From 61baa5987ecacbfa1f9adb626e87702be14447be Mon Sep 17 00:00:00 2001 From: Claude Date: Thu, 20 Aug 2026 21:29:04 +0000 Subject: [PATCH 1/3] Milestone 1: port the DuckDB PEG parser engine to Go Scaffold the module (go.mod, MIT LICENSE + LICENSE.DUCKDB, CI, CLAUDE.md) and implement the engine layer described in PLAN.md: - internal/grammar: vendor the .gram/.list files verbatim from DuckDB commit 044a04a7cd39e6e8235f756597ae42dde084e5e5 (provenance + SHA-256 in internal/grammar/README.md) and port the grammar loader (peg_parser.cpp/parsed_grammar.cpp) plus the assembly step from inline_grammar.py (keyword lists become ordered-choice rules). - token: token kinds, Token{Kind, Text, Span}, and DuckDB's keyword categories. The vendored lists overlap outside reserved/unreserved (32 keywords sit in two lists at this pin), so category membership is a bitmask, matching the pinned build's effective behavior rather than the exactly-one-list claim in upstream docs. - lexer: port of base_tokenizer.cpp + parser_tokenizer.cpp, including dollar-quoted strings with the $[0-9] parameter disambiguation and quote-rewrite, E'' escape strings, nested block comments, the PostgreSQL operator '+' trimming rule, and the parser behavior's tokenize errors. - internal/matcher: matcher tree compiled from the grammar (matcher_factory.cpp), packrat memoization over upstream's designated rule list (parser_packrat.cpp), the transcribed rule-override table (identifier variants, literals, EndOfInput), ParseResult tree with upstream-style dumping, and furthest-failure syntax errors. Upstream quirks are ported and pinned by tests: negative lookahead drops only the '!' operator (its operand still consumes), and '/' binds only the immediately preceding element. - cmd/debug-parse: dump tokens or the raw ParseResult tree, peeling one TopLevelStatement at a time like upstream's parse loop. The 19-unmatched-parens pathological case from upstream's blog post runs in ~1ms as a benchmark; go test -race is clean. Co-Authored-By: Claude Claude-Session: https://claude.ai/code/session_01CTQBC9AzfdFPFsZtwn1mHY --- .github/workflows/ci.yml | 22 + CLAUDE.md | 49 ++ LICENSE | 21 + LICENSE.DUCKDB | 27 + README.md | 46 +- cmd/debug-parse/main.go | 78 +++ go.mod | 3 + internal/grammar/README.md | 62 ++ .../duckdb/keywords/column_name_keyword.list | 55 ++ .../duckdb/keywords/func_name_keyword.list | 30 + .../duckdb/keywords/reserved_keyword.list | 75 +++ .../duckdb/keywords/type_name_keyword.list | 32 + .../duckdb/keywords/unreserved_keyword.list | 339 ++++++++++ internal/grammar/duckdb/statements/alter.gram | 52 ++ .../grammar/duckdb/statements/analyze.gram | 3 + .../grammar/duckdb/statements/attach.gram | 6 + internal/grammar/duckdb/statements/call.gram | 1 + .../grammar/duckdb/statements/checkpoint.gram | 2 + .../grammar/duckdb/statements/comment.gram | 19 + .../grammar/duckdb/statements/common.gram | 195 ++++++ .../grammar/duckdb/statements/connect.gram | 6 + internal/grammar/duckdb/statements/copy.gram | 65 ++ .../duckdb/statements/create_index.gram | 21 + .../duckdb/statements/create_macro.gram | 15 + .../duckdb/statements/create_schema.gram | 1 + .../duckdb/statements/create_secret.gram | 4 + .../duckdb/statements/create_sequence.gram | 22 + .../duckdb/statements/create_table.gram | 97 +++ .../duckdb/statements/create_trigger.gram | 26 + .../duckdb/statements/create_type.gram | 5 + .../duckdb/statements/create_view.gram | 3 + .../grammar/duckdb/statements/deallocate.gram | 2 + .../grammar/duckdb/statements/delete.gram | 4 + .../grammar/duckdb/statements/describe.gram | 39 ++ .../grammar/duckdb/statements/detach.gram | 1 + internal/grammar/duckdb/statements/drop.gram | 43 ++ .../grammar/duckdb/statements/execute.gram | 1 + .../grammar/duckdb/statements/explain.gram | 29 + .../grammar/duckdb/statements/export.gram | 3 + .../grammar/duckdb/statements/expression.gram | 339 ++++++++++ .../duckdb/statements/external_resource.gram | 11 + .../grammar/duckdb/statements/insert.gram | 34 + internal/grammar/duckdb/statements/load.gram | 8 + .../grammar/duckdb/statements/merge_into.gram | 27 + internal/grammar/duckdb/statements/pivot.gram | 24 + .../grammar/duckdb/statements/pragma.gram | 6 + .../grammar/duckdb/statements/prepare.gram | 3 + .../grammar/duckdb/statements/select.gram | 215 +++++++ internal/grammar/duckdb/statements/set.gram | 30 + .../duckdb/statements/transaction.gram | 14 + .../grammar/duckdb/statements/update.gram | 11 + internal/grammar/duckdb/statements/use.gram | 7 + .../grammar/duckdb/statements/vacuum.gram | 13 + internal/grammar/embed.go | 152 +++++ internal/grammar/grammar_test.go | 219 +++++++ internal/grammar/parser.go | 300 +++++++++ internal/matcher/engine.go | 152 +++++ internal/matcher/factory.go | 386 ++++++++++++ internal/matcher/matcher.go | 295 +++++++++ internal/matcher/matcher_test.go | 517 +++++++++++++++ internal/matcher/packrat.go | 52 ++ internal/matcher/result.go | 377 +++++++++++ internal/matcher/special.go | 329 ++++++++++ lexer/lexer.go | 586 ++++++++++++++++++ lexer/lexer_test.go | 320 ++++++++++ token/keywords.go | 143 +++++ token/keywords_test.go | 119 ++++ token/token.go | 85 +++ 68 files changed, 6277 insertions(+), 1 deletion(-) create mode 100644 .github/workflows/ci.yml create mode 100644 CLAUDE.md create mode 100644 LICENSE create mode 100644 LICENSE.DUCKDB create mode 100644 cmd/debug-parse/main.go create mode 100644 go.mod create mode 100644 internal/grammar/README.md create mode 100644 internal/grammar/duckdb/keywords/column_name_keyword.list create mode 100644 internal/grammar/duckdb/keywords/func_name_keyword.list create mode 100644 internal/grammar/duckdb/keywords/reserved_keyword.list create mode 100644 internal/grammar/duckdb/keywords/type_name_keyword.list create mode 100644 internal/grammar/duckdb/keywords/unreserved_keyword.list create mode 100644 internal/grammar/duckdb/statements/alter.gram create mode 100644 internal/grammar/duckdb/statements/analyze.gram create mode 100644 internal/grammar/duckdb/statements/attach.gram create mode 100644 internal/grammar/duckdb/statements/call.gram create mode 100644 internal/grammar/duckdb/statements/checkpoint.gram create mode 100644 internal/grammar/duckdb/statements/comment.gram create mode 100644 internal/grammar/duckdb/statements/common.gram create mode 100644 internal/grammar/duckdb/statements/connect.gram create mode 100644 internal/grammar/duckdb/statements/copy.gram create mode 100644 internal/grammar/duckdb/statements/create_index.gram create mode 100644 internal/grammar/duckdb/statements/create_macro.gram create mode 100644 internal/grammar/duckdb/statements/create_schema.gram create mode 100644 internal/grammar/duckdb/statements/create_secret.gram create mode 100644 internal/grammar/duckdb/statements/create_sequence.gram create mode 100644 internal/grammar/duckdb/statements/create_table.gram create mode 100644 internal/grammar/duckdb/statements/create_trigger.gram create mode 100644 internal/grammar/duckdb/statements/create_type.gram create mode 100644 internal/grammar/duckdb/statements/create_view.gram create mode 100644 internal/grammar/duckdb/statements/deallocate.gram create mode 100644 internal/grammar/duckdb/statements/delete.gram create mode 100644 internal/grammar/duckdb/statements/describe.gram create mode 100644 internal/grammar/duckdb/statements/detach.gram create mode 100644 internal/grammar/duckdb/statements/drop.gram create mode 100644 internal/grammar/duckdb/statements/execute.gram create mode 100644 internal/grammar/duckdb/statements/explain.gram create mode 100644 internal/grammar/duckdb/statements/export.gram create mode 100644 internal/grammar/duckdb/statements/expression.gram create mode 100644 internal/grammar/duckdb/statements/external_resource.gram create mode 100644 internal/grammar/duckdb/statements/insert.gram create mode 100644 internal/grammar/duckdb/statements/load.gram create mode 100644 internal/grammar/duckdb/statements/merge_into.gram create mode 100644 internal/grammar/duckdb/statements/pivot.gram create mode 100644 internal/grammar/duckdb/statements/pragma.gram create mode 100644 internal/grammar/duckdb/statements/prepare.gram create mode 100644 internal/grammar/duckdb/statements/select.gram create mode 100644 internal/grammar/duckdb/statements/set.gram create mode 100644 internal/grammar/duckdb/statements/transaction.gram create mode 100644 internal/grammar/duckdb/statements/update.gram create mode 100644 internal/grammar/duckdb/statements/use.gram create mode 100644 internal/grammar/duckdb/statements/vacuum.gram create mode 100644 internal/grammar/embed.go create mode 100644 internal/grammar/grammar_test.go create mode 100644 internal/grammar/parser.go create mode 100644 internal/matcher/engine.go create mode 100644 internal/matcher/factory.go create mode 100644 internal/matcher/matcher.go create mode 100644 internal/matcher/matcher_test.go create mode 100644 internal/matcher/packrat.go create mode 100644 internal/matcher/result.go create mode 100644 internal/matcher/special.go create mode 100644 lexer/lexer.go create mode 100644 lexer/lexer_test.go create mode 100644 token/keywords.go create mode 100644 token/keywords_test.go create mode 100644 token/token.go diff --git a/.github/workflows/ci.yml b/.github/workflows/ci.yml new file mode 100644 index 0000000..70e6014 --- /dev/null +++ b/.github/workflows/ci.yml @@ -0,0 +1,22 @@ +name: ci + +on: + push: + branches: [main] + pull_request: + +permissions: + contents: read + +jobs: + test: + runs-on: ubuntu-latest + steps: + - uses: actions/checkout@v4 + - uses: actions/setup-go@v5 + with: + go-version-file: go.mod + - run: go build ./... + - run: go vet ./... + - run: gofmt -l . && test -z "$(gofmt -l .)" + - run: go test -race ./... diff --git a/CLAUDE.md b/CLAUDE.md new file mode 100644 index 0000000..16165d8 --- /dev/null +++ b/CLAUDE.md @@ -0,0 +1,49 @@ +# darkwing development guide + +darkwing is a pure Go port of DuckDB v2.0's PEG parser. Read `PLAN.md` first — +it is the authoritative design document. The engine is a faithful port of the +C++ under `src/parser/peg/` in the DuckDB repo, pinned at the commit recorded +in `internal/grammar/README.md`. + +## Layout + +- `token/` — token kinds, `Token{Kind, Text, Span}`, the five keyword + categories (built from the vendored `.list` files). +- `lexer/` — port of `base_tokenizer.cpp` + `parser_tokenizer.cpp`. +- `internal/grammar/` — vendored `.gram`/`.list` files (never edit them by + hand; they are re-vendored by the regeneration workflow) and the grammar + loader, a port of `peg_parser.cpp`/`parsed_grammar.cpp`. +- `internal/matcher/` — matcher tree, packrat memoization, rule overrides and + `ParseResult`, a port of `matcher_factory.cpp`/`matcher.cpp`/ + `parser_packrat.cpp` and `matcher/*.hpp`. +- `cmd/debug-parse/` — dump tokens or the raw `ParseResult` tree for SQL + passed on the command line. + +## Rules of the port + +- **Effective behavior over textbook behavior.** darkwing replicates what the + pinned DuckDB build actually does, including acknowledged quirks: negative + lookahead (`!`) is parsed but ignored by the matcher; `/` binds only the + immediately preceding element (upstream grammars parenthesize sequences in + alternatives); `*`/`+`/`?` wrap only the last element of the current list. + Do not "fix" these — they are pinned by tests. +- **Vendored files are verbatim.** `internal/grammar/duckdb/**` is copied + unmodified from upstream. Changing grammar behavior means advancing the pin, + never editing the files. +- **Zero dependencies.** `go.mod` stays module line + Go version only. + +## Dev loop + +``` +go build ./... && go vet ./... && gofmt -l . && go test -race ./... +``` + +Debugging a parse: + +``` +go run ./cmd/debug-parse 'SELECT 1' # ParseResult tree +go run ./cmd/debug-parse -tokens 'SELECT 1' # token dump +``` + +Corpus tooling (`cmd/next-test`, `cmd/regenerate`, `-check-parse`) arrives in +milestone 2; until then upstream-transcribed unit tests are the safety net. diff --git a/LICENSE b/LICENSE new file mode 100644 index 0000000..7dadf56 --- /dev/null +++ b/LICENSE @@ -0,0 +1,21 @@ +MIT License + +Copyright (c) 2026 The sqlc Authors + +Permission is hereby granted, free of charge, to any person obtaining a copy +of this software and associated documentation files (the "Software"), to deal +in the Software without restriction, including without limitation the rights +to use, copy, modify, merge, publish, distribute, sublicense, and/or sell +copies of the Software, and to permit persons to whom the Software is +furnished to do so, subject to the following conditions: + +The above copyright notice and this permission notice shall be included in all +copies or substantial portions of the Software. + +THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE +AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER +LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, +OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE +SOFTWARE. diff --git a/LICENSE.DUCKDB b/LICENSE.DUCKDB new file mode 100644 index 0000000..9185d5d --- /dev/null +++ b/LICENSE.DUCKDB @@ -0,0 +1,27 @@ +darkwing vendors grammar and keyword files from DuckDB and ports portions of +DuckDB's PEG parser (tokenizer, grammar loader, and matcher) to Go. DuckDB is +distributed under the MIT license, reproduced below. + +Source: https://github.com/duckdb/duckdb + +--- + +Copyright 2018-2026 Stichting DuckDB Foundation + +Permission is hereby granted, free of charge, to any person obtaining a copy +of this software and associated documentation files (the "Software"), to deal +in the Software without restriction, including without limitation the rights +to use, copy, modify, merge, publish, distribute, sublicense, and/or sell +copies of the Software, and to permit persons to whom the Software is +furnished to do so, subject to the following conditions: + +The above copyright notice and this permission notice shall be included in +all copies or substantial portions of the Software. + +THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE +AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER +LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, +OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE +SOFTWARE. diff --git a/README.md b/README.md index 487c664..30c7a3b 100644 --- a/README.md +++ b/README.md @@ -1 +1,45 @@ -# darkwing \ No newline at end of file +# darkwing + +*The terror that flaps in the night, for DuckDB.* + +darkwing is a hand-written, zero-dependency Go port of DuckDB v2.0's +PEG-based SQL parser, built to power a first-class DuckDB engine in +[sqlc](https://github.com/sqlc-dev/sqlc). See [PLAN.md](PLAN.md) for the full +design. + +Unlike its siblings ([oliphant](https://github.com/sqlc-dev/oliphant), +[marino](https://github.com/sqlc-dev/marino), +[meyer](https://github.com/sqlc-dev/meyer), +[teesql](https://github.com/sqlc-dev/teesql), +[zetajones](https://github.com/sqlc-dev/zetajones), +[doubleclick](https://github.com/sqlc-dev/doubleclick)), darkwing does not +re-express the grammar as recursive descent: DuckDB's own production parser +is an interpreter over machine-readable grammar text, so darkwing vendors the +`.gram`/`.list` files verbatim and ports the engine — tokenizer, grammar +loader, and matcher (with packrat memoization) — to Go. + +## Status + +Milestone 1 (engine) is complete: + +- `token/` — token kinds and DuckDB's keyword categories +- `lexer/` — port of the parsing tokenizer +- `internal/grammar/` — vendored grammar (pinned upstream commit recorded in + `internal/grammar/README.md`) and the grammar loader +- `internal/matcher/` — matcher tree, packrat memoization, rule overrides, + furthest-failure error reporting +- `cmd/debug-parse` — dump tokens or the raw parse tree for SQL on the + command line + +Next: corpus extraction and the accept/reject conformance gate against a +pinned DuckDB binary (milestone 2), then the AST and transformers. + +``` +$ go run ./cmd/debug-parse 'SELECT 1' +$ go run ./cmd/debug-parse -tokens 'SELECT * FROM t' +``` + +## License + +MIT (see `LICENSE`). Vendored DuckDB grammar files and the ported engine +derive from MIT-licensed DuckDB source; see `LICENSE.DUCKDB`. diff --git a/cmd/debug-parse/main.go b/cmd/debug-parse/main.go new file mode 100644 index 0000000..a4fa4ec --- /dev/null +++ b/cmd/debug-parse/main.go @@ -0,0 +1,78 @@ +// Command debug-parse tokenizes and matches SQL from the command line, +// dumping either the token stream or the raw ParseResult tree — the +// milestone-1 window into the engine, before transformers and a public +// Parse API exist. +// +// Usage: +// +// debug-parse [-tokens] 'SELECT 1' +package main + +import ( + "flag" + "fmt" + "os" + "strings" + + "github.com/sqlc-dev/darkwing/internal/matcher" + "github.com/sqlc-dev/darkwing/lexer" +) + +func main() { + tokensOnly := flag.Bool("tokens", false, "dump the token stream instead of the parse tree") + flag.Parse() + if flag.NArg() == 0 { + fmt.Fprintln(os.Stderr, "usage: debug-parse [-tokens] ") + os.Exit(2) + } + sql := strings.Join(flag.Args(), " ") + if err := run(sql, *tokensOnly); err != nil { + fmt.Fprintf(os.Stderr, "error: %v\n", err) + os.Exit(1) + } +} + +func run(sql string, tokensOnly bool) error { + tokens, err := lexer.Tokenize(sql) + if err != nil { + return err + } + if tokensOnly { + for _, t := range tokens { + fmt.Printf("%-16s %4d..%-4d %q\n", t.Kind, t.Span.Start, t.Span.End, t.Text) + } + return nil + } + engine, err := matcher.Default() + if err != nil { + return err + } + // peel one TopLevelStatement at a time, exactly like upstream's + // Parser::ParseQuery loop + pos := 0 + statement := 0 + for pos < len(tokens) { + result, newPos, err := engine.MatchTopLevel(tokens, pos) + if err != nil { + return err + } + if newPos == pos { + // no progress; should be unreachable with a well-formed + // TopLevelStatement rule + return fmt.Errorf("matcher made no progress at token %d", pos) + } + pos = newPos + // TopLevelStatement <- Statement? (';'+ / EndOfInput): a + // separator-only match yields no statement, as upstream's + // TransformTopLevelStatement returns nullptr for it + if lr, ok := result.(*matcher.ListResult); ok && len(lr.Children) > 0 { + if opt, ok := lr.Children[0].(*matcher.OptionalResult); ok && !opt.HasResult() { + continue + } + } + statement++ + fmt.Printf("-- statement %d\n", statement) + fmt.Print(matcher.Dump(result)) + } + return nil +} diff --git a/go.mod b/go.mod new file mode 100644 index 0000000..ed9f51c --- /dev/null +++ b/go.mod @@ -0,0 +1,3 @@ +module github.com/sqlc-dev/darkwing + +go 1.24 diff --git a/internal/grammar/README.md b/internal/grammar/README.md new file mode 100644 index 0000000..5709875 --- /dev/null +++ b/internal/grammar/README.md @@ -0,0 +1,62 @@ +# Vendored DuckDB grammar + +The files under `duckdb/` are copied **verbatim** from the DuckDB repository +and are load-bearing: the matcher engine interprets them at runtime. Never +edit them by hand — changes happen only by advancing the pin (see PLAN.md, +§ Regeneration workflow). + +- Upstream: https://github.com/duckdb/duckdb +- Source tree: `src/parser/peg/grammar/` +- Pinned commit: `044a04a7cd39e6e8235f756597ae42dde084e5e5` (main, 2026-08-20) + +DuckDB is MIT-licensed; see `LICENSE.DUCKDB` at the repository root. + +## File checksums (SHA-256) + +``` +a4a70d6558ff8684ab5adaed67a53328135ba163faa553a5eec544a10768cf8b statements/alter.gram +4bd5c409bb84e7b0fa189de1cf73c145ace1498138d2bc0d7c5fdea470815fd0 statements/analyze.gram +fb98930e1a251fec3a44a5443ab98ea02d9426fc96477aeb356654f2c55075fa statements/attach.gram +cf752ee0bae6b4f2940d63d701b18a533549a6a5f623f3f68f9d3c2e08637e33 statements/call.gram +0758036168b998cd2020a3fa2b358a978cc40de4d6706e84c04793dbca0e78e2 statements/checkpoint.gram +bf7567659ec5cfb157acfe174ecad6e5fa6d8e13b8792cf41c4e0217c52193e4 statements/comment.gram +411b742320a6b8c956f2505d89a2f1468c6917dd0b6b9e5371a940776aa9be7a statements/common.gram +19b1c24e05dd0fd5795e2ae5c5495583a10f0f6c1f4afcbfe5e4abfb360c7aba statements/connect.gram +f70d1566ee95ea32152761ae708e89c6ce16364758ec0fb4a9fd635ad9a2b6a3 statements/copy.gram +2f77a721a498ccae914ed4426884ac704931a7a4dd724eb325940de909ea1e62 statements/create_index.gram +831dbbe5fd612ddbd4aa448560acc290015080887917d8b2d2c1a38c9dffb3d7 statements/create_macro.gram +fbcec6a4c54ccafccf1f902e27b2417edf3450a0a04226beab1e4c6f6c742eb2 statements/create_schema.gram +d145c7659cbda441cd380b7cbdda88adf84307c18148aeed46dbefbc41c72ec5 statements/create_secret.gram +9dfdc09fb59bdd891fe71f51ccfc48f7acaa39c49250be18e10ee77dccf36bac statements/create_sequence.gram +2b68d04246879ca3b8162d942484e59731d367882ee18d3461dcea918589e3ad statements/create_table.gram +15ec6922853cdae4e1d51e7c10c1a25da70f5f2969b8b2993185c37fd81c6fe7 statements/create_trigger.gram +0da80da21a0660a2c59b4a1312a70bb3fdf51cbfb3211925fee894db89233f21 statements/create_type.gram +9ede97c886fa89f1c617914f88e3657192d34ae72bcf4803dee01e57cc2300c4 statements/create_view.gram +d62c7218252ad6f762cc05125dc6cfe02c3c5f906df1e3a599a958296f78ff69 statements/deallocate.gram +f9ded93197d1133107d3ec6d48210c1c5ccdb588cc61d03d164cadebfb06881d statements/delete.gram +c1242ea8a05cf628e152e189df9c94d866494e1b092553fcbb45142d0b3b92e7 statements/describe.gram +ec5f4bd0ba34ecfefbf09f2d637bfaec2f7b84311a639aeee589b997d72abba9 statements/detach.gram +ca141624e02e3f1542e4b1251359b8938cd4d02c563f32bbbc5fff1fbc178643 statements/drop.gram +9f2ad89280ac00af9f6ab462a693f21a54383738ddcbb8d144409481ef85923b statements/execute.gram +306c0603ae5e1a72975f3739a238570038b8d5487a89997afde7101eafccc8e7 statements/explain.gram +507cca9d8af7c3a061e04a654ccda1671784c81a115418b3aff57f9157382b53 statements/export.gram +79dfa73c85d18e4674009a7f210ce771f4df8957d05ffad6b58e3781b7365f00 statements/expression.gram +f150e2176c4a7398f8380c5ca8be43ec1d9ad63018f1e974ebf3b6e525529ae4 statements/external_resource.gram +000cdce02e55003cb38ca8d1c1f8304cc1e0b5513e92494d2de9aae2d467556d statements/insert.gram +3763ae5ea68638fe6d1b484ac147aa89c626d15f72d874cffd513c883bb1f340 statements/load.gram +2b98ac7310bcf1726fe4b2288e0fa02a09e6cb68cb2c0b8168e4bd770f73fb1f statements/merge_into.gram +f01099ef498cd6dd3e32f008e8600fc2e3da9715d1f8b84d0b46d559ee7f72da statements/pivot.gram +68ba82f61baed8fd57bb29043d025b2aaff86da0bfde49bee711f67e1f0ff8c3 statements/pragma.gram +a8ce0da5078fa6d07c3376ff0f3b9db21a214f53cba43f7f39c0112f9dee228c statements/prepare.gram +27f075e3a594815f016e851f04922d5b65ba59d818663307e147779b262fd6e5 statements/select.gram +1d500aeb6bdd88fc8e434bb116dde8192c13c9e7354017e596dc2ef46424288a statements/set.gram +2de0cc72aeb00b6b6247348bd06db8e9a088cecb2c20516e678fe4261c909877 statements/transaction.gram +d13cc52137a903fa42b4e476341b2f08cbe24ed4ad31b41df76001151f1b58d7 statements/update.gram +27b36ea5fdfc5b1c38fa3976276dc857629764bfa57171b8d1db1f2ff74b6787 statements/use.gram +6888deac794935a90e191f389f24f7786bc2b23a69a6374d5214dad50f095c4b statements/vacuum.gram +39ad28d2ef56a744fc354ee6f37a79434f490401d7810250d3899ffbc19891c7 keywords/column_name_keyword.list +6e0d26e4f6a6b47b4392542ed4c4a3f68db3792781d349874bd0cce537dfe877 keywords/func_name_keyword.list +0e66c73b69c650f44d542840de6936fd6adc72bd6d8f80703209bc93aa7f4c41 keywords/reserved_keyword.list +f999e346c982a548c8ede53d8a9022e4c366a1c54fb6380b7d97afedcf5ccad3 keywords/type_name_keyword.list +d95aa28d78cbe3cd9dd2e0b9c77a0f32988d78e29cd8b4feedfe4044b451b609 keywords/unreserved_keyword.list +``` diff --git a/internal/grammar/duckdb/keywords/column_name_keyword.list b/internal/grammar/duckdb/keywords/column_name_keyword.list new file mode 100644 index 0000000..ace24fe --- /dev/null +++ b/internal/grammar/duckdb/keywords/column_name_keyword.list @@ -0,0 +1,55 @@ +BETWEEN +BIGINT +BIT +BOOLEAN +CHAR +CHARACTER +COALESCE +COLUMNS +DEC +DECIMAL +EXISTS +EXTRACT +FLOAT +GENERATED +GROUPING +GROUPING_ID +INOUT +INT +INTEGER +INTERVAL +MAP +NATIONAL +NCHAR +NONE +NULLIF +NUMERIC +OUT +OVERLAY +POSITION +PRECISION +REAL +ROW +SETOF +SMALLINT +SUBSTRING +STRUCT +TIME +TIMESTAMP +TREAT +TRIM +TRY_CAST +TUPLE +VALUES +VARCHAR +XMLATTRIBUTES +XMLCONCAT +XMLELEMENT +XMLEXISTS +XMLFOREST +XMLNAMESPACES +XMLPARSE +XMLPI +XMLROOT +XMLSERIALIZE +XMLTABLE \ No newline at end of file diff --git a/internal/grammar/duckdb/keywords/func_name_keyword.list b/internal/grammar/duckdb/keywords/func_name_keyword.list new file mode 100644 index 0000000..123b579 --- /dev/null +++ b/internal/grammar/duckdb/keywords/func_name_keyword.list @@ -0,0 +1,30 @@ +ASOF +AT +AUTHORIZATION +BINARY +COLLATION +CONCURRENTLY +CROSS +FREEZE +FULL +GENERATED +GLOB +ILIKE +INNER +IS +ISNULL +JOIN +LEFT +LIKE +MAP +NATURAL +NOTNULL +OUTER +OVERLAPS +POSITIONAL +RIGHT +SIMILAR +STRUCT +TABLESAMPLE +TUPLE +VERBOSE \ No newline at end of file diff --git a/internal/grammar/duckdb/keywords/reserved_keyword.list b/internal/grammar/duckdb/keywords/reserved_keyword.list new file mode 100644 index 0000000..72a0116 --- /dev/null +++ b/internal/grammar/duckdb/keywords/reserved_keyword.list @@ -0,0 +1,75 @@ +ALL +ANALYSE +ANALYZE +AND +ANY +ARRAY +AS +ASC +ASYMMETRIC +BOTH +CASE +CAST +CHECK +COLLATE +COLUMN +CONSTRAINT +CREATE +DEFAULT +DEFERRABLE +DESC +DESCRIBE +DISTINCT +DO +ELSE +END +EXCEPT +FALSE +FETCH +FOR +FOREIGN +FROM +GROUP +HAVING +QUALIFY +IN +INITIALLY +INTERSECT +INTO +LAMBDA +LATERAL +LEADING +LIMIT +NOT +NULL +OFFSET +ON +ONLY +OR +ORDER +PIVOT +PIVOT_WIDER +PIVOT_LONGER +PLACING +PRIMARY +REFERENCES +RETURNING +SELECT +SHOW +SOME +SUMMARIZE +SYMMETRIC +TABLE +THEN +TO +TRAILING +TRUE +UNION +UNIQUE +UNPIVOT +USING +VARIADIC +WHEN +WHERE +WINDOW +WITH diff --git a/internal/grammar/duckdb/keywords/type_name_keyword.list b/internal/grammar/duckdb/keywords/type_name_keyword.list new file mode 100644 index 0000000..0fe9682 --- /dev/null +++ b/internal/grammar/duckdb/keywords/type_name_keyword.list @@ -0,0 +1,32 @@ +ASOF +AT +AUTHORIZATION +BINARY +BY +COLLATION +COLUMNS +CONCURRENTLY +CROSS +FREEZE +FULL +GLOB +ILIKE +INNER +IS +ISNULL +JOIN +LEFT +LIKE +NATURAL +NOTNULL +OUTER +OVERLAPS +POSITIONAL +RIGHT +UNPACK +SIMILAR +TABLESAMPLE +TRY_CAST +VERBOSE +SEMI +ANTI \ No newline at end of file diff --git a/internal/grammar/duckdb/keywords/unreserved_keyword.list b/internal/grammar/duckdb/keywords/unreserved_keyword.list new file mode 100644 index 0000000..5ac11f9 --- /dev/null +++ b/internal/grammar/duckdb/keywords/unreserved_keyword.list @@ -0,0 +1,339 @@ +ABORT +ABSOLUTE +ACCESS +ACTION +ADD +ADMIN +AFTER +AGGREGATE +ALSO +ALTER +ALWAYS +APPROX +ASSERTION +ASSIGNMENT +ATTACH +ATTRIBUTE +BACKWARD +BEFORE +BEGIN +CACHE +CALL +CALLED +CASCADE +CASCADED +CATALOG +CENTURY +CENTURIES +CHAIN +CHARACTERISTICS +CHECKPOINT +CLASS +CLOSE +CLUSTER +COMMENT +COMMENTS +COMMIT +COMMITTED +COMPRESSION +CONFIGURATION +CONFLICT +CONNECT +CONNECTION +CONSTRAINTS +CONTENT +CONTINUE +CONVERSION +COPY +COST +CSV +CUBE +CURRENT +CURSOR +CYCLE +DATA +DATABASE +DAY +DAYS +DEALLOCATE +DECADE +DECADES +DECLARE +DEFAULTS +DEFERRED +DEFINER +DELETE +DELIMITER +DELIMITERS +DEPENDS +DETACH +DICTIONARY +DISABLE +DISCARD +DISCONNECT +DISTANCE +DOCUMENT +DOMAIN +DOUBLE +DROP +EACH +ENABLE +ENCODING +ENCRYPTED +ENUM +ERROR +ESCAPE +EVENT +EXACT +EXCLUDE +EXCLUDING +EXCLUSIVE +EXECUTE +EXPLAIN +EXPORT +EXPORT_STATE +EXTENSION +EXTENSIONS +EXTERNAL +FAMILY +FILTER +FIRST +FOLLOWING +FORCE +FORWARD +FUNCTION +FUNCTIONS +GLOBAL +GRANT +GRANTED +GROUPS +HANDLER +HEADER +HOLD +HOUR +HOURS +IDENTITY +IF +IGNORE +IMMEDIATE +IMMUTABLE +IMPLICIT +IMPORT +INCLUDE +INCLUDING +INCREMENT +INDEX +INDEXES +INHERIT +INHERITS +INLINE +INPUT +INSENSITIVE +INSERT +INSTALL +INSTEAD +INVOKER +JSON +ISOLATION +KEY +LABEL +LANGUAGE +LARGE +LAST +LEAKPROOF +LEVEL +LISTEN +LOAD +LOCAL +LOCATION +LOCK +LOCKED +LOGGED +MACRO +MAPPING +MATCH +MATCHED +MATERIALIZED +MAXVALUE +MERGE +METHOD +MICROSECOND +MICROSECONDS +MILLENNIUM +MILLENNIA +MILLISECOND +MILLISECONDS +MINUTE +MINUTES +MINVALUE +MODE +MONTH +MONTHS +MOVE +NAME +NAMES +NEAREST +NEW +NEXT +NO +NOTHING +NOTIFY +NOWAIT +NULLS +OBJECT +OF +OFF +OIDS +OLD +OPERATOR +OPTION +OPTIONS +ORDINALITY +OTHERS +OVER +OVERRIDING +OWNED +OWNER +PARALLEL +PARSER +PARTIAL +PARTITION +PARTITIONED +PASSING +PASSWORD +PERCENT +PERSISTENT +PLANS +POLICY +PRAGMA +PRECEDING +PREPARE +PREPARED +PRESERVE +PRIOR +PRIVILEGES +PROCEDURAL +PROCEDURE +PROGRAM +PUBLICATION +QUARTER +QUARTERS +QUOTE +RANGE +READ +REASSIGN +RECHECK +RECURSIVE +REF +REFERENCING +REFRESH +REINDEX +RELATIVE +RELEASE +RENAME +REPEATABLE +REPLACE +REPLICA +RESET +RESOURCE +RESPECT +RESTART +RESTRICT +RETURNS +REVOKE +ROLE +ROLLBACK +ROLLUP +ROWS +RULE +SAMPLE +SAVEPOINT +SCHEMA +SCHEMAS +SCOPE +SCROLL +SEARCH +SECRET +SECOND +SECONDS +SECURE +SECURITY +SEQUENCE +SEQUENCES +SERIALIZABLE +SERVER +SESSION +SET +SETS +SHARE +SIMILARITY +SIMPLE +SKIP +SNAPSHOT +SORTED +SOURCE +SQL +STABLE +STANDALONE +START +STATEMENT +STATISTICS +STDIN +STDOUT +STORAGE +STORED +STRICT +STRIP +SUBSCRIPTION +SYSID +SYSTEM +TABLES +TABLESPACE +TARGET +TEMP +TEMPLATE +TEMPORARY +TEXT +TIES +TRANSACTION +TRANSFORM +TRIGGER +TRUNCATE +TRUSTED +TYPE +TYPES +UNBOUNDED +UNCOMMITTED +UNENCRYPTED +UNKNOWN +UNLISTEN +UNLOGGED +UNTIL +UPDATE +USE +USER +VACUUM +VALID +VALIDATE +VALIDATOR +VALUE +VARIABLE +VARYING +VERSION +VIEW +VIEWS +VIRTUAL +VOLATILE +WEEK +WEEKS +WHITESPACE +WITHIN +WITHOUT +WORK +WRAPPER +WRITE +XML +YEAR +YEARS +YES +ZONE diff --git a/internal/grammar/duckdb/statements/alter.gram b/internal/grammar/duckdb/statements/alter.gram new file mode 100644 index 0000000..6066fa1 --- /dev/null +++ b/internal/grammar/duckdb/statements/alter.gram @@ -0,0 +1,52 @@ +AlterStatement <- 'ALTER' AlterOptions + +AlterOptions <- AlterTableStmt / AlterViewStmt / AlterSequenceStmt / AlterDatabaseStmt / AlterSchemaStmt + +AlterTableStmt <- 'TABLE' IfExists? BaseTableName List(AlterTableOptions) +AlterSchemaStmt <- 'SCHEMA' IfExists? QualifiedName RenameAlter + +AlterTableOptions <- AddColumn / DropColumn / AlterColumn / AddConstraint / ChangeNullability / + RenameColumn / RenameAlter / SetPartitionedBy / ResetPartitionedBy / SetSortedBy / ResetSortedBy / SetOptions / ResetOptions + +AddConstraint <- 'ADD' TopLevelConstraint +AddColumn <- 'ADD' 'COLUMN'? IfNotExists? AddColumnEntry +AddColumnEntry <- DottedIdentifier Type? GeneratedColumn? ColumnConstraint* +DropColumn <- 'DROP' 'COLUMN'? IfExists? NestedColumnName DropBehavior? +AlterColumn <- 'ALTER' 'COLUMN'? NestedColumnName AlterColumnEntry +RenameColumn <- 'RENAME' 'COLUMN'? NestedColumnName 'TO' Identifier +NestedColumnName <- IdentifierDot* ColumnName +IdentifierDot <- Identifier '.' +RenameAlter <- 'RENAME' 'TO' Identifier +SetPartitionedBy <- 'SET' 'PARTITIONED' 'BY' Parens(List(Expression)) +ResetPartitionedBy <- 'RESET' 'PARTITIONED' 'BY' +SetSortedBy <- 'SET' 'SORTED' 'BY' Parens(OrderByExpressions) +ResetSortedBy <- 'RESET' 'SORTED' 'BY' +SetOptions <- 'SET' RelOptionList +ResetOptions <- 'RESET' RelOptionList + +AlterColumnEntry <- AddOrDropDefault / ChangeNullability / AlterType + +AddOrDropDefault <- AddDefault / DropDefault +AddDefault <- 'SET' 'DEFAULT' Expression +DropDefault <- 'DROP' 'DEFAULT' + +ChangeNullability <- DropOrSet 'NOT' 'NULL' +DropOrSet <- DropNullability / SetNullability +DropNullability <- 'DROP' +SetNullability <- 'SET' + +AlterType <- SetData? 'TYPE' Type? UsingExpression? +SetData <- 'SET' 'DATA'? +UsingExpression <- 'USING' Expression + +AlterViewStmt <- 'VIEW' IfExists? BaseTableName RenameAlter + +AlterSequenceStmt <- 'SEQUENCE' IfExists? QualifiedSequenceName AlterSequenceOptions + +QualifiedSequenceName <- CatalogQualification? SchemaQualification? SequenceName + +AlterSequenceOptions <- RenameAlterSequenceOptions / SetSequenceOption +RenameAlterSequenceOptions <- RenameAlter +SetSequenceOption <- SequenceOption+ + +AlterDatabaseStmt <- 'DATABASE' IfExists? Identifier 'SET' 'ALIAS' 'TO' Identifier diff --git a/internal/grammar/duckdb/statements/analyze.gram b/internal/grammar/duckdb/statements/analyze.gram new file mode 100644 index 0000000..9de3632 --- /dev/null +++ b/internal/grammar/duckdb/statements/analyze.gram @@ -0,0 +1,3 @@ +AnalyzeStatement <- AnalyzeKeyword AnalyzeVerbose? AnalyzeTarget? +AnalyzeTarget <- BaseTableName NameList? +AnalyzeVerbose <- 'VERBOSE' diff --git a/internal/grammar/duckdb/statements/attach.gram b/internal/grammar/duckdb/statements/attach.gram new file mode 100644 index 0000000..213f8a5 --- /dev/null +++ b/internal/grammar/duckdb/statements/attach.gram @@ -0,0 +1,6 @@ +AttachStatement <- 'ATTACH' OrReplace? IfNotExists? Database? DatabasePath AttachAlias? AttachOptions? + +Database <- 'DATABASE' +DatabasePath <- Expression +AttachAlias <- 'AS' ColId +AttachOptions <- GenericCopyOptionList diff --git a/internal/grammar/duckdb/statements/call.gram b/internal/grammar/duckdb/statements/call.gram new file mode 100644 index 0000000..1e01a18 --- /dev/null +++ b/internal/grammar/duckdb/statements/call.gram @@ -0,0 +1 @@ +CallStatement <- 'CALL' QualifiedTableFunction TableFunctionArguments diff --git a/internal/grammar/duckdb/statements/checkpoint.gram b/internal/grammar/duckdb/statements/checkpoint.gram new file mode 100644 index 0000000..194a9bf --- /dev/null +++ b/internal/grammar/duckdb/statements/checkpoint.gram @@ -0,0 +1,2 @@ +CheckpointStatement <- CheckpointForce? 'CHECKPOINT' CatalogName? +CheckpointForce <- 'FORCE' diff --git a/internal/grammar/duckdb/statements/comment.gram b/internal/grammar/duckdb/statements/comment.gram new file mode 100644 index 0000000..fd58174 --- /dev/null +++ b/internal/grammar/duckdb/statements/comment.gram @@ -0,0 +1,19 @@ +CommentStatement <- 'COMMENT' 'ON' CommentOnType DottedIdentifier 'IS' CommentValue + +CommentOnType <- CommentTable / CommentSequence / CommentFunction / CommentMacroTable / CommentMacro / + CommentView / CommentDatabase / CommentIndex / CommentSchema / CommentType / CommentColumn + +CommentTable <- 'TABLE' +CommentSequence <- 'SEQUENCE' +CommentFunction <- 'FUNCTION' +CommentMacroTable <- 'MACRO' 'TABLE' +CommentMacro <- 'MACRO' +CommentView <- 'VIEW' +CommentDatabase <- 'DATABASE' +CommentIndex <- 'INDEX' +CommentSchema <- 'SCHEMA' +CommentType <- 'TYPE' +CommentColumn <- 'COLUMN' + +CommentValue <- NullLiteral / StringLiteralValue +StringLiteralValue <- StringLiteral diff --git a/internal/grammar/duckdb/statements/common.gram b/internal/grammar/duckdb/statements/common.gram new file mode 100644 index 0000000..445b426 --- /dev/null +++ b/internal/grammar/duckdb/statements/common.gram @@ -0,0 +1,195 @@ +Program <- TopLevelStatement* + +TopLevelStatement <- Statement? (';'+ / EndOfInput) + +Statement <- + ExternalResourceStatement / + CreateStatement / + SelectStatement / + SetStatement / + PragmaStatement / + CallStatement / + InsertStatement / + DropStatement / + CopyStatement / + ExplainStatement / + UpdateStatement / + PrepareStatement / + ExecuteStatement / + AlterStatement / + TransactionStatement / + DeleteStatement / + AttachStatement / + UseStatement / + DetachStatement / + CheckpointStatement / + VacuumStatement / + ResetStatement / + ExportStatement / + ImportStatement / + CommentStatement / + DeallocateStatement / + TruncateStatement / + LoadStatement / + InstallStatement / + UpdateExtensionsStatement / + AnalyzeStatement / + MergeIntoStatement / + ConnectStatement / + DisconnectStatement / + ExpressionStatement + +AnalyzeKeyword <- 'ANALYZE' / 'ANALYSE' + +ExpressionStatement <- List(ExpressionAlias) +ExpressionAlias <- ColIdExpression / ExpressionAsCollabel / Expression + +CatalogName <- Identifier +SchemaName <- Identifier +ReservedSchemaName <- Identifier +TableName <- Identifier +ReservedTableName <- Identifier +ReservedIdentifier <- Identifier +ColumnName <- Identifier +ReservedColumnName <- Identifier +IndexName <- Identifier +ReservedIndexName <- Identifier +SettingName <- Identifier +PragmaName <- Identifier +FunctionName <- Identifier +ReservedFunctionName <- Identifier +ReservedTypeName <- Identifier +TableFunctionName <- Identifier +ConstraintName <- ColIdOrString +SequenceName <- Identifier +CollationName <- Identifier +CopyOptionName <- ColLabel + +NumberLiteral <- < [+-]?[0-9]*([.][0-9]*)? > +StringLiteral <- '\'' [^\']* '\'' + +Type <- TypeVariations ArrayBounds* +TypeVariations <- TimeType / IntervalType / BitType / RowType / VariantType / MapType / TupleType / GeometryType / UnionType / NumericType / SetofType / SimpleType +SimpleType <- CharacterSimpleType / QualifiedSimpleType +CharacterSimpleType <- CharacterType TypeModifiers? +QualifiedSimpleType <- QualifiedTypeName TypeModifiers? +CharacterType <- ('CHARACTER' 'VARYING'?) / + ('CHAR' 'VARYING'?) / + ('NATIONAL' 'CHARACTER' 'VARYING'?) / + ('NATIONAL' 'CHAR' 'VARYING'?) / + ('NCHAR' 'VARYING'?) / + 'VARCHAR' + +IntervalType <- IntervalInterval / IntervalNumber +IntervalInterval <- IntervalWithSpecifier / IntervalWithoutSpecifier +IntervalWithSpecifier <- IntervalWithRangeSpecifier / IntervalWithSimpleSpecifier +IntervalWithRangeSpecifier <- 'INTERVAL' IntervalToIntervalAsType +IntervalWithSimpleSpecifier <- 'INTERVAL' Interval +IntervalWithoutSpecifier <- 'INTERVAL' + +IntervalToIntervalAsType <- (YearKeyword 'TO' MonthKeyword) / + (DayKeyword 'TO' HourKeyword) / + (DayKeyword 'TO' MinuteKeyword) / + (DayKeyword 'TO' SecondKeyword) / + (HourKeyword 'TO' MinuteKeyword) / + (HourKeyword 'TO' SecondKeyword) / + (MinuteKeyword 'TO' SecondKeyword) +IntervalNumber <- 'INTERVAL' Parens(NumberLiteral) + +YearKeyword <- 'YEAR' / 'YEARS' +MonthKeyword <- 'MONTH' / 'MONTHS' +DayKeyword <- 'DAY' / 'DAYS' +HourKeyword <- 'HOUR' / 'HOURS' +MinuteKeyword <- 'MINUTE' / 'MINUTES' +SecondKeyword <- 'SECOND' / 'SECONDS' +MillisecondKeyword <- 'MILLISECOND' / 'MILLISECONDS' +MicrosecondKeyword <- 'MICROSECOND' / 'MICROSECONDS' +WeekKeyword <- 'WEEK' / 'WEEKS' +QuarterKeyword <- 'QUARTER' / 'QUARTERS' +DecadeKeyword <- 'DECADE' / 'DECADES' +CenturyKeyword <- 'CENTURY' / 'CENTURIES' +MillenniumKeyword <- 'MILLENNIUM' / 'MILLENNIA' + +Interval <- IntervalToInterval / + YearKeyword / + MonthKeyword / + DayKeyword / + HourKeyword / + MinuteKeyword / + SecondKeyword / + MillisecondKeyword / + MicrosecondKeyword / + WeekKeyword / + QuarterKeyword / + DecadeKeyword / + CenturyKeyword / + MillenniumKeyword + +IntervalToInterval <- YearToMonth / + DayToHour / + DayToMinute / + DayToSecond / + HourToMinute / + HourToSecond / + MinuteToSecond +YearToMonth <- YearKeyword 'TO' MonthKeyword +DayToHour <- DayKeyword 'TO' HourKeyword +DayToMinute <- DayKeyword 'TO' MinuteKeyword +DayToSecond <- DayKeyword 'TO' SecondKeyword +HourToMinute <- HourKeyword 'TO' MinuteKeyword +HourToSecond <- HourKeyword 'TO' SecondKeyword +MinuteToSecond <- MinuteKeyword 'TO' SecondKeyword + +BitType <- 'BIT' 'VARYING'? Parens(List(Expression))? +GeometryType <- 'GEOMETRY' Parens(Expression)? +VariantType <- 'VARIANT' + +NumericType <- SimpleNumericType / DecimalNumericType +SimpleNumericType <- IntType / IntegerType / SmallintType / + BigintType / RealType / BooleanType / DoubleType +DecimalNumericType <- FloatType / DecimalType / DecType / NumericModType + +IntType <- 'INT' +IntegerType <- 'INTEGER' +SmallintType <- 'SMALLINT' +BigintType <- 'BIGINT' +RealType <- 'REAL' +BooleanType <- 'BOOLEAN' +DoubleType <- ('DOUBLE' 'PRECISION') + +FloatType <- 'FLOAT' Parens(NumberLiteral)? +DecimalType <- 'DECIMAL' TypeModifiers? +DecType <- 'DEC' TypeModifiers? +NumericModType <- 'NUMERIC' TypeModifiers? + +QualifiedTypeName <- CatalogReservedSchemaTypeName / SchemaReservedTypeName / TypeNameAsQualifiedName +TypeNameAsQualifiedName <- TypeName +CatalogReservedSchemaTypeName <- CatalogQualification ReservedSchemaQualification ReservedTypeName +SchemaReservedTypeName <- SchemaQualification ReservedTypeName +TypeModifiers <- Parens(List(Expression)?) +RowType <- RowOrStruct ColIdTypeList? +SetofType <- 'SETOF' Type +UnionType <- 'UNION' ColIdTypeList +ColIdTypeList <- Parens(List(ColIdType)) +MapType <- 'MAP' Parens(List(Type))? +TupleType <- 'TUPLE' Parens(List(Type)) +ColIdType <- ColId Type +ArrayBounds <- ArrayKeywordWithBounds / SquareBracketsArray / ArrayKeyword +ArrayKeyword <- 'ARRAY' +ArrayKeywordWithBounds <- 'ARRAY' SquareBracketsArray +SquareBracketsArray <- '[' Expression? ']' +TimeType <- TimeOrTimestamp TypeModifiers? TimeZone? +TimeOrTimestamp <- TimeTypeId / TimestampTypeId +TimeTypeId <- 'TIME' +TimestampTypeId <- 'TIMESTAMP' +TimeZone <- WithOrWithout 'TIME' 'ZONE' +WithOrWithout <- WithRule / WithoutRule +WithRule <- 'WITH' +WithoutRule <- 'WITHOUT' + +RowOrStruct <- 'ROW' / 'STRUCT' + +# internal definitions +%whitespace <- [ \t\n\r]* +List(D) <- D (',' D)* ','? +Parens(D) <- '(' D ')' diff --git a/internal/grammar/duckdb/statements/connect.gram b/internal/grammar/duckdb/statements/connect.gram new file mode 100644 index 0000000..1ed1dd2 --- /dev/null +++ b/internal/grammar/duckdb/statements/connect.gram @@ -0,0 +1,6 @@ +ConnectStatement <- 'CONNECT' SessionTarget? +DisconnectStatement <- 'DISCONNECT' +SessionTarget <- LocalSessionTarget / StringSessionTarget / CatalogSessionTarget +LocalSessionTarget <- 'LOCAL' +StringSessionTarget <- StringLiteral GenericCopyOptionList? +CatalogSessionTarget <- CatalogName diff --git a/internal/grammar/duckdb/statements/copy.gram b/internal/grammar/duckdb/statements/copy.gram new file mode 100644 index 0000000..06cb3f5 --- /dev/null +++ b/internal/grammar/duckdb/statements/copy.gram @@ -0,0 +1,65 @@ +CopyStatement <- 'COPY' CopyVariations +CopyVariations <- CopyTable / CopySelect / CopyFromDatabase + +CopyTable <- BaseTableName InsertColumnList? FromOrTo CopyFileName CopyOptions? +FromOrTo <- CopyFrom / CopyTo +CopyFrom <- 'FROM' +CopyTo <- 'TO' + +CopySelect <- Parens(SelectStatementInternal) 'TO' CopyFileName CopyOptions? + +CopyFileName <- CopyFileNameExpression / CopyFileNameStringLiteral / CopyFileNameIdentifier / CopyFileNameIdentifierColId +CopyFileNameExpression <- Parameter / ParensExpression +CopyFileNameStringLiteral <- StringLiteral +CopyFileNameIdentifier <- Identifier +CopyFileNameIdentifierColId <- IdentifierColId +IdentifierColId <- Identifier '.' ColId +CopyOptions <- 'WITH'? CopyOptionList +CopyOptionList <- CopyGenericOptionList / SpecializedOptionList +SpecializedOptionList <- SpecializedOption SpecializedOptionTail* +SpecializedOptionTail <- ','? SpecializedOption +SpecializedOption <- SingleOption / NullAsOption / DelimiterAsOption / EscapeAsOption / + EncodingOption / QuoteAsOption / ForceQuoteOption / PartitionByOption / ForceNullOption + +SingleOption <- BinaryOption / FreezeOption / OidsOption / CsvOption / HeaderOption +BinaryOption <- 'BINARY' +FreezeOption <- 'FREEZE' +OidsOption <- 'OIDS' +CsvOption <- 'CSV' +HeaderOption <- 'HEADER' +NullAsOption <- 'NULL' 'AS'? StringLiteral +DelimiterAsOption <- 'DELIMITER' 'AS'? StringLiteral +QuoteAsOption <- 'QUOTE' 'AS'? StringLiteral +EscapeAsOption <- 'ESCAPE' 'AS'? StringLiteral +EncodingOption <- 'ENCODING' StringLiteral +ForceQuoteOption <- ForceQuote? 'QUOTE' StarSymbolColumnList +StarSymbolColumnList <- StarSymbol / ColumnList +ForceQuote <- 'FORCE' +PartitionByOption <- ('PARTITION' / 'PARTITIONED') 'BY' PartitionByColumnList +PartitionByColumnList <- StarPartitionByColumnList / ParenthesizedPartitionByColumnList / SinglePartitionByColumnList +StarPartitionByColumnList <- StarSymbol +ParenthesizedPartitionByColumnList <- Parens(ColumnList) +SinglePartitionByColumnList <- ColId +ForceNullOption <- 'FORCE' ForceNotNull? 'NULL' ColumnList +ForceNotNull <- 'NOT' +StarSymbol <- '*' + +CopyGenericOptionList <- Parens(List(CopyGenericOption)) +CopyGenericOption <- OrderByCopyOption / PartitionedByCopyOption / GenericCopyOption +OrderByCopyOption <- 'ORDER' 'BY' GenericCopyOptionValue? +PartitionedByCopyOption <- ('PARTITION' / 'PARTITIONED') 'BY' GenericCopyOptionValue? +GenericCopyOptionList <- Parens(List(GenericCopyOption)) +GenericCopyOption <- CopyOptionName GenericCopyOptionValue? +GenericCopyOptionValue <- GenericCopyOptionOrderList / GenericCopyOptionExpression +GenericCopyOptionOrderList <- GenericCopyOptionParenthesizedExpressionList +GenericCopyOptionExpression <- Expression +GenericCopyOptionParenthesizedExpressionList <- Parens(OrderByExpressionList) + +CopyFromDatabase <- CopyFromDatabaseWithFlag / CopyFromDatabaseWithoutFlag +CopyFromDatabaseWithFlag <- 'FROM' 'DATABASE' ColId 'TO' ColId CopyDatabaseFlag +CopyFromDatabaseWithoutFlag <- 'FROM' 'DATABASE' ColId 'TO' ColId + +CopyDatabaseFlag <- Parens(SchemaOrData) +SchemaOrData <- CopySchema / CopyData +CopySchema <- 'SCHEMA' +CopyData <- 'DATA' diff --git a/internal/grammar/duckdb/statements/create_index.gram b/internal/grammar/duckdb/statements/create_index.gram new file mode 100644 index 0000000..1d5161c --- /dev/null +++ b/internal/grammar/duckdb/statements/create_index.gram @@ -0,0 +1,21 @@ +CreateIndexStmt <- UniqueIndex? 'INDEX' IfNotExists? IndexName? 'ON' BaseTableName InsertColumnList? IndexType? Parens(List(IndexElement))? WithList? WhereClause? + +WithList <- 'WITH' RelOptionOrOids +RelOptionOrOids <- RelOptionList / Oids +RelOptionList <- Parens(List(RelOption)) +Oids <- WithOrWithoutOids 'OIDS' +WithOrWithoutOids <- WithOids / WithoutOids +WithOids <- 'WITH' +WithoutOids <- 'WITHOUT' +IndexElement <- Expression DescOrAsc? NullsFirstOrLast? +UniqueIndex <- 'UNIQUE' +IndexType <- 'USING' Identifier +RelOption <- RelOptionName RelOptionArgumentOpt? +RelOptionName <- DottedIdentifierString / StringLiteral +DottedIdentifierString <- DottedIdentifier +RelOptionArgumentOpt <- '=' DefArg +DefArg <- DefArgNull / DefArgStringLiteral / NumberLiteral / NoneLiteral / Expression / DefArgKeyword +DefArgNull <- NullLiteral +DefArgKeyword <- ReservedKeyword +DefArgStringLiteral <- StringLiteral +NoneLiteral <- 'NONE' diff --git a/internal/grammar/duckdb/statements/create_macro.gram b/internal/grammar/duckdb/statements/create_macro.gram new file mode 100644 index 0000000..821b65b --- /dev/null +++ b/internal/grammar/duckdb/statements/create_macro.gram @@ -0,0 +1,15 @@ +CreateMacroStmt <- MacroOrFunction IfNotExists? QualifiedName List(MacroDefinition) + +MacroOrFunction <- MacroKeyword / FunctionKeyword +MacroKeyword <- 'MACRO' +FunctionKeyword <- 'FUNCTION' + +MacroDefinition <- Parens(MacroParameters?) 'AS' MacroDefinitionBody +MacroDefinitionBody <- TableMacroDefinition / ScalarMacroDefinition + +MacroParameters <- List(MacroParameter) +MacroParameter <- NamedParameter / SimpleParameter +SimpleParameter <- TypeFuncName Type? + +ScalarMacroDefinition <- Expression +TableMacroDefinition <- 'TABLE' SelectStatementInternal diff --git a/internal/grammar/duckdb/statements/create_schema.gram b/internal/grammar/duckdb/statements/create_schema.gram new file mode 100644 index 0000000..5044cc8 --- /dev/null +++ b/internal/grammar/duckdb/statements/create_schema.gram @@ -0,0 +1 @@ +CreateSchemaStmt <- 'SCHEMA' IfNotExists? QualifiedName \ No newline at end of file diff --git a/internal/grammar/duckdb/statements/create_secret.gram b/internal/grammar/duckdb/statements/create_secret.gram new file mode 100644 index 0000000..038e46b --- /dev/null +++ b/internal/grammar/duckdb/statements/create_secret.gram @@ -0,0 +1,4 @@ +CreateSecretStmt <- 'SECRET' IfNotExists? SecretName? SecretStorageSpecifier? GenericCopyOptionList + +SecretStorageSpecifier <- 'IN' Identifier +SecretName <- ColId diff --git a/internal/grammar/duckdb/statements/create_sequence.gram b/internal/grammar/duckdb/statements/create_sequence.gram new file mode 100644 index 0000000..f0b6b9e --- /dev/null +++ b/internal/grammar/duckdb/statements/create_sequence.gram @@ -0,0 +1,22 @@ +CreateSequenceStmt <- 'SEQUENCE' IfNotExists? QualifiedName SequenceOption* + +SequenceOption <- + SeqSetCycle / + SeqSetIncrement / + SeqSetMinMax / + SeqNoMinMax / + SeqStartWith / + SeqOwnedBy + +SeqSetCycle <- SeqCycle / SeqNoCycle +SeqCycle <- 'CYCLE' +SeqNoCycle <- 'NO' 'CYCLE' +SeqSetIncrement <- 'INCREMENT' 'BY'? Expression +SeqSetMinMax <- SeqMinOrMax Expression +SeqNoMinMax <- 'NO' SeqMinOrMax +SeqStartWith <- 'START' 'WITH'? Expression +SeqOwnedBy <- 'OWNED' 'BY' QualifiedName + +SeqMinOrMax <- MinValue / MaxValue +MinValue <- 'MINVALUE' +MaxValue <- 'MAXVALUE' diff --git a/internal/grammar/duckdb/statements/create_table.gram b/internal/grammar/duckdb/statements/create_table.gram new file mode 100644 index 0000000..26883ef --- /dev/null +++ b/internal/grammar/duckdb/statements/create_table.gram @@ -0,0 +1,97 @@ +CreateStatement <- 'CREATE' OrReplace? Temporary? CreateStatementVariation +CreateStatementVariation <- CreateTableStmt / CreateMacroStmt / CreateSequenceStmt / CreateTypeStmt / CreateSchemaStmt / CreateViewStmt / CreateIndexStmt / CreateSecretStmt / CreateTriggerStmt +OrReplace <- 'OR' 'REPLACE' +Temporary <- Persistent / TempPersistent / TemporaryPersistent +Persistent <- 'PERSISTENT' +TempPersistent <- 'TEMP' +TemporaryPersistent <- 'TEMPORARY' + +CreateTableStmt <- 'TABLE' IfNotExists? QualifiedName CreateTableDefinition CommitAction? +CreateTableDefinition <- CreateTableAs / CreateColumnList + +CreateTableAs <- IdentifierList? PartitionSortedOptions? WithList? 'AS' Statement WithData? +PartitionSortedOptions <- PartitionOptSortedOptions / SortedOptPartitionOptions +PartitionOptSortedOptions <- PartitionOptions SortedOptions? +SortedOptPartitionOptions <- SortedOptions PartitionOptions? +PartitionOptions <- 'PARTITIONED' 'BY' Parens(List(Expression)) +SortedOptions <- 'SORTED' 'BY' Parens(List(Expression)) + +WithData <- WithDataOnly / WithNoData +WithDataOnly <- 'WITH' 'DATA' +WithNoData <- 'WITH' 'NO' 'DATA' +IdentifierList <- Parens(List(Identifier)) +CreateColumnList <- Parens(CreateTableColumnList?) PartitionSortedOptions? WithList? +IfNotExists <- 'IF' 'NOT' 'EXISTS' +QualifiedName <- CatalogReservedSchemaIdentifier / SchemaReservedIdentifierOrStringLiteral / IdentifierOrStringLiteral +SchemaReservedIdentifierOrStringLiteral <- SchemaQualification ReservedIdentifierOrStringLiteral +CatalogReservedSchemaIdentifier <- CatalogQualification ReservedSchemaQualification ReservedIdentifierOrStringLiteral +IdentifierOrStringLiteral <- Identifier / StringLiteral +ReservedIdentifierOrStringLiteral <- ReservedIdentifier / StringLiteral +CatalogQualification <- CatalogName '.' +SchemaQualification <- SchemaName '.' +ReservedSchemaQualification <- ReservedSchemaName '.' +TableQualification <- TableName '.' +ReservedTableQualification <- ReservedTableName '.' + +CreateTableColumnList <- List(CreateTableColumnElement) +CreateTableColumnElement <- CreateTableColumnDefinition / CreateTableConstraint +CreateTableColumnDefinition <- ColumnDefinition +CreateTableConstraint <- TopLevelConstraint +ColumnDefinition <- DottedIdentifier Type? GeneratedColumn? ConstraintNameClause? ColumnConstraint* +ColumnConstraint <- NotNullConstraint / UniqueConstraint / PrimaryKeyConstraint / DefaultValue / CheckConstraint / ForeignKeyConstraint / ColumnCollation / ColumnCompression +NotNullConstraint <- NullConstraint / NotNullColumnConstraint +NullConstraint <- 'NULL' +NotNullColumnConstraint <- 'NOT' 'NULL' +UniqueConstraint <- 'UNIQUE' +PrimaryKeyConstraint <- 'PRIMARY' 'KEY' +DefaultValue <- 'DEFAULT' ColumnDefaultExpr +CheckConstraint <- 'CHECK' Parens(Expression) +ForeignKeyConstraint <- 'REFERENCES' BaseTableName Parens(ColumnList)? KeyActions +ColumnCollation <- 'COLLATE' DottedIdentifier +ColumnCompression <- 'USING' 'COMPRESSION' ColIdOrString + +KeyActions <- UpdateAction? DeleteAction? +UpdateAction <- 'ON' 'UPDATE' KeyAction +DeleteAction <- 'ON' 'DELETE' KeyAction +KeyAction <- NoKeyAction / RestrictKeyAction / CascadeKeyAction / SetNullKeyAction / SetDefaultKeyAction +NoKeyAction <- 'NO' 'ACTION' +RestrictKeyAction <- 'RESTRICT' +CascadeKeyAction <- 'CASCADE' +SetNullKeyAction <- 'SET' 'NULL' +SetDefaultKeyAction <- 'SET' 'DEFAULT' + +TopLevelConstraint <- ConstraintNameClause? TopLevelConstraintList +TopLevelConstraintList <- TopPrimaryKeyConstraint / TopCheckConstraint / TopUniqueConstraint / TopForeignKeyConstraint +ConstraintNameClause <- 'CONSTRAINT' Identifier +TopCheckConstraint <- CheckConstraint +TopPrimaryKeyConstraint <- 'PRIMARY' 'KEY' ColumnIdList +TopUniqueConstraint <- 'UNIQUE' ColumnIdList +TopForeignKeyConstraint <- 'FOREIGN' 'KEY' ColumnIdList ForeignKeyConstraint +ColumnIdList <- Parens(List(ColId)) + +PlainIdentifier <- !ReservedKeyword <[a-z_]i[a-z0-9_]i*> +QuotedIdentifier <- '"' [^"]* '"' +DottedIdentifier <- Identifier DotColLabel* +DotColLabel <- '.' ColLabel +Identifier <- QuotedIdentifier / PlainIdentifier + +ColId <- UnreservedKeyword / ColumnNameKeyword / Identifier +ColIdOrString <- ColId / StringLiteralIdentifier +TypeFuncName <- UnreservedKeyword / TypeNameKeyword / FuncNameKeyword / Identifier +TypeName <- UnreservedKeyword / TypeNameKeyword / Identifier +ColLabel <- ReservedKeyword / UnreservedKeyword / ColumnNameKeyword / FuncNameKeyword / TypeNameKeyword / Identifier +ColLabelOrString <- ColLabelIdentifier / StringLiteralIdentifier +ColLabelIdentifier <- ColLabel +StringLiteralIdentifier <- StringLiteral +GeneratedColumn <- Generated? 'AS' Parens(Expression) GeneratedColumnType? + +Generated <- 'GENERATED' AlwaysOrByDefault? +AlwaysOrByDefault <- 'ALWAYS' / ('BY' 'DEFAULT') +GeneratedColumnType <- VirtualGeneratedColumn / StoredGeneratedColumn + +CommitAction <- 'ON' 'COMMIT' PreserveOrDelete 'ROWS' +PreserveOrDelete <- PreserveRows / DeleteRows +PreserveRows <- 'PRESERVE' +DeleteRows <- 'DELETE' +VirtualGeneratedColumn <- 'VIRTUAL' +StoredGeneratedColumn <- 'STORED' diff --git a/internal/grammar/duckdb/statements/create_trigger.gram b/internal/grammar/duckdb/statements/create_trigger.gram new file mode 100644 index 0000000..a68ef7e --- /dev/null +++ b/internal/grammar/duckdb/statements/create_trigger.gram @@ -0,0 +1,26 @@ +CreateTriggerStmt <- 'TRIGGER' IfNotExists? TriggerName TriggerTiming TriggerEvent 'ON' BaseTableName ReferencingClause? ForEachClause? TriggerBody + +TriggerBody <- InsertStatement / UpdateStatement / DeleteStatement / MergeIntoStatement +TriggerName <- Identifier + +ReferencingClause <- 'REFERENCING' ReferencingItem ReferencingItem? +ReferencingItem <- ReferencingNewTableAs / ReferencingOldTableAs +ReferencingNewTableAs <- 'NEW' 'TABLE' 'AS' ColId +ReferencingOldTableAs <- 'OLD' 'TABLE' 'AS' ColId + +TriggerTiming <- TriggerBefore / TriggerAfter / TriggerInsteadOf +TriggerBefore <- 'BEFORE' +TriggerAfter <- 'AFTER' +TriggerInsteadOf <- 'INSTEAD' 'OF' + +TriggerEvent <- TriggerEventUpdateOf / TriggerEventInsert / TriggerEventDelete / TriggerEventUpdate +TriggerEventInsert <- 'INSERT' +TriggerEventDelete <- 'DELETE' +TriggerEventUpdate <- 'UPDATE' +TriggerEventUpdateOf <- 'UPDATE' 'OF' TriggerColumnList + +TriggerColumnList <- List(ColId) + +ForEachClause <- ForEachRow / ForEachStatement +ForEachRow <- 'FOR' 'EACH' 'ROW' +ForEachStatement <- 'FOR' 'EACH' 'STATEMENT' diff --git a/internal/grammar/duckdb/statements/create_type.gram b/internal/grammar/duckdb/statements/create_type.gram new file mode 100644 index 0000000..d0eb562 --- /dev/null +++ b/internal/grammar/duckdb/statements/create_type.gram @@ -0,0 +1,5 @@ +CreateTypeStmt <- 'TYPE' IfNotExists? QualifiedName 'AS' CreateType +CreateType <- EnumSelectType / EnumStringLiteralList / CreateTypeFromType +CreateTypeFromType <- Type +EnumSelectType <- 'ENUM' Parens(SelectStatementInternal) +EnumStringLiteralList <- 'ENUM' Parens(List(StringLiteral)?) diff --git a/internal/grammar/duckdb/statements/create_view.gram b/internal/grammar/duckdb/statements/create_view.gram new file mode 100644 index 0000000..4f598dc --- /dev/null +++ b/internal/grammar/duckdb/statements/create_view.gram @@ -0,0 +1,3 @@ +CreateViewStmt <- CreateSecure? CreateRecursive? 'VIEW' IfNotExists? QualifiedName InsertColumnList? WithList? 'AS' SelectStatementInternal +CreateRecursive <- 'RECURSIVE' +CreateSecure <- 'SECURE' diff --git a/internal/grammar/duckdb/statements/deallocate.gram b/internal/grammar/duckdb/statements/deallocate.gram new file mode 100644 index 0000000..3526871 --- /dev/null +++ b/internal/grammar/duckdb/statements/deallocate.gram @@ -0,0 +1,2 @@ +DeallocateStatement <- 'DEALLOCATE' DeallocatePrepare? Identifier +DeallocatePrepare <- 'PREPARE' diff --git a/internal/grammar/duckdb/statements/delete.gram b/internal/grammar/duckdb/statements/delete.gram new file mode 100644 index 0000000..f609c2f --- /dev/null +++ b/internal/grammar/duckdb/statements/delete.gram @@ -0,0 +1,4 @@ +DeleteStatement <- WithClause? 'DELETE' 'FROM' TargetOptAlias DeleteUsingClause? WhereClause? ReturningClause? +TruncateStatement <- 'TRUNCATE' 'TABLE'? BaseTableName +TargetOptAlias <- BaseTableName 'AS'? ColId? +DeleteUsingClause <- 'USING' List(TableRef) diff --git a/internal/grammar/duckdb/statements/describe.gram b/internal/grammar/duckdb/statements/describe.gram new file mode 100644 index 0000000..fbf71f3 --- /dev/null +++ b/internal/grammar/duckdb/statements/describe.gram @@ -0,0 +1,39 @@ +DescribeStatement <- ShowTables / ShowDeprecatedSelect / DescribeSelect / ShowAllTables / ShowByName / DescribeByName + +# "DESCRIBE (query)" and "SUMMARIZE (query)" describe the query's columns. "SHOW (query)" does too but is deprecated, +# so ShowDeprecatedSelect is parsed yet suppressed from autocomplete (matcher_factory.cpp) - SHOW won't offer to complete a query. +ShowDeprecatedSelect <- ShowRule SelectStatementInternal +DescribeSelect <- DescribeOrSummarize SelectStatementInternal +ShowAllTables <- ShowOrDescribe 'ALL' 'TABLES'? +ShowTables <- ShowOrDescribe 'TABLES' 'FROM' QualifiedName + +# "SHOW name" is settings-first, so its target autocompletes setting names (and the special MySQL forms), not +# arbitrary tables. "DESCRIBE"/"SUMMARIZE" describe a relation, so their target autocompletes table names. +ShowByName <- ShowRule ShowTarget? +DescribeByName <- DescribeOrSummarize DescribeTarget? +DescribeOrSummarize <- DescribeRule / Summarize + +# SHOW's own forms (a settings-first name and the special MySQL forms) plus the describe-style targets it still +# tolerates for the deprecated "describe via SHOW". Only settings and the special forms are autocompleted after SHOW; +# a qualified table is parsed but its suggestions are suppressed (see matcher.cpp). +ShowTarget <- ShowDeprecatedQualifiedTableName / ShowSettingName / DescribeStringLiteral / ShowSpecialForm +# "SHOW cat.tbl" still describes a table (deprecated), but is suppressed from autocomplete (see matcher.cpp) so SHOW +# does not complete qualified tables (unlike DESCRIBE, which does). Wraps the generic QualifiedTableName (select.gram). +ShowDeprecatedQualifiedTableName <- QualifiedTableName +# A bare identifier is suggested as a setting name (SettingName is overridden to SUGGEST_SETTING_NAME). +ShowSettingName <- SettingName +# The special MySQL forms are only here so autocomplete suggests these keywords after SHOW; parsing of e.g. +# "SHOW databases" resolves through ShowSettingName (the identifier) above, which the transformer special-cases. +ShowSpecialForm <- 'DATABASES' / 'SCHEMAS' / 'TABLES' / 'VARIABLES' + +DescribeTarget <- DescribeBaseTableName / DescribeStringLiteral +DescribeBaseTableName <- BaseTableName +DescribeStringLiteral <- StringLiteral + +Summarize <- SummarizeRule +SummarizeRule <- 'SUMMARIZE' +ShowOrDescribe <- ShowRule / DescribeRule +ShowRule <- 'SHOW' +DescribeRule <- DescribeLongRule / DescRule +DescribeLongRule <- 'DESCRIBE' +DescRule <- 'DESC' diff --git a/internal/grammar/duckdb/statements/detach.gram b/internal/grammar/duckdb/statements/detach.gram new file mode 100644 index 0000000..560d319 --- /dev/null +++ b/internal/grammar/duckdb/statements/detach.gram @@ -0,0 +1 @@ +DetachStatement <- 'DETACH' Database? IfExists? CatalogName diff --git a/internal/grammar/duckdb/statements/drop.gram b/internal/grammar/duckdb/statements/drop.gram new file mode 100644 index 0000000..8c9c5c2 --- /dev/null +++ b/internal/grammar/duckdb/statements/drop.gram @@ -0,0 +1,43 @@ +DropStatement <- 'DROP' DropEntries DropBehavior? + +DropEntries <- + DropTable / + DropTableFunction / + DropFunction / + DropSchema / + DropIndex / + DropSequence / + DropCollation / + DropType / + DropSecret / + DropTrigger + +DropTrigger <- 'TRIGGER' IfExists? TriggerName 'ON' BaseTableName + +DropTable <- TableOrView IfExists? List(BaseTableName) +DropTableFunction <- CommentMacroTable IfExists? List(TableFunctionName) +DropFunction <- FunctionTypeMacro IfExists? List(FunctionIdentifier) +DropSchema <- 'SCHEMA' IfExists? List(QualifiedName) +DropIndex <- 'INDEX' IfExists? List(QualifiedIndexName) +QualifiedIndexName <- CatalogReservedSchemaIndex / SchemaReservedIndex / QualifiedIndexNameString +QualifiedIndexNameString <- IndexName +SchemaReservedIndex <- SchemaQualification ReservedIndexName +CatalogReservedSchemaIndex <- CatalogQualification ReservedSchemaQualification ReservedIndexName +DropSequence <- 'SEQUENCE' IfExists? List(QualifiedSequenceName) +DropCollation <- 'COLLATION' IfExists? List(CollationName) +DropType <- 'TYPE' IfExists? List(QualifiedTypeName) +DropSecret <- Temporary? 'SECRET' IfExists? SecretName DropSecretStorage? + +TableOrView <- CommentTable / CommentView / MaterializedViewEntry +MaterializedViewEntry <- 'MATERIALIZED' 'VIEW' +FunctionTypeMacro <- FunctionTypeMacroKeyword / FunctionTypeFunction +FunctionTypeMacroKeyword <- 'MACRO' +FunctionTypeFunction <- 'FUNCTION' + +DropBehavior <- CascadeDropBehavior / RestrictDropBehavior +CascadeDropBehavior <- 'CASCADE' +RestrictDropBehavior <- 'RESTRICT' + +IfExists <- 'IF' 'EXISTS' + +DropSecretStorage <- 'FROM' Identifier diff --git a/internal/grammar/duckdb/statements/execute.gram b/internal/grammar/duckdb/statements/execute.gram new file mode 100644 index 0000000..13e5ca1 --- /dev/null +++ b/internal/grammar/duckdb/statements/execute.gram @@ -0,0 +1 @@ +ExecuteStatement <- 'EXECUTE' Identifier TableFunctionArguments? \ No newline at end of file diff --git a/internal/grammar/duckdb/statements/explain.gram b/internal/grammar/duckdb/statements/explain.gram new file mode 100644 index 0000000..72f232e --- /dev/null +++ b/internal/grammar/duckdb/statements/explain.gram @@ -0,0 +1,29 @@ +ExplainStatement <- 'EXPLAIN' AnalyzeKeyword? ExplainOptionList? ExplainableStatements +ExplainOptionList <- Parens(List(ExplainOption)) +ExplainOption <- ExplainOptionName Expression? +ExplainOptionName <- AnalyzeKeyword / ColId / FuncNameKeyword / TypeNameKeyword + +ExplainSelectStatement <- SelectStatementInternal + +ExplainableStatements <- + AlterStatement / + AnalyzeStatement / + CallStatement / + CheckpointStatement / + CopyStatement / + CreateStatement / + DeallocateStatement / + DeleteStatement / + DropStatement / + ExecuteStatement / + InsertStatement / + LoadStatement / + MergeIntoStatement / + PragmaStatement / + PrepareStatement / + ExplainSelectStatement / + TransactionStatement / + UpdateStatement / + VacuumStatement / + SetStatement / + ResetStatement diff --git a/internal/grammar/duckdb/statements/export.gram b/internal/grammar/duckdb/statements/export.gram new file mode 100644 index 0000000..d6d5640 --- /dev/null +++ b/internal/grammar/duckdb/statements/export.gram @@ -0,0 +1,3 @@ +ExportStatement <- 'EXPORT' 'DATABASE' ExportSource? StringLiteral GenericCopyOptionList? +ExportSource <- CatalogName 'TO' +ImportStatement <- 'IMPORT' 'DATABASE' StringLiteral diff --git a/internal/grammar/duckdb/statements/expression.gram b/internal/grammar/duckdb/statements/expression.gram new file mode 100644 index 0000000..65738f7 --- /dev/null +++ b/internal/grammar/duckdb/statements/expression.gram @@ -0,0 +1,339 @@ +ColumnReference <- CatalogReservedSchemaTableColumnName / SchemaReservedTableColumnName / TableReservedColumnName / NestedColumnName +CatalogReservedSchemaTableColumnName <- CatalogQualification ReservedSchemaQualification ReservedTableQualification ReservedColumnName +SchemaReservedTableColumnName <- SchemaQualification ReservedTableQualification ReservedColumnName +TableReservedColumnName <- TableQualification ReservedColumnName +FunctionExpression <- FunctionIdentifier FunctionExpressionArguments WithinGroupClause? FilterClause? ExportClause? OverClause? +FunctionExpressionArguments <- Parens(FunctionExpressionArgumentList) +FunctionExpressionArgumentList <- DistinctOrAll? FunctionArgumentList? OrderByClause? IgnoreOrRespectNulls? +FunctionArgumentList <- List(FunctionArgument) + +FunctionIdentifier <- CatalogReservedSchemaFunctionName / SchemaReservedFunctionName / FunctionNameAsQualifiedName +FunctionNameAsQualifiedName <- FunctionName +CatalogReservedSchemaFunctionName <- CatalogQualification ReservedSchemaQualification? ReservedFunctionName +SchemaReservedFunctionName <- SchemaQualification ReservedFunctionName + +DistinctOrAll <- DistinctKeyword / AllKeyword +DistinctKeyword <- 'DISTINCT' +AllKeyword <- 'ALL' +ExportClause <- 'EXPORT_STATE' +WithinGroupClause <- 'WITHIN' 'GROUP' Parens(OrderByClause) +FilterClause <- 'FILTER' FilterClauseExpression +FilterClauseExpression <- Parens(FilterClauseContents) +FilterClauseContents <- 'WHERE'? Expression +IgnoreOrRespectNulls <- IgnoreNulls / RespectNulls +IgnoreNulls <- 'IGNORE' 'NULLS' +RespectNulls <- 'RESPECT' 'NULLS' + +ParenthesisExpression <- Parens(List(Expression)?) +LiteralExpression <- StringLiteral / NumberLiteral / ConstantLiteral +ConstantLiteral <- NullLiteral / TrueLiteral / FalseLiteral +NullLiteral <- 'NULL' +TrueLiteral <- 'TRUE' +FalseLiteral <- 'FALSE' +CastExpression <- CastOrTryCast Parens(CastArguments) +CastArguments <- Expression 'AS' Type +CastOrTryCast <- CastKeyword / TryCastKeyword +CastKeyword <- 'CAST' +TryCastKeyword <- 'TRY_CAST' +ColIdDot <- ColId '.' +StarExpression <- StarQualifierList? '*' ExcludeList? ReplaceList? RenameList? +StarQualifierList <- ColIdDot+ +ExcludeList <- ExcludeOrExcept ExcludeNames +ExcludeOrExcept <- 'EXCLUDE' / 'EXCEPT' +ExcludeNames <- ExcludeNameList / ExcludeNameSingle +ExcludeNameList <- Parens(List(ExcludeName)) +ExcludeNameSingle <- ExcludeName +ExcludeName <- ExcludeDottedName / ExcludeColumnName +ExcludeDottedName <- DottedIdentifier +ExcludeColumnName <- ColIdOrString +ReplaceList <- 'REPLACE' ReplaceEntries +ReplaceEntries <- ReplaceEntrySingle / ReplaceEntryList +ReplaceEntrySingle <- ReplaceEntry +ReplaceEntryList <- Parens(List(ReplaceEntry)) +ReplaceEntry <- Expression 'AS' ColumnReference +RenameList <- 'RENAME' RenameEntries +RenameEntries <- RenameEntryList / SingleRenameEntry +RenameEntryList <- Parens(List(RenameEntry)) +SingleRenameEntry <- RenameEntry +RenameEntry <- ExcludeName 'AS' Identifier +SubqueryExpression <- SubqueryNot? SubqueryExists? SubqueryReference +SubqueryNot <- 'NOT' +SubqueryExists <- 'EXISTS' +CaseExpression <- 'CASE' Expression? CaseWhenThen+ CaseElse? 'END' +CaseWhenThen <- 'WHEN' Expression 'THEN' Expression +CaseElse <- 'ELSE' Expression +TypeLiteral <- Type StringLiteral +IntervalLiteral <- 'INTERVAL' IntervalParameter Interval? +IntervalParameter <- IntervalStringParameter / NumberLiteral / ParensExpression +IntervalStringParameter <- StringLiteral +FrameClause <- Framing FrameExtent WindowExcludeClause? +Framing <- RowsFraming / RangeFraming / GroupsFraming +RowsFraming <- 'ROWS' +RangeFraming <- 'RANGE' +GroupsFraming <- 'GROUPS' +FrameExtent <- BetweenFrameExtent / SingleFrameExtent +SingleFrameExtent <- FrameBound +BetweenFrameExtent <- 'BETWEEN' FrameBound 'AND' FrameBound +FrameBound <- FrameUnbounded / FrameCurrentRow / FrameExpression +FrameUnbounded <- 'UNBOUNDED' PrecedingOrFollowing +FrameExpression <- Expression PrecedingOrFollowing +FrameCurrentRow <- 'CURRENT' 'ROW' +PrecedingOrFollowing <- PrecedingFrame / FollowingFrame +PrecedingFrame <- 'PRECEDING' +FollowingFrame <- 'FOLLOWING' +WindowExcludeClause <- 'EXCLUDE' WindowExcludeElement +WindowExcludeElement <- ExcludeCurrentRow / ExcludeGroup / ExcludeTies / ExcludeNoOthers +ExcludeCurrentRow <- 'CURRENT' 'ROW' +ExcludeGroup <- 'GROUP' +ExcludeTies <- 'TIES' +ExcludeNoOthers <- 'NO' 'OTHERS' +OverClause <- 'OVER' WindowFrame +WindowFrame <- ParensIdentifier / WindowFrameDefinition / IdentifierWindowFrame +IdentifierWindowFrame <- Identifier +ParensIdentifier <- Parens(Identifier) +WindowFrameDefinition <- WindowFrameNameContentsParens / WindowFrameContentsParens +WindowFrameNameContentsParens <- Parens(WindowFrameNameContents) +WindowFrameNameContents <- BaseWindowName? WindowFrameContents +WindowFrameContentsParens <- Parens(WindowFrameContents) +WindowFrameContents <- WindowPartition? OrderByClause? FrameClause? +BaseWindowName <- Identifier +WindowPartition <- 'PARTITION' 'BY' List(Expression) +ListExpression <- ArrayBoundedListExpression / ArrayParensSelect +ArrayBoundedListExpression <- 'ARRAY'? BoundedListExpression +ArrayParensSelect <- 'ARRAY' Parens(SelectStatementInternal) +BoundedListExpression <- '[' List(Expression)? ']' +StructExpression <- '{' List(StructField)? '}' +StructField <- ColIdOrString ':' Expression +MapExpression <- 'MAP' MapStructExpression +MapStructExpression <- '{' List(MapStructField)? '}' +MapStructField <- Expression ':' Expression + +GroupingExpression <- GroupingOrGroupingId Parens(List(Expression)?) +GroupingOrGroupingId <- GroupingKeyword / GroupingIdKeyword +GroupingKeyword <- 'GROUPING' +GroupingIdKeyword <- 'GROUPING_ID' +Parameter <- QuestionMarkNumberedParameter / AnonymousParameter / NumberedParameter / ColLabelParameter +QuestionMarkNumberedParameter <- '?' NumberLiteral +AnonymousParameter <- '?' +NumberedParameter <- '$' NumberLiteral +ColLabelParameter <- '$' ColLabel +PositionalExpression <- '#' NumberLiteral +DefaultExpression <- 'DEFAULT' + +ListComprehensionExpression <- '[' Expression 'FOR' List(ColIdOrString) 'IN' Expression ListComprehensionFilter? ']' +ListComprehensionFilter <- 'IF' Expression + +ParensExpression <- Parens(Expression) + +SingleExpression <- + ParensExpression / + LiteralExpression / + Parameter / + SubqueryExpression / + SpecialFunctionExpression / + ParenthesisExpression / + IntervalLiteral / + TypeLiteral / + CaseExpression / + StarExpression / + CastExpression / + GroupingExpression / + MapExpression / + FunctionExpression / + ColumnReference / + ListComprehensionExpression / + ListExpression / + StructExpression / + PositionalExpression / + DefaultExpression + +# LEVEL 1 (Lowest) +Expression <- LambdaArrowExpression +ColumnDefaultExpr <- ColDefOrExpr +# LEVEL 1.5 +LambdaArrowExpression <- LogicalOrExpression SingleArrowPair* +SingleArrowPair <- '->' LogicalOrExpression +LogicalOrExpression <- LogicalAndExpression LogicalOrExpressionTail* +LogicalOrExpressionTail <- 'OR' LogicalAndExpression +ColDefOrExpr <- ColDefAndExpr ColDefOrExpressionTail* +ColDefOrExpressionTail <- 'OR' ColDefAndExpr +# LEVEL 2 +LogicalAndExpression <- LogicalNotExpression LogicalAndExpressionTail* +LogicalAndExpressionTail <- 'AND' LogicalNotExpression +ColDefAndExpr <- IsDistinctFromExpression ColDefAndExpressionTail* +ColDefAndExpressionTail <- 'AND' IsDistinctFromExpression +# LEVEL 3 +LogicalNotExpression <- NotExpression? IsExpression +NotExpression <- NotKeyword+ +NotKeyword <- 'NOT' +# LEVEL 4 +IsExpression <- IsDistinctFromExpression IsTest* +IsTest <- IsLiteral / NotNull / IsNull +IsLiteral <- 'IS' 'NOT'? IsLiteralValue +IsLiteralValue <- TrueLiteral / FalseLiteral / NullLiteral / UnknownLiteral +UnknownLiteral <- 'UNKNOWN' +NotNull <- NotNullKeyword / NotNullOperator +NotNullKeyword <- 'NOT' 'NULL' +NotNullOperator <- 'NOTNULL' +IsNull <- IsNullOperator +IsNullOperator <- 'ISNULL' +# LEVEL 5 (Split because IsDistinctFromExpression allows post expression while IsOperator does not) +IsDistinctFromExpression <- ComparisonExpression IsDistinctFromTail* +IsDistinctFromTail <- IsDistinctFromOp ComparisonExpression +IsDistinctFromOp <- 'IS' 'NOT'? 'DISTINCT' 'FROM' +# LEVEL 6 +ComparisonExpression <- BetweenInLikeExpression ComparisonExpressionTail* +ComparisonExpressionTail <- ComparisonOperator NotExpression? BetweenInLikeExpression +ComparisonOperator <- + OperatorEqual / + OperatorNotEqual / + OperatorLessThan / + OperatorGreaterThan / + OperatorLessThanEquals / + OperatorGreaterThanEquals + +OperatorEqual <- '=' / '==' +OperatorNotEqual <- '!=' / '<>' +OperatorLessThan <- '<' +OperatorGreaterThan <- '>' +OperatorLessThanEquals <- '<=' +OperatorGreaterThanEquals <- '>=' +# LEVEL 7 +BetweenInLikeExpression <- OtherOperatorExpression BetweenInLikeOp? +BetweenInLikeOp <- 'NOT'? BetweenInLikeOpExpression +BetweenInLikeOpExpression <- BetweenClause / InClause / LikeClause +LikeClause <- LikeVariations OtherOperatorExpression EscapeClause? +EscapeClause <- 'ESCAPE' ComparisonExpression + +LikeVariations <- SimilarToToken / RegexInsensitiveMatchToken / RegexMatchToken / ILikeToken / LikeToken / GlobToken / NotILikeOp / NotLikeOp / NotRegexInsensitiveMatchOp / NotSimilarToOp +LikeToken <- 'LIKE' / '~~' +ILikeToken <- 'ILIKE' / '~~*' +GlobToken <- 'GLOB' / '~~~' +SimilarToToken <- 'SIMILAR' 'TO' +RegexMatchToken <- '~' +RegexInsensitiveMatchToken <- '~*' +NotILikeOp <- '!~~*' +NotLikeOp <- '!~~' +NotRegexInsensitiveMatchOp <- '!~*' +NotSimilarToOp <- '!~' + +InClause <- 'IN' InExpression +InExpression <- InExpressionList / InSelectStatement / InContainsExpression +InContainsExpression <- OtherOperatorExpression +InExpressionList <- Parens(List(Expression)) +InSelectStatement <- Parens(SelectStatementInternal) +BetweenClause <- 'BETWEEN' OtherOperatorExpression 'AND' OtherOperatorExpression +# LEVEL 8 +OtherOperatorExpression <- BitwiseExpression OtherOperatorTail* +OtherOperatorTail <- OtherOperator BitwiseExpression +OtherOperator <- + AnyAllParsedOperator / NamedOtherOperator +AnyAllParsedOperator <- AnyAllOperator +NamedOtherOperator <- + QualifiedOperator / InetOperator / JsonOperator / ListOperator / StringOperator / OperatorLiteral +OperatorLiteral <- Identifier +AnyAllOperator <- AnyOp AnyOrAll +AnyOrAll <- SubqueryAny / SubqueryAll +SubqueryAny <- 'ANY' +SubqueryAll <- 'ALL' +InetOperator <- '>>=' / '<<=' +JsonOperator <- '->>' +ListOperator <- '&&' / '@>' / '<@' +StringOperator <- '^@' / '||' +QualifiedOperator <- 'OPERATOR' Parens(QualifiedOperatorContents) +QualifiedOperatorContents <- ColIdDot* AnyOp +AnyOp <- '!~~*' / '>>=' / '<<=' / '->>' / '!~~' / '!~*' / '~~*' / '~~~' / '~*' / '!~' / '^@' / '||' / '&&' / '@>' / '<@' / '<=' / '>=' / '<>' / '!=' / '==' / '<<' / '>>' / '//' / '**' / '->' / '~~' / '+' / '-' / '*' / '/' / '%' / '^' / '<' / '>' / '=' / '&' / '|' / '~' / '!' +# LEVEL 9 +BitwiseExpression <- AdditiveExpression BitwiseExpressionTail* +BitwiseExpressionTail <- BitOperator AdditiveExpression +BitOperator <- '&' / '|' / '<<' / '>>' +# LEVEL 10 +AdditiveExpression <- MultiplicativeExpression AdditiveExpressionTail* +AdditiveExpressionTail <- Term MultiplicativeExpression +Term <- '+' / '-' +# LEVEL 11 +MultiplicativeExpression <- ExponentiationExpression MultiplicativeExpressionTail* +MultiplicativeExpressionTail <- Factor ExponentiationExpression +Factor <- '*' / '/' / '//' / '%' +# LEVEL 12 +ExponentiationExpression <- CollateExpression ExponentiationExpressionTail* +ExponentiationExpressionTail <- ExponentOperator CollateExpression +ExponentOperator <- '^' / '**' +# LEVEL 13 +CollateExpression <- AtTimeZoneExpression CollateExpressionTail* +CollateExpressionTail <- CollateOperator AtTimeZoneExpression +CollateOperator <- 'COLLATE' +# LEVEL 14 +AtTimeZoneExpression <- PrefixExpression AtTimeZoneExpressionTail* +AtTimeZoneExpressionTail <- AtTimeZoneOperator PrefixExpression +AtTimeZoneOperator <- 'AT' 'TIME' 'ZONE' +# LEVEL 15 +PrefixExpression <- PrefixOperator* BaseExpression +PrefixOperator <- QualifiedOperator / MinusPrefixOperator / PlusPrefixOperator / TildePrefixOperator +MinusPrefixOperator <- '-' +PlusPrefixOperator <- '+' +TildePrefixOperator <- '~' +# LEVEL 16 (Highest) +BaseExpression <- SingleExpression IndirectionList? +IndirectionList <- Indirection+ + +Indirection <- CastOperator / DotOperator / SliceExpression / PostfixOperator +CastOperator <- '::' Type +DotOperator <- DotMethodOperator / DotColumnOperator +DotMethodOperator <- '.' MethodExpression +DotColumnOperator <- '.' ColLabel +MethodExpression <- ColLabel MethodExpressionArguments +MethodExpressionArguments <- Parens(MethodExpressionArgumentList) +MethodExpressionArgumentList <- DistinctOrAll? MethodFunctionArguments? OrderByClause? IgnoreOrRespectNulls? +MethodFunctionArguments <- List(FunctionArgument) +SliceExpression <- '[' SliceBound ']' +SliceBound <- Expression? EndSliceBound? StepSliceBound? +EndSliceBound <- ':' EndSliceValue? +EndSliceValue <- Expression / EndSliceMinus +EndSliceMinus <- '-' +StepSliceBound <- ':' Expression? +PostfixOperator <- '!' + + +SpecialFunctionExpression <- CoalesceExpression / UnpackExpression / TryExpression / ColumnsExpression / ExtractExpression / LambdaExpression / NullIfExpression / PositionExpression / RowExpression / SubstringExpression / TrimExpression / OverlayExpression +CoalesceExpression <- 'COALESCE' Parens(List(Expression)) +UnpackExpression <- 'UNPACK' Parens(Expression) +TryExpression <- 'TRY' Parens(Expression) +ColumnsExpression <- StarSymbol? 'COLUMNS' Parens(Expression) +ExtractExpression <- 'EXTRACT' Parens(ExtractArguments) +ExtractArguments <- ExtractArgument 'FROM' Expression +LambdaExpression <- 'LAMBDA' List(ColIdOrString) ':' Expression +NullIfExpression <- 'NULLIF' Parens(NullIfArguments) +NullIfArguments <- Expression ',' Expression +PositionExpression <- 'POSITION' Parens(PositionArguments) +PositionArguments <- OtherOperatorExpression 'IN' Expression +RowExpression <- 'ROW' Parens(List(Expression)?) +SubstringExpression <- 'SUBSTRING' Parens(SubstringArguments) +SubstringArguments <- SubstringParameters / SubstringExpressionList +SubstringExpressionList <- List(Expression) +SubstringParameters <- Expression SubstringFromFor +SubstringFromFor <- SubstringFromOptionalFor / SubstringFor +SubstringFromOptionalFor <- FromExpression ForExpression? +SubstringFor <- ForExpression +TrimExpression <- 'TRIM' Parens(TrimArguments) +TrimArguments <- TrimDirection? TrimSource? List(Expression) +TrimDirection <- TrimBoth / TrimLeading / TrimTrailing +TrimBoth <- 'BOTH' +TrimLeading <- 'LEADING' +TrimTrailing <- 'TRAILING' +TrimSource <- Expression? 'FROM' +OverlayExpression <- 'OVERLAY' Parens(OverlayArguments) +OverlayArguments <- OverlayParameters / OverlayExpressionList +OverlayParameters <- Expression 'PLACING' Expression FromExpression ForExpression? +FromExpression <- 'FROM' Expression +ForExpression <- 'FOR' Expression +OverlayExpressionList <- List(Expression) + +ExtractArgument <- ExtractDatePartArgument / ExtractIdentifierArgument / ExtractStringArgument +ExtractDatePartArgument <- ExtractDatePart +ExtractIdentifierArgument <- Identifier +ExtractStringArgument <- StringLiteral +ExtractDatePart <- + YearKeyword / MonthKeyword / DayKeyword / HourKeyword / MinuteKeyword / SecondKeyword / + MillisecondKeyword / MicrosecondKeyword / WeekKeyword / QuarterKeyword / DecadeKeyword / + CenturyKeyword / MillenniumKeyword diff --git a/internal/grammar/duckdb/statements/external_resource.gram b/internal/grammar/duckdb/statements/external_resource.gram new file mode 100644 index 0000000..b493a11 --- /dev/null +++ b/internal/grammar/duckdb/statements/external_resource.gram @@ -0,0 +1,11 @@ +ExternalResourceStatement <- CreateExternalResourceStmt / RegisterExternalResourceStmt / DestroyExternalResourceStmt / ShowExternalResourcesStmt + +CreateExternalResourceStmt <- 'CREATE' 'EXTERNAL' 'RESOURCE' StringLiteral AttachAlias? ExternalResourceCreationOptions? +RegisterExternalResourceStmt <- 'REGISTER' 'EXTERNAL' 'RESOURCE' StringLiteral AttachAlias? 'FROM' Expression +DestroyExternalResourceStmt <- 'DESTROY' 'EXTERNAL' 'RESOURCE' ColId +ShowExternalResourcesStmt <- 'SHOW' ShowAllModifier? 'EXTERNAL' 'RESOURCES' +ShowAllModifier <- 'ALL' + +# The recipe's create params. Its own rule rather than AttachOptions: the two option bags are +# distinct, and a statement can carry both. +ExternalResourceCreationOptions <- GenericCopyOptionList diff --git a/internal/grammar/duckdb/statements/insert.gram b/internal/grammar/duckdb/statements/insert.gram new file mode 100644 index 0000000..3e1ffa8 --- /dev/null +++ b/internal/grammar/duckdb/statements/insert.gram @@ -0,0 +1,34 @@ +InsertStatement <- WithClause? 'INSERT' OrAction? 'INTO' InsertTarget ByNameOrPosition? InsertColumnList? InsertValues OnConflictClause? ReturningClause? + +OrAction <- InsertOrReplace / InsertOrIgnore +InsertOrReplace <- 'OR' 'REPLACE' +InsertOrIgnore <- 'OR' 'IGNORE' +ByNameOrPosition <- InsertByNameOrder / InsertByPositionOrder +InsertByNameOrder <- 'BY' InsertByName +InsertByPositionOrder <- 'BY' InsertByPosition +InsertByName <- 'NAME' +InsertByPosition <- 'POSITION' + +InsertTarget <- BaseTableName InsertAlias? +InsertAlias <- 'AS' Identifier + +ColumnList <- List(ColId) +InsertColumnList <- Parens(ColumnList) + +InsertValues <- SelectInsertValues / DefaultValues +SelectInsertValues <- SelectStatementInternal +DefaultValues <- 'DEFAULT' 'VALUES' + +OnConflictClause <- 'ON' 'CONFLICT' OnConflictTarget? OnConflictAction + +OnConflictTarget <- OnConflictExpressionTarget / OnConflictIndexTarget +OnConflictExpressionTarget <- ColumnIdList WhereClause? +OnConflictIndexTarget <- 'ON' 'CONSTRAINT' ConstraintName + + +OnConflictAction <- OnConflictUpdate / OnConflictNothing + +OnConflictUpdate <- 'DO' 'UPDATE' 'SET' UpdateSetClause WhereClause? +OnConflictNothing <- 'DO' 'NOTHING' + +ReturningClause <- 'RETURNING' TargetList diff --git a/internal/grammar/duckdb/statements/load.gram b/internal/grammar/duckdb/statements/load.gram new file mode 100644 index 0000000..1659edb --- /dev/null +++ b/internal/grammar/duckdb/statements/load.gram @@ -0,0 +1,8 @@ +LoadStatement <- 'LOAD' ColIdOrString ExtensionAlias? +ExtensionAlias <- 'AS' Identifier +InstallStatement <- 'FORCE'? 'INSTALL' IdentifierOrStringLiteral FromSource? VersionNumber? +UpdateExtensionsStatement <- 'UPDATE' 'EXTENSIONS' Parens(List(Identifier))? +FromSource <- FromSourceIdentifier / FromSourceString +FromSourceIdentifier <- 'FROM' Identifier +FromSourceString <- 'FROM' StringLiteral +VersionNumber <- 'VERSION' IdentifierOrStringLiteral \ No newline at end of file diff --git a/internal/grammar/duckdb/statements/merge_into.gram b/internal/grammar/duckdb/statements/merge_into.gram new file mode 100644 index 0000000..a1ceb3c --- /dev/null +++ b/internal/grammar/duckdb/statements/merge_into.gram @@ -0,0 +1,27 @@ +MergeIntoStatement <- WithClause? 'MERGE' 'INTO' TargetOptAlias MergeIntoUsingClause JoinQualifier MergeMatch+ ReturningClause? +MergeIntoUsingClause <- 'USING' TableRef +MergeMatch <- MatchedClause / NotMatchedClause +MatchedClause <- 'WHEN' 'MATCHED' AndExpression? 'THEN' MatchedClauseAction +MatchedClauseAction <- UpdateMatchClause / DeleteMatchClause / InsertMatchClause / DoNothingMatchClause / ErrorMatchClause +UpdateMatchClause <- 'UPDATE' UpdateMatchInfo? +UpdateMatchInfo <- UpdateMatchSetAction / UpdateByNameOrPosition +UpdateMatchSetAction <- UpdateMatchSetClause +UpdateByNameOrPosition <- ByNameOrPosition +DeleteMatchClause <- 'DELETE' +InsertMatchClause <- 'INSERT' InsertMatchInfo? +InsertMatchInfo <- InsertValuesList / InsertDefaultValues / InsertByNameOrPosition +InsertDefaultValues <- 'DEFAULT' 'VALUES' +InsertByNameOrPosition <- ByNameOrPosition? '*'? +InsertValuesList <- InsertColumnList? 'VALUES' Parens(List(Expression)) +DoNothingMatchClause <- 'DO' 'NOTHING' +ErrorMatchClause <- 'ERROR' Expression? +UpdateMatchSetClause <- 'SET' UpdateMatchSetInfo +UpdateMatchSetInfo <- UpdateSetClause / StarSymbol +AndExpression <- 'AND' Expression +NotMatchedClause <- 'WHEN' 'NOT' 'MATCHED' BySourceOrTarget? AndExpression? 'THEN' MatchedClauseAction +BySourceOrTarget <- BySource / ByTarget +BySource <- 'BY' 'SOURCE' +ByTarget <- 'BY' 'TARGET' + + + diff --git a/internal/grammar/duckdb/statements/pivot.gram b/internal/grammar/duckdb/statements/pivot.gram new file mode 100644 index 0000000..6f2841f --- /dev/null +++ b/internal/grammar/duckdb/statements/pivot.gram @@ -0,0 +1,24 @@ +PivotStatement <- PivotKeyword TableRef PivotOn? PivotUsing? PivotGroupByList? + +PivotOn <- 'ON' PivotColumnList +PivotUsing <- 'USING' TargetList +PivotColumnList <- List(PivotColumnEntry) +PivotColumnEntry <- PivotColumnSubquery / PivotValueList / PivotColumnExpression +PivotColumnExpression <- Expression +PivotColumnSubquery <- BaseExpression 'IN' Parens(SelectStatementInternal) + +PivotKeyword <- 'PIVOT' / 'PIVOT_WIDER' +UnpivotKeyword <- 'UNPIVOT' / 'PIVOT_LONGER' + +UnpivotStatement <- UnpivotKeyword TableRef 'ON' TargetList IntoNameValues? + +IntoNameValues <- 'INTO' 'NAME' ColIdOrString ValueOrValues List(Identifier) + +ValueOrValues <- 'VALUE' / 'VALUES' + +IncludeOrExcludeNulls <- IncludeNulls / ExcludeNulls +IncludeNulls <- 'INCLUDE' 'NULLS' +ExcludeNulls <- 'EXCLUDE' 'NULLS' +UnpivotHeader <- UnpivotHeaderSingle / UnpivotHeaderList +UnpivotHeaderSingle <- ColIdOrString +UnpivotHeaderList <- Parens(List(ColIdOrString)) diff --git a/internal/grammar/duckdb/statements/pragma.gram b/internal/grammar/duckdb/statements/pragma.gram new file mode 100644 index 0000000..c07dc6f --- /dev/null +++ b/internal/grammar/duckdb/statements/pragma.gram @@ -0,0 +1,6 @@ +PragmaStatement <- 'PRAGMA' PragmaAssignOrFunction +PragmaAssignOrFunction <- PragmaAssign / PragmaFunction + +PragmaAssign <- SettingName '=' VariableList +PragmaFunction <- PragmaName PragmaParameters? +PragmaParameters <- Parens(List(Expression)) diff --git a/internal/grammar/duckdb/statements/prepare.gram b/internal/grammar/duckdb/statements/prepare.gram new file mode 100644 index 0000000..269b69f --- /dev/null +++ b/internal/grammar/duckdb/statements/prepare.gram @@ -0,0 +1,3 @@ +PrepareStatement <- 'PREPARE' Identifier TypeList? 'AS' Statement + +TypeList <- Parens(List(Type)) diff --git a/internal/grammar/duckdb/statements/select.gram b/internal/grammar/duckdb/statements/select.gram new file mode 100644 index 0000000..94cd199 --- /dev/null +++ b/internal/grammar/duckdb/statements/select.gram @@ -0,0 +1,215 @@ +SelectStatement <- SelectStatementInternal +SelectStatementInternal <- WithClause? SelectSetOpChain ResultModifiers? +SelectSetOpChain <- IntersectChain SelectSetOpChainTail* +SelectSetOpChainTail <- SetopClause IntersectChain +IntersectChain <- SelectAtom IntersectChainTail* +IntersectChainTail <- SetIntersectClause SelectAtom +SetIntersectClause <- 'INTERSECT' DistinctOrAll? +SelectAtom <- SelectParens / SelectStatementType + +SelectParens <- Parens(SelectStatementInternal) + +SetopClause <- SetopType DistinctOrAll? ByName? +SetopType <- SetopUnion / SetopExcept +SetopUnion <- 'UNION' +SetopExcept <- 'EXCEPT' +ByName <- 'BY' 'NAME' + +SelectStatementType <- OptionalParensSimpleSelect / ValuesClause / DescribeStatement / TableStatement / PivotStatement / UnpivotStatement +ResultModifiers <- OrderByClause? LimitOffset? +LimitOffset <- LimitOffsetClause / OffsetFetchClause / OffsetLimitClause / FetchOnlyClause +LimitOffsetClause <- LimitClause OffsetClause? +OffsetLimitClause <- OffsetClause LimitClause? +OffsetFetchClause <- OffsetClause FetchClause +FetchOnlyClause <- FetchClause +TableStatement <- 'TABLE' BaseTableName +OptionalParensSimpleSelect <- SimpleSelectParens / SimpleSelect +SimpleSelectParens <- Parens(SimpleSelect) +SimpleSelect <- SelectFrom WhereClause? GroupByClause? HavingClause? WindowClause? QualifyClause? SampleClause? + +SelectFrom <- SelectFromClause / FromSelectClause +SelectFromClause <- SelectClause FromClause? +FromSelectClause <- FromClause SelectClause? +WithStatement <- ColIdOrString InsertColumnList? UsingKey? 'AS' Materialized? CTEBody +CTEBody <- CTESelectBody / CTEDMLBody +CTESelectBody <- Parens(SelectStatementInternal) +CTEDMLBody <- Parens(Statement) +UsingKey <- 'USING' 'KEY' Parens(TargetList) +Materialized <- 'NOT'? 'MATERIALIZED' +WithClause <- 'WITH' Recursive? List(WithStatement) +Recursive <- 'RECURSIVE' +SelectClause <- 'SELECT' DistinctClause? TargetList? +TargetList <- List(AliasedExpression) +ColumnAliases <- Parens(List(ColIdOrString)) + +DistinctClause <- DistinctOn / DistinctAll +DistinctAll <- 'ALL' +DistinctOn <- 'DISTINCT' DistinctOnTargets? +DistinctOnTargets <- 'ON' Parens(List(Expression)) + +InnerTableRef <- ValuesRef / TableFunction / TableSubquery / BaseTableRef / ParensTableRef + +TableRef <- InnerTableRef JoinOrPivot* +TableSubquery <- Lateral? SubqueryReference TableAlias? +BaseTableRef <- TableAliasColon? BaseTableName TableAlias? AtClause? SampleClause? +TableAliasColon <- ColIdOrString ':' +ValuesRef <- ValuesClause TableAlias? +ParensTableRef <- TableAliasColon? Parens(TableRef) TableAlias? SampleClause? + +JoinOrPivot <- JoinClause / TablePivotClause / TableUnpivotClause + +TablePivotClause <- 'PIVOT' Parens(TablePivotClauseBody) TableAlias? +TablePivotClauseBody <- TargetList 'FOR' PivotValueList+ PivotGroupByList? +PivotGroupByList <- 'GROUP' 'BY' List(ColIdOrString) +TableUnpivotClause <- 'UNPIVOT' IncludeOrExcludeNulls? Parens(TableUnpivotClauseBody) TableAlias? +TableUnpivotClauseBody <- UnpivotHeader 'FOR' UnpivotValueList+ + +PivotHeader <- BaseExpression +PivotValueList <- PivotHeader 'IN' PivotValueTarget +PivotValueTarget <- PivotEnumTarget / PivotListTarget +PivotEnumTarget <- Identifier +PivotListTarget <- PivotTargetList +UnpivotValueList <- UnpivotHeader 'IN' UnpivotTargetList +PivotTargetList <- Parens(TargetList) +UnpivotTargetList <- Parens(TargetList) + +Lateral <- 'LATERAL' + +BaseTableName <- QualifiedTableName / UnqualifiedBaseTableName +UnqualifiedBaseTableName <- TableName +QualifiedTableName <- CatalogReservedSchemaTable / SchemaReservedTable +SchemaReservedTable <- SchemaQualification ReservedTableName +CatalogReservedSchemaTable <- CatalogQualification ReservedSchemaQualification ReservedTableName + +TableFunction <- TableFunctionLateralOpt / TableFunctionAliasColon +TableFunctionLateralOpt <- Lateral? QualifiedTableFunction TableFunctionArguments WithOrdinality? TableAlias? +TableFunctionAliasColon <- TableAliasColon QualifiedTableFunction TableFunctionArguments WithOrdinality? SampleClause? +WithOrdinality <- 'WITH' 'ORDINALITY' +QualifiedTableFunction <- CatalogQualification? SchemaQualification? TableFunctionName +TableFunctionArguments <- Parens(List(FunctionArgument)?) +FunctionArgument <- NamedFunctionArgument / PositionalFunctionArgument +NamedFunctionArgument <- NamedParameter +PositionalFunctionArgument <- Expression +NamedParameter <- TypeFuncName Type? NamedParameterAssignment Expression +NamedParameterAssignment <- ':=' / '=>' + +TableAlias <- TableAliasAs / TableAliasWithoutAs +TableAliasAs <- 'AS' IdentifierOrStringLiteral ColumnAliases? +TableAliasWithoutAs <- Identifier ColumnAliases? + +AtClause <- 'AT' Parens(AtSpecifier) +AtSpecifier <- AtUnit '=>' Expression +AtUnit <- VersionAtUnit / TimestampAtUnit +VersionAtUnit <- 'VERSION' +TimestampAtUnit <- 'TIMESTAMP' + +JoinClause <- JoinByClause / RegularJoinClause / JoinWithoutOnClause / NearestJoinClause +# NEAREST BY has two alternatives so PEG can backtrack: the bare form uses alias-less target mirrors (tried +# first, so an unaliased target does not greedily consume NEAREST/APPROX/EXACT as an alias), and the aliased +# form falls back to a full TableRef when a real alias identifier follows the target. +NearestJoinClause <- NearestJoinBare / NearestJoinAliased +NearestJoinAliased <- JoinType? 'JOIN' TableRef ApproxOrExact? 'NEAREST' NumberLiteral? 'BY' DistanceOrSimilarity Expression +NearestJoinBare <- JoinType? 'JOIN' NearestBareTableRef ApproxOrExact? 'NEAREST' NumberLiteral? 'BY' DistanceOrSimilarity Expression +NearestBareTableRef <- NearestValuesRef / NearestTableFunction / NearestTableSubquery / NearestBaseTableRef / NearestParensTableRef +NearestValuesRef <- ValuesClause +NearestTableFunction <- Lateral? QualifiedTableFunction TableFunctionArguments WithOrdinality? +NearestTableSubquery <- Lateral? SubqueryReference +NearestBaseTableRef <- BaseTableName AtClause? SampleClause? +NearestParensTableRef <- Parens(TableRef) SampleClause? +ApproxOrExact <- NearestApprox / NearestExact +NearestApprox <- 'APPROX' +NearestExact <- 'EXACT' +DistanceOrSimilarity <- NearestDistance / NearestSimilarity +NearestDistance <- 'DISTANCE' +NearestSimilarity <- 'SIMILARITY' +RegularJoinClause <- Asof? JoinType? 'JOIN' TableRef JoinQualifier +JoinByClause <- 'JOIN' 'BY' Parens('TYPE' ColLabel) TableRef JoinQualifier +Asof <- 'ASOF' +JoinWithoutOnClause <- JoinPrefix 'JOIN' InnerTableRef +JoinQualifier <- OnClause / UsingClause +OnClause <- 'ON' Expression +UsingClause <- 'USING' Parens(List(ColumnName)) + +JoinType <- FullJoin / LeftJoin / RightJoin / SemiJoin / AntiJoin / InnerJoin +JoinPrefix <- CrossJoinPrefix / NaturalJoinPrefix / PositionalJoinPrefix +CrossJoinPrefix <- 'CROSS' +NaturalJoinPrefix <- 'NATURAL' JoinType? +PositionalJoinPrefix <- 'POSITIONAL' +FullJoin <- 'FULL' 'OUTER'? +LeftJoin <- 'LEFT' 'OUTER'? +RightJoin <- 'RIGHT' 'OUTER'? +SemiJoin <- 'SEMI' +AntiJoin <- 'ANTI' +InnerJoin <- 'INNER' + +FromClause <- 'FROM' List(TableRef) +WhereClause <- 'WHERE' Expression +GroupByClause <- 'GROUP' 'BY' GroupByExpressions +HavingClause <- 'HAVING' Expression +QualifyClause <- 'QUALIFY' Expression +SampleClause <- (TableSample / UsingSample) SampleEntry +UsingSample <- 'USING' 'SAMPLE' +TableSample <- 'TABLESAMPLE' +WindowClause <- 'WINDOW' List(WindowDefinition) +WindowDefinition <- Identifier 'AS' WindowFrameDefinition + +SampleEntry <- SampleEntryFunction / SampleEntryCount +SampleEntryCount <- SampleCount Parens(SampleProperties)? +SampleEntryFunction <- SampleFunction? Parens(SampleCount) RepeatableSample? +SampleFunction <- ColId +SampleProperties <- ColId (',' SampleSeed)? +RepeatableSample <- 'REPEATABLE' Parens(SampleSeed) + +SampleSeed <- NumberLiteral + +SampleCount <- SampleValue SampleUnit? +SampleValue <- NumberLiteral / Parameter +SampleUnit <- SamplePercentage / SampleRows +SamplePercentage <- '%' / 'PERCENT' +SampleRows <- 'ROWS' + +GroupByExpressions <- GroupByList / GroupByAll +GroupByAll <- 'ALL' +GroupByList <- List(GroupByExpression) +GroupByExpression <- EmptyGroupingItem / CubeOrRollupClause / GroupingSetsClause / GroupByBaseExpression +GroupByBaseExpression <- Expression +EmptyGroupingItem <- '(' ')' +CubeOrRollupClause <- CubeOrRollup Parens(List(Expression)?) +CubeOrRollup <- CubeKeyword / RollupKeyword +CubeKeyword <- 'CUBE' +RollupKeyword <- 'ROLLUP' +GroupingSetsClause <- 'GROUPING' 'SETS' Parens(List(GroupByExpression)) + +SubqueryReference <- Parens(SelectStatementInternal) + +OrderByExpression <- Expression DescOrAsc? NullsFirstOrLast? +DescOrAsc <- DescendingOrder / AscendingOrder +DescendingOrder <- 'DESC' / 'DESCENDING' +AscendingOrder <- 'ASC' / 'ASCENDING' +NullsFirstOrLast <- NullsFirst / NullsLast +NullsFirst <- 'NULLS' 'FIRST' +NullsLast <- 'NULLS' 'LAST' +OrderByClause <- 'ORDER' 'BY' OrderByExpressions +OrderByExpressions <- OrderByAll / OrderByExpressionList +OrderByExpressionList <- List(OrderByExpression) +OrderByAll <- 'ALL' DescOrAsc? NullsFirstOrLast? + +LimitClause <- 'LIMIT' LimitValue +OffsetClause <- 'OFFSET' OffsetValue +OffsetValue <- Expression RowOrRows? +RowOrRows <- 'ROW' / 'ROWS' +LimitValue <- LimitAll / LimitLiteralPercent / LimitExpression +LimitAll <- 'ALL' +LimitLiteralPercent <- NumberLiteral 'PERCENT' +LimitExpression <- Expression '%'? +FetchClause <- 'FETCH' FirstOrNext FetchValue RowOrRows 'ONLY' +FirstOrNext <- 'FIRST' / 'NEXT' +FetchValue <- Expression + +AliasedExpression <- ColIdExpression / ExpressionAsCollabel / ExpressionOptIdentifier +ColIdExpression <- ColId ':' Expression +ExpressionAsCollabel <- Expression 'AS' ColLabelOrString +ExpressionOptIdentifier <- Expression Identifier? + +ValuesClause <- 'VALUES' List(ValuesExpressions) +ValuesExpressions <- Parens(List(Expression)) diff --git a/internal/grammar/duckdb/statements/set.gram b/internal/grammar/duckdb/statements/set.gram new file mode 100644 index 0000000..a5d302a --- /dev/null +++ b/internal/grammar/duckdb/statements/set.gram @@ -0,0 +1,30 @@ +SetStatement <- 'SET' SetAssignmentOrTimeZone +SetAssignmentOrTimeZone <- SetSchema / StandardAssignment / SetTimeZone + +ResetStatement <- 'RESET' SetVariableOrSetting +SetSchema <- 'SCHEMA' StringLiteral +StandardAssignment <- SetVariableOrSetting SetAssignment +SetVariableOrSetting <- SetVariable / SetSetting +SetTimeZone <- 'TIME' 'ZONE' ZoneValue + +ZoneValue <- ZoneIntervalWithPrecision / ZoneIntervalWithInterval / ZoneLocal / ZoneDefault / ZoneStringLiteral / ZoneIdentifier / NumberLiteral +ZoneLocal <- 'LOCAL' +ZoneDefault <- 'DEFAULT' +ZoneStringLiteral <- StringLiteral +ZoneIdentifier <- Identifier +ZoneIntervalWithInterval <- 'INTERVAL' StringLiteral Interval? +ZoneIntervalWithPrecision <- 'INTERVAL' Parens(NumberLiteral) StringLiteral + +SetSetting <- SettingScope? SettingName +SetVariable <- VariableScope Identifier +VariableScope <- 'VARIABLE' + +SettingScope <- LocalScope / SessionScope / GlobalScope +LocalScope <- 'LOCAL' +SessionScope <- 'SESSION' +GlobalScope <- 'GLOBAL' + +SetAssignment <- VariableAssign VariableList + +VariableAssign <- '=' / 'TO' +VariableList <- List(Expression) diff --git a/internal/grammar/duckdb/statements/transaction.gram b/internal/grammar/duckdb/statements/transaction.gram new file mode 100644 index 0000000..607062c --- /dev/null +++ b/internal/grammar/duckdb/statements/transaction.gram @@ -0,0 +1,14 @@ +TransactionStatement <- BeginTransaction / RollbackTransaction / CommitTransaction + +BeginTransaction <- StartOrBegin Transaction? ReadOrWrite? +RollbackTransaction <- AbortOrRollback Transaction? +CommitTransaction <- CommitOrEnd Transaction? + +StartOrBegin <- 'START' / 'BEGIN' +Transaction <- 'WORK' / 'TRANSACTION' +ReadOrWrite <- 'READ' ReadOnlyOrReadWrite +ReadOnlyOrReadWrite <- ReadOnly / ReadWrite +ReadOnly <- 'ONLY' +ReadWrite <- 'WRITE' +AbortOrRollback <- 'ABORT' / 'ROLLBACK' +CommitOrEnd <- 'COMMIT' / 'END' \ No newline at end of file diff --git a/internal/grammar/duckdb/statements/update.gram b/internal/grammar/duckdb/statements/update.gram new file mode 100644 index 0000000..70a734b --- /dev/null +++ b/internal/grammar/duckdb/statements/update.gram @@ -0,0 +1,11 @@ +UpdateStatement <- WithClause? 'UPDATE' UpdateTarget UpdateSetClause FromClause? WhereClause? ReturningClause? + +UpdateTarget <- BaseTableSet / BaseTableAliasSet +BaseTableSet <- BaseTableName 'SET' +BaseTableAliasSet <- BaseTableName UpdateAlias? 'SET' +UpdateAlias <- 'AS'? ColId +UpdateSetClause <- UpdateSetElementList / UpdateSetTuple +UpdateSetTuple <- Parens(List(ColumnName)) '=' Expression +UpdateSetElementList <- List(UpdateSetElement) +UpdateSetElement <- UpdateSetColumnTarget '=' Expression +UpdateSetColumnTarget <- ColumnName DotIdentifier* diff --git a/internal/grammar/duckdb/statements/use.gram b/internal/grammar/duckdb/statements/use.gram new file mode 100644 index 0000000..4336370 --- /dev/null +++ b/internal/grammar/duckdb/statements/use.gram @@ -0,0 +1,7 @@ +UseStatement <- 'USE' UseTarget + +UseTarget <- UseTargetCatalogSchema / SchemaNameAsUseTarget / CatalogNameAsUseTarget +SchemaNameAsUseTarget <- SchemaName +CatalogNameAsUseTarget <- CatalogName +UseTargetCatalogSchema <- CatalogName '.' ReservedSchemaName DotIdentifier* +DotIdentifier <- '.' Identifier diff --git a/internal/grammar/duckdb/statements/vacuum.gram b/internal/grammar/duckdb/statements/vacuum.gram new file mode 100644 index 0000000..b2b532e --- /dev/null +++ b/internal/grammar/duckdb/statements/vacuum.gram @@ -0,0 +1,13 @@ +VacuumStatement <- 'VACUUM' VacuumOptions? AnalyzeTarget? +VacuumOptions <- VacuumParensOptions / VacuumLegacyOptions + +VacuumParensOptions <- Parens(List(VacuumOption)) +VacuumLegacyOptions <- OptFull? OptFreeze? OptVerbose? OptAnalyze? +VacuumOption <- OptAnalyze / OptFreeze / OptFull / OptVerbose / Identifier + +OptAnalyze <- AnalyzeKeyword +OptFull <- 'FULL' +OptFreeze <- 'FREEZE' +OptVerbose <- 'VERBOSE' + +NameList <- Parens(List(ColId)) diff --git a/internal/grammar/embed.go b/internal/grammar/embed.go new file mode 100644 index 0000000..e2a7652 --- /dev/null +++ b/internal/grammar/embed.go @@ -0,0 +1,152 @@ +// Package grammar embeds the DuckDB PEG grammar vendored from the pinned +// upstream commit and loads it into rule objects. It is a port of DuckDB's +// src/parser/peg/peg_parser.cpp and parsed_grammar.cpp, plus the grammar +// assembly performed upstream by scripts/parser/inline_grammar.py. +package grammar + +import ( + "embed" + "fmt" + "sort" + "strings" + "sync" +) + +//go:embed duckdb/statements/*.gram duckdb/keywords/*.list +var files embed.FS + +// KeywordList names one vendored keyword .list file. +type KeywordList struct { + // File is the vendored file name, e.g. "reserved_keyword.list". + File string + // RuleName is the grammar rule the list becomes when the grammar is + // assembled, e.g. "ReservedKeyword" (upstream: filename_to_upper_camel). + RuleName string +} + +// KeywordLists enumerates the five vendored keyword lists in the order the +// assembly step visits them (sorted by file name, as upstream does). +func KeywordLists() []KeywordList { + return []KeywordList{ + {File: "column_name_keyword.list", RuleName: "ColumnNameKeyword"}, + {File: "func_name_keyword.list", RuleName: "FuncNameKeyword"}, + {File: "reserved_keyword.list", RuleName: "ReservedKeyword"}, + {File: "type_name_keyword.list", RuleName: "TypeNameKeyword"}, + {File: "unreserved_keyword.list", RuleName: "UnreservedKeyword"}, + } +} + +// Keywords returns the keywords of one vendored list, lowercased, in file +// order (upstream lowercases on load; the lists are already lower-case). +func Keywords(list string) ([]string, error) { + data, err := files.ReadFile("duckdb/keywords/" + list) + if err != nil { + return nil, err + } + var result []string + for _, line := range strings.Split(string(data), "\n") { + line = strings.TrimSpace(line) + if line == "" { + continue + } + result = append(result, strings.ToLower(line)) + } + return result, nil +} + +// GrammarFiles returns the vendored .gram file names, sorted. +func GrammarFiles() ([]string, error) { + entries, err := files.ReadDir("duckdb/statements") + if err != nil { + return nil, err + } + var names []string + for _, e := range entries { + if strings.HasSuffix(e.Name(), ".gram") { + names = append(names, e.Name()) + } + } + sort.Strings(names) + return names, nil +} + +// AssembledText builds the complete grammar text the same way upstream's +// inline_grammar.py does: common.gram first, then each keyword list rendered +// as an ordered-choice rule of quoted keywords, then the remaining .gram +// files in sorted order. +func AssembledText() (string, error) { + var sb strings.Builder + + common, err := files.ReadFile("duckdb/statements/common.gram") + if err != nil { + return "", err + } + sb.Write(common) + sb.WriteString("\n") + + for _, list := range KeywordLists() { + keywords, err := Keywords(list.File) + if err != nil { + return "", err + } + sb.WriteString(list.RuleName) + sb.WriteString(" <- ") + for i, kw := range keywords { + if i > 0 { + sb.WriteString(" /\n") + } + sb.WriteString("'") + sb.WriteString(kw) + sb.WriteString("'") + } + sb.WriteString("\n") + } + + names, err := GrammarFiles() + if err != nil { + return "", err + } + for _, name := range names { + if name == "common.gram" { + continue + } + data, err := files.ReadFile("duckdb/statements/" + name) + if err != nil { + return "", err + } + sb.Write(data) + sb.WriteString("\n") + } + return sb.String(), nil +} + +var ( + loadOnce sync.Once + loaded *Grammar + loadErr error +) + +// Load parses the embedded grammar once and returns the immutable result. +// The returned Grammar is safe for concurrent use. +func Load() (*Grammar, error) { + loadOnce.Do(func() { + text, err := AssembledText() + if err != nil { + loadErr = err + return + } + g, err := Parse(text) + if err != nil { + loadErr = fmt.Errorf("parsing embedded grammar: %w", err) + return + } + // Upstream's ParsedGrammar::CreateDefault adds an empty EndOfInput + // rule when the grammar text does not define one; the matcher + // satisfies it with a rule override. + if g.Rule("EndOfInput") == nil { + g.addRule(&Rule{Name: "EndOfInput"}) + } + loaded = g + }) + return loaded, loadErr +} diff --git a/internal/grammar/grammar_test.go b/internal/grammar/grammar_test.go new file mode 100644 index 0000000..e55d66b --- /dev/null +++ b/internal/grammar/grammar_test.go @@ -0,0 +1,219 @@ +package grammar + +import ( + "strings" + "testing" +) + +// Loading the vendored grammar cleanly is itself the milestone-1 gate. +func TestLoadVendoredGrammar(t *testing.T) { + g, err := Load() + if err != nil { + t.Fatalf("Load: %v", err) + } + for _, name := range []string{"Program", "TopLevelStatement", "Statement", "Expression", "List", "Parens", "EndOfInput", "%whitespace"} { + if g.Rule(name) == nil { + t.Errorf("rule %q missing", name) + } + } + // the keyword lists become ordered-choice rules during assembly + for _, list := range KeywordLists() { + rule := g.Rule(list.RuleName) + if rule == nil { + t.Errorf("keyword rule %q missing", list.RuleName) + continue + } + words, err := Keywords(list.File) + if err != nil { + t.Fatal(err) + } + literals := 0 + for _, tok := range rule.Tokens { + if tok.Type == Literal { + literals++ + } + } + if literals != len(words) { + t.Errorf("keyword rule %q has %d literals, want %d", list.RuleName, literals, len(words)) + } + } +} + +// Every rule reference must resolve to a defined rule. EndOfInput is +// satisfied by a rule override; %whitespace is character-level and never +// referenced (the tokenizer handles whitespace). +func TestAllReferencesDefined(t *testing.T) { + g, err := Load() + if err != nil { + t.Fatal(err) + } + for _, name := range g.RuleNames() { + rule := g.Rule(name) + for _, tok := range rule.Tokens { + if tok.Type != Reference && tok.Type != FunctionCall { + continue + } + if _, isParam := rule.Parameters[tok.Text]; isParam { + continue + } + if g.Rule(tok.Text) == nil { + t.Errorf("rule %q references undefined rule %q", name, tok.Text) + } + } + } +} + +func TestRuleNamesCaseInsensitive(t *testing.T) { + g, err := Load() + if err != nil { + t.Fatal(err) + } + if g.Rule("program") == nil || g.Rule("PROGRAM") == nil { + t.Error("rule lookup should be case-insensitive") + } +} + +func TestParseBasics(t *testing.T) { + g, err := Parse("Rule <- 'A' Other / 'B'\nOther <- 'C'?\n") + if err != nil { + t.Fatal(err) + } + rule := g.Rule("Rule") + if rule == nil { + t.Fatal("Rule missing") + } + want := []Token{ + {Literal, "A"}, + {Reference, "Other"}, + {Operator, "/"}, + {Literal, "B"}, + } + if len(rule.Tokens) != len(want) { + t.Fatalf("tokens = %v, want %v", rule.Tokens, want) + } + for i, w := range want { + if rule.Tokens[i] != w { + t.Errorf("token[%d] = %v, want %v", i, rule.Tokens[i], w) + } + } +} + +func TestParseParameterizedRule(t *testing.T) { + g, err := Parse("List(D) <- D (',' D)* ','?\n") + if err != nil { + t.Fatal(err) + } + rule := g.Rule("List") + if rule == nil { + t.Fatal("List missing") + } + if len(rule.Parameters) != 1 || rule.Parameters["D"] != 0 { + t.Errorf("parameters = %v", rule.Parameters) + } +} + +func TestParseNestedFunctionCalls(t *testing.T) { + g, err := Parse("R <- Parens(List(Expression))\n") + if err != nil { + t.Fatal(err) + } + rule := g.Rule("R") + want := []Token{ + {FunctionCall, "Parens"}, + {FunctionCall, "List"}, + {Reference, "Expression"}, + {Operator, ")"}, + {Operator, ")"}, + } + for i, w := range want { + if rule.Tokens[i] != w { + t.Errorf("token[%d] = %v, want %v", i, rule.Tokens[i], w) + } + } +} + +func TestParseComments(t *testing.T) { + g, err := Parse("# leading comment\nR <- 'A' # trailing comment\nS <- 'B'\n") + if err != nil { + t.Fatal(err) + } + if g.Rule("R") == nil || g.Rule("S") == nil { + t.Error("comment handling dropped a rule") + } + if len(g.Rule("R").Tokens) != 1 { + t.Errorf("R tokens = %v", g.Rule("R").Tokens) + } +} + +func TestParsePercentRule(t *testing.T) { + g, err := Parse("%whitespace <- [ \\t\\n\\r]*\n") + if err != nil { + t.Fatal(err) + } + rule := g.Rule("%whitespace") + if rule == nil { + t.Fatal("%whitespace missing") + } + if rule.Tokens[0].Type != Regex { + t.Errorf("tokens = %v", rule.Tokens) + } +} + +func TestParseNegativeLookahead(t *testing.T) { + g, err := Parse("R <- !'A' Ident\nIdent <- 'B'\n") + if err != nil { + t.Fatal(err) + } + rule := g.Rule("R") + if rule.Tokens[0] != (Token{Operator, "!"}) { + t.Errorf("negative lookahead not parsed: %v", rule.Tokens) + } +} + +func TestParseMultiLineChoice(t *testing.T) { + // a trailing '/' continues the rule across the newline + g, err := Parse("R <- 'A' /\n 'B'\nS <- 'C'\n") + if err != nil { + t.Fatal(err) + } + if len(g.Rule("R").Tokens) != 3 { + t.Errorf("R tokens = %v", g.Rule("R").Tokens) + } + if g.Rule("S") == nil { + t.Error("S missing") + } +} + +func TestParseErrors(t *testing.T) { + for _, tc := range []struct { + text string + want string + }{ + {"R <- 'A'\nR <- 'B'\n", "duplicate rule name"}, + {"R <- 'A", "did not find closing"}, + {"R <- 'A'i\n", "unexpected \"i\""}, + {"<- 'A'\n", "expected an alpha-numeric rule name"}, + {"R\n", "does not have a definition"}, + // a stray ')' errors at grammar-parse time; an unbalanced '(' is + // only caught later, when the matcher factory compiles the rule + {"R <- 'A')\n", "unclosed bracket"}, + } { + _, err := Parse(tc.text) + if err == nil || !strings.Contains(err.Error(), tc.want) { + t.Errorf("Parse(%q) err = %v, want containing %q", tc.text, err, tc.want) + } + } +} + +func TestParseSingleRule(t *testing.T) { + rule, err := ParseSingleRule("R <- 'A' 'B'\n") + if err != nil { + t.Fatal(err) + } + if rule.Name != "R" || len(rule.Tokens) != 2 { + t.Errorf("rule = %+v", rule) + } + if _, err := ParseSingleRule("R <- 'A'\nS <- 'B'\n"); err == nil { + t.Error("two rules accepted by ParseSingleRule") + } +} diff --git a/internal/grammar/parser.go b/internal/grammar/parser.go new file mode 100644 index 0000000..2f21144 --- /dev/null +++ b/internal/grammar/parser.go @@ -0,0 +1,300 @@ +package grammar + +import ( + "fmt" + "strings" +) + +// TokenType classifies one token of a rule definition. +// Port of duckdb PEGTokenType (peg_parser.hpp). +type TokenType int + +const ( + // Literal is a quoted literal token ('Keyword'). + Literal TokenType = iota + // Reference is a reference to another rule (Rule). + Reference + // Operator is a grammar operator (/ ? * + ( ) !). + Operator + // FunctionCall is the start of a parameterized-rule call (List(...)). + FunctionCall + // Regex is a character-class token ([^'] or <[a-z_]i[a-z0-9_]i*>). + Regex +) + +// Token is one token of a rule definition. +type Token struct { + Type TokenType + Text string +} + +// Rule is a parsed grammar rule: a name, optional parameters (for macros +// such as List(D)), and the flat token stream of its definition. Port of +// duckdb PEGRule. +type Rule struct { + Name string + // Parameters maps parameter name to position. Upstream supports at most + // one parameter per rule; the matcher factory enforces that. + Parameters map[string]int + Tokens []Token +} + +// Grammar is an immutable set of parsed rules, keyed case-insensitively by +// rule name (upstream uses case_insensitive_map_t). Port of duckdb +// ParsedGrammar. +type Grammar struct { + rules map[string]*Rule // key: lower-cased rule name + names []string // insertion order, original spelling +} + +// Rule returns the rule with the given name (case-insensitive), or nil. +func (g *Grammar) Rule(name string) *Rule { + return g.rules[strings.ToLower(name)] +} + +// RuleNames returns all rule names in insertion order. +func (g *Grammar) RuleNames() []string { + return append([]string(nil), g.names...) +} + +func (g *Grammar) addRule(rule *Rule) error { + key := strings.ToLower(rule.Name) + if _, ok := g.rules[key]; ok { + return fmt.Errorf("failed to parse grammar - duplicate rule name %s", rule.Name) + } + g.rules[key] = rule + g.names = append(g.names, rule.Name) + return nil +} + +// Parse parses PEG grammar text into rules. It is a direct port of duckdb +// PEGParser::ParseRules (peg_parser.cpp): a small state machine over the +// characters of the grammar text that produces, per rule, a flat token +// stream. Structure (grouping, choice, repetition) is interpreted later by +// the matcher factory, exactly as upstream does. +func Parse(text string) (*Grammar, error) { + p := &pegParser{grammar: &Grammar{rules: make(map[string]*Rule)}} + if err := p.parseRules(text); err != nil { + return nil, err + } + return p.grammar, nil +} + +// ParseSingleRule parses text that must contain exactly one rule definition. +// Port of duckdb ParsedGrammar::ParseSingleRule. +func ParseSingleRule(text string) (*Rule, error) { + g, err := Parse(text) + if err != nil { + return nil, err + } + if len(g.names) != 1 { + return nil, fmt.Errorf("expected exactly one PEG rule definition") + } + return g.Rule(g.names[0]), nil +} + +type parseState int + +const ( + stateRuleName parseState = iota + stateRuleSeparator + stateRuleDefinition +) + +type pegParser struct { + grammar *Grammar +} + +func isSpace(c byte) bool { + return c == ' ' || c == '\t' || c == '\n' || c == '\v' || c == '\f' || c == '\r' +} + +func isNewline(c byte) bool { + return c == '\n' || c == '\r' +} + +func isAlphaNumeric(c byte) bool { + return (c >= 'A' && c <= 'Z') || (c >= 'a' && c <= 'z') || (c >= '0' && c <= '9') +} + +func isPEGOperator(c byte) bool { + switch c { + case '/', '?', '(', ')', '*', '+', '!': + return true + default: + return false + } +} + +func (p *pegParser) parseRules(grammar string) error { + var ruleName string + rule := &Rule{} + state := stateRuleName + bracketCount := 0 + inOrClause := false + + c := 0 + n := len(grammar) + for c < n { + if grammar[c] == '#' { + // comment - ignore until EOL + for c < n && !isNewline(grammar[c]) { + c++ + } + continue + } + if state == stateRuleDefinition && isNewline(grammar[c]) && bracketCount == 0 && + !inOrClause && len(rule.Tokens) > 0 { + // a newline while parsing a rule definition completes the rule + rule.Name = ruleName + if err := p.grammar.addRule(rule); err != nil { + return err + } + rule = &Rule{} + ruleName = "" + state = stateRuleName + c++ + continue + } + if isSpace(grammar[c]) { + c++ + continue + } + switch state { + case stateRuleName: + startPos := c + if grammar[c] == '%' { + // rules can start with % (%whitespace) + c++ + } + for c < n && isAlphaNumeric(grammar[c]) { + c++ + } + if c == startPos { + return fmt.Errorf("failed to parse grammar - expected an alpha-numeric rule name (pos %d)", c) + } + ruleName = grammar[startPos:c] + rule = &Rule{} + state = stateRuleSeparator + case stateRuleSeparator: + if grammar[c] == '(' { + if len(rule.Parameters) > 0 { + return fmt.Errorf("failed to parse grammar - multiple parameters at position %d", c) + } + c++ + parameterStart := c + for c < n && isAlphaNumeric(grammar[c]) { + c++ + } + if parameterStart == c { + return fmt.Errorf("failed to parse grammar - expected a parameter at position %d", c) + } + if rule.Parameters == nil { + rule.Parameters = make(map[string]int) + } + rule.Parameters[grammar[parameterStart:c]] = len(rule.Parameters) + if c >= n || grammar[c] != ')' { + return fmt.Errorf("failed to parse grammar - expected closing bracket at position %d", c) + } + c++ + } else { + if c+1 >= n || grammar[c] != '<' || grammar[c+1] != '-' { + return fmt.Errorf("failed to parse grammar - expected a rule definition (<-) (pos %d)", c) + } + c += 2 + state = stateRuleDefinition + } + case stateRuleDefinition: + inOrClause = false + switch { + case grammar[c] == '\'': + // parse literal + c++ + literalStart := c + for c < n && grammar[c] != '\'' { + if grammar[c] == '\\' { + // escape + c++ + } + c++ + } + if c >= n { + return fmt.Errorf("failed to parse grammar - did not find closing ' (pos %d)", c) + } + rule.Tokens = append(rule.Tokens, Token{Type: Literal, Text: grammar[literalStart:c]}) + c++ + if c < n && grammar[c] == 'i' { + return fmt.Errorf("failed to parse grammar - unexpected \"i\" found in grammar near rule %s", ruleName) + } + case isAlphaNumeric(grammar[c]): + // alphanumeric character - this is a rule reference + ruleStart := c + for c < n && isAlphaNumeric(grammar[c]) { + c++ + } + tok := Token{Text: grammar[ruleStart:c]} + if c < n && grammar[c] == '(' { + // this is a function call + c++ + bracketCount++ + tok.Type = FunctionCall + } else { + tok.Type = Reference + } + rule.Tokens = append(rule.Tokens, tok) + case grammar[c] == '[' || grammar[c] == '<': + // character class - [^'] or <...> + ruleStart := c + finalChar := byte(']') + if grammar[c] == '<' { + finalChar = '>' + } + for c < n && grammar[c] != finalChar { + if grammar[c] == '\\' { + // handle escapes + c++ + } + if c < n { + c++ + } + } + c++ + end := c + if end > n { + end = n + } + rule.Tokens = append(rule.Tokens, Token{Type: Regex, Text: grammar[ruleStart:end]}) + case isPEGOperator(grammar[c]): + switch grammar[c] { + case '(': + bracketCount++ + case ')': + if bracketCount == 0 { + return fmt.Errorf("failed to parse grammar - unclosed bracket at position %d in rule %s", c, ruleName) + } + bracketCount-- + case '/': + inOrClause = true + } + // operators are always length 1 + rule.Tokens = append(rule.Tokens, Token{Type: Operator, Text: grammar[c : c+1]}) + c++ + default: + return fmt.Errorf("unrecognized rule contents in rule %s (character %s)", ruleName, grammar[c:c+1]) + } + } + } + if state == stateRuleSeparator { + return fmt.Errorf("failed to parse grammar - rule %s does not have a definition", ruleName) + } + if state == stateRuleDefinition { + if len(rule.Tokens) == 0 { + return fmt.Errorf("failed to parse grammar - rule %s is empty", ruleName) + } + rule.Name = ruleName + if err := p.grammar.addRule(rule); err != nil { + return err + } + } + return nil +} diff --git a/internal/matcher/engine.go b/internal/matcher/engine.go new file mode 100644 index 0000000..0116709 --- /dev/null +++ b/internal/matcher/engine.go @@ -0,0 +1,152 @@ +package matcher + +import ( + "fmt" + "sync" + + "github.com/sqlc-dev/darkwing/internal/grammar" + "github.com/sqlc-dev/darkwing/token" +) + +// SyntaxError reports a failed match: the furthest token the matcher +// reached, upstream's "syntax error at or near" basis. +type SyntaxError struct { + // Token is the token at or near the failure (never the end-of-input + // sentinel when a real token precedes it). + Token token.Token +} + +func (e *SyntaxError) Error() string { + return fmt.Sprintf("syntax error at or near %q", e.Token.Text) +} + +// MatchError is a non-positional matching error, mirroring the +// ParserException upstream throws from inside a matcher (currently only +// the double-exponent number literal case). +type MatchError struct { + Msg string +} + +func (e *MatchError) Error() string { + return e.Msg +} + +// Engine is an immutable compiled grammar, safe for concurrent use. Each +// Match call gets its own packrat cache, as upstream does per top-level +// statement. +type Engine struct { + root matcher + topLevel matcher +} + +// New compiles g starting from rootRule. Rules unreachable from rootRule +// are not compiled (matching upstream's lazy CreateMatcher recursion); the +// standard rule overrides and packrat memoization list are always +// installed first. +func New(g *grammar.Grammar, rootRule string) (*Engine, error) { + f := newFactory(g) + for _, name := range packratMemoizedRules { + f.memoized[name] = true + } + f.installOverrides() + root, err := f.createMatcher(rootRule, nil) + if err != nil { + return nil, err + } + e := &Engine{root: root} + // TopLevelStatement is built as a sub-rule of Program; expose it for + // the statement-at-a-time parse loop when present + if tls, ok := f.matchers["TopLevelStatement"]; ok { + e.topLevel = tls + } + return e, nil +} + +var ( + defaultOnce sync.Once + defaultEngine *Engine + defaultErr error +) + +// Default compiles the embedded DuckDB grammar once, rooted at Program, +// and returns the shared immutable engine. +func Default() (*Engine, error) { + defaultOnce.Do(func() { + g, err := grammar.Load() + if err != nil { + defaultErr = err + return + } + e, err := New(g, "Program") + if err != nil { + defaultErr = err + return + } + if e.topLevel == nil { + defaultErr = fmt.Errorf("grammar is missing required root rule 'TopLevelStatement'") + return + } + defaultEngine = e + }) + return defaultEngine, defaultErr +} + +// Match matches the root rule against tokens starting at pos. On success +// it returns the parse result and the position after the consumed tokens. +// On failure it returns a *SyntaxError locating the furthest token +// reached. Port of PEGTransformerFactory::TransformTopLevelStatement's +// match-and-report step. +func (e *Engine) Match(tokens []token.Token, pos int) (ParseResult, int, error) { + return runMatch(e.root, tokens, pos) +} + +// MatchTopLevel matches a single TopLevelStatement, the entry point of the +// statement-at-a-time parse loop. +func (e *Engine) MatchTopLevel(tokens []token.Token, pos int) (ParseResult, int, error) { + if e.topLevel == nil { + return nil, pos, fmt.Errorf("engine has no TopLevelStatement rule") + } + return runMatch(e.topLevel, tokens, pos) +} + +func runMatch(root matcher, tokens []token.Token, pos int) (result ParseResult, newPos int, err error) { + s := &state{ + tokens: tokens, + pos: pos, + max: pos, + packrat: newPackratCache(), + } + defer func() { + if r := recover(); r != nil { + if me, ok := r.(*MatchError); ok { + result, newPos, err = nil, pos, me + return + } + panic(r) + } + }() + r := match(root, s) + if r == nil { + return nil, pos, syntaxError(tokens, s.max) + } + return r, s.pos, nil +} + +// syntaxError builds the furthest-failure error, walking back past the +// end-of-input sentinel so the message names a real token. +func syntaxError(tokens []token.Token, maxTokenIndex int) error { + if len(tokens) == 0 { + return &SyntaxError{Token: token.Token{Kind: token.EndOfInput}} + } + idx := maxTokenIndex + if idx >= len(tokens) { + idx = len(tokens) - 1 + } + if idx > 0 && tokens[idx].Kind == token.EndOfInput { + idx-- + } + if idx < 0 { + idx = 0 + } + return &SyntaxError{Token: tokens[idx]} +} diff --git a/internal/matcher/factory.go b/internal/matcher/factory.go new file mode 100644 index 0000000..b9e0416 --- /dev/null +++ b/internal/matcher/factory.go @@ -0,0 +1,386 @@ +package matcher + +import ( + "fmt" + "strings" + + "github.com/sqlc-dev/darkwing/internal/grammar" +) + +// factory compiles grammar rules into a matcher tree. Port of +// MatcherFactory (matcher_factory.cpp): the flat token stream of each rule +// is interpreted with a stack of open lists; `/` `?` `*` `+` rewrite the +// most recent element, replicating upstream's (deliberately ported) +// binding quirks — `/` binds only the immediately preceding element, which +// is why upstream grammars parenthesize multi-token alternatives. +type factory struct { + grammar *grammar.Grammar + // matchers caches rule matchers by rule name and holds the rule + // overrides (upstream: string_map_t>, case + // sensitive). + matchers map[string]matcher + // keywords caches keyword matchers case-insensitively. + keywords map[string]*keywordMatcher + // memoized is the set of packrat-memoized rule names. + memoized map[string]bool + nextID int +} + +func newFactory(g *grammar.Grammar) *factory { + return &factory{ + grammar: g, + matchers: make(map[string]matcher), + keywords: make(map[string]*keywordMatcher), + memoized: make(map[string]bool), + } +} + +// alloc assigns the packrat identity (upstream: MatcherAllocator). +func (f *factory) alloc(m matcher) matcher { + m.meta().id = f.nextID + f.nextID++ + return m +} + +func (f *factory) newList() *listMatcher { + m := &listMatcher{} + f.alloc(m) + return m +} + +func (f *factory) newListWith(children []matcher) *listMatcher { + m := &listMatcher{children: children} + f.alloc(m) + return m +} + +func (f *factory) newChoice(children []matcher) *choiceMatcher { + m := &choiceMatcher{children: children} + f.alloc(m) + return m +} + +func (f *factory) newOptional(child matcher) *optionalMatcher { + m := &optionalMatcher{child: child} + f.alloc(m) + return m +} + +func (f *factory) newRepeat(element matcher) *repeatMatcher { + m := &repeatMatcher{element: element} + f.alloc(m) + return m +} + +func (f *factory) keyword(text string) *keywordMatcher { + key := strings.ToLower(text) + if m, ok := f.keywords[key]; ok { + return m + } + m := &keywordMatcher{keyword: text} + f.alloc(m) + f.keywords[key] = m + return m +} + +// addRuleOverride installs a special-token matcher for a rule, replacing +// its grammar definition. Port of MatcherFactory::AddRuleOverride. +func (f *factory) addRuleOverride(name string, m matcher) { + f.alloc(m) + if f.memoized[name] { + m.meta().memoized = true + } + if f.grammar.Rule(name) != nil { + m.meta().setRule(name) + } else if m.meta().name == "" { + m.meta().name = name + } + f.matchers[name] = m +} + +// stack entry for interpreting one rule's token stream. Port of +// MatcherFactory::MatcherList. +type stackEntry struct { + m matcher + functionName string + isFunction bool +} + +type matcherStack struct { + f *factory + entries []stackEntry +} + +func (ms *matcherStack) addRoot(m matcher) { + ms.entries = append(ms.entries, stackEntry{m: m}) +} + +func (ms *matcherStack) beginFunction(name string) { + ms.entries = append(ms.entries, stackEntry{m: ms.f.newList(), functionName: name, isFunction: true}) +} + +func (ms *matcherStack) addMatcher(m matcher) error { + root := ms.entries[len(ms.entries)-1].m + switch root := root.(type) { + case *listMatcher: + root.children = append(root.children, m) + case *choiceMatcher: + // for a choice matcher we pop the choice from the stack after + // adding the alternative + if len(ms.entries) <= 1 { + return fmt.Errorf("choice matcher should never be the root in the matcher stack") + } + root.children = append(root.children, m) + ms.entries = ms.entries[:len(ms.entries)-1] + default: + return fmt.Errorf("cannot add matcher to root matcher of this type") + } + return nil +} + +func (ms *matcherStack) closeBracket() error { + if len(ms.entries) <= 1 { + return fmt.Errorf("PEG matcher create error - found too many close brackets") + } + top := ms.entries[len(ms.entries)-1] + if !top.isFunction { + ms.entries = ms.entries[:len(ms.entries)-1] + return ms.addMatcher(top.m) + } + // function matcher: substitute the parameterized rule + params := top.m.(*listMatcher) + var param matcher + if len(params.children) == 1 { + param = params.children[0] + } else { + param = ms.f.newListWith(params.children) + } + call, err := ms.f.createMatcher(top.functionName, []matcher{param}) + if err != nil { + return err + } + ms.entries = ms.entries[:len(ms.entries)-1] + return ms.addMatcher(call) +} + +func (ms *matcherStack) lastRootList() (*listMatcher, error) { + root, ok := ms.entries[len(ms.entries)-1].m.(*listMatcher) + if !ok { + return nil, fmt.Errorf("expected a list matcher") + } + return root, nil +} + +// createMatcher builds (and caches) the matcher for a rule, recursively +// building referenced rules. params carries macro arguments for +// parameterized rules (List(D), Parens(D)). Port of +// MatcherFactory::CreateMatcher. +func (f *factory) createMatcher(ruleName string, params []matcher) (matcher, error) { + isFunctionCall := len(params) > 0 + if !isFunctionCall { + if m, ok := f.matchers[ruleName]; ok { + return m, nil + } + } + rule := f.grammar.Rule(ruleName) + if rule == nil { + return nil, fmt.Errorf("failed to create matcher for rule %s - rule is missing", ruleName) + } + // matchers can be recursive: cache before recursively constructing + root := f.newList() + if !isFunctionCall { + f.matchers[rule.Name] = root + } + + stack := &matcherStack{f: f} + stack.addRoot(root) + if len(rule.Parameters) > 1 { + return nil, fmt.Errorf("only functions with a single parameter are supported") + } + if len(params) != len(rule.Parameters) { + return nil, fmt.Errorf("parameter count mismatch (rule %s expected %d parameters but got %d)", + ruleName, len(rule.Parameters), len(params)) + } + for _, tok := range rule.Tokens { + var err error + switch tok.Type { + case grammar.Literal: + err = stack.addMatcher(f.keyword(tok.Text)) + case grammar.Reference: + if idx, ok := rule.Parameters[tok.Text]; ok { + // refers to a macro parameter - use it directly + err = stack.addMatcher(params[idx]) + } else { + var child matcher + child, err = f.createMatcher(tok.Text, nil) + if err == nil { + err = stack.addMatcher(child) + } + } + case grammar.FunctionCall: + stack.beginFunction(tok.Text) + case grammar.Operator: + err = f.applyOperator(stack, ruleName, tok.Text[0]) + case grammar.Regex: + err = fmt.Errorf("REGEX operator not supported in PEG grammar (found in rule %s)", ruleName) + default: + err = fmt.Errorf("unrecognized peg token type") + } + if err != nil { + return nil, err + } + } + if len(stack.entries) != 1 { + return nil, fmt.Errorf("PEG matcher create error - unclosed bracket found in rule %s", ruleName) + } + + root.setRule(rule.Name) + if f.memoized[ruleName] { + root.memoized = true + } + return root, nil +} + +func (f *factory) applyOperator(stack *matcherStack, ruleName string, op byte) error { + switch op { + case '?', '*': + // optional/repeat rewrites the most recent element of the current + // list; '*' is Optional(Repeat(child)) + root, err := stack.lastRootList() + if err != nil { + return fmt.Errorf("optional/repeat in rule %s: %w", ruleName, err) + } + if len(root.children) == 0 { + return fmt.Errorf("optional/repeat rule found as first token in rule %s", ruleName) + } + final := root.children[len(root.children)-1] + if op == '*' { + final = f.newRepeat(final) + } + root.children[len(root.children)-1] = f.newOptional(final) + case '+': + root, err := stack.lastRootList() + if err != nil { + return fmt.Errorf("repeat in rule %s: %w", ruleName, err) + } + if len(root.children) == 0 { + return fmt.Errorf("repeat rule found as first token in rule %s", ruleName) + } + final := root.children[len(root.children)-1] + root.children[len(root.children)-1] = f.newRepeat(final) + case '/': + // ordered choice between the most recent element and what follows + root, err := stack.lastRootList() + if err != nil { + return fmt.Errorf("OR in rule %s: %w", ruleName, err) + } + if len(root.children) == 0 { + return fmt.Errorf("OR rule found as first token in rule %s", ruleName) + } + previous := root.children[len(root.children)-1] + if choice, ok := previous.(*choiceMatcher); ok { + stack.addRoot(choice) + } else { + choice := f.newChoice([]matcher{previous}) + root.children[len(root.children)-1] = choice + stack.addRoot(choice) + } + case '(': + stack.addRoot(f.newList()) + case ')': + return stack.closeBracket() + case '!': + // negative lookahead is parsed but ignored, replicating the pinned + // DuckDB build (an acknowledged upstream TODO). Flip this in + // lockstep with upstream, never independently. + default: + return fmt.Errorf("unrecognized peg operator type %q", string(op)) + } + return nil +} + +//===----------------------------------------------------------------------===// +// Generated tables (transcribed from matcher_factory.cpp) +//===----------------------------------------------------------------------===// + +// packratMemoizedRules is upstream's designated hot-rule list +// (START/END GENERATED PACKRAT MEMOIZED RULES). +var packratMemoizedRules = []string{ + "Expression", + "LambdaArrowExpression", + "LogicalOrExpression", + "LogicalAndExpression", + "LogicalNotExpression", + "IsExpression", + "ComparisonExpression", + "BitwiseExpression", + "AdditiveExpression", + "MultiplicativeExpression", + "ExponentiationExpression", + "PrefixExpression", + "CollateExpression", + "AtTimeZoneExpression", + "SingleExpression", + "BaseExpression", + "ParensExpression", + "ParenthesisExpression", + "Identifier", + "ColId", + "ColumnReference", + "FunctionExpression", +} + +// installOverrides transcribes upstream's rule override table +// (START/END GENERATED RULE OVERRIDES + the EndOfInput override). Special +// tokens are handled natively rather than by grammar expansion. +func (f *factory) installOverrides() { + ident := func(class identifierClass, supportsString bool, display string) matcher { + return &identifierMatcher{class: class, supportsStringLiteral: supportsString, display: display} + } + reserved := func(supportsString bool, display string) matcher { + return &identifierMatcher{reserved: true, supportsStringLiteral: supportsString, display: display} + } + + f.addRuleOverride("Identifier", ident(classColumnName, false, "VARIABLE")) + f.addRuleOverride("ReservedIdentifier", reserved(false, "VARIABLE")) + f.addRuleOverride("CatalogName", ident(classColumnName, false, "CATALOG_NAME")) + f.addRuleOverride("SchemaName", ident(classColumnName, false, "SCHEMA_NAME")) + f.addRuleOverride("ReservedSchemaName", reserved(false, "SCHEMA_NAME")) + f.addRuleOverride("TableName", ident(classColumnName, true, "TABLE_NAME")) + f.addRuleOverride("ReservedTableName", reserved(true, "TABLE_NAME")) + f.addRuleOverride("ColumnName", ident(classColumnName, false, "COLUMN_NAME")) + f.addRuleOverride("ReservedColumnName", reserved(false, "COLUMN_NAME")) + f.addRuleOverride("IndexName", ident(classColumnName, false, "VARIABLE")) + f.addRuleOverride("ReservedIndexName", reserved(false, "VARIABLE")) + f.addRuleOverride("SequenceName", ident(classColumnName, false, "VARIABLE")) + f.addRuleOverride("FunctionName", ident(classTypeFunc, false, "SCALAR_FUNCTION_NAME")) + f.addRuleOverride("ReservedFunctionName", reserved(false, "SCALAR_FUNCTION_NAME")) + f.addRuleOverride("ReservedKeyword", reserved(false, "VARIABLE")) + f.addRuleOverride("TableFunctionName", ident(classTypeFunc, false, "TABLE_FUNCTION_NAME")) + f.addRuleOverride("TypeName", ident(classTypeName, false, "TYPE_NAME")) + f.addRuleOverride("ReservedTypeName", reserved(false, "TYPE_NAME")) + f.addRuleOverride("PragmaName", ident(classColumnName, false, "PRAGMA_NAME")) + f.addRuleOverride("SettingName", ident(classColumnName, false, "SETTING_NAME")) + f.addRuleOverride("CopyOptionName", reserved(false, "VARIABLE")) + f.addRuleOverride("NumberLiteral", &numberLiteralMatcher{matcherMeta: matcherMeta{name: "NumberLiteral"}}) + f.addRuleOverride("StringLiteral", &stringLiteralMatcher{matcherMeta: matcherMeta{name: "StringLiteral"}}) + f.addRuleOverride("OperatorLiteral", &operatorMatcher{}) + + // EndOfInput has no grammar body; satisfied here, as upstream does + // outside the regenerated block + f.addRuleOverride("EndOfInput", &endOfInputMatcher{}) +} + +// OverrideRuleNames returns the names of all rule overrides, for tests that +// cross-check the override table against the vendored grammar. +func OverrideRuleNames() []string { + return []string{ + "Identifier", "ReservedIdentifier", "CatalogName", "SchemaName", + "ReservedSchemaName", "TableName", "ReservedTableName", "ColumnName", + "ReservedColumnName", "IndexName", "ReservedIndexName", "SequenceName", + "FunctionName", "ReservedFunctionName", "ReservedKeyword", + "TableFunctionName", "TypeName", "ReservedTypeName", "PragmaName", + "SettingName", "CopyOptionName", "NumberLiteral", "StringLiteral", + "OperatorLiteral", "EndOfInput", + } +} diff --git a/internal/matcher/matcher.go b/internal/matcher/matcher.go new file mode 100644 index 0000000..b6fab9c --- /dev/null +++ b/internal/matcher/matcher.go @@ -0,0 +1,295 @@ +package matcher + +import ( + "strings" + + "github.com/sqlc-dev/darkwing/token" +) + +// state carries the token stream and matching position. It plays the role +// of upstream's MatchState + TokenIterator: matchers advance pos on success +// and restore it on failure (upstream achieves the same by matching on a +// copied iterator and propagating the position only on success). +type state struct { + tokens []token.Token + pos int + // max is the furthest token index reached, the basis for syntax error + // reporting (upstream: MatchState::max_token_index). + max int + packrat *packratCache +} + +func (s *state) current() *token.Token { + if s.pos < len(s.tokens) { + return &s.tokens[s.pos] + } + return nil +} + +func (s *state) advance() { + s.pos++ + if s.pos > s.max { + s.max = s.pos + } +} + +// currentOffset returns the byte offset of the current token, mirroring the +// start_offset capture every composite matcher performs. +func (s *state) currentOffset() (int, bool) { + if t := s.current(); t != nil { + return t.Span.Start, true + } + return 0, false +} + +type matcherMeta struct { + // id is the packrat identity, assigned by the factory (upstream: + // MatcherAllocator index). + id int + // name is the display/result name; set alongside rule. + name string + // rule is the grammar rule name attached to this matcher, "" if none. + rule string + hasRule bool + memoized bool +} + +func (m *matcherMeta) meta() *matcherMeta { return m } + +func (m *matcherMeta) setRule(name string) { + m.rule = name + m.name = name + m.hasRule = true +} + +// matcher is the interface all matcher-tree nodes implement. Port of the +// duckdb Matcher class hierarchy, restricted to the parse-result path (the +// autocomplete Match/AddSuggestion path is out of scope). +type matcher interface { + // matchInternal attempts to match at the current position. It returns + // nil on failure and must leave state.pos unchanged in that case. + matchInternal(s *state) ParseResult + meta() *matcherMeta + String() string +} + +// match is the memoization- and rule-attaching wrapper around +// matchInternal. Port of Matcher::MatchParseResult. +func match(m matcher, s *state) ParseResult { + var r ParseResult + mm := m.meta() + if s.packrat != nil && mm.memoized { + r = s.packrat.match(m, s) + } else { + r = m.matchInternal(s) + } + if r != nil && mm.hasRule { + r.base().name = mm.rule + } + return r +} + +// ciEquals is StringUtil::CIEquals: ASCII case-insensitive equality. +func ciEquals(a, b string) bool { + if len(a) != len(b) { + return false + } + for i := 0; i < len(a); i++ { + ca, cb := a[i], b[i] + if ca >= 'A' && ca <= 'Z' { + ca += 'a' - 'A' + } + if cb >= 'A' && cb <= 'Z' { + cb += 'a' - 'A' + } + if ca != cb { + return false + } + } + return true +} + +//===----------------------------------------------------------------------===// +// Composite matchers +//===----------------------------------------------------------------------===// + +// listMatcher matches a sequence of child matchers. Port of ListMatcher. +type listMatcher struct { + matcherMeta + children []matcher +} + +func (m *listMatcher) matchInternal(s *state) ParseResult { + start := s.pos + offset, hasOffset := s.currentOffset() + results := make([]ParseResult, 0, len(m.children)) + for _, child := range m.children { + r := match(child, s) + if r == nil { + s.pos = start + return nil + } + results = append(results, r) + } + // an empty name implies a subrule, e.g. the bracket group in + // 'SET' (StandardAssignment / SetTimeZone) + lr := &ListResult{Children: results} + lr.name = m.name + lr.offset, lr.hasOffset = offset, hasOffset + for _, child := range results { + lr.encloseChild(child) + } + return lr +} + +func (m *listMatcher) String() string { + parts := make([]string, len(m.children)) + for i, child := range m.children { + parts[i] = name(child) + } + return "(" + strings.Join(parts, " ") + ")" +} + +// choiceMatcher matches the first succeeding alternative. Port of +// ChoiceMatcher. +type choiceMatcher struct { + matcherMeta + children []matcher +} + +func (m *choiceMatcher) matchInternal(s *state) ParseResult { + offset, hasOffset := s.currentOffset() + for i, child := range m.children { + r := match(child, s) + if r != nil { + cr := &ChoiceResult{Result: r, Index: i} + cr.name = r.Name() + cr.offset, cr.hasOffset = offset, hasOffset + cr.encloseChild(r) + return cr + } + } + return nil +} + +func (m *choiceMatcher) String() string { + parts := make([]string, len(m.children)) + for i, child := range m.children { + parts[i] = name(child) + } + return strings.Join(parts, " / ") +} + +// optionalMatcher matches zero-or-one of its child. Port of +// OptionalMatcher. +type optionalMatcher struct { + matcherMeta + child matcher +} + +func (m *optionalMatcher) matchInternal(s *state) ParseResult { + offset, hasOffset := s.currentOffset() + r := match(m.child, s) + if r == nil { + return &OptionalResult{} + } + or := &OptionalResult{Result: r} + or.name = r.Name() + or.offset, or.hasOffset = offset, hasOffset + or.encloseChild(r) + return or +} + +func (m *optionalMatcher) String() string { + return name(m.child) + "?" +} + +// repeatMatcher matches one-or-more of its element (`*` compiles to +// Optional(Repeat(...))). Port of RepeatMatcher. +type repeatMatcher struct { + matcherMeta + element matcher +} + +func (m *repeatMatcher) matchInternal(s *state) ParseResult { + offset, hasOffset := s.currentOffset() + first := match(m.element, s) + if first == nil { + return nil + } + results := []ParseResult{first} + for { + r := match(m.element, s) + if r == nil { + break + } + results = append(results, r) + } + rr := &RepeatResult{Children: results} + rr.offset, rr.hasOffset = offset, hasOffset + for _, child := range results { + rr.encloseChild(child) + } + return rr +} + +func (m *repeatMatcher) String() string { + return name(m.element) + "*" +} + +func name(m matcher) string { + if mm := m.meta(); mm.name != "" { + return mm.name + } + return m.String() +} + +//===----------------------------------------------------------------------===// +// Leaf matchers +//===----------------------------------------------------------------------===// + +// keywordMatcher matches one keyword or punctuation literal +// case-insensitively. Port of KeywordMatcher. +type keywordMatcher struct { + matcherMeta + keyword string +} + +func (m *keywordMatcher) matchInternal(s *state) ParseResult { + tok := s.current() + if tok == nil || !ciEquals(m.keyword, tok.Text) { + return nil + } + offset := tok.Span.Start + length := len(tok.Text) + text := tok.Text + s.advance() + kr := &KeywordResult{Keyword: text} + kr.name = m.name + kr.offset, kr.hasOffset = offset, true + kr.length, kr.hasLength = length, true + return kr +} + +func (m *keywordMatcher) String() string { + return "'" + m.keyword + "'" +} + +// endOfInputMatcher consumes the EndOfInput sentinel. Port of +// EndOfInputMatcher. +type endOfInputMatcher struct { + matcherMeta +} + +func (m *endOfInputMatcher) matchInternal(s *state) ParseResult { + tok := s.current() + if tok == nil || tok.Kind != token.EndOfInput { + return nil + } + s.advance() + return &EndOfInputResult{} +} + +func (m *endOfInputMatcher) String() string { + return "EndOfInput" +} diff --git a/internal/matcher/matcher_test.go b/internal/matcher/matcher_test.go new file mode 100644 index 0000000..1261d83 --- /dev/null +++ b/internal/matcher/matcher_test.go @@ -0,0 +1,517 @@ +package matcher + +import ( + "errors" + "strings" + "testing" + + "github.com/sqlc-dev/darkwing/internal/grammar" + "github.com/sqlc-dev/darkwing/lexer" + "github.com/sqlc-dev/darkwing/token" +) + +// Compiling the full vendored grammar from the Program root is the +// milestone-1 engine gate: it proves every reachable rule compiles and +// that no reachable rule needs the (unsupported) character-class tokens — +// those rules are all satisfied by overrides. +func TestDefaultEngineCompiles(t *testing.T) { + engine, err := Default() + if err != nil { + t.Fatalf("Default: %v", err) + } + if engine.topLevel == nil { + t.Fatal("TopLevelStatement matcher missing") + } +} + +// Every rule override must name a rule the vendored grammar defines (or, +// for EndOfInput, the implicit rule the loader adds), so the transcribed +// table cannot drift silently from upstream. +func TestOverridesExistInGrammar(t *testing.T) { + g, err := grammar.Load() + if err != nil { + t.Fatal(err) + } + for _, name := range OverrideRuleNames() { + if g.Rule(name) == nil { + t.Errorf("override %q has no rule in the vendored grammar", name) + } + } +} + +// Rules whose definitions use character-class tokens (Regex) cannot be +// compiled by the matcher factory; every one of them must be shadowed by +// a rule override on any path from Program (the overrides short-circuit +// compilation, so rules like PlainIdentifier behind the Identifier +// override are never compiled). This is the "special rules" walk from the +// plan: walk the grammar from Program, stopping at overridden rules, and +// require that no reached rule needs a character-class token. +func TestRegexRulesAreOverridden(t *testing.T) { + g, err := grammar.Load() + if err != nil { + t.Fatal(err) + } + overridden := make(map[string]bool) + for _, name := range OverrideRuleNames() { + overridden[strings.ToLower(name)] = true + } + visited := make(map[string]bool) + var walk func(name string) + walk = func(name string) { + key := strings.ToLower(name) + if visited[key] || overridden[key] { + return + } + visited[key] = true + rule := g.Rule(name) + if rule == nil { + t.Errorf("reachable rule %q is missing", name) + return + } + for _, tok := range rule.Tokens { + switch tok.Type { + case grammar.Regex: + t.Errorf("reachable rule %q uses a character-class token but has no override", name) + case grammar.Reference, grammar.FunctionCall: + if _, isParam := rule.Parameters[tok.Text]; !isParam { + walk(tok.Text) + } + } + } + } + walk("Program") +} + +func mustTokens(t *testing.T, sql string) []token.Token { + t.Helper() + tokens, err := lexer.Tokenize(sql) + if err != nil { + t.Fatalf("Tokenize(%q): %v", sql, err) + } + return tokens +} + +// matchAll drives the statement-at-a-time loop over the whole input. +func matchAll(t *testing.T, engine *Engine, sql string) ([]ParseResult, error) { + t.Helper() + tokens := mustTokens(t, sql) + var results []ParseResult + pos := 0 + for pos < len(tokens) { + r, newPos, err := engine.MatchTopLevel(tokens, pos) + if err != nil { + return nil, err + } + if newPos == pos { + t.Fatalf("no progress at token %d of %q", pos, sql) + } + results = append(results, r) + pos = newPos + } + return results, nil +} + +func TestAcceptStatements(t *testing.T) { + engine, err := Default() + if err != nil { + t.Fatal(err) + } + // a milestone-1 smoke set spanning the dialect surface; the full + // corpus gate is milestone 2 + accepted := []string{ + "SELECT 1", + "SELECT * FROM t", + "SELECT a, b FROM t WHERE x = 1 GROUP BY ALL ORDER BY ALL", + "FROM t SELECT x", + "FROM t", + "SELECT * EXCLUDE (a) REPLACE (b + 1 AS b) FROM t", + "1 + 1", + "SELECT [1, 2, 3]", + "SELECT {'a': 1}", + "SELECT x -> x + 1", + "SELECT l[1:3]", + "SELECT CAST(x AS INTEGER)", + "SELECT TRY_CAST(x AS INTEGER)", + "SELECT x::INTEGER", + "SELECT count(*)", + "SELECT $1, $name, ?", + "SELECT 'it''s'", + "SELECT E'a\\'b'", + "SELECT $$dollar$$", + "WITH cte AS (SELECT 1) SELECT * FROM cte", + "SELECT DISTINCT ON (a) a, b FROM t", + "SELECT a FROM t UNION BY NAME SELECT b FROM u", + "CREATE TABLE t (id INTEGER PRIMARY KEY, name VARCHAR)", + "CREATE OR REPLACE TEMP TABLE t AS SELECT 1", + "INSERT INTO t VALUES (1, 2)", + "INSERT INTO t BY NAME SELECT 1 AS a", + "UPDATE t SET x = 1 WHERE y = 2", + "DELETE FROM t WHERE x = 1", + "DROP TABLE IF EXISTS t", + "ALTER TABLE t ADD COLUMN c INTEGER", + "ATTACH 'file.db' AS db", + "DETACH db", + "USE db", + "COPY t TO 'out.parquet' (FORMAT parquet)", + "EXPORT DATABASE 'dir'", + "INSTALL httpfs", + "LOAD httpfs", + "PRAGMA table_info('t')", + "SET threads = 4", + "RESET threads", + "BEGIN TRANSACTION", + "COMMIT", + "CHECKPOINT", + "VACUUM", + "TRUNCATE t", + "COMMENT ON TABLE t IS 'hi'", + "PREPARE q AS SELECT $1", + "EXECUTE q(1)", + "DEALLOCATE q", + "EXPLAIN SELECT 1", + "DESCRIBE t", + "SHOW TABLES", + "SUMMARIZE t", + "PIVOT tbl ON col USING sum(v)", + "UNPIVOT tbl ON a, b", + "SELECT 1; SELECT 2;", + "SELECT interval '1 hour'", + "SELECT x AT TIME ZONE 'UTC'", + "SELECT a FROM t QUALIFY row_number() OVER (PARTITION BY b) = 1", + "SELECT * FROM t USING SAMPLE 10%", + "MERGE INTO t USING s ON t.id = s.id WHEN MATCHED THEN UPDATE SET x = 1", + "SELECT struct.field FROM t", + `SELECT "quoted col" FROM "quoted table"`, + "CREATE SCHEMA s", + "CREATE SEQUENCE seq", + "CREATE TYPE mood AS ENUM ('happy', 'sad')", + "CREATE MACRO add1(x) AS x + 1", + "CREATE VIEW v AS SELECT 1", + "CREATE INDEX idx ON t (a)", + } + for _, sql := range accepted { + if _, err := matchAll(t, engine, sql); err != nil { + t.Errorf("accept %q: %v", sql, err) + } + } +} + +func TestRejectStatements(t *testing.T) { + engine, err := Default() + if err != nil { + t.Fatal(err) + } + rejected := []struct { + sql string + near string + }{ + {"SELECT (", "("}, + {"SELECT 1 +", "+"}, + {"SELECT FROM FROM", "FROM"}, + {"CREATE 1", "1"}, + {"SELECT * FROM WHERE", "WHERE"}, + {"INSERT INTO", "INTO"}, + } + for _, tc := range rejected { + _, err := matchAll(t, engine, tc.sql) + var syntaxErr *SyntaxError + if !errors.As(err, &syntaxErr) { + t.Errorf("reject %q: err = %v, want *SyntaxError", tc.sql, err) + continue + } + if syntaxErr.Token.Text != tc.near { + t.Errorf("reject %q: at or near %q, want %q", tc.sql, syntaxErr.Token.Text, tc.near) + } + if want := "syntax error at or near " + `"` + tc.near + `"`; syntaxErr.Error() != want { + t.Errorf("reject %q: message %q, want %q", tc.sql, syntaxErr.Error(), want) + } + } +} + +// Reserved keywords are rejected as bare identifiers but allowed quoted; +// category keywords are accepted in their positions. +func TestKeywordCategoryMatching(t *testing.T) { + engine, err := Default() + if err != nil { + t.Fatal(err) + } + if _, err := matchAll(t, engine, `SELECT x FROM "select"`); err != nil { + t.Errorf("quoted reserved keyword as table name: %v", err) + } + // GENERATED is a column-name keyword: valid as a bare column reference + if _, err := matchAll(t, engine, "SELECT generated FROM t"); err != nil { + t.Errorf("column-name keyword as column: %v", err) + } + // unreserved keywords are valid everywhere identifiers are + if _, err := matchAll(t, engine, "SELECT abort FROM abort"); err != nil { + t.Errorf("unreserved keyword as identifier: %v", err) + } +} + +// Negative lookahead (`!`) is parsed but ignored by the matcher, +// replicating the pinned DuckDB build (acknowledged upstream TODO in +// matcher_factory.cpp). "Ignored" means only the `!` operator itself is +// dropped: its operand stays in the sequence as an ordinary CONSUMING +// element. Textbook PEG would make `!'A' 'A'` unsatisfiable; the pinned +// behavior matches two A tokens. Flip this test in lockstep with +// upstream, never independently. (The vendored grammar's only bare `!` is +// in PlainIdentifier, which sits behind the Identifier override and is +// never compiled, so nothing reachable depends on the choice today.) +func TestNegativeLookaheadIgnored(t *testing.T) { + g, err := grammar.Parse("Root <- !'A' 'A' EndOfInput\n") + if err != nil { + t.Fatal(err) + } + engine, err := New(g, "Root") + if err != nil { + t.Fatal(err) + } + if _, _, err := engine.Match(mustTokens(t, "A A"), 0); err != nil { + t.Errorf("pinned behavior: !'A' consumes a token; A A should match: %v", err) + } + if _, _, err := engine.Match(mustTokens(t, "A"), 0); err == nil { + t.Error("pinned behavior: a single A should not satisfy !'A' 'A'") + } +} + +// The `/` operator binds only the immediately preceding element: upstream +// compiles `A B / C` as A (B / C), which is why the vendored grammars +// parenthesize multi-token alternatives. Pin that quirk. +func TestChoiceBindsLastElement(t *testing.T) { + g, err := grammar.Parse("Root <- 'A' 'B' / 'C'\n") + if err != nil { + t.Fatal(err) + } + engine, err := New(g, "Root") + if err != nil { + t.Fatal(err) + } + // "A C" matches: A then (B / C) + if _, _, err := engine.Match(mustTokens(t, "A C"), 0); err != nil { + t.Errorf("A C should match A (B / C): %v", err) + } + // bare "C" does not: the leading A is required + if _, _, err := engine.Match(mustTokens(t, "C"), 0); err == nil { + t.Error("C alone should not match A (B / C)") + } +} + +func TestParameterizedRuleExpansion(t *testing.T) { + g, err := grammar.Parse("Root <- Parens(List(Item)) EndOfInput\nItem <- 'A' / 'B'\nList(D) <- D (',' D)* ','?\nParens(D) <- '(' D ')'\n") + if err != nil { + t.Fatal(err) + } + engine, err := New(g, "Root") + if err != nil { + t.Fatal(err) + } + for _, sql := range []string{"(A)", "(A, B)", "(A, B,)", "(A,B,A)"} { + if _, _, err := engine.Match(mustTokens(t, sql), 0); err != nil { + t.Errorf("match %q: %v", sql, err) + } + } + for _, sql := range []string{"()", "(A", "A)", "(A B)"} { + if _, _, err := engine.Match(mustTokens(t, sql), 0); err == nil { + t.Errorf("match %q should fail", sql) + } + } +} + +// The parse-result shape is what transformers index into; pin the result +// kinds for a tiny grammar. +func TestParseResultShape(t *testing.T) { + g, err := grammar.Parse("Root <- 'GO' Name Number? EndOfInput\nName <- Identifier\nNumber <- NumberLiteral\nIdentifier <- 'x'\nNumberLiteral <- 'y'\n") + if err != nil { + t.Fatal(err) + } + engine, err := New(g, "Root") + if err != nil { + t.Fatal(err) + } + r, _, err := engine.Match(mustTokens(t, "go abc 42"), 0) + if err != nil { + t.Fatal(err) + } + root, ok := r.(*ListResult) + if !ok { + t.Fatalf("root = %T, want *ListResult", r) + } + if root.Name() != "Root" { + t.Errorf("root name = %q", root.Name()) + } + if len(root.Children) != 4 { + t.Fatalf("root children = %d, want 4", len(root.Children)) + } + kw, ok := root.Child(0).(*KeywordResult) + if !ok || kw.Keyword != "go" { + t.Errorf("child 0 = %#v, want keyword \"go\" (original spelling)", root.Child(0)) + } + // Name is itself a rule, so its match is a one-child ListResult + // wrapping the identifier override's result + nameList, ok := root.Child(1).(*ListResult) + if !ok || nameList.Name() != "Name" || len(nameList.Children) != 1 { + t.Fatalf("child 1 = %#v", root.Child(1)) + } + name, ok := nameList.Child(0).(*IdentifierResult) + if !ok || name.Identifier != "abc" { + t.Errorf("Name child = %#v", nameList.Child(0)) + } + opt, ok := root.Child(2).(*OptionalResult) + if !ok || !opt.HasResult() { + t.Fatalf("child 2 = %#v", root.Child(2)) + } + numList, ok := opt.Result.(*ListResult) + if !ok || numList.Name() != "Number" || len(numList.Children) != 1 { + t.Fatalf("optional result = %#v", opt.Result) + } + num, ok := numList.Child(0).(*NumberResult) + if !ok || num.Number != "42" { + t.Errorf("Number child = %#v", numList.Child(0)) + } + if _, ok := root.Child(3).(*EndOfInputResult); !ok { + t.Errorf("child 3 = %#v", root.Child(3)) + } + // offsets: the identifier starts at byte 3 + if off, length, ok := name.Loc(); !ok || off != 3 || length != 3 { + t.Errorf("identifier loc = (%d, %d, %v)", off, length, ok) + } +} + +// The identifier overrides unwrap quoting: "a""b" becomes a"b. +func TestIdentifierUnwrapping(t *testing.T) { + engine, err := Default() + if err != nil { + t.Fatal(err) + } + r, _, err := engine.MatchTopLevel(mustTokens(t, `SELECT 1 AS "a""b"`), 0) + if err != nil { + t.Fatal(err) + } + var found bool + var walk func(ParseResult) + walk = func(n ParseResult) { + switch n := n.(type) { + case *IdentifierResult: + if n.Identifier == `a"b` { + found = true + } + case *ListResult: + for _, c := range n.Children { + walk(c) + } + case *RepeatResult: + for _, c := range n.Children { + walk(c) + } + case *ChoiceResult: + walk(n.Result) + case *OptionalResult: + if n.Result != nil { + walk(n.Result) + } + } + } + walk(r) + if !found { + t.Error(`quoted identifier "a""b" was not unwrapped to a"b`) + } +} + +// Upstream throws (rather than failing the alternative) when a number +// token carries two exponent markers. +func TestDoubleScientificNotationError(t *testing.T) { + engine, err := Default() + if err != nil { + t.Fatal(err) + } + _, err = matchAll(t, engine, "SELECT 1e5e2") + var matchErr *MatchError + if !errors.As(err, &matchErr) { + t.Fatalf("err = %v, want *MatchError", err) + } + if matchErr.Msg != "Already found scientific notation" { + t.Errorf("msg = %q", matchErr.Msg) + } +} + +// The engine is immutable and must be race-clean under concurrent use +// (each Match call owns its packrat cache). +func TestConcurrentMatching(t *testing.T) { + engine, err := Default() + if err != nil { + t.Fatal(err) + } + statements := []string{ + "SELECT a, b FROM t WHERE x = 1", + "INSERT INTO t VALUES (1)", + "SELECT ((((", // syntax error path + "CREATE TABLE t (a INTEGER)", + } + done := make(chan struct{}) + for i := 0; i < 8; i++ { + go func(i int) { + defer func() { done <- struct{}{} }() + for j := 0; j < 25; j++ { + sql := statements[(i+j)%len(statements)] + tokens, err := lexer.Tokenize(sql) + if err != nil { + t.Error(err) + return + } + engine.MatchTopLevel(tokens, 0) + } + }(i) + } + for i := 0; i < 8; i++ { + <-done + } +} + +// Packrat memoization keeps pathological backtracking linear: upstream's +// motivating case is a SELECT with 19 unmatched '(' going from 10.6s to +// ~1ms. Without memoization this test would not terminate in any +// reasonable time. +func TestPathologicalBacktracking(t *testing.T) { + engine, err := Default() + if err != nil { + t.Fatal(err) + } + sql := "SELECT " + strings.Repeat("(", 19) + _, err = matchAll(t, engine, sql) + var syntaxErr *SyntaxError + if !errors.As(err, &syntaxErr) { + t.Fatalf("err = %v, want *SyntaxError", err) + } +} + +func BenchmarkPathologicalParens(b *testing.B) { + engine, err := Default() + if err != nil { + b.Fatal(err) + } + tokens, err := lexer.Tokenize("SELECT " + strings.Repeat("(", 19)) + if err != nil { + b.Fatal(err) + } + b.ResetTimer() + for i := 0; i < b.N; i++ { + engine.MatchTopLevel(tokens, 0) + } +} + +func BenchmarkSimpleSelect(b *testing.B) { + engine, err := Default() + if err != nil { + b.Fatal(err) + } + tokens, err := lexer.Tokenize("SELECT a, b, count(*) FROM t WHERE x = 1 AND y > 2 GROUP BY a, b ORDER BY a LIMIT 10") + if err != nil { + b.Fatal(err) + } + b.ResetTimer() + for i := 0; i < b.N; i++ { + if _, _, err := engine.MatchTopLevel(tokens, 0); err != nil { + b.Fatal(err) + } + } +} diff --git a/internal/matcher/packrat.go b/internal/matcher/packrat.go new file mode 100644 index 0000000..48cb1c1 --- /dev/null +++ b/internal/matcher/packrat.go @@ -0,0 +1,52 @@ +package matcher + +// packratCache memoizes (matcher, token position) match outcomes for the +// designated hot rules, killing exponential backtracking on pathological +// inputs. Port of ParserPackratCache (parser_packrat.cpp). One cache lives +// per top-level match call. +type packratCache struct { + entries map[packratKey]packratEntry +} + +type packratKey struct { + matcherID int + tokenIndex int +} + +type packratEntry struct { + success bool + posAfter int + maxTokenSeen int + result ParseResult +} + +func newPackratCache() *packratCache { + return &packratCache{entries: make(map[packratKey]packratEntry)} +} + +func (c *packratCache) match(m matcher, s *state) ParseResult { + key := packratKey{matcherID: m.meta().id, tokenIndex: s.pos} + if cached, ok := c.entries[key]; ok { + s.pos = cached.posAfter + if cached.maxTokenSeen > s.max { + s.max = cached.maxTokenSeen + } + if cached.success { + return cached.result + } + return nil + } + maxBefore := s.max + r := m.matchInternal(s) + entry := packratEntry{ + success: r != nil, + posAfter: s.pos, + result: r, + } + entry.maxTokenSeen = maxBefore + if s.max > entry.maxTokenSeen { + entry.maxTokenSeen = s.max + } + c.entries[key] = entry + return r +} diff --git a/internal/matcher/result.go b/internal/matcher/result.go new file mode 100644 index 0000000..774943c --- /dev/null +++ b/internal/matcher/result.go @@ -0,0 +1,377 @@ +// Package matcher compiles the loaded PEG grammar into a matcher tree and +// matches token streams against it, producing a generic parse tree +// (ParseResult). It is a port of DuckDB's matcher_factory.cpp, matcher.cpp, +// parser_packrat.cpp and the matcher/*.hpp headers, minus the autocomplete +// suggestion machinery (out of scope for darkwing). +package matcher + +import ( + "fmt" + "strings" +) + +// ResultKind classifies a ParseResult node. Port of duckdb ParseResultType +// (transformer/parse_result.hpp), restricted to the kinds the matcher +// produces. +type ResultKind uint8 + +const ( + // KindList is a matched sequence. + KindList ResultKind = iota + // KindOptional is a matched `?` (possibly empty). + KindOptional + // KindRepeat is a matched `+` body (also the body of `*`, which + // compiles to Optional(Repeat(...))). + KindRepeat + // KindChoice is a matched ordered-choice alternative. + KindChoice + // KindIdentifier is a matched identifier special token. + KindIdentifier + // KindKeyword is a matched keyword or punctuation literal. + KindKeyword + // KindNumber is a matched number literal special token. + KindNumber + // KindString is a matched string literal special token. + KindString + // KindOperator is a matched operator special token. + KindOperator + // KindEndOfInput is the consumed end-of-input sentinel. + KindEndOfInput +) + +func (k ResultKind) String() string { + switch k { + case KindList: + return "LIST" + case KindOptional: + return "OPTIONAL" + case KindRepeat: + return "REPEAT" + case KindChoice: + return "CHOICE" + case KindIdentifier: + return "IDENTIFIER" + case KindKeyword: + return "KEYWORD" + case KindNumber: + return "NUMBER" + case KindString: + return "STRING" + case KindOperator: + return "OPERATOR" + case KindEndOfInput: + return "END_OF_INPUT" + default: + return fmt.Sprintf("ResultKind(%d)", uint8(k)) + } +} + +// StringKind classifies a string literal by its prefix. Port of duckdb +// SpecialStringCharacter (special_string_utils.hpp). +type StringKind uint8 + +const ( + // StringStandard is a plain '...' literal. + StringStandard StringKind = iota + // StringNational is an N'...' literal. + StringNational + // StringHexadecimal is an X'...' literal. + StringHexadecimal + // StringEscape is an E'...' literal. + StringEscape + // StringBit is a B'...' literal. + StringBit +) + +// ParseResult is one node of the generic parse tree. Nodes are immutable +// once matching completes; packrat memoization may share a node between +// multiple parents. +type ParseResult interface { + Kind() ResultKind + // Name is the grammar rule name that produced this node, or "" for + // anonymous sub-rules (e.g. a parenthesized group). + Name() string + // Loc returns the source byte range [offset, offset+length) this node + // covers. ok is false when the node has no location (an empty optional, + // or end of input). + Loc() (offset, length int, ok bool) + + base() *resultBase + dump(sb *strings.Builder, visited map[*resultBase]bool, indent string, isLast bool) +} + +type resultBase struct { + name string + offset int + length int + hasOffset bool + hasLength bool +} + +func (b *resultBase) Name() string { return b.name } + +func (b *resultBase) Loc() (int, int, bool) { + if !b.hasOffset { + return 0, 0, false + } + length := 0 + if b.hasLength { + length = b.length + } + return b.offset, length, true +} + +func (b *resultBase) base() *resultBase { return b } + +// encloseChild grows this node's location so it encloses the child's +// location. Port of ParseResult::EncloseChild + QueryLocation::Merge. +func (b *resultBase) encloseChild(child ParseResult) { + if !b.hasOffset { + return + } + childOffset, childLength, ok := child.Loc() + if !ok { + return + } + selfLength := 0 + if b.hasLength { + selfLength = b.length + } + start := b.offset + if childOffset < start { + start = childOffset + } + end := b.offset + selfLength + if childEnd := childOffset + childLength; childEnd > end { + end = childEnd + } + // upstream only updates length, keeping the node's own offset + b.length = end - b.offset + b.hasLength = true +} + +func (b *resultBase) dumpHeader(sb *strings.Builder, kind ResultKind, indent string, isLast bool) { + sb.WriteString(indent) + if isLast { + sb.WriteString("└─") + } else { + sb.WriteString("├─") + } + sb.WriteString(" ") + sb.WriteString(kind.String()) + if b.name != "" { + sb.WriteString(" (") + sb.WriteString(b.name) + sb.WriteString(")") + } +} + +func childIndent(indent string, isLast bool) string { + if isLast { + return indent + " " + } + return indent + "│ " +} + +// Dump renders the parse tree in the same style as upstream's +// ParseResult::ToString. +func Dump(r ParseResult) string { + var sb strings.Builder + r.dump(&sb, make(map[*resultBase]bool), "", true) + return sb.String() +} + +// ListResult is a matched sequence. Port of ListParseResult. +type ListResult struct { + resultBase + Children []ParseResult +} + +func (r *ListResult) Kind() ResultKind { return KindList } + +// Child returns the index-th child, panicking on out-of-bounds (the +// transformer indexes by grammar position, so out-of-bounds is a bug). +func (r *ListResult) Child(index int) ParseResult { return r.Children[index] } + +func (r *ListResult) dump(sb *strings.Builder, visited map[*resultBase]bool, indent string, isLast bool) { + dumpChildren(&r.resultBase, KindList, r.Children, sb, visited, indent, isLast) +} + +// RepeatResult is one-or-more matches of a repeated element. Port of +// RepeatParseResult. +type RepeatResult struct { + resultBase + Children []ParseResult +} + +func (r *RepeatResult) Kind() ResultKind { return KindRepeat } + +func (r *RepeatResult) dump(sb *strings.Builder, visited map[*resultBase]bool, indent string, isLast bool) { + dumpChildren(&r.resultBase, KindRepeat, r.Children, sb, visited, indent, isLast) +} + +func dumpChildren(b *resultBase, kind ResultKind, children []ParseResult, sb *strings.Builder, + visited map[*resultBase]bool, indent string, isLast bool) { + sb.WriteString(indent) + if isLast { + sb.WriteString("└─") + } else { + sb.WriteString("├─") + } + if visited[b] { + fmt.Fprintf(sb, " %s (%s) [... already printed ...]\n", kindLabel(kind), b.name) + return + } + visited[b] = true + sb.WriteString(" ") + sb.WriteString(kind.String()) + if b.name != "" { + sb.WriteString(" (") + sb.WriteString(b.name) + sb.WriteString(")") + } + fmt.Fprintf(sb, " [%d children]\n", len(children)) + ci := childIndent(indent, isLast) + for i, child := range children { + child.dump(sb, visited, ci, i == len(children)-1) + } +} + +func kindLabel(kind ResultKind) string { + if kind == KindRepeat { + return "Repeat" + } + return "List" +} + +// OptionalResult is a matched `?`. Result is nil when the optional did not +// match. Port of OptionalParseResult. +type OptionalResult struct { + resultBase + Result ParseResult +} + +func (r *OptionalResult) Kind() ResultKind { return KindOptional } + +// HasResult reports whether the optional matched. +func (r *OptionalResult) HasResult() bool { return r.Result != nil } + +func (r *OptionalResult) dump(sb *strings.Builder, visited map[*resultBase]bool, indent string, isLast bool) { + if r.Result != nil { + // collapse: print the child in place of the optional + r.Result.dump(sb, visited, indent, isLast) + return + } + sb.WriteString(indent) + if isLast { + sb.WriteString("└─") + } else { + sb.WriteString("├─") + } + sb.WriteString(" OPTIONAL [empty]\n") +} + +// ChoiceResult wraps the matched alternative of an ordered choice. Port of +// ChoiceParseResult. +type ChoiceResult struct { + resultBase + Result ParseResult + // Index is the position of the matched alternative. + Index int +} + +func (r *ChoiceResult) Kind() ResultKind { return KindChoice } + +func (r *ChoiceResult) dump(sb *strings.Builder, visited map[*resultBase]bool, indent string, isLast bool) { + sb.WriteString(indent) + if isLast { + sb.WriteString("└─") + } else { + sb.WriteString("├─") + } + fmt.Fprintf(sb, " [CHOICE (idx: %d)] ->\n", r.Index) + r.Result.dump(sb, visited, childIndent(indent, isLast), true) +} + +// IdentifierResult is a matched identifier, unwrapped from quoting. Port of +// IdentifierParseResult. +type IdentifierResult struct { + resultBase + Identifier string +} + +func (r *IdentifierResult) Kind() ResultKind { return KindIdentifier } + +func (r *IdentifierResult) dump(sb *strings.Builder, _ map[*resultBase]bool, indent string, isLast bool) { + r.dumpHeader(sb, KindIdentifier, indent, isLast) + fmt.Fprintf(sb, ": %s\n", r.Identifier) +} + +// KeywordResult is a matched keyword or punctuation literal (original +// source spelling). Port of KeywordParseResult. +type KeywordResult struct { + resultBase + Keyword string +} + +func (r *KeywordResult) Kind() ResultKind { return KindKeyword } + +func (r *KeywordResult) dump(sb *strings.Builder, _ map[*resultBase]bool, indent string, isLast bool) { + r.dumpHeader(sb, KindKeyword, indent, isLast) + fmt.Fprintf(sb, ": %q\n", r.Keyword) +} + +// NumberResult is a matched number literal (raw text). Port of +// NumberParseResult. +type NumberResult struct { + resultBase + Number string +} + +func (r *NumberResult) Kind() ResultKind { return KindNumber } + +func (r *NumberResult) dump(sb *strings.Builder, _ map[*resultBase]bool, indent string, isLast bool) { + r.dumpHeader(sb, KindNumber, indent, isLast) + fmt.Fprintf(sb, ": %s\n", r.Number) +} + +// StringResult is a matched string literal with the quotes and prefix +// stripped and doubled quotes unescaped. Port of StringLiteralParseResult. +type StringResult struct { + resultBase + Value string + StringKind StringKind +} + +func (r *StringResult) Kind() ResultKind { return KindString } + +func (r *StringResult) dump(sb *strings.Builder, _ map[*resultBase]bool, indent string, isLast bool) { + r.dumpHeader(sb, KindString, indent, isLast) + fmt.Fprintf(sb, ": '%s'\n", r.Value) +} + +// OperatorResult is a matched operator token. Port of OperatorParseResult. +type OperatorResult struct { + resultBase + Operator string +} + +func (r *OperatorResult) Kind() ResultKind { return KindOperator } + +func (r *OperatorResult) dump(sb *strings.Builder, _ map[*resultBase]bool, indent string, isLast bool) { + r.dumpHeader(sb, KindOperator, indent, isLast) + fmt.Fprintf(sb, ": %s\n", r.Operator) +} + +// EndOfInputResult marks the consumed end-of-input sentinel. Port of +// EndOfInputParseResult. +type EndOfInputResult struct { + resultBase +} + +func (r *EndOfInputResult) Kind() ResultKind { return KindEndOfInput } + +func (r *EndOfInputResult) dump(sb *strings.Builder, _ map[*resultBase]bool, indent string, isLast bool) { + r.dumpHeader(sb, KindEndOfInput, indent, isLast) + sb.WriteString("\n") +} diff --git a/internal/matcher/special.go b/internal/matcher/special.go new file mode 100644 index 0000000..1b5d966 --- /dev/null +++ b/internal/matcher/special.go @@ -0,0 +1,329 @@ +package matcher + +import ( + "strings" + + "github.com/sqlc-dev/darkwing/token" +) + +// identifierClass selects which keyword category an identifier position +// may consume, mirroring the relevant part of upstream's SuggestionState +// (IdentifierMatcher::GetAllowedCategory / SupportsStringLiteral). +type identifierClass uint8 + +const ( + // classColumnName allows unreserved + column-name keywords (the + // default for ColId-style positions). + classColumnName identifierClass = iota + // classTypeFunc allows unreserved + func-name/type-name keywords + // (function name positions). + classTypeFunc + // classTypeName allows unreserved + type-name keywords (type name + // positions). + classTypeName +) + +// identifierMatcher matches identifier tokens with category-aware keyword +// acceptance. Port of IdentifierMatcher and ReservedIdentifierMatcher +// (matcher/identifier_matcher.hpp); reserved selects the latter, which +// accepts even reserved keywords (qualified positions such as +// catalog.schema."select"). +type identifierMatcher struct { + matcherMeta + class identifierClass + // reserved: ReservedIdentifierMatcher behavior (no keyword filtering). + reserved bool + // supportsStringLiteral: single-quoted tokens are acceptable (table + // and file name positions, where '...' is a path). + supportsStringLiteral bool + // display is the ToString label (upstream prints the suggestion type). + display string +} + +func isQuoted(text string) bool { + return text[0] == '"' && text[len(text)-1] == '"' +} + +func isSingleQuoted(text string) bool { + return text[0] == '\'' && text[len(text)-1] == '\'' +} + +// charIsKeywordStart mirrors Tokenizer::CharacterIsKeyword for the first +// identifier character. +func charIsKeywordStart(c byte) bool { + switch c { + case '(', ')', '{', '}', '[', ']', ',', '?', '$', '-', '#': + // single-byte operators + return false + case '\'', ';', '"', '.': + // control flow ('-' already covered above) + return false + } + if c == ' ' || c == '\t' || c == '\n' || c == '\v' || c == '\f' || c == '\r' { + return false + } + // StringUtil::CharacterIsOperator: ASCII punctuation except '_' + if c != '_' && ((c >= '!' && c <= '/') || (c >= ':' && c <= '@') || (c >= '[' && c <= '`') || (c >= '{' && c <= '~')) { + return false + } + return true +} + +func (m *identifierMatcher) isIdentifier(text string) bool { + if text == "" { + return false + } + if isSingleQuoted(text) && m.supportsStringLiteral { + return true + } + if isQuoted(text) { + return true + } + if text[0] == '.' || (text[0] >= '0' && text[0] <= '9') { + // CharacterIsInitialNumber + return false + } + return charIsKeywordStart(text[0]) +} + +func (m *identifierMatcher) isAllowedKeyword(text string) bool { + categories := token.Categories(text) + if categories == token.KeywordNone { + return true + } + if categories.Has(token.KeywordUnreserved) { + return true + } + switch m.class { + case classTypeName: + return categories.Has(token.KeywordTypeName) + case classTypeFunc: + // upstream's typefunc map is the union of the func-name and + // type-name lists + return categories.Has(token.KeywordFuncName) || categories.Has(token.KeywordTypeName) + default: + return categories.Has(token.KeywordColumnName) + } +} + +func (m *identifierMatcher) matchInternal(s *state) ParseResult { + tok := s.current() + if tok == nil { + return nil + } + text := tok.Text + if !m.reserved && !m.isAllowedKeyword(text) { + return nil + } + if !m.isIdentifier(text) { + return nil + } + offset := tok.Span.Start + length := len(text) + s.advance() + + result := text + if m.reserved { + // ReservedIdentifierMatcher only unwraps double quotes; a + // single-quoted path literal is kept verbatim + if isQuoted(result) { + result = strings.ReplaceAll(result[1:len(result)-1], `""`, `"`) + } + } else { + switch { + case isQuoted(result): + result = strings.ReplaceAll(result[1:len(result)-1], `""`, `"`) + case isSingleQuoted(result) && m.supportsStringLiteral: + // a single-quoted token in a table or file-name position is a + // path: unwrapped but never folded + result = strings.ReplaceAll(result[1:len(result)-1], "''", "'") + } + } + // identifier case folding (preserve_identifier_case) is not ported: + // darkwing always preserves case, DuckDB's default + + ir := &IdentifierResult{Identifier: result} + ir.offset, ir.hasOffset = offset, true + ir.length, ir.hasLength = length, true + return ir +} + +func (m *identifierMatcher) String() string { + return m.display +} + +// numberLiteralMatcher matches number literal tokens. Port of +// NumberLiteralMatcher. +type numberLiteralMatcher struct { + matcherMeta +} + +func charIsInitialNumber(c byte) bool { + return (c >= '0' && c <= '9') || c == '.' +} + +func charIsNumberCont(c byte) bool { + return charIsInitialNumber(c) || c == 'e' || c == 'E' || c == '_' +} + +func (m *numberLiteralMatcher) matchInternal(s *state) ParseResult { + tok := s.current() + if tok == nil { + return nil + } + text := tok.Text + if text == "" || !charIsInitialNumber(text[0]) { + return nil + } + // a lone '.' is a dot operator, not a number literal + if text == "." { + return nil + } + scientific := false + for i := 1; i < len(text); i++ { + c := text[i] + if c == 'e' || c == 'E' { + if scientific { + // upstream throws a ParserException here, aborting the + // entire parse rather than failing this alternative + panic(&MatchError{Msg: "Already found scientific notation"}) + } + scientific = true + } + if scientific && (c == '+' || c == '-') { + continue + } + if !charIsNumberCont(c) { + return nil + } + } + offset := tok.Span.Start + length := len(text) + s.advance() + nr := &NumberResult{Number: text} + nr.name = m.name + nr.offset, nr.hasOffset = offset, true + nr.length, nr.hasLength = length, true + return nr +} + +func (m *numberLiteralMatcher) String() string { + return "NUMBER_LITERAL" +} + +// stringLiteralMatcher matches string literal tokens, including prefixed +// forms (E”, N”, X”, B”). Port of StringLiteralMatcher + +// special_string_utils.hpp. +type stringLiteralMatcher struct { + matcherMeta +} + +func specialStringInfo(text string) (StringKind, int) { + if text == "" { + return StringStandard, 0 + } + c := text[0] + if c == '\'' { + return StringStandard, 1 + } + // the second char must be a quote to confirm a special string + if len(text) > 1 && text[1] == '\'' { + switch c { + case 'N', 'n': + return StringNational, 2 + case 'X', 'x': + return StringHexadecimal, 2 + case 'B', 'b': + return StringBit, 2 + case 'E', 'e': + return StringEscape, 2 + } + } + return StringStandard, 1 +} + +func (m *stringLiteralMatcher) matchInternal(s *state) ParseResult { + tok := s.current() + if tok == nil { + return nil + } + text := tok.Text + kind, prefixLen := specialStringInfo(text) + if prefixLen < 1 || len(text) < prefixLen+1 { + return nil + } + if text[prefixLen-1] != '\'' || text[len(text)-1] != '\'' { + return nil + } + offset := tok.Span.Start + length := len(text) + s.advance() + value := strings.ReplaceAll(text[prefixLen:len(text)-1], "''", "'") + sr := &StringResult{Value: value, StringKind: kind} + sr.name = m.name + sr.offset, sr.hasOffset = offset, true + sr.length, sr.hasLength = length, true + return sr +} + +func (m *stringLiteralMatcher) String() string { + return "STRING_LITERAL" +} + +// operatorMatcher matches generic multi-character operator tokens that are +// not claimed by dedicated grammar rules. Port of OperatorMatcher. +type operatorMatcher struct { + matcherMeta +} + +func isOperatorChar(c byte) bool { + switch c { + case '+', '-', '*', '/', '%', '^', '<', '>', '=', '~', '!', '@', '&', '|': + return true + default: + return false + } +} + +func (m *operatorMatcher) matchInternal(s *state) ParseResult { + tok := s.current() + if tok == nil { + return nil + } + text := tok.Text + // exclude the lambda arrow and JSON arrow - these have dedicated + // grammar roles + if text == "->" || text == "->>" { + return nil + } + // single-character operators are handled at specific precedence levels + if len(text) == 1 { + return nil + } + // exclude known comparison operators - handled by ComparisonExpression + switch text { + case "<=", ">=", "!=", "==", "<>": + return nil + } + // exclude LIKE/SIMILAR operators - handled by LikeVariations + switch text { + case "~~", "~~*", "~~~", "~*", "!~~", "!~~*", "!~", "!~*": + return nil + } + for i := 0; i < len(text); i++ { + if !isOperatorChar(text[i]) { + return nil + } + } + offset := tok.Span.Start + length := len(text) + s.advance() + or := &OperatorResult{Operator: text} + or.offset, or.hasOffset = offset, true + or.length, or.hasLength = length, true + return or +} + +func (m *operatorMatcher) String() string { + return "OPERATOR" +} diff --git a/lexer/lexer.go b/lexer/lexer.go new file mode 100644 index 0000000..b850666 --- /dev/null +++ b/lexer/lexer.go @@ -0,0 +1,586 @@ +// Package lexer tokenizes DuckDB SQL. It is a port of DuckDB's parsing +// tokenizer: src/parser/peg/tokenizer/base_tokenizer.cpp with the parser +// behavior overrides from parser_tokenizer.cpp. The PEG matcher is +// token-level, not character-level: this tokenizer runs first, strips +// comments, and emits tokens with byte offsets; the matcher never sees raw +// text. +package lexer + +import ( + "fmt" + "strings" + + "github.com/sqlc-dev/darkwing/token" +) + +// Error is a tokenization error with a byte offset into the input. +type Error struct { + Msg string + Offset int +} + +func (e *Error) Error() string { + return fmt.Sprintf("%s (offset %d)", e.Msg, e.Offset) +} + +type tokenizeState int + +const ( + stateStandard tokenizeState = iota + stateSingleLineComment + stateMultiLineComment + stateQuotedIdentifier + stateStringLiteral + stateKeyword + stateNumeric + stateOperator + stateDollarQuotedString +) + +func stateToKind(state tokenizeState) token.Kind { + switch state { + case stateStandard: + return token.Identifier + case stateSingleLineComment, stateMultiLineComment: + return token.Comment + case stateQuotedIdentifier: + return token.Identifier + case stateStringLiteral: + return token.String + case stateKeyword: + return token.Keyword + case stateNumeric: + return token.Number + case stateOperator: + return token.Operator + case stateDollarQuotedString: + return token.String + default: + panic("unknown tokenize state") + } +} + +func isUnterminatedState(state tokenizeState) bool { + switch state { + case stateStringLiteral, stateQuotedIdentifier, stateDollarQuotedString: + return true + default: + return false + } +} + +func charIsSpace(c byte) bool { + return c == ' ' || c == '\t' || c == '\n' || c == '\v' || c == '\f' || c == '\r' +} + +func charIsDigit(c byte) bool { + return c >= '0' && c <= '9' +} + +// charIsOperatorAny is StringUtil::CharacterIsOperator: any ASCII +// punctuation except underscore. +func charIsOperatorAny(c byte) bool { + if c == '_' { + return false + } + if c >= '!' && c <= '/' { + return true + } + if c >= ':' && c <= '@' { + return true + } + if c >= '[' && c <= '`' { + return true + } + if c >= '{' && c <= '~' { + return true + } + return false +} + +func isSingleByteOperator(c byte) bool { + switch c { + case '(', ')', '{', '}', '[', ']', ',', '?', '$', '-', '#': + return true + default: + return false + } +} + +func charIsInitialNumber(c byte) bool { + return charIsDigit(c) || c == '.' +} + +func charIsNumber(c byte) bool { + if charIsInitialNumber(c) { + return true + } + switch c { + case 'e', 'E', '_': // exponents and separators + return true + default: + return false + } +} + +func charIsScientific(c byte) bool { + return c == 'e' || c == 'E' +} + +func charIsControlFlow(c byte) bool { + switch c { + case '\'', '-', ';', '"', '.': + return true + default: + return false + } +} + +func charIsKeyword(c byte) bool { + if isSingleByteOperator(c) { + return false + } + if charIsOperatorAny(c) { + return false + } + if charIsSpace(c) { + return false + } + if charIsControlFlow(c) { + return false + } + return true +} + +// charIsOperatorCont reports whether c may continue a multi-character +// operator token (Tokenizer::CharacterIsOperator). +func charIsOperatorCont(c byte) bool { + if isSingleByteOperator(c) { + return false + } + if charIsControlFlow(c) { + return false + } + return charIsOperatorAny(c) +} + +func charIsSpecialStringPrefix(c byte) bool { + switch c { + case 'N', 'n', 'X', 'x', 'E', 'e', 'B', 'b': + return true + default: + return false + } +} + +// isValidDollarTagChar reports whether c may appear in a dollar-quote tag: +// A-Z, a-z, 0-9, underscore, or \200-\377. Digits are only valid after the +// first character; callers validate that before scanning. +func isValidDollarTagChar(c byte) bool { + if c >= 'A' && c <= 'Z' { + return true + } + if c >= 'a' && c <= 'z' { + return true + } + if c >= '0' && c <= '9' { + return true + } + if c == '_' { + return true + } + return c >= 0x80 +} + +// specialOperator reports whether a multi-character special operator starts +// at sql[pos] and returns its length (Tokenizer::IsSpecialOperator). +func specialOperator(sql string, pos int) (int, bool) { + if pos+2 < len(sql) && sql[pos:pos+3] == "->>" { + return 3, true + } + if pos+1 >= len(sql) { + // 2-byte operators are out-of-bounds + return 0, false + } + switch sql[pos : pos+2] { + case "::", ":=", "->", "**", "//": + return 2, true + } + return 0, false +} + +type lexer struct { + sql string + tokens []token.Token +} + +func (l *lexer) push(kind token.Kind, text string, offset int) { + l.tokens = append(l.tokens, token.Token{ + Kind: kind, + Text: text, + Span: token.Span{Start: offset, End: offset + len(text)}, + }) +} + +// pushRange is TokenizerBehavior::PushToken with the parser behavior's +// zero-length delimited identifier check: comments and empty ranges are +// dropped. +func (l *lexer) pushRange(start, end int, kind token.Kind, unterminated bool) error { + if kind == token.Identifier && end == start+2 && l.sql[start:end] == `""` { + return &Error{Msg: "zero-length delimited identifier", Offset: start} + } + if kind == token.Comment { + return nil + } + if start >= end { + return nil + } + l.tokens = append(l.tokens, token.Token{ + Kind: kind, + Text: l.sql[start:end], + Span: token.Span{Start: start, End: end}, + Unterminated: unterminated, + }) + return nil +} + +// Tokenize splits sql into tokens for the PEG matcher. Comments are +// filtered out; every ';' becomes a Terminator token (statement boundaries +// are determined by the grammar, not the tokenizer); an EndOfInput sentinel +// is always appended. Errors carry byte offsets and match the conditions +// upstream's parser tokenizer raises: unterminated string literals, +// unterminated quoted identifiers, and zero-length delimited identifiers. +func Tokenize(sql string) ([]token.Token, error) { + l := &lexer{sql: sql} + if err := l.run(); err != nil { + return nil, err + } + l.push(token.EndOfInput, "", len(sql)) + return l.tokens, nil +} + +func (l *lexer) run() error { + sql := l.sql + n := len(sql) + state := stateStandard + lastPos := 0 + escapeString := false + dollarQuoteMarker := "" + dollarMarkerStart := 0 + multiLineCommentDepth := 0 + + for i := 0; i < n; i++ { + c := sql[i] + switch state { + case stateStandard: + if c == '\'' { + state = stateStringLiteral + lastPos = i + escapeString = false + break + } + if c == '"' { + state = stateQuotedIdentifier + lastPos = i + break + } + if c == ';' { + // end of statement - always emitted as a Terminator token + // so the grammar can consume it + l.push(token.Terminator, ";", i) + lastPos = i + 1 + break + } + if c == '$' { + // dollar-quoted string, parameter, or collabel parameter + if i+1 >= n { + // we need more than a single dollar + break + } + if sql[i+1] >= '0' && sql[i+1] <= '9' { + // $[numeric] is a parameter, not a dollar-quoted string + l.push(token.Operator, "$", i) + break + } + // scan until next $ + nextDollar := 0 + for idx := i + 1; idx < n; idx++ { + if sql[idx] == '$' { + nextDollar = idx + break + } + if !isValidDollarTagChar(sql[idx]) { + break + } + } + if nextDollar == 0 { + // collabel parameter ($collabel) + l.push(token.Operator, "$", i) + break + } + state = stateDollarQuotedString + lastPos = i + i = nextDollar + // found a complete marker, store it + dollarMarkerStart = lastPos + 1 + dollarQuoteMarker = sql[dollarMarkerStart:i] + break + } + if c == '-' && i+1 < n && sql[i+1] == '-' { + i++ + state = stateSingleLineComment + break + } + if c == '/' && i+1 < n && sql[i+1] == '*' { + i++ + state = stateMultiLineComment + multiLineCommentDepth = 1 + break + } + if charIsSpace(c) { + lastPos = i + 1 + break + } + if opLen, ok := specialOperator(sql, i); ok { + // special operator - pushed with lastPos as its offset, + // exactly as upstream does + l.push(token.Operator, sql[i:i+opLen], lastPos) + i += opLen - 1 + lastPos = i + 1 + break + } + if isSingleByteOperator(c) { + l.push(token.Operator, string(c), lastPos) + lastPos = i + 1 + break + } + if charIsInitialNumber(c) { + state = stateNumeric + lastPos = i + break + } + if charIsSpecialStringPrefix(c) { + // look ahead to see if a quote follows + if i+1 < n && sql[i+1] == '\'' { + state = stateStringLiteral + lastPos = i + if c == 'E' || c == 'e' { + escapeString = true + } + i++ + break + } + } + if charIsOperatorAny(c) { + state = stateOperator + lastPos = i + break + } + state = stateKeyword + lastPos = i + + case stateNumeric: + // "always allowed" numeric characters + if charIsInitialNumber(c) { + break + } + // underscore only when immediately followed by a digit + if c == '_' && i+1 < n && charIsInitialNumber(sql[i+1]) { + break + } + // scientific notation marker + if charIsScientific(c) && !charIsScientific(sql[i-1]) { + // require at least one digit before 'e'/'E' + if charIsDigit(sql[lastPos]) || charIsDigit(sql[i-1]) { + break + } + } + // '+' or '-' is only valid directly after the exponent marker + if (c == '+' || c == '-') && charIsScientific(sql[i-1]) { + break + } + // end of number: backtrack to the last plain numeric character + for !charIsInitialNumber(sql[i-1]) { + i-- + } + if err := l.pushRange(lastPos, i, token.Number, false); err != nil { + return err + } + state = stateStandard + lastPos = i + i-- + + case stateOperator: + if !charIsOperatorCont(c) { + // PostgreSQL trimming rule: an operator cannot end in '+' + // unless it contains at least one of: ~ ! @ # % ^ & | ` ? + endPos := i + hasSpecial := false + for j := lastPos; j < endPos; j++ { + switch sql[j] { + case '~', '!', '@', '#', '%', '^', '&', '|', '`', '?': + hasSpecial = true + } + if hasSpecial { + break + } + } + if !hasSpecial { + for endPos > lastPos && sql[endPos-1] == '+' { + endPos-- + } + } + if err := l.pushRange(lastPos, endPos, token.Operator, false); err != nil { + return err + } + // push any trimmed '+' characters as individual tokens + for j := endPos; j < i; j++ { + l.push(token.Operator, string(sql[j]), j) + } + state = stateStandard + lastPos = i + i-- + } + + case stateKeyword: + // '$' is valid as a non-initial identifier character + if c != '$' && !charIsKeyword(c) { + word := sql[lastPos:i] + kind := token.Identifier + if token.IsKeyword(word) { + kind = token.Keyword + } + if err := l.pushRange(lastPos, i, kind, false); err != nil { + return err + } + state = stateStandard + lastPos = i + i-- + } + + case stateStringLiteral: + if escapeString && c == '\\' && i+1 < n { + i++ + break + } + if c == '\'' { + if i+1 < n && sql[i+1] == '\'' { + // escaped - skip escape + i++ + } else { + if err := l.pushRange(lastPos, i+1, token.String, false); err != nil { + return err + } + lastPos = i + 1 + escapeString = false + state = stateStandard + } + } + + case stateQuotedIdentifier: + if c == '"' { + if i+1 < n && sql[i+1] == '"' { + // escaped - skip escape + i++ + } else { + if err := l.pushRange(lastPos, i+1, token.Identifier, false); err != nil { + return err + } + lastPos = i + 1 + state = stateStandard + } + } + + case stateSingleLineComment: + if c == '\n' || c == '\r' { + if err := l.pushRange(lastPos, i+1, token.Comment, false); err != nil { + return err + } + lastPos = i + 1 + state = stateStandard + } + + case stateMultiLineComment: + if c == '/' && i+1 < n && sql[i+1] == '*' { + i++ + multiLineCommentDepth++ + } else if c == '*' && i+1 < n && sql[i+1] == '/' { + i++ + multiLineCommentDepth-- + if multiLineCommentDepth == 0 { + if err := l.pushRange(lastPos, i+1, token.Comment, false); err != nil { + return err + } + lastPos = i + 1 + state = stateStandard + } + } + + case stateDollarQuotedString: + // all that will get us out is a $[marker]$ + if c != '$' { + break + } + if i+1 >= n { + // no room for the final dollar + break + } + // skip to the next dollar symbol + start := i + 1 + end := start + for end < n && sql[end] != '$' { + end++ + } + if end >= n { + // no final dollar, continue as normal + break + } + if end-start != len(dollarQuoteMarker) { + // length mismatch, cannot match + break + } + if sql[start:start+len(dollarQuoteMarker)] != dollarQuoteMarker { + // marker mismatch + break + } + // marker found - rewrite to a plain quoted literal, exactly as + // upstream does + fullMarkerLen := len(dollarQuoteMarker) + 2 + quoted := sql[lastPos : start+len(dollarQuoteMarker)+1] + content := quoted[fullMarkerLen : len(quoted)-fullMarkerLen] + content = strings.ReplaceAll(content, "'", "''") + quoted = "'" + content + "'" + // upstream records the rewritten text's length, not the source + // extent, so the span is Start + len(Text) + l.push(token.String, quoted, dollarMarkerStart-1) + dollarQuoteMarker = "" + state = stateStandard + i = end + lastPos = i + 1 + } + } + + switch state { + case stateSingleLineComment, stateMultiLineComment: + return l.pushRange(lastPos, n, token.Comment, false) + case stateDollarQuotedString: + return l.pushRange(lastPos, n, token.String, true) + } + + // last token handling (parser behavior: unterminated strings and quoted + // identifiers are errors) + switch state { + case stateStringLiteral: + return &Error{Msg: "unterminated string literal", Offset: lastPos} + case stateQuotedIdentifier: + return &Error{Msg: "unterminated quoted identifier", Offset: lastPos} + } + lastWord := sql[lastPos:] + if len(lastWord) == 0 { + return nil + } + if state == stateKeyword && !token.IsKeyword(lastWord) { + state = stateStandard + } + return l.pushRange(lastPos, n, stateToKind(state), isUnterminatedState(state)) +} diff --git a/lexer/lexer_test.go b/lexer/lexer_test.go new file mode 100644 index 0000000..b1f373c --- /dev/null +++ b/lexer/lexer_test.go @@ -0,0 +1,320 @@ +package lexer + +import ( + "errors" + "testing" + + "github.com/sqlc-dev/darkwing/token" +) + +type tok struct { + kind token.Kind + text string + start int +} + +func check(t *testing.T, sql string, want []tok) { + t.Helper() + got, err := Tokenize(sql) + if err != nil { + t.Fatalf("Tokenize(%q): %v", sql, err) + } + // every token stream ends with the EndOfInput sentinel + if len(got) == 0 || got[len(got)-1].Kind != token.EndOfInput { + t.Fatalf("Tokenize(%q): missing EndOfInput sentinel: %v", sql, got) + } + if got[len(got)-1].Span.Start != len(sql) { + t.Errorf("Tokenize(%q): sentinel offset = %d, want %d", sql, got[len(got)-1].Span.Start, len(sql)) + } + body := got[:len(got)-1] + if len(body) != len(want) { + t.Fatalf("Tokenize(%q) = %v, want %v", sql, body, want) + } + for i, w := range want { + g := body[i] + if g.Kind != w.kind || g.Text != w.text || g.Span.Start != w.start { + t.Errorf("Tokenize(%q)[%d] = %v, want %s(%q)@%d", sql, i, g, w.kind, w.text, w.start) + } + } +} + +func checkErr(t *testing.T, sql, msg string, offset int) { + t.Helper() + _, err := Tokenize(sql) + var lexErr *Error + if !errors.As(err, &lexErr) { + t.Fatalf("Tokenize(%q): err = %v, want *Error", sql, err) + } + if lexErr.Msg != msg || lexErr.Offset != offset { + t.Errorf("Tokenize(%q): err = %q@%d, want %q@%d", sql, lexErr.Msg, lexErr.Offset, msg, offset) + } +} + +func TestKeywordsAndIdentifiers(t *testing.T) { + check(t, "SELECT a FROM t", []tok{ + {token.Keyword, "SELECT", 0}, + {token.Identifier, "a", 7}, + {token.Keyword, "FROM", 9}, + {token.Identifier, "t", 14}, + }) + // keywords are case-insensitive; the raw spelling is preserved + check(t, "select SeLeCt", []tok{ + {token.Keyword, "select", 0}, + {token.Keyword, "SeLeCt", 7}, + }) + // '$' is a valid non-initial identifier character + check(t, "a$b", []tok{{token.Identifier, "a$b", 0}}) +} + +func TestTerminator(t *testing.T) { + check(t, "SELECT 1; SELECT 2", []tok{ + {token.Keyword, "SELECT", 0}, + {token.Number, "1", 7}, + {token.Terminator, ";", 8}, + {token.Keyword, "SELECT", 10}, + {token.Number, "2", 17}, + }) + check(t, ";;", []tok{ + {token.Terminator, ";", 0}, + {token.Terminator, ";", 1}, + }) +} + +func TestStrings(t *testing.T) { + check(t, "'hello'", []tok{{token.String, "'hello'", 0}}) + // doubled-quote escape stays inside one token + check(t, "'it''s'", []tok{{token.String, "'it''s'", 0}}) + // escape strings: backslash escapes the quote only in E'...' + check(t, `E'a\'b'`, []tok{{token.String, `E'a\'b'`, 0}}) + check(t, "e'x'", []tok{{token.String, "e'x'", 0}}) + // other special string prefixes + check(t, "N'x' X'ff' B'01'", []tok{ + {token.String, "N'x'", 0}, + {token.String, "X'ff'", 5}, + {token.String, "B'01'", 11}, + }) + // prefix letter not followed by a quote is an ordinary identifier + check(t, "Ex 'y'", []tok{ + {token.Identifier, "Ex", 0}, + {token.String, "'y'", 3}, + }) +} + +func TestQuotedIdentifiers(t *testing.T) { + check(t, `"my table"`, []tok{{token.Identifier, `"my table"`, 0}}) + check(t, `"a""b"`, []tok{{token.Identifier, `"a""b"`, 0}}) +} + +func TestDollarQuotedStrings(t *testing.T) { + // empty tag: rewritten to a plain quoted literal + check(t, "$$abc$$", []tok{{token.String, "'abc'", 0}}) + // named tag + check(t, "$tag$abc$tag$", []tok{{token.String, "'abc'", 0}}) + // embedded quotes are doubled during the rewrite + check(t, "$$it's$$", []tok{{token.String, "'it''s'", 0}}) + // mismatched inner marker does not close the string + check(t, "$a$x$b$y$a$", []tok{{token.String, "'x$b$y'", 0}}) + // $1 is a parameter, never a dollar-quote opener + check(t, "$1", []tok{ + {token.Operator, "$", 0}, + {token.Number, "1", 1}, + }) + // $tag with no closing dollar is a collabel parameter ("name" itself + // is an unreserved keyword, so use a non-keyword tag) + check(t, "$xyz", []tok{ + {token.Operator, "$", 0}, + {token.Identifier, "xyz", 1}, + }) + // an invalid tag character stops the marker scan: parameter again + check(t, "$na-me$x$na-me$", []tok{ + {token.Operator, "$", 0}, + {token.Identifier, "na", 1}, + {token.Operator, "-", 3}, + {token.Identifier, "me$x$na", 4}, + {token.Operator, "-", 11}, + {token.Identifier, "me$", 12}, + }) + // unterminated dollar-quote: raw text token flagged unterminated + got, err := Tokenize("$$abc") + if err != nil { + t.Fatal(err) + } + if got[0].Text != "$$abc" || !got[0].Unterminated || got[0].Kind != token.String { + t.Errorf("unterminated dollar quote = %v", got[0]) + } +} + +func TestParameters(t *testing.T) { + check(t, "? $1 $abc", []tok{ + {token.Operator, "?", 0}, + {token.Operator, "$", 2}, + {token.Number, "1", 3}, + {token.Operator, "$", 5}, + {token.Identifier, "abc", 6}, + }) + // trailing lone '$' at end of input becomes an identifier-typed token + // (upstream's last-token handling in the STANDARD state) + check(t, "SELECT $", []tok{ + {token.Keyword, "SELECT", 0}, + {token.Identifier, "$", 7}, + }) +} + +func TestNumbers(t *testing.T) { + check(t, "1 1.5 .5 1e5 1.5e-3 1E+2", []tok{ + {token.Number, "1", 0}, + {token.Number, "1.5", 2}, + {token.Number, ".5", 6}, + {token.Number, "1e5", 9}, + {token.Number, "1.5e-3", 13}, + {token.Number, "1E+2", 20}, + }) + // hex literals lex as number then identifier-ish keyword state: + // 0x1A: '0' begins numeric; 'x' is not a number char -> backtrack + check(t, "0x1A", []tok{ + {token.Number, "0", 0}, + {token.Identifier, "x1A", 1}, + }) + // underscore separators: only underscore-digit is allowed + check(t, "1_000", []tok{{token.Number, "1_000", 0}}) + check(t, "1__0", []tok{ + {token.Number, "1", 0}, + {token.Identifier, "__0", 1}, + }) + // double exponent splits at the second marker + check(t, "1ee5", []tok{ + {token.Number, "1", 0}, + {token.Identifier, "ee5", 1}, + }) + // '+' only continues the number directly after the exponent marker + check(t, "1+5", []tok{ + {token.Number, "1", 0}, + {token.Operator, "+", 1}, + {token.Number, "5", 2}, + }) + // ".e100" is not a number: no digit before the marker + check(t, ".e100", []tok{ + {token.Number, ".", 0}, + {token.Identifier, "e100", 1}, + }) +} + +func TestOperators(t *testing.T) { + check(t, "a::b", []tok{ + {token.Identifier, "a", 0}, + {token.Operator, "::", 1}, + {token.Identifier, "b", 3}, + }) + check(t, "j->'k' j->>'k'", []tok{ + {token.Identifier, "j", 0}, + {token.Operator, "->", 1}, + {token.String, "'k'", 3}, + {token.Identifier, "j", 7}, + {token.Operator, "->>", 8}, + {token.String, "'k'", 11}, + }) + check(t, "2**3 7//2 x:=1", []tok{ + {token.Number, "2", 0}, + {token.Operator, "**", 1}, + {token.Number, "3", 3}, + {token.Number, "7", 5}, + {token.Operator, "//", 6}, + {token.Number, "2", 8}, + {token.Identifier, "x", 10}, + {token.Operator, ":=", 11}, + {token.Number, "1", 13}, + }) + // multi-character operator tokens + check(t, "a >= b <> c", []tok{ + {token.Identifier, "a", 0}, + {token.Operator, ">=", 2}, + {token.Identifier, "b", 5}, + {token.Operator, "<>", 7}, + {token.Identifier, "c", 10}, + }) + // single-byte operators are individual tokens + check(t, "(a, b)", []tok{ + {token.Operator, "(", 0}, + {token.Identifier, "a", 1}, + {token.Operator, ",", 2}, + {token.Identifier, "b", 4}, + {token.Operator, ")", 5}, + }) + // PostgreSQL trimming rule: an operator cannot end in '+' unless it + // contains one of ~ ! @ # % ^ & | ` ? + check(t, "a=+b", []tok{ + {token.Identifier, "a", 0}, + {token.Operator, "=", 1}, + {token.Operator, "+", 2}, + {token.Identifier, "b", 3}, + }) + check(t, "a@+b", []tok{ + {token.Identifier, "a", 0}, + {token.Operator, "@+", 1}, + {token.Identifier, "b", 3}, + }) + // '!=' stays one operator token + check(t, "a != b", []tok{ + {token.Identifier, "a", 0}, + {token.Operator, "!=", 2}, + {token.Identifier, "b", 5}, + }) +} + +func TestComments(t *testing.T) { + // comments are filtered out entirely + check(t, "SELECT 1 -- trailing", []tok{ + {token.Keyword, "SELECT", 0}, + {token.Number, "1", 7}, + }) + check(t, "-- line\nSELECT 1", []tok{ + {token.Keyword, "SELECT", 8}, + {token.Number, "1", 15}, + }) + check(t, "SELECT /* mid */ 1", []tok{ + {token.Keyword, "SELECT", 0}, + {token.Number, "1", 17}, + }) + // block comments nest + check(t, "SELECT /* a /* b */ c */ 1", []tok{ + {token.Keyword, "SELECT", 0}, + {token.Number, "1", 25}, + }) + // unterminated comments are not an error: the rest is a comment + check(t, "SELECT 1 /* open", []tok{ + {token.Keyword, "SELECT", 0}, + {token.Number, "1", 7}, + }) +} + +func TestErrors(t *testing.T) { + checkErr(t, "SELECT 'abc", "unterminated string literal", 7) + checkErr(t, `SELECT "abc`, "unterminated quoted identifier", 7) + checkErr(t, `SELECT ""`, "zero-length delimited identifier", 7) +} + +func TestLastTokenStates(t *testing.T) { + // number at end of input is pushed without backtracking + check(t, "SELECT 1e", []tok{ + {token.Keyword, "SELECT", 0}, + {token.Number, "1e", 7}, + }) + // operator at end of input + check(t, "1 =", []tok{ + {token.Number, "1", 0}, + {token.Operator, "=", 2}, + }) + // keyword state at end resolves against the keyword table + check(t, "SELECT", []tok{{token.Keyword, "SELECT", 0}}) + check(t, "selectx", []tok{{token.Identifier, "selectx", 0}}) +} + +func TestEmptyInput(t *testing.T) { + got, err := Tokenize("") + if err != nil { + t.Fatal(err) + } + if len(got) != 1 || got[0].Kind != token.EndOfInput { + t.Errorf("Tokenize(\"\") = %v, want only the sentinel", got) + } +} diff --git a/token/keywords.go b/token/keywords.go new file mode 100644 index 0000000..1dc8caa --- /dev/null +++ b/token/keywords.go @@ -0,0 +1,143 @@ +package token + +import ( + "fmt" + "strings" + "sync" + + "github.com/sqlc-dev/darkwing/internal/grammar" +) + +// KeywordCategory is a bitmask of DuckDB keyword categories, one bit per +// vendored .list file. Upstream's build script enforces that a keyword is +// never both reserved and unreserved, but the remaining lists overlap (32 +// keywords appear in two lists at the current pin, e.g. GENERATED is both +// a column-name and a func-name keyword), so membership is a set, not a +// single category. The categories decide which identifier positions may +// consume the keyword (PEGKeywordCategory in +// duckdb/parser/peg/keyword_helper.hpp). +type KeywordCategory uint8 + +const ( + // KeywordReserved keywords can never be used as bare identifiers. + KeywordReserved KeywordCategory = 1 << iota + // KeywordUnreserved keywords are allowed in any identifier position. + KeywordUnreserved + // KeywordColumnName keywords are allowed as column names. + KeywordColumnName + // KeywordFuncName keywords are allowed as function names. + KeywordFuncName + // KeywordTypeName keywords are allowed as type names and, like + // func-name keywords, as function names (upstream folds both lists + // into its type/func map). + KeywordTypeName + + // KeywordNone means the word is not a keyword. + KeywordNone KeywordCategory = 0 +) + +// Has reports whether c includes category. +func (c KeywordCategory) Has(category KeywordCategory) bool { + return c&category != 0 +} + +func (c KeywordCategory) String() string { + if c == KeywordNone { + return "none" + } + var parts []string + for _, entry := range []struct { + bit KeywordCategory + name string + }{ + {KeywordReserved, "reserved"}, + {KeywordUnreserved, "unreserved"}, + {KeywordColumnName, "column_name"}, + {KeywordFuncName, "func_name"}, + {KeywordTypeName, "type_name"}, + } { + if c.Has(entry.bit) { + parts = append(parts, entry.name) + } + } + if len(parts) == 0 { + return fmt.Sprintf("KeywordCategory(%d)", uint8(c)) + } + return strings.Join(parts, "|") +} + +var ( + keywordOnce sync.Once + keywordMap map[string]KeywordCategory + keywordErr error +) + +func listCategory(file string) KeywordCategory { + switch file { + case "reserved_keyword.list": + return KeywordReserved + case "unreserved_keyword.list": + return KeywordUnreserved + case "column_name_keyword.list": + return KeywordColumnName + case "func_name_keyword.list": + return KeywordFuncName + case "type_name_keyword.list": + return KeywordTypeName + default: + return KeywordNone + } +} + +func keywords() map[string]KeywordCategory { + keywordOnce.Do(func() { + m := make(map[string]KeywordCategory) + for _, list := range grammar.KeywordLists() { + words, err := grammar.Keywords(list.File) + if err != nil { + keywordErr = err + return + } + category := listCategory(list.File) + for _, w := range words { + m[w] |= category + } + } + // the only disjointness upstream's build script enforces + for w, c := range m { + if c.Has(KeywordReserved) && c.Has(KeywordUnreserved) { + keywordErr = fmt.Errorf("keyword %q has conflicting RESERVED/UNRESERVED categories", w) + return + } + } + keywordMap = m + }) + if keywordErr != nil { + panic(keywordErr) + } + return keywordMap +} + +// Categories returns the category set of word (case-insensitive); +// KeywordNone if word is not a keyword. +func Categories(word string) KeywordCategory { + return keywords()[strings.ToLower(word)] +} + +// IsKeyword reports whether word (case-insensitive) is a keyword in any +// category. +func IsKeyword(word string) bool { + return Categories(word) != KeywordNone +} + +// KeywordCount returns the number of keywords carrying the given category +// bit, or the number of distinct keywords for KeywordNone. +func KeywordCount(category KeywordCategory) int { + n := 0 + for _, c := range keywords() { + if category == KeywordNone || c.Has(category) { + n++ + } + } + return n +} diff --git a/token/keywords_test.go b/token/keywords_test.go new file mode 100644 index 0000000..0fe3f59 --- /dev/null +++ b/token/keywords_test.go @@ -0,0 +1,119 @@ +package token + +import ( + "sort" + "testing" + + "github.com/sqlc-dev/darkwing/internal/grammar" +) + +// Per-list keyword counts at the current pin. A pin advance that changes +// these is expected to update this test alongside the vendored lists. +func TestKeywordListCounts(t *testing.T) { + counts := map[string]int{ + "reserved_keyword.list": 75, + "unreserved_keyword.list": 339, + "column_name_keyword.list": 55, + "func_name_keyword.list": 30, + "type_name_keyword.list": 32, + } + total := 0 + for _, list := range grammar.KeywordLists() { + words, err := grammar.Keywords(list.File) + if err != nil { + t.Fatalf("Keywords(%s): %v", list.File, err) + } + if got, want := len(words), counts[list.File]; got != want { + t.Errorf("%s: %d keywords, want %d", list.File, got, want) + } + total += len(words) + } + if total != 531 { + t.Errorf("total keyword entries = %d, want 531", total) + } +} + +func TestCategoryCounts(t *testing.T) { + for _, tc := range []struct { + category KeywordCategory + want int + }{ + {KeywordReserved, 75}, + {KeywordUnreserved, 339}, + {KeywordColumnName, 55}, + {KeywordFuncName, 30}, + {KeywordTypeName, 32}, + } { + if got := KeywordCount(tc.category); got != tc.want { + t.Errorf("KeywordCount(%s) = %d, want %d", tc.category, got, tc.want) + } + } +} + +// Upstream's build script enforces only that no keyword is both reserved +// and unreserved; the other lists overlap. Pin the exact overlap set so a +// pin advance surfaces membership changes. +func TestReservedUnreservedDisjoint(t *testing.T) { + reserved, err := grammar.Keywords("reserved_keyword.list") + if err != nil { + t.Fatal(err) + } + for _, w := range reserved { + if Categories(w).Has(KeywordUnreserved) { + t.Errorf("keyword %q is both reserved and unreserved", w) + } + } +} + +func TestMultiCategoryKeywords(t *testing.T) { + single := func(c KeywordCategory) bool { + return c&(c-1) == 0 + } + var multi []string + lists := make(map[string][]string) + for _, list := range grammar.KeywordLists() { + words, err := grammar.Keywords(list.File) + if err != nil { + t.Fatal(err) + } + lists[list.File] = words + } + seen := map[string]bool{} + for _, words := range lists { + for _, w := range words { + if !seen[w] && !single(Categories(w)) { + multi = append(multi, w) + } + seen[w] = true + } + } + sort.Strings(multi) + // 32 keywords appear in two lists at the current pin + if len(multi) != 32 { + t.Errorf("multi-category keywords = %d (%v), want 32", len(multi), multi) + } + // spot-check the documented examples + if got := Categories("generated"); got != KeywordColumnName|KeywordFuncName { + t.Errorf("Categories(generated) = %s", got) + } + if got := Categories("map"); got != KeywordColumnName|KeywordFuncName { + t.Errorf("Categories(map) = %s", got) + } + if got := Categories("is"); got != KeywordFuncName|KeywordTypeName { + t.Errorf("Categories(is) = %s", got) + } +} + +func TestCategoriesCaseInsensitive(t *testing.T) { + for _, w := range []string{"select", "SELECT", "Select", "sElEcT"} { + if got := Categories(w); !got.Has(KeywordReserved) { + t.Errorf("Categories(%q) = %s, want reserved", w, got) + } + } + if IsKeyword("definitely_not_a_keyword") { + t.Error("IsKeyword(definitely_not_a_keyword) = true") + } + if !IsKeyword("abort") { + t.Error("IsKeyword(abort) = false, want true (unreserved)") + } +} diff --git a/token/token.go b/token/token.go new file mode 100644 index 0000000..978d5e7 --- /dev/null +++ b/token/token.go @@ -0,0 +1,85 @@ +// Package token defines the lexical tokens of the DuckDB SQL dialect as +// produced by darkwing's tokenizer, plus DuckDB's five-category keyword +// classification. The kinds mirror the parser-relevant subset of DuckDB's +// TokenType (src/include/duckdb/parser/peg/token_type.hpp). +package token + +import "fmt" + +// Kind classifies a token. +type Kind uint8 + +const ( + // Invalid is the zero Kind; the tokenizer never emits it. + Invalid Kind = iota + // Keyword is a bare word that appears in one of the keyword lists. + Keyword + // String is a string literal, including prefixed (E'...', X'...', + // N'...', B'...') and dollar-quoted forms (already normalized to a + // plain quoted literal by the tokenizer, as upstream does). + String + // Number is a numeric literal. + Number + // Operator is an operator token (including '(' ')' ',' '$' '?' etc.). + Operator + // Identifier is a bare word that is not a keyword, or a quoted + // identifier (quotes retained in Text; the matcher unwraps them). + Identifier + // Comment is a comment token. The parsing tokenizer filters comments + // out; the Kind exists to mirror upstream's classification. + Comment + // Terminator is a statement-terminating ';'. The PEG grammar consumes + // it (TopLevelStatement); statement boundaries are decided by the + // grammar, not the tokenizer. + Terminator + // EndOfInput is the sentinel appended after the last real token. + EndOfInput +) + +func (k Kind) String() string { + switch k { + case Invalid: + return "INVALID" + case Keyword: + return "KEYWORD" + case String: + return "STRING_LITERAL" + case Number: + return "NUMBER_LITERAL" + case Operator: + return "OPERATOR" + case Identifier: + return "IDENTIFIER" + case Comment: + return "COMMENT" + case Terminator: + return "TERMINATOR" + case EndOfInput: + return "END_OF_INPUT" + default: + return fmt.Sprintf("Kind(%d)", uint8(k)) + } +} + +// Span is a half-open byte range [Start, End) into the original SQL text. +type Span struct { + Start int + End int +} + +// Token is a single lexical token. Text is the raw source slice except for +// dollar-quoted strings, which the tokenizer rewrites to an equivalent +// plain quoted literal while Span still covers the original source (the +// same behavior as upstream's MatcherToken). +type Token struct { + Kind Kind + Text string + Span Span + // Unterminated marks a token that ran into end of input (an unclosed + // dollar-quoted string). + Unterminated bool +} + +func (t Token) String() string { + return fmt.Sprintf("%s(%q)@%d", t.Kind, t.Text, t.Span.Start) +} From d4cbc42547ce8e6766c7d27687508522cde22f4b Mon Sep 17 00:00:00 2001 From: Claude Date: Thu, 20 Aug 2026 22:21:21 +0000 Subject: [PATCH 2/3] Milestone 2: conformance corpus and the accept/reject gate MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Advance the pin to 8cbdaba6acb50db7780d22a65dd131584d472262, the commit of the DuckDB nightly CLI v2.0.0-alpha38195 (the oracle): grammar, corpus expectations, and oracle must come from the same commit, and the nightly is the pin we can verify against. Re-vendor the grammar (describe.gram, select.gram, create_view.gram, one unreserved keyword removed) and update the provenance README and keyword-count tests. New corpus machinery, per PLAN.md § Conformance oracle and corpus: - internal/sqltest: sqllogictest .test reader, extraction only. Records end at empty-or-comment lines exactly as upstream's SQLLogicParser does; template substitutions (${...}) are skipped, never expanded. - internal/testfile: the consolidated corpus format (cases separated by ==, SQL/expectation by --) plus *.metadata.json todo/skip sidecars keyed by case content hash so entries survive regeneration. - internal/duckdbsrc: locate and verify the pinned CLI, run statements against :memory: with extension autoloading disabled, classify Parser Error (must-reject) vs success/post-parse errors (must-accept). - cmd/regenerate: extract test/sql/**/*.test + test/fuzzer/**/*.test, dedup, run the oracle concurrently, write parser/testdata. Expectations are never edited by hand. - cmd/next-test: print the next todo case from corpus metadata. - parser/parser_test.go: the corpus harness and milestone-2 gate, with -check-parse case dumps and -record-todos triage (auto-records only transformer-raised rejects; engine disagreements always fail). Corpus: 4,071 files, 45,226 unique statements (43,819 must-accept, 1,407 must-reject) from 4,178 upstream .test files. The gate is green: every grammar-level accept/reject decision agrees with the pinned binary. 290 cases are todo (upstream rejects them in its transformer - positional reference bounds, chained comparisons, recursive-CTE modifier checks, VALUES arity, and similar - which land with milestones 3-5), and 11 are skipped with notes (parser-extension records and nested bind-time parses the grammar never sees). Co-Authored-By: Claude Claude-Session: https://claude.ai/code/session_01CTQBC9AzfdFPFsZtwn1mHY --- .gitignore | 4 + CLAUDE.md | 41 +- README.md | 9 +- cmd/next-test/main.go | 86 ++ cmd/regenerate/main.go | 287 +++++ internal/duckdbsrc/duckdbsrc.go | 160 +++ internal/grammar/README.md | 16 +- .../duckdb/keywords/unreserved_keyword.list | 1 - .../duckdb/statements/create_view.gram | 3 +- .../grammar/duckdb/statements/describe.gram | 29 +- .../grammar/duckdb/statements/select.gram | 3 +- internal/sqltest/sqltest.go | 134 +++ internal/sqltest/sqltest_test.go | 85 ++ internal/testfile/testfile.go | 257 ++++ internal/testfile/testfile_test.go | 97 ++ parser/parser_test.go | 238 ++++ parser/testdata/README.md | 17 + .../corpus/fuzzer/afl/alter_if_exists.test | 13 + .../fuzzer/afl/analyze_empty_table.test | 17 + .../corpus/fuzzer/afl/case_map_cast.test | 9 + .../fuzzer/afl/decimal_string_roundtrip.test | 37 + .../fuzzer/afl/generate_series_null.test | 41 + .../fuzzer/afl/grouping_empty_table.test | 13 + .../fuzzer/afl/invalid_foreign_key.test | 9 + .../corpus/fuzzer/afl/issue_7551.test | 29 + .../corpus/fuzzer/afl/issue_8185.test | 13 + .../corpus/fuzzer/afl/limit_out_of_range.test | 17 + .../fuzzer/afl/non_foldable_parameter.test | 13 + .../corpus/fuzzer/afl/random_join.test | 13 + .../fuzzer/afl/self_referential_alias.test | 21 + .../afl/window_function_binder_error.test | 13 + .../fuzzer/afl/window_type_mismatch.test | 13 + .../duckfuzz/arg_minmax_by_decimal.test | 23 + .../duckfuzz/array_const_columndatacopy.test | 21 + .../duckfuzz/array_const_null_cast.test | 17 + .../fuzzer/duckfuzz/array_distance.test | 17 + .../duckfuzz/array_group_by_sample.test | 37 + .../corpus/fuzzer/duckfuzz/array_hash.test | 23 + .../duckfuzz/array_list_gather_cast.test | 22 + .../array_serialization_flattening.test | 13 + .../fuzzer/duckfuzz/array_slice_nullness.test | 13 + .../duckfuzz/array_slice_underflow.test | 13 + .../duckfuzz/array_slice_vector_type.test | 46 + .../duckfuzz/arrow_scan_subquery_nullptr.test | 9 + .../fuzzer/duckfuzz/bitstring_agg_minmax.test | 25 + .../duckfuzz/bitstring_agg_uhugeint.test | 17 + .../duckfuzz/bitstring_agg_unfoldable.test | 25 + .../fuzzer/duckfuzz/column_alias_exist.test | 13 + .../complex_join_cardinality_assert.test | 13 + .../compressed_materialization_hugeint.test | 13 + .../compressed_materialization_json.test | 9 + .../duckfuzz/correlated_subqueries.test | 43 + .../fuzzer/duckfuzz/corrupted_parquet.test | 15 + .../duckfuzz/create_sort_key_strings.test | 25 + .../duck_fuzz_column_binding_tests.test | 21 + .../fuzzer/duckfuzz/duckdb_fuzzer_4430.test | 29 + .../empty_result_pullup_delim_joins.test | 30 + .../fuzzer/duckfuzz/enum_const_cast.test | 9 + .../duckfuzz/filter_combiner_assert.test | 13 + .../fuzzer/duckfuzz/fuzzer_issue_2698.test | 9 + .../fuzzer/duckfuzz/fuzzer_issue_2980.test | 9 + .../fuzzer/duckfuzz/fuzzer_issue_4325.test | 9 + .../duckfuzz/generate_null_timestamp.test | 10 + .../duckfuzz/group_by_all_positional_ref.test | 13 + .../corpus/fuzzer/duckfuzz/hash_constant.test | 9 + .../fuzzer/duckfuzz/having_window_bind.test | 47 + .../duckfuzz/hugeint_negate_underflow.test | 9 + .../fuzzer/duckfuzz/invalid_make_time.test | 33 + .../json_execute_serialized_null.test | 13 + .../fuzzer/duckfuzz/json_extract_null.test | 9 + .../duckfuzz/json_extract_string_null.test | 13 + .../duckfuzz/json_functions_null_params.test | 25 + .../fuzzer/duckfuzz/julian_overflow.test | 21 + .../duckfuzz/late_materialization_filter.test | 20 + .../duckfuzz/limit_offset_macro_subquery.test | 9 + .../duckfuzz/limit_percent_subquery.test | 17 + .../corpus/fuzzer/duckfuzz/list_try_cast.test | 33 + .../fuzzer/duckfuzz/list_zip_no_args.test | 13 + .../corpus/fuzzer/duckfuzz/logger_null.test | 9 + .../duckfuzz/map_concat_type_mismatch.test | 17 + .../fuzzer/duckfuzz/null_arguments.test | 45 + .../null_arguments.test.metadata.json | 7 + .../fuzzer/duckfuzz/null_checkpoint.test | 9 + .../corpus/fuzzer/duckfuzz/ordagg_nargs.test | 16 + .../order_by_positional_reference.test | 9 + .../duckfuzz/pivot_aggregate_mismatch.test | 9 + .../duckfuzz/qualify_column_reference.test | 17 + .../read_ndjson_non_varchar_input.test | 13 + .../fuzzer/duckfuzz/regex_syntax_2889.test | 13 + .../regex_syntax_2889.test.metadata.json | 5 + .../duckfuzz/regexp_replace_constant.test | 13 + .../fuzzer/duckfuzz/repeat_row_null.test | 17 + .../fuzzer/duckfuzz/repeat_wrong_number.test | 29 + ...join_has_correct_left_right_relations.test | 51 + .../string_to_nested_cast_sample.test | 16 + .../fuzzer/duckfuzz/strptime_const_arg.test | 15 + .../corpus/fuzzer/duckfuzz/temporal_avg.test | 9 + .../duckfuzz/test_vector_types_double_3.test | 9 + .../fuzzer/duckfuzz/to_weeks_overflow.test | 11 + .../duckfuzz/tuple_data_empty_heap.test | 13 + .../fuzzer/duckfuzz/union_dict_tag.test | 9 + .../fuzzer/duckfuzz/unpivot_multiple_in.test | 9 + .../unpivot_multiple_in.test.metadata.json | 5 + .../duckfuzz/vector_size_out_of_range.test | 9 + .../corpus/fuzzer/duckfuzz/vector_type.test | 29 + ...pressions_in_column_lifetime_analyzer.test | 53 + .../duckfuzz/window_expression_equality.test | 16 + .../fuzzer/duckfuzz/window_negate_stats.test | 11 + .../fuzzer/duckfuzz/window_null_range.test | 15 + .../duckfuzz/window_order_bind_failure.test | 21 + .../corpus/fuzzer/fuzz_not_operator.test | 13 + .../fuzzer/fuzz_not_unpacked_columns.test | 37 + parser/testdata/corpus/fuzzer/issue4298.test | 21 + .../corpus/fuzzer/nthvalue_indexing.test | 11 + .../pedro/C_C++_API_query_verification.test | 25 + .../pedro/aggregate_assertion_errors.test | 29 + .../fuzzer/pedro/alter_column_generated.test | 25 + .../fuzzer/pedro/alter_dependencies.test | 29 + .../pedro/alter_dependency_conflict.test | 25 + .../fuzzer/pedro/alter_table_rowid.test | 25 + .../fuzzer/pedro/alter_type_null_mix.test | 17 + .../pedro/alter_virtual_column_segfault.test | 13 + .../fuzzer/pedro/analyze_nonexistant.test | 13 + .../fuzzer/pedro/another_binder_error.test | 25 + .../fuzzer/pedro/art_concatenate_prefix.test | 21 + .../corpus/fuzzer/pedro/art_prefix_error.test | 13 + .../fuzzer/pedro/between_mark_reference.test | 13 + .../fuzzer/pedro/between_type_mismatch.test | 13 + .../fuzzer/pedro/binder_assertion_error.test | 43 + .../binder_error_with_having_statement.test | 29 + .../fuzzer/pedro/blob_wrong_optimization.test | 41 + .../pedro/buffer_manager_out_of_memory.test | 33 + .../pedro/buffer_manager_resize_issue.test | 33 + ...cardinality_estimator_assertion_error.test | 17 + .../cardinality_estimator_runtime_issue.test | 17 + .../fuzzer/pedro/comparison_to_string.test | 13 + .../pedro/complex_offset_clause_crash.test | 9 + .../pedro/complex_type_all_subquery.test | 37 + .../pedro/concurrent_catalog_usage.test | 13 + .../fuzzer/pedro/concurrent_set_threads.test | 9 + .../fuzzer/pedro/constraints_temp_table.test | 25 + .../fuzzer/pedro/correlated_in_segv.test | 17 + .../fuzzer/pedro/correlated_limit_rowid.test | 9 + .../pedro/correlated_offset_subquery.test | 13 + .../correlated_subquery_downcast_error.test | 9 + .../fuzzer/pedro/create_index_error.test | 69 ++ .../pedro/create_replace_table_union.test | 25 + .../pedro/currval_sequence_dependency.test | 25 + .../pedro/date_int_optimizer_error.test | 13 + .../pedro/decimal_with_invalid_scale.test | 9 + .../fuzzer/pedro/delete_add_column.test | 37 + .../fuzzer/pedro/delete_using_bindings.test | 13 + .../corpus/fuzzer/pedro/drop_gcol.test | 13 + .../corpus/fuzzer/pedro/duplicate_cte.test | 9 + .../fuzzer/pedro/duplicate_using_clause.test | 45 + .../pedro/escaped_trim_function_call.test | 13 + .../pedro/export_parquet_generated.test | 41 + .../pedro/first_value_window_crash.test | 9 + .../floating_point_conversion_overflow.test | 61 + .../pedro/floating_point_inequality.test | 13 + .../fuzzer/pedro/force_external_blob.test | 13 + .../fuzzer/pedro/force_no_cross_product.test | 13 + .../forced_parallelism_empty_select.test | 17 + .../pedro/foreign_key_binding_issue.test | 21 + ...reign_key_binding_issue.test.metadata.json | 7 + .../pedro/foreign_key_type_mismatch.test | 17 + .../fuzzer/pedro/gcol_stack_overflow.test | 25 + .../fuzzer/pedro/group_by_all_row_alias.test | 13 + .../fuzzer/pedro/hash_finalize_race.test | 13 + .../pedro/having_query_wrong_result.test | 17 + .../pedro/having_subquery_failed_to_bind.test | 29 + .../pedro/in_clause_optimization_error.test | 37 + .../fuzzer/pedro/in_clause_setop_rewrite.test | 21 + .../fuzzer/pedro/incomplete_checkpoint.test | 33 + .../fuzzer/pedro/incorrect_offset_result.test | 13 + .../fuzzer/pedro/index_current_timestamp.test | 33 + .../fuzzer/pedro/index_generated_column.test | 21 + .../fuzzer/pedro/index_insert_from_union.test | 41 + .../pedro/index_not_updated_returning.test | 17 + .../fuzzer/pedro/index_on_altered_table.test | 9 + .../pedro/insert_or_replace_only_pk.test | 17 + .../pedro/intersect_correlated_subquery.test | 21 + .../fuzzer/pedro/intersect_empty_array.test | 9 + .../pedro/is_distinct_from_validation.test | 13 + .../fuzzer/pedro/lag_window_function.test | 9 + .../corpus/fuzzer/pedro/last_memory_leak.test | 17 + .../corpus/fuzzer/pedro/lateral_join.test | 17 + .../corpus/fuzzer/pedro/like_empty_list.test | 21 + .../fuzzer/pedro/limit_on_any_subquery.test | 17 + .../local_transaction_delete_empty_tree.test | 9 + .../logical_column_index_out_of_range.test | 21 + .../fuzzer/pedro/missing_subquery_error.test | 17 + .../pedro/multiplication_verification.test | 13 + .../corpus/fuzzer/pedro/nan_as_seed.test | 25 + .../natural_join_generated_heap_overflow.test | 21 + .../fuzzer/pedro/nested_limit_subquery.test | 25 + .../pedro/nested_subquery_table_function.test | 17 + .../pedro/non_boolean_aggregate_filter.test | 13 + .../offset_query_allocator_assertion.test | 9 + .../fuzzer/pedro/order_by_all_with_union.test | 9 + .../pedro/overflow_parsing_interval.test | 21 + .../pedro/overflow_varchar_decimal_cast.test | 21 + .../corpus/fuzzer/pedro/parser_roundtrip.test | 29 + .../prepared_statement_recursive_cte.test | 13 + .../pedro/pushdown_assertion_error.test | 21 + .../corpus/fuzzer/pedro/pushdown_error.test | 33 + .../pushdown_simplification_overflow.test | 21 + .../fuzzer/pedro/qualify_binder_error.test | 29 + .../pedro/random_engine_use_after_free.test | 13 + .../pedro/recursive_cte_dependent_join.test | 9 + .../pedro/recursive_cte_limit_percent.test | 13 + .../fuzzer/pedro/regr_count_validity.test | 9 + .../fuzzer/pedro/rename_column_assertion.test | 21 + .../corpus/fuzzer/pedro/rename_restart.test | 25 + .../pedro/rename_table_index_rollback.test | 9 + .../pedro/rename_table_index_storage.test | 13 + .../fuzzer/pedro/restart_current_time.test | 9 + .../corpus/fuzzer/pedro/restart_random.test | 13 + .../returning_clause_sizes_not_match.test | 61 + .../pedro/returning_clause_with_rowid.test | 53 + .../fuzzer/pedro/rollup_wrong_result.test | 33 + .../fuzzer/pedro/sample_limit_overflow.test | 9 + .../pedro/segment_tree_index_issue.test | 25 + .../fuzzer/pedro/setop_type_mismatch.test | 53 + .../pedro/signed_and_unsigned_comparison.test | 20 + .../pedro/statistics_propagation_set_op.test | 9 + .../fuzzer/pedro/strftime_constant_null.test | 21 + .../fuzzer/pedro/strptime_null_argument.test | 9 + .../pedro/subquery_assertion_error.test | 9 + .../pedro/temp_sequence_durability.test | 17 + .../fuzzer/pedro/temp_sequence_reconnect.test | 28 + .../fuzzer/pedro/temp_table_cleanup.test | 17 + .../corpus/fuzzer/pedro/test_segv_argmax.test | 28 + .../test_truncate_heap_use_after_free.test | 17 + .../pedro/test_window_function_nullptr.test | 17 + .../fuzzer/pedro/update_default_segv.test | 21 + .../fuzzer/pedro/update_join_bind_error.test | 21 + .../fuzzer/pedro/update_join_statistics.test | 13 + .../fuzzer/pedro/utf8_invalid_unicode.test | 101 ++ .../vacuum_table_with_generated_column.test | 45 + .../fuzzer/pedro/vacuum_unsupported_type.test | 13 + .../pedro/verify_parallelism_batch_index.test | 13 + .../fuzzer/pedro/view_not_rebound_error.test | 33 + .../corpus/fuzzer/pedro/wal_rename_table.test | 13 + .../fuzzer/pedro/window_function_timeout.test | 21 + .../fuzzer/pedro/window_self_reference.test | 13 + .../window_self_reference.test.metadata.json | 6 + .../fuzzer/public/cast_index_expression.test | 9 + .../corpus/fuzzer/public/columns_using.test | 19 + .../distinct_on_non_integer_literal.test | 13 + .../fuzzer/public/duplicate_alias_using.test | 11 + .../corpus/fuzzer/public/enum_empty_type.test | 21 + .../fuzzer/public/insert_by_name_default.test | 13 + .../insert_or_replace_default_values.test | 25 + .../fuzzer/public/insert_returning.test | 13 + .../public/lateral_in_right_side_of_join.test | 29 + .../fuzzer/public/lateral_join_subquery.test | 13 + .../fuzzer/public/lateral_right_join.test | 21 + .../fuzzer/public/pivot_empty_enum.test | 13 + .../fuzzer/public/pivot_full_join_using.test | 17 + .../positional_join_correlated_subquery.test | 10 + .../public/pragma_named_parameters.test | 9 + ...pragma_named_parameters.test.metadata.json | 5 + .../public/regex_range_filter_mismatch.test | 13 + .../fuzzer/public/semi_anti_join_using.test | 17 + .../corpus/fuzzer/public/semi_join_using.test | 27 + .../fuzzer/public/unpivot_partial_values.test | 9 + .../public/unsatisfiable_filter_prune.test | 21 + .../fuzzer/public/window_subquery_error.test | 9 + .../window_subquery_with_functions_error.test | 13 + .../sqlsmith/bitstring_agg_executor.test | 13 + .../sqlsmith/bitstring_agg_overflow.test | 29 + .../fuzzer/sqlsmith/current_schemas_null.test | 25 + .../fuzzer/sqlsmith/dayofweek_overflow.test | 21 + .../sqlsmith/fuzzer_window_varchar.test | 21 + .../sqlsmith/generate_series_overflow.test | 37 + .../sqlsmith/interval_diff_overflow.test | 26 + .../sqlsmith/interval_multiply_overflow.test | 10 + .../fuzzer/sqlsmith/json_contains_null.test | 18 + .../fuzzer/sqlsmith/like_null_pattern.test | 9 + .../corpus/fuzzer/sqlsmith/mad_overflow.test | 10 + .../fuzzer/sqlsmith/makedate_overflow.test | 15 + .../sqlsmith/nested_correlated_subquery.test | 52 + .../corpus/fuzzer/sqlsmith/nullif_map.test | 21 + .../sqlsmith/nullif_map_with_config.test | 49 + .../statistics_assertion_trigger.test | 49 + .../fuzzer/sqlsmith/strptime_nullpointer.test | 17 + .../sqlsmith/struct_null_coalesce_assert.test | 17 + .../fuzzer/sqlsmith/struct_verify_crash.test | 21 + .../sqlsmith/subquery_binding_error.test | 26 + .../fuzzer/sqlsmith/test_abs_overflow.test | 17 + .../sqlsmith/timestamp_diff_overflow.test | 30 + .../fuzzer/sqlsmith/timestamp_overflow.test | 13 + .../sqlsmith/timestamptz_double_cast.test | 19 + .../sqlsmith/timestamptz_null_range.test | 14 + .../sqlsmith/validity_mask_out_of_bounds.test | 21 + .../sqlsmith/window-leadlag-overflow.test | 17 + .../fuzzer/sqlsmith/window-list-value.test | 16 + .../fuzzer/sqlsmith/window-rows-overflow.test | 51 + .../sqlsmith/window_function_error.test | 14 + .../fuzzer/sqlsmith/window_scalar_range.test | 23 + .../approx_quantile_export_state.test | 82 ++ .../approx_top_k_export_state.test | 91 ++ .../arg_min_max_export_state.test | 122 ++ .../bool_and_export_state.test | 81 ++ .../count_export_state.test | 17 + .../first_last_export_state.test | 126 ++ .../kahan_avg_export_state.test | 26 + .../legacy_aggregate_state.test | 13 + .../list_export_state.test | 129 ++ .../minmax_export_state.test | 85 ++ .../ordered_aggregate_export_state.test | 244 ++++ .../product_export_state.test | 52 + .../state_export_parquet.test | 17 + .../sum_export_state.test | 41 + .../test_aggregate_state_type.test | 209 ++++ .../test_combine_aggr.test | 154 +++ .../test_corr_state_export.test | 25 + .../test_covar_export_state.test | 45 + .../test_state_export_opaque.test | 117 ++ ...est_state_export_opaque.test.metadata.json | 5 + .../test_state_export_quantile.test | 173 +++ .../test_state_export_string_agg.test | 107 ++ .../test_state_export_struct.test | 505 ++++++++ ...est_state_export_struct.test.metadata.json | 5 + .../test_stddev_export_state.test | 43 + .../vector_minmax_export_state.test | 95 ++ .../aggregate/aggregates/approx_top_k.test | 90 ++ .../aggregate/aggregates/arg_min_max_n.test | 57 + .../aggregates/arg_min_max_n_tpch.test | 64 + .../aggregates/arg_min_max_nulls_last.test | 49 + .../sql/aggregate/aggregates/binning.test | 249 ++++ .../aggregates/bitstring_agg_empty.test | 32 + .../aggregates/duckdb_fuzzer_4313.test | 9 + .../aggregate/aggregates/histogram_exact.test | 79 ++ .../aggregates/histogram_table_function.test | 81 ++ .../corpus/sql/aggregate/aggregates/lttb.test | 210 ++++ .../aggregates/max_n_all_types_grouped.test | 43 + .../aggregate/aggregates/mode_rewrite.test | 253 ++++ .../aggregates/mode_rewrite_memory.test | 14 + .../aggregates/string_agg_union.test | 27 + .../aggregates/test_aggr_string.test | 54 + .../aggregates/test_aggregate_types.test | 105 ++ .../test_aggregate_types_scalar.test | 141 +++ .../aggregate/aggregates/test_any_value.test | 164 +++ .../aggregates/test_any_value_noninlined.test | 45 + .../aggregates/test_approx_quantile.test | 301 +++++ .../test_approximate_distinct_count.test | 109 ++ .../aggregates/test_arg_min_max.test | 185 +++ .../aggregates/test_arg_min_max_null.test | 89 ++ .../sql/aggregate/aggregates/test_avg.test | 153 +++ .../aggregate/aggregates/test_bigint_avg.test | 17 + .../aggregates/test_binned_histogram.test | 86 ++ .../aggregate/aggregates/test_bit_and.test | 57 + .../sql/aggregate/aggregates/test_bit_or.test | 49 + .../aggregate/aggregates/test_bit_xor.test | 49 + .../aggregates/test_bitstring_agg.test | 209 ++++ .../sql/aggregate/aggregates/test_bool.test | 85 ++ .../sql/aggregate/aggregates/test_corr.test | 50 + .../sql/aggregate/aggregates/test_count.test | 25 + .../aggregates/test_count_all_types.test | 54 + .../aggregate/aggregates/test_count_star.test | 21 + .../sql/aggregate/aggregates/test_covar.test | 65 + .../aggregates/test_empty_aggregate.test | 21 + .../aggregate/aggregates/test_entropy.test | 78 ++ .../test_first_last_any_ordered.test | 57 + .../aggregates/test_first_noninlined.test | 37 + .../aggregates/test_group_on_expression.test | 49 + .../aggregate/aggregates/test_histogram.test | 145 +++ .../aggregates/test_histogram_3529.test | 27 + .../aggregates/test_incorrect_aggregate.test | 57 + .../aggregate/aggregates/test_kahan_avg.test | 17 + .../aggregate/aggregates/test_kahan_sum.test | 17 + .../aggregate/aggregates/test_kurtosis.test | 77 ++ .../sql/aggregate/aggregates/test_last.test | 114 ++ .../aggregates/test_last_noninlined.test | 33 + .../sql/aggregate/aggregates/test_mad.test | 96 ++ .../sql/aggregate/aggregates/test_median.test | 121 ++ .../sql/aggregate/aggregates/test_minmax.test | 17 + .../aggregates/test_minmax_14145.test | 9 + .../sql/aggregate/aggregates/test_mode.test | 243 ++++ .../aggregates/test_null_aggregates.test | 385 ++++++ .../aggregates/test_order_by_aggregate.test | 82 ++ .../aggregates/test_ordered_aggregates.test | 191 +++ ...test_ordered_aggregates.test.metadata.json | 11 + .../aggregate/aggregates/test_perfect_ht.test | 61 + .../aggregate/aggregates/test_product.test | 50 + .../aggregates/test_quantile_cont.test | 222 ++++ .../aggregates/test_quantile_cont_list.test | 79 ++ .../aggregates/test_quantile_disc.test | 173 +++ .../aggregates/test_quantile_disc_list.test | 106 ++ .../aggregate/aggregates/test_regression.test | 294 +++++ .../aggregates/test_scalar_aggr.test | 33 + .../sql/aggregate/aggregates/test_sem.test | 35 + .../aggregates/test_simple_filter.test | 74 ++ .../aggregate/aggregates/test_skewness.test | 46 + .../sql/aggregate/aggregates/test_stddev.test | 133 +++ .../aggregate/aggregates/test_string_agg.test | 150 +++ .../aggregates/test_string_agg_big.test | 21 + .../sql/aggregate/aggregates/test_sum.test | 57 + .../aggregates/test_sum.test.metadata.json | 5 + .../aggregates/test_weighted_avg.test | 41 + .../aggregate/distinct/distinct_limit.test | 113 ++ .../aggregate/distinct/distinct_on_nulls.test | 59 + .../distinct/distinct_on_order_by.test | 128 ++ .../grouped/combined_with_grouping.test | 75 ++ .../distinct/grouped/identical_inputs.test | 13 + .../distinct/grouped/issue_5070.test | 22 + .../grouped/multiple_grouping_sets.test | 132 +++ .../distinct/grouped/string_agg.test | 51 + .../sql/aggregate/distinct/issue19616.test | 34 + .../sql/aggregate/distinct/issue2656.test | 39 + .../sql/aggregate/distinct/issue8505.test | 19 + .../sql/aggregate/distinct/issue9241.test | 21 + .../rewrite/distinct_aggregate_rewrite.test | 346 ++++++ .../sql/aggregate/distinct/test_distinct.test | 56 + .../aggregate/distinct/test_distinct_on.test | 101 ++ .../distinct/test_distinct_on_columns.test | 116 ++ .../distinct/test_distinct_order_by.test | 29 + .../ungrouped/test_distinct_ungrouped.test | 132 +++ .../test_distinct_ungrouped_shared_input.test | 13 + .../sql/aggregate/group/group_by_all.test | 73 ++ .../aggregate/group/group_by_all_having.test | 21 + .../aggregate/group/group_by_all_order.test | 25 + .../sql/aggregate/group/group_by_limits.test | 93 ++ .../sql/aggregate/group/test_group_by.test | 117 ++ .../aggregate/group/test_group_by_alias.test | 57 + .../aggregate/group/test_group_by_error.test | 34 + .../group/test_group_by_large_string.test | 17 + .../group/test_group_by_multi_column.test | 13 + .../aggregate/group/test_group_by_nested.test | 178 +++ .../group/test_group_by_null_length.test | 49 + .../sql/aggregate/group/test_group_null.test | 13 + .../sql/aggregate/grouping_sets/cube.test | 74 ++ .../grouping_sets/cube.test.metadata.json | 7 + .../sql/aggregate/grouping_sets/grouping.test | 106 ++ .../grouping_sets/grouping_sets.test | 127 ++ .../grouping_sets/grouping_sets_filter.test | 21 + .../aggregate/grouping_sets/issue_3730.test | 42 + .../multiple_empty_grouping_sets.test | 10 + .../sql/aggregate/grouping_sets/rollup.test | 49 + .../grouping_sets/rollup.test.metadata.json | 5 + .../sql/aggregate/having/having_alias.test | 37 + .../having/having_without_groupby.test | 41 + .../sql/aggregate/having/test_having.test | 49 + .../aggregate/having/test_scalar_having.test | 61 + .../sql/aggregate/qualify/test_qualify.test | 166 +++ .../aggregate/qualify/test_qualify_macro.test | 29 + .../aggregate/qualify/test_qualify_view.test | 41 + .../corpus/sql/aggregate/quantile_fun.test | 37 + .../sql/alter/add_col/test_add_col.test | 21 + .../sql/alter/add_col/test_add_col_chain.test | 17 + .../alter/add_col/test_add_col_default.test | 13 + .../add_col/test_add_col_default_seq.test | 13 + .../test_add_col_if_not_exists_default.test | 25 + .../alter/add_col/test_add_col_incorrect.test | 21 + .../test_add_col_incorrect.test.metadata.json | 5 + .../sql/alter/add_col/test_add_col_index.test | 25 + .../sql/alter/add_col/test_add_col_stats.test | 13 + .../add_col/test_add_col_transactions.test | 21 + .../alter/add_col/test_add_col_user_type.test | 37 + .../add_pk/test_add_multi_column_pk.test | 29 + .../corpus/sql/alter/add_pk/test_add_pk.test | 89 ++ .../alter/add_pk/test_add_pk_alter_in_tx.test | 13 + .../sql/alter/add_pk/test_add_pk_attach.test | 25 + .../add_pk/test_add_pk_catalog_error.test | 37 + .../add_pk/test_add_pk_gaps_in_rowids.test | 25 + .../add_pk/test_add_pk_invalid_data.test | 53 + .../add_pk/test_add_pk_invalid_type.test | 17 + .../add_pk/test_add_pk_naming_conflict.test | 37 + .../alter/add_pk/test_add_pk_rollback.test | 33 + .../sql/alter/add_pk/test_add_pk_wal.test | 13 + .../test_add_pk_with_generated_column.test | 33 + .../test_add_same_pk_simultaneously.test | 9 + .../alter/add_pk/test_add_same_pk_twice.test | 21 + .../alter/alter_col/test_drop_not_null.test | 61 + .../alter_col/test_not_null_in_tran.test | 121 ++ .../alter_col/test_not_null_multi_tran.test | 37 + .../alter/alter_col/test_set_not_null.test | 73 ++ .../alter/alter_table_set_partitioned_by.test | 17 + .../sql/alter/alter_table_set_sorted_by.test | 13 + .../alter/alter_table_set_table_options.test | 49 + ...table_set_table_options.test.metadata.json | 6 + .../alter/alter_type/alter_type_struct.test | 21 + .../sql/alter/alter_type/test_alter_type.test | 57 + .../test_alter_type.test.metadata.json | 5 + ...er_type_active_transaction_visibility.test | 25 + .../alter_type/test_alter_type_check.test | 13 + .../test_alter_type_dependencies.test | 29 + .../test_alter_type_expression.test | 9 + .../alter_type/test_alter_type_incorrect.test | 25 + .../alter_type/test_alter_type_index.test | 13 + .../alter_type/test_alter_type_local.test | 9 + .../test_alter_type_multi_column.test | 9 + .../alter_type/test_alter_type_not_null.test | 17 + .../alter_type/test_alter_type_rollback.test | 9 + .../test_alter_type_transactions.test | 21 + .../alter_type/test_alter_type_unique.test | 9 + ...test_alter_type_with_generated_column.test | 9 + .../sql/alter/default/drop_default.test | 25 + .../sql/alter/default/test_set_default.test | 65 + .../sql/alter/drop_col/test_drop_col.test | 9 + .../alter/drop_col/test_drop_col_check.test | 25 + .../drop_col/test_drop_col_check_next.test | 13 + ...test_drop_col_concurrent_dml_conflict.test | 41 + .../alter/drop_col/test_drop_col_failure.test | 25 + .../drop_col/test_drop_col_not_null_next.test | 17 + .../drop_col/test_drop_col_operations.test | 21 + .../sql/alter/drop_col/test_drop_col_pk.test | 9 + .../test_drop_col_with_generated_cols.test | 25 + .../sql/alter/list/add_column_in_struct.test | 54 + .../sql/alter/list/drop_column_in_struct.test | 17 + .../alter/list/rename_column_in_struct.test | 57 + .../sql/alter/map/add_column_in_struct.test | 105 ++ .../sql/alter/map/drop_column_in_struct.test | 29 + .../alter/map/rename_column_in_struct.test | 29 + .../sql/alter/rename_col/test_rename_col.test | 9 + .../rename_col/test_rename_col_check.test | 21 + .../test_rename_col_dependencies.test | 13 + .../rename_col/test_rename_col_failure.test | 17 + .../rename_col/test_rename_col_not_null.test | 13 + .../rename_col/test_rename_col_rollback.test | 17 + .../test_rename_col_transactions.test | 12 + .../rename_col/test_rename_col_unique.test | 25 + .../alter/rename_schema/rename_schema.test | 9 + .../test_rename_bug4455_schema.test | 37 + .../alter/rename_table/test_rename_table.test | 81 ++ .../rename_table/test_rename_table_case.test | 25 + .../test_rename_table_chain_commit.test | 53 + .../test_rename_table_collision.test | 97 ++ .../test_rename_table_constraints.test | 41 + .../test_rename_table_incorrect.test | 17 + .../test_rename_table_many_transactions.test | 29 + .../test_rename_table_transactions.test | 13 + .../rename_table/test_rename_table_view.test | 21 + ...st_rename_table_with_dependency_check.test | 25 + ..._rename_table_with_insert_transaction.test | 17 + .../alter/rename_view/test_rename_view.test | 39 + .../test_rename_view_incorrect.test | 21 + .../test_rename_view_many_transactions.test | 33 + .../rename_view/test_rename_view_table.test | 9 + .../alter/struct/add_col_nested_struct.test | 33 + .../sql/alter/struct/add_col_struct.test | 41 + .../alter/struct/drop_col_nested_struct.test | 29 + .../sql/alter/struct/drop_col_struct.test | 33 + .../struct/rename_col_nested_struct.test | 49 + .../sql/alter/struct/rename_col_struct.test | 56 + .../rename_col_struct_case_insensitive.test | 9 + .../sql/alter/test_alter_database_rename.test | 49 + .../sql/alter/test_alter_if_exists.test | 137 +++ .../corpus/sql/attach/attach_all_types.test | 25 + .../attach_catalog_error_early_out.test | 17 + .../attach/attach_checkpoint_on_detach.test | 141 +++ .../sql/attach/attach_checkpoint_vacuum.test | 21 + .../corpus/sql/attach/attach_copy.test | 33 + .../sql/attach/attach_create_index.test | 17 + .../sql/attach/attach_cross_catalog.test | 33 + .../sql/attach/attach_custom_block_size.test | 65 + .../sql/attach/attach_database_options.test | 17 + .../sql/attach/attach_database_size.test | 21 + .../sql/attach/attach_dbname_quotes.test | 57 + .../attach/attach_default_database_case.test | 29 + .../sql/attach/attach_default_table.test | 77 ++ .../corpus/sql/attach/attach_defaults.test | 17 + .../sql/attach/attach_dependencies.test | 57 + .../sql/attach/attach_did_you_mean.test | 57 + .../sql/attach/attach_different_alias.test | 29 + .../corpus/sql/attach/attach_duckdb_type.test | 21 + .../attach/attach_enable_external_access.test | 37 + .../attach/attach_encrypted_db_key_test.test | 53 + .../attach_encryption_block_header.test | 57 + ...ttach_encryption_downgrade_prevention.test | 17 + .../attach_encryption_fallback_readonly.test | 49 + .../corpus/sql/attach/attach_enums.test | 75 ++ .../sql/attach/attach_export_import.test | 65 + .../corpus/sql/attach/attach_expr.test | 21 + .../sql/attach/attach_external_access.test | 9 + .../sql/attach/attach_filepath_roundtrip.test | 49 + .../corpus/sql/attach/attach_foreign_key.test | 33 + .../attach_foreign_key_external_catalog.test | 69 ++ .../corpus/sql/attach/attach_fsspec.test | 25 + .../corpus/sql/attach/attach_hidden.test | 29 + .../sql/attach/attach_home_directory.test | 33 + .../sql/attach/attach_huggingface_index.test | 9 + .../sql/attach/attach_icu_collation.test | 17 + .../sql/attach/attach_if_not_exists.test | 37 + .../attach/attach_if_not_exists_detach.test | 17 + .../corpus/sql/attach/attach_index.test | 52 + .../corpus/sql/attach/attach_issue16122.test | 29 + .../corpus/sql/attach/attach_issue7567.test | 33 + .../corpus/sql/attach/attach_issue7711.test | 13 + .../corpus/sql/attach/attach_issue_21491.test | 21 + .../corpus/sql/attach/attach_issue_7660.test | 29 + .../corpus/sql/attach/attach_lambda_view.test | 34 + .../corpus/sql/attach/attach_macros.test | 29 + .../attach_modify_multiple_databases.test | 21 + .../sql/attach/attach_multi_identifiers.test | 100 ++ .../sql/attach/attach_nested_types.test | 61 + .../sql/attach/attach_new_compression.test | 53 + .../sql/attach/attach_no_wal_writes_mode.test | 45 + .../corpus/sql/attach/attach_null.test | 9 + .../corpus/sql/attach/attach_or_replace.test | 61 + .../corpus/sql/attach/attach_persistent.test | 25 + .../attach/attach_pragma_storage_info.test | 21 + .../sql/attach/attach_prefetch_header.test | 53 + .../corpus/sql/attach/attach_read_only.test | 53 + .../attach/attach_read_only_transaction.test | 21 + .../attach_replay_with_no_wal_writes.test | 37 + .../corpus/sql/attach/attach_reserved.test | 41 + .../sql/attach/attach_row_group_size.test | 25 + .../attach_row_group_size_decreasing.test | 37 + .../corpus/sql/attach/attach_same_db.test | 13 + .../corpus/sql/attach/attach_schema.test | 17 + .../corpus/sql/attach/attach_sequence.test | 37 + .../attach/attach_serialize_dependency.test | 57 + .../sql/attach/attach_show_all_tables.test | 37 + .../corpus/sql/attach/attach_show_table.test | 49 + .../sql/attach/attach_storage_version.test | 93 ++ .../sql/attach/attach_table_constraints.test | 17 + .../corpus/sql/attach/attach_table_ddl.test | 73 ++ .../corpus/sql/attach/attach_table_info.test | 33 + .../sql/attach/attach_transactionality.test | 33 + .../sql/attach/attach_use_rollback.test | 21 + .../sql/attach/attach_view_search_path.test | 61 + .../corpus/sql/attach/attach_views.test | 49 + .../corpus/sql/attach/attach_wal_alter.test | 21 + .../sql/attach/attach_wal_alter_sequence.test | 45 + .../corpus/sql/attach/detach_keyword.test | 13 + .../detach_manager_default_database.test | 25 + .../attach/external_resource_discovery.test | 47 + .../attach/external_resource_statements.test | 41 + .../corpus/sql/attach/in_memory_attach.test | 33 + .../corpus/sql/attach/reattach_schema.test | 101 ++ .../attach/reattach_schema.test.metadata.json | 5 + .../sql/attach/remote_file_concurrently.test | 13 + .../sql/attach/searchpath_fallback.test | 158 +++ .../corpus/sql/attach/show_databases.test | 29 + .../corpus/sql/attach/show_schemas.test | 31 + .../corpus/sql/attach/system_catalog.test | 37 + .../corpus/sql/binder/alias_error_10057.test | 12 + .../binder/alias_qualification_errors.test | 21 + .../binder/alias_qualification_group_by.test | 46 + .../binder/alias_qualification_having.test | 54 + .../binder/alias_qualification_order_by.test | 33 + .../binder/alias_qualification_qualify.test | 46 + ...alias_qualification_select_projection.test | 88 ++ .../sql/binder/alias_qualification_where.test | 32 + .../sql/binder/alias_where_side_effects.test | 9 + .../sql/binder/column_ref_as_alias.test | 47 + .../sql/binder/column_value_alias_group.test | 29 + .../corpus/sql/binder/duplicate_alias.test | 33 + .../sql/binder/function_chaining_19035.test | 64 + .../binder/group_by_incremental_alias.test | 17 + .../sql/binder/group_by_qualification.test | 33 + .../sql/binder/integer_literal_binding.test | 29 + .../corpus/sql/binder/legacy_null_type.test | 17 + .../sql/binder/missing_column_error.test | 26 + .../corpus/sql/binder/not_similar_to.test | 53 + .../corpus/sql/binder/old_implicit_cast.test | 25 + .../binder/old_implicit_cast_template.test | 17 + .../corpus/sql/binder/order_by_view.test | 46 + .../binder/qualified_alias_method_call.test | 45 + .../sql/binder/separate_schema_tables.test | 127 ++ .../corpus/sql/binder/similar_to.test | 57 + .../sql/binder/string_literal_binding.test | 82 ++ .../sql/binder/table_alias_single_quotes.test | 13 + .../corpus/sql/binder/table_view_alias.test | 37 + .../corpus/sql/binder/test_alias.test | 49 + .../binder/test_alias_map_in_subquery.test | 80 ++ .../binder/test_case_insensitive_binding.test | 177 +++ .../test_duplicate_in_set_operation.test | 47 + .../binder/test_function_chaining_alias.test | 118 ++ .../corpus/sql/binder/test_having_alias.test | 61 + .../sql/binder/test_implicit_struct_pack.test | 64 + .../sql/binder/test_in_with_collate.test | 53 + .../binder/test_null_type_propagation.test | 126 ++ .../test_postitional_ref_order_binding.test | 13 + .../sql/binder/test_select_clause_alias.test | 72 ++ .../corpus/sql/binder/test_string_alias.test | 29 + .../corpus/sql/cast/boolean_autocast.test | 97 ++ .../corpus/sql/cast/cast_error_location.test | 149 +++ .../corpus/sql/cast/decimal_cast.test | 33 + .../corpus/sql/cast/decimal_float_cast.test | 49 + .../corpus/sql/cast/decimal_integer_cast.test | 13 + .../sql/cast/dot_function_missing_error.test | 17 + .../corpus/sql/cast/double_float_cast.test | 25 + .../corpus/sql/cast/float_decimal_cast.test | 9 + .../corpus/sql/cast/float_integer_cast.test | 89 ++ .../corpus/sql/cast/signed_cast_repro.test | 25 + .../cast/string_to_integer_decimal_cast.test | 133 +++ .../cast/string_to_integer_exponent_cast.test | 213 ++++ .../corpus/sql/cast/string_to_list_cast.test | 427 +++++++ .../sql/cast/string_to_list_escapes.test | 209 ++++ .../sql/cast/string_to_list_roundtrip.test | 33 + .../sql/cast/string_to_struct_cast.test | 375 ++++++ .../sql/cast/string_to_struct_escapes.test | 9 + .../sql/cast/string_to_unnamed_struct.test | 75 ++ .../corpus/sql/cast/struct_to_map.test | 222 ++++ .../corpus/sql/cast/test_bit_cast.test | 329 ++++++ .../corpus/sql/cast/test_boolean_cast.test | 185 +++ .../sql/cast/test_exponent_in_cast.test | 45 + .../sql/cast/test_string_binary_cast.test | 122 ++ .../corpus/sql/cast/test_string_cast.test | 165 +++ .../corpus/sql/cast/test_try_cast.test | 37 + .../corpus/sql/cast/timestamp_casts.test | 119 ++ .../corpus/sql/cast/timestamp_date_cast.test | 32 + .../testdata/corpus/sql/cast/union_cast.test | 21 + .../sql/catalog/case_insensitive_alter.test | 45 + .../sql/catalog/case_insensitive_binder.test | 61 + .../sql/catalog/case_insensitive_caps.test | 29 + .../sql/catalog/case_insensitive_cte.test | 15 + .../catalog/case_insensitive_operations.test | 103 ++ .../sql/catalog/case_insensitive_using.test | 161 +++ .../corpus/sql/catalog/comment_on.test | 245 ++++ .../corpus/sql/catalog/comment_on_column.test | 69 ++ .../sql/catalog/comment_on_dependencies.test | 57 + .../sql/catalog/comment_on_extended.test | 129 ++ .../comment_on_extended.test.metadata.json | 6 + .../catalog/comment_on_pg_description.test | 125 ++ .../corpus/sql/catalog/comment_on_wal.test | 9 + .../add_column_to_table_referenced_by_fk.test | 36 + ...d_column_to_table_referenced_by_macro.test | 21 + ...dd_column_to_table_referenced_by_view.test | 13 + ...e_of_table_column_referenced_by_index.test | 17 + .../drop_recreate_schema_dependency.test | 33 + ...move_table_column_referenced_by_index.test | 9 + ...name_table_column_referenced_by_index.test | 13 + ...rename_view_referenced_by_table_macro.test | 21 + ...t_of_table_column_referenced_by_index.test | 21 + .../test_alter_dependency_ownership.test | 235 ++++ ...er_dependency_ownership.test.metadata.json | 5 + .../dependencies/test_alter_owned_by.test | 37 + .../dependencies/test_alter_owning_table.test | 39 + .../dependencies/test_concurrent_alter.test | 17 + .../dependencies/test_concurrent_drop.test | 19 + .../test_concurrent_index_creation.test | 25 + .../test_concurrent_schema_creation.test | 25 + .../test_default_value_dependency.test | 53 + .../test_drop_column_sequence_dependency.test | 69 ++ ...est_drop_default_referencing_sequence.test | 51 + ...est_prepare_dependencies_transactions.test | 25 + .../test_prepared_dependency.test | 13 + .../dependencies/test_schema_dependency.test | 33 + .../test_set_default_sequence_dependency.test | 72 ++ .../dependencies/test_write_after_rename.test | 29 + .../corpus/sql/catalog/did_you_mean.test | 40 + .../sql/catalog/drop_create_rollback.test | 21 + .../sql/catalog/function/attached_macro.test | 35 + .../function/information_schema_macro.test | 9 + .../catalog/function/macro_query_table.test | 29 + .../python_style_macro_parameters.test | 85 ++ .../sql/catalog/function/query_function.test | 233 ++++ .../query_function.test.metadata.json | 14 + .../function/struct_extract_macro.test | 21 + .../catalog/function/test_complex_macro.test | 324 +++++ .../function/test_cross_catalog_macros.test | 17 + .../sql/catalog/function/test_cte_macro.test | 75 ++ .../sql/catalog/function/test_drop_macro.test | 25 + .../function/test_macro_correlated_cte.test | 29 + .../function/test_macro_default_arg.test | 83 ++ ...t_macro_default_arg_with_dependencies.test | 45 + .../function/test_macro_issue_13104.test | 25 + .../function/test_macro_issue_14276.test | 17 + .../function/test_macro_issue_18927.test | 13 + .../function/test_macro_issue_19119.test | 17 + .../function/test_macro_overloads.test | 72 ++ .../test_macro_relpersistence_conflict.test | 37 + .../function/test_macro_type_overloads.test | 366 ++++++ .../test_macro_with_unknown_types.test | 15 + .../function/test_recursive_macro.test | 49 + .../catalog/function/test_sequence_macro.test | 73 ++ .../catalog/function/test_simple_macro.test | 308 +++++ .../test_simple_macro.test.metadata.json | 9 + .../catalog/function/test_subquery_macro.test | 53 + .../catalog/function/test_table_macro.test | 118 ++ .../function/test_table_macro_args.test | 116 ++ .../test_table_macro_args.test.metadata.json | 6 + .../function/test_table_macro_complex.test | 52 + .../function/test_table_macro_copy.test | 18 + .../function/test_table_macro_groups.test | 69 ++ .../catalog/function/test_window_macro.test | 103 ++ .../catalog/information_schema_read_only.test | 17 + .../corpus/sql/catalog/issue_9459.test | 13 + .../nested_schema/create_nested_schema.test | 54 + .../nested_schema/drop_nested_schema.test | 142 +++ .../drop_nested_schema_persist.test | 68 ++ .../catalog/nested_schema/nested_alter.test | 173 +++ .../nested_schema/nested_constraints.test | 81 ++ .../catalog/nested_schema/nested_entries.test | 209 ++++ .../nested_entries.test.metadata.json | 5 + .../nested_schema/nested_entries_persist.test | 121 ++ .../catalog/nested_schema/nested_export.test | 103 ++ .../nested_schema/nested_schema_limits.test | 114 ++ .../nested_schema_storage_version.test | 17 + .../catalog/nested_schema/nested_table.test | 71 ++ .../nested_schema/nested_table_columnref.test | 125 ++ .../nested_schema/nested_table_dml.test | 109 ++ .../nested_table_dml_persist.test | 65 + .../nested_schema/nested_table_persist.test | 54 + .../nested_schema/nested_wal_replay.test | 133 +++ .../sql/catalog/nested_schema/persist.test | 17 + ..._currval_before_nextval_not_supported.test | 21 + ...ence_currval_before_nextval_supported.test | 9 + .../sql/catalog/sequence/sequence_cycle.test | 13 + .../sequence/sequence_offset_increment.test | 13 + .../catalog/sequence/sequence_overflow.test | 61 + .../corpus/sql/catalog/sequence/setval.test | 169 +++ .../sequence/test_duckdb_sequences.test | 17 + .../sql/catalog/sequence/test_sequence.test | 245 ++++ .../sequence/test_sequence.test.metadata.json | 23 + .../sequence/test_sequence_dependency.test | 13 + .../sequence/test_sequence_google_fuzz.test | 17 + .../catalog/table/create_table_as_abort.test | 13 + .../table/create_table_parameters.test | 21 + .../sql/catalog/table/long_identifier.test | 29 + .../table/test_create_table_parallelism.test | 25 + .../sql/catalog/table/test_default.test | 89 ++ .../catalog/table/test_default_not_null.test | 65 + .../catalog/table/test_default_values.test | 41 + .../test_default_values.test.metadata.json | 5 + .../sql/catalog/table/test_many_columns.test | 13 + .../sql/catalog/test_alter_oid_stability.test | 29 + .../sql/catalog/test_catalog_errors.test | 57 + .../sql/catalog/test_create_from_select.test | 29 + .../catalog/test_extension_suggestion.test | 9 + .../sql/catalog/test_if_not_exists.test | 29 + .../test_incorrect_table_creation.test | 21 + ...ncorrect_table_creation.test.metadata.json | 7 + .../test_querying_from_detached_catalog.test | 37 + .../sql/catalog/test_quoted_column_name.test | 29 + .../corpus/sql/catalog/test_schema.test | 73 ++ .../corpus/sql/catalog/test_set_schema.test | 453 +++++++ .../sql/catalog/test_set_search_path.test | 185 +++ .../test_set_search_path.test.metadata.json | 6 + .../sql/catalog/test_standard_schema.test | 29 + .../corpus/sql/catalog/test_temporary.test | 113 ++ .../catalog/test_temporary.test.metadata.json | 5 + .../sql/catalog/test_unicode_schema.test | 49 + .../sql/catalog/view/deferred_binding.test | 13 + .../sql/catalog/view/recursive_view.test | 29 + .../recursive_view_with_dependencies.test | 9 + .../view/test_loosely_qualified_view_sql.test | 48 + .../sql/catalog/view/test_stacked_view.test | 29 + .../corpus/sql/catalog/view/test_view.test | 47 + .../sql/catalog/view/test_view_alias.test | 29 + .../catalog/view/test_view_delete_update.test | 17 + .../view/test_view_drop_concurrent.test | 13 + .../view/test_view_duplicate_columns.test | 35 + .../catalog/view/test_view_schema_change.test | 37 + ..._view_schema_change_with_dependencies.test | 13 + .../sql/catalog/view/test_view_sql.test | 67 ++ .../view/test_view_sql_with_dependencies.test | 9 + .../sql/catalog/view/view_if_not_exists.test | 13 + .../sql/collate/collate_filter_pushdown.test | 25 + .../sql/collate/collate_in_subquery.test | 29 + .../corpus/sql/collate/collate_like.test | 77 ++ .../sql/collate/collate_non_varchar.test | 13 + .../sql/collate/collate_order_by_alias.test | 38 + .../collate/collate_ordered_aggregate.test | 17 + .../sql/collate/collate_string_col.test | 19 + .../corpus/sql/collate/collate_subquery.test | 21 + .../sql/collate/collation_sort_keys.test | 113 ++ .../collate/icu_collation_propagation.test | 69 ++ .../nop_collation_join_filter_pushdown.test | 33 + .../test_collate_accent_insensitive.test | 57 + .../test_collate_and_grouping_sets.test | 53 + .../sql/collate/test_collate_between.test | 33 + .../test_collate_case_insensitive.test | 41 + .../sql/collate/test_collate_expression.test | 49 + .../corpus/sql/collate/test_collate_list.test | 13 + .../collate/test_collate_list_contains.test | 85 ++ .../collate/test_collate_null_constant.test | 109 ++ .../test_collate_orderby_column_number.test | 81 ++ .../sql/collate/test_collate_pivot.test | 71 ++ .../collate/test_collation_propagation.test | 65 + .../sql/collate/test_combined_collation.test | 17 + .../sql/collate/test_default_collations.test | 17 + .../corpus/sql/collate/test_icu_collate.test | 110 ++ .../sql/collate/test_pragma_collations.test | 11 + .../sql/collate/test_strpos_collate.test | 121 ++ .../collate/test_unsupported_collations.test | 29 + ..._unsupported_collations.test.metadata.json | 5 + .../corpus/sql/conjunction/or_between.test | 53 + .../corpus/sql/conjunction/or_comparison.test | 57 + .../connect/concurrent_connect_detach.test | 29 + .../corpus/sql/connect/connect_quack.test | 45 + .../sql/connect/connect_string_ephemeral.test | 9 + .../corpus/sql/connect/connect_syntax.test | 29 + .../sql/constraints/check/check_struct.test | 25 + .../sql/constraints/check/test_check.test | 68 ++ .../check/test_check.test.metadata.json | 6 + ...test_update_check_non_updated_columns.test | 129 ++ .../sql/constraints/foreignkey/fk_19469.test | 115 ++ .../sql/constraints/foreignkey/fk_20530.test | 65 + .../sql/constraints/foreignkey/fk_4309.test | 83 ++ .../sql/constraints/foreignkey/fk_4365.test | 17 + .../foreignkey/fk_case_insensitivity.test | 33 + .../foreignkey/fk_implicit_primary_key.test | 29 + .../foreign_key_matching_columns.test | 80 ++ .../constraints/foreignkey/test_action.test | 53 + .../foreignkey/test_action.test.metadata.json | 10 + .../constraints/foreignkey/test_fk_alter.test | 32 + .../constraints/foreignkey/test_fk_chain.test | 89 ++ .../test_fk_concurrency_conflicts.test | 37 + .../foreignkey/test_fk_create_type.test | 41 + .../foreignkey/test_fk_cross_schema.test | 21 + .../test_fk_eager_constraint_checking.test | 53 + .../foreignkey/test_fk_export.test | 45 + .../foreignkey/test_fk_multiple.test | 153 +++ .../foreignkey/test_fk_on_view_error.test | 17 + .../test_fk_pk_multi_transaction_delete.test | 29 + .../foreignkey/test_fk_rollback.test | 29 + .../test_fk_self_reference_export.test | 25 + .../foreignkey/test_fk_self_referencing.test | 109 ++ .../foreignkey/test_fk_temporary.test | 242 ++++ .../foreignkey/test_fk_transaction.test | 77 ++ .../foreignkey/test_fk_with_attached_db.test | 29 + .../foreignkey/test_foreignkey.test | 65 + .../test_foreignkey.test.metadata.json | 6 + .../constraints/primarykey/test_pk_bool.test | 25 + .../primarykey/test_pk_col_subset.test | 37 + .../test_pk_concurrency_conflicts.test | 29 + .../primarykey/test_pk_many_columns.test | 21 + .../primarykey/test_pk_multi_column.test | 21 + .../primarykey/test_pk_multi_string.test | 33 + .../primarykey/test_pk_rollback.test | 9 + .../primarykey/test_pk_string.test | 37 + .../primarykey/test_pk_update_delete.test | 49 + .../primarykey/test_pk_updel_local.test | 13 + .../test_pk_updel_multi_column.test | 61 + .../primarykey/test_primary_key.test | 41 + .../test_constraint_with_updates.test | 57 + .../corpus/sql/constraints/test_not_null.test | 33 + .../sql/constraints/unique/test_unique.test | 29 + .../constraints/unique/test_unique_error.test | 17 + .../unique/test_unique_multi_column.test | 25 + .../unique/test_unique_multi_constraint.test | 45 + .../unique/test_unique_string.test | 33 + .../constraints/unique/test_unique_temp.test | 9 + .../corpus/sql/copy/async_file_lifecycle.test | 88 ++ .../testdata/corpus/sql/copy/copy_blob.test | 41 + parser/testdata/corpus/sql/copy/copy_cte.test | 138 +++ .../sql/copy/copy_cte.test.metadata.json | 6 + .../testdata/corpus/sql/copy/csv/14512.test | 21 + .../testdata/corpus/sql/copy/csv/14874.test | 13 + .../testdata/corpus/sql/copy/csv/17738.test | 21 + .../testdata/corpus/sql/copy/csv/17744.test | 67 ++ .../testdata/corpus/sql/copy/csv/18579.test | 9 + .../testdata/corpus/sql/copy/csv/19578.test | 13 + .../testdata/corpus/sql/copy/csv/21248.test | 9 + parser/testdata/corpus/sql/copy/csv/7702.test | 13 + .../sql/copy/csv/afl/fuzz_20250211_crash.test | 9 + .../sql/copy/csv/afl/fuzz_20250226.test | 13 + .../copy/csv/afl/test_afl_ignore_errors.test | 9 + .../copy/csv/afl/test_afl_no_parameter.test | 9 + .../copy/csv/afl/test_afl_null_padding.test | 9 + .../sql/copy/csv/afl/test_afl_skip.test | 9 + .../sql/copy/csv/afl/test_fuzz_3977.test | 361 ++++++ .../sql/copy/csv/afl/test_fuzz_4086.test | 17 + .../sql/copy/csv/afl/test_fuzz_4172.test | 9 + .../sql/copy/csv/afl/test_fuzz_4234.test | 9 + .../sql/copy/csv/afl/test_fuzz_4329.test | 9 + .../sql/copy/csv/afl/test_fuzz_4379.test | 26 + .../sql/copy/csv/afl/test_fuzz_4496.test | 13 + .../sql/copy/csv/afl/test_fuzz_4793.test | 13 + .../sql/copy/csv/afl/test_fuzz_5194.test | 13 + .../corpus/sql/copy/csv/allow_empty.test | 36 + .../corpus/sql/copy/csv/auto/test_14177.test | 9 + .../sql/copy/csv/auto/test_auto_5250.test | 9 + .../sql/copy/csv/auto/test_auto_5378.test | 9 + .../sql/copy/csv/auto/test_auto_8231.test | 17 + .../sql/copy/csv/auto/test_auto_8573.test | 13 + .../sql/copy/csv/auto/test_auto_8649.test | 9 + .../sql/copy/csv/auto/test_auto_8860.test | 9 + .../csv/auto/test_auto_column_type_opt.test | 49 + .../sql/copy/csv/auto/test_auto_cranlogs.test | 27 + .../csv/auto/test_auto_greek_ncvoter.test | 31 + .../copy/csv/auto/test_auto_greek_utf8.test | 21 + .../sql/copy/csv/auto/test_auto_imdb.test | 23 + .../sql/copy/csv/auto/test_auto_lineitem.test | 35 + .../sql/copy/csv/auto/test_auto_ontime.test | 31 + .../sql/copy/csv/auto/test_auto_web_page.test | 27 + .../sql/copy/csv/auto/test_csv_auto.test | 127 ++ .../csv/auto/test_date_format_bug_linux.test | 9 + .../copy/csv/auto/test_describe_order.test | 17 + .../csv/auto/test_double_quoted_header.test | 13 + .../sql/copy/csv/auto/test_early_out.test | 10 + .../copy/csv/auto/test_header_completion.test | 69 ++ .../copy/csv/auto/test_header_detection.test | 97 ++ .../auto/test_large_integer_detection.test | 74 ++ .../copy/csv/auto/test_normalize_names.test | 69 ++ .../sql/copy/csv/auto/test_sample_size.test | 45 + .../sql/copy/csv/auto/test_sniffer_blob.test | 25 + .../auto/test_sniffer_empty_start_value.test | 9 + .../sql/copy/csv/auto/test_timings_csv.test | 13 + .../copy/csv/auto/test_type_candidates.test | 97 ++ .../copy/csv/auto/test_type_detection.test | 85 ++ .../sql/copy/csv/auto_glob_directory.test | 13 + .../csv/code_cov/buffer_manager_finalize.test | 21 + .../csv/code_cov/csv_dialect_detection.test | 17 + .../csv/code_cov/csv_exact_buffer_size.test | 21 + .../copy/csv/code_cov/csv_sniffer_header.test | 21 + .../csv_state_machine_invalid_utf.test | 77 ++ .../copy/csv/code_cov/csv_type_detection.test | 21 + .../csv/code_cov/csv_type_refinement.test | 13 + .../corpus/sql/copy/csv/column_names.test | 29 + .../copy/csv/copy_disable_parallelism.test | 9 + .../corpus/sql/copy/csv/copy_expression.test | 29 + .../sql/copy/csv/copy_to_overwrite.test | 33 + .../corpus/sql/copy/csv/csv_copy_sniffer.test | 23 + .../sql/copy/csv/csv_decimal_separator.test | 69 ++ .../corpus/sql/copy/csv/csv_dtypes.test | 73 ++ .../copy/csv/csv_dtypes_union_by_name.test | 71 ++ .../corpus/sql/copy/csv/csv_duck_fuzz.test | 21 + .../copy/csv/csv_duck_fuzz.test.metadata.json | 5 + .../corpus/sql/copy/csv/csv_enum.test | 25 + .../sql/copy/csv/csv_error_message.test | 29 + .../sql/copy/csv/csv_external_access.test | 37 + .../sql/copy/csv/csv_glob_fallback.test | 13 + .../corpus/sql/copy/csv/csv_hive.test | 102 ++ .../sql/copy/csv/csv_hive_filename_union.test | 49 + .../sql/copy/csv/csv_home_directory.test | 41 + .../corpus/sql/copy/csv/csv_limit_copy.test | 17 + .../sql/copy/csv/csv_line_too_long.test | 21 + .../corpus/sql/copy/csv/csv_names.test | 101 ++ .../corpus/sql/copy/csv/csv_null_byte.test | 25 + .../corpus/sql/copy/csv/csv_null_padding.test | 25 + .../corpus/sql/copy/csv/csv_nullstr_list.test | 105 ++ .../sql/copy/csv/csv_projection_pushdown.test | 37 + .../csv/csv_quoted_newline_incorrect.test | 9 + .../copy/csv/csv_roundtrip_single_null.test | 17 + .../csv/csv_windows_mixed_separators.test | 29 + .../csv/duck_fuzz/test_internal_4048.test | 14 + .../corpus/sql/copy/csv/empty_first_line.test | 13 + .../sql/copy/csv/empty_string_quote.test | 29 + .../testdata/corpus/sql/copy/csv/except.test | 13 + .../sql/copy/csv/glob/copy_csv_glob.test | 21 + .../sql/copy/csv/glob/read_csv_glob.test | 161 +++ .../csv/glob/read_csv_glob.test.metadata.json | 8 + .../sql/copy/csv/glob/test_unmatch_globs.test | 21 + .../copy/csv/inconsistent_cells_error.test | 9 + .../corpus/sql/copy/csv/integer_exponent.test | 9 + .../corpus/sql/copy/csv/issue_22153.test | 13 + .../corpus/sql/copy/csv/issue_6690.test | 13 + .../corpus/sql/copy/csv/issue_6764.test | 29 + .../copy/csv/leading_zeros_autodetect.test | 37 + .../multidelimiter/test_2_byte_delimiter.test | 29 + .../test_3_4_byte_delimiter.test | 17 + .../copy/csv/multidelimiter/test_abac.test | 101 ++ .../test_options_inconsistencies.test | 17 + .../corpus/sql/copy/csv/null_padding_big.test | 45 + .../corpus/sql/copy/csv/null_terminator.test | 33 + .../sql/copy/csv/null_value_wrong_type.test | 9 + .../csv/overwrite/test_copy_overwrite.test | 41 + .../test_overwrite_pipe_windows.test | 9 + .../parallel/csv_parallel_buffer_size.test | 49 + .../parallel/csv_parallel_null_option.test | 51 + .../parallel_csv_hive_partitioning.test | 13 + .../parallel/parallel_csv_union_by_name.test | 41 + .../sql/copy/csv/parallel/test_5438.test | 9 + .../sql/copy/csv/parallel/test_5566.test | 21 + .../sql/copy/csv/parallel/test_7578.test | 41 + .../csv/parallel/test_multiple_files.test | 21 + .../copy/csv/parallel/test_parallel_csv.test | 25 + .../test_parallel_error_messages.test | 97 ++ .../corpus/sql/copy/csv/plus_autodetect.test | 17 + .../csv/pollock/test_field_delimiter.test | 11 + .../copy/csv/pollock/test_quotation_char.test | 11 + .../csv/read_ahead/csv_readahead_gzip.test | 32 + .../read_ahead/csv_readahead_multi_file.test | 40 + .../csv/read_ahead/csv_readahead_rejects.test | 46 + .../read_ahead/csv_readahead_single_file.test | 20 + .../sql/copy/csv/read_csv_subquery.test | 30 + .../sql/copy/csv/read_csv_variable.test | 21 + .../csv/read_csv_variable.test.metadata.json | 5 + .../copy/csv/recursive_csv_union_by_name.test | 23 + .../sql/copy/csv/recursive_read_csv.test | 55 + .../csv_incorrect_columns_amount_rejects.test | 56 + .../copy/csv/rejects/csv_rejects_auto.test | 41 + .../csv/rejects/csv_rejects_flush_cast.test | 14 + .../rejects/csv_rejects_flush_message.test | 12 + .../csv/rejects/csv_rejects_maximum_line.test | 33 + .../copy/csv/rejects/csv_rejects_read.test | 116 ++ ...sv_rejects_truncate_line_invalid_utf8.test | 13 + .../csv/rejects/csv_rejects_two_tables.test | 178 +++ .../csv/rejects/csv_unquoted_rejects.test | 44 + .../csv/rejects/test_invalid_parameters.test | 94 ++ .../csv/rejects/test_invalid_utf_rejects.test | 10 + .../sql/copy/csv/rejects/test_mixed.test | 12 + .../test_multiple_errors_same_line.test | 129 ++ .../corpus/sql/copy/csv/relaxed_quotes.test | 73 ++ .../testdata/corpus/sql/copy/csv/struct.test | 9 + .../corpus/sql/copy/csv/struct_padding.test | 9 + .../corpus/sql/copy/csv/test_11403.test | 13 + .../corpus/sql/copy/csv/test_11840.test | 13 + .../corpus/sql/copy/csv/test_12596.test | 17 + .../corpus/sql/copy/csv/test_15473.test | 41 + .../corpus/sql/copy/csv/test_8890.test | 23 + .../corpus/sql/copy/csv/test_9005.test | 9 + .../corpus/sql/copy/csv/test_afl.test | 105 ++ .../corpus/sql/copy/csv/test_all_quotes.test | 9 + .../csv/test_allow_quoted_nulls_option.test | 17 + .../corpus/sql/copy/csv/test_auto_date.test | 65 + .../copy/csv/test_auto_detection_headers.test | 25 + .../corpus/sql/copy/csv/test_bgzf_read.test | 21 + .../corpus/sql/copy/csv/test_big_header.test | 25 + .../corpus/sql/copy/csv/test_blob.test | 37 + .../corpus/sql/copy/csv/test_bug_10273.test | 9 + .../copy/csv/test_column_inconsistencies.test | 45 + .../sql/copy/csv/test_comment_midline.test | 92 ++ .../sql/copy/csv/test_comment_option.test | 81 ++ .../sql/copy/csv/test_compression_flag.test | 43 + .../corpus/sql/copy/csv/test_copy.test | 213 ++++ .../sql/copy/csv/test_copy.test.metadata.json | 7 + .../sql/copy/csv/test_copy_default.test | 21 + .../corpus/sql/copy/csv/test_copy_gzip.test | 44 + .../copy/csv/test_copy_many_empty_lines.test | 17 + .../corpus/sql/copy/csv/test_copy_null.test | 85 ++ .../copy/csv/test_csv_duplicate_columns.test | 25 + .../copy/csv/test_csv_error_message_type.test | 69 ++ .../corpus/sql/copy/csv/test_csv_json.test | 25 + .../sql/copy/csv/test_csv_mixed_casts.test | 116 ++ .../csv/test_csv_no_trailing_newline.test | 17 + .../csv/test_csv_projection_pushdown.test | 79 ++ .../test_csv_projection_pushdown_glob.test | 41 + .../sql/copy/csv/test_csv_timestamp_tz.test | 67 ++ .../copy/csv/test_csv_timestamp_tz_icu.test | 23 + .../corpus/sql/copy/csv/test_date.test | 37 + .../sql/copy/csv/test_date_sniffer.test | 41 + .../corpus/sql/copy/csv/test_dateformat.test | 101 ++ .../corpus/sql/copy/csv/test_decimal.test | 61 + .../sql/copy/csv/test_double_sniffer.test | 25 + .../sql/copy/csv/test_empty_header.test | 10 + .../corpus/sql/copy/csv/test_empty_quote.test | 21 + .../corpus/sql/copy/csv/test_enum_csv.test | 13 + .../sql/copy/csv/test_escape_long_value.test | 41 + .../copy/csv/test_export_force_quotes.test | 17 + .../sql/copy/csv/test_export_not_null.test | 49 + .../copy/csv/test_extra_delimiters_rfc.test | 9 + .../sql/copy/csv/test_filename_filter.test | 21 + .../sql/copy/csv/test_force_not_null.test | 45 + .../corpus/sql/copy/csv/test_force_quote.test | 57 + .../copy/csv/test_glob_reorder_lineitem.test | 38 + .../sql/copy/csv/test_glob_reorder_null.test | 33 + .../corpus/sql/copy/csv/test_glob_type.test | 53 + .../corpus/sql/copy/csv/test_greek_utf8.test | 25 + .../corpus/sql/copy/csv/test_header_only.test | 72 ++ .../sql/copy/csv/test_headers_12089.test | 13 + .../sql/copy/csv/test_hits_problematic.test | 21 + .../sql/copy/csv/test_ignore_errors.test | 85 ++ .../csv/test_ignore_errors_end_of_chunk.test | 29 + .../copy/csv/test_ignore_mid_null_line.test | 10 + .../corpus/sql/copy/csv/test_imdb.test | 17 + .../copy/csv/test_infinite_loop_escape.test | 17 + .../sql/copy/csv/test_insert_into_types.test | 195 +++ .../copy/csv/test_issue3562_assertion.test | 13 + .../corpus/sql/copy/csv/test_issue5077.test | 17 + .../corpus/sql/copy/csv/test_lineitem.test | 25 + .../corpus/sql/copy/csv/test_lineitem_gz.test | 32 + .../corpus/sql/copy/csv/test_linesize.test | 9 + .../corpus/sql/copy/csv/test_long_line.test | 21 + .../sql/copy/csv/test_many_columns.test | 13 + .../sql/copy/csv/test_mismatch_schemas.test | 48 + .../corpus/sql/copy/csv/test_missing_row.test | 9 + .../sql/copy/csv/test_mixed_line_endings.test | 9 + .../sql/copy/csv/test_mixed_new_line.test | 61 + .../corpus/sql/copy/csv/test_ncvoter.test | 25 + .../corpus/sql/copy/csv/test_nfc.test | 17 + .../corpus/sql/copy/csv/test_nfc_suite.test | 33 + .../sql/copy/csv/test_non_unicode_header.test | 17 + .../csv/test_null_padding_projection.test | 100 ++ .../sql/copy/csv/test_null_padding_union.test | 32 + .../corpus/sql/copy/csv/test_ontime.test | 25 + .../copy/csv/test_parallel_nullpadding.test | 29 + .../copy/csv/test_partition_compression.test | 41 + .../sql/copy/csv/test_prefix_suffix.test | 17 + .../sql/copy/csv/test_quote_default.test | 13 + .../copy/csv/test_quoted_later_escaped.test | 37 + .../sql/copy/csv/test_quoted_newline.test | 17 + .../corpus/sql/copy/csv/test_read_csv.test | 61 + .../copy/csv/test_replacement_scan_alias.test | 29 + .../corpus/sql/copy/csv/test_segfault.test | 9 + .../corpus/sql/copy/csv/test_skip_bom.test | 21 + .../corpus/sql/copy/csv/test_skip_header.test | 13 + .../corpus/sql/copy/csv/test_sniff_csv.test | 97 ++ .../sql/copy/csv/test_sniff_csv_options.test | 121 ++ .../sql/copy/csv/test_sniffer_hang.test | 9 + .../copy/csv/test_sniffer_tab_delimiter.test | 33 + .../sql/copy/csv/test_soccer_kaggle.test | 9 + .../copy/csv/test_thijs_unquoted_file.test | 29 + .../copy/csv/test_thousands_separator.test | 91 ++ .../corpus/sql/copy/csv/test_time.test | 21 + .../sql/copy/csv/test_timestamp_offset.test | 9 + .../sql/copy/csv/test_timestamptz_12926.test | 29 + .../sql/copy/csv/test_union_by_name.test | 82 ++ .../copy/csv/test_union_by_name_types.test | 17 + .../corpus/sql/copy/csv/test_validator.test | 49 + .../corpus/sql/copy/csv/test_web_page.test | 33 + .../sql/copy/csv/test_windows_newline.test | 21 + .../csv/test_wrong_newline_delimiter.test | 21 + .../sql/copy/csv/timestamp_with_tz.test | 37 + .../corpus/sql/copy/csv/tsv_copy.test | 25 + .../corpus/sql/copy/csv/unicode_filename.test | 21 + .../sql/copy/csv/unquoted_escape/basic.test | 28 + .../copy/csv/unquoted_escape/human_eval.test | 55 + .../copy/csv/unquoted_escape/identical.test | 9 + .../sql/copy/csv/unquoted_escape/mixed.test | 13 + .../sql/copy/csv/write_header_default.test | 25 + .../corpus/sql/copy/csv/zstd_crash.test | 53 + .../testdata/corpus/sql/copy/csv/zstd_fs.test | 17 + .../concurrent_encrypted_attach.test | 9 + .../encryption/different_aes_ciphers.test | 49 + ...erent_encryption_versions_and_ciphers.test | 29 + .../encryption_storage_versions.test | 101 ++ .../sql/copy/encryption/force_mbedtls.test | 13 + .../test_different_encryption_versions.test | 89 ++ .../encryption/unencrypted_to_encrypted.test | 13 + ...unencrypted_to_encrypted_direct_query.test | 9 + .../encryption/write_encrypted_database.test | 9 + .../corpus/sql/copy/file_size_bytes.test | 142 +++ .../testdata/corpus/sql/copy/format_uuid.test | 173 +++ .../copy/hive_partition_null_overwrite.test | 11 + .../testdata/corpus/sql/copy/parquet/afl.test | 13 + .../corpus/sql/copy/parquet/allow_empty.test | 71 ++ .../copy/parquet/alltypes-dictionaries.test | 53 + .../sql/copy/parquet/attach_parquet.test | 29 + .../sql/copy/parquet/auto_glob_directory.test | 13 + .../corpus/sql/copy/parquet/aws2.test | 9 + .../corpus/sql/copy/parquet/aws_kinesis.test | 13 + .../corpus/sql/copy/parquet/bigdecimal.test | 9 + .../copy/parquet/bloom_filter_decimal.test | 59 + .../copy/parquet/bloom_filter_interval.test | 145 +++ .../sql/copy/parquet/bloom_filters.test | 724 ++++++++++++ .../sql/copy/parquet/broken_parquet.test | 37 + .../sql/copy/parquet/byte_stream_split.test | 9 + .../parquet/case_insensitive_replacement.test | 9 + .../sql/copy/parquet/copy_ninf_stats.test | 13 + .../parquet/copy_option_non_foldable.test | 26 + .../copy/parquet/copy_option_prepared.test | 26 + .../copy/parquet/copy_option_suggestion.test | 13 + .../sql/copy/parquet/corrupt_stats.test | 9 + .../sql/copy/parquet/cte_batch_exchange.test | 56 + .../sql/copy/parquet/decimal_filter.test | 17 + .../sql/copy/parquet/delta_byte_array.test | 13 + .../sql/copy/parquet/describe_parquet.test | 17 + ...ictionary_compression_ratio_threshold.test | 41 + .../encryption/arrow_compatibility.test | 25 + .../sql/copy/parquet/enum_converted_type.test | 9 + .../sql/copy/parquet/file_metadata.test | 17 + .../corpus/sql/copy/parquet/fixed.test | 9 + .../corpus/sql/copy/parquet/float16.test | 21 + .../parquet/hive_partitioning_struct.test | 30 + .../sql/copy/parquet/hive_timestamps.test | 48 + .../parquet/incorrect_converted_type.test | 49 + .../sql/copy/parquet/infer_copy_format.test | 25 + .../sql/copy/parquet/invalid_utf8_stats.test | 9 + .../corpus/sql/copy/parquet/issue_21508.test | 19 + .../corpus/sql/copy/parquet/json_parquet.test | 13 + .../corpus/sql/copy/parquet/kv_metadata.test | 41 + .../sql/copy/parquet/lineitem_arrow.test | 21 + .../sql/copy/parquet/metadata_full.test | 65 + .../multi_file/adaptive_filter_carryover.test | 152 +++ .../multi_file_filter_integer_types.test | 54 + .../multi_file/multi_file_filter_mixed.test | 30 + .../multi_file/multi_file_filter_struct.test | 112 ++ .../parquet/multi_file_conversion_error.test | 25 + .../copy/parquet/parallel_parquet_glob.test | 29 + .../corpus/sql/copy/parquet/parquet2.test | 33 + .../sql/copy/parquet/parquet2strings.test | 9 + .../sql/copy/parquet/parquet_10148.test | 9 + .../sql/copy/parquet/parquet_10279.test | 9 + .../sql/copy/parquet/parquet_12621.test | 11 + .../parquet_13053_duplicate_column_names.test | 21 + .../corpus/sql/copy/parquet/parquet_1554.test | 13 + .../corpus/sql/copy/parquet/parquet_1588.test | 37 + .../corpus/sql/copy/parquet/parquet_1589.test | 13 + .../parquet/parquet_1618_struct_strings.test | 17 + .../corpus/sql/copy/parquet/parquet_1619.test | 17 + ...parquet_22147_union_by_name_nonnested.test | 41 + .../corpus/sql/copy/parquet/parquet_2267.test | 13 + .../corpus/sql/copy/parquet/parquet_3896.test | 67 ++ .../corpus/sql/copy/parquet/parquet_3989.test | 17 + .../corpus/sql/copy/parquet/parquet_4442.test | 9 + .../corpus/sql/copy/parquet/parquet_4859.test | 9 + .../corpus/sql/copy/parquet/parquet_4903.test | 9 + .../corpus/sql/copy/parquet/parquet_5209.test | 20 + .../corpus/sql/copy/parquet/parquet_6044.test | 13 + .../corpus/sql/copy/parquet/parquet_6580.test | 12 + .../parquet/parquet_6630_union_by_name.test | 25 + .../corpus/sql/copy/parquet/parquet_6933.test | 50 + .../copy/parquet/parquet_all_null_column.test | 77 ++ .../copy/parquet/parquet_arrow_timestamp.test | 13 + .../corpus/sql/copy/parquet/parquet_blob.test | 9 + .../sql/copy/parquet/parquet_blob_string.test | 53 + .../parquet_bloom_filter_corruption.test | 21 + .../parquet_column_metadata_corruption.test | 23 + .../parquet_copy_failure_cleans_up.test | 21 + .../parquet/parquet_copy_type_mismatch.test | 37 + .../copy/parquet/parquet_corrupt_stats.test | 9 + .../sql/copy/parquet/parquet_count_star.test | 13 + .../parquet/parquet_debug_use_openssl.test | 13 + ...parquet_dictionary_zero_sum_aggregate.test | 20 + .../copy/parquet/parquet_encoding_skip.test | 21 + .../sql/copy/parquet/parquet_encryption.test | 81 ++ .../sql/copy/parquet/parquet_enum_test.test | 9 + .../parquet/parquet_expression_filter.test | 34 + .../parquet_expression_filter_pruning.test | 298 +++++ .../copy/parquet/parquet_external_access.test | 33 + .../sql/copy/parquet/parquet_filename.test | 87 ++ .../copy/parquet/parquet_filename_filter.test | 69 ++ .../copy/parquet/parquet_filter_bug1391.test | 26 + ...parquet_filter_dictionary_materialize.test | 32 + .../parquet_fixed_length_blob_dict.test | 16 + .../sql/copy/parquet/parquet_glob_cache.test | 9 + .../corpus/sql/copy/parquet/parquet_go.test | 9 + .../corpus/sql/copy/parquet/parquet_hive.test | 139 +++ .../sql/copy/parquet/parquet_hive2.test | 45 + .../sql/copy/parquet/parquet_hive_empty.test | 29 + .../sql/copy/parquet/parquet_hive_null.test | 141 +++ .../parquet/parquet_hive_override_stats.test | 59 + .../parquet_json_varchar_mismatch.test | 33 + .../parquet/parquet_late_materialization.test | 101 ++ .../corpus/sql/copy/parquet/parquet_list.test | 37 + .../parquet/parquet_list.test.metadata.json | 7 + .../sql/copy/parquet/parquet_metadata.test | 62 + .../copy/parquet/parquet_metadata_blob.test | 41 + .../copy/parquet/parquet_metadata_cache.test | 35 + .../corpus/sql/copy/parquet/parquet_nan.test | 30 + .../sql/copy/parquet/parquet_no_stats.test | 9 + .../sql/copy/parquet/parquet_nullbyte.test | 13 + .../sql/copy/parquet/parquet_pandas_date.test | 9 + .../parquet/parquet_prefetch_cost_model.test | 55 + .../parquet_prefetch_cost_model_remote.test | 33 + .../parquet_prefetch_metrics_multifile.test | 67 ++ .../parquet/parquet_prefetch_projection.test | 66 ++ .../parquet_prefetch_row_group_outcome.test | 166 +++ .../parquet_prefetch_strategy_option.test | 47 + .../parquet_prefetch_tracked_memory.test | 21 + .../sql/copy/parquet/parquet_row_number.test | 61 + .../parquet/parquet_schema_evolution.test | 105 ++ .../parquet_schema_num_children_fix.test | 81 ++ .../sql/copy/parquet/parquet_silly.test | 9 + .../copy/parquet/parquet_sqlnull_write.test | 21 + .../sql/copy/parquet/parquet_stats.test | 125 ++ .../copy/parquet/parquet_string_stats.test | 9 + .../copy/parquet/parquet_union_by_name.test | 89 ++ .../copy/parquet/parquet_virtual_columns.test | 35 + ...parquet_virtual_file_row_group_number.test | 114 ++ ...l_file_row_group_number.test.metadata.json | 5 + .../parquet_virtual_file_row_number.test | 17 + .../copy/parquet/parquet_write_codecs.test | 33 + .../parquet/parquet_write_repeated_lists.test | 17 + .../corpus/sql/copy/parquet/parquet_zstd.test | 9 + .../parquet/partition_by_bind_issues.test | 27 + .../readahead_active_jobs_hang.test | 13 + .../read_ahead/readahead_depth_learning.test | 35 + .../read_ahead/readahead_depth_setting.test | 33 + .../read_ahead/readahead_io_errors.test | 21 + .../readahead_limit_slot_leak_hang.test | 13 + .../readahead_order_preservation.test | 32 + .../readahead_starved_consumers.test | 17 + .../copy/parquet/read_parquet_parameter.test | 17 + .../recursive_parquet_union_by_name.test | 23 + .../replacement_scan_custom_extension.test | 17 + .../corpus/sql/copy/parquet/rle_bool.test | 13 + .../copy/parquet/shredded_variant_stats.test | 192 +++ .../corpus/sql/copy/parquet/spark_v2.test | 17 + .../parquet/struct_column_reader_skip.test | 9 + .../parquet/struct_skip_pushdown_null.test | 28 + .../sql/copy/parquet/test_aws_files.test | 9 + .../test_parallel_many_row_groups.test | 13 + .../copy/parquet/test_parquet_decimal.test | 25 + .../test_parquet_duplicate_columns.test | 25 + .../parquet/test_parquet_filter_pushdown.test | 105 ++ .../sql/copy/parquet/test_parquet_gzip.test | 9 + .../sql/copy/parquet/test_parquet_nested.test | 41 + .../sql/copy/parquet/test_parquet_null.test | 9 + .../sql/copy/parquet/test_parquet_scan.test | 161 +++ .../sql/copy/parquet/test_parquet_stats.test | 65 + .../sql/copy/parquet/timestamp_ms_stats.test | 37 + .../corpus/sql/copy/parquet/timestamp_s.test | 25 + .../sql/copy/parquet/timetz_parquet.test | 9 + .../corpus/sql/copy/parquet/timezone.test | 17 + .../union_by_name_hive_partitioning.test | 94 ++ .../copy/parquet/union_by_name_pushdown.test | 37 + .../parquet/union_by_name_struct_filter.test | 17 + .../union_by_name_struct_projection.test | 35 + .../variant_array_row_group_pruning.test | 24 + .../parquet_dictionary_index_width.test | 101 ++ .../parquet/writer/parquet_empty_struct.test | 17 + .../writer/parquet_test_all_types.test | 46 + .../writer/parquet_timetz_metadata.test | 22 + .../writer/parquet_timetz_roundtrip.test | 22 + .../parquet/writer/parquet_union_list.test | 219 ++++ .../writer/parquet_write_booleans.test | 31 + .../parquet_write_compression_level.test | 45 + .../writer/parquet_write_data_page_size.test | 35 + .../parquet/writer/parquet_write_date.test | 29 + .../writer/parquet_write_decimals.test | 72 ++ .../parquet/writer/parquet_write_enums.test | 68 ++ .../writer/parquet_write_field_id.test | 197 ++++ .../writer/parquet_write_home_directory.test | 29 + .../parquet/writer/parquet_write_hugeint.test | 25 + .../writer/parquet_write_interval.test | 30 + .../writer/parquet_write_issue_5779.test | 53 + .../writer/parquet_write_memory_usage.test | 21 + ...quet_write_memory_usage.test.metadata.json | 5 + .../parquet/writer/parquet_write_signed.test | 69 ++ .../writer/parquet_write_string_distinct.test | 13 + .../parquet/writer/parquet_write_strings.test | 58 + .../writer/parquet_write_strings_v1.test | 9 + .../writer/parquet_write_timestamp.test | 125 ++ .../writer/parquet_write_uhugeint.test | 13 + .../writer/parquet_write_unsigned.test | 69 ++ .../parquet/writer/parquet_write_uuid.test | 58 + .../writer/partition_without_hive.test | 25 + .../parquet/writer/row_group_size_bytes.test | 73 ++ .../copy/parquet/writer/skip_empty_write.test | 61 + .../writer/test_copy_overwrite_parquet.test | 29 + .../parquet/writer/test_parquet_write.test | 33 + .../writer/test_parquet_write_complex.test | 73 ++ .../parquet/writer/write_complex_nested.test | 94 ++ .../sql/copy/parquet/writer/write_list.test | 61 + .../sql/copy/parquet/writer/write_map.test | 90 ++ .../writer/write_stats_big_string.test | 25 + .../writer/write_stats_null_count.test | 45 + .../sql/copy/parquet/writer/write_struct.test | 121 ++ .../partitioned/hive_filter_pushdown.test | 41 + .../partitioned/hive_partition_append.test | 52 + ...ive_partition_case_insensitive_column.test | 9 + .../hive_partition_compression.test | 14 + .../hive_partition_duplicate_name.test | 11 + .../partitioned/hive_partition_escape.test | 51 + .../hive_partition_join_pushdown.test | 68 ++ .../hive_partition_recursive_cte.test | 35 + .../hive_partitioned_delayed_flush.test | 125 ++ .../partitioned/hive_partitioned_write.test | 110 ++ .../hive_partitioning_overwrite.test | 41 + .../order_by_without_partition.test | 188 +++ .../copy/partitioned/partition_by_syntax.test | 49 + .../partition_by_syntax.test.metadata.json | 5 + .../partitioned/partition_issue_6304.test | 21 + .../partitioned_early_finalize.test | 149 +++ .../partitioned_file_rotation.test | 132 +++ .../partitioned/partitioned_group_by.test | 123 ++ .../partitioned/partitioned_order_by.test | 156 +++ .../partitioned_order_by_flush_race.test | 28 + .../copy/partitioned/partitioned_window.test | 79 ++ .../skip_partition_column_writes.test | 189 +++ .../corpus/sql/copy/per_thread_output.test | 45 + .../corpus/sql/copy/return_files.test | 45 + .../corpus/sql/copy/return_stats.test | 229 ++++ .../sql/copy/return_stats_extra_info.test | 37 + .../sql/copy/return_stats_truncate.test | 29 + .../corpus/sql/copy/row_groups_per_file.test | 151 +++ parser/testdata/corpus/sql/copy/tmp_file.test | 29 + .../copy_database_different_types.test | 65 + .../copy_database/copy_database_errors.test | 41 + .../sql/copy_database/copy_database_fk.test | 9 + .../copy_database/copy_database_gen_col.test | 25 + .../copy_database/copy_database_index.test | 41 + .../copy_database/copy_database_multiple.test | 17 + .../copy_database/copy_database_simple.test | 29 + .../copy_database_with_index.test | 26 + .../copy_database_with_unique_index.test | 49 + .../copy_table_with_sequence.test | 94 ++ .../testdata/corpus/sql/create/create_as.test | 105 ++ .../sql/create/create_as_issue_11968.test | 17 + .../create_as_partition_sorted_options.test | 133 +++ .../corpus/sql/create/create_database.test | 17 + .../create/create_index_on_issue_13643.test | 29 + .../sql/create/create_objects_readonly.test | 29 + .../corpus/sql/create/create_or_replace.test | 29 + .../create_or_replace.test.metadata.json | 5 + .../create_table_as_duplicate_names.test | 53 + .../sql/create/create_table_as_error.test | 9 + .../create_table_as_error.test.metadata.json | 5 + .../sql/create/create_table_compression.test | 93 ++ .../sql/create/create_table_empty_name.test | 13 + ...create_table_empty_name.test.metadata.json | 5 + .../create/create_table_extra_options.test | 164 +++ .../create/create_table_with_arraybounds.test | 59 + .../corpus/sql/create/create_using_index.test | 9 + parser/testdata/corpus/sql/cte/cte_bc.test | 25 + .../sql/cte/cte_colname_issue_10074.test | 15 + .../testdata/corpus/sql/cte/cte_describe.test | 29 + .../sql/cte/cte_describe.test.metadata.json | 6 + .../corpus/sql/cte/cte_issue_17311.test | 16 + .../corpus/sql/cte/cte_null_values.test | 12 + .../corpus/sql/cte/cte_on_conflict_issue.test | 32 + .../testdata/corpus/sql/cte/cte_schema.test | 18 + .../sql/cte/cte_with_replacement_scan.test | 16 + parser/testdata/corpus/sql/cte/dml_cte.test | 706 +++++++++++ .../corpus/sql/cte/dml_cte.test.metadata.json | 10 + .../sql/cte/incorrect_recursive_cte.test | 17 + .../corpus/sql/cte/insert_cte_bug_3417.test | 29 + .../corpus/sql/cte/lazy_cte_bind.test | 10 + .../sql/cte/lazy_cte_bind_correlated.test | 15 + .../annotated_and_auto_materialized.test | 44 + .../cte/materialized/cte_filter_pusher.test | 109 ++ .../materialized/dml_materialized_cte.test | 68 ++ .../incorrect_recursive_cte_materialized.test | 17 + .../sql/cte/materialized/internal_3004.test | 34 + .../materialized_cte_modifiers.test | 36 + .../materialized_cte_order_preservation.test | 188 +++ .../materialized_cte_parallel_buffered.test | 172 +++ .../materialized_cte_prepared.test | 85 ++ .../recursive_array_slice_materialized.test | 59 + .../recursive_cte_complex_pipelines.test | 94 ++ .../recursive_cte_error_materialized.test | 32 + .../recursive_hang_2745_materialized.test | 64 + .../test_bug_922_materialized.test | 10 + ...correlated_recursive_cte_materialized.test | 175 +++ .../test_cte_hash_join_exchange.test | 319 +++++ .../test_cte_in_cte_materialized.test | 45 + ...cte_in_cte_materialized.test.metadata.json | 5 + .../materialized/test_cte_materialized.test | 105 ++ .../test_cte_overflow_materialized.test | 21 + .../cte/materialized/test_issue_10260.test | 30 + .../materialized/test_materialized_cte.test | 214 ++++ ...est_nested_recursive_cte_materialized.test | 43 + ...uter_joins_recursive_cte_materialized.test | 37 + ...t_recursive_cte_tutorial_materialized.test | 111 ++ ..._recursive_cte_union_all_materialized.test | 68 ++ ..._union_all_materialized.test.metadata.json | 8 + ...test_recursive_cte_union_materialized.test | 85 ++ ..._cte_union_materialized.test.metadata.json | 8 + .../corpus/sql/cte/recursive_array_slice.test | 51 + .../sql/cte/recursive_cte_batch_index.test | 59 + .../sql/cte/recursive_cte_column_pruning.test | 173 +++ .../cte/recursive_cte_complex_pipelines.test | 169 +++ .../cte/recursive_cte_correlated_complex.test | 101 ++ .../corpus/sql/cte/recursive_cte_error.test | 20 + .../cte/recursive_cte_invariant_build.test | 85 ++ ...recursive_cte_invariant_build_logging.test | 138 +++ .../cte/recursive_cte_key_aggregation.test | 464 ++++++++ .../cte/recursive_cte_key_final_drain.test | 64 + .../recursive_cte_key_hll_aggregation.test | 25 + .../sql/cte/recursive_cte_key_probe.test | 516 ++++++++ .../sql/cte/recursive_cte_key_snapshot.test | 63 + .../corpus/sql/cte/recursive_cte_limit.test | 50 + .../corpus/sql/cte/recursive_cte_logging.test | 380 ++++++ ...recursive_cte_parallel_union_all_sink.test | 75 ++ ...sive_cte_parallel_union_distinct_sink.test | 60 + .../corpus/sql/cte/recursive_hang_2745.test | 64 + .../testdata/corpus/sql/cte/test_bug_922.test | 10 + parser/testdata/corpus/sql/cte/test_cte.test | 169 +++ .../sql/cte/test_cte.test.metadata.json | 5 + .../corpus/sql/cte/test_cte_in_cte.test | 33 + .../corpus/sql/cte/test_cte_overflow.test | 13 + .../corpus/sql/cte/test_issue_5673.test | 34 + .../sql/cte/test_moderate_union_all.test | 112 ++ .../sql/cte/test_nested_recursive_cte.test | 43 + .../cte/test_outer_joins_recursive_cte.test | 82 ++ .../sql/cte/test_recursive_cte_recurring.test | 94 ++ .../sql/cte/test_recursive_cte_tutorial.test | 80 ++ .../sql/cte/test_recursive_cte_union.test | 97 ++ ...est_recursive_cte_union.test.metadata.json | 8 + .../sql/cte/test_recursive_cte_union_all.test | 73 ++ ...recursive_cte_union_all.test.metadata.json | 8 + .../warn_deprecated_union_in_using_key.test | 31 + .../bulk_delete_version_info_memory.test | 17 + .../delete/cleanup_delete_on_conflict.test | 17 + .../delete_compression_after_restart.test | 29 + ...e_compression_blocked_by_old_snapshot.test | 37 + .../corpus/sql/delete/delete_query_node.test | 78 ++ .../delete/full_vector_delete_conflict.test | 29 + .../delete/full_vector_delete_rollback.test | 13 + .../delete/large_deletes_transactions.test | 13 + .../corpus/sql/delete/list_delete.test | 25 + .../delete/masked_vector_further_delete.test | 25 + .../sql/delete/masked_vector_rollback.test | 25 + .../partial_delete_version_info_memory.test | 21 + .../corpus/sql/delete/test_delete.test | 21 + .../sql/delete/test_delete_indexed.test | 118 ++ .../corpus/sql/delete/test_large_delete.test | 17 + .../sql/delete/test_segment_deletes.test | 45 + .../corpus/sql/delete/test_truncate.test | 13 + .../corpus/sql/delete/test_using_delete.test | 41 + .../delete/test_using_delete_duplicates.test | 97 ++ .../test_detailed_profiler.test | 15 + .../corpus/sql/error/aggregate_order_by.test | 17 + .../sql/error/correlated_at_clause.test | 13 + .../sql/error/error_location_multicaret.test | 25 + .../error/error_location_not_duplicated.test | 9 + .../corpus/sql/error/error_position.test | 13 + .../error/error_position_json_execute.test | 13 + .../corpus/sql/error/escape_percent_sign.test | 14 + .../sql/error/extension_function_error.test | 41 + .../corpus/sql/error/incorrect_sql.test | 163 +++ .../corpus/sql/error/lineitem_errors.test | 73 ++ .../corpus/sql/error/missing_type.test | 9 + .../mix_aggregate_and_non_aggregate.test | 21 + .../sql/error/qualified_column_error.test | 49 + .../sql/error/subquery_single_column.test | 9 + .../table_function_as_scalar_function.test | 9 + .../sql/error/unknown_window_function.test | 9 + .../sql/explain/explain_all_statements.test | 101 ++ .../corpus/sql/explain/explain_execute.test | 21 + .../corpus/sql/explain/explain_formats.test | 131 ++ .../explain/order_by_topn_explain_fqn.test | 48 + .../corpus/sql/explain/test_explain.test | 49 + .../sql/explain/test_explain_analyze.test | 73 ++ .../test_explain_analyze.test.metadata.json | 6 + .../sql/explain/test_explain_limit.test | 21 + .../corpus/sql/export/empty_export.test | 9 + .../sql/export/export_compression_level.test | 38 + .../corpus/sql/export/export_database.test | 161 +++ .../export/export_database.test.metadata.json | 7 + .../sql/export/export_external_access.test | 17 + .../corpus/sql/export/export_functions.test | 26 + .../sql/export/export_generated_columns.test | 44 + .../corpus/sql/export/export_hive_path.test | 17 + .../corpus/sql/export/export_indexes.test | 41 + .../corpus/sql/export/export_macros.test | 33 + .../corpus/sql/export/export_quoted_enum.test | 37 + .../sql/export/export_quoted_structs.test | 17 + .../sql/export/export_quoted_union.test | 24 + .../corpus/sql/export/export_temp_tables.test | 17 + .../corpus/sql/export/export_types.test | 49 + .../export/parquet/export_parquet_bit.test | 13 + .../export/parquet/export_parquet_enum.test | 24 + .../parquet/export_parquet_hugeint.test | 9 + .../export/parquet/export_parquet_json.test | 9 + .../export/parquet/export_parquet_list.test | 11 + .../export/parquet/export_parquet_map.test | 31 + .../export/parquet/export_parquet_struct.test | 15 + .../export/parquet/export_parquet_union.test | 17 + .../corpus/sql/export/parquet_export.test | 29 + .../corpus/sql/extensions/aliasing.test | 49 + .../allowed_directories_install.test | 21 + .../attach_type_alias_conflict.test | 33 + .../corpus/sql/extensions/checked_load.test | 21 + .../sql/extensions/load_arbitrary_path.test | 9 + .../load_use_extension_one_query.test | 13 + ...use_extension_one_query.test.metadata.json | 6 + .../permissions_duckdb_extension.test | 33 + .../corpus/sql/extensions/quack_peeling.test | 49 + .../quack_peeling.test.metadata.json | 9 + .../extensions/sqlite_alter_table_add_pk.test | 21 + .../extensions/version_is_valid_sqlite.test | 13 + .../corpus/sql/filter/filter_cache.test | 21 + .../sql/filter/filter_cache_dictionary.test | 62 + .../corpus/sql/filter/test_alias_filter.test | 29 + .../sql/filter/test_constant_comparisons.test | 97 ++ .../test_expression_executor_select.test | 91 ++ .../sql/filter/test_illegal_filters.test | 9 + .../filter/test_last_option_corruption.test | 9 + .../sql/filter/test_obsolete_filters.test | 229 ++++ .../corpus/sql/filter/test_or_pushdown.test | 69 ++ .../sql/filter/test_struct_pushdown.test | 190 +++ .../sql/filter/test_transitive_filters.test | 202 ++++ ...test_try_filter_doesnt_mutate_columns.test | 150 +++ .../sql/filter/test_variant_filter.test | 75 ++ .../sql/filter/test_zonemap_segment.test | 49 + .../sql/function/array/array_and_map.test | 17 + .../function/array/array_cosine_distance.test | 37 + .../array/array_cosine_similarity.test | 25 + .../function/array/array_cross_product.test | 35 + .../sql/function/array/array_distance.test | 29 + .../sql/function/array/array_flatten.test | 13 + .../function/array/array_inner_product.test | 37 + .../sql/function/array/array_length.test | 45 + .../function/array/array_list_functions.test | 69 ++ .../function/autocomplete/alter_table.test | 21 + .../sql/function/autocomplete/copy.test | 25 + .../autocomplete/create_function.test | 29 + .../function/autocomplete/create_schema.test | 29 + .../autocomplete/create_sequence.test | 17 + .../function/autocomplete/create_table.test | 97 ++ .../function/autocomplete/create_type.test | 21 + .../sql/function/autocomplete/drop.test | 45 + .../function/autocomplete/expressions.test | 73 ++ .../autocomplete/identical_schema_table.test | 17 + .../function/autocomplete/insert_into.test | 33 + .../sql/function/autocomplete/pragma.test | 21 + .../autocomplete/scalar_functions.test | 17 + .../sql/function/autocomplete/select.test | 201 ++++ .../sql/function/autocomplete/setting.test | 25 + .../sql/function/autocomplete/show.test | 21 + .../sql/function/autocomplete/sql_format.test | 712 +++++++++++ .../function/autocomplete/suggest_file.test | 13 + .../autocomplete/table_functions.test | 41 + .../sql/function/autocomplete/tpch.test | 130 ++ .../sql/function/autocomplete/views.test | 21 + .../sql/function/autocomplete/window.test | 45 + .../corpus/sql/function/blob/base64.test | 73 ++ .../sql/function/blob/create_sort_key.test | 181 +++ .../blob/create_sort_key_blob_escapes.test | 89 ++ .../corpus/sql/function/blob/encode.test | 45 + .../function/blob/test_blob_array_slice.test | 49 + .../sql/function/blob/test_concat_blob.test | 21 + .../corpus/sql/function/date/date_add.test | 17 + .../date/date_diff_extreme_dates.test | 33 + .../sql/function/date/date_part_stats.test | 149 +++ .../sql/function/date/date_trunc_4202.test | 29 + .../sql/function/date/date_trunc_stats.test | 44 + .../sql/function/date/test_date_part.test | 264 +++++ .../sql/function/date/test_date_trunc.test | 197 ++++ .../sql/function/date/test_extract.test | 85 ++ .../date/test_extract_edge_cases.test | 269 +++++ .../sql/function/date/test_extract_month.test | 13 + .../sql/function/date/test_extract_year.test | 21 + .../sql/function/date/test_strftime.test | 106 ++ .../date/test_strftime_exhaustive.test | 186 +++ .../function/date/test_time_bucket_date.test | 318 +++++ .../sql/function/enum/test_enum_code.test | 41 + .../sql/function/enum/test_enum_first.test | 17 + .../sql/function/enum/test_enum_last.test | 13 + .../sql/function/enum/test_enum_range.test | 45 + .../sql/function/generic/assert_true.test | 45 + .../function/generic/can_cast_implicitly.test | 25 + .../sql/function/generic/case_condition.test | 13 + .../function/generic/case_short_circuit.test | 21 + .../sql/function/generic/case_varchar.test | 17 + .../sql/function/generic/cast_to_type.test | 49 + .../function/generic/constant_or_null.test | 25 + .../corpus/sql/function/generic/error.test | 40 + .../sql/function/generic/hash_func.test | 154 +++ .../corpus/sql/function/generic/invoke.test | 101 ++ .../function/generic/least_greatest_enum.test | 13 + .../generic/least_greatest_types.test | 17 + .../sql/function/generic/replace_type.test | 41 + .../function/generic/table_func_varargs.test | 9 + .../generic/test_approx_database_count.test | 21 + .../sql/function/generic/test_between.test | 214 ++++ .../generic/test_between_sideeffects.test | 37 + .../function/generic/test_boolean_test.test | 77 ++ .../generic/test_connection_count.test | 9 + .../corpus/sql/function/generic/test_if.test | 25 + .../sql/function/generic/test_if_null.test | 21 + .../corpus/sql/function/generic/test_in.test | 142 +++ .../function/generic/test_least_greatest.test | 137 +++ .../sql/function/generic/test_null_if.test | 41 + .../corpus/sql/function/generic/test_set.test | 57 + .../generic/test_set.test.metadata.json | 5 + .../sql/function/generic/test_sleep.test | 133 +++ .../generic/test_sleep.test.metadata.json | 5 + .../sql/function/generic/test_stats.test | 49 + .../function/generic/test_table_param.test | 21 + .../corpus/sql/function/index/index_key.test | 296 +++++ .../sql/function/interval/test_date_part.test | 145 +++ .../sql/function/interval/test_extract.test | 129 ++ .../interval/test_interval_muldiv.test | 58 + .../interval/test_interval_trunc.test | 81 ++ .../function/list/aggregates/any_value.test | 71 ++ .../aggregates/approx_count_distinct.test | 97 ++ .../sql/function/list/aggregates/avg.test | 61 + .../list/aggregates/bigints_sum_avg.test | 63 + .../sql/function/list/aggregates/bit_and.test | 29 + .../sql/function/list/aggregates/bit_or.test | 25 + .../sql/function/list/aggregates/bit_xor.test | 25 + .../function/list/aggregates/bool_and_or.test | 41 + .../sql/function/list/aggregates/count.test | 29 + .../sql/function/list/aggregates/entropy.test | 69 ++ .../sql/function/list/aggregates/first.test | 59 + .../function/list/aggregates/histogram.test | 81 ++ .../list/aggregates/histogram_decimal.test | 9 + .../sql/function/list/aggregates/hugeint.test | 29 + .../function/list/aggregates/incorrect.test | 133 +++ .../function/list/aggregates/kurtosis.test | 36 + .../sql/function/list/aggregates/last.test | 30 + .../sql/function/list/aggregates/mad.test | 110 ++ .../sql/function/list/aggregates/max.test | 26 + .../sql/function/list/aggregates/median.test | 33 + .../sql/function/list/aggregates/min.test | 26 + .../list/aggregates/minmax_nested.test | 153 +++ .../sql/function/list/aggregates/mode.test | 105 ++ .../sql/function/list/aggregates/nested.test | 41 + .../list/aggregates/null_or_empty.test | 25 + .../sql/function/list/aggregates/product.test | 33 + .../sql/function/list/aggregates/sem.test | 37 + .../function/list/aggregates/skewness.test | 60 + .../function/list/aggregates/string_agg.test | 70 ++ .../sql/function/list/aggregates/sum.test | 53 + .../function/list/aggregates/sum_bool.test | 17 + .../list/aggregates/sum_no_overflow.test | 13 + .../function/list/aggregates/uhugeint.test | 29 + .../function/list/aggregates/var_stddev.test | 97 ++ .../sql/function/list/array_length.test | 41 + .../sql/function/list/array_to_string.test | 33 + .../list/array_to_string_comma_default.test | 41 + .../corpus/sql/function/list/flatten.test | 119 ++ .../sql/function/list/generate_series.test | 193 +++ .../list/generate_series_timestamp.test | 71 ++ .../function/list/generate_subscripts.test | 21 + .../list/icu_generate_series_timestamptz.test | 77 ++ .../function/list/lambda_constant_null.test | 9 + .../expression_iterator_cases_deprecated.test | 107 ++ .../list/lambdas/arrow/filter_deprecated.test | 155 +++ .../arrow/lambda_scope_deprecated.test | 141 +++ .../lambdas_and_functions_deprecated.test | 31 + .../lambdas_and_group_by_deprecated.test | 48 + .../arrow/lambdas_and_macros_deprecated.test | 65 + .../arrow/list_comprehension_deprecated.test | 79 ++ .../list/lambdas/arrow/reduce_deprecated.test | 301 +++++ .../arrow/reduce_initial_deprecated.test | 306 +++++ .../arrow/rhs_parameters_deprecated.test | 64 + .../lambdas/arrow/storage_deprecated.test | 37 + .../arrow/table_functions_deprecated.test | 74 ++ .../lambdas/arrow/test_deprecated_lambda.test | 17 + .../test_lambda_arrow_storage_deprecated.test | 23 + .../lambdas/arrow/transform_deprecated.test | 211 ++++ .../transform_with_index_deprecated.test | 85 ++ .../lambdas/arrow/warn_deprecated_arrow.test | 25 + .../lambdas/expression_iterator_cases.test | 91 ++ .../sql/function/list/lambdas/filter.test | 127 ++ .../sql/function/list/lambdas/incorrect.test | 210 ++++ .../function/list/lambdas/lambda_scope.test | 61 + .../list/lambdas/lambdas_and_functions.test | 23 + .../list/lambdas/lambdas_and_group_by.test | 29 + .../list/lambdas/lambdas_and_macros.test | 41 + .../list/lambdas/list_comprehension.test | 59 + .../sql/function/list/lambdas/reduce.test | 205 ++++ .../function/list/lambdas/reduce_initial.test | 294 +++++ .../function/list/lambdas/rhs_parameters.test | 58 + .../sql/function/list/lambdas/storage.test | 22 + .../list/lambdas/table_functions.test | 44 + .../list/lambdas/test_lambda_storage.test | 13 + .../sql/function/list/lambdas/transform.test | 193 +++ .../list/lambdas/transform_with_index.test | 93 ++ .../function/list/lambdas/vector_types.test | 17 + .../corpus/sql/function/list/list_concat.test | 205 ++++ .../sql/function/list/list_contains.test | 340 ++++++ .../function/list/list_cosine_similarity.test | 41 + .../sql/function/list/list_distance.test | 33 + .../sql/function/list/list_distinct.test | 178 +++ .../list/list_has_any_and_has_all.test | 229 ++++ .../sql/function/list/list_inner_product.test | 33 + .../sql/function/list/list_intersect.test | 137 +++ .../sql/function/list/list_position.test | 305 +++++ .../sql/function/list/list_position_nan.test | 21 + .../corpus/sql/function/list/list_resize.test | 265 +++++ .../sql/function/list/list_resize_error.test | 45 + .../sql/function/list/list_reverse.test | 205 ++++ .../sql/function/list/list_sort_having.test | 49 + .../function/list/list_sort_vector_types.test | 21 + .../corpus/sql/function/list/list_unique.test | 141 +++ .../sql/function/list/list_value_arrays.test | 141 +++ .../list/list_value_nested_lists.test | 167 +++ .../sql/function/list/list_value_structs.test | 99 ++ .../corpus/sql/function/list/list_where.test | 161 +++ .../corpus/sql/function/list/list_zip.test | 233 ++++ .../corpus/sql/function/list/repeat_list.test | 57 + .../list/test_lambda_with_struct_aliases.test | 46 + .../nested/array_extract_unnamed_struct.test | 41 + .../sql/function/nested/test_issue_5437.test | 13 + .../function/nested/test_struct_insert.test | 46 + .../function/nested/test_struct_update.test | 78 ++ .../corpus/sql/function/numeric/abs.test | 9 + .../sql/function/numeric/decimal_mod.test | 33 + .../function/numeric/set_seed_for_sample.test | 13 + .../numeric/test_arithmetic_aliases.test | 29 + .../sql/function/numeric/test_binom.test | 61 + .../sql/function/numeric/test_bit_count.test | 17 + .../sql/function/numeric/test_even.test | 41 + .../sql/function/numeric/test_factorial.test | 41 + .../sql/function/numeric/test_fdiv_fmod.test | 61 + .../sql/function/numeric/test_floor_ceil.test | 65 + .../sql/function/numeric/test_gamma.test | 105 ++ .../sql/function/numeric/test_gcd_lcm.test | 50 + .../sql/function/numeric/test_geomean.test | 25 + .../function/numeric/test_invalid_math.test | 49 + .../sql/function/numeric/test_is_nan.test | 61 + .../corpus/sql/function/numeric/test_mod.test | 29 + .../sql/function/numeric/test_nextafter.test | 77 ++ .../sql/function/numeric/test_pg_math.test | 133 +++ .../corpus/sql/function/numeric/test_pow.test | 41 + .../sql/function/numeric/test_random.test | 101 ++ .../sql/function/numeric/test_round.test | 57 + .../sql/function/numeric/test_round_even.test | 61 + .../function/numeric/test_round_integers.test | 39 + .../sql/function/numeric/test_sign_bit.test | 33 + .../sql/function/numeric/test_trigo.test | 269 +++++ .../sql/function/numeric/test_trunc.test | 61 + .../numeric/test_trunc_precision.test | 64 + .../numeric/test_type_resolution.test | 173 +++ .../sql/function/numeric/test_unary.test | 73 ++ .../function/operator/test_arithmetic.test | 57 + .../operator/test_arithmetic_sqllogic.test | 61 + .../function/operator/test_bitwise_ops.test | 65 + .../operator/test_bitwise_ops_types.test | 29 + .../function/operator/test_comparison.test | 53 + .../test_comparison.test.metadata.json | 7 + .../function/operator/test_conjunction.test | 137 +++ .../operator/test_date_arithmetic.test | 69 ++ .../operator/test_division_overflow.test | 37 + .../operator/test_in_empty_table.test | 17 + .../sql/function/string/format_bytes.test | 101 ++ .../corpus/sql/function/string/hex.test | 57 + .../sql/function/string/like_unicode.test | 45 + .../corpus/sql/function/string/md5.test | 37 + .../corpus/sql/function/string/null_byte.test | 98 ++ .../corpus/sql/function/string/overlay.test | 137 +++ .../string/parse_formatted_bytes.test | 165 +++ .../sql/function/string/parse_path.test | 337 ++++++ .../function/string/parse_path_windows.test | 49 + .../corpus/sql/function/string/path_join.test | 106 ++ .../sql/function/string/regex_capture.test | 112 ++ .../sql/function/string/regex_escape.test | 77 ++ .../sql/function/string/regex_extract.test | 106 ++ .../function/string/regex_extract_all.test | 489 ++++++++ .../string/regex_extract_all_struct.test | 273 +++++ .../string/regex_filter_pushdown.test | 29 + .../sql/function/string/regex_operators.test | 133 +++ .../string/regex_operators_v1_5_view.test | 21 + .../sql/function/string/regex_replace.test | 172 +++ .../sql/function/string/regex_search.test | 151 +++ .../string/regexp_split_to_table.test | 17 + .../string/regexp_unicode_literal.test | 49 + .../corpus/sql/function/string/sha1.test | 37 + .../corpus/sql/function/string/sha256.test | 29 + .../sql/function/string/strip_accents.test | 37 + .../function/string/test_array_extract.test | 77 ++ .../sql/function/string/test_ascii.test | 69 ++ .../corpus/sql/function/string/test_bar.test | 141 +++ .../sql/function/string/test_bit_length.test | 37 + .../sql/function/string/test_caseconvert.test | 49 + .../function/string/test_complex_unicode.test | 77 ++ .../sql/function/string/test_concat.test | 37 + .../function/string/test_concat_binding.test | 57 + .../function/string/test_concat_function.test | 37 + .../sql/function/string/test_concat_ws.test | 97 ++ .../sql/function/string/test_contains.test | 91 ++ .../function/string/test_contains_utf8.test | 49 + .../string/test_damerau_levenshtein.test | 230 ++++ .../sql/function/string/test_format.test | 89 ++ .../string/test_format_extensions.test | 125 ++ .../corpus/sql/function/string/test_glob.test | 213 ++++ .../sql/function/string/test_ilike.test | 117 ++ .../string/test_ilike_constant_pattern.test | 129 ++ .../string/test_ilike_embedded_null.test | 61 + .../function/string/test_ilike_escape.test | 97 ++ .../test_ilike_escape_constant_pattern.test | 154 +++ .../sql/function/string/test_instr.test | 57 + .../sql/function/string/test_instr_utf8.test | 37 + .../sql/function/string/test_issue_1812.test | 52 + .../sql/function/string/test_jaccard.test | 113 ++ .../function/string/test_jaro_winkler.test | 161 +++ .../corpus/sql/function/string/test_left.test | 61 + .../sql/function/string/test_length.test | 17 + .../sql/function/string/test_levenshtein.test | 158 +++ .../corpus/sql/function/string/test_like.test | 225 ++++ .../sql/function/string/test_like_escape.test | 91 ++ .../sql/function/string/test_mismatches.test | 125 ++ .../corpus/sql/function/string/test_pad.test | 85 ++ .../sql/function/string/test_prefix.test | 169 +++ .../sql/function/string/test_printf.test | 181 +++ .../sql/function/string/test_repeat.test | 61 + .../sql/function/string/test_replace.test | 53 + .../sql/function/string/test_reverse.test | 33 + .../sql/function/string/test_right.test | 25 + .../sql/function/string/test_similar_to.test | 113 ++ .../sql/function/string/test_split_part.test | 81 ++ .../string/test_starts_with_function.test | 67 ++ .../test_starts_with_function_utf8.test | 29 + .../string/test_starts_with_operator.test | 63 + .../test_starts_with_operator_utf8.test | 29 + .../string/test_string_array_slice.test | 133 +++ .../function/string/test_string_slice.test | 133 +++ .../test_string_slice.test.metadata.json | 8 + .../function/string/test_string_split.test | 201 ++++ .../sql/function/string/test_subscript.test | 61 + .../string/test_subscript.test.metadata.json | 5 + .../sql/function/string/test_substring.test | 177 +++ .../function/string/test_substring_utf8.test | 45 + .../sql/function/string/test_suffix.test | 153 +++ .../sql/function/string/test_to_base.test | 111 ++ .../sql/function/string/test_translate.test | 97 ++ .../corpus/sql/function/string/test_trim.test | 93 ++ .../sql/function/string/test_unicode.test | 29 + .../sql/function/string/test_url_encode.test | 41 + .../sql/function/test_scalar_executor.test | 33 + .../corpus/sql/function/time/epoch.test | 17 + .../sql/function/time/test_date_part.test | 174 +++ .../sql/function/time/test_extract.test | 85 ++ .../sql/function/time/test_extract_stats.test | 24 + .../function/time/test_time_bucket_time.test | 233 ++++ .../corpus/sql/function/timestamp/age.test | 129 ++ .../sql/function/timestamp/current_time.test | 53 + .../function/timestamp/current_timestamp.test | 27 + .../corpus/sql/function/timestamp/epoch.test | 37 + .../sql/function/timestamp/make_date.test | 287 +++++ .../timestamp/test_date_diff_epoch.test | 60 + .../function/timestamp/test_date_part.test | 280 +++++ .../sql/function/timestamp/test_extract.test | 81 ++ .../function/timestamp/test_extract_ms.test | 29 + .../sql/function/timestamp/test_icu_age.test | 88 ++ .../function/timestamp/test_icu_dateadd.test | 340 ++++++ .../function/timestamp/test_icu_datediff.test | 212 ++++ .../function/timestamp/test_icu_datepart.test | 322 +++++ .../function/timestamp/test_icu_datesub.test | 238 ++++ .../timestamp/test_icu_datetrunc.test | 135 +++ .../function/timestamp/test_icu_makedate.test | 203 ++++ .../function/timestamp/test_icu_strftime.test | 128 ++ .../function/timestamp/test_icu_strptime.test | 290 +++++ .../test_icu_time_bucket_timestamptz.test | 308 +++++ .../timestamp/test_last_modified.test | 18 + .../sql/function/timestamp/test_now.test | 21 + .../function/timestamp/test_now_prepared.test | 33 + .../timestamp/test_strftime_timestamp.test | 167 +++ .../timestamp/test_strftime_timestamp_ns.test | 15 + .../sql/function/timestamp/test_strptime.test | 533 +++++++++ .../timestamp/test_strptime_nonascii.test | 21 + .../timestamp/test_time_bucket_timestamp.test | 240 ++++ .../function/timestamp/test_try_strptime.test | 489 ++++++++ .../sql/function/timetz/test_date_part.test | 154 +++ .../sql/function/timetz/test_extract.test | 33 + .../sql/function/timetz/timetz_group_by.test | 13 + .../function/tokenize/simple_tokenize.test | 85 ++ .../corpus/sql/function/uuid/test_uuid.test | 55 + .../sql/function/uuid/test_uuid_function.test | 37 + .../variant/variant_array_length.test | 150 +++ .../variant_array_length_shredded.test | 68 ++ .../function/variant/variant_contains.test | 237 ++++ .../variant/variant_contains_shredded.test | 32 + .../sql/function/variant/variant_exists.test | 117 ++ .../variant/variant_exists_shredded.test | 49 + .../sql/function/variant/variant_extract.test | 80 ++ .../variant/variant_extract_string.test | 185 +++ .../variant_extract_string_shredded.test | 28 + .../variant/variant_extract_try_cast.test | 47 + .../function/variant/variant_group_array.test | 61 + .../variant/variant_group_array_shredded.test | 50 + .../sql/function/variant/variant_keys.test | 141 +++ .../variant/variant_keys_shredded.test | 39 + .../variant_shredded_extract_nested.test | 65 + .../sql/function/variant/variant_type.test | 124 ++ .../variant/variant_type_shredded.test | 27 + .../sql/function/variant/variant_typeof.test | 56 + .../sql/generated_columns/stored/basic.test | 12 + .../virtual/alter_table.test | 41 + .../virtual/alter_table.test.metadata.json | 8 + .../generated_columns/virtual/ambiguity.test | 55 + .../virtual/ambiguity.test.metadata.json | 5 + .../virtual/cascading_delete.test | 41 + .../generated_columns/virtual/casting.test | 33 + .../sql/generated_columns/virtual/check.test | 44 + .../circular_dependency_stresstest.test | 54 + .../generated_columns/virtual/collate.test | 28 + .../virtual/collate.test.metadata.json | 5 + .../virtual/create_table.test | 84 ++ .../virtual/create_table.test.metadata.json | 5 + .../generated_columns/virtual/default.test | 37 + .../virtual/default.test.metadata.json | 5 + .../virtual/drop_dependency.test | 16 + .../virtual/foreign_key.test | 69 ++ .../virtual/foreign_key_extensive.test | 16 + .../virtual/from_generated_column.test | 34 + .../from_generated_column.test.metadata.json | 5 + .../virtual/gcol_duckdb_columns.test | 29 + .../generated_columns/virtual/group_by.test | 65 + .../virtual/implicit_type.test | 43 + .../virtual/implicit_type.test.metadata.json | 5 + .../sql/generated_columns/virtual/insert.test | 59 + .../virtual/not_referencing_columns.test | 20 + .../sql/generated_columns/virtual/null.test | 24 + .../generated_columns/virtual/partition.test | 40 + .../virtual/preserve_order.test | 13 + .../virtual/primary_key.test | 28 + .../virtual/referencing_gencols.test | 65 + .../sql/generated_columns/virtual/rename.test | 13 + .../virtual/rename_dependency.test | 23 + .../virtual/rename_table.test | 21 + .../virtual/row_group_fetch.test | 25 + .../sql/generated_columns/virtual/rowid.test | 31 + .../virtual/rowid.test.metadata.json | 5 + .../sql/generated_columns/virtual/select.test | 25 + .../virtual/select_alias.test | 35 + .../virtual/type_resolution_bug.test | 20 + .../generated_columns/virtual/typechange.test | 20 + .../virtual/typechange_dependency.test | 9 + .../sql/generated_columns/virtual/unique.test | 28 + .../sql/generated_columns/virtual/update.test | 29 + .../virtual/update_index.test | 26 + .../test_art_compound_key_changes.test | 80 ++ .../test_art_eager_batch_insert.test | 33 + .../test_art_eager_constraint_checking.test | 248 ++++ .../constraints/test_art_eager_with_wal.test | 13 + .../art/constraints/test_art_large_abort.test | 33 + .../constraints/test_art_simple_update.test | 29 + .../test_art_tx_conflict_revert.test | 45 + ...test_art_tx_delete_with_global_nested.test | 25 + .../constraints/test_art_tx_deletes_list.test | 33 + .../test_art_tx_deletes_rollback.test | 25 + .../test_art_tx_deletes_varchar.test | 25 + .../constraints/test_art_tx_over_eager.test | 25 + .../constraints/test_art_tx_returning.test | 21 + .../constraints/test_art_tx_same_row_id.test | 13 + ...test_art_tx_update_with_global_nested.test | 13 + .../constraints/test_art_tx_updates_list.test | 33 + .../test_art_tx_updates_pk_col.test | 29 + .../test_art_tx_updates_rollback.test | 9 + ...test_art_tx_upsert_with_global_nested.test | 13 + .../constraints/test_art_tx_upserts_list.test | 13 + .../test_art_tx_upserts_local.test | 29 + .../test_art_tx_upserts_rollback.test | 13 + .../test_art_upsert_duplicate.test | 30 + .../test_art_upsert_other_index.test | 37 + .../test_art_big_compound_key.test | 19 + .../test_art_create_if_exists.test | 29 + .../test_art_create_index_delete.test | 25 + ...st_art_create_index_duplicate_deletes.test | 9 + .../test_art_create_many_duplicates.test | 41 + ...st_art_create_many_duplicates_deletes.test | 13 + .../create_drop/test_art_create_unique.test | 33 + .../art/create_drop/test_art_drop_index.test | 61 + .../test_art_invalid_create_index.test | 45 + .../create_drop/test_art_many_versions.test | 21 + .../create_drop/test_art_single_value.test | 45 + .../test_art_sel_vector.test | 45 + .../test_art_simple_update.test | 13 + .../insert_update_delete/test_art_update.test | 29 + .../test_art_update_other_column.test | 37 + .../test_art_update_same_value.test | 13 + .../test_art_update_with_dict_fsst.test | 25 + .../sql/index/art/issues/test_art_fuzzer.test | 93 ++ .../art/issues/test_art_fuzzer_persisted.test | 17 + .../issues/test_art_internal_issue_4742.test | 41 + .../art/issues/test_art_issue_21394.test | 13 + .../index/art/issues/test_art_issue_4976.test | 21 + .../index/art/issues/test_art_issue_6603.test | 38 + .../index/art/issues/test_art_issue_6799.test | 36 + .../index/art/issues/test_art_issue_7349.test | 45 + .../index/art/issues/test_art_issue_7530.test | 21 + .../art/issues/test_art_view_col_binding.test | 50 + .../multi_column/test_art_multi_column.test | 29 + .../test_art_multi_predicate.test | 13 + .../art/nodes/test_art_leaf_coverage.test | 77 ++ .../nodes/test_art_nested_leaf_coverage.test | 33 + .../sql/index/art/nodes/test_art_node_16.test | 29 + .../index/art/nodes/test_art_node_256.test | 17 + .../sql/index/art/nodes/test_art_node_4.test | 9 + .../sql/index/art/nodes/test_art_node_48.test | 41 + ...rt_prefix_transform_deprecated_create.test | 23 + ...art_prefix_transform_deprecated_gated.test | 89 ++ .../art/nodes/test_art_prefixes_restart.test | 54 + .../art/nodes/test_art_sparse_merge.test | 25 + .../art/scan/test_art_adaptive_scan.test | 25 + .../index/art/scan/test_art_many_matches.test | 37 + .../scan/test_art_negative_range_scan.test | 21 + .../art/scan/test_art_node256_byte_edges.test | 54 + .../index/art/scan/test_art_null_bytes.test | 69 ++ .../art/scan/test_art_prepared_scan.test | 29 + .../index/art/scan/test_art_range_scan.test | 61 + .../art/scan/test_art_scan_coverage.test | 137 +++ .../scan/test_art_scan_duplicate_filters.test | 63 + .../scan/test_art_scan_normal_to_nested.test | 37 + .../art/scan/test_art_scan_thresholds.test | 41 + .../test_hash_join_in_filter_index_scan.test | 35 + .../art/scan/test_in_filter_index_scan.test | 65 + .../scan/test_not_distinct_index_scan.test | 74 ++ .../sql/index/art/scan/test_random_uuid.test | 65 + .../art/storage/test_art_auto_checkpoint.test | 33 + ...test_art_buffered_replays_chunk_edges.test | 61 + ...test_art_buffered_replays_interleaved.test | 29 + ...art_buffered_replays_interval_merging.test | 97 ++ .../test_art_buffered_replays_multi_col.test | 63 + .../art/storage/test_art_checkpoint.test | 25 + .../art/storage/test_art_duckdb_versions.test | 93 ++ .../index/art/storage/test_art_import.test | 29 + .../art/storage/test_art_import_export.test | 22 + .../index/art/storage/test_art_mem_limit.test | 17 + .../sql/index/art/storage/test_art_names.test | 55 + .../index/art/storage/test_art_readonly.test | 21 + .../index/art/storage/test_art_storage.test | 78 ++ .../test_art_storage_long_prefixes.test | 25 + .../test_art_storage_multi_checkpoint.test | 21 + .../test_art_wal_checkpoint_minimal.test | 29 + .../test_art_wal_replay_drop_table.test | 41 + .../storage/test_art_wal_replay_in_tx.test | 49 + .../test_art_wal_replay_with_buffer.test | 25 + ...art_wal_replay_with_buffer_concurrent.test | 29 + .../index/art/test_art_empty_close_range.test | 13 + .../sql/index/art/test_art_tx_update_key.test | 25 + .../sql/index/art/test_index_key_rebind.test | 33 + .../sql/index/art/types/test_art_boolean.test | 17 + .../art/types/test_art_coverage_types.test | 109 ++ .../sql/index/art/types/test_art_double.test | 29 + .../art/types/test_art_expression_key.test | 45 + .../art/types/test_art_integer_types.test | 89 ++ .../sql/index/art/types/test_art_real.test | 25 + .../sql/index/art/types/test_art_real_pk.test | 25 + .../sql/index/art/types/test_art_union.test | 117 ++ .../sql/index/art/types/test_art_varchar.test | 44 + .../art/vacuum/test_art_vacuum_rollback.test | 29 + .../sql/index/create_index_options.test | 17 + .../corpus/sql/insert/insert_by_name.test | 158 +++ .../insert_from_many_grouping_sets.test | 37 + .../corpus/sql/insert/insert_query_node.test | 106 ++ .../corpus/sql/insert/insert_rollback.test | 9 + .../corpus/sql/insert/null_values.test | 21 + .../corpus/sql/insert/test_big_insert.test | 29 + .../corpus/sql/insert/test_insert.test | 25 + .../sql/insert/test_insert_invalid.test | 45 + .../test_insert_invalid.test.metadata.json | 6 + .../corpus/sql/insert/test_insert_query.test | 13 + .../corpus/sql/insert/test_insert_type.test | 29 + .../insert/unaligned_interleaved_appends.test | 25 + .../sql/join/asof/test_asof_empty_right.test | 26 + .../corpus/sql/join/asof/test_asof_join.test | 97 ++ .../sql/join/asof/test_asof_join_doubles.test | 213 ++++ .../asof/test_asof_join_filter_pushdown.test | 75 ++ .../asof/test_asof_join_inequalities.test | 100 ++ .../join/asof/test_asof_join_integers.test | 69 ++ .../sql/join/asof/test_asof_join_nulls.test | 69 ++ .../join/asof/test_asof_join_predicates.test | 114 ++ .../sql/join/asof/test_asof_join_prefix.test | 200 ++++ .../join/asof/test_asof_join_pushdown.test | 174 +++ .../sql/join/asof/test_asof_join_setops.test | 69 ++ .../join/asof/test_asof_join_subquery.test | 33 + .../join/asof/test_asof_join_timestamps.test | 61 + .../sql/join/asof/test_asof_join_types.test | 56 + .../sql/join/asof/test_asof_join_varchar.test | 27 + .../corpus/sql/join/asof/test_asof_limit.test | 34 + .../join/asof/test_asof_semi_anti_mark.test | 39 + .../cross_product/test_cross_product.test | 21 + .../testdata/corpus/sql/join/empty_joins.test | 105 ++ .../full_outer/full_outer_join_cache.test | 21 + .../full_outer/full_outer_join_union.test | 63 + .../join/full_outer/test_full_outer_join.test | 33 + .../test_full_outer_join_complex.test | 21 + .../test_full_outer_join_inequality.test | 13 + .../test_full_outer_join_issue_4252.test | 173 +++ .../test_full_outer_join_range.test | 13 + .../hash_join/hash_join_constant_probe.test | 133 +++ .../hash_join/hash_join_dict_surviving.test | 329 ++++++ .../hash_join/hash_join_dictionary_probe.test | 204 ++++ .../hash_join_residual_predicates.test | 311 +++++ .../sql/join/iejoin/iejoin_issue_6861.test | 74 ++ .../sql/join/iejoin/iejoin_issue_7278.test | 98 ++ .../sql/join/iejoin/merge_join_switch.test | 42 + .../join/iejoin/predicate_expressions.test | 99 ++ .../sql/join/iejoin/test_countzeros.test | 49 + .../sql/join/iejoin/test_ieantijoin.test | 239 ++++ .../corpus/sql/join/iejoin/test_iejoin.test | 118 ++ .../join/iejoin/test_iejoin_east_west.test | 89 ++ .../sql/join/iejoin/test_iejoin_events.test | 43 + .../join/iejoin/test_iejoin_null_keys.test | 65 + .../sql/join/iejoin/test_iejoin_overlaps.test | 31 + .../join/iejoin/test_iejoin_predicate.test | 97 ++ .../sql/join/iejoin/test_iesemijoin.test | 186 +++ .../sql/join/inner/empty_tinyint_column.test | 25 + .../sql/join/inner/equality_join_limits.test | 85 ++ .../corpus/sql/join/inner/join_cache.test | 25 + .../sql/join/inner/join_cross_product.test | 49 + .../corpus/sql/join/inner/list_join.test | 17 + .../sql/join/inner/not_between_is_null.test | 22 + .../right_semi_dict_emission_dead_end.test | 49 + .../sql/join/inner/test_eq_ineq_join.test | 85 ++ .../test_inner_join_filter_pushdown.test | 81 ++ .../corpus/sql/join/inner/test_join.test | 61 + .../sql/join/inner/test_join_duplicates.test | 17 + .../inner/test_join_filter_precedence.test | 172 +++ .../sql/join/inner/test_join_is_distinct.test | 219 ++++ .../join/inner/test_join_is_not_distinct.test | 91 ++ .../corpus/sql/join/inner/test_lt_join.test | 25 + .../test_prefix_range_filter_non_utf8.test | 33 + .../test_prefix_range_filter_pushdown.test | 375 ++++++ ...refix_range_filter_pushdown_strinline.test | 213 ++++ .../sql/join/inner/test_range_join.test | 49 + .../sql/join/inner/test_unequal_join.test | 41 + .../inner/test_unequal_join_duplicates.test | 17 + .../sql/join/inner/test_using_chain.test | 73 ++ .../sql/join/inner/test_using_join.test | 77 ++ .../sql/join/inner/test_varchar_join.test | 25 + .../join/left_outer/left_join_issue_1172.test | 62 + .../left_outer/left_join_issue_15316.test | 49 + .../left_outer/left_join_issue_23805.test | 33 + .../join/left_outer/left_join_issue_6341.test | 33 + .../join/left_outer/left_join_issue_7905.test | 54 + .../left_outer/non_foldable_left_join.test | 9 + .../test_left_join_filter_pushdown.test | 39 + .../left_outer/test_left_join_on_true.test | 78 ++ .../sql/join/left_outer/test_left_outer.test | 89 ++ .../sql/join/left_outer/unique_left_join.test | 142 +++ .../corpus/sql/join/natural/natural_join.test | 206 ++++ .../sql/join/nearest/nearest_basic.test | 174 +++ .../sql/join/nearest/nearest_errors.test | 49 + .../nearest/nearest_errors.test.metadata.json | 10 + .../sql/join/nearest/nearest_parser.test | 70 ++ .../sql/join/nearest/nearest_storage.test | 82 ++ .../non_inner_decorrelation_regressions.test | 337 ++++++ .../sql/join/non_inner_join_subquery.test | 112 ++ .../join/non_inner_join_subquery_binding.test | 232 ++++ ...ir_dependent_full_outer_join_subquery.test | 751 ++++++++++++ ...ent_full_outer_join_subquery_bindings.test | 721 +++++++++++ ...ependent_full_outer_join_subquery_cte.test | 146 +++ .../join/pair_dependent_join_subquery.test | 736 ++++++++++++ ...ir_dependent_outer_reference_subquery.test | 363 ++++++ .../pair_dependent_volatile_subquery.test | 35 + .../sql/join/positional/issue20086.test | 21 + .../join/positional/test_positional_join.test | 107 ++ .../pushdown/pushdown_generated_columns.test | 17 + .../join/pushdown/pushdown_join_types.test | 46 + .../join/pushdown/pushdown_many_joins.test | 37 + .../right_outer/right_join_complex_null.test | 37 + .../test_right_join_filter_pushdown.test | 51 + .../join/right_outer/test_right_outer.test | 73 ++ .../semianti/10406-anti-on-ints-strings.test | 49 + .../corpus/sql/join/semianti/antijoin.test | 120 ++ .../semianti/mix_equality_inequality.test | 49 + ...wise_NL_join_with_mutliple_conditions.test | 63 + .../corpus/sql/join/semianti/right_anti.test | 80 ++ .../corpus/sql/join/semianti/right_semi.test | 72 ++ .../corpus/sql/join/semianti/semijoin.test | 76 ++ .../test_semianti_join_filter_pushdown.test | 59 + .../join/semianti/test_simple_anti_join.test | 46 + ..._operator_reordering_with_delim_joins.test | 24 + .../sql/join/test_complex_join_expr.test | 29 + .../sql/join/test_complex_range_join.test | 188 +++ .../test_join_always_true_conditions.test | 76 ++ .../corpus/sql/join/test_join_by.test | 85 ++ .../sql/join/test_join_by.test.metadata.json | 5 + .../sql/join/test_join_on_aggregates.test | 21 + .../sql/join/test_merge_join_predicate.test | 71 ++ .../sql/join/test_nested_inequality.test | 93 ++ .../sql/join/test_predicate_binding.test | 49 + .../corpus/sql/join/test_string_payload.test | 25 + .../corpus/sql/json/copy_geojson.test | 249 ++++ .../sql/json/copy_json_null_options.test | 73 ++ .../sql/json/copy_json_partition_by.test | 80 ++ .../sql/json/issues/internal_issue2732.test | 9 + .../sql/json/issues/internal_issue3146.test | 17 + .../sql/json/issues/internal_issue3197.test | 9 + .../sql/json/issues/internal_issue391.test | 17 + .../sql/json/issues/internal_issue4014.test | 9 + .../sql/json/issues/internal_issue4389.test | 21 + .../sql/json/issues/internal_issue4403.test | 9 + .../sql/json/issues/internal_issue4794.test | 9 + .../sql/json/issues/internal_issue5288.test | 9 + .../sql/json/issues/issue10751and11152.test | 25 + .../corpus/sql/json/issues/issue10784.test | 17 + .../corpus/sql/json/issues/issue10866.test | 13 + .../corpus/sql/json/issues/issue11804.test | 28 + .../corpus/sql/json/issues/issue12188.test | 17 + .../corpus/sql/json/issues/issue12861.test | 33 + .../corpus/sql/json/issues/issue13212.test | 21 + .../corpus/sql/json/issues/issue13725.test | 29 + .../corpus/sql/json/issues/issue13948.test | 65 + .../corpus/sql/json/issues/issue14167.test | 9 + .../corpus/sql/json/issues/issue14245.test | 9 + .../corpus/sql/json/issues/issue14259.test | 9 + .../corpus/sql/json/issues/issue15038.test | 57 + .../corpus/sql/json/issues/issue15601.test | 13 + .../corpus/sql/json/issues/issue16568.test | 9 + .../corpus/sql/json/issues/issue16570.test | 13 + .../corpus/sql/json/issues/issue16684.test | 21 + .../corpus/sql/json/issues/issue16968.test | 21 + .../corpus/sql/json/issues/issue17135.test | 45 + .../corpus/sql/json/issues/issue18301.test | 33 + .../corpus/sql/json/issues/issue19357.test | 17 + .../corpus/sql/json/issues/issue19366.test | 17 + .../corpus/sql/json/issues/issue22764.test | 11 + .../json/issues/issue22764.test.metadata.json | 5 + .../corpus/sql/json/issues/issue23114.test | 21 + .../corpus/sql/json/issues/issue6722.test | 13 + .../corpus/sql/json/issues/issue8695.test | 29 + .../issues/large_quoted_string_constant.test | 87 ++ ...nference_threshold_internal_exception.test | 13 + .../json/issues/read_json_memory_usage.test | 17 + .../sql/json/issues/test_json_temp_8062.test | 17 + .../sql/json/scalar/json_nested_casts.test | 374 ++++++ .../sql/json/scalar/test_geojson_cast.test | 61 + .../json/scalar/test_json_array_length.test | 45 + .../sql/json/scalar/test_json_arrow_expr.test | 19 + .../sql/json/scalar/test_json_contains.test | 65 + .../sql/json/scalar/test_json_create.test | 287 +++++ .../sql/json/scalar/test_json_deep_merge.test | 223 ++++ .../sql/json/scalar/test_json_dot_syntax.test | 161 +++ .../sql/json/scalar/test_json_exists.test | 31 + .../sql/json/scalar/test_json_extract.test | 272 +++++ .../scalar/test_json_extract_input_types.test | 66 ++ .../corpus/sql/json/scalar/test_json_icu.test | 17 + .../sql/json/scalar/test_json_insert.test | 160 +++ .../sql/json/scalar/test_json_keys.test | 54 + .../json/scalar/test_json_merge_patch.test | 81 ++ .../scalar/test_json_merge_patch_diff.test | 213 ++++ .../sql/json/scalar/test_json_normalize.test | 177 +++ .../sql/json/scalar/test_json_path.test | 223 ++++ .../json/scalar/test_json_path_prepared.test | 53 + .../sql/json/scalar/test_json_pretty.test | 39 + .../sql/json/scalar/test_json_remove.test | 188 +++ .../sql/json/scalar/test_json_replace.test | 152 +++ .../corpus/sql/json/scalar/test_json_set.test | 308 +++++ .../json/scalar/test_json_strip_nulls.test | 104 ++ .../sql/json/scalar/test_json_structure.test | 142 +++ .../sql/json/scalar/test_json_transform.test | 417 +++++++ .../sql/json/scalar/test_json_type.test | 168 +++ .../sql/json/scalar/test_json_valid.test | 497 ++++++++ .../sql/json/scalar/test_json_value.test | 124 ++ .../sql/json/scalar/test_st_asgeojson.test | 79 ++ .../json/scalar/test_st_geomfromgeojson.test | 101 ++ .../sql/json/table/auto_glob_directory.test | 13 + .../sql/json/table/json_empty_array.test | 37 + .../json/table/json_multi_file_reader.test | 85 ++ .../json_table_in_out_fullkey_quoting.test | 66 ++ .../sql/json/table/multi_file_hang.test | 17 + .../sql/json/table/read_geojson_errors.test | 37 + .../table/read_geojson_featurecollection.test | 97 ++ .../sql/json/table/read_geojson_ndjson.test | 44 + .../sql/json/table/read_geojson_nested.test | 77 ++ .../table/read_geojson_pseudo_columns.test | 94 ++ .../corpus/sql/json/table/read_json.test | 199 ++++ .../sql/json/table/read_json_dates.test | 365 ++++++ .../sql/json/table/read_json_objects.test | 129 ++ .../sql/json/table/read_json_union.test | 25 + ...read_json_unnest_heterogeneous_struct.test | 64 + .../sql/json/table/test_json_copy_zstd.test | 17 + ...son_nested_struct_projection_pushdown.test | 41 + .../corpus/sql/json/test_json_bool.test | 13 + .../corpus/sql/json/test_json_cast.test | 161 +++ .../json/test_json_copy_serialize_plan.test | 31 + .../sql/json/test_json_empty_object.test | 45 + .../corpus/sql/json/test_json_export.test | 37 + .../sql/json/test_json_geometry_format.test | 61 + .../json/test_json_group_window_macro.test | 21 + .../corpus/sql/json/test_json_macros.test | 41 + .../sql/json/test_json_persistence.test | 17 + .../sql/json/test_json_serialize_plan.test | 65 + .../sql/json/test_json_serialize_sql.test | 140 +++ ...test_json_serialize_sql.test.metadata.json | 10 + .../corpus/sql/json/test_json_sqlite.test | 93 ++ .../keywords/escaped_quotes_expressions.test | 65 + .../sql/keywords/keywords_in_expressions.test | 69 ++ .../limit/streaming_limit_pipeline_flush.test | 18 + .../sql/limit/test_batch_limit_filters.test | 17 + .../corpus/sql/limit/test_limit0.test | 21 + .../limit/test_preserve_insertion_order.test | 37 + .../logging/enable_logging_file_no_path.test | 45 + .../logging/file_system_logging_attach.test | 28 + .../file_system_logging_attach_deadlock.test | 13 + .../corpus/sql/logging/http_log_timing.test | 39 + .../testdata/corpus/sql/logging/logging.test | 53 + .../sql/logging/logging_buffer_size.test | 69 ++ .../sql/logging/logging_call_functions.test | 77 ++ .../sql/logging/logging_context_ids.test | 53 + .../corpus/sql/logging/logging_csv.test | 100 ++ .../logging/logging_file_bind_replace.test | 53 + .../sql/logging/logging_file_persistence.test | 13 + .../logging_file_truncate_rewrite.test | 17 + .../logging_memory_after_truncate.test | 25 + .../corpus/sql/logging/logging_types.test | 33 + .../sql/logging/test_logging_function.test | 46 + .../testdata/corpus/sql/merge/merge_into.test | 116 ++ .../sql/merge/merge_into.test.metadata.json | 5 + .../merge_into_bind_matching_columns.test | 65 + .../sql/merge/merge_into_by_source.test | 25 + .../sql/merge/merge_into_constraint.test | 46 + .../corpus/sql/merge/merge_into_default.test | 38 + .../corpus/sql/merge/merge_into_error.test | 28 + .../corpus/sql/merge/merge_into_index.test | 25 + .../sql/merge/merge_into_insert_star.test | 30 + .../sql/merge/merge_into_invalid_action.test | 23 + .../sql/merge/merge_into_invalid_column.test | 13 + .../merge_into_invalid_column_reference.test | 121 ++ .../sql/merge/merge_into_join_as_filter.test | 37 + .../merge/merge_into_multiple_updates.test | 42 + .../sql/merge/merge_into_parenthesis_bug.test | 42 + .../sql/merge/merge_into_returning.test | 44 + .../corpus/sql/merge/merge_into_subquery.test | 33 + .../sql/merge/merge_into_subquery_action.test | 42 + .../merge/merge_into_subquery_condition.test | 20 + .../sql/merge/merge_into_too_few_columns.test | 24 + .../sql/merge/merge_into_update_star.test | 34 + .../sql/merge/merge_multi_match_error.test | 139 +++ .../corpus/sql/merge/trigger_merge_into.test | 223 ++++ .../sql/optimizer/any_extremum_rewrite.test | 93 ++ .../array_extract_row_group_pruning.test | 59 + .../optimizer/boolean_row_group_pruning.test | 25 + .../optimizer/boolean_wrapper_pushdown.test | 53 + .../empty_string_concat_pruning.test | 47 + .../list_comprehension_rewrite.test | 95 ++ .../test_casting_negative_integer_to_bit.test | 25 + .../expression/test_common_aggregate.test | 55 + .../test_comparison_simplification.test | 35 + .../test_conjunction_optimization.test | 65 + .../sql/optimizer/expression/test_cse.test | 57 + .../expression/test_date_subtract_filter.test | 20 + .../test_enum_in_simplification.test | 218 ++++ .../test_equal_or_null_optimization.test | 108 ++ .../test_in_clause_simplification.test | 25 + .../test_indistinct_aggregates.test | 13 + .../expression/test_move_constants.test | 129 ++ .../expression/test_negation_limits.test | 57 + .../expression/test_nop_arithmetic.test | 69 ++ .../test_row_comparison_simplification.test | 53 + .../expression/test_timestamp_offset.test | 43 + .../optimizer/in_list_row_group_pruning.test | 39 + .../sql/optimizer/instr_zonemap_pruning.test | 46 + .../optimizer/interval_row_group_pruning.test | 57 + ...late_materialization_pushdown_extract.test | 64 + .../late_materialization_table_filters.test | 122 ++ .../monotone_function_zonemap_pruning.test | 100 ++ .../sql/optimizer/monotone_preimage.test | 121 ++ .../nested_null_segment_pruning.test | 44 + ...ed_null_segment_pruning.test.metadata.json | 5 + .../not_conjunction_simplification.test | 79 ++ .../optimizer/nullable_row_group_pruning.test | 93 ++ .../plan/plan_struct_projection_pushdown.test | 85 ++ .../plan/test_anti_join_empty_child.test | 17 + .../test_disable_build_side_probe_side.test | 9 + .../test_equivalent_filter_mirroring.test | 51 + .../optimizer/plan/test_except_empty_rhs.test | 21 + .../optimizer/plan/test_filter_pushdown.test | 162 +++ .../plan/test_filter_pushdown_duplicate.test | 13 + .../plan/test_filter_pushdown_large.test | 113 ++ ...test_filter_pushdown_materialized_cte.test | 31 + .../test_recursive_build_side_probe_side.test | 16 + .../plan/test_recursive_join_order_guard.test | 38 + .../plan/test_table_filter_pushdown.test | 29 + .../plan/test_unused_column_after_join.test | 29 + .../sql/optimizer/power_zonemap_pruning.test | 77 ++ .../sql/optimizer/predicate_factoring.test | 85 ++ .../sql/optimizer/rewrite_nan_null.test | 91 ++ .../rewrite_nan_null.test.metadata.json | 5 + .../sql/optimizer/sign_row_group_pruning.test | 23 + .../optimizer/string_row_group_pruning.test | 95 ++ .../sql/optimizer/string_stats_merge.test | 213 ++++ .../sql/optimizer/struct_segment_pruning.test | 50 + .../struct_segment_pruning.test.metadata.json | 5 + .../optimizer/substring_zonemap_pruning.test | 226 ++++ .../corpus/sql/optimizer/table_filters.test | 514 ++++++++ .../sql/optimizer/temporal_cast_dst.test | 43 + .../sql/optimizer/temporal_cast_zonemap.test | 129 ++ ...test_common_subplan_cte_binding_order.test | 75 ++ .../test_common_subplan_projection_maps.test | 198 ++++ .../test_common_subplan_table_filters.test | 49 + .../test_duplicate_groups_optimizer.test | 84 ++ .../sql/optimizer/test_fd_derived_groups.test | 94 ++ .../test_glob_row_group_pruning.test | 43 + .../sql/optimizer/test_in_rewrite_rule.test | 29 + .../test_negated_filter_cardinality.test | 41 + .../test_no_pushdown_cast_into_cte.test | 87 ++ .../test_not_comparison_simplification.test | 49 + .../optimizer/test_rollup_column_pruning.test | 67 ++ .../sql/optimizer/test_rowid_pruning.test | 73 ++ .../sql/optimizer/test_rowid_pushdown.test | 45 + .../test_rowid_pushdown_deletes.test | 21 + .../optimizer/test_rowid_pushdown_plan.test | 25 + .../sql/optimizer/test_window_self_join.test | 273 +++++ .../tests_no_pushdown_under_samples.test | 22 + ...ndow_elimination_late_materialization.test | 93 ++ .../topn_window_set_elimination.test | 56 + .../window_self_join_optimizer_csv.test | 21 + .../sql/order/hugeint_order_by_extremes.test | 21 + .../corpus/sql/order/issue_11936.test | 17 + .../sql/order/limit_full_outer_join.test | 13 + .../corpus/sql/order/limit_parameter.test | 49 + .../corpus/sql/order/limit_percent_view.test | 25 + .../corpus/sql/order/limit_union.test | 13 + .../corpus/sql/order/negative_offset.test | 29 + .../corpus/sql/order/order_by_all.test | 25 + .../sql/order/order_by_internal_5293.test | 27 + .../corpus/sql/order/order_overflow.test | 9 + .../testdata/corpus/sql/order/test_limit.test | 157 +++ .../corpus/sql/order/test_limit_cte.test | 13 + .../sql/order/test_limit_parameter.test | 105 ++ .../corpus/sql/order/test_limit_percent.test | 149 +++ .../corpus/sql/order/test_nulls_first.test | 73 ++ .../order/test_nulls_first.test.metadata.json | 5 + .../corpus/sql/order/test_order_by.test | 105 ++ .../sql/order/test_order_by_exceptions.test | 41 + .../test_order_by_non_ordinal_literal.test | 69 ++ .../corpus/sql/order/test_order_large.test | 13 + .../corpus/sql/order/test_order_pragma.test | 33 + .../sql/order/test_order_range_mapping.test | 41 + .../corpus/sql/order/test_order_unnest.test | 43 + .../corpus/sql/order/top_n_issue_21623.test | 72 ++ .../corpus/sql/order/top_n_nulls.test | 23 + .../sql/ordinality/ordinality_constant.test | 89 ++ .../sql/ordinality/ordinality_inout.test | 65 + .../corpus/sql/overflow/bigint_overflow.test | 109 ++ .../sql/overflow/double_float_overflow.test | 33 + .../sql/overflow/expression_tree_depth.test | 17 + .../expression_tree_depth.test.metadata.json | 5 + .../corpus/sql/overflow/integer_overflow.test | 201 ++++ .../corpus/sql/overflow/table_overflow.test | 149 +++ .../sql/overflow/test_numeric_overflow.test | 65 + .../corpus/sql/overflow/test_overflow.test | 73 ++ .../parallelism/async_task_schedule_pool.test | 29 + .../interquery/concurrent_appends.test | 13 + .../concurrent_checkpoint_insert.test | 21 + .../concurrent_force_checkpoint.test | 33 + ...oncurrent_index_scans_while_appending.test | 9 + .../concurrent_reads_while_altering.test | 13 + .../concurrent_reads_while_renaming.test | 13 + ...ncurrent_set_async_threads_read_ahead.test | 25 + ...depth_first_evaluation_union_and_join.test | 41 + .../intraquery/error_in_pipeline.test | 21 + .../intraquery/parallel_sample.test | 13 + .../test_parallel_nested_aggregates.test | 45 + .../test_persistent_parallelism.test | 17 + .../intraquery/test_simple_parallelism.test | 21 + .../intraquery/test_verify_parallelism.test | 17 + .../corpus/sql/parser/columns_aliases.test | 77 ++ .../corpus/sql/parser/columns_issue9867.test | 28 + .../corpus/sql/parser/digit_separators.test | 229 ++++ .../parser/division_operator_precedence.test | 29 + .../dollar_quotes_internal_issue2224.test | 57 + .../sql/parser/empty_quoted_identifier.test | 17 + .../sql/parser/expression_depth_limit.test | 17 + .../parser/external_resource_roundtrip.test | 73 ++ .../corpus/sql/parser/fetch_first.test | 37 + .../corpus/sql/parser/from_first.test | 37 + .../corpus/sql/parser/function_chaining.test | 73 ++ .../corpus/sql/parser/hex_string_literal.test | 21 + .../corpus/sql/parser/indirection.test | 29 + .../parser/invalid_utf8_parser_location.test | 15 + .../corpus/sql/parser/invisible_spaces.test | 42 + .../corpus/sql/parser/join_alias.test | 31 + .../corpus/sql/parser/position_prepare.test | 13 + .../corpus/sql/parser/star_expression.test | 53 + .../parser/statement_tostring_roundtrip.test | 346 ++++++ .../corpus/sql/parser/switch_case.test | 85 ++ .../corpus/sql/parser/table_at_clause.test | 37 + .../corpus/sql/parser/test_columns.test | 77 ++ .../corpus/sql/parser/test_columns_lists.test | 97 ++ .../corpus/sql/parser/test_columns_order.test | 41 + .../sql/parser/test_columns_prepared.test | 37 + .../sql/parser/test_columns_unpacked.test | 218 ++++ .../corpus/sql/parser/test_columns_where.test | 37 + .../corpus/sql/parser/test_long_error.test | 13 + .../sql/parser/test_operator_precedence.test | 57 + .../sql/parser/test_value_functions.test | 49 + .../corpus/sql/parser/trailing_commas.test | 67 ++ .../sql/parser/unreserved_keyword_casing.test | 13 + .../corpus/sql/parser/values_list_error.test | 13 + .../values_list_error.test.metadata.json | 6 + .../parser/values_list_without_brackets.test | 13 + .../corpus/sql/peg_parser/binary_type.test | 17 + .../sql/peg_parser/enable_peg_parser.test | 13 + .../corpus/sql/peg_parser/escape_string.test | 73 ++ .../escape_string.test.metadata.json | 7 + .../sql/peg_parser/expression_statement.test | 49 + .../sql/peg_parser/fuzzer/diverge_0000.test | 9 + .../sql/peg_parser/fuzzer/diverge_0002.test | 9 + .../sql/peg_parser/fuzzer/diverge_0004.test | 9 + .../sql/peg_parser/fuzzer/diverge_0007.test | 13 + .../sql/peg_parser/fuzzer/diverge_0009.test | 9 + .../sql/peg_parser/fuzzer/diverge_0014.test | 13 + .../sql/peg_parser/fuzzer/diverge_0020.test | 9 + .../fuzzer/diverge_0020.test.metadata.json | 5 + .../sql/peg_parser/fuzzer/diverge_0039.test | 17 + .../sql/peg_parser/fuzzer/diverge_0060.test | 13 + .../sql/peg_parser/fuzzer/fuzzer_4434.test | 14 + .../fuzzer/fuzzer_4434.test.metadata.json | 6 + .../sql/peg_parser/fuzzer/internal_0001.test | 9 + .../fuzzer/internal_0001.test.metadata.json | 5 + .../sql/peg_parser/fuzzer/internal_0206.test | 9 + .../sql/peg_parser/fuzzer/internal_0208.test | 9 + .../sql/peg_parser/fuzzer/internal_0227.test | 25 + .../fuzzer/internal_0227.test.metadata.json | 6 + .../corpus/sql/peg_parser/identifier.test | 57 + .../corpus/sql/peg_parser/parser/alter.test | 9 + .../sql/peg_parser/parser/analyze_vacuum.test | 25 + .../sql/peg_parser/parser/array_subquery.test | 29 + .../peg_parser/parser/attach_or_replace.test | 9 + .../corpus/sql/peg_parser/parser/collate.test | 9 + .../sql/peg_parser/parser/colon_alias.test | 21 + .../sql/peg_parser/parser/comments.test | 26 + .../peg_parser/parser/copy_expression.test | 37 + .../sql/peg_parser/parser/create_macro.test | 17 + .../sql/peg_parser/parser/create_table.test | 33 + .../sql/peg_parser/parser/create_type.test | 9 + .../peg_parser/parser/custom_operator.test | 21 + .../sql/peg_parser/parser/delete_from.test | 9 + .../sql/peg_parser/parser/dollar_quoted.test | 37 + .../peg_parser/parser/dotted_functions.test | 21 + .../sql/peg_parser/parser/empty_map.test | 9 + .../sql/peg_parser/parser/ignore_nulls.test | 9 + .../corpus/sql/peg_parser/parser/index.test | 25 + .../corpus/sql/peg_parser/parser/insert.test | 17 + .../peg_parser/parser/insert_statement.test | 9 + .../peg_parser/parser/invisible_space.test | 9 + .../peg_parser/parser/lambda_functions.test | 41 + .../sql/peg_parser/parser/list_slices.test | 13 + .../sql/peg_parser/parser/load_extension.test | 25 + .../corpus/sql/peg_parser/parser/map.test | 33 + .../sql/peg_parser/parser/merge_into.test | 29 + .../peg_parser/parser/named_parameters.test | 29 + .../sql/peg_parser/parser/nested_join.test | 21 + .../sql/peg_parser/parser/on_conflict.test | 9 + .../peg_parser/parser/pivot_statement.test | 9 + .../sql/peg_parser/parser/position.test | 21 + .../sql/peg_parser/parser/recursive.test | 29 + .../corpus/sql/peg_parser/parser/sample.test | 29 + .../parser/scientific_notation.test | 17 + .../sql/peg_parser/parser/select_star.test | 21 + .../sql/peg_parser/parser/show_table.test | 9 + .../peg_parser/parser/struct_identifier.test | 41 + .../support_optional_not_null_constraint.test | 9 + .../sql/peg_parser/parser/support_try.test | 9 + .../parser/support_unreserved_keywords.test | 229 ++++ .../corpus/sql/peg_parser/parser/type.test | 65 + .../peg_parser/parser/update_statement.test | 21 + .../sql/peg_parser/parser/use_statement.test | 13 + .../peg_parser/parser/window_function.test | 25 + .../peg_parser/parser/with_ordinality.test | 13 + .../sql/peg_parser/peg_syntax_error.test | 133 +++ .../peg_syntax_error.test.metadata.json | 7 + .../sql/peg_parser/qualified_operator.test | 13 + .../qualified_operator.test.metadata.json | 5 + .../transformer/alter_statement.test | 82 ++ .../transformer/attach_statement.test | 25 + .../transformer/call_statement.test | 21 + .../transformer/delete_statement.test | 79 ++ .../transformer/drop_statement.test | 41 + .../transformer/load_statement.test | 13 + .../transformer/peg_transformer.test | 9 + .../peg_parser/transformer/set_statement.test | 45 + .../set_statement.test.metadata.json | 5 + .../transformer/special_string.test | 13 + .../transformer/statement_length.test | 21 + .../transformer/transaction_statement.test | 9 + .../sql/peg_parser/transformer/trim.test | 9 + .../transformer/unary_expression.test | 29 + .../transformer/update_extensions.test | 21 + .../transformer/use_statement_trampoline.test | 49 + ...se_statement_trampoline.test.metadata.json | 5 + .../sql/peg_parser/unterminated_literals.test | 21 + .../corpus/sql/pg_catalog/pg_attribute.test | 17 + .../corpus/sql/pg_catalog/pg_constraint.test | 29 + .../corpus/sql/pg_catalog/pg_database.test | 13 + .../corpus/sql/pg_catalog/pg_depend.test | 13 + .../corpus/sql/pg_catalog/pg_enum.test | 13 + .../corpus/sql/pg_catalog/pg_index.test | 29 + .../corpus/sql/pg_catalog/pg_namespace.test | 37 + .../pg_catalog/pg_prepared_statements.test | 25 + .../corpus/sql/pg_catalog/pg_privilege.test | 17 + .../corpus/sql/pg_catalog/pg_sequence.test | 17 + .../corpus/sql/pg_catalog/pg_sequences.test | 17 + .../corpus/sql/pg_catalog/pg_settings.test | 17 + .../corpus/sql/pg_catalog/pg_tablespace.test | 13 + .../corpus/sql/pg_catalog/pg_type.test | 101 ++ .../corpus/sql/pg_catalog/pg_views.test | 17 + .../corpus/sql/pg_catalog/sqlalchemy.test | 334 ++++++ .../sql/pg_catalog/system_functions.test | 69 ++ .../corpus/sql/pivot/optional_pivots.test | 61 + .../corpus/sql/pivot/pivot_15141.test | 25 + .../testdata/corpus/sql/pivot/pivot_6390.test | 204 ++++ .../corpus/sql/pivot/pivot_bigquery.test | 72 ++ .../sql/pivot/pivot_case_insensitive.test | 33 + .../corpus/sql/pivot/pivot_databricks.test | 124 ++ .../corpus/sql/pivot/pivot_empty.test | 25 + .../testdata/corpus/sql/pivot/pivot_enum.test | 62 + .../corpus/sql/pivot/pivot_errors.test | 33 + .../corpus/sql/pivot/pivot_expressions.test | 53 + .../pivot_expressions.test.metadata.json | 7 + .../corpus/sql/pivot/pivot_generated.test | 28 + .../corpus/sql/pivot/pivot_in_boolean.test | 13 + .../corpus/sql/pivot/pivot_in_subquery.test | 21 + .../sql/pivot/pivot_operator_expression.test | 31 + .../corpus/sql/pivot/pivot_prepare.test | 43 + .../pivot/pivot_prepare.test.metadata.json | 5 + .../corpus/sql/pivot/pivot_query_text.test | 25 + .../testdata/corpus/sql/pivot/pivot_star.test | 21 + .../corpus/sql/pivot/pivot_storage.test | 30 + .../sql/pivot/pivot_struct_aggregate.test | 13 + .../corpus/sql/pivot/pivot_subquery.test | 46 + .../pivot/pivot_subquery.test.metadata.json | 7 + .../corpus/sql/pivot/test_multi_pivot.test | 92 ++ .../testdata/corpus/sql/pivot/test_pivot.test | 183 +++ .../test_pivot_duplicate_aggregates.test | 84 ++ .../corpus/sql/pivot/test_unpivot.test | 100 ++ .../sql/pivot/test_unpivot.test.metadata.json | 5 + .../corpus/sql/pivot/test_unpivot_stmt.test | 58 + .../sql/pivot/top_level_pivot_syntax.test | 71 ++ .../top_level_pivot_syntax.test.metadata.json | 5 + .../corpus/sql/pivot/unpivot_expression.test | 54 + .../sql/pivot/unpivot_internal_names.test | 17 + .../corpus/sql/pivot/unpivot_no_columns.test | 13 + .../pivot/unpivot_non_aligned_columns.test | 29 + .../corpus/sql/pivot/unpivot_types.test | 27 + .../sql/pivot/unpivot_unnamed_subquery.test | 10 + .../corpus/sql/pivot/unpivot_view.test | 28 + .../pragma/pragma_database_size_readonly.test | 9 + .../call_enable_profiling_function.test | 145 +++ ...able_profiling_function.test.metadata.json | 7 + .../test_all_profiling_settings.test | 25 + .../test_attach_and_checkpoint_latency.test | 69 ++ ..._and_checkpoint_latency.test.metadata.json | 5 + .../test_autocheckpoint_latency.test | 63 + ..._autocheckpoint_latency.test.metadata.json | 6 + .../profiling/test_checkpoint_profiling.test | 93 ++ ...st_checkpoint_profiling.test.metadata.json | 8 + ...st_commit_write_wal_latency_and_count.test | 61 + ...e_wal_latency_and_count.test.metadata.json | 6 + ..._custom_profiling_blocked_thread_time.test | 29 + ...test_custom_profiling_disable_metrics.test | 71 ++ ...ofiling_disable_metrics.test.metadata.json | 5 + .../test_custom_profiling_errors.test | 29 + ...t_custom_profiling_optimizer_settings.test | 39 + ...test_custom_profiling_result_set_size.test | 18 + ...iling_row_group_metrics_local_storage.test | 67 ++ .../test_custom_profiling_rows_scanned.test | 32 + ...custom_profiling_rows_scanned_parquet.test | 24 + ...stom_profiling_total_memory_allocated.test | 56 + .../test_custom_profiling_using_groups.test | 141 +++ ...st_duckdb_profiling_settings_function.test | 33 + ...iling_settings_function.test.metadata.json | 5 + .../test_empty_profiling_settings.test | 25 + .../profiling/test_legacy_metrics_format.test | 49 + .../profiling/test_logging_interaction.test | 37 + ...est_logging_interaction.test.metadata.json | 5 + .../profiling/test_no_reset_setting.test | 13 + .../test_no_reset_setting.test.metadata.json | 5 + .../test_operator_info_suppression.test | 9 + .../pragma/profiling/test_profiling_all.test | 53 + .../pragma/profiling/test_profiling_fs.test | 35 + .../test_profiling_output_file_overwrite.test | 45 + ...g_output_file_overwrite.test.metadata.json | 6 + .../test_db_invalidation_after_load.test | 13 + .../sql/pragma/test_disabled_compression.test | 21 + .../sql/pragma/test_enable_profile.test | 25 + .../test_enable_profile.test.metadata.json | 5 + .../sql/pragma/test_force_compression.test | 13 + .../corpus/sql/pragma/test_memory_limit.test | 153 +++ .../test_memory_limit.test.metadata.json | 10 + .../corpus/sql/pragma/test_metadata_info.test | 29 + .../sql/pragma/test_pragma_database_list.test | 21 + .../sql/pragma/test_pragma_database_size.test | 33 + .../sql/pragma/test_pragma_functions.test | 9 + .../sql/pragma/test_pragma_parsing.test | 25 + .../pragma/test_pragma_sanitized_inputs.test | 29 + .../sql/pragma/test_pragma_version.test | 53 + .../corpus/sql/pragma/test_query_log.test | 25 + .../corpus/sql/pragma/test_show_tables.test | 85 ++ .../sql/pragma/test_show_tables_from.test | 109 ++ .../pragma/test_show_tables_temp_views.test | 25 + .../corpus/sql/pragma/test_storage_info.test | 44 + .../corpus/sql/pragma/test_table_info.test | 88 ++ .../pragma/test_table_info_quoted_names.test | 57 + ...table_info_quoted_names.test.metadata.json | 9 + .../sql/pragma/test_various_pragmas.test | 49 + .../corpus/sql/prepared/invalid_prepare.test | 37 + .../prepared/parameter_order_subquery.test | 104 ++ .../sql/prepared/parameter_variants.test | 29 + .../corpus/sql/prepared/prepare_copy.test | 39 + .../sql/prepared/prepare_default_varchar.test | 237 ++++ .../sql/prepared/prepare_from_first.test | 17 + .../corpus/sql/prepared/prepare_in.test | 17 + .../corpus/sql/prepared/prepare_lambda.test | 45 + .../sql/prepared/prepare_list_functions.test | 45 + .../sql/prepared/prepare_maintain_types.test | 29 + .../sql/prepared/prepare_mixed_types.test | 77 ++ .../sql/prepared/prepare_offset_first.test | 17 + .../sql/prepared/prepare_summarize.test | 37 + .../prepared/prepare_window_functions.test | 37 + .../sql/prepared/prepared_named_param.test | 33 + .../sql/prepared/prepared_null_binding.test | 21 + .../corpus/sql/prepared/prepared_select.test | 58 + .../prepared/prepared_stale_statistics.test | 165 +++ .../prepared_statistics_optimization.test | 143 +++ .../corpus/sql/prepared/prepared_update.test | 37 + .../sql/prepared/test_basic_prepare.test | 61 + .../corpus/sql/prepared/test_issue_2079.test | 53 + .../corpus/sql/prepared/test_issue_21077.test | 29 + .../corpus/sql/prepared/test_issue_4010.test | 13 + .../corpus/sql/prepared/test_issue_4042.test | 37 + .../corpus/sql/prepared/test_issue_6276.test | 13 + .../prepared/test_prepare_ambiguous_type.test | 257 ++++ .../sql/prepared/test_prepare_delete.test | 29 + .../prepared/test_prepare_delete_update.test | 13 + .../sql/prepared/test_prepare_drop.test | 21 + .../sql/prepared/test_prepare_error.test | 13 + .../sql/prepared/test_prepare_issue_5132.test | 17 + .../sql/prepared/test_prepare_issue_8500.test | 13 + .../sql/prepared/test_prepare_null.test | 33 + .../sql/prepared/test_prepare_select.test | 45 + .../sql/prepared/test_prepare_subquery.test | 25 + .../sql/prepared/test_prepare_types.test | 17 + .../sql/prepared/test_prepare_unused_cte.test | 29 + .../corpus/sql/projection/coalesce_error.test | 27 + .../corpus/sql/projection/coalesce_rowid.test | 17 + .../sql/projection/select_star_exclude.test | 217 ++++ .../select_star_exclude.test.metadata.json | 8 + .../sql/projection/select_star_like.test | 93 ++ .../sql/projection/select_star_rename.test | 65 + .../select_star_rename.test.metadata.json | 6 + .../sql/projection/select_star_replace.test | 57 + .../select_star_replace.test.metadata.json | 6 + .../sql/projection/select_struct_star.test | 41 + .../test_columns_replace_using.test | 69 ++ .../projection/test_complex_expressions.test | 137 +++ .../corpus/sql/projection/test_row_id.test | 49 + .../projection/test_row_id_expression.test | 113 ++ .../projection/test_scalar_projection.test | 41 + .../test_scalar_projection.test.metadata.json | 5 + .../projection/test_simple_projection.test | 33 + .../sql/projection/test_table_star.test | 49 + .../sql/projection/test_value_list.test | 93 ++ .../test_value_list.test.metadata.json | 7 + .../no_crash_when_no_returning_columns.test | 41 + .../sql/returning/returning_delete.test | 603 ++++++++++ .../sql/returning/returning_delete_list.test | 30 + .../returning_delete_same_transaction.test | 81 ++ .../sql/returning/returning_insert.test | 130 ++ .../corpus/sql/returning/returning_large.test | 9 + .../sql/returning/returning_update.test | 186 +++ .../can_sample_from_ingested_files.test | 49 + .../sql/sample/same_seed_same_sample.test | 17 + .../table_samples/basic_sample_tests.test | 65 + ...table_sample_converts_to_block_sample.test | 29 + .../test_sample_is_destroyed_on_updates.test | 53 + .../table_samples/test_sample_types.test | 69 ++ .../test_table_sample_errors.test | 17 + .../sql/sample/test_sample_too_big.test | 29 + .../test_sample_too_big.test.metadata.json | 7 + .../corpus/sql/sample/test_system_rows.test | 116 ++ .../sql/sample/test_system_rows_pushdown.test | 36 + .../sql/secrets/create_secret_expression.test | 93 ++ ...reate_secret_expression.test.metadata.json | 5 + .../create_secret_filesystem_logging.test | 21 + .../secrets/create_secret_hffs_autoload.test | 31 + ..._secret_persistence_no_client_context.test | 13 + .../secrets/create_transaction_secret.test | 13 + .../drop_persistent_secret_if_exists.test | 21 + .../secrets/secret_autoloading_errors.test | 29 + .../secrets/secret_compatibility_http.test | 13 + .../select/test_multi_column_reference.test | 117 ++ .../sql/select/test_positional_reference.test | 37 + ...st_positional_reference.test.metadata.json | 5 + .../sql/select/test_projection_names.test | 33 + .../sql/select/test_schema_reference.test | 21 + .../test_select_alias_prefix_colon.test | 89 ++ .../corpus/sql/select/test_select_into.test | 17 + .../sql/select/test_select_locking.test | 21 + .../select/test_select_qualified_view.test | 25 + .../corpus/sql/setops/ambiguous_order_by.test | 13 + .../corpus/sql/setops/setops_pushdown.test | 41 + .../corpus/sql/setops/test_except.test | 53 + .../setops/test_full_outer_join_union.test | 81 ++ .../corpus/sql/setops/test_nested_except.test | 29 + .../corpus/sql/setops/test_pg_union.test | 301 +++++ .../corpus/sql/setops/test_setops.test | 79 ++ .../sql/setops/test_union_all_by_name.test | 129 ++ .../corpus/sql/setops/test_union_binding.test | 125 ++ .../corpus/sql/setops/test_union_by_name.test | 93 ++ .../corpus/sql/setops/test_union_error.test | 9 + .../sql/setops/test_union_except_empty.test | 21 + .../corpus/sql/setops/test_union_order.test | 13 + .../sql/setops/test_union_subquery.test | 13 + .../sql/setops/test_union_type_cast.test | 29 + .../corpus/sql/setops/union_aggregate.test | 60 + .../setops/union_all_projection_pushdown.test | 65 + .../corpus/sql/setops/union_limit.test | 115 ++ .../corpus/sql/setops/union_pipeline.test | 17 + .../corpus/sql/setops/union_shared_scan.test | 20 + .../corpus/sql/setops/value_union.test | 48 + .../corpus/sql/settings/access_mode.test | 9 + .../corpus/sql/settings/allowed_configs.test | 69 ++ .../settings/allowed_configs_extensions.test | 13 + .../sql/settings/allowed_directories.test | 133 +++ .../corpus/sql/settings/allowed_paths.test | 29 + .../sql/settings/block_allocator_memory.test | 41 + .../settings/connection_local_settings.test | 37 + .../settings/default_null_order_extended.test | 33 + .../settings/dialect_compatibility_mode.test | 29 + .../corpus/sql/settings/drop_set_schema.test | 37 + .../corpus/sql/settings/errors_as_json.test | 25 + .../settings/integer_division_setting.test | 25 + .../settings/lock_configuration_schema.test | 29 + .../sql/settings/max_execution_time.test | 84 ++ .../sql/settings/operator_memory_limit.test | 89 ++ .../settings/reset/reset_memory_limit.test | 17 + .../sql/settings/reset/reset_threads.test | 13 + .../sql/settings/set_schema_temp_main.test | 21 + .../corpus/sql/settings/setting_alias.test | 17 + .../sql/settings/setting_collation.test | 17 + .../settings/setting_disabled_optimizer.test | 25 + ...ting_disabled_optimizer.test.metadata.json | 6 + .../sql/settings/setting_exhaustive.test | 45 + .../sql/settings/setting_null_order.test | 17 + .../corpus/sql/settings/setting_order.test | 21 + .../setting_preserve_identifier_case.test | 29 + .../sql/settings/setting_profiling_mode.test | 13 + .../setting_profiling_mode.test.metadata.json | 5 + .../corpus/sql/settings/setting_threads.test | 17 + .../corpus/sql/settings/settings_icu.test | 29 + .../settings/test_disabled_file_systems.test | 41 + ...st_disabled_local_filesystem_metadata.test | 17 + ...est_disabled_local_filesystem_secrets.test | 9 + .../test_external_access_secrets.test | 13 + .../sql/settings/test_lock_configuration.test | 25 + .../corpus/sql/settings/user_agent.test | 25 + .../sql/show_select/describe_rowid.test | 31 + .../sql/show_select/describe_subquery.test | 37 + .../show_select/show_quote_identifier.test | 13 + .../show_select/show_select_constraints.test | 89 ++ .../sql/show_select/summarize_subquery.test | 17 + .../sql/show_select/test_describe_all.test | 21 + .../sql/show_select/test_describe_quoted.test | 73 ++ .../sql/show_select/test_show_select.test | 29 + .../sql/show_select/test_summarize.test | 67 ++ .../show_select/test_summarize_quoted.test | 25 + .../storage/adaptive_segment_allocation.test | 175 +++ .../alter_add_col_defaultexpr_sequence.test | 13 + ...lter_based_on_unfinished_insert_fails.test | 35 + .../alter/alter_column_constraint.test | 41 + .../alter/alter_lazy_metadata_load.test | 29 + .../storage/append_strings_to_persistent.test | 25 + .../attach_autocheckpoint_in_memory.test | 41 + .../attach_autocheckpoint_no_wal_writes.test | 41 + .../attach_autocheckpoint_propagation.test | 29 + .../storage/attach/attach_invalidation.test | 61 + .../attach_invalidation_default_db.test | 33 + .../attach_invalidation_sibling_commit.test | 37 + .../attach_invalidation_sibling_rollback.test | 13 + .../corpus/sql/storage/attach_mmap.test | 117 ++ .../storage/attach_mmap.test.metadata.json | 5 + .../sql/storage/bc/internal_schemas_0102.test | 9 + .../sql/storage/bc/test_broken_view_v092.test | 9 + .../corpus/sql/storage/bc/test_view_v092.test | 17 + .../sql/storage/buffer_manager_temp_dir.test | 17 + .../generated_columns/virtual/basic.test | 16 + .../virtual/constraints.test | 91 ++ .../catalog/test_check_constraint.test | 29 + .../sql/storage/catalog/test_drop_table.test | 21 + .../storage/catalog/test_macro_storage.test | 29 + .../test_not_distinct_from_default.test | 17 + .../catalog/test_not_null_constraint.test | 9 + .../catalog/test_prepared_storage.test | 33 + .../catalog/test_store_add_column.test | 13 + .../catalog/test_store_alter_type.test | 21 + .../catalog/test_store_default_sequence.test | 33 + .../storage/catalog/test_store_defaults.test | 13 + .../catalog/test_store_remove_column.test | 9 + .../catalog/test_store_rename_column.test | 13 + .../catalog/test_store_rename_table.test | 13 + .../catalog/test_store_rename_view.test | 17 + .../storage/catalog/test_store_sequences.test | 17 + .../storage/catalog/test_store_temporary.test | 57 + .../catalog/test_table_macro_storage.test | 50 + .../catalog/test_view_explicit_aliases.test | 21 + .../storage/catalog/test_view_storage.test | 9 + .../checkpoint/checkpoint_in_transaction.test | 41 + ...heckpoint_with_outstanding_insertions.test | 33 + ...xed_table_delete_insert_fragmentation.test | 57 + ...itial_database_autocheckpoint_failure.test | 9 + ...est_checkpoint_failure_delayed_commit.test | 17 + .../test_checkpoint_failure_on_detach.test | 17 + .../sql/storage/checkpointed_self_append.test | 21 + .../checkpointed_self_append_tinyint.test | 13 + .../corpus/sql/storage/commit_abort.test | 37 + .../sql/storage/commit_abort_medium.test | 13 + .../sql/storage/commit_index_deletes.test | 13 + .../block_size_with_rollback.test | 17 + .../compact_block_size.test | 17 + .../compact_vector_size.test | 13 + .../create_table_compression.test | 15 + .../default_block_size.test | 13 + .../compact_block_size/ensure_bitpacking.test | 33 + .../ensure_no_bitpacking.test | 33 + .../insertion_order_odd_batches.test | 53 + .../compact_block_size/mixed_block_sizes.test | 26 + .../alp/alp_corrupted_exception_position.test | 17 + .../compression/alp/alp_corrupted_file.test | 17 + .../alp/alp_corrupted_offsets.test | 17 + .../alp/alp_corrupted_vector_size.test | 9 + .../compression/alp/alp_inf_null_nan.test | 316 +++++ .../compression/alp/alp_list_skip.test | 17 + .../storage/compression/alp/alp_min_max.test | 25 + .../compression/alp/alp_negative_numbers.test | 38 + .../storage/compression/alp/alp_nulls.test | 262 ++++ .../compression/alp/alp_out_of_range.test | 17 + .../storage/compression/alp/alp_simple.test | 9 + .../compression/alp/alp_simple_float.test | 29 + .../compression/alp/alp_storage_version.test | 57 + .../storage/compression/alp/alp_zeros.test | 9 + .../alprd/alprd_corrupted_dict_size.test | 17 + .../alprd_corrupted_exception_position.test | 13 + .../compression/alprd/alprd_inf_null_nan.test | 17 + .../compression/alprd/alprd_min_max.test | 13 + .../alprd/alprd_negative_numbers.test | 17 + .../compression/alprd/alprd_nulls.test | 103 ++ .../compression/alprd/alprd_simple.test | 21 + .../compression/alprd/alprd_simple_float.test | 13 + .../alprd/alprd_storage_version.test | 57 + .../bitpacking/bitpacking_constant_delta.test | 37 + .../bitpacking/bitpacking_delta_for.test | 21 + .../bitpacking_filter_pushdown.test | 37 + .../bitpacking/bitpacking_hugeint.test | 61 + .../bitpacking/bitpacking_mode.test | 25 + .../bitpacking/bitpacking_nulls.test | 29 + .../bitpacking/bitpacking_simple.test | 29 + .../bitpacking/bitpacking_simple_hugeint.test | 9 + .../bitpacking_size_calculation.test | 15 + .../bitpacking/bitpacking_storage_info.test | 53 + .../bitpacking/bitpacking_table_copy.test | 29 + .../bitpacking/bitpacking_uhugeint.test | 53 + .../bitpacking/force_bitpacking.test | 21 + .../bitpacking/struct_bitpacking.test | 20 + .../compression/compression_selection.test | 49 + .../default_storage_dict_fsst.test | 23 + .../dict_fsst_expression_filter.test | 104 ++ .../compression/dict_fsst/dict_fsst_test.test | 47 + .../dict_fsst/dictionary_covers_validity.test | 63 + .../dict_fsst/dictionary_storage_info.test | 21 + .../compression/dict_fsst/fetch_row.test | 31 + .../dict_fsst/force_dictionary.test | 9 + .../dict_fsst/invalid_symbol_table.test | 17 + .../compression/dict_fsst/issue_5675.test | 37 + .../dict_fsst/issue_5675_followup.test | 14 + .../compression/dict_fsst/issue_5759.test | 13 + .../dict_fsst/repeated_string_stats.test | 32 + ...est_dict_fsst_with_smaller_block_size.test | 33 + .../dict_fsst/test_null_filter_pushdown.test | 21 + .../dict_fsst/test_null_update.test | 24 + .../dictionary/dict_corrupted_offset.test | 13 + .../dictionary/dictionary_storage_info.test | 9 + .../compression/dictionary/fetch_row.test | 30 + .../invalid_dictionary_metadata.test | 77 ++ .../total_string_length_dictionary.test | 21 + .../fsst/fsst_disable_compression.test | 21 + .../fsst/fsst_greedy_long_strings.test | 27 + .../fsst/fsst_small_symbol_table.test | 31 + .../compression/fsst/fsst_storage_info.test | 9 + .../fsst/invalid_fsst_bitpacking_width.test | 17 + .../storage/compression/fsst/issue_5675.test | 9 + .../storage/compression/fsst/issue_5759.test | 9 + .../patas/patas_corrupted_file.test | 13 + .../storage/compression/rle/force_rle.test | 17 + .../sql/storage/compression/rle/rle_bool.test | 21 + .../storage/compression/rle/rle_constant.test | 53 + .../rle/rle_corrupted_count_offset.test | 9 + .../storage/compression/rle/rle_filter.test | 25 + .../compression/rle/rle_filter_pushdown.test | 21 + .../compression/rle/rle_index_fetch.test | 9 + .../storage/compression/rle/rle_medium.test | 18 + .../compression/rle/rle_nulls_edge_case.test | 29 + .../storage/compression/rle/rle_select.test | 25 + .../compression/rle/rle_select_list.test | 31 + .../storage/compression/rle/struct_rle.test | 14 + .../roaring/roaring_analyze_array.test | 49 + .../roaring/roaring_analyze_bitset.test | 15 + .../roaring/roaring_analyze_run.test | 15 + .../roaring/roaring_array_simple.test | 36 + .../roaring/roaring_bitset_simple.test | 21 + .../roaring/roaring_bool_analyze_array.test | 37 + .../roaring/roaring_bool_analyze_bitset.test | 15 + .../roaring/roaring_bool_analyze_run.test | 15 + .../roaring/roaring_bool_array_simple.test | 36 + .../roaring_bool_array_simple_w_null.test | 35 + .../roaring/roaring_bool_bitset_simple.test | 21 + .../roaring_bool_bitset_simple_w_null.test | 23 + .../roaring/roaring_bool_fetch_row.test | 35 + .../roaring/roaring_bool_first_is_null.test | 21 + .../roaring_bool_inverted_array_simple.test | 24 + .../roaring_bool_inverted_run_simple.test | 9 + .../roaring/roaring_bool_run_simple.test | 13 + .../roaring_bool_run_simple_w_null.test | 24 + .../roaring_bool_smaller_than_vector.test | 13 + ...oaring_bool_uncompressed_under_v1_5_0.test | 9 + .../roaring/roaring_corrupted_file.test | 9 + .../roaring/roaring_fetch_row.test | 19 + .../roaring_inverted_array_simple.test | 24 + .../roaring/roaring_inverted_run_simple.test | 9 + .../roaring/roaring_run_simple.test | 13 + .../roaring/roaring_smaller_than_vector.test | 9 + .../compression/simple_compression.test | 13 + .../skip_explicit_compression_analyze.test | 70 ++ .../compression/string/big_strings.test | 67 ++ .../sql/storage/compression/string/blob.test | 77 ++ .../sql/storage/compression/string/empty.test | 54 + .../compression/string/filter_pushdown.test | 33 + .../compression/string/index_fetch.test | 51 + .../storage/compression/string/medium.test | 21 + .../storage/compression/string/simple.test | 17 + .../storage/compression/string/struct.test | 20 + .../compression/string/table_copy.test | 25 + .../compression/test_using_compression.test | 27 + .../storage/compression/zstd/fetch_row.test | 45 + .../sql/storage/compression/zstd/nulls.test | 30 + .../compression/zstd/test_skipping.test | 21 + .../sql/storage/compression/zstd/zstd.test | 13 + .../zstd/zstd_force_compression.test | 13 + ...oncurrent_attach_if_not_exists_create.test | 13 + .../foreignkey/foreign_key_persistent.test | 41 + .../foreign_key_persistent_memory_limit.test | 9 + .../corrupt/corrupt_catalog_entry.test | 9 + .../corrupt/corrupt_encoding_overflow.test | 9 + .../storage/delete/load_delete_modify.test | 33 + .../sql/storage/delete/repeated_deletes.test | 57 + .../storage/delete/test_store_deletes.test | 21 + .../delete/test_unchanged_deletes.test | 17 + .../delete/test_unchanged_deletes_large.test | 13 + .../storage/distinct_statistics_storage.test | 13 + .../encrypted_tmp_file_setting.test | 33 + ...temp_directory_enable_external_access.test | 13 + .../wal/encrypted_wal_blob_storage.test | 21 + .../wal/encrypted_wal_lazy_creation.test | 29 + .../encryption/wal/encrypted_wal_pragmas.test | 37 + .../sql/storage/extended_string_stats.test | 43 + .../storage/extensions/extension_default.test | 13 + .../storage/extensions/extension_views.test | 9 + .../external_file_cache_async_toggle.test | 42 + .../external_file_cache_block_size.test | 65 + .../external_file_cache_validate.test | 37 + .../sql/storage/filter_pushdown_struct.test | 25 + .../full_vector_delete_checkpoint.test | 13 + .../storage/issue3789_node_segment_tree.test | 21 + .../sql/storage/issue7582_list_storage.test | 17 + .../storage/lazy_load/lazy_load_limit.test | 13 + .../corpus/sql/storage/many_checkpoints.test | 17 + .../corpus/sql/storage/many_self_append.test | 9 + .../memory/in_memory_disabled_zstd.test | 21 + .../metadata/full_table_metadata_reuse.test | 29 + .../full_table_metadata_reuse_v7.test | 35 + .../metadata/multi_table_metadata_reuse.test | 37 + .../partial_column_metadata_reuse.test | 70 ++ ...ial_column_metadata_reuse_drop_column.test | 62 + ...ial_column_metadata_reuse_small_block.test | 29 + .../partial_column_metadata_reuse_v7.test | 13 + .../partial_table_metadata_reuse.test | 13 + .../mix/test_update_delete_string.test | 33 + .../mix/updates_deletes_big_table.test | 37 + .../updates_deletes_persistent_segments.test | 33 + ...le_clients_checkpoint_pending_updates.test | 33 + .../nested/struct_of_lists_unaligned.test | 13 + .../corpus/sql/storage/null_byte_storage.test | 29 + .../optimistic_write_delete.test | 21 + .../optimistic_write_large_strings.test | 32 + ...timistic_write_not_trigger_checkpoint.test | 25 + .../optimistic_write_temp_table.test | 25 + .../optimistic_write_update.test | 9 + .../many_columns_drop_table.test | 45 + .../partial_blocks/many_columns_rle.test | 13 + .../partial_blocks/many_columns_storage.test | 13 + .../partial_blocks/many_columns_strings.test | 33 + .../partial_blocks/many_columns_validity.test | 9 + .../partial_delete_checkpoint_mask.test | 17 + .../partial_delete_pending_compress.test | 25 + .../piecemeal_delete_checkpoint_compress.test | 17 + .../pragma_storage_info_scan_type.test | 50 + .../prefetch/async_native_scan_pool.test | 17 + .../async_native_scan_positional.test | 17 + .../read_duckdb/read_duckdb_basic.test | 65 + .../read_duckdb/read_duckdb_generated.test | 34 + .../read_duckdb/read_duckdb_index.test | 29 + .../read_duckdb/read_duckdb_schema.test | 41 + .../read_duckdb/read_duckdb_suggested.test | 25 + .../read_duckdb/read_duckdb_top_n.test | 33 + .../read_duckdb/read_duckdb_transaction.test | 17 + .../read_duckdb_union_by_name.test | 29 + .../read_duckdb_virtual_columns.test | 17 + ...est_reclaim_space_update_large_string.test | 25 + .../sql/storage/row_group_fetch_bulk.test | 111 ++ .../alter_preserves_rowid_gaps.test | 73 ++ .../append_after_gap_checkpoint.test | 89 ++ .../bulk_append_after_gap_checkpoint.test | 49 + .../indexed_checkpoint_drop_row_group.test | 53 + .../indexed_dense_vacuum_merge.test | 49 + .../indexed_geometry_legacy_no_remap.test | 83 ++ .../indexed_geometry_vacuum_remap.test | 63 + .../indexed_incremental_vacuum_remap.test | 91 ++ .../indexed_live_vacuum_no_rebuild.test | 82 ++ ..._live_vacuum_no_rebuild.test.metadata.json | 5 + ...d_old_storage_keeps_deleted_row_group.test | 58 + .../indexed_rebuild_fallback_then_remap.test | 78 ++ ...exed_remap_duplicate_key_across_tasks.test | 63 + .../indexed_remap_merges_across_gap.test | 61 + .../indexed_remap_partial_chunk.test | 67 ++ ...ndexed_remap_same_key_rowid_collision.test | 63 + ...s_geometry_legacy_no_merge_across_gap.test | 92 ++ .../rowid_gaps/leading_gap_lookup.test | 101 ++ .../rowid_gaps/old_storage_dense_rewrite.test | 45 + .../wal_replay_after_gap_checkpoint.test | 29 + .../sql/storage/shutdown_create_index.test | 37 + .../storage/shutdown_running_transaction.test | 9 + .../sql/storage/shutdown_unique_index.test | 13 + .../storage_exceeds_block_large_string.test | 29 + .../storage/storage_exceeds_single_block.test | 17 + .../storage_exceeds_single_block_strings.test | 21 + .../storage_exceeds_single_block_types.test | 9 + .../corpus/sql/storage/storage_types.test | 41 + .../sql/storage/storage_version_65.test | 37 + .../corpus/sql/storage/storage_versions.test | 29 + .../sql/storage/store_group_order_all.test | 40 + .../temp_directory/max_swap_space_error.test | 61 + .../max_swap_space_explicit.test | 13 + .../max_swap_space_inmemory.test | 41 + .../max_swap_space_persistent.test | 45 + .../max_swap_space_unlimited.test | 9 + .../temp_directory/temp_directory_null.test | 17 + .../test_default_temp_directory.test | 9 + .../corpus/sql/storage/test_empty_table.test | 9 + ...t_eviction_queue_dead_nodes_underflow.test | 12 + ...ignore_duplicate_deletes_unique_index.test | 25 + .../sql/storage/test_index_checkpoint.test | 21 + .../sql/storage/test_large_commits.test | 21 + .../storage/test_read_only_wal_replay.test | 117 ++ .../sql/storage/test_restart_extension.test | 9 + .../storage/test_show_tables_persistent.test | 21 + .../corpus/sql/storage/test_storage_scan.test | 13 + .../sql/storage/test_store_integers.test | 25 + .../sql/storage/test_store_nulls_strings.test | 9 + .../sql/storage/test_truncate_persistent.test | 17 + .../sql/storage/test_unaligned_scan.test | 13 + .../storage/test_unique_index_checkpoint.test | 34 + .../total_string_length_nested_types.test | 49 + .../total_string_length_repeated_insert.test | 17 + .../sql/storage/types/list/default_list.test | 13 + .../types/list/empty_float_arrays.test | 25 + .../types/list/list_index_compression.test | 73 ++ .../types/list/persistent_list_storage.test | 41 + .../types/list/store_list_of_struct.test | 21 + .../sql/storage/types/map/map_storage.test | 13 + .../storage/types/struct/default_struct.test | 150 +++ .../types/struct/nested_struct_storage.test | 78 ++ .../struct/pushdown_extract_validity.test | 29 + .../types/struct/struct_of_empty_list.test | 13 + .../storage/types/struct/struct_storage.test | 21 + .../sql/storage/types/test_bit_storage.test | 17 + .../sql/storage/types/test_blob_storage.test | 13 + .../storage/types/test_hugeint_storage.test | 25 + .../storage/types/test_interval_storage.test | 29 + .../storage/types/test_timestamp_storage.test | 37 + .../storage/types/test_uhugeint_storage.test | 25 + .../storage/types/test_unsigned_storage.test | 55 + .../sql/storage/types/test_uuid.storage.test | 29 + .../types/variant/append_shredded.test | 17 + .../types/variant/extension_types.test | 21 + .../storage/types/variant/index_fetch.test | 33 + .../types/variant/struct_of_variant.test | 37 + .../storage/types/variant/test_all_types.test | 13 + .../variant/test_all_types_single_object.test | 40 + .../variant/test_all_types_single_table.test | 39 + .../types/variant/test_all_types_variant.test | 17 + .../sql/storage/types/variant/update.test | 17 + ...ariant_case_sensitive_fields_shredded.test | 49 + .../variant/variant_comparator_shredded.test | 84 ++ .../variant/variant_comparator_stats.test | 114 ++ .../variant_duplicate_keys_shredding.test | 14 + .../variant_extract_filter_pushdown.test | 62 + .../types/variant/variant_extract_stats.test | 117 ++ .../storage/types/variant/variant_index.test | 17 + .../types/variant/variant_null_missing.test | 73 ++ ...nt_null_shredding_inconsistency_issue.test | 28 + .../variant_shredded_extract_non_object.test | 26 + .../types/variant/variant_shredded_slice.test | 30 + .../variant/variant_shredding_empty_keys.test | 25 + .../variant_shredding_inconsistent.test | 23 + .../variant_shredding_omit_untyped.test | 25 + .../variant/variant_shredding_small.test | 33 + .../variant/variant_storage_version.test | 33 + parser/testdata/corpus/sql/storage/unzip.test | 13 + .../update/dictionary_update_null.test | 22 + .../update/test_store_null_updates.test | 17 + .../update/wal_restart_update_insert.test | 33 + .../wal/wal_autocheckpoint_entries.test | 101 ++ .../sql/storage/wal/wal_create_index.test | 41 + .../storage/wal/wal_create_insert_drop.test | 49 + .../sql/storage/wal/wal_index_delete.test | 53 + .../sql/storage/wal/wal_index_delete_gen.test | 37 + .../storage/wal/wal_index_interleaved.test | 61 + .../wal_index_large_batch_interleaved.test | 25 + .../sql/storage/wal/wal_index_replay.test | 29 + .../sql/storage/wal/wal_lazy_creation.test | 13 + .../wal_null_update_row_group_pruning.test | 37 + .../sql/storage/wal/wal_promote_version.test | 25 + ...sistency_add_column_current_timestamp.test | 41 + ..._replay_consistency_add_column_random.test | 25 + ...unbound_index_create_index_during_wal.test | 53 + ...replay_unbound_index_generated_column.test | 33 + ...al_replay_unbound_index_mixed_inserts.test | 45 + .../wal_replay_unbound_index_multi_index.test | 49 + .../storage/wal/wal_replay_with_function.test | 21 + .../sql/storage/wal/wal_storage_types.test | 55 + .../wal/wal_store_mixed_updates_big.test | 49 + .../wal/wal_store_mixed_updates_big_null.test | 17 + .../sql/storage/wal/wal_store_sequences.test | 9 + .../storage/wal/wal_store_updates_big.test | 9 + .../wal/wal_store_updates_big_varchar.test | 25 + .../storage/wal/wal_timestamp_storage.test | 21 + .../sql/storage/wal/wal_uhugeint_storage.test | 9 + .../sql/storage/wal/wal_view_storage.test | 31 + .../storage_version/storage_hyperloglog.test | 49 + .../storage_version/storage_version_bump.test | 25 + .../sql/subquery/any_all/issue_2999.test | 9 + .../sql/subquery/any_all/subquery_in.test | 17 + .../sql/subquery/any_all/test_any_all.test | 37 + .../any_all/test_any_all.test.metadata.json | 6 + .../any_all/test_correlated_any_all.test | 85 ++ .../test_multi_column_mark_join_nulls.test | 214 ++++ .../any_all/test_row_comparison_any_all.test | 181 +++ ...test_row_not_equal_any_null_semantics.test | 94 ++ .../subquery/any_all/test_scalar_any_all.test | 37 + .../sql/subquery/any_all/test_scalar_in.test | 41 + .../subquery/any_all/test_simple_not_in.test | 33 + .../test_uncorrelated_all_subquery.test | 125 ++ .../test_uncorrelated_any_subquery.test | 65 + .../complex_correlated_subquery_issue.test | 65 + .../correlated_internal_issue_5975.test | 187 +++ .../complex/correlated_list_any_join.test | 45 + .../complex/nested_unnest_subquery.test | 21 + .../exists/test_correlated_exists.test | 141 +++ ..._correlated_exists_with_derived_table.test | 33 + .../exists/test_exists_union_by_name.test | 23 + .../sql/subquery/exists/test_issue_22267.test | 64 + .../sql/subquery/exists/test_issue_23979.test | 51 + .../sql/subquery/exists/test_issue_9308.test | 25 + .../subquery/exists/test_scalar_exists.test | 21 + .../test_uncorrelated_exists_subquery.test | 61 + .../sql/subquery/lateral/lateral_arrays.test | 41 + .../lateral/lateral_binding_views.test | 21 + .../subquery/lateral/lateral_fuzzer_1463.test | 27 + .../lateral/lateral_fuzzer_5984_23.test | 13 + .../lateral/lateral_grouping_sets.test | 35 + .../lateral/lateral_join_aggregate.test | 17 + .../subquery/lateral/lateral_join_chain.test | 29 + .../lateral_join_generated_columns.test | 20 + .../subquery/lateral/lateral_join_macro.test | 19 + .../subquery/lateral/lateral_large_lists.test | 17 + .../subquery/lateral/lateral_left_join.test | 61 + .../sql/subquery/lateral/lateral_qualify.test | 13 + .../sql/subquery/lateral/lateral_values.test | 13 + .../sql/subquery/lateral/pg_lateral.test | 304 +++++ .../subquery/lateral/test_lateral_join.test | 148 +++ .../subquery/scalar/array_order_subquery.test | 91 ++ .../sql/subquery/scalar/array_subquery.test | 57 + .../subquery/scalar/coalesce_subquery.test | 9 + .../scalar/correlated_missing_columns.test | 37 + .../sql/subquery/scalar/correlated_pivot.test | 57 + .../scalar/correlated_pivot_error.test | 17 + .../subquery/scalar/in_multiple_columns.test | 25 + .../scalar/nested_subquery_window.test | 17 + .../subquery/scalar/order_by_correlated.test | 29 + .../subquery/scalar/subquery_row_in_any.test | 50 + .../test_complex_correlated_subquery.test | 115 ++ ...st_complex_nested_correlated_subquery.test | 41 + .../scalar/test_correlated_grouping_set.test | 25 + .../scalar/test_correlated_set_op.test | 17 + .../scalar/test_correlated_side_effects.test | 28 + .../scalar/test_correlated_subquery.test | 89 ++ .../scalar/test_correlated_subquery_cte.test | 131 ++ .../test_correlated_subquery_where.test | 17 + .../scalar/test_correlated_window.test | 25 + .../scalar/test_count_star_subquery.test | 45 + .../subquery/scalar/test_delete_subquery.test | 25 + .../test_grouped_correlated_subquery.test | 110 ++ .../sql/subquery/scalar/test_issue_4216.test | 21 + .../sql/subquery/scalar/test_issue_6136.test | 42 + .../sql/subquery/scalar/test_issue_6184.test | 88 ++ .../sql/subquery/scalar/test_issue_7079.test | 41 + .../scalar/test_join_in_subquery.test | 17 + .../scalar/test_many_correlated_columns.test | 33 + .../subquery/scalar/test_scalar_subquery.test | 133 +++ .../scalar/test_scalar_subquery_cte.test | 91 ++ .../scalar/test_subquery_any_join.test | 37 + .../test_tpcds_correlated_subquery.test | 17 + .../test_uncorrelated_scalar_subquery.test | 73 ++ .../test_uncorrelated_varchar_subquery.test | 41 + .../subquery/scalar/test_unnest_subquery.test | 73 ++ .../subquery/scalar/test_update_subquery.test | 25 + .../test_varchar_correlated_subquery.test | 53 + .../scalar/test_window_function_subquery.test | 25 + .../sql/subquery/table/test_aliasing.test | 21 + .../subquery/table/test_subquery_union.test | 9 + .../subquery/table/test_table_subquery.test | 33 + .../subquery/table/test_unnamed_subquery.test | 33 + .../corpus/sql/subquery/test_neumann.test | 17 + .../corpus/sql/subquery/test_offset.test | 9 + .../create_external_resource.test | 316 +++++ .../sql/table_function/database_oid.test | 17 + .../duckdb_available_metrics.test | 11 + .../sql/table_function/duckdb_columns.test | 51 + .../table_function/duckdb_constraints.test | 45 + .../table_function/duckdb_constraints_fk.test | 44 + .../duckdb_constraints_issue11284.test | 29 + .../duckdb_constraints_issue12863.test | 29 + .../sql/table_function/duckdb_databases.test | 49 + .../table_function/duckdb_dependencies.test | 9 + .../sql/table_function/duckdb_dialects.test | 25 + .../duckdb_eviction_queues.test | 36 + .../duckdb_eviction_queues_transactions.test | 13 + .../sql/table_function/duckdb_extensions.test | 17 + .../duckdb_functions_window.test | 12 + .../sql/table_function/duckdb_indexes.test | 17 + .../sql/table_function/duckdb_keywords.test | 9 + .../duckdb_memory_convert_to_persistent.test | 13 + .../sql/table_function/duckdb_optimizers.test | 13 + .../duckdb_prepared_statements.test | 9 + .../sql/table_function/duckdb_schemas.test | 21 + .../sql/table_function/duckdb_sequences.test | 23 + .../sql/table_function/duckdb_settings.test | 31 + .../sql/table_function/duckdb_tables.test | 35 + .../sql/table_function/duckdb_types.test | 13 + .../sql/table_function/duckdb_views.test | 41 + .../external_resource_discovery.test | 70 ++ .../external_resource_discovery_error.test | 41 + .../external_resource_logging.test | 104 ++ .../external_resource_types.test | 98 ++ .../table_function/icu_range_timestamptz.test | 74 ++ .../table_function/information_schema.test | 145 +++ ...ormation_schema_fkey_constraint_names.test | 62 + .../information_schema_issue12867.test | 17 + .../information_schema_types.test | 13 + .../lateral_table_function.test | 13 + .../postgres_setof_compatibility.test | 97 ++ .../range_function_different_iterators.test | 37 + .../range_function_lateral.test | 77 ++ .../table_function/range_non_foldable.test | 32 + .../sql/table_function/range_timestamp.test | 94 ++ .../range_timestamp_lateral_empty.test | 65 + .../table_function/read_text_and_blob.test | 57 + .../register_external_resource.test | 70 ++ .../sql/table_function/sqlite_master.test | 41 + .../sqlite_master_connections.test | 9 + .../table_function/sqlite_master_quotes.test | 29 + .../test_information_schema_columns.test | 1050 +++++++++++++++++ .../table_function/test_range_function.test | 109 ++ .../table_function/test_repeat_function.test | 41 + .../table_function/test_table_function.test | 33 + ...warn_deprecated_identifier_conversion.test | 25 + .../timezone/disable_timestamptz_casts.test | 33 + .../sql/timezone/icu_calendar_operations.test | 28 + .../sql/timezone/test_icu_calendar.test | 62 + .../timezone/test_icu_calendar_chinese.test | 101 ++ .../timezone/test_icu_calendar_coptic.test | 97 ++ .../timezone/test_icu_calendar_hebrew.test | 65 + .../timezone/test_icu_calendar_islamic.test | 86 ++ .../test_icu_calendar_islamic_observed.test | 35 + .../timezone/test_icu_calendar_japanese.test | 59 + .../timezone/test_icu_calendar_persian.test | 81 ++ .../timezone/test_icu_calendar_systems.test | 126 ++ .../corpus/sql/timezone/test_icu_casts.test | 63 + .../timezone/test_icu_datetime_overflow.test | 57 + .../sql/timezone/test_icu_datetime_sweep.test | 32 + .../sql/timezone/test_icu_timezone.test | 295 +++++ .../test_icu_timezone_edge_cases.test | 230 ++++ .../test_icu_timezone_far_future.test | 112 ++ .../test_icu_timezone_properties.test | 50 + .../testdata/corpus/sql/topn/test_top_n.test | 37 + .../test_top_n_distinct_row_group_pruner.test | 29 + .../corpus/sql/topn/test_top_n_lists.test | 45 + .../corpus/sql/topn/test_top_n_medium.test | 17 + .../sql/topn/test_top_n_nested_struct.test | 26 + .../sql/topn/test_top_n_nulls_first.test | 21 + ..._first_row_group_reorderer_edge_cases.test | 71 ++ .../test_top_n_nulls_row_group_pruner.test | 16 + ...op_n_nulls_row_group_pruner_extensive.test | 363 ++++++ .../sql/topn/test_top_n_nulls_small.test | 65 + .../test_top_n_offset_no_limit_pruner.test | 25 + .../corpus/sql/topn/test_top_n_structs.test | 13 + .../sql/topn/top_n_materialization.test | 21 + .../corpus/sql/topn/top_n_pruning.test | 128 ++ .../corpus/sql/topn/topn_nulls_first.test | 23 + .../corpus/sql/topn/tpcds_q14_topn.test | 49 + .../corpus/sql/topn/tpcds_q59_topn.test | 22 + .../corpus/sql/tpcds/dsdgen_readonly.test | 17 + .../corpus/sql/tpcds/dsdgen_sync_scan.test | 17 + .../testdata/corpus/sql/tpcds/tpcds_sf0.test | 37 + .../corpus/sql/tpch/dbgen_readonly.test | 17 + parser/testdata/corpus/sql/tpch/tpch_sf0.test | 29 + .../aborted_transaction_commit.test | 17 + .../transactions/commit_revert_failure.test | 41 + .../transactions/concurrent_drop_index.test | 33 + .../transactions/concurrent_drop_table.test | 41 + .../conflict_drop_then_delete.test | 23 + .../transactions/conflict_rename_append.test | 31 + .../transactions/count_star_transactions.test | 25 + .../delete_and_drop_in_same_transaction.test | 23 + .../delete_index_lookup_transactions.test | 21 + .../sql/transactions/min_max_deletes.test | 9 + .../sql/transactions/min_max_updates.test | 17 + ...rt_commit_index_corruption_drop_table.test | 41 + .../sql/transactions/rollback_drop.test | 13 + .../transactions/rollback_drop_column.test | 29 + .../sql/transactions/rollback_drop_index.test | 9 + .../sql/transactions/rollback_drop_table.test | 13 + .../rollback_drop_table_with_delete.test | 21 + ...n_policy_is_respected_by_preprocessor.test | 17 + .../multistatement_is_transactional.test | 9 + ...nsactional_after_BEGIN_chained_COMMIT.test | 9 + ...tement_is_transactional_chained_BEGIN.test | 9 + ...ansactional_chained_BEGIN_body_COMMIT.test | 9 + ...ement_is_transactional_chained_PRAGMA.test | 9 + ...is_transactional_chained_PRAGMA_BEGIN.test | 9 + .../pivot_is_handled_correctly.test | 9 + ...est_alter_sequence_ownership_conflict.test | 23 + ...st_alter_sequence_ownership_conflict2.test | 19 + .../transactions/test_basic_transactions.test | 9 + ...st_cardinality_estimation_uncommitted.test | 13 + .../test_create_drop_conflict.test | 21 + .../test_create_drop_conflict_variation1.test | 13 + .../sql/transactions/test_ddl_after_dml.test | 57 + .../test_from_update_conflict.test | 37 + .../sql/transactions/test_index_abort.test | 17 + ...index_delete_cleanup_non_main_storage.test | 145 +++ .../test_index_huge_aborted_append.test | 21 + .../test_index_large_aborted_append.test | 33 + .../transactions/test_index_local_update.test | 29 + .../test_index_pending_delete.test | 9 + .../test_index_pending_update.test | 13 + .../test_index_rollback_flushed_data.test | 17 + .../test_index_transaction_local.test | 33 + .../test_index_versioned_deletes.test | 17 + .../test_index_versioned_updates.test | 13 + .../test_multi_transaction_append.test | 9 + .../sql/transactions/test_multi_version.test | 21 + .../test_multi_version_large.test | 29 + .../sql/transactions/test_null_version.test | 13 + .../test_read_only_transactions.test | 9 + .../test_stacked_schema_change.test | 21 + .../transactions/test_transaction_abort.test | 17 + .../test_transaction_local_add.test | 9 + .../test_transaction_local_alter_type.test | 9 + .../test_transaction_local_data.test | 13 + .../test_transaction_local_drop.test | 9 + .../test_transaction_local_unique_ops.test | 13 + .../transaction_insert_delete_chunks.test | 21 + .../transaction_insert_mixed_deletes.test | 9 + .../types/test_hugeint_transactions.test | 29 + .../types/test_interval_transactions.test | 25 + .../types/test_uhugeint_transactions.test | 29 + .../sql/trigger/create_trigger_catalog.test | 214 ++++ .../sql/trigger/create_trigger_parse.test | 100 ++ .../sql/trigger/create_trigger_wal.test | 37 + .../corpus/sql/trigger/drop_trigger.test | 113 ++ .../sql/trigger/drop_trigger_parse.test | 57 + .../corpus/sql/trigger/drop_trigger_wal.test | 37 + .../sql/trigger/trigger_after_delete.test | 184 +++ .../trigger_after_delete_referencing.test | 137 +++ .../sql/trigger/trigger_after_insert.test | 359 ++++++ .../trigger_after_insert_referencing.test | 243 ++++ .../sql/trigger/trigger_after_update.test | 212 ++++ .../trigger/trigger_after_update_old_new.test | 445 +++++++ .../trigger_after_update_old_new_wal.test | 36 + .../trigger_after_update_referencing.test | 93 ++ .../sql/trigger/trigger_alter_table.test | 33 + .../trigger/trigger_before_after_mixed.test | 191 +++ .../sql/trigger/trigger_before_delete.test | 76 ++ .../sql/trigger/trigger_before_insert.test | 87 ++ .../sql/trigger/trigger_before_update.test | 111 ++ .../sql/trigger/trigger_for_each_row.test | 883 ++++++++++++++ .../trigger/trigger_multiple_per_event.test | 541 +++++++++ .../trigger_referencing_validation.test | 172 +++ ..._referencing_validation.test.metadata.json | 7 + .../corpus/sql/trigger/trigger_returning.test | 737 ++++++++++++ .../trigger_returning_binder_parity.test | 171 +++ .../trigger_update_from_multi_match.test | 87 ++ .../corpus/sql/types/alias/nested_alias.test | 17 + .../sql/types/alias/recursive_alias.test | 17 + .../corpus/sql/types/alias/test_alias.test | 25 + .../sql/types/alias/test_alias_functions.test | 13 + .../sql/types/alias/test_alias_map.test | 13 + .../sql/types/alias/test_alias_struct.test | 49 + .../alias/test_alias_struct_nested_alias.test | 34 + .../sql/types/alias/test_alias_table.test | 138 +++ .../sql/types/alias/type_with_schema.test | 23 + .../sql/types/bignum/test_big_bignum.test | 17 + .../types/bignum/test_bignum_boundaries.test | 59 + .../types/bignum/test_bignum_comparisons.test | 72 ++ .../sql/types/bignum/test_bignum_double.test | 49 + .../bignum/test_bignum_float_string_cast.test | 33 + .../sql/types/bignum/test_bignum_hugeint.test | 29 + .../bignum/test_bignum_implicit_cast.test | 25 + .../types/bignum/test_bignum_not_cast.test | 9 + .../types/bignum/test_bignum_subtract.test | 53 + .../sql/types/bignum/test_bignum_sum.test | 232 ++++ .../types/bignum/test_bignum_try_cast.test | 45 + .../bignum/test_bignum_varchar_invalid.test | 21 + .../sql/types/bignum/test_double_bignum.test | 41 + .../bignum/test_int_bignum_conversion.test | 81 ++ .../test_varchar_bignum_conversion.test | 57 + .../bignum/test_varchar_bignum_unhappy.test | 129 ++ .../corpus/sql/types/bit/bit_issue_11211.test | 20 + .../corpus/sql/types/bit/bit_issue_22527.test | 121 ++ .../corpus/sql/types/bit/bit_try_cast.test | 101 ++ .../corpus/sql/types/bit/test_bit.test | 137 +++ .../bit/test_bit_bitwise_operations.test | 113 ++ .../sql/types/bit/test_bit_equality.test | 9 + .../sql/types/bit/test_bit_functions.test | 121 ++ .../corpus/sql/types/bit/test_hex_to_bit.test | 49 + .../corpus/sql/types/blob/test_blob.test | 25 + .../corpus/sql/types/blob/test_blob_cast.test | 61 + .../sql/types/blob/test_blob_function.test | 53 + .../types/blob/test_blob_invalid_utf8.test | 17 + .../sql/types/blob/test_blob_operator.test | 45 + .../sql/types/blob/test_blob_string.test | 17 + .../sql/types/blob/test_blob_try_cast.test | 61 + .../sql/types/date/date_implicit_cast.test | 21 + .../corpus/sql/types/date/date_limits.test | 197 ++++ .../corpus/sql/types/date/date_parsing.test | 406 +++++++ .../corpus/sql/types/date/date_try_cast.test | 121 ++ .../corpus/sql/types/date/test_bc_dates.test | 45 + .../corpus/sql/types/date/test_date.test | 65 + .../corpus/sql/types/date/test_date_2411.test | 21 + .../sql/types/date/test_incorrect_dates.test | 53 + .../sql/types/decimal/cast_from_decimal.test | 73 ++ .../sql/types/decimal/cast_to_decimal.test | 317 +++++ .../sql/types/decimal/decimal_aggregates.test | 53 + .../sql/types/decimal/decimal_arithmetic.test | 149 +++ .../types/decimal/decimal_automatic_cast.test | 28 + .../sql/types/decimal/decimal_average.test | 186 +++ .../decimal_decimal_overflow_cast.test | 89 ++ .../sql/types/decimal/decimal_division.test | 105 ++ .../sql/types/decimal/decimal_exception.test | 53 + .../sql/types/decimal/decimal_exponent.test | 173 +++ .../sql/types/decimal/decimal_overflow.test | 57 + .../types/decimal/decimal_overflow_table.test | 41 + .../sql/types/decimal/decimal_promotion.test | 57 + .../sql/types/decimal/decimal_try_cast.test | 181 +++ .../decimal/large_decimal_constants.test | 21 + .../sql/types/decimal/test_decimal.test | 145 +++ .../sql/types/decimal/test_decimal_2411.test | 25 + .../sql/types/decimal/test_decimal_2975.test | 21 + .../sql/types/decimal/test_decimal_4106.test | 21 + .../decimal/test_decimal_from_string.test | 33 + .../sql/types/decimal/test_decimal_ops.test | 276 +++++ ...test_decimal_small_precision_behavior.test | 37 + .../sql/types/decimal/test_empty_dec.test | 21 + .../sql/types/decimal/test_empty_decimal.test | 17 + .../sql/types/enum/standalone_enum.test | 33 + .../corpus/sql/types/enum/test_3479.test | 29 + .../corpus/sql/types/enum/test_3641.test | 44 + .../corpus/sql/types/enum/test_5983.test | 29 + .../corpus/sql/types/enum/test_6356.test | 69 ++ .../sql/types/enum/test_alter_enum.test | 43 + .../corpus/sql/types/enum/test_enum.test | 145 +++ .../corpus/sql/types/enum/test_enum_case.test | 21 + .../corpus/sql/types/enum/test_enum_cast.test | 89 ++ .../sql/types/enum/test_enum_comparisons.test | 169 +++ .../sql/types/enum/test_enum_constraints.test | 65 + .../types/enum/test_enum_duckdb_types.test | 9 + .../sql/types/enum/test_enum_schema.test | 93 ++ .../sql/types/enum/test_enum_structs.test | 46 + .../sql/types/enum/test_enum_table.test | 158 +++ .../sql/types/enum/test_enum_temp_tbl.test | 21 + .../sql/types/enum/test_enum_to_numbers.test | 201 ++++ .../enum/test_enums_and_built_in_types.test | 25 + .../sql/types/float/ieee_floating_points.test | 93 ++ .../corpus/sql/types/float/infinity_test.test | 105 ++ .../corpus/sql/types/float/nan_aggregate.test | 45 + .../sql/types/float/nan_aggregates.test | 29 + .../sql/types/float/nan_arithmetic.test | 121 ++ .../corpus/sql/types/float/nan_cast.test | 25 + .../corpus/sql/types/float/nan_functions.test | 90 ++ .../corpus/sql/types/float/nan_join.test | 25 + .../corpus/sql/types/float/nan_ordering.test | 57 + .../corpus/sql/types/float/nan_test.test | 65 + .../corpus/sql/types/float/nan_window.test | 21 + .../corpus/sql/types/float/nested_nan.test | 21 + .../corpus/sql/types/geo/geometry.test | 134 +++ .../sql/types/geo/geometry_compatability.test | 61 + .../corpus/sql/types/geo/geometry_crs.test | 69 ++ .../types/geo/geometry_crs.test.metadata.json | 5 + .../sql/types/geo/geometry_crs_projjson.test | 115 ++ .../sql/types/geo/geometry_crs_wkt2.test | 40 + .../types/geo/geometry_from_wkb_stats.test | 168 +++ .../geometry_intersection_filter_parquet.test | 38 + .../sql/types/geo/geometry_intersects.test | 21 + .../geo/geometry_legacy_recheckpoint.test | 29 + .../sql/types/geo/geometry_nonascii_cast.test | 21 + .../types/geo/geometry_parquet_pushdown.test | 35 + ...ometry_parquet_pushdown.test.metadata.json | 5 + .../sql/types/geo/geometry_persist.test | 13 + .../sql/types/geo/geometry_persist_wal.test | 29 + .../corpus/sql/types/geo/geometry_shred.test | 25 + .../sql/types/geo/geometry_shred_deletes.test | 21 + .../sql/types/geo/geometry_shred_empty.test | 52 + .../sql/types/geo/geometry_shred_fetch.test | 25 + .../sql/types/geo/geometry_shred_limit.test | 25 + .../sql/types/geo/geometry_shred_list.test | 21 + .../sql/types/geo/geometry_shred_more.test | 97 ++ .../types/geo/geometry_shred_pk_append.test | 17 + .../corpus/sql/types/geo/geometry_stats.test | 33 + .../sql/types/geo/geometry_stats_prune.test | 43 + .../geo/geometry_stats_prune_shredded.test | 9 + .../types/geo/geometry_storage_version.test | 17 + .../corpus/sql/types/geo/geometry_update.test | 21 + .../types/geo/geometry_vertex_extract.test | 196 +++ .../corpus/sql/types/geo/geometry_wkb.test | 197 ++++ .../sql/types/hugeint/hugeint_multiply.test | 133 +++ .../types/hugeint/hugeint_sum_overflow.test | 45 + .../sql/types/hugeint/hugeint_try_cast.test | 37 + .../hugeint/test_hugeint_aggregates.test | 29 + .../hugeint/test_hugeint_arithmetic.test | 389 ++++++ .../types/hugeint/test_hugeint_auto_cast.test | 21 + .../types/hugeint/test_hugeint_bitwise.test | 145 +++ .../hugeint/test_hugeint_conversion.test | 149 +++ .../types/hugeint/test_hugeint_exponent.test | 37 + .../types/hugeint/test_hugeint_functions.test | 33 + .../hugeint/test_hugeint_null_value.test | 37 + .../sql/types/hugeint/test_hugeint_ops.test | 58 + .../sql/types/interval/frac_interval.test | 101 ++ .../sql/types/interval/interval_alias.test | 9 + .../types/interval/interval_constants.test | 369 ++++++ .../interval_constants.test.metadata.json | 11 + .../sql/types/interval/interval_try_cast.test | 89 ++ .../sql/types/interval/test_interval.test | 315 +++++ .../interval/test_interval_addition.test | 250 ++++ .../types/interval/test_interval_between.test | 37 + .../interval/test_interval_comparison.test | 119 ++ .../sql/types/interval/test_interval_ops.test | 21 + .../corpus/sql/types/list/list_case.test | 25 + .../sql/types/list/list_comparison.test | 612 ++++++++++ .../sql/types/list/list_concat_null.test | 81 ++ .../sql/types/list/list_cross_product.test | 65 + .../corpus/sql/types/list/list_distinct.test | 189 +++ .../list/list_extract_internal_issue2747.test | 9 + .../sql/types/list/list_extract_struct.test | 65 + .../corpus/sql/types/list/list_index.test | 17 + .../types/list/list_index_abort_small.test | 33 + .../list/list_index_abort_small_nested.test | 33 + .../corpus/sql/types/list/list_indexing.test | 37 + .../sql/types/list/list_null_members.test | 51 + .../types/list/list_null_members_small.test | 38 + .../corpus/sql/types/list/list_of_struct.test | 58 + .../sql/types/list/list_parse_recursion.test | 9 + .../corpus/sql/types/list/list_stats.test | 77 ++ .../types/list/list_test_many_deletes.test | 33 + .../sql/types/list/list_to_varchar_cast.test | 9 + .../list/list_update_with_many_matches.test | 21 + .../corpus/sql/types/list/list_updates.test | 33 + .../sql/types/list/list_updates_varchar.test | 25 + .../sql/types/list/mix_numeric_types.test | 37 + .../sql/types/list/nested_list_extract.test | 77 ++ .../sql/types/list/nested_list_slice.test | 33 + .../sql/types/list/nested_list_updates.test | 17 + .../sql/types/list/recursive_unnest.test | 81 ++ .../sql/types/list/unnest_aggregate.test | 17 + .../corpus/sql/types/list/unnest_array.test | 21 + .../sql/types/list/unnest_complex_types.test | 49 + .../corpus/sql/types/list/unnest_expand.test | 45 + .../sql/types/list/unnest_group_by.test | 147 +++ .../sql/types/list/unnest_having_qualify.test | 13 + .../sql/types/list/unnest_null_empty.test | 99 ++ .../sql/types/list/unnest_table_function.test | 119 ++ .../corpus/sql/types/list/unnest_types.test | 33 + .../corpus/sql/types/map/map_cast.test | 45 + .../map/map_const_and_col_combination.test | 125 ++ .../corpus/sql/types/map/map_empty.test | 9 + .../types/map/map_extract_nested_null.test | 17 + .../corpus/sql/types/map/map_null.test | 51 + .../types/nested/array/array_aggregate.test | 29 + .../sql/types/nested/array/array_cast.test | 141 +++ .../types/nested/array/array_coverage.test | 29 + .../nested/array/array_fuzzer_failures.test | 17 + .../sql/types/nested/array/array_invalid.test | 45 + .../array/array_invalid.test.metadata.json | 6 + .../sql/types/nested/array/array_joins.test | 72 ++ .../sql/types/nested/array/array_joins_2.test | 29 + .../sql/types/nested/array/array_large.test | 49 + .../nested/array/array_limit_offset.test | 21 + .../types/nested/array/array_list_agg.test | 29 + .../nested/array/array_list_aggregate.test | 17 + .../sql/types/nested/array/array_misc.test | 71 ++ .../nested/array/array_roundtrip_csv.test | 21 + .../nested/array/array_roundtrip_json.test | 17 + .../nested/array/array_roundtrip_parquet.test | 13 + .../types/nested/array/array_rowgroup.test | 17 + .../sql/types/nested/array/array_simple.test | 64 + .../types/nested/array/array_statistics.test | 13 + .../types/nested/array/array_storage_3.test | 29 + .../types/nested/array/array_summarize.test | 25 + .../types/nested/array/array_try_cast.test | 65 + .../array/array_try_cast_vector_types.test | 13 + .../types/nested/array/array_tupleformat.test | 80 ++ .../sql/types/nested/array/array_unnest.test | 37 + .../sql/types/nested/list/any_list.test | 85 ++ .../corpus/sql/types/nested/list/array.test | 65 + .../sql/types/nested/list/array_agg.test | 62 + .../nested/list/internal_issue_2457.test | 29 + .../nested/list/list_aggr_parameter.test | 37 + .../nested/list/list_aggregate_dict.test | 29 + .../types/nested/list/list_aggregates.test | 69 ++ .../sql/types/nested/list/list_subquery.test | 29 + .../types/nested/list/test_list_extract.test | 205 ++++ ...test_list_functions_with_null_structs.test | 129 ++ .../types/nested/list/test_list_index.test | 73 ++ .../types/nested/list/test_list_slice.test | 178 +++ .../list/test_list_slice_negative_step.test | 75 ++ .../list/test_list_slice_numeric_limits.test | 77 ++ .../nested/list/test_list_slice_step.test | 221 ++++ .../types/nested/list/test_nested_list.test | 185 +++ .../types/nested/list/test_scalar_list.test | 89 ++ .../sql/types/nested/map/map_error.test | 89 ++ .../nested/map/map_from_entries/column.test | 29 + .../map_from_entries/column_null_entry.test | 13 + .../map/map_from_entries/data_types.test | 261 ++++ .../map_from_entries/dictionary_vector.test | 25 + .../nested/map/map_from_entries/empty.test | 9 + .../nested/map/map_from_entries/invalid.test | 29 + .../nested/map/map_from_entries/nested.test | 37 + .../nested/map/map_from_entries/null.test | 34 + .../map/map_from_entries/null_entry.test | 27 + .../corpus/sql/types/nested/map/test_map.test | 41 + .../nested/map/test_map_and_lambdas.test | 13 + .../nested/map/test_map_cardinality.test | 45 + .../sql/types/nested/map/test_map_concat.test | 149 +++ .../types/nested/map/test_map_constant.test | 29 + .../types/nested/map/test_map_contains.test | 77 ++ .../types/nested/map/test_map_entries.test | 54 + .../sql/types/nested/map/test_map_keys.test | 108 ++ .../nested/map/test_map_nested_keys.test | 124 ++ .../types/nested/map/test_map_subscript.test | 191 +++ .../map/test_map_subscript_composite.test | 113 ++ .../map/test_map_subscript_from_column.test | 41 + .../map/test_map_subscript_vector_types.test | 67 ++ .../nested/map/test_map_subscript_where.test | 38 + .../sql/types/nested/map/test_map_values.test | 69 ++ .../nested/map/test_map_vector_types.test | 84 ++ .../nested/map/test_null_map_interaction.test | 45 + .../sql/types/nested/nested_nested_types.test | 21 + .../nested/struct/struct_aggregates.test | 38 + .../struct/struct_aggregates_types.test | 53 + .../sql/types/nested/struct/struct_dict.test | 37 + .../types/nested/struct/struct_is_null.test | 17 + .../nested/struct/struct_of_lists_where.test | 21 + .../types/nested/struct/struct_subquery.test | 17 + .../sql/types/nested/struct/test_struct.test | 129 ++ .../types/nested/struct/test_struct_keys.test | 77 ++ .../nested/struct/test_struct_values.test | 93 ++ .../sql/types/nested/unnest_range_plan.test | 12 + .../sql/types/null/test_boolean_null.test | 73 ++ .../corpus/sql/types/null/test_is_null.test | 17 + .../corpus/sql/types/null/test_null.test | 45 + .../corpus/sql/types/null/test_null_aggr.test | 21 + .../corpus/sql/types/null/test_null_cast.test | 9 + .../numeric/arithmetic_vector_types.test | 9 + .../sql/types/numeric/bigint_try_cast.test | 149 +++ .../corpus/sql/types/numeric/bool_casts.test | 21 + .../combinations/decimal_combinations.test | 57 + .../combinations/usmallint_combinations.test | 21 + .../combinations/utinyint_combinations.test | 25 + .../sql/types/numeric/hugeint_try_cast.test | 149 +++ .../sql/types/numeric/integer_try_cast.test | 149 +++ .../sql/types/numeric/smallint_try_cast.test | 149 +++ .../sql/types/numeric/test_empty_numeric.test | 21 + .../sql/types/numeric/tinyint_try_cast.test | 149 +++ .../numeric/ubigint_arithmetic_casting.test | 17 + .../sql/types/numeric/ubigint_try_cast.test | 133 +++ .../sql/types/numeric/uhugeint_try_cast.test | 133 +++ .../sql/types/numeric/uinteger_try_cast.test | 129 ++ .../sql/types/numeric/usmallint_try_cast.test | 125 ++ .../sql/types/numeric/utinyint_try_cast.test | 121 ++ .../sql/types/string/test_big_strings.test | 17 + .../corpus/sql/types/string/test_unicode.test | 41 + .../struct/create_qualified_type_array.test | 89 ++ .../sql/types/struct/create_type_struct.test | 37 + .../corpus/sql/types/struct/empty_struct.test | 101 ++ .../types/struct/inet_struct_comparison.test | 35 + .../nested_struct_projection_pushdown.test | 152 +++ .../sql/types/struct/nested_structs.test | 55 + .../corpus/sql/types/struct/remap_struct.test | 170 +++ .../types/struct/remap_struct_in_list.test | 64 + .../sql/types/struct/remap_struct_in_map.test | 136 +++ .../struct/remap_struct_list_source_name.test | 57 + .../sql/types/struct/remap_struct_size.test | 39 + .../corpus/sql/types/struct/struct_case.test | 53 + .../struct/struct_case_insensitivity.test | 41 + .../corpus/sql/types/struct/struct_cast.test | 120 ++ .../types/struct/struct_cast_superset.test | 38 + .../sql/types/struct/struct_comparison.test | 696 +++++++++++ .../sql/types/struct/struct_concat.test | 65 + .../sql/types/struct/struct_contains.test | 161 +++ .../types/struct/struct_cross_product.test | 13 + .../types/struct/struct_different_names.test | 97 ++ .../sql/types/struct/struct_distinct.test | 218 ++++ .../sql/types/struct/struct_equality_bug.test | 13 + .../corpus/sql/types/struct/struct_index.test | 54 + .../sql/types/struct/struct_named_cast.test | 25 + .../sql/types/struct/struct_null_members.test | 113 ++ .../sql/types/struct/struct_operations.test | 41 + .../sql/types/struct/struct_pack_list.test | 25 + .../sql/types/struct/struct_position.test | 181 +++ .../struct/struct_projection_pushdown.test | 94 ++ ...struct_projection_pushdown_in_storage.test | 41 + ...uct_projection_pushdown_optimizer_bug.test | 36 + .../struct_projection_pushdown_unnamed.test | 21 + .../corpus/sql/types/struct/struct_stats.test | 29 + .../sql/types/struct/struct_subquery.test | 13 + .../sql/types/struct/struct_tables.test | 21 + .../types/struct/struct_unnest_recursion.test | 13 + .../sql/types/struct/struct_updates.test | 29 + .../corpus/sql/types/struct/test_tuple.test | 141 +++ .../types/struct/unnamed_struct_casts.test | 13 + .../struct/unnamed_struct_comparison.test | 50 + .../sql/types/struct/unnamed_struct_mix.test | 13 + .../sql/types/struct/unnest_column_names.test | 69 ++ .../sql/types/struct/unnest_struct.test | 85 ++ .../sql/types/struct/unnest_struct_mix.test | 73 ++ .../types/struct/unnest_struct_subquery.test | 17 + .../sql/types/struct/update_empty_row.test | 9 + .../update_empty_row.test.metadata.json | 5 + .../corpus/sql/types/test_date_cast.test | 22 + .../corpus/sql/types/test_null_type.test | 77 ++ .../sql/types/test_qualified_type_cast.test | 33 + .../corpus/sql/types/test_quotes.test | 120 ++ .../corpus/sql/types/test_typeof.test | 9 + .../types/test_user_type_errors_18452.test | 21 + ..._user_type_errors_18452.test.metadata.json | 5 + .../corpus/sql/types/time/test_time.test | 53 + .../corpus/sql/types/time/test_time_2411.test | 13 + .../corpus/sql/types/time/test_time_ns.test | 136 +++ .../corpus/sql/types/time/test_time_tz.test | 95 ++ .../sql/types/time/test_time_tz_collate.test | 55 + .../sql/types/time/test_time_tz_icu.test | 66 ++ .../corpus/sql/types/time/time_limits.test | 37 + .../corpus/sql/types/time/time_parsing.test | 73 ++ .../corpus/sql/types/time/time_try_cast.test | 69 ++ .../alternative_timestamp_casts.test | 67 ++ .../sql/types/timestamp/bc_timestamp.test | 17 + .../timestamp/infinity_cast_coverage.test | 9 + .../timestamp/test_incorrect_timestamp.test | 65 + .../types/timestamp/test_infinite_time.test | 219 ++++ .../sql/types/timestamp/test_timestamp.test | 117 ++ .../types/timestamp/test_timestamp_2411.test | 25 + .../test_timestamp_auto_casting.test | 38 + .../types/timestamp/test_timestamp_ms.test | 13 + .../timestamp/test_timestamp_to_tz_cast.test | 69 ++ .../types/timestamp/test_timestamp_types.test | 180 +++ .../types/timestamp/test_timestamp_tz.test | 21 + .../sql/types/timestamp/timestamp_limits.test | 97 ++ .../types/timestamp/timestamp_precision.test | 46 + .../timestamp_precision.test.metadata.json | 6 + .../timestamp/timestamp_timezone_cast.test | 41 + .../types/timestamp/timestamp_try_cast.test | 89 ++ .../sql/types/timestamp/utc_offset.test | 49 + .../sql/types/type/test_make_get_type.test | 29 + .../sql/types/type/test_type_storage.test | 9 + .../corpus/sql/types/type_literal.test | 52 + .../uhugeint/test_uhugeint_aggregates.test | 13 + .../uhugeint/test_uhugeint_arithmetic.test | 129 ++ .../uhugeint/test_uhugeint_auto_cast.test | 21 + .../uhugeint/test_uhugeint_conversion.test | 105 ++ .../uhugeint/test_uhugeint_exponent.test | 37 + .../uhugeint/test_uhugeint_functions.test | 33 + .../uhugeint/test_uhugeint_null_value.test | 13 + .../sql/types/uhugeint/test_uhugeint_ops.test | 58 + .../sql/types/uhugeint/uhugeint_literal.test | 21 + .../sql/types/uhugeint/uhugeint_multiply.test | 125 ++ .../sql/types/uhugeint/uhugeint_try_cast.test | 29 + .../sql/types/union/struct_to_json_union.test | 49 + .../sql/types/union/struct_to_union.test | 87 ++ .../sql/types/union/union_aggregate.test | 37 + .../sql/types/union/union_ambiguous.test | 77 ++ .../corpus/sql/types/union/union_cast.test | 158 +++ .../corpus/sql/types/union/union_compare.test | 39 + .../corpus/sql/types/union/union_extract.test | 97 ++ .../corpus/sql/types/union/union_join.test | 74 ++ .../sql/types/union/union_limit_offset.test | 17 + .../corpus/sql/types/union/union_limits.test | 95 ++ .../corpus/sql/types/union/union_list.test | 72 ++ .../corpus/sql/types/union/union_sort.test | 57 + .../corpus/sql/types/union/union_struct.test | 53 + .../corpus/sql/types/union/union_tag.test | 57 + .../corpus/sql/types/union/union_test.test | 57 + .../sql/types/union/union_validity.test | 17 + .../corpus/sql/types/union/union_value.test | 68 ++ .../unsigned/test_unsigned_arithmetic.test | 81 ++ .../unsigned/test_unsigned_auto_cast.test | 149 +++ .../unsigned/test_unsigned_conversion.test | 365 ++++++ .../types/unsigned/test_unsigned_verify.test | 17 + .../corpus/sql/types/uuid/test_uuid_cast.test | 45 + .../types/uuid/test_uuid_uhugeint_cast.test | 53 + .../variant/implicit_cast_from_variant.test | 220 ++++ .../corpus/sql/types/variant/json_cast.test | 152 +++ .../sql/types/variant/test_all_types.test | 21 + .../corpus/sql/types/variant/tpch_test.test | 21 + .../types/variant/tpch_test_through_json.test | 13 + .../types/variant/try_cast_from_variant.test | 81 ++ .../sql/types/variant/variant_cast_stats.test | 91 ++ .../sql/types/variant/variant_casts.test | 29 + .../sql/types/variant/variant_distinct.test | 466 ++++++++ .../variant_map_to_variant_filter.test | 21 + .../sql/update/compact_update_allocation.test | 270 +++++ .../force_update_to_del_and_insert.test | 37 + .../corpus/sql/update/issue_22392.test | 25 + .../corpus/sql/update/null_update_merge.test | 53 + .../update/null_update_merge_transaction.test | 9 + .../sql/update/string_update_null_heap.test | 17 + .../string_update_transaction_local_7348.test | 29 + .../sql/update/test_big_string_update.test | 21 + .../sql/update/test_cascading_updates.test | 33 + .../sql/update/test_multiple_assignment.test | 45 + ...est_multiple_assignment.test.metadata.json | 7 + .../corpus/sql/update/test_null_update.test | 21 + .../update/test_repeated_string_update.test | 17 + .../test_stress_update_issue_19688.test | 40 + .../corpus/sql/update/test_string_update.test | 13 + .../test_string_update_many_strings.test | 17 + .../sql/update/test_string_update_null.test | 9 + .../update/test_string_update_rollback.test | 9 + .../test_string_update_rollback_null.test | 17 + .../corpus/sql/update/test_update.test | 21 + .../update/test_update_delete_same_tuple.test | 17 + .../corpus/sql/update/test_update_from.test | 113 ++ .../sql/update/test_update_issue_3170.test | 61 + .../sql/update/test_update_many_updaters.test | 45 + .../test_update_many_updaters_nulls.test | 17 + .../corpus/sql/update/test_update_mix.test | 13 + .../sql/update/test_update_same_value.test | 25 + .../test_update_with_non_regular_type.test | 45 + .../sql/update/update_after_commit.test | 17 + .../corpus/sql/update/update_default.test | 9 + .../corpus/sql/update/update_delete_wal.test | 29 + .../sql/update/update_error_suggestions.test | 17 + ...pdate_error_suggestions.test.metadata.json | 5 + .../sql/update/update_from_multi_match.test | 249 ++++ .../corpus/sql/update/update_join_nulls.test | 20 + .../sql/update/update_null_integers.test | 21 + .../corpus/sql/update/update_query_node.test | 50 + .../update_string_null_merge_dict_fsst.test | 25 + .../upsert/concurrent_insert_or_replace.test | 30 + .../issue_20952_non_pk_index_column.test | 107 ++ .../pk_and_non_unique_index.test | 22 + .../upsert/insert_or_replace/returning.test | 24 + .../insert_or_replace/returning_nothing.test | 26 + .../unique_and_non_unique_index.test | 21 + .../insert_or_replace/unique_constraint.test | 28 + .../insert_or_replace/unique_index.test | 21 + .../upsert/minimal_reproducable_example.test | 21 + .../corpus/sql/upsert/no_complex_default.test | 13 + .../sql/upsert/postgres/composite_key.test | 99 ++ .../non_spurious_duplicate_violation.test | 35 + .../postgres/planner_preprocessing.test | 167 +++ .../sql/upsert/postgres/single_key.test | 86 ++ .../corpus/sql/upsert/test_big_insert.test | 74 ++ ...est_big_insert_no_vector_verification.test | 13 + .../sql/upsert/test_generated_column.test | 37 + ...est_problematic_conditional_do_update.test | 37 + .../corpus/sql/upsert/upsert_aliased.test | 48 + .../corpus/sql/upsert/upsert_basic.test | 117 ++ .../sql/upsert/upsert_conflict_target.test | 33 + .../upsert/upsert_conflict_target_index.test | 32 + .../corpus/sql/upsert/upsert_coverage.test | 26 + .../corpus/sql/upsert/upsert_default.test | 77 ++ .../upsert/upsert_default_expressions.test | 28 + .../upsert_default_value_causes_conflict.test | 24 + .../sql/upsert/upsert_default_values.test | 16 + .../sql/upsert/upsert_distinct_bug.test | 41 + .../sql/upsert/upsert_duplicates_issue.test | 17 + .../upsert/upsert_excluded_references.test | 36 + .../sql/upsert/upsert_explicit_index.test | 53 + .../upsert/upsert_global_mixed_conflicts.test | 35 + .../upsert_inner_conflict_do_nothing.test | 19 + .../corpus/sql/upsert/upsert_lambda.test | 62 + .../sql/upsert/upsert_local_no_tuples.test | 32 + .../upsert/upsert_multiple_constraints.test | 17 + .../sql/upsert/upsert_order_coverage.test | 29 + .../sql/upsert/upsert_partial_update.test | 17 + .../corpus/sql/upsert/upsert_returning.test | 58 + .../sql/upsert/upsert_set_expressions.test | 20 + .../corpus/sql/upsert/upsert_shorthand.test | 37 + .../upsert_shorthand.test.metadata.json | 5 + .../corpus/sql/upsert/upsert_transaction.test | 80 ++ .../corpus/sql/upsert/upsert_unique_null.test | 20 + .../corpus/sql/vacuum/test_analyze.test | 73 ++ .../sql/vacuum/vacuum_nested_types.test | 13 + .../sql/variables/test_variable_syntax.test | 153 +++ .../corpus/sql/variables/test_variables.test | 61 + .../sql/variant/variant_comparator.test | 182 +++ .../sql/vector_types/list_vector_types.test | 65 + .../sql/vector_types/vector_types_errors.test | 13 + .../corpus/sql/window/test_basic_window.test | 114 ++ .../corpus/sql/window/test_boundary_expr.test | 119 ++ .../sql/window/test_constant_orderby.test | 17 + .../sql/window/test_cume_dist_orderby.test | 59 + .../corpus/sql/window/test_dense_rank.test | 189 +++ .../sql/window/test_duplicate_partition.test | 45 + .../corpus/sql/window/test_empty_frames.test | 133 +++ .../corpus/sql/window/test_evil_window.test | 41 + .../corpus/sql/window/test_fill_orderby.test | 257 ++++ .../corpus/sql/window/test_ignore_nulls.test | 264 +++++ .../sql/window/test_invalid_window.test | 84 ++ .../test_invalid_window.test.metadata.json | 6 + .../corpus/sql/window/test_lead_lag.test | 119 ++ .../sql/window/test_leadlag_orderby.test | 64 + .../corpus/sql/window/test_list_window.test | 49 + .../corpus/sql/window/test_mad_window.test | 63 + .../corpus/sql/window/test_mode_window.test | 66 ++ .../sql/window/test_naive_aggregation.test | 142 +++ .../sql/window/test_negative_range.test | 53 + .../window/test_no_default_window_spec.test | 33 + .../corpus/sql/window/test_nthvalue.test | 117 ++ .../corpus/sql/window/test_ntile.test | 151 +++ .../corpus/sql/window/test_order_by_all.test | 25 + .../test_order_by_all.test.metadata.json | 5 + .../sql/window/test_quantile_window.test | 215 ++++ .../sql/window/test_range_optimisation.test | 41 + .../testdata/corpus/sql/window/test_rank.test | 40 + .../corpus/sql/window/test_rank_orderby.test | 76 ++ .../sql/window/test_rownumber_orderby.test | 18 + .../corpus/sql/window/test_scalar_window.test | 33 + .../test_scalar_window.test.metadata.json | 6 + .../sql/window/test_split_partition_heap.test | 13 + .../sql/window/test_streaming_lead_lag.test | 152 +++ .../sql/window/test_streaming_nthvalue.test | 47 + .../sql/window/test_streaming_window.test | 421 +++++++ .../test_streaming_window_distinct.test | 44 + .../corpus/sql/window/test_thread_count.test | 18 + .../corpus/sql/window/test_tpcc_results.test | 24 + .../corpus/sql/window/test_tpcds_q49.test | 17 + .../corpus/sql/window/test_value_exclude.test | 39 + .../corpus/sql/window/test_value_orderby.test | 91 ++ .../window/test_volatile_independence.test | 21 + .../corpus/sql/window/test_wide_orderby.test | 27 + .../window/test_window_aggregate_macro.test | 27 + .../sql/window/test_window_binding.test | 29 + .../sql/window/test_window_binding_ctes.test | 53 + ...est_window_binding_ctes.test.metadata.json | 6 + .../corpus/sql/window/test_window_bool.test | 37 + .../corpus/sql/window/test_window_clause.test | 111 ++ .../test_window_clause.test.metadata.json | 10 + .../test_window_constant_aggregate.test | 190 +++ .../test_window_constant_allocator.test | 26 + .../corpus/sql/window/test_window_cse.test | 53 + .../corpus/sql/window/test_window_dbplyr.test | 25 + .../sql/window/test_window_distinct.test | 171 +++ .../corpus/sql/window/test_window_filter.test | 86 ++ .../sql/window/test_window_finalize_race.test | 43 + .../corpus/sql/window/test_window_fusion.test | 179 +++ .../sql/window/test_window_interval.test | 15 + .../sql/window/test_window_order_collate.test | 67 ++ .../corpus/sql/window/test_window_rows.test | 344 ++++++ .../sql/window/test_window_string_agg.test | 21 + .../corpus/sql/window/test_window_tpcds.test | 53 + .../corpus/sql/window/test_window_types.test | 9 + .../sql/window/test_window_unnest_error.test | 41 + .../sql/window/test_window_wisconsin.test | 89 ++ .../corpus/sql/window/window_mtcars.test | 145 +++ token/keywords_test.go | 8 +- 4225 files changed, 234902 insertions(+), 43 deletions(-) create mode 100644 .gitignore create mode 100644 cmd/next-test/main.go create mode 100644 cmd/regenerate/main.go create mode 100644 internal/duckdbsrc/duckdbsrc.go create mode 100644 internal/sqltest/sqltest.go create mode 100644 internal/sqltest/sqltest_test.go create mode 100644 internal/testfile/testfile.go create mode 100644 internal/testfile/testfile_test.go create mode 100644 parser/parser_test.go create mode 100644 parser/testdata/README.md create mode 100644 parser/testdata/corpus/fuzzer/afl/alter_if_exists.test create mode 100644 parser/testdata/corpus/fuzzer/afl/analyze_empty_table.test create mode 100644 parser/testdata/corpus/fuzzer/afl/case_map_cast.test create mode 100644 parser/testdata/corpus/fuzzer/afl/decimal_string_roundtrip.test create mode 100644 parser/testdata/corpus/fuzzer/afl/generate_series_null.test create mode 100644 parser/testdata/corpus/fuzzer/afl/grouping_empty_table.test create mode 100644 parser/testdata/corpus/fuzzer/afl/invalid_foreign_key.test create mode 100644 parser/testdata/corpus/fuzzer/afl/issue_7551.test create mode 100644 parser/testdata/corpus/fuzzer/afl/issue_8185.test create mode 100644 parser/testdata/corpus/fuzzer/afl/limit_out_of_range.test create mode 100644 parser/testdata/corpus/fuzzer/afl/non_foldable_parameter.test create mode 100644 parser/testdata/corpus/fuzzer/afl/random_join.test create mode 100644 parser/testdata/corpus/fuzzer/afl/self_referential_alias.test create mode 100644 parser/testdata/corpus/fuzzer/afl/window_function_binder_error.test create mode 100644 parser/testdata/corpus/fuzzer/afl/window_type_mismatch.test create mode 100644 parser/testdata/corpus/fuzzer/duckfuzz/arg_minmax_by_decimal.test create mode 100644 parser/testdata/corpus/fuzzer/duckfuzz/array_const_columndatacopy.test create mode 100644 parser/testdata/corpus/fuzzer/duckfuzz/array_const_null_cast.test create mode 100644 parser/testdata/corpus/fuzzer/duckfuzz/array_distance.test create mode 100644 parser/testdata/corpus/fuzzer/duckfuzz/array_group_by_sample.test create mode 100644 parser/testdata/corpus/fuzzer/duckfuzz/array_hash.test create mode 100644 parser/testdata/corpus/fuzzer/duckfuzz/array_list_gather_cast.test create mode 100644 parser/testdata/corpus/fuzzer/duckfuzz/array_serialization_flattening.test create mode 100644 parser/testdata/corpus/fuzzer/duckfuzz/array_slice_nullness.test create mode 100644 parser/testdata/corpus/fuzzer/duckfuzz/array_slice_underflow.test create mode 100644 parser/testdata/corpus/fuzzer/duckfuzz/array_slice_vector_type.test create mode 100644 parser/testdata/corpus/fuzzer/duckfuzz/arrow_scan_subquery_nullptr.test create mode 100644 parser/testdata/corpus/fuzzer/duckfuzz/bitstring_agg_minmax.test create mode 100644 parser/testdata/corpus/fuzzer/duckfuzz/bitstring_agg_uhugeint.test create mode 100644 parser/testdata/corpus/fuzzer/duckfuzz/bitstring_agg_unfoldable.test create mode 100644 parser/testdata/corpus/fuzzer/duckfuzz/column_alias_exist.test create mode 100644 parser/testdata/corpus/fuzzer/duckfuzz/complex_join_cardinality_assert.test create mode 100644 parser/testdata/corpus/fuzzer/duckfuzz/compressed_materialization_hugeint.test create mode 100644 parser/testdata/corpus/fuzzer/duckfuzz/compressed_materialization_json.test create mode 100644 parser/testdata/corpus/fuzzer/duckfuzz/correlated_subqueries.test create mode 100644 parser/testdata/corpus/fuzzer/duckfuzz/corrupted_parquet.test create mode 100644 parser/testdata/corpus/fuzzer/duckfuzz/create_sort_key_strings.test create mode 100644 parser/testdata/corpus/fuzzer/duckfuzz/duck_fuzz_column_binding_tests.test create mode 100644 parser/testdata/corpus/fuzzer/duckfuzz/duckdb_fuzzer_4430.test create mode 100644 parser/testdata/corpus/fuzzer/duckfuzz/empty_result_pullup_delim_joins.test create mode 100644 parser/testdata/corpus/fuzzer/duckfuzz/enum_const_cast.test create mode 100644 parser/testdata/corpus/fuzzer/duckfuzz/filter_combiner_assert.test create mode 100644 parser/testdata/corpus/fuzzer/duckfuzz/fuzzer_issue_2698.test create mode 100644 parser/testdata/corpus/fuzzer/duckfuzz/fuzzer_issue_2980.test create mode 100644 parser/testdata/corpus/fuzzer/duckfuzz/fuzzer_issue_4325.test create mode 100644 parser/testdata/corpus/fuzzer/duckfuzz/generate_null_timestamp.test create mode 100644 parser/testdata/corpus/fuzzer/duckfuzz/group_by_all_positional_ref.test create mode 100644 parser/testdata/corpus/fuzzer/duckfuzz/hash_constant.test create mode 100644 parser/testdata/corpus/fuzzer/duckfuzz/having_window_bind.test create mode 100644 parser/testdata/corpus/fuzzer/duckfuzz/hugeint_negate_underflow.test create mode 100644 parser/testdata/corpus/fuzzer/duckfuzz/invalid_make_time.test create mode 100644 parser/testdata/corpus/fuzzer/duckfuzz/json_execute_serialized_null.test create mode 100644 parser/testdata/corpus/fuzzer/duckfuzz/json_extract_null.test create mode 100644 parser/testdata/corpus/fuzzer/duckfuzz/json_extract_string_null.test create mode 100644 parser/testdata/corpus/fuzzer/duckfuzz/json_functions_null_params.test create mode 100644 parser/testdata/corpus/fuzzer/duckfuzz/julian_overflow.test create mode 100644 parser/testdata/corpus/fuzzer/duckfuzz/late_materialization_filter.test create mode 100644 parser/testdata/corpus/fuzzer/duckfuzz/limit_offset_macro_subquery.test create mode 100644 parser/testdata/corpus/fuzzer/duckfuzz/limit_percent_subquery.test create mode 100644 parser/testdata/corpus/fuzzer/duckfuzz/list_try_cast.test create mode 100644 parser/testdata/corpus/fuzzer/duckfuzz/list_zip_no_args.test create mode 100644 parser/testdata/corpus/fuzzer/duckfuzz/logger_null.test create mode 100644 parser/testdata/corpus/fuzzer/duckfuzz/map_concat_type_mismatch.test create mode 100644 parser/testdata/corpus/fuzzer/duckfuzz/null_arguments.test create mode 100644 parser/testdata/corpus/fuzzer/duckfuzz/null_arguments.test.metadata.json create mode 100644 parser/testdata/corpus/fuzzer/duckfuzz/null_checkpoint.test create mode 100644 parser/testdata/corpus/fuzzer/duckfuzz/ordagg_nargs.test create mode 100644 parser/testdata/corpus/fuzzer/duckfuzz/order_by_positional_reference.test create mode 100644 parser/testdata/corpus/fuzzer/duckfuzz/pivot_aggregate_mismatch.test create mode 100644 parser/testdata/corpus/fuzzer/duckfuzz/qualify_column_reference.test create mode 100644 parser/testdata/corpus/fuzzer/duckfuzz/read_ndjson_non_varchar_input.test create mode 100644 parser/testdata/corpus/fuzzer/duckfuzz/regex_syntax_2889.test create mode 100644 parser/testdata/corpus/fuzzer/duckfuzz/regex_syntax_2889.test.metadata.json create mode 100644 parser/testdata/corpus/fuzzer/duckfuzz/regexp_replace_constant.test create mode 100644 parser/testdata/corpus/fuzzer/duckfuzz/repeat_row_null.test create mode 100644 parser/testdata/corpus/fuzzer/duckfuzz/repeat_wrong_number.test create mode 100644 parser/testdata/corpus/fuzzer/duckfuzz/semi_join_has_correct_left_right_relations.test create mode 100644 parser/testdata/corpus/fuzzer/duckfuzz/string_to_nested_cast_sample.test create mode 100644 parser/testdata/corpus/fuzzer/duckfuzz/strptime_const_arg.test create mode 100644 parser/testdata/corpus/fuzzer/duckfuzz/temporal_avg.test create mode 100644 parser/testdata/corpus/fuzzer/duckfuzz/test_vector_types_double_3.test create mode 100644 parser/testdata/corpus/fuzzer/duckfuzz/to_weeks_overflow.test create mode 100644 parser/testdata/corpus/fuzzer/duckfuzz/tuple_data_empty_heap.test create mode 100644 parser/testdata/corpus/fuzzer/duckfuzz/union_dict_tag.test create mode 100644 parser/testdata/corpus/fuzzer/duckfuzz/unpivot_multiple_in.test create mode 100644 parser/testdata/corpus/fuzzer/duckfuzz/unpivot_multiple_in.test.metadata.json create mode 100644 parser/testdata/corpus/fuzzer/duckfuzz/vector_size_out_of_range.test create mode 100644 parser/testdata/corpus/fuzzer/duckfuzz/vector_type.test create mode 100644 parser/testdata/corpus/fuzzer/duckfuzz/visit_operator_expressions_in_column_lifetime_analyzer.test create mode 100644 parser/testdata/corpus/fuzzer/duckfuzz/window_expression_equality.test create mode 100644 parser/testdata/corpus/fuzzer/duckfuzz/window_negate_stats.test create mode 100644 parser/testdata/corpus/fuzzer/duckfuzz/window_null_range.test create mode 100644 parser/testdata/corpus/fuzzer/duckfuzz/window_order_bind_failure.test create mode 100644 parser/testdata/corpus/fuzzer/fuzz_not_operator.test create mode 100644 parser/testdata/corpus/fuzzer/fuzz_not_unpacked_columns.test create mode 100644 parser/testdata/corpus/fuzzer/issue4298.test create mode 100644 parser/testdata/corpus/fuzzer/nthvalue_indexing.test create mode 100644 parser/testdata/corpus/fuzzer/pedro/C_C++_API_query_verification.test create mode 100644 parser/testdata/corpus/fuzzer/pedro/aggregate_assertion_errors.test create mode 100644 parser/testdata/corpus/fuzzer/pedro/alter_column_generated.test create mode 100644 parser/testdata/corpus/fuzzer/pedro/alter_dependencies.test create mode 100644 parser/testdata/corpus/fuzzer/pedro/alter_dependency_conflict.test create mode 100644 parser/testdata/corpus/fuzzer/pedro/alter_table_rowid.test create mode 100644 parser/testdata/corpus/fuzzer/pedro/alter_type_null_mix.test create mode 100644 parser/testdata/corpus/fuzzer/pedro/alter_virtual_column_segfault.test create mode 100644 parser/testdata/corpus/fuzzer/pedro/analyze_nonexistant.test create mode 100644 parser/testdata/corpus/fuzzer/pedro/another_binder_error.test create mode 100644 parser/testdata/corpus/fuzzer/pedro/art_concatenate_prefix.test create mode 100644 parser/testdata/corpus/fuzzer/pedro/art_prefix_error.test create mode 100644 parser/testdata/corpus/fuzzer/pedro/between_mark_reference.test create mode 100644 parser/testdata/corpus/fuzzer/pedro/between_type_mismatch.test create mode 100644 parser/testdata/corpus/fuzzer/pedro/binder_assertion_error.test create mode 100644 parser/testdata/corpus/fuzzer/pedro/binder_error_with_having_statement.test create mode 100644 parser/testdata/corpus/fuzzer/pedro/blob_wrong_optimization.test create mode 100644 parser/testdata/corpus/fuzzer/pedro/buffer_manager_out_of_memory.test create mode 100644 parser/testdata/corpus/fuzzer/pedro/buffer_manager_resize_issue.test create mode 100644 parser/testdata/corpus/fuzzer/pedro/cardinality_estimator_assertion_error.test create mode 100644 parser/testdata/corpus/fuzzer/pedro/cardinality_estimator_runtime_issue.test create mode 100644 parser/testdata/corpus/fuzzer/pedro/comparison_to_string.test create mode 100644 parser/testdata/corpus/fuzzer/pedro/complex_offset_clause_crash.test create mode 100644 parser/testdata/corpus/fuzzer/pedro/complex_type_all_subquery.test create mode 100644 parser/testdata/corpus/fuzzer/pedro/concurrent_catalog_usage.test create mode 100644 parser/testdata/corpus/fuzzer/pedro/concurrent_set_threads.test create mode 100644 parser/testdata/corpus/fuzzer/pedro/constraints_temp_table.test create mode 100644 parser/testdata/corpus/fuzzer/pedro/correlated_in_segv.test create mode 100644 parser/testdata/corpus/fuzzer/pedro/correlated_limit_rowid.test create mode 100644 parser/testdata/corpus/fuzzer/pedro/correlated_offset_subquery.test create mode 100644 parser/testdata/corpus/fuzzer/pedro/correlated_subquery_downcast_error.test create mode 100644 parser/testdata/corpus/fuzzer/pedro/create_index_error.test create mode 100644 parser/testdata/corpus/fuzzer/pedro/create_replace_table_union.test create mode 100644 parser/testdata/corpus/fuzzer/pedro/currval_sequence_dependency.test create mode 100644 parser/testdata/corpus/fuzzer/pedro/date_int_optimizer_error.test create mode 100644 parser/testdata/corpus/fuzzer/pedro/decimal_with_invalid_scale.test create mode 100644 parser/testdata/corpus/fuzzer/pedro/delete_add_column.test create mode 100644 parser/testdata/corpus/fuzzer/pedro/delete_using_bindings.test create mode 100644 parser/testdata/corpus/fuzzer/pedro/drop_gcol.test create mode 100644 parser/testdata/corpus/fuzzer/pedro/duplicate_cte.test create mode 100644 parser/testdata/corpus/fuzzer/pedro/duplicate_using_clause.test create mode 100644 parser/testdata/corpus/fuzzer/pedro/escaped_trim_function_call.test create mode 100644 parser/testdata/corpus/fuzzer/pedro/export_parquet_generated.test create mode 100644 parser/testdata/corpus/fuzzer/pedro/first_value_window_crash.test create mode 100644 parser/testdata/corpus/fuzzer/pedro/floating_point_conversion_overflow.test create mode 100644 parser/testdata/corpus/fuzzer/pedro/floating_point_inequality.test create mode 100644 parser/testdata/corpus/fuzzer/pedro/force_external_blob.test create mode 100644 parser/testdata/corpus/fuzzer/pedro/force_no_cross_product.test create mode 100644 parser/testdata/corpus/fuzzer/pedro/forced_parallelism_empty_select.test create mode 100644 parser/testdata/corpus/fuzzer/pedro/foreign_key_binding_issue.test create mode 100644 parser/testdata/corpus/fuzzer/pedro/foreign_key_binding_issue.test.metadata.json create mode 100644 parser/testdata/corpus/fuzzer/pedro/foreign_key_type_mismatch.test create mode 100644 parser/testdata/corpus/fuzzer/pedro/gcol_stack_overflow.test create mode 100644 parser/testdata/corpus/fuzzer/pedro/group_by_all_row_alias.test create mode 100644 parser/testdata/corpus/fuzzer/pedro/hash_finalize_race.test create mode 100644 parser/testdata/corpus/fuzzer/pedro/having_query_wrong_result.test create mode 100644 parser/testdata/corpus/fuzzer/pedro/having_subquery_failed_to_bind.test create mode 100644 parser/testdata/corpus/fuzzer/pedro/in_clause_optimization_error.test create mode 100644 parser/testdata/corpus/fuzzer/pedro/in_clause_setop_rewrite.test create mode 100644 parser/testdata/corpus/fuzzer/pedro/incomplete_checkpoint.test create mode 100644 parser/testdata/corpus/fuzzer/pedro/incorrect_offset_result.test create mode 100644 parser/testdata/corpus/fuzzer/pedro/index_current_timestamp.test create mode 100644 parser/testdata/corpus/fuzzer/pedro/index_generated_column.test create mode 100644 parser/testdata/corpus/fuzzer/pedro/index_insert_from_union.test create mode 100644 parser/testdata/corpus/fuzzer/pedro/index_not_updated_returning.test create mode 100644 parser/testdata/corpus/fuzzer/pedro/index_on_altered_table.test create mode 100644 parser/testdata/corpus/fuzzer/pedro/insert_or_replace_only_pk.test create mode 100644 parser/testdata/corpus/fuzzer/pedro/intersect_correlated_subquery.test create mode 100644 parser/testdata/corpus/fuzzer/pedro/intersect_empty_array.test create mode 100644 parser/testdata/corpus/fuzzer/pedro/is_distinct_from_validation.test create mode 100644 parser/testdata/corpus/fuzzer/pedro/lag_window_function.test create mode 100644 parser/testdata/corpus/fuzzer/pedro/last_memory_leak.test create mode 100644 parser/testdata/corpus/fuzzer/pedro/lateral_join.test create mode 100644 parser/testdata/corpus/fuzzer/pedro/like_empty_list.test create mode 100644 parser/testdata/corpus/fuzzer/pedro/limit_on_any_subquery.test create mode 100644 parser/testdata/corpus/fuzzer/pedro/local_transaction_delete_empty_tree.test create mode 100644 parser/testdata/corpus/fuzzer/pedro/logical_column_index_out_of_range.test create mode 100644 parser/testdata/corpus/fuzzer/pedro/missing_subquery_error.test create mode 100644 parser/testdata/corpus/fuzzer/pedro/multiplication_verification.test create mode 100644 parser/testdata/corpus/fuzzer/pedro/nan_as_seed.test create mode 100644 parser/testdata/corpus/fuzzer/pedro/natural_join_generated_heap_overflow.test create mode 100644 parser/testdata/corpus/fuzzer/pedro/nested_limit_subquery.test create mode 100644 parser/testdata/corpus/fuzzer/pedro/nested_subquery_table_function.test create mode 100644 parser/testdata/corpus/fuzzer/pedro/non_boolean_aggregate_filter.test create mode 100644 parser/testdata/corpus/fuzzer/pedro/offset_query_allocator_assertion.test create mode 100644 parser/testdata/corpus/fuzzer/pedro/order_by_all_with_union.test create mode 100644 parser/testdata/corpus/fuzzer/pedro/overflow_parsing_interval.test create mode 100644 parser/testdata/corpus/fuzzer/pedro/overflow_varchar_decimal_cast.test create mode 100644 parser/testdata/corpus/fuzzer/pedro/parser_roundtrip.test create mode 100644 parser/testdata/corpus/fuzzer/pedro/prepared_statement_recursive_cte.test create mode 100644 parser/testdata/corpus/fuzzer/pedro/pushdown_assertion_error.test create mode 100644 parser/testdata/corpus/fuzzer/pedro/pushdown_error.test create mode 100644 parser/testdata/corpus/fuzzer/pedro/pushdown_simplification_overflow.test create mode 100644 parser/testdata/corpus/fuzzer/pedro/qualify_binder_error.test create mode 100644 parser/testdata/corpus/fuzzer/pedro/random_engine_use_after_free.test create mode 100644 parser/testdata/corpus/fuzzer/pedro/recursive_cte_dependent_join.test create mode 100644 parser/testdata/corpus/fuzzer/pedro/recursive_cte_limit_percent.test create mode 100644 parser/testdata/corpus/fuzzer/pedro/regr_count_validity.test create mode 100644 parser/testdata/corpus/fuzzer/pedro/rename_column_assertion.test create mode 100644 parser/testdata/corpus/fuzzer/pedro/rename_restart.test create mode 100644 parser/testdata/corpus/fuzzer/pedro/rename_table_index_rollback.test create mode 100644 parser/testdata/corpus/fuzzer/pedro/rename_table_index_storage.test create mode 100644 parser/testdata/corpus/fuzzer/pedro/restart_current_time.test create mode 100644 parser/testdata/corpus/fuzzer/pedro/restart_random.test create mode 100644 parser/testdata/corpus/fuzzer/pedro/returning_clause_sizes_not_match.test create mode 100644 parser/testdata/corpus/fuzzer/pedro/returning_clause_with_rowid.test create mode 100644 parser/testdata/corpus/fuzzer/pedro/rollup_wrong_result.test create mode 100644 parser/testdata/corpus/fuzzer/pedro/sample_limit_overflow.test create mode 100644 parser/testdata/corpus/fuzzer/pedro/segment_tree_index_issue.test create mode 100644 parser/testdata/corpus/fuzzer/pedro/setop_type_mismatch.test create mode 100644 parser/testdata/corpus/fuzzer/pedro/signed_and_unsigned_comparison.test create mode 100644 parser/testdata/corpus/fuzzer/pedro/statistics_propagation_set_op.test create mode 100644 parser/testdata/corpus/fuzzer/pedro/strftime_constant_null.test create mode 100644 parser/testdata/corpus/fuzzer/pedro/strptime_null_argument.test create mode 100644 parser/testdata/corpus/fuzzer/pedro/subquery_assertion_error.test create mode 100644 parser/testdata/corpus/fuzzer/pedro/temp_sequence_durability.test create mode 100644 parser/testdata/corpus/fuzzer/pedro/temp_sequence_reconnect.test create mode 100644 parser/testdata/corpus/fuzzer/pedro/temp_table_cleanup.test create mode 100644 parser/testdata/corpus/fuzzer/pedro/test_segv_argmax.test create mode 100644 parser/testdata/corpus/fuzzer/pedro/test_truncate_heap_use_after_free.test create mode 100644 parser/testdata/corpus/fuzzer/pedro/test_window_function_nullptr.test create mode 100644 parser/testdata/corpus/fuzzer/pedro/update_default_segv.test create mode 100644 parser/testdata/corpus/fuzzer/pedro/update_join_bind_error.test create mode 100644 parser/testdata/corpus/fuzzer/pedro/update_join_statistics.test create mode 100644 parser/testdata/corpus/fuzzer/pedro/utf8_invalid_unicode.test create mode 100644 parser/testdata/corpus/fuzzer/pedro/vacuum_table_with_generated_column.test create mode 100644 parser/testdata/corpus/fuzzer/pedro/vacuum_unsupported_type.test create mode 100644 parser/testdata/corpus/fuzzer/pedro/verify_parallelism_batch_index.test create mode 100644 parser/testdata/corpus/fuzzer/pedro/view_not_rebound_error.test create mode 100644 parser/testdata/corpus/fuzzer/pedro/wal_rename_table.test create mode 100644 parser/testdata/corpus/fuzzer/pedro/window_function_timeout.test create mode 100644 parser/testdata/corpus/fuzzer/pedro/window_self_reference.test create mode 100644 parser/testdata/corpus/fuzzer/pedro/window_self_reference.test.metadata.json create mode 100644 parser/testdata/corpus/fuzzer/public/cast_index_expression.test create mode 100644 parser/testdata/corpus/fuzzer/public/columns_using.test create mode 100644 parser/testdata/corpus/fuzzer/public/distinct_on_non_integer_literal.test create mode 100644 parser/testdata/corpus/fuzzer/public/duplicate_alias_using.test create mode 100644 parser/testdata/corpus/fuzzer/public/enum_empty_type.test create mode 100644 parser/testdata/corpus/fuzzer/public/insert_by_name_default.test create mode 100644 parser/testdata/corpus/fuzzer/public/insert_or_replace_default_values.test create mode 100644 parser/testdata/corpus/fuzzer/public/insert_returning.test create mode 100644 parser/testdata/corpus/fuzzer/public/lateral_in_right_side_of_join.test create mode 100644 parser/testdata/corpus/fuzzer/public/lateral_join_subquery.test create mode 100644 parser/testdata/corpus/fuzzer/public/lateral_right_join.test create mode 100644 parser/testdata/corpus/fuzzer/public/pivot_empty_enum.test create mode 100644 parser/testdata/corpus/fuzzer/public/pivot_full_join_using.test create mode 100644 parser/testdata/corpus/fuzzer/public/positional_join_correlated_subquery.test create mode 100644 parser/testdata/corpus/fuzzer/public/pragma_named_parameters.test create mode 100644 parser/testdata/corpus/fuzzer/public/pragma_named_parameters.test.metadata.json create mode 100644 parser/testdata/corpus/fuzzer/public/regex_range_filter_mismatch.test create mode 100644 parser/testdata/corpus/fuzzer/public/semi_anti_join_using.test create mode 100644 parser/testdata/corpus/fuzzer/public/semi_join_using.test create mode 100644 parser/testdata/corpus/fuzzer/public/unpivot_partial_values.test create mode 100644 parser/testdata/corpus/fuzzer/public/unsatisfiable_filter_prune.test create mode 100644 parser/testdata/corpus/fuzzer/public/window_subquery_error.test create mode 100644 parser/testdata/corpus/fuzzer/public/window_subquery_with_functions_error.test create mode 100644 parser/testdata/corpus/fuzzer/sqlsmith/bitstring_agg_executor.test create mode 100644 parser/testdata/corpus/fuzzer/sqlsmith/bitstring_agg_overflow.test create mode 100644 parser/testdata/corpus/fuzzer/sqlsmith/current_schemas_null.test create mode 100644 parser/testdata/corpus/fuzzer/sqlsmith/dayofweek_overflow.test create mode 100644 parser/testdata/corpus/fuzzer/sqlsmith/fuzzer_window_varchar.test create mode 100644 parser/testdata/corpus/fuzzer/sqlsmith/generate_series_overflow.test create mode 100644 parser/testdata/corpus/fuzzer/sqlsmith/interval_diff_overflow.test create mode 100644 parser/testdata/corpus/fuzzer/sqlsmith/interval_multiply_overflow.test create mode 100644 parser/testdata/corpus/fuzzer/sqlsmith/json_contains_null.test create mode 100644 parser/testdata/corpus/fuzzer/sqlsmith/like_null_pattern.test create mode 100644 parser/testdata/corpus/fuzzer/sqlsmith/mad_overflow.test create mode 100644 parser/testdata/corpus/fuzzer/sqlsmith/makedate_overflow.test create mode 100644 parser/testdata/corpus/fuzzer/sqlsmith/nested_correlated_subquery.test create mode 100644 parser/testdata/corpus/fuzzer/sqlsmith/nullif_map.test create mode 100644 parser/testdata/corpus/fuzzer/sqlsmith/nullif_map_with_config.test create mode 100644 parser/testdata/corpus/fuzzer/sqlsmith/statistics_assertion_trigger.test create mode 100644 parser/testdata/corpus/fuzzer/sqlsmith/strptime_nullpointer.test create mode 100644 parser/testdata/corpus/fuzzer/sqlsmith/struct_null_coalesce_assert.test create mode 100644 parser/testdata/corpus/fuzzer/sqlsmith/struct_verify_crash.test create mode 100644 parser/testdata/corpus/fuzzer/sqlsmith/subquery_binding_error.test create mode 100644 parser/testdata/corpus/fuzzer/sqlsmith/test_abs_overflow.test create mode 100644 parser/testdata/corpus/fuzzer/sqlsmith/timestamp_diff_overflow.test create mode 100644 parser/testdata/corpus/fuzzer/sqlsmith/timestamp_overflow.test create mode 100644 parser/testdata/corpus/fuzzer/sqlsmith/timestamptz_double_cast.test create mode 100644 parser/testdata/corpus/fuzzer/sqlsmith/timestamptz_null_range.test create mode 100644 parser/testdata/corpus/fuzzer/sqlsmith/validity_mask_out_of_bounds.test create mode 100644 parser/testdata/corpus/fuzzer/sqlsmith/window-leadlag-overflow.test create mode 100644 parser/testdata/corpus/fuzzer/sqlsmith/window-list-value.test create mode 100644 parser/testdata/corpus/fuzzer/sqlsmith/window-rows-overflow.test create mode 100644 parser/testdata/corpus/fuzzer/sqlsmith/window_function_error.test create mode 100644 parser/testdata/corpus/fuzzer/sqlsmith/window_scalar_range.test create mode 100644 parser/testdata/corpus/sql/aggregate/aggregate_state_export/approx_quantile_export_state.test create mode 100644 parser/testdata/corpus/sql/aggregate/aggregate_state_export/approx_top_k_export_state.test create mode 100644 parser/testdata/corpus/sql/aggregate/aggregate_state_export/arg_min_max_export_state.test create mode 100644 parser/testdata/corpus/sql/aggregate/aggregate_state_export/bool_and_export_state.test create mode 100644 parser/testdata/corpus/sql/aggregate/aggregate_state_export/count_export_state.test create mode 100644 parser/testdata/corpus/sql/aggregate/aggregate_state_export/first_last_export_state.test create mode 100644 parser/testdata/corpus/sql/aggregate/aggregate_state_export/kahan_avg_export_state.test create mode 100644 parser/testdata/corpus/sql/aggregate/aggregate_state_export/legacy_aggregate_state.test create mode 100644 parser/testdata/corpus/sql/aggregate/aggregate_state_export/list_export_state.test create mode 100644 parser/testdata/corpus/sql/aggregate/aggregate_state_export/minmax_export_state.test create mode 100644 parser/testdata/corpus/sql/aggregate/aggregate_state_export/ordered_aggregate_export_state.test create mode 100644 parser/testdata/corpus/sql/aggregate/aggregate_state_export/product_export_state.test create mode 100644 parser/testdata/corpus/sql/aggregate/aggregate_state_export/state_export_parquet.test create mode 100644 parser/testdata/corpus/sql/aggregate/aggregate_state_export/sum_export_state.test create mode 100644 parser/testdata/corpus/sql/aggregate/aggregate_state_export/test_aggregate_state_type.test create mode 100644 parser/testdata/corpus/sql/aggregate/aggregate_state_export/test_combine_aggr.test create mode 100644 parser/testdata/corpus/sql/aggregate/aggregate_state_export/test_corr_state_export.test create mode 100644 parser/testdata/corpus/sql/aggregate/aggregate_state_export/test_covar_export_state.test create mode 100644 parser/testdata/corpus/sql/aggregate/aggregate_state_export/test_state_export_opaque.test create mode 100644 parser/testdata/corpus/sql/aggregate/aggregate_state_export/test_state_export_opaque.test.metadata.json create mode 100644 parser/testdata/corpus/sql/aggregate/aggregate_state_export/test_state_export_quantile.test create mode 100644 parser/testdata/corpus/sql/aggregate/aggregate_state_export/test_state_export_string_agg.test create mode 100644 parser/testdata/corpus/sql/aggregate/aggregate_state_export/test_state_export_struct.test create mode 100644 parser/testdata/corpus/sql/aggregate/aggregate_state_export/test_state_export_struct.test.metadata.json create mode 100644 parser/testdata/corpus/sql/aggregate/aggregate_state_export/test_stddev_export_state.test create mode 100644 parser/testdata/corpus/sql/aggregate/aggregate_state_export/vector_minmax_export_state.test create mode 100644 parser/testdata/corpus/sql/aggregate/aggregates/approx_top_k.test create mode 100644 parser/testdata/corpus/sql/aggregate/aggregates/arg_min_max_n.test create mode 100644 parser/testdata/corpus/sql/aggregate/aggregates/arg_min_max_n_tpch.test create mode 100644 parser/testdata/corpus/sql/aggregate/aggregates/arg_min_max_nulls_last.test create mode 100644 parser/testdata/corpus/sql/aggregate/aggregates/binning.test create mode 100644 parser/testdata/corpus/sql/aggregate/aggregates/bitstring_agg_empty.test create mode 100644 parser/testdata/corpus/sql/aggregate/aggregates/duckdb_fuzzer_4313.test create mode 100644 parser/testdata/corpus/sql/aggregate/aggregates/histogram_exact.test create mode 100644 parser/testdata/corpus/sql/aggregate/aggregates/histogram_table_function.test create mode 100644 parser/testdata/corpus/sql/aggregate/aggregates/lttb.test create mode 100644 parser/testdata/corpus/sql/aggregate/aggregates/max_n_all_types_grouped.test create mode 100644 parser/testdata/corpus/sql/aggregate/aggregates/mode_rewrite.test create mode 100644 parser/testdata/corpus/sql/aggregate/aggregates/mode_rewrite_memory.test create mode 100644 parser/testdata/corpus/sql/aggregate/aggregates/string_agg_union.test create mode 100644 parser/testdata/corpus/sql/aggregate/aggregates/test_aggr_string.test create mode 100644 parser/testdata/corpus/sql/aggregate/aggregates/test_aggregate_types.test create mode 100644 parser/testdata/corpus/sql/aggregate/aggregates/test_aggregate_types_scalar.test create mode 100644 parser/testdata/corpus/sql/aggregate/aggregates/test_any_value.test create mode 100644 parser/testdata/corpus/sql/aggregate/aggregates/test_any_value_noninlined.test create mode 100644 parser/testdata/corpus/sql/aggregate/aggregates/test_approx_quantile.test create mode 100644 parser/testdata/corpus/sql/aggregate/aggregates/test_approximate_distinct_count.test create mode 100644 parser/testdata/corpus/sql/aggregate/aggregates/test_arg_min_max.test create mode 100644 parser/testdata/corpus/sql/aggregate/aggregates/test_arg_min_max_null.test create mode 100644 parser/testdata/corpus/sql/aggregate/aggregates/test_avg.test create mode 100644 parser/testdata/corpus/sql/aggregate/aggregates/test_bigint_avg.test create mode 100644 parser/testdata/corpus/sql/aggregate/aggregates/test_binned_histogram.test create mode 100644 parser/testdata/corpus/sql/aggregate/aggregates/test_bit_and.test create mode 100644 parser/testdata/corpus/sql/aggregate/aggregates/test_bit_or.test create mode 100644 parser/testdata/corpus/sql/aggregate/aggregates/test_bit_xor.test create mode 100644 parser/testdata/corpus/sql/aggregate/aggregates/test_bitstring_agg.test create mode 100644 parser/testdata/corpus/sql/aggregate/aggregates/test_bool.test create mode 100644 parser/testdata/corpus/sql/aggregate/aggregates/test_corr.test create mode 100644 parser/testdata/corpus/sql/aggregate/aggregates/test_count.test create mode 100644 parser/testdata/corpus/sql/aggregate/aggregates/test_count_all_types.test create mode 100644 parser/testdata/corpus/sql/aggregate/aggregates/test_count_star.test create mode 100644 parser/testdata/corpus/sql/aggregate/aggregates/test_covar.test create mode 100644 parser/testdata/corpus/sql/aggregate/aggregates/test_empty_aggregate.test create mode 100644 parser/testdata/corpus/sql/aggregate/aggregates/test_entropy.test create mode 100644 parser/testdata/corpus/sql/aggregate/aggregates/test_first_last_any_ordered.test create mode 100644 parser/testdata/corpus/sql/aggregate/aggregates/test_first_noninlined.test create mode 100644 parser/testdata/corpus/sql/aggregate/aggregates/test_group_on_expression.test create mode 100644 parser/testdata/corpus/sql/aggregate/aggregates/test_histogram.test create mode 100644 parser/testdata/corpus/sql/aggregate/aggregates/test_histogram_3529.test create mode 100644 parser/testdata/corpus/sql/aggregate/aggregates/test_incorrect_aggregate.test create mode 100644 parser/testdata/corpus/sql/aggregate/aggregates/test_kahan_avg.test create mode 100644 parser/testdata/corpus/sql/aggregate/aggregates/test_kahan_sum.test create mode 100644 parser/testdata/corpus/sql/aggregate/aggregates/test_kurtosis.test create mode 100644 parser/testdata/corpus/sql/aggregate/aggregates/test_last.test create mode 100644 parser/testdata/corpus/sql/aggregate/aggregates/test_last_noninlined.test create mode 100644 parser/testdata/corpus/sql/aggregate/aggregates/test_mad.test create mode 100644 parser/testdata/corpus/sql/aggregate/aggregates/test_median.test create mode 100644 parser/testdata/corpus/sql/aggregate/aggregates/test_minmax.test create mode 100644 parser/testdata/corpus/sql/aggregate/aggregates/test_minmax_14145.test create mode 100644 parser/testdata/corpus/sql/aggregate/aggregates/test_mode.test create mode 100644 parser/testdata/corpus/sql/aggregate/aggregates/test_null_aggregates.test create mode 100644 parser/testdata/corpus/sql/aggregate/aggregates/test_order_by_aggregate.test create mode 100644 parser/testdata/corpus/sql/aggregate/aggregates/test_ordered_aggregates.test create mode 100644 parser/testdata/corpus/sql/aggregate/aggregates/test_ordered_aggregates.test.metadata.json create mode 100644 parser/testdata/corpus/sql/aggregate/aggregates/test_perfect_ht.test create mode 100644 parser/testdata/corpus/sql/aggregate/aggregates/test_product.test create mode 100644 parser/testdata/corpus/sql/aggregate/aggregates/test_quantile_cont.test create mode 100644 parser/testdata/corpus/sql/aggregate/aggregates/test_quantile_cont_list.test create mode 100644 parser/testdata/corpus/sql/aggregate/aggregates/test_quantile_disc.test create mode 100644 parser/testdata/corpus/sql/aggregate/aggregates/test_quantile_disc_list.test create mode 100644 parser/testdata/corpus/sql/aggregate/aggregates/test_regression.test create mode 100644 parser/testdata/corpus/sql/aggregate/aggregates/test_scalar_aggr.test create mode 100644 parser/testdata/corpus/sql/aggregate/aggregates/test_sem.test create mode 100644 parser/testdata/corpus/sql/aggregate/aggregates/test_simple_filter.test create mode 100644 parser/testdata/corpus/sql/aggregate/aggregates/test_skewness.test create mode 100644 parser/testdata/corpus/sql/aggregate/aggregates/test_stddev.test create mode 100644 parser/testdata/corpus/sql/aggregate/aggregates/test_string_agg.test create mode 100644 parser/testdata/corpus/sql/aggregate/aggregates/test_string_agg_big.test create mode 100644 parser/testdata/corpus/sql/aggregate/aggregates/test_sum.test create mode 100644 parser/testdata/corpus/sql/aggregate/aggregates/test_sum.test.metadata.json create mode 100644 parser/testdata/corpus/sql/aggregate/aggregates/test_weighted_avg.test create mode 100644 parser/testdata/corpus/sql/aggregate/distinct/distinct_limit.test create mode 100644 parser/testdata/corpus/sql/aggregate/distinct/distinct_on_nulls.test create mode 100644 parser/testdata/corpus/sql/aggregate/distinct/distinct_on_order_by.test create mode 100644 parser/testdata/corpus/sql/aggregate/distinct/grouped/combined_with_grouping.test create mode 100644 parser/testdata/corpus/sql/aggregate/distinct/grouped/identical_inputs.test create mode 100644 parser/testdata/corpus/sql/aggregate/distinct/grouped/issue_5070.test create mode 100644 parser/testdata/corpus/sql/aggregate/distinct/grouped/multiple_grouping_sets.test create mode 100644 parser/testdata/corpus/sql/aggregate/distinct/grouped/string_agg.test create mode 100644 parser/testdata/corpus/sql/aggregate/distinct/issue19616.test create mode 100644 parser/testdata/corpus/sql/aggregate/distinct/issue2656.test create mode 100644 parser/testdata/corpus/sql/aggregate/distinct/issue8505.test create mode 100644 parser/testdata/corpus/sql/aggregate/distinct/issue9241.test create mode 100644 parser/testdata/corpus/sql/aggregate/distinct/rewrite/distinct_aggregate_rewrite.test create mode 100644 parser/testdata/corpus/sql/aggregate/distinct/test_distinct.test create mode 100644 parser/testdata/corpus/sql/aggregate/distinct/test_distinct_on.test create mode 100644 parser/testdata/corpus/sql/aggregate/distinct/test_distinct_on_columns.test create mode 100644 parser/testdata/corpus/sql/aggregate/distinct/test_distinct_order_by.test create mode 100644 parser/testdata/corpus/sql/aggregate/distinct/ungrouped/test_distinct_ungrouped.test create mode 100644 parser/testdata/corpus/sql/aggregate/distinct/ungrouped/test_distinct_ungrouped_shared_input.test create mode 100644 parser/testdata/corpus/sql/aggregate/group/group_by_all.test create mode 100644 parser/testdata/corpus/sql/aggregate/group/group_by_all_having.test create mode 100644 parser/testdata/corpus/sql/aggregate/group/group_by_all_order.test create mode 100644 parser/testdata/corpus/sql/aggregate/group/group_by_limits.test create mode 100644 parser/testdata/corpus/sql/aggregate/group/test_group_by.test create mode 100644 parser/testdata/corpus/sql/aggregate/group/test_group_by_alias.test create mode 100644 parser/testdata/corpus/sql/aggregate/group/test_group_by_error.test create mode 100644 parser/testdata/corpus/sql/aggregate/group/test_group_by_large_string.test create mode 100644 parser/testdata/corpus/sql/aggregate/group/test_group_by_multi_column.test create mode 100644 parser/testdata/corpus/sql/aggregate/group/test_group_by_nested.test create mode 100644 parser/testdata/corpus/sql/aggregate/group/test_group_by_null_length.test create mode 100644 parser/testdata/corpus/sql/aggregate/group/test_group_null.test create mode 100644 parser/testdata/corpus/sql/aggregate/grouping_sets/cube.test create mode 100644 parser/testdata/corpus/sql/aggregate/grouping_sets/cube.test.metadata.json create mode 100644 parser/testdata/corpus/sql/aggregate/grouping_sets/grouping.test create mode 100644 parser/testdata/corpus/sql/aggregate/grouping_sets/grouping_sets.test create mode 100644 parser/testdata/corpus/sql/aggregate/grouping_sets/grouping_sets_filter.test create mode 100644 parser/testdata/corpus/sql/aggregate/grouping_sets/issue_3730.test create mode 100644 parser/testdata/corpus/sql/aggregate/grouping_sets/multiple_empty_grouping_sets.test create mode 100644 parser/testdata/corpus/sql/aggregate/grouping_sets/rollup.test create mode 100644 parser/testdata/corpus/sql/aggregate/grouping_sets/rollup.test.metadata.json create mode 100644 parser/testdata/corpus/sql/aggregate/having/having_alias.test create mode 100644 parser/testdata/corpus/sql/aggregate/having/having_without_groupby.test create mode 100644 parser/testdata/corpus/sql/aggregate/having/test_having.test create mode 100644 parser/testdata/corpus/sql/aggregate/having/test_scalar_having.test create mode 100644 parser/testdata/corpus/sql/aggregate/qualify/test_qualify.test create mode 100644 parser/testdata/corpus/sql/aggregate/qualify/test_qualify_macro.test create mode 100644 parser/testdata/corpus/sql/aggregate/qualify/test_qualify_view.test create mode 100644 parser/testdata/corpus/sql/aggregate/quantile_fun.test create mode 100644 parser/testdata/corpus/sql/alter/add_col/test_add_col.test create mode 100644 parser/testdata/corpus/sql/alter/add_col/test_add_col_chain.test create mode 100644 parser/testdata/corpus/sql/alter/add_col/test_add_col_default.test create mode 100644 parser/testdata/corpus/sql/alter/add_col/test_add_col_default_seq.test create mode 100644 parser/testdata/corpus/sql/alter/add_col/test_add_col_if_not_exists_default.test create mode 100644 parser/testdata/corpus/sql/alter/add_col/test_add_col_incorrect.test create mode 100644 parser/testdata/corpus/sql/alter/add_col/test_add_col_incorrect.test.metadata.json create mode 100644 parser/testdata/corpus/sql/alter/add_col/test_add_col_index.test create mode 100644 parser/testdata/corpus/sql/alter/add_col/test_add_col_stats.test create mode 100644 parser/testdata/corpus/sql/alter/add_col/test_add_col_transactions.test create mode 100644 parser/testdata/corpus/sql/alter/add_col/test_add_col_user_type.test create mode 100644 parser/testdata/corpus/sql/alter/add_pk/test_add_multi_column_pk.test create mode 100644 parser/testdata/corpus/sql/alter/add_pk/test_add_pk.test create mode 100644 parser/testdata/corpus/sql/alter/add_pk/test_add_pk_alter_in_tx.test create mode 100644 parser/testdata/corpus/sql/alter/add_pk/test_add_pk_attach.test create mode 100644 parser/testdata/corpus/sql/alter/add_pk/test_add_pk_catalog_error.test create mode 100644 parser/testdata/corpus/sql/alter/add_pk/test_add_pk_gaps_in_rowids.test create mode 100644 parser/testdata/corpus/sql/alter/add_pk/test_add_pk_invalid_data.test create mode 100644 parser/testdata/corpus/sql/alter/add_pk/test_add_pk_invalid_type.test create mode 100644 parser/testdata/corpus/sql/alter/add_pk/test_add_pk_naming_conflict.test create mode 100644 parser/testdata/corpus/sql/alter/add_pk/test_add_pk_rollback.test create mode 100644 parser/testdata/corpus/sql/alter/add_pk/test_add_pk_wal.test create mode 100644 parser/testdata/corpus/sql/alter/add_pk/test_add_pk_with_generated_column.test create mode 100644 parser/testdata/corpus/sql/alter/add_pk/test_add_same_pk_simultaneously.test create mode 100644 parser/testdata/corpus/sql/alter/add_pk/test_add_same_pk_twice.test create mode 100644 parser/testdata/corpus/sql/alter/alter_col/test_drop_not_null.test create mode 100644 parser/testdata/corpus/sql/alter/alter_col/test_not_null_in_tran.test create mode 100644 parser/testdata/corpus/sql/alter/alter_col/test_not_null_multi_tran.test create mode 100644 parser/testdata/corpus/sql/alter/alter_col/test_set_not_null.test create mode 100644 parser/testdata/corpus/sql/alter/alter_table_set_partitioned_by.test create mode 100644 parser/testdata/corpus/sql/alter/alter_table_set_sorted_by.test create mode 100644 parser/testdata/corpus/sql/alter/alter_table_set_table_options.test create mode 100644 parser/testdata/corpus/sql/alter/alter_table_set_table_options.test.metadata.json create mode 100644 parser/testdata/corpus/sql/alter/alter_type/alter_type_struct.test create mode 100644 parser/testdata/corpus/sql/alter/alter_type/test_alter_type.test create mode 100644 parser/testdata/corpus/sql/alter/alter_type/test_alter_type.test.metadata.json create mode 100644 parser/testdata/corpus/sql/alter/alter_type/test_alter_type_active_transaction_visibility.test create mode 100644 parser/testdata/corpus/sql/alter/alter_type/test_alter_type_check.test create mode 100644 parser/testdata/corpus/sql/alter/alter_type/test_alter_type_dependencies.test create mode 100644 parser/testdata/corpus/sql/alter/alter_type/test_alter_type_expression.test create mode 100644 parser/testdata/corpus/sql/alter/alter_type/test_alter_type_incorrect.test create mode 100644 parser/testdata/corpus/sql/alter/alter_type/test_alter_type_index.test create mode 100644 parser/testdata/corpus/sql/alter/alter_type/test_alter_type_local.test create mode 100644 parser/testdata/corpus/sql/alter/alter_type/test_alter_type_multi_column.test create mode 100644 parser/testdata/corpus/sql/alter/alter_type/test_alter_type_not_null.test create mode 100644 parser/testdata/corpus/sql/alter/alter_type/test_alter_type_rollback.test create mode 100644 parser/testdata/corpus/sql/alter/alter_type/test_alter_type_transactions.test create mode 100644 parser/testdata/corpus/sql/alter/alter_type/test_alter_type_unique.test create mode 100644 parser/testdata/corpus/sql/alter/alter_type/test_alter_type_with_generated_column.test create mode 100644 parser/testdata/corpus/sql/alter/default/drop_default.test create mode 100644 parser/testdata/corpus/sql/alter/default/test_set_default.test create mode 100644 parser/testdata/corpus/sql/alter/drop_col/test_drop_col.test create mode 100644 parser/testdata/corpus/sql/alter/drop_col/test_drop_col_check.test create mode 100644 parser/testdata/corpus/sql/alter/drop_col/test_drop_col_check_next.test create mode 100644 parser/testdata/corpus/sql/alter/drop_col/test_drop_col_concurrent_dml_conflict.test create mode 100644 parser/testdata/corpus/sql/alter/drop_col/test_drop_col_failure.test create mode 100644 parser/testdata/corpus/sql/alter/drop_col/test_drop_col_not_null_next.test create mode 100644 parser/testdata/corpus/sql/alter/drop_col/test_drop_col_operations.test create mode 100644 parser/testdata/corpus/sql/alter/drop_col/test_drop_col_pk.test create mode 100644 parser/testdata/corpus/sql/alter/drop_col/test_drop_col_with_generated_cols.test create mode 100644 parser/testdata/corpus/sql/alter/list/add_column_in_struct.test create mode 100644 parser/testdata/corpus/sql/alter/list/drop_column_in_struct.test create mode 100644 parser/testdata/corpus/sql/alter/list/rename_column_in_struct.test create mode 100644 parser/testdata/corpus/sql/alter/map/add_column_in_struct.test create mode 100644 parser/testdata/corpus/sql/alter/map/drop_column_in_struct.test create mode 100644 parser/testdata/corpus/sql/alter/map/rename_column_in_struct.test create mode 100644 parser/testdata/corpus/sql/alter/rename_col/test_rename_col.test create mode 100644 parser/testdata/corpus/sql/alter/rename_col/test_rename_col_check.test create mode 100644 parser/testdata/corpus/sql/alter/rename_col/test_rename_col_dependencies.test create mode 100644 parser/testdata/corpus/sql/alter/rename_col/test_rename_col_failure.test create mode 100644 parser/testdata/corpus/sql/alter/rename_col/test_rename_col_not_null.test create mode 100644 parser/testdata/corpus/sql/alter/rename_col/test_rename_col_rollback.test create mode 100644 parser/testdata/corpus/sql/alter/rename_col/test_rename_col_transactions.test create mode 100644 parser/testdata/corpus/sql/alter/rename_col/test_rename_col_unique.test create mode 100644 parser/testdata/corpus/sql/alter/rename_schema/rename_schema.test create mode 100644 parser/testdata/corpus/sql/alter/rename_table/test_rename_bug4455_schema.test create mode 100644 parser/testdata/corpus/sql/alter/rename_table/test_rename_table.test create mode 100644 parser/testdata/corpus/sql/alter/rename_table/test_rename_table_case.test create mode 100644 parser/testdata/corpus/sql/alter/rename_table/test_rename_table_chain_commit.test create mode 100644 parser/testdata/corpus/sql/alter/rename_table/test_rename_table_collision.test create mode 100644 parser/testdata/corpus/sql/alter/rename_table/test_rename_table_constraints.test create mode 100644 parser/testdata/corpus/sql/alter/rename_table/test_rename_table_incorrect.test create mode 100644 parser/testdata/corpus/sql/alter/rename_table/test_rename_table_many_transactions.test create mode 100644 parser/testdata/corpus/sql/alter/rename_table/test_rename_table_transactions.test create mode 100644 parser/testdata/corpus/sql/alter/rename_table/test_rename_table_view.test create mode 100644 parser/testdata/corpus/sql/alter/rename_table/test_rename_table_with_dependency_check.test create mode 100644 parser/testdata/corpus/sql/alter/rename_table/test_rename_table_with_insert_transaction.test create mode 100644 parser/testdata/corpus/sql/alter/rename_view/test_rename_view.test create mode 100644 parser/testdata/corpus/sql/alter/rename_view/test_rename_view_incorrect.test create mode 100644 parser/testdata/corpus/sql/alter/rename_view/test_rename_view_many_transactions.test create mode 100644 parser/testdata/corpus/sql/alter/rename_view/test_rename_view_table.test create mode 100644 parser/testdata/corpus/sql/alter/struct/add_col_nested_struct.test create mode 100644 parser/testdata/corpus/sql/alter/struct/add_col_struct.test create mode 100644 parser/testdata/corpus/sql/alter/struct/drop_col_nested_struct.test create mode 100644 parser/testdata/corpus/sql/alter/struct/drop_col_struct.test create mode 100644 parser/testdata/corpus/sql/alter/struct/rename_col_nested_struct.test create mode 100644 parser/testdata/corpus/sql/alter/struct/rename_col_struct.test create mode 100644 parser/testdata/corpus/sql/alter/struct/rename_col_struct_case_insensitive.test create mode 100644 parser/testdata/corpus/sql/alter/test_alter_database_rename.test create mode 100644 parser/testdata/corpus/sql/alter/test_alter_if_exists.test create mode 100644 parser/testdata/corpus/sql/attach/attach_all_types.test create mode 100644 parser/testdata/corpus/sql/attach/attach_catalog_error_early_out.test create mode 100644 parser/testdata/corpus/sql/attach/attach_checkpoint_on_detach.test create mode 100644 parser/testdata/corpus/sql/attach/attach_checkpoint_vacuum.test create mode 100644 parser/testdata/corpus/sql/attach/attach_copy.test create mode 100644 parser/testdata/corpus/sql/attach/attach_create_index.test create mode 100644 parser/testdata/corpus/sql/attach/attach_cross_catalog.test create mode 100644 parser/testdata/corpus/sql/attach/attach_custom_block_size.test create mode 100644 parser/testdata/corpus/sql/attach/attach_database_options.test create mode 100644 parser/testdata/corpus/sql/attach/attach_database_size.test create mode 100644 parser/testdata/corpus/sql/attach/attach_dbname_quotes.test create mode 100644 parser/testdata/corpus/sql/attach/attach_default_database_case.test create mode 100644 parser/testdata/corpus/sql/attach/attach_default_table.test create mode 100644 parser/testdata/corpus/sql/attach/attach_defaults.test create mode 100644 parser/testdata/corpus/sql/attach/attach_dependencies.test create mode 100644 parser/testdata/corpus/sql/attach/attach_did_you_mean.test create mode 100644 parser/testdata/corpus/sql/attach/attach_different_alias.test create mode 100644 parser/testdata/corpus/sql/attach/attach_duckdb_type.test create mode 100644 parser/testdata/corpus/sql/attach/attach_enable_external_access.test create mode 100644 parser/testdata/corpus/sql/attach/attach_encrypted_db_key_test.test create mode 100644 parser/testdata/corpus/sql/attach/attach_encryption_block_header.test create mode 100644 parser/testdata/corpus/sql/attach/attach_encryption_downgrade_prevention.test create mode 100644 parser/testdata/corpus/sql/attach/attach_encryption_fallback_readonly.test create mode 100644 parser/testdata/corpus/sql/attach/attach_enums.test create mode 100644 parser/testdata/corpus/sql/attach/attach_export_import.test create mode 100644 parser/testdata/corpus/sql/attach/attach_expr.test create mode 100644 parser/testdata/corpus/sql/attach/attach_external_access.test create mode 100644 parser/testdata/corpus/sql/attach/attach_filepath_roundtrip.test create mode 100644 parser/testdata/corpus/sql/attach/attach_foreign_key.test create mode 100644 parser/testdata/corpus/sql/attach/attach_foreign_key_external_catalog.test create mode 100644 parser/testdata/corpus/sql/attach/attach_fsspec.test create mode 100644 parser/testdata/corpus/sql/attach/attach_hidden.test create mode 100644 parser/testdata/corpus/sql/attach/attach_home_directory.test create mode 100644 parser/testdata/corpus/sql/attach/attach_huggingface_index.test create mode 100644 parser/testdata/corpus/sql/attach/attach_icu_collation.test create mode 100644 parser/testdata/corpus/sql/attach/attach_if_not_exists.test create mode 100644 parser/testdata/corpus/sql/attach/attach_if_not_exists_detach.test create mode 100644 parser/testdata/corpus/sql/attach/attach_index.test create mode 100644 parser/testdata/corpus/sql/attach/attach_issue16122.test create mode 100644 parser/testdata/corpus/sql/attach/attach_issue7567.test create mode 100644 parser/testdata/corpus/sql/attach/attach_issue7711.test create mode 100644 parser/testdata/corpus/sql/attach/attach_issue_21491.test create mode 100644 parser/testdata/corpus/sql/attach/attach_issue_7660.test create mode 100644 parser/testdata/corpus/sql/attach/attach_lambda_view.test create mode 100644 parser/testdata/corpus/sql/attach/attach_macros.test create mode 100644 parser/testdata/corpus/sql/attach/attach_modify_multiple_databases.test create mode 100644 parser/testdata/corpus/sql/attach/attach_multi_identifiers.test create mode 100644 parser/testdata/corpus/sql/attach/attach_nested_types.test create mode 100644 parser/testdata/corpus/sql/attach/attach_new_compression.test create mode 100644 parser/testdata/corpus/sql/attach/attach_no_wal_writes_mode.test create mode 100644 parser/testdata/corpus/sql/attach/attach_null.test create mode 100644 parser/testdata/corpus/sql/attach/attach_or_replace.test create mode 100644 parser/testdata/corpus/sql/attach/attach_persistent.test create mode 100644 parser/testdata/corpus/sql/attach/attach_pragma_storage_info.test create mode 100644 parser/testdata/corpus/sql/attach/attach_prefetch_header.test create mode 100644 parser/testdata/corpus/sql/attach/attach_read_only.test create mode 100644 parser/testdata/corpus/sql/attach/attach_read_only_transaction.test create mode 100644 parser/testdata/corpus/sql/attach/attach_replay_with_no_wal_writes.test create mode 100644 parser/testdata/corpus/sql/attach/attach_reserved.test create mode 100644 parser/testdata/corpus/sql/attach/attach_row_group_size.test create mode 100644 parser/testdata/corpus/sql/attach/attach_row_group_size_decreasing.test create mode 100644 parser/testdata/corpus/sql/attach/attach_same_db.test create mode 100644 parser/testdata/corpus/sql/attach/attach_schema.test create mode 100644 parser/testdata/corpus/sql/attach/attach_sequence.test create mode 100644 parser/testdata/corpus/sql/attach/attach_serialize_dependency.test create mode 100644 parser/testdata/corpus/sql/attach/attach_show_all_tables.test create mode 100644 parser/testdata/corpus/sql/attach/attach_show_table.test create mode 100644 parser/testdata/corpus/sql/attach/attach_storage_version.test create mode 100644 parser/testdata/corpus/sql/attach/attach_table_constraints.test create mode 100644 parser/testdata/corpus/sql/attach/attach_table_ddl.test create mode 100644 parser/testdata/corpus/sql/attach/attach_table_info.test create mode 100644 parser/testdata/corpus/sql/attach/attach_transactionality.test create mode 100644 parser/testdata/corpus/sql/attach/attach_use_rollback.test create mode 100644 parser/testdata/corpus/sql/attach/attach_view_search_path.test create mode 100644 parser/testdata/corpus/sql/attach/attach_views.test create mode 100644 parser/testdata/corpus/sql/attach/attach_wal_alter.test create mode 100644 parser/testdata/corpus/sql/attach/attach_wal_alter_sequence.test create mode 100644 parser/testdata/corpus/sql/attach/detach_keyword.test create mode 100644 parser/testdata/corpus/sql/attach/detach_manager_default_database.test create mode 100644 parser/testdata/corpus/sql/attach/external_resource_discovery.test create mode 100644 parser/testdata/corpus/sql/attach/external_resource_statements.test create mode 100644 parser/testdata/corpus/sql/attach/in_memory_attach.test create mode 100644 parser/testdata/corpus/sql/attach/reattach_schema.test create mode 100644 parser/testdata/corpus/sql/attach/reattach_schema.test.metadata.json create mode 100644 parser/testdata/corpus/sql/attach/remote_file_concurrently.test create mode 100644 parser/testdata/corpus/sql/attach/searchpath_fallback.test create mode 100644 parser/testdata/corpus/sql/attach/show_databases.test create mode 100644 parser/testdata/corpus/sql/attach/show_schemas.test create mode 100644 parser/testdata/corpus/sql/attach/system_catalog.test create mode 100644 parser/testdata/corpus/sql/binder/alias_error_10057.test create mode 100644 parser/testdata/corpus/sql/binder/alias_qualification_errors.test create mode 100644 parser/testdata/corpus/sql/binder/alias_qualification_group_by.test create mode 100644 parser/testdata/corpus/sql/binder/alias_qualification_having.test create mode 100644 parser/testdata/corpus/sql/binder/alias_qualification_order_by.test create mode 100644 parser/testdata/corpus/sql/binder/alias_qualification_qualify.test create mode 100644 parser/testdata/corpus/sql/binder/alias_qualification_select_projection.test create mode 100644 parser/testdata/corpus/sql/binder/alias_qualification_where.test create mode 100644 parser/testdata/corpus/sql/binder/alias_where_side_effects.test create mode 100644 parser/testdata/corpus/sql/binder/column_ref_as_alias.test create mode 100644 parser/testdata/corpus/sql/binder/column_value_alias_group.test create mode 100644 parser/testdata/corpus/sql/binder/duplicate_alias.test create mode 100644 parser/testdata/corpus/sql/binder/function_chaining_19035.test create mode 100644 parser/testdata/corpus/sql/binder/group_by_incremental_alias.test create mode 100644 parser/testdata/corpus/sql/binder/group_by_qualification.test create mode 100644 parser/testdata/corpus/sql/binder/integer_literal_binding.test create mode 100644 parser/testdata/corpus/sql/binder/legacy_null_type.test create mode 100644 parser/testdata/corpus/sql/binder/missing_column_error.test create mode 100644 parser/testdata/corpus/sql/binder/not_similar_to.test create mode 100644 parser/testdata/corpus/sql/binder/old_implicit_cast.test create mode 100644 parser/testdata/corpus/sql/binder/old_implicit_cast_template.test create mode 100644 parser/testdata/corpus/sql/binder/order_by_view.test create mode 100644 parser/testdata/corpus/sql/binder/qualified_alias_method_call.test create mode 100644 parser/testdata/corpus/sql/binder/separate_schema_tables.test create mode 100644 parser/testdata/corpus/sql/binder/similar_to.test create mode 100644 parser/testdata/corpus/sql/binder/string_literal_binding.test create mode 100644 parser/testdata/corpus/sql/binder/table_alias_single_quotes.test create mode 100644 parser/testdata/corpus/sql/binder/table_view_alias.test create mode 100644 parser/testdata/corpus/sql/binder/test_alias.test create mode 100644 parser/testdata/corpus/sql/binder/test_alias_map_in_subquery.test create mode 100644 parser/testdata/corpus/sql/binder/test_case_insensitive_binding.test create mode 100644 parser/testdata/corpus/sql/binder/test_duplicate_in_set_operation.test create mode 100644 parser/testdata/corpus/sql/binder/test_function_chaining_alias.test create mode 100644 parser/testdata/corpus/sql/binder/test_having_alias.test create mode 100644 parser/testdata/corpus/sql/binder/test_implicit_struct_pack.test create mode 100644 parser/testdata/corpus/sql/binder/test_in_with_collate.test create mode 100644 parser/testdata/corpus/sql/binder/test_null_type_propagation.test create mode 100644 parser/testdata/corpus/sql/binder/test_postitional_ref_order_binding.test create mode 100644 parser/testdata/corpus/sql/binder/test_select_clause_alias.test create mode 100644 parser/testdata/corpus/sql/binder/test_string_alias.test create mode 100644 parser/testdata/corpus/sql/cast/boolean_autocast.test create mode 100644 parser/testdata/corpus/sql/cast/cast_error_location.test create mode 100644 parser/testdata/corpus/sql/cast/decimal_cast.test create mode 100644 parser/testdata/corpus/sql/cast/decimal_float_cast.test create mode 100644 parser/testdata/corpus/sql/cast/decimal_integer_cast.test create mode 100644 parser/testdata/corpus/sql/cast/dot_function_missing_error.test create mode 100644 parser/testdata/corpus/sql/cast/double_float_cast.test create mode 100644 parser/testdata/corpus/sql/cast/float_decimal_cast.test create mode 100644 parser/testdata/corpus/sql/cast/float_integer_cast.test create mode 100644 parser/testdata/corpus/sql/cast/signed_cast_repro.test create mode 100644 parser/testdata/corpus/sql/cast/string_to_integer_decimal_cast.test create mode 100644 parser/testdata/corpus/sql/cast/string_to_integer_exponent_cast.test create mode 100644 parser/testdata/corpus/sql/cast/string_to_list_cast.test create mode 100644 parser/testdata/corpus/sql/cast/string_to_list_escapes.test create mode 100644 parser/testdata/corpus/sql/cast/string_to_list_roundtrip.test create mode 100644 parser/testdata/corpus/sql/cast/string_to_struct_cast.test create mode 100644 parser/testdata/corpus/sql/cast/string_to_struct_escapes.test create mode 100644 parser/testdata/corpus/sql/cast/string_to_unnamed_struct.test create mode 100644 parser/testdata/corpus/sql/cast/struct_to_map.test create mode 100644 parser/testdata/corpus/sql/cast/test_bit_cast.test create mode 100644 parser/testdata/corpus/sql/cast/test_boolean_cast.test create mode 100644 parser/testdata/corpus/sql/cast/test_exponent_in_cast.test create mode 100644 parser/testdata/corpus/sql/cast/test_string_binary_cast.test create mode 100644 parser/testdata/corpus/sql/cast/test_string_cast.test create mode 100644 parser/testdata/corpus/sql/cast/test_try_cast.test create mode 100644 parser/testdata/corpus/sql/cast/timestamp_casts.test create mode 100644 parser/testdata/corpus/sql/cast/timestamp_date_cast.test create mode 100644 parser/testdata/corpus/sql/cast/union_cast.test create mode 100644 parser/testdata/corpus/sql/catalog/case_insensitive_alter.test create mode 100644 parser/testdata/corpus/sql/catalog/case_insensitive_binder.test create mode 100644 parser/testdata/corpus/sql/catalog/case_insensitive_caps.test create mode 100644 parser/testdata/corpus/sql/catalog/case_insensitive_cte.test create mode 100644 parser/testdata/corpus/sql/catalog/case_insensitive_operations.test create mode 100644 parser/testdata/corpus/sql/catalog/case_insensitive_using.test create mode 100644 parser/testdata/corpus/sql/catalog/comment_on.test create mode 100644 parser/testdata/corpus/sql/catalog/comment_on_column.test create mode 100644 parser/testdata/corpus/sql/catalog/comment_on_dependencies.test create mode 100644 parser/testdata/corpus/sql/catalog/comment_on_extended.test create mode 100644 parser/testdata/corpus/sql/catalog/comment_on_extended.test.metadata.json create mode 100644 parser/testdata/corpus/sql/catalog/comment_on_pg_description.test create mode 100644 parser/testdata/corpus/sql/catalog/comment_on_wal.test create mode 100644 parser/testdata/corpus/sql/catalog/dependencies/add_column_to_table_referenced_by_fk.test create mode 100644 parser/testdata/corpus/sql/catalog/dependencies/add_column_to_table_referenced_by_macro.test create mode 100644 parser/testdata/corpus/sql/catalog/dependencies/add_column_to_table_referenced_by_view.test create mode 100644 parser/testdata/corpus/sql/catalog/dependencies/change_type_of_table_column_referenced_by_index.test create mode 100644 parser/testdata/corpus/sql/catalog/dependencies/drop_recreate_schema_dependency.test create mode 100644 parser/testdata/corpus/sql/catalog/dependencies/remove_table_column_referenced_by_index.test create mode 100644 parser/testdata/corpus/sql/catalog/dependencies/rename_table_column_referenced_by_index.test create mode 100644 parser/testdata/corpus/sql/catalog/dependencies/rename_view_referenced_by_table_macro.test create mode 100644 parser/testdata/corpus/sql/catalog/dependencies/set_default_of_table_column_referenced_by_index.test create mode 100644 parser/testdata/corpus/sql/catalog/dependencies/test_alter_dependency_ownership.test create mode 100644 parser/testdata/corpus/sql/catalog/dependencies/test_alter_dependency_ownership.test.metadata.json create mode 100644 parser/testdata/corpus/sql/catalog/dependencies/test_alter_owned_by.test create mode 100644 parser/testdata/corpus/sql/catalog/dependencies/test_alter_owning_table.test create mode 100644 parser/testdata/corpus/sql/catalog/dependencies/test_concurrent_alter.test create mode 100644 parser/testdata/corpus/sql/catalog/dependencies/test_concurrent_drop.test create mode 100644 parser/testdata/corpus/sql/catalog/dependencies/test_concurrent_index_creation.test create mode 100644 parser/testdata/corpus/sql/catalog/dependencies/test_concurrent_schema_creation.test create mode 100644 parser/testdata/corpus/sql/catalog/dependencies/test_default_value_dependency.test create mode 100644 parser/testdata/corpus/sql/catalog/dependencies/test_drop_column_sequence_dependency.test create mode 100644 parser/testdata/corpus/sql/catalog/dependencies/test_drop_default_referencing_sequence.test create mode 100644 parser/testdata/corpus/sql/catalog/dependencies/test_prepare_dependencies_transactions.test create mode 100644 parser/testdata/corpus/sql/catalog/dependencies/test_prepared_dependency.test create mode 100644 parser/testdata/corpus/sql/catalog/dependencies/test_schema_dependency.test create mode 100644 parser/testdata/corpus/sql/catalog/dependencies/test_set_default_sequence_dependency.test create mode 100644 parser/testdata/corpus/sql/catalog/dependencies/test_write_after_rename.test create mode 100644 parser/testdata/corpus/sql/catalog/did_you_mean.test create mode 100644 parser/testdata/corpus/sql/catalog/drop_create_rollback.test create mode 100644 parser/testdata/corpus/sql/catalog/function/attached_macro.test create mode 100644 parser/testdata/corpus/sql/catalog/function/information_schema_macro.test create mode 100644 parser/testdata/corpus/sql/catalog/function/macro_query_table.test create mode 100644 parser/testdata/corpus/sql/catalog/function/python_style_macro_parameters.test create mode 100644 parser/testdata/corpus/sql/catalog/function/query_function.test create mode 100644 parser/testdata/corpus/sql/catalog/function/query_function.test.metadata.json create mode 100644 parser/testdata/corpus/sql/catalog/function/struct_extract_macro.test create mode 100644 parser/testdata/corpus/sql/catalog/function/test_complex_macro.test create mode 100644 parser/testdata/corpus/sql/catalog/function/test_cross_catalog_macros.test create mode 100644 parser/testdata/corpus/sql/catalog/function/test_cte_macro.test create mode 100644 parser/testdata/corpus/sql/catalog/function/test_drop_macro.test create mode 100644 parser/testdata/corpus/sql/catalog/function/test_macro_correlated_cte.test create mode 100644 parser/testdata/corpus/sql/catalog/function/test_macro_default_arg.test create mode 100644 parser/testdata/corpus/sql/catalog/function/test_macro_default_arg_with_dependencies.test create mode 100644 parser/testdata/corpus/sql/catalog/function/test_macro_issue_13104.test create mode 100644 parser/testdata/corpus/sql/catalog/function/test_macro_issue_14276.test create mode 100644 parser/testdata/corpus/sql/catalog/function/test_macro_issue_18927.test create mode 100644 parser/testdata/corpus/sql/catalog/function/test_macro_issue_19119.test create mode 100644 parser/testdata/corpus/sql/catalog/function/test_macro_overloads.test create mode 100644 parser/testdata/corpus/sql/catalog/function/test_macro_relpersistence_conflict.test create mode 100644 parser/testdata/corpus/sql/catalog/function/test_macro_type_overloads.test create mode 100644 parser/testdata/corpus/sql/catalog/function/test_macro_with_unknown_types.test create mode 100644 parser/testdata/corpus/sql/catalog/function/test_recursive_macro.test create mode 100644 parser/testdata/corpus/sql/catalog/function/test_sequence_macro.test create mode 100644 parser/testdata/corpus/sql/catalog/function/test_simple_macro.test create mode 100644 parser/testdata/corpus/sql/catalog/function/test_simple_macro.test.metadata.json create mode 100644 parser/testdata/corpus/sql/catalog/function/test_subquery_macro.test create mode 100644 parser/testdata/corpus/sql/catalog/function/test_table_macro.test create mode 100644 parser/testdata/corpus/sql/catalog/function/test_table_macro_args.test create mode 100644 parser/testdata/corpus/sql/catalog/function/test_table_macro_args.test.metadata.json create mode 100644 parser/testdata/corpus/sql/catalog/function/test_table_macro_complex.test create mode 100644 parser/testdata/corpus/sql/catalog/function/test_table_macro_copy.test create mode 100644 parser/testdata/corpus/sql/catalog/function/test_table_macro_groups.test create mode 100644 parser/testdata/corpus/sql/catalog/function/test_window_macro.test create mode 100644 parser/testdata/corpus/sql/catalog/information_schema_read_only.test create mode 100644 parser/testdata/corpus/sql/catalog/issue_9459.test create mode 100644 parser/testdata/corpus/sql/catalog/nested_schema/create_nested_schema.test create mode 100644 parser/testdata/corpus/sql/catalog/nested_schema/drop_nested_schema.test create mode 100644 parser/testdata/corpus/sql/catalog/nested_schema/drop_nested_schema_persist.test create mode 100644 parser/testdata/corpus/sql/catalog/nested_schema/nested_alter.test create mode 100644 parser/testdata/corpus/sql/catalog/nested_schema/nested_constraints.test create mode 100644 parser/testdata/corpus/sql/catalog/nested_schema/nested_entries.test create mode 100644 parser/testdata/corpus/sql/catalog/nested_schema/nested_entries.test.metadata.json create mode 100644 parser/testdata/corpus/sql/catalog/nested_schema/nested_entries_persist.test create mode 100644 parser/testdata/corpus/sql/catalog/nested_schema/nested_export.test create mode 100644 parser/testdata/corpus/sql/catalog/nested_schema/nested_schema_limits.test create mode 100644 parser/testdata/corpus/sql/catalog/nested_schema/nested_schema_storage_version.test create mode 100644 parser/testdata/corpus/sql/catalog/nested_schema/nested_table.test create mode 100644 parser/testdata/corpus/sql/catalog/nested_schema/nested_table_columnref.test create mode 100644 parser/testdata/corpus/sql/catalog/nested_schema/nested_table_dml.test create mode 100644 parser/testdata/corpus/sql/catalog/nested_schema/nested_table_dml_persist.test create mode 100644 parser/testdata/corpus/sql/catalog/nested_schema/nested_table_persist.test create mode 100644 parser/testdata/corpus/sql/catalog/nested_schema/nested_wal_replay.test create mode 100644 parser/testdata/corpus/sql/catalog/nested_schema/persist.test create mode 100644 parser/testdata/corpus/sql/catalog/sequence/sequence_currval_before_nextval_not_supported.test create mode 100644 parser/testdata/corpus/sql/catalog/sequence/sequence_currval_before_nextval_supported.test create mode 100644 parser/testdata/corpus/sql/catalog/sequence/sequence_cycle.test create mode 100644 parser/testdata/corpus/sql/catalog/sequence/sequence_offset_increment.test create mode 100644 parser/testdata/corpus/sql/catalog/sequence/sequence_overflow.test create mode 100644 parser/testdata/corpus/sql/catalog/sequence/setval.test create mode 100644 parser/testdata/corpus/sql/catalog/sequence/test_duckdb_sequences.test create mode 100644 parser/testdata/corpus/sql/catalog/sequence/test_sequence.test create mode 100644 parser/testdata/corpus/sql/catalog/sequence/test_sequence.test.metadata.json create mode 100644 parser/testdata/corpus/sql/catalog/sequence/test_sequence_dependency.test create mode 100644 parser/testdata/corpus/sql/catalog/sequence/test_sequence_google_fuzz.test create mode 100644 parser/testdata/corpus/sql/catalog/table/create_table_as_abort.test create mode 100644 parser/testdata/corpus/sql/catalog/table/create_table_parameters.test create mode 100644 parser/testdata/corpus/sql/catalog/table/long_identifier.test create mode 100644 parser/testdata/corpus/sql/catalog/table/test_create_table_parallelism.test create mode 100644 parser/testdata/corpus/sql/catalog/table/test_default.test create mode 100644 parser/testdata/corpus/sql/catalog/table/test_default_not_null.test create mode 100644 parser/testdata/corpus/sql/catalog/table/test_default_values.test create mode 100644 parser/testdata/corpus/sql/catalog/table/test_default_values.test.metadata.json create mode 100644 parser/testdata/corpus/sql/catalog/table/test_many_columns.test create mode 100644 parser/testdata/corpus/sql/catalog/test_alter_oid_stability.test create mode 100644 parser/testdata/corpus/sql/catalog/test_catalog_errors.test create mode 100644 parser/testdata/corpus/sql/catalog/test_create_from_select.test create mode 100644 parser/testdata/corpus/sql/catalog/test_extension_suggestion.test create mode 100644 parser/testdata/corpus/sql/catalog/test_if_not_exists.test create mode 100644 parser/testdata/corpus/sql/catalog/test_incorrect_table_creation.test create mode 100644 parser/testdata/corpus/sql/catalog/test_incorrect_table_creation.test.metadata.json create mode 100644 parser/testdata/corpus/sql/catalog/test_querying_from_detached_catalog.test create mode 100644 parser/testdata/corpus/sql/catalog/test_quoted_column_name.test create mode 100644 parser/testdata/corpus/sql/catalog/test_schema.test create mode 100644 parser/testdata/corpus/sql/catalog/test_set_schema.test create mode 100644 parser/testdata/corpus/sql/catalog/test_set_search_path.test create mode 100644 parser/testdata/corpus/sql/catalog/test_set_search_path.test.metadata.json create mode 100644 parser/testdata/corpus/sql/catalog/test_standard_schema.test create mode 100644 parser/testdata/corpus/sql/catalog/test_temporary.test create mode 100644 parser/testdata/corpus/sql/catalog/test_temporary.test.metadata.json create mode 100644 parser/testdata/corpus/sql/catalog/test_unicode_schema.test create mode 100644 parser/testdata/corpus/sql/catalog/view/deferred_binding.test create mode 100644 parser/testdata/corpus/sql/catalog/view/recursive_view.test create mode 100644 parser/testdata/corpus/sql/catalog/view/recursive_view_with_dependencies.test create mode 100644 parser/testdata/corpus/sql/catalog/view/test_loosely_qualified_view_sql.test create mode 100644 parser/testdata/corpus/sql/catalog/view/test_stacked_view.test create mode 100644 parser/testdata/corpus/sql/catalog/view/test_view.test create mode 100644 parser/testdata/corpus/sql/catalog/view/test_view_alias.test create mode 100644 parser/testdata/corpus/sql/catalog/view/test_view_delete_update.test create mode 100644 parser/testdata/corpus/sql/catalog/view/test_view_drop_concurrent.test create mode 100644 parser/testdata/corpus/sql/catalog/view/test_view_duplicate_columns.test create mode 100644 parser/testdata/corpus/sql/catalog/view/test_view_schema_change.test create mode 100644 parser/testdata/corpus/sql/catalog/view/test_view_schema_change_with_dependencies.test create mode 100644 parser/testdata/corpus/sql/catalog/view/test_view_sql.test create mode 100644 parser/testdata/corpus/sql/catalog/view/test_view_sql_with_dependencies.test create mode 100644 parser/testdata/corpus/sql/catalog/view/view_if_not_exists.test create mode 100644 parser/testdata/corpus/sql/collate/collate_filter_pushdown.test create mode 100644 parser/testdata/corpus/sql/collate/collate_in_subquery.test create mode 100644 parser/testdata/corpus/sql/collate/collate_like.test create mode 100644 parser/testdata/corpus/sql/collate/collate_non_varchar.test create mode 100644 parser/testdata/corpus/sql/collate/collate_order_by_alias.test create mode 100644 parser/testdata/corpus/sql/collate/collate_ordered_aggregate.test create mode 100644 parser/testdata/corpus/sql/collate/collate_string_col.test create mode 100644 parser/testdata/corpus/sql/collate/collate_subquery.test create mode 100644 parser/testdata/corpus/sql/collate/collation_sort_keys.test create mode 100644 parser/testdata/corpus/sql/collate/icu_collation_propagation.test create mode 100644 parser/testdata/corpus/sql/collate/nop_collation_join_filter_pushdown.test create mode 100644 parser/testdata/corpus/sql/collate/test_collate_accent_insensitive.test create mode 100644 parser/testdata/corpus/sql/collate/test_collate_and_grouping_sets.test create mode 100644 parser/testdata/corpus/sql/collate/test_collate_between.test create mode 100644 parser/testdata/corpus/sql/collate/test_collate_case_insensitive.test create mode 100644 parser/testdata/corpus/sql/collate/test_collate_expression.test create mode 100644 parser/testdata/corpus/sql/collate/test_collate_list.test create mode 100644 parser/testdata/corpus/sql/collate/test_collate_list_contains.test create mode 100644 parser/testdata/corpus/sql/collate/test_collate_null_constant.test create mode 100644 parser/testdata/corpus/sql/collate/test_collate_orderby_column_number.test create mode 100644 parser/testdata/corpus/sql/collate/test_collate_pivot.test create mode 100644 parser/testdata/corpus/sql/collate/test_collation_propagation.test create mode 100644 parser/testdata/corpus/sql/collate/test_combined_collation.test create mode 100644 parser/testdata/corpus/sql/collate/test_default_collations.test create mode 100644 parser/testdata/corpus/sql/collate/test_icu_collate.test create mode 100644 parser/testdata/corpus/sql/collate/test_pragma_collations.test create mode 100644 parser/testdata/corpus/sql/collate/test_strpos_collate.test create mode 100644 parser/testdata/corpus/sql/collate/test_unsupported_collations.test create mode 100644 parser/testdata/corpus/sql/collate/test_unsupported_collations.test.metadata.json create mode 100644 parser/testdata/corpus/sql/conjunction/or_between.test create mode 100644 parser/testdata/corpus/sql/conjunction/or_comparison.test create mode 100644 parser/testdata/corpus/sql/connect/concurrent_connect_detach.test create mode 100644 parser/testdata/corpus/sql/connect/connect_quack.test create mode 100644 parser/testdata/corpus/sql/connect/connect_string_ephemeral.test create mode 100644 parser/testdata/corpus/sql/connect/connect_syntax.test create mode 100644 parser/testdata/corpus/sql/constraints/check/check_struct.test create mode 100644 parser/testdata/corpus/sql/constraints/check/test_check.test create mode 100644 parser/testdata/corpus/sql/constraints/check/test_check.test.metadata.json create mode 100644 parser/testdata/corpus/sql/constraints/check/test_update_check_non_updated_columns.test create mode 100644 parser/testdata/corpus/sql/constraints/foreignkey/fk_19469.test create mode 100644 parser/testdata/corpus/sql/constraints/foreignkey/fk_20530.test create mode 100644 parser/testdata/corpus/sql/constraints/foreignkey/fk_4309.test create mode 100644 parser/testdata/corpus/sql/constraints/foreignkey/fk_4365.test create mode 100644 parser/testdata/corpus/sql/constraints/foreignkey/fk_case_insensitivity.test create mode 100644 parser/testdata/corpus/sql/constraints/foreignkey/fk_implicit_primary_key.test create mode 100644 parser/testdata/corpus/sql/constraints/foreignkey/foreign_key_matching_columns.test create mode 100644 parser/testdata/corpus/sql/constraints/foreignkey/test_action.test create mode 100644 parser/testdata/corpus/sql/constraints/foreignkey/test_action.test.metadata.json create mode 100644 parser/testdata/corpus/sql/constraints/foreignkey/test_fk_alter.test create mode 100644 parser/testdata/corpus/sql/constraints/foreignkey/test_fk_chain.test create mode 100644 parser/testdata/corpus/sql/constraints/foreignkey/test_fk_concurrency_conflicts.test create mode 100644 parser/testdata/corpus/sql/constraints/foreignkey/test_fk_create_type.test create mode 100644 parser/testdata/corpus/sql/constraints/foreignkey/test_fk_cross_schema.test create mode 100644 parser/testdata/corpus/sql/constraints/foreignkey/test_fk_eager_constraint_checking.test create mode 100644 parser/testdata/corpus/sql/constraints/foreignkey/test_fk_export.test create mode 100644 parser/testdata/corpus/sql/constraints/foreignkey/test_fk_multiple.test create mode 100644 parser/testdata/corpus/sql/constraints/foreignkey/test_fk_on_view_error.test create mode 100644 parser/testdata/corpus/sql/constraints/foreignkey/test_fk_pk_multi_transaction_delete.test create mode 100644 parser/testdata/corpus/sql/constraints/foreignkey/test_fk_rollback.test create mode 100644 parser/testdata/corpus/sql/constraints/foreignkey/test_fk_self_reference_export.test create mode 100644 parser/testdata/corpus/sql/constraints/foreignkey/test_fk_self_referencing.test create mode 100644 parser/testdata/corpus/sql/constraints/foreignkey/test_fk_temporary.test create mode 100644 parser/testdata/corpus/sql/constraints/foreignkey/test_fk_transaction.test create mode 100644 parser/testdata/corpus/sql/constraints/foreignkey/test_fk_with_attached_db.test create mode 100644 parser/testdata/corpus/sql/constraints/foreignkey/test_foreignkey.test create mode 100644 parser/testdata/corpus/sql/constraints/foreignkey/test_foreignkey.test.metadata.json create mode 100644 parser/testdata/corpus/sql/constraints/primarykey/test_pk_bool.test create mode 100644 parser/testdata/corpus/sql/constraints/primarykey/test_pk_col_subset.test create mode 100644 parser/testdata/corpus/sql/constraints/primarykey/test_pk_concurrency_conflicts.test create mode 100644 parser/testdata/corpus/sql/constraints/primarykey/test_pk_many_columns.test create mode 100644 parser/testdata/corpus/sql/constraints/primarykey/test_pk_multi_column.test create mode 100644 parser/testdata/corpus/sql/constraints/primarykey/test_pk_multi_string.test create mode 100644 parser/testdata/corpus/sql/constraints/primarykey/test_pk_rollback.test create mode 100644 parser/testdata/corpus/sql/constraints/primarykey/test_pk_string.test create mode 100644 parser/testdata/corpus/sql/constraints/primarykey/test_pk_update_delete.test create mode 100644 parser/testdata/corpus/sql/constraints/primarykey/test_pk_updel_local.test create mode 100644 parser/testdata/corpus/sql/constraints/primarykey/test_pk_updel_multi_column.test create mode 100644 parser/testdata/corpus/sql/constraints/primarykey/test_primary_key.test create mode 100644 parser/testdata/corpus/sql/constraints/test_constraint_with_updates.test create mode 100644 parser/testdata/corpus/sql/constraints/test_not_null.test create mode 100644 parser/testdata/corpus/sql/constraints/unique/test_unique.test create mode 100644 parser/testdata/corpus/sql/constraints/unique/test_unique_error.test create mode 100644 parser/testdata/corpus/sql/constraints/unique/test_unique_multi_column.test create mode 100644 parser/testdata/corpus/sql/constraints/unique/test_unique_multi_constraint.test create mode 100644 parser/testdata/corpus/sql/constraints/unique/test_unique_string.test create mode 100644 parser/testdata/corpus/sql/constraints/unique/test_unique_temp.test create mode 100644 parser/testdata/corpus/sql/copy/async_file_lifecycle.test create mode 100644 parser/testdata/corpus/sql/copy/copy_blob.test create mode 100644 parser/testdata/corpus/sql/copy/copy_cte.test create mode 100644 parser/testdata/corpus/sql/copy/copy_cte.test.metadata.json create mode 100644 parser/testdata/corpus/sql/copy/csv/14512.test create mode 100644 parser/testdata/corpus/sql/copy/csv/14874.test create mode 100644 parser/testdata/corpus/sql/copy/csv/17738.test create mode 100644 parser/testdata/corpus/sql/copy/csv/17744.test create mode 100644 parser/testdata/corpus/sql/copy/csv/18579.test create mode 100644 parser/testdata/corpus/sql/copy/csv/19578.test create mode 100644 parser/testdata/corpus/sql/copy/csv/21248.test create mode 100644 parser/testdata/corpus/sql/copy/csv/7702.test create mode 100644 parser/testdata/corpus/sql/copy/csv/afl/fuzz_20250211_crash.test create mode 100644 parser/testdata/corpus/sql/copy/csv/afl/fuzz_20250226.test create mode 100644 parser/testdata/corpus/sql/copy/csv/afl/test_afl_ignore_errors.test create mode 100644 parser/testdata/corpus/sql/copy/csv/afl/test_afl_no_parameter.test create mode 100644 parser/testdata/corpus/sql/copy/csv/afl/test_afl_null_padding.test create mode 100644 parser/testdata/corpus/sql/copy/csv/afl/test_afl_skip.test create mode 100644 parser/testdata/corpus/sql/copy/csv/afl/test_fuzz_3977.test create mode 100644 parser/testdata/corpus/sql/copy/csv/afl/test_fuzz_4086.test create mode 100644 parser/testdata/corpus/sql/copy/csv/afl/test_fuzz_4172.test create mode 100644 parser/testdata/corpus/sql/copy/csv/afl/test_fuzz_4234.test create mode 100644 parser/testdata/corpus/sql/copy/csv/afl/test_fuzz_4329.test create mode 100644 parser/testdata/corpus/sql/copy/csv/afl/test_fuzz_4379.test create mode 100644 parser/testdata/corpus/sql/copy/csv/afl/test_fuzz_4496.test create mode 100644 parser/testdata/corpus/sql/copy/csv/afl/test_fuzz_4793.test create mode 100644 parser/testdata/corpus/sql/copy/csv/afl/test_fuzz_5194.test create mode 100644 parser/testdata/corpus/sql/copy/csv/allow_empty.test create mode 100644 parser/testdata/corpus/sql/copy/csv/auto/test_14177.test create mode 100644 parser/testdata/corpus/sql/copy/csv/auto/test_auto_5250.test create mode 100644 parser/testdata/corpus/sql/copy/csv/auto/test_auto_5378.test create mode 100644 parser/testdata/corpus/sql/copy/csv/auto/test_auto_8231.test create mode 100644 parser/testdata/corpus/sql/copy/csv/auto/test_auto_8573.test create mode 100644 parser/testdata/corpus/sql/copy/csv/auto/test_auto_8649.test create mode 100644 parser/testdata/corpus/sql/copy/csv/auto/test_auto_8860.test create mode 100644 parser/testdata/corpus/sql/copy/csv/auto/test_auto_column_type_opt.test create mode 100644 parser/testdata/corpus/sql/copy/csv/auto/test_auto_cranlogs.test create mode 100644 parser/testdata/corpus/sql/copy/csv/auto/test_auto_greek_ncvoter.test create mode 100644 parser/testdata/corpus/sql/copy/csv/auto/test_auto_greek_utf8.test create mode 100644 parser/testdata/corpus/sql/copy/csv/auto/test_auto_imdb.test create mode 100644 parser/testdata/corpus/sql/copy/csv/auto/test_auto_lineitem.test create mode 100644 parser/testdata/corpus/sql/copy/csv/auto/test_auto_ontime.test create mode 100644 parser/testdata/corpus/sql/copy/csv/auto/test_auto_web_page.test create mode 100644 parser/testdata/corpus/sql/copy/csv/auto/test_csv_auto.test create mode 100644 parser/testdata/corpus/sql/copy/csv/auto/test_date_format_bug_linux.test create mode 100644 parser/testdata/corpus/sql/copy/csv/auto/test_describe_order.test create mode 100644 parser/testdata/corpus/sql/copy/csv/auto/test_double_quoted_header.test create mode 100644 parser/testdata/corpus/sql/copy/csv/auto/test_early_out.test create mode 100644 parser/testdata/corpus/sql/copy/csv/auto/test_header_completion.test create mode 100644 parser/testdata/corpus/sql/copy/csv/auto/test_header_detection.test create mode 100644 parser/testdata/corpus/sql/copy/csv/auto/test_large_integer_detection.test create mode 100644 parser/testdata/corpus/sql/copy/csv/auto/test_normalize_names.test create mode 100644 parser/testdata/corpus/sql/copy/csv/auto/test_sample_size.test create mode 100644 parser/testdata/corpus/sql/copy/csv/auto/test_sniffer_blob.test create mode 100644 parser/testdata/corpus/sql/copy/csv/auto/test_sniffer_empty_start_value.test create mode 100644 parser/testdata/corpus/sql/copy/csv/auto/test_timings_csv.test create mode 100644 parser/testdata/corpus/sql/copy/csv/auto/test_type_candidates.test create mode 100644 parser/testdata/corpus/sql/copy/csv/auto/test_type_detection.test create mode 100644 parser/testdata/corpus/sql/copy/csv/auto_glob_directory.test create mode 100644 parser/testdata/corpus/sql/copy/csv/code_cov/buffer_manager_finalize.test create mode 100644 parser/testdata/corpus/sql/copy/csv/code_cov/csv_dialect_detection.test create mode 100644 parser/testdata/corpus/sql/copy/csv/code_cov/csv_exact_buffer_size.test create mode 100644 parser/testdata/corpus/sql/copy/csv/code_cov/csv_sniffer_header.test create mode 100644 parser/testdata/corpus/sql/copy/csv/code_cov/csv_state_machine_invalid_utf.test create mode 100644 parser/testdata/corpus/sql/copy/csv/code_cov/csv_type_detection.test create mode 100644 parser/testdata/corpus/sql/copy/csv/code_cov/csv_type_refinement.test create mode 100644 parser/testdata/corpus/sql/copy/csv/column_names.test create mode 100644 parser/testdata/corpus/sql/copy/csv/copy_disable_parallelism.test create mode 100644 parser/testdata/corpus/sql/copy/csv/copy_expression.test create mode 100644 parser/testdata/corpus/sql/copy/csv/copy_to_overwrite.test create mode 100644 parser/testdata/corpus/sql/copy/csv/csv_copy_sniffer.test create mode 100644 parser/testdata/corpus/sql/copy/csv/csv_decimal_separator.test create mode 100644 parser/testdata/corpus/sql/copy/csv/csv_dtypes.test create mode 100644 parser/testdata/corpus/sql/copy/csv/csv_dtypes_union_by_name.test create mode 100644 parser/testdata/corpus/sql/copy/csv/csv_duck_fuzz.test create mode 100644 parser/testdata/corpus/sql/copy/csv/csv_duck_fuzz.test.metadata.json create mode 100644 parser/testdata/corpus/sql/copy/csv/csv_enum.test create mode 100644 parser/testdata/corpus/sql/copy/csv/csv_error_message.test create mode 100644 parser/testdata/corpus/sql/copy/csv/csv_external_access.test create mode 100644 parser/testdata/corpus/sql/copy/csv/csv_glob_fallback.test create mode 100644 parser/testdata/corpus/sql/copy/csv/csv_hive.test create mode 100644 parser/testdata/corpus/sql/copy/csv/csv_hive_filename_union.test create mode 100644 parser/testdata/corpus/sql/copy/csv/csv_home_directory.test create mode 100644 parser/testdata/corpus/sql/copy/csv/csv_limit_copy.test create mode 100644 parser/testdata/corpus/sql/copy/csv/csv_line_too_long.test create mode 100644 parser/testdata/corpus/sql/copy/csv/csv_names.test create mode 100644 parser/testdata/corpus/sql/copy/csv/csv_null_byte.test create mode 100644 parser/testdata/corpus/sql/copy/csv/csv_null_padding.test create mode 100644 parser/testdata/corpus/sql/copy/csv/csv_nullstr_list.test create mode 100644 parser/testdata/corpus/sql/copy/csv/csv_projection_pushdown.test create mode 100644 parser/testdata/corpus/sql/copy/csv/csv_quoted_newline_incorrect.test create mode 100644 parser/testdata/corpus/sql/copy/csv/csv_roundtrip_single_null.test create mode 100644 parser/testdata/corpus/sql/copy/csv/csv_windows_mixed_separators.test create mode 100644 parser/testdata/corpus/sql/copy/csv/duck_fuzz/test_internal_4048.test create mode 100644 parser/testdata/corpus/sql/copy/csv/empty_first_line.test create mode 100644 parser/testdata/corpus/sql/copy/csv/empty_string_quote.test create mode 100644 parser/testdata/corpus/sql/copy/csv/except.test create mode 100644 parser/testdata/corpus/sql/copy/csv/glob/copy_csv_glob.test create mode 100644 parser/testdata/corpus/sql/copy/csv/glob/read_csv_glob.test create mode 100644 parser/testdata/corpus/sql/copy/csv/glob/read_csv_glob.test.metadata.json create mode 100644 parser/testdata/corpus/sql/copy/csv/glob/test_unmatch_globs.test create mode 100644 parser/testdata/corpus/sql/copy/csv/inconsistent_cells_error.test create mode 100644 parser/testdata/corpus/sql/copy/csv/integer_exponent.test create mode 100644 parser/testdata/corpus/sql/copy/csv/issue_22153.test create mode 100644 parser/testdata/corpus/sql/copy/csv/issue_6690.test create mode 100644 parser/testdata/corpus/sql/copy/csv/issue_6764.test create mode 100644 parser/testdata/corpus/sql/copy/csv/leading_zeros_autodetect.test create mode 100644 parser/testdata/corpus/sql/copy/csv/multidelimiter/test_2_byte_delimiter.test create mode 100644 parser/testdata/corpus/sql/copy/csv/multidelimiter/test_3_4_byte_delimiter.test create mode 100644 parser/testdata/corpus/sql/copy/csv/multidelimiter/test_abac.test create mode 100644 parser/testdata/corpus/sql/copy/csv/multidelimiter/test_options_inconsistencies.test create mode 100644 parser/testdata/corpus/sql/copy/csv/null_padding_big.test create mode 100644 parser/testdata/corpus/sql/copy/csv/null_terminator.test create mode 100644 parser/testdata/corpus/sql/copy/csv/null_value_wrong_type.test create mode 100644 parser/testdata/corpus/sql/copy/csv/overwrite/test_copy_overwrite.test create mode 100644 parser/testdata/corpus/sql/copy/csv/overwrite/test_overwrite_pipe_windows.test create mode 100644 parser/testdata/corpus/sql/copy/csv/parallel/csv_parallel_buffer_size.test create mode 100644 parser/testdata/corpus/sql/copy/csv/parallel/csv_parallel_null_option.test create mode 100644 parser/testdata/corpus/sql/copy/csv/parallel/parallel_csv_hive_partitioning.test create mode 100644 parser/testdata/corpus/sql/copy/csv/parallel/parallel_csv_union_by_name.test create mode 100644 parser/testdata/corpus/sql/copy/csv/parallel/test_5438.test create mode 100644 parser/testdata/corpus/sql/copy/csv/parallel/test_5566.test create mode 100644 parser/testdata/corpus/sql/copy/csv/parallel/test_7578.test create mode 100644 parser/testdata/corpus/sql/copy/csv/parallel/test_multiple_files.test create mode 100644 parser/testdata/corpus/sql/copy/csv/parallel/test_parallel_csv.test create mode 100644 parser/testdata/corpus/sql/copy/csv/parallel/test_parallel_error_messages.test create mode 100644 parser/testdata/corpus/sql/copy/csv/plus_autodetect.test create mode 100644 parser/testdata/corpus/sql/copy/csv/pollock/test_field_delimiter.test create mode 100644 parser/testdata/corpus/sql/copy/csv/pollock/test_quotation_char.test create mode 100644 parser/testdata/corpus/sql/copy/csv/read_ahead/csv_readahead_gzip.test create mode 100644 parser/testdata/corpus/sql/copy/csv/read_ahead/csv_readahead_multi_file.test create mode 100644 parser/testdata/corpus/sql/copy/csv/read_ahead/csv_readahead_rejects.test create mode 100644 parser/testdata/corpus/sql/copy/csv/read_ahead/csv_readahead_single_file.test create mode 100644 parser/testdata/corpus/sql/copy/csv/read_csv_subquery.test create mode 100644 parser/testdata/corpus/sql/copy/csv/read_csv_variable.test create mode 100644 parser/testdata/corpus/sql/copy/csv/read_csv_variable.test.metadata.json create mode 100644 parser/testdata/corpus/sql/copy/csv/recursive_csv_union_by_name.test create mode 100644 parser/testdata/corpus/sql/copy/csv/recursive_read_csv.test create mode 100644 parser/testdata/corpus/sql/copy/csv/rejects/csv_incorrect_columns_amount_rejects.test create mode 100644 parser/testdata/corpus/sql/copy/csv/rejects/csv_rejects_auto.test create mode 100644 parser/testdata/corpus/sql/copy/csv/rejects/csv_rejects_flush_cast.test create mode 100644 parser/testdata/corpus/sql/copy/csv/rejects/csv_rejects_flush_message.test create mode 100644 parser/testdata/corpus/sql/copy/csv/rejects/csv_rejects_maximum_line.test create mode 100644 parser/testdata/corpus/sql/copy/csv/rejects/csv_rejects_read.test create mode 100644 parser/testdata/corpus/sql/copy/csv/rejects/csv_rejects_truncate_line_invalid_utf8.test create mode 100644 parser/testdata/corpus/sql/copy/csv/rejects/csv_rejects_two_tables.test create mode 100644 parser/testdata/corpus/sql/copy/csv/rejects/csv_unquoted_rejects.test create mode 100644 parser/testdata/corpus/sql/copy/csv/rejects/test_invalid_parameters.test create mode 100644 parser/testdata/corpus/sql/copy/csv/rejects/test_invalid_utf_rejects.test create mode 100644 parser/testdata/corpus/sql/copy/csv/rejects/test_mixed.test create mode 100644 parser/testdata/corpus/sql/copy/csv/rejects/test_multiple_errors_same_line.test create mode 100644 parser/testdata/corpus/sql/copy/csv/relaxed_quotes.test create mode 100644 parser/testdata/corpus/sql/copy/csv/struct.test create mode 100644 parser/testdata/corpus/sql/copy/csv/struct_padding.test create mode 100644 parser/testdata/corpus/sql/copy/csv/test_11403.test create mode 100644 parser/testdata/corpus/sql/copy/csv/test_11840.test create mode 100644 parser/testdata/corpus/sql/copy/csv/test_12596.test create mode 100644 parser/testdata/corpus/sql/copy/csv/test_15473.test create mode 100644 parser/testdata/corpus/sql/copy/csv/test_8890.test create mode 100644 parser/testdata/corpus/sql/copy/csv/test_9005.test create mode 100644 parser/testdata/corpus/sql/copy/csv/test_afl.test create mode 100644 parser/testdata/corpus/sql/copy/csv/test_all_quotes.test create mode 100644 parser/testdata/corpus/sql/copy/csv/test_allow_quoted_nulls_option.test create mode 100644 parser/testdata/corpus/sql/copy/csv/test_auto_date.test create mode 100644 parser/testdata/corpus/sql/copy/csv/test_auto_detection_headers.test create mode 100644 parser/testdata/corpus/sql/copy/csv/test_bgzf_read.test create mode 100644 parser/testdata/corpus/sql/copy/csv/test_big_header.test create mode 100644 parser/testdata/corpus/sql/copy/csv/test_blob.test create mode 100644 parser/testdata/corpus/sql/copy/csv/test_bug_10273.test create mode 100644 parser/testdata/corpus/sql/copy/csv/test_column_inconsistencies.test create mode 100644 parser/testdata/corpus/sql/copy/csv/test_comment_midline.test create mode 100644 parser/testdata/corpus/sql/copy/csv/test_comment_option.test create mode 100644 parser/testdata/corpus/sql/copy/csv/test_compression_flag.test create mode 100644 parser/testdata/corpus/sql/copy/csv/test_copy.test create mode 100644 parser/testdata/corpus/sql/copy/csv/test_copy.test.metadata.json create mode 100644 parser/testdata/corpus/sql/copy/csv/test_copy_default.test create mode 100644 parser/testdata/corpus/sql/copy/csv/test_copy_gzip.test create mode 100644 parser/testdata/corpus/sql/copy/csv/test_copy_many_empty_lines.test create mode 100644 parser/testdata/corpus/sql/copy/csv/test_copy_null.test create mode 100644 parser/testdata/corpus/sql/copy/csv/test_csv_duplicate_columns.test create mode 100644 parser/testdata/corpus/sql/copy/csv/test_csv_error_message_type.test create mode 100644 parser/testdata/corpus/sql/copy/csv/test_csv_json.test create mode 100644 parser/testdata/corpus/sql/copy/csv/test_csv_mixed_casts.test create mode 100644 parser/testdata/corpus/sql/copy/csv/test_csv_no_trailing_newline.test create mode 100644 parser/testdata/corpus/sql/copy/csv/test_csv_projection_pushdown.test create mode 100644 parser/testdata/corpus/sql/copy/csv/test_csv_projection_pushdown_glob.test create mode 100644 parser/testdata/corpus/sql/copy/csv/test_csv_timestamp_tz.test create mode 100644 parser/testdata/corpus/sql/copy/csv/test_csv_timestamp_tz_icu.test create mode 100644 parser/testdata/corpus/sql/copy/csv/test_date.test create mode 100644 parser/testdata/corpus/sql/copy/csv/test_date_sniffer.test create mode 100644 parser/testdata/corpus/sql/copy/csv/test_dateformat.test create mode 100644 parser/testdata/corpus/sql/copy/csv/test_decimal.test create mode 100644 parser/testdata/corpus/sql/copy/csv/test_double_sniffer.test create mode 100644 parser/testdata/corpus/sql/copy/csv/test_empty_header.test create mode 100644 parser/testdata/corpus/sql/copy/csv/test_empty_quote.test create mode 100644 parser/testdata/corpus/sql/copy/csv/test_enum_csv.test create mode 100644 parser/testdata/corpus/sql/copy/csv/test_escape_long_value.test create mode 100644 parser/testdata/corpus/sql/copy/csv/test_export_force_quotes.test create mode 100644 parser/testdata/corpus/sql/copy/csv/test_export_not_null.test create mode 100644 parser/testdata/corpus/sql/copy/csv/test_extra_delimiters_rfc.test create mode 100644 parser/testdata/corpus/sql/copy/csv/test_filename_filter.test create mode 100644 parser/testdata/corpus/sql/copy/csv/test_force_not_null.test create mode 100644 parser/testdata/corpus/sql/copy/csv/test_force_quote.test create mode 100644 parser/testdata/corpus/sql/copy/csv/test_glob_reorder_lineitem.test create mode 100644 parser/testdata/corpus/sql/copy/csv/test_glob_reorder_null.test create mode 100644 parser/testdata/corpus/sql/copy/csv/test_glob_type.test create mode 100644 parser/testdata/corpus/sql/copy/csv/test_greek_utf8.test create mode 100644 parser/testdata/corpus/sql/copy/csv/test_header_only.test create mode 100644 parser/testdata/corpus/sql/copy/csv/test_headers_12089.test create mode 100644 parser/testdata/corpus/sql/copy/csv/test_hits_problematic.test create mode 100644 parser/testdata/corpus/sql/copy/csv/test_ignore_errors.test create mode 100644 parser/testdata/corpus/sql/copy/csv/test_ignore_errors_end_of_chunk.test create mode 100644 parser/testdata/corpus/sql/copy/csv/test_ignore_mid_null_line.test create mode 100644 parser/testdata/corpus/sql/copy/csv/test_imdb.test create mode 100644 parser/testdata/corpus/sql/copy/csv/test_infinite_loop_escape.test create mode 100644 parser/testdata/corpus/sql/copy/csv/test_insert_into_types.test create mode 100644 parser/testdata/corpus/sql/copy/csv/test_issue3562_assertion.test create mode 100644 parser/testdata/corpus/sql/copy/csv/test_issue5077.test create mode 100644 parser/testdata/corpus/sql/copy/csv/test_lineitem.test create mode 100644 parser/testdata/corpus/sql/copy/csv/test_lineitem_gz.test create mode 100644 parser/testdata/corpus/sql/copy/csv/test_linesize.test create mode 100644 parser/testdata/corpus/sql/copy/csv/test_long_line.test create mode 100644 parser/testdata/corpus/sql/copy/csv/test_many_columns.test create mode 100644 parser/testdata/corpus/sql/copy/csv/test_mismatch_schemas.test create mode 100644 parser/testdata/corpus/sql/copy/csv/test_missing_row.test create mode 100644 parser/testdata/corpus/sql/copy/csv/test_mixed_line_endings.test create mode 100644 parser/testdata/corpus/sql/copy/csv/test_mixed_new_line.test create mode 100644 parser/testdata/corpus/sql/copy/csv/test_ncvoter.test create mode 100644 parser/testdata/corpus/sql/copy/csv/test_nfc.test create mode 100644 parser/testdata/corpus/sql/copy/csv/test_nfc_suite.test create mode 100644 parser/testdata/corpus/sql/copy/csv/test_non_unicode_header.test create mode 100644 parser/testdata/corpus/sql/copy/csv/test_null_padding_projection.test create mode 100644 parser/testdata/corpus/sql/copy/csv/test_null_padding_union.test create mode 100644 parser/testdata/corpus/sql/copy/csv/test_ontime.test create mode 100644 parser/testdata/corpus/sql/copy/csv/test_parallel_nullpadding.test create mode 100644 parser/testdata/corpus/sql/copy/csv/test_partition_compression.test create mode 100644 parser/testdata/corpus/sql/copy/csv/test_prefix_suffix.test create mode 100644 parser/testdata/corpus/sql/copy/csv/test_quote_default.test create mode 100644 parser/testdata/corpus/sql/copy/csv/test_quoted_later_escaped.test create mode 100644 parser/testdata/corpus/sql/copy/csv/test_quoted_newline.test create mode 100644 parser/testdata/corpus/sql/copy/csv/test_read_csv.test create mode 100644 parser/testdata/corpus/sql/copy/csv/test_replacement_scan_alias.test create mode 100644 parser/testdata/corpus/sql/copy/csv/test_segfault.test create mode 100644 parser/testdata/corpus/sql/copy/csv/test_skip_bom.test create mode 100644 parser/testdata/corpus/sql/copy/csv/test_skip_header.test create mode 100644 parser/testdata/corpus/sql/copy/csv/test_sniff_csv.test create mode 100644 parser/testdata/corpus/sql/copy/csv/test_sniff_csv_options.test create mode 100644 parser/testdata/corpus/sql/copy/csv/test_sniffer_hang.test create mode 100644 parser/testdata/corpus/sql/copy/csv/test_sniffer_tab_delimiter.test create mode 100644 parser/testdata/corpus/sql/copy/csv/test_soccer_kaggle.test create mode 100644 parser/testdata/corpus/sql/copy/csv/test_thijs_unquoted_file.test create mode 100644 parser/testdata/corpus/sql/copy/csv/test_thousands_separator.test create mode 100644 parser/testdata/corpus/sql/copy/csv/test_time.test create mode 100644 parser/testdata/corpus/sql/copy/csv/test_timestamp_offset.test create mode 100644 parser/testdata/corpus/sql/copy/csv/test_timestamptz_12926.test create mode 100644 parser/testdata/corpus/sql/copy/csv/test_union_by_name.test create mode 100644 parser/testdata/corpus/sql/copy/csv/test_union_by_name_types.test create mode 100644 parser/testdata/corpus/sql/copy/csv/test_validator.test create mode 100644 parser/testdata/corpus/sql/copy/csv/test_web_page.test create mode 100644 parser/testdata/corpus/sql/copy/csv/test_windows_newline.test create mode 100644 parser/testdata/corpus/sql/copy/csv/test_wrong_newline_delimiter.test create mode 100644 parser/testdata/corpus/sql/copy/csv/timestamp_with_tz.test create mode 100644 parser/testdata/corpus/sql/copy/csv/tsv_copy.test create mode 100644 parser/testdata/corpus/sql/copy/csv/unicode_filename.test create mode 100644 parser/testdata/corpus/sql/copy/csv/unquoted_escape/basic.test create mode 100644 parser/testdata/corpus/sql/copy/csv/unquoted_escape/human_eval.test create mode 100644 parser/testdata/corpus/sql/copy/csv/unquoted_escape/identical.test create mode 100644 parser/testdata/corpus/sql/copy/csv/unquoted_escape/mixed.test create mode 100644 parser/testdata/corpus/sql/copy/csv/write_header_default.test create mode 100644 parser/testdata/corpus/sql/copy/csv/zstd_crash.test create mode 100644 parser/testdata/corpus/sql/copy/csv/zstd_fs.test create mode 100644 parser/testdata/corpus/sql/copy/encryption/concurrent_encrypted_attach.test create mode 100644 parser/testdata/corpus/sql/copy/encryption/different_aes_ciphers.test create mode 100644 parser/testdata/corpus/sql/copy/encryption/different_encryption_versions_and_ciphers.test create mode 100644 parser/testdata/corpus/sql/copy/encryption/encryption_storage_versions.test create mode 100644 parser/testdata/corpus/sql/copy/encryption/force_mbedtls.test create mode 100644 parser/testdata/corpus/sql/copy/encryption/test_different_encryption_versions.test create mode 100644 parser/testdata/corpus/sql/copy/encryption/unencrypted_to_encrypted.test create mode 100644 parser/testdata/corpus/sql/copy/encryption/unencrypted_to_encrypted_direct_query.test create mode 100644 parser/testdata/corpus/sql/copy/encryption/write_encrypted_database.test create mode 100644 parser/testdata/corpus/sql/copy/file_size_bytes.test create mode 100644 parser/testdata/corpus/sql/copy/format_uuid.test create mode 100644 parser/testdata/corpus/sql/copy/hive_partition_null_overwrite.test create mode 100644 parser/testdata/corpus/sql/copy/parquet/afl.test create mode 100644 parser/testdata/corpus/sql/copy/parquet/allow_empty.test create mode 100644 parser/testdata/corpus/sql/copy/parquet/alltypes-dictionaries.test create mode 100644 parser/testdata/corpus/sql/copy/parquet/attach_parquet.test create mode 100644 parser/testdata/corpus/sql/copy/parquet/auto_glob_directory.test create mode 100644 parser/testdata/corpus/sql/copy/parquet/aws2.test create mode 100644 parser/testdata/corpus/sql/copy/parquet/aws_kinesis.test create mode 100644 parser/testdata/corpus/sql/copy/parquet/bigdecimal.test create mode 100644 parser/testdata/corpus/sql/copy/parquet/bloom_filter_decimal.test create mode 100644 parser/testdata/corpus/sql/copy/parquet/bloom_filter_interval.test create mode 100644 parser/testdata/corpus/sql/copy/parquet/bloom_filters.test create mode 100644 parser/testdata/corpus/sql/copy/parquet/broken_parquet.test create mode 100644 parser/testdata/corpus/sql/copy/parquet/byte_stream_split.test create mode 100644 parser/testdata/corpus/sql/copy/parquet/case_insensitive_replacement.test create mode 100644 parser/testdata/corpus/sql/copy/parquet/copy_ninf_stats.test create mode 100644 parser/testdata/corpus/sql/copy/parquet/copy_option_non_foldable.test create mode 100644 parser/testdata/corpus/sql/copy/parquet/copy_option_prepared.test create mode 100644 parser/testdata/corpus/sql/copy/parquet/copy_option_suggestion.test create mode 100644 parser/testdata/corpus/sql/copy/parquet/corrupt_stats.test create mode 100644 parser/testdata/corpus/sql/copy/parquet/cte_batch_exchange.test create mode 100644 parser/testdata/corpus/sql/copy/parquet/decimal_filter.test create mode 100644 parser/testdata/corpus/sql/copy/parquet/delta_byte_array.test create mode 100644 parser/testdata/corpus/sql/copy/parquet/describe_parquet.test create mode 100644 parser/testdata/corpus/sql/copy/parquet/dictionary_compression_ratio_threshold.test create mode 100644 parser/testdata/corpus/sql/copy/parquet/encryption/arrow_compatibility.test create mode 100644 parser/testdata/corpus/sql/copy/parquet/enum_converted_type.test create mode 100644 parser/testdata/corpus/sql/copy/parquet/file_metadata.test create mode 100644 parser/testdata/corpus/sql/copy/parquet/fixed.test create mode 100644 parser/testdata/corpus/sql/copy/parquet/float16.test create mode 100644 parser/testdata/corpus/sql/copy/parquet/hive_partitioning_struct.test create mode 100644 parser/testdata/corpus/sql/copy/parquet/hive_timestamps.test create mode 100644 parser/testdata/corpus/sql/copy/parquet/incorrect_converted_type.test create mode 100644 parser/testdata/corpus/sql/copy/parquet/infer_copy_format.test create mode 100644 parser/testdata/corpus/sql/copy/parquet/invalid_utf8_stats.test create mode 100644 parser/testdata/corpus/sql/copy/parquet/issue_21508.test create mode 100644 parser/testdata/corpus/sql/copy/parquet/json_parquet.test create mode 100644 parser/testdata/corpus/sql/copy/parquet/kv_metadata.test create mode 100644 parser/testdata/corpus/sql/copy/parquet/lineitem_arrow.test create mode 100644 parser/testdata/corpus/sql/copy/parquet/metadata_full.test create mode 100644 parser/testdata/corpus/sql/copy/parquet/multi_file/adaptive_filter_carryover.test create mode 100644 parser/testdata/corpus/sql/copy/parquet/multi_file/multi_file_filter_integer_types.test create mode 100644 parser/testdata/corpus/sql/copy/parquet/multi_file/multi_file_filter_mixed.test create mode 100644 parser/testdata/corpus/sql/copy/parquet/multi_file/multi_file_filter_struct.test create mode 100644 parser/testdata/corpus/sql/copy/parquet/multi_file_conversion_error.test create mode 100644 parser/testdata/corpus/sql/copy/parquet/parallel_parquet_glob.test create mode 100644 parser/testdata/corpus/sql/copy/parquet/parquet2.test create mode 100644 parser/testdata/corpus/sql/copy/parquet/parquet2strings.test create mode 100644 parser/testdata/corpus/sql/copy/parquet/parquet_10148.test create mode 100644 parser/testdata/corpus/sql/copy/parquet/parquet_10279.test create mode 100644 parser/testdata/corpus/sql/copy/parquet/parquet_12621.test create mode 100644 parser/testdata/corpus/sql/copy/parquet/parquet_13053_duplicate_column_names.test create mode 100644 parser/testdata/corpus/sql/copy/parquet/parquet_1554.test create mode 100644 parser/testdata/corpus/sql/copy/parquet/parquet_1588.test create mode 100644 parser/testdata/corpus/sql/copy/parquet/parquet_1589.test create mode 100644 parser/testdata/corpus/sql/copy/parquet/parquet_1618_struct_strings.test create mode 100644 parser/testdata/corpus/sql/copy/parquet/parquet_1619.test create mode 100644 parser/testdata/corpus/sql/copy/parquet/parquet_22147_union_by_name_nonnested.test create mode 100644 parser/testdata/corpus/sql/copy/parquet/parquet_2267.test create mode 100644 parser/testdata/corpus/sql/copy/parquet/parquet_3896.test create mode 100644 parser/testdata/corpus/sql/copy/parquet/parquet_3989.test create mode 100644 parser/testdata/corpus/sql/copy/parquet/parquet_4442.test create mode 100644 parser/testdata/corpus/sql/copy/parquet/parquet_4859.test create mode 100644 parser/testdata/corpus/sql/copy/parquet/parquet_4903.test create mode 100644 parser/testdata/corpus/sql/copy/parquet/parquet_5209.test create mode 100644 parser/testdata/corpus/sql/copy/parquet/parquet_6044.test create mode 100644 parser/testdata/corpus/sql/copy/parquet/parquet_6580.test create mode 100644 parser/testdata/corpus/sql/copy/parquet/parquet_6630_union_by_name.test create mode 100644 parser/testdata/corpus/sql/copy/parquet/parquet_6933.test create mode 100644 parser/testdata/corpus/sql/copy/parquet/parquet_all_null_column.test create mode 100644 parser/testdata/corpus/sql/copy/parquet/parquet_arrow_timestamp.test create mode 100644 parser/testdata/corpus/sql/copy/parquet/parquet_blob.test create mode 100644 parser/testdata/corpus/sql/copy/parquet/parquet_blob_string.test create mode 100644 parser/testdata/corpus/sql/copy/parquet/parquet_bloom_filter_corruption.test create mode 100644 parser/testdata/corpus/sql/copy/parquet/parquet_column_metadata_corruption.test create mode 100644 parser/testdata/corpus/sql/copy/parquet/parquet_copy_failure_cleans_up.test create mode 100644 parser/testdata/corpus/sql/copy/parquet/parquet_copy_type_mismatch.test create mode 100644 parser/testdata/corpus/sql/copy/parquet/parquet_corrupt_stats.test create mode 100644 parser/testdata/corpus/sql/copy/parquet/parquet_count_star.test create mode 100644 parser/testdata/corpus/sql/copy/parquet/parquet_debug_use_openssl.test create mode 100644 parser/testdata/corpus/sql/copy/parquet/parquet_dictionary_zero_sum_aggregate.test create mode 100644 parser/testdata/corpus/sql/copy/parquet/parquet_encoding_skip.test create mode 100644 parser/testdata/corpus/sql/copy/parquet/parquet_encryption.test create mode 100644 parser/testdata/corpus/sql/copy/parquet/parquet_enum_test.test create mode 100644 parser/testdata/corpus/sql/copy/parquet/parquet_expression_filter.test create mode 100644 parser/testdata/corpus/sql/copy/parquet/parquet_expression_filter_pruning.test create mode 100644 parser/testdata/corpus/sql/copy/parquet/parquet_external_access.test create mode 100644 parser/testdata/corpus/sql/copy/parquet/parquet_filename.test create mode 100644 parser/testdata/corpus/sql/copy/parquet/parquet_filename_filter.test create mode 100644 parser/testdata/corpus/sql/copy/parquet/parquet_filter_bug1391.test create mode 100644 parser/testdata/corpus/sql/copy/parquet/parquet_filter_dictionary_materialize.test create mode 100644 parser/testdata/corpus/sql/copy/parquet/parquet_fixed_length_blob_dict.test create mode 100644 parser/testdata/corpus/sql/copy/parquet/parquet_glob_cache.test create mode 100644 parser/testdata/corpus/sql/copy/parquet/parquet_go.test create mode 100644 parser/testdata/corpus/sql/copy/parquet/parquet_hive.test create mode 100644 parser/testdata/corpus/sql/copy/parquet/parquet_hive2.test create mode 100644 parser/testdata/corpus/sql/copy/parquet/parquet_hive_empty.test create mode 100644 parser/testdata/corpus/sql/copy/parquet/parquet_hive_null.test create mode 100644 parser/testdata/corpus/sql/copy/parquet/parquet_hive_override_stats.test create mode 100644 parser/testdata/corpus/sql/copy/parquet/parquet_json_varchar_mismatch.test create mode 100644 parser/testdata/corpus/sql/copy/parquet/parquet_late_materialization.test create mode 100644 parser/testdata/corpus/sql/copy/parquet/parquet_list.test create mode 100644 parser/testdata/corpus/sql/copy/parquet/parquet_list.test.metadata.json create mode 100644 parser/testdata/corpus/sql/copy/parquet/parquet_metadata.test create mode 100644 parser/testdata/corpus/sql/copy/parquet/parquet_metadata_blob.test create mode 100644 parser/testdata/corpus/sql/copy/parquet/parquet_metadata_cache.test create mode 100644 parser/testdata/corpus/sql/copy/parquet/parquet_nan.test create mode 100644 parser/testdata/corpus/sql/copy/parquet/parquet_no_stats.test create mode 100644 parser/testdata/corpus/sql/copy/parquet/parquet_nullbyte.test create mode 100644 parser/testdata/corpus/sql/copy/parquet/parquet_pandas_date.test create mode 100644 parser/testdata/corpus/sql/copy/parquet/parquet_prefetch_cost_model.test create mode 100644 parser/testdata/corpus/sql/copy/parquet/parquet_prefetch_cost_model_remote.test create mode 100644 parser/testdata/corpus/sql/copy/parquet/parquet_prefetch_metrics_multifile.test create mode 100644 parser/testdata/corpus/sql/copy/parquet/parquet_prefetch_projection.test create mode 100644 parser/testdata/corpus/sql/copy/parquet/parquet_prefetch_row_group_outcome.test create mode 100644 parser/testdata/corpus/sql/copy/parquet/parquet_prefetch_strategy_option.test create mode 100644 parser/testdata/corpus/sql/copy/parquet/parquet_prefetch_tracked_memory.test create mode 100644 parser/testdata/corpus/sql/copy/parquet/parquet_row_number.test create mode 100644 parser/testdata/corpus/sql/copy/parquet/parquet_schema_evolution.test create mode 100644 parser/testdata/corpus/sql/copy/parquet/parquet_schema_num_children_fix.test create mode 100644 parser/testdata/corpus/sql/copy/parquet/parquet_silly.test create mode 100644 parser/testdata/corpus/sql/copy/parquet/parquet_sqlnull_write.test create mode 100644 parser/testdata/corpus/sql/copy/parquet/parquet_stats.test create mode 100644 parser/testdata/corpus/sql/copy/parquet/parquet_string_stats.test create mode 100644 parser/testdata/corpus/sql/copy/parquet/parquet_union_by_name.test create mode 100644 parser/testdata/corpus/sql/copy/parquet/parquet_virtual_columns.test create mode 100644 parser/testdata/corpus/sql/copy/parquet/parquet_virtual_file_row_group_number.test create mode 100644 parser/testdata/corpus/sql/copy/parquet/parquet_virtual_file_row_group_number.test.metadata.json create mode 100644 parser/testdata/corpus/sql/copy/parquet/parquet_virtual_file_row_number.test create mode 100644 parser/testdata/corpus/sql/copy/parquet/parquet_write_codecs.test create mode 100644 parser/testdata/corpus/sql/copy/parquet/parquet_write_repeated_lists.test create mode 100644 parser/testdata/corpus/sql/copy/parquet/parquet_zstd.test create mode 100644 parser/testdata/corpus/sql/copy/parquet/partition_by_bind_issues.test create mode 100644 parser/testdata/corpus/sql/copy/parquet/read_ahead/readahead_active_jobs_hang.test create mode 100644 parser/testdata/corpus/sql/copy/parquet/read_ahead/readahead_depth_learning.test create mode 100644 parser/testdata/corpus/sql/copy/parquet/read_ahead/readahead_depth_setting.test create mode 100644 parser/testdata/corpus/sql/copy/parquet/read_ahead/readahead_io_errors.test create mode 100644 parser/testdata/corpus/sql/copy/parquet/read_ahead/readahead_limit_slot_leak_hang.test create mode 100644 parser/testdata/corpus/sql/copy/parquet/read_ahead/readahead_order_preservation.test create mode 100644 parser/testdata/corpus/sql/copy/parquet/read_ahead/readahead_starved_consumers.test create mode 100644 parser/testdata/corpus/sql/copy/parquet/read_parquet_parameter.test create mode 100644 parser/testdata/corpus/sql/copy/parquet/recursive_parquet_union_by_name.test create mode 100644 parser/testdata/corpus/sql/copy/parquet/replacement_scan_custom_extension.test create mode 100644 parser/testdata/corpus/sql/copy/parquet/rle_bool.test create mode 100644 parser/testdata/corpus/sql/copy/parquet/shredded_variant_stats.test create mode 100644 parser/testdata/corpus/sql/copy/parquet/spark_v2.test create mode 100644 parser/testdata/corpus/sql/copy/parquet/struct_column_reader_skip.test create mode 100644 parser/testdata/corpus/sql/copy/parquet/struct_skip_pushdown_null.test create mode 100644 parser/testdata/corpus/sql/copy/parquet/test_aws_files.test create mode 100644 parser/testdata/corpus/sql/copy/parquet/test_parallel_many_row_groups.test create mode 100644 parser/testdata/corpus/sql/copy/parquet/test_parquet_decimal.test create mode 100644 parser/testdata/corpus/sql/copy/parquet/test_parquet_duplicate_columns.test create mode 100644 parser/testdata/corpus/sql/copy/parquet/test_parquet_filter_pushdown.test create mode 100644 parser/testdata/corpus/sql/copy/parquet/test_parquet_gzip.test create mode 100644 parser/testdata/corpus/sql/copy/parquet/test_parquet_nested.test create mode 100644 parser/testdata/corpus/sql/copy/parquet/test_parquet_null.test create mode 100644 parser/testdata/corpus/sql/copy/parquet/test_parquet_scan.test create mode 100644 parser/testdata/corpus/sql/copy/parquet/test_parquet_stats.test create mode 100644 parser/testdata/corpus/sql/copy/parquet/timestamp_ms_stats.test create mode 100644 parser/testdata/corpus/sql/copy/parquet/timestamp_s.test create mode 100644 parser/testdata/corpus/sql/copy/parquet/timetz_parquet.test create mode 100644 parser/testdata/corpus/sql/copy/parquet/timezone.test create mode 100644 parser/testdata/corpus/sql/copy/parquet/union_by_name_hive_partitioning.test create mode 100644 parser/testdata/corpus/sql/copy/parquet/union_by_name_pushdown.test create mode 100644 parser/testdata/corpus/sql/copy/parquet/union_by_name_struct_filter.test create mode 100644 parser/testdata/corpus/sql/copy/parquet/union_by_name_struct_projection.test create mode 100644 parser/testdata/corpus/sql/copy/parquet/variant_array_row_group_pruning.test create mode 100644 parser/testdata/corpus/sql/copy/parquet/writer/parquet_dictionary_index_width.test create mode 100644 parser/testdata/corpus/sql/copy/parquet/writer/parquet_empty_struct.test create mode 100644 parser/testdata/corpus/sql/copy/parquet/writer/parquet_test_all_types.test create mode 100644 parser/testdata/corpus/sql/copy/parquet/writer/parquet_timetz_metadata.test create mode 100644 parser/testdata/corpus/sql/copy/parquet/writer/parquet_timetz_roundtrip.test create mode 100644 parser/testdata/corpus/sql/copy/parquet/writer/parquet_union_list.test create mode 100644 parser/testdata/corpus/sql/copy/parquet/writer/parquet_write_booleans.test create mode 100644 parser/testdata/corpus/sql/copy/parquet/writer/parquet_write_compression_level.test create mode 100644 parser/testdata/corpus/sql/copy/parquet/writer/parquet_write_data_page_size.test create mode 100644 parser/testdata/corpus/sql/copy/parquet/writer/parquet_write_date.test create mode 100644 parser/testdata/corpus/sql/copy/parquet/writer/parquet_write_decimals.test create mode 100644 parser/testdata/corpus/sql/copy/parquet/writer/parquet_write_enums.test create mode 100644 parser/testdata/corpus/sql/copy/parquet/writer/parquet_write_field_id.test create mode 100644 parser/testdata/corpus/sql/copy/parquet/writer/parquet_write_home_directory.test create mode 100644 parser/testdata/corpus/sql/copy/parquet/writer/parquet_write_hugeint.test create mode 100644 parser/testdata/corpus/sql/copy/parquet/writer/parquet_write_interval.test create mode 100644 parser/testdata/corpus/sql/copy/parquet/writer/parquet_write_issue_5779.test create mode 100644 parser/testdata/corpus/sql/copy/parquet/writer/parquet_write_memory_usage.test create mode 100644 parser/testdata/corpus/sql/copy/parquet/writer/parquet_write_memory_usage.test.metadata.json create mode 100644 parser/testdata/corpus/sql/copy/parquet/writer/parquet_write_signed.test create mode 100644 parser/testdata/corpus/sql/copy/parquet/writer/parquet_write_string_distinct.test create mode 100644 parser/testdata/corpus/sql/copy/parquet/writer/parquet_write_strings.test create mode 100644 parser/testdata/corpus/sql/copy/parquet/writer/parquet_write_strings_v1.test create mode 100644 parser/testdata/corpus/sql/copy/parquet/writer/parquet_write_timestamp.test create mode 100644 parser/testdata/corpus/sql/copy/parquet/writer/parquet_write_uhugeint.test create mode 100644 parser/testdata/corpus/sql/copy/parquet/writer/parquet_write_unsigned.test create mode 100644 parser/testdata/corpus/sql/copy/parquet/writer/parquet_write_uuid.test create mode 100644 parser/testdata/corpus/sql/copy/parquet/writer/partition_without_hive.test create mode 100644 parser/testdata/corpus/sql/copy/parquet/writer/row_group_size_bytes.test create mode 100644 parser/testdata/corpus/sql/copy/parquet/writer/skip_empty_write.test create mode 100644 parser/testdata/corpus/sql/copy/parquet/writer/test_copy_overwrite_parquet.test create mode 100644 parser/testdata/corpus/sql/copy/parquet/writer/test_parquet_write.test create mode 100644 parser/testdata/corpus/sql/copy/parquet/writer/test_parquet_write_complex.test create mode 100644 parser/testdata/corpus/sql/copy/parquet/writer/write_complex_nested.test create mode 100644 parser/testdata/corpus/sql/copy/parquet/writer/write_list.test create mode 100644 parser/testdata/corpus/sql/copy/parquet/writer/write_map.test create mode 100644 parser/testdata/corpus/sql/copy/parquet/writer/write_stats_big_string.test create mode 100644 parser/testdata/corpus/sql/copy/parquet/writer/write_stats_null_count.test create mode 100644 parser/testdata/corpus/sql/copy/parquet/writer/write_struct.test create mode 100644 parser/testdata/corpus/sql/copy/partitioned/hive_filter_pushdown.test create mode 100644 parser/testdata/corpus/sql/copy/partitioned/hive_partition_append.test create mode 100644 parser/testdata/corpus/sql/copy/partitioned/hive_partition_case_insensitive_column.test create mode 100644 parser/testdata/corpus/sql/copy/partitioned/hive_partition_compression.test create mode 100644 parser/testdata/corpus/sql/copy/partitioned/hive_partition_duplicate_name.test create mode 100644 parser/testdata/corpus/sql/copy/partitioned/hive_partition_escape.test create mode 100644 parser/testdata/corpus/sql/copy/partitioned/hive_partition_join_pushdown.test create mode 100644 parser/testdata/corpus/sql/copy/partitioned/hive_partition_recursive_cte.test create mode 100644 parser/testdata/corpus/sql/copy/partitioned/hive_partitioned_delayed_flush.test create mode 100644 parser/testdata/corpus/sql/copy/partitioned/hive_partitioned_write.test create mode 100644 parser/testdata/corpus/sql/copy/partitioned/hive_partitioning_overwrite.test create mode 100644 parser/testdata/corpus/sql/copy/partitioned/order_by_without_partition.test create mode 100644 parser/testdata/corpus/sql/copy/partitioned/partition_by_syntax.test create mode 100644 parser/testdata/corpus/sql/copy/partitioned/partition_by_syntax.test.metadata.json create mode 100644 parser/testdata/corpus/sql/copy/partitioned/partition_issue_6304.test create mode 100644 parser/testdata/corpus/sql/copy/partitioned/partitioned_early_finalize.test create mode 100644 parser/testdata/corpus/sql/copy/partitioned/partitioned_file_rotation.test create mode 100644 parser/testdata/corpus/sql/copy/partitioned/partitioned_group_by.test create mode 100644 parser/testdata/corpus/sql/copy/partitioned/partitioned_order_by.test create mode 100644 parser/testdata/corpus/sql/copy/partitioned/partitioned_order_by_flush_race.test create mode 100644 parser/testdata/corpus/sql/copy/partitioned/partitioned_window.test create mode 100644 parser/testdata/corpus/sql/copy/partitioned/skip_partition_column_writes.test create mode 100644 parser/testdata/corpus/sql/copy/per_thread_output.test create mode 100644 parser/testdata/corpus/sql/copy/return_files.test create mode 100644 parser/testdata/corpus/sql/copy/return_stats.test create mode 100644 parser/testdata/corpus/sql/copy/return_stats_extra_info.test create mode 100644 parser/testdata/corpus/sql/copy/return_stats_truncate.test create mode 100644 parser/testdata/corpus/sql/copy/row_groups_per_file.test create mode 100644 parser/testdata/corpus/sql/copy/tmp_file.test create mode 100644 parser/testdata/corpus/sql/copy_database/copy_database_different_types.test create mode 100644 parser/testdata/corpus/sql/copy_database/copy_database_errors.test create mode 100644 parser/testdata/corpus/sql/copy_database/copy_database_fk.test create mode 100644 parser/testdata/corpus/sql/copy_database/copy_database_gen_col.test create mode 100644 parser/testdata/corpus/sql/copy_database/copy_database_index.test create mode 100644 parser/testdata/corpus/sql/copy_database/copy_database_multiple.test create mode 100644 parser/testdata/corpus/sql/copy_database/copy_database_simple.test create mode 100644 parser/testdata/corpus/sql/copy_database/copy_database_with_index.test create mode 100644 parser/testdata/corpus/sql/copy_database/copy_database_with_unique_index.test create mode 100644 parser/testdata/corpus/sql/copy_database/copy_table_with_sequence.test create mode 100644 parser/testdata/corpus/sql/create/create_as.test create mode 100644 parser/testdata/corpus/sql/create/create_as_issue_11968.test create mode 100644 parser/testdata/corpus/sql/create/create_as_partition_sorted_options.test create mode 100644 parser/testdata/corpus/sql/create/create_database.test create mode 100644 parser/testdata/corpus/sql/create/create_index_on_issue_13643.test create mode 100644 parser/testdata/corpus/sql/create/create_objects_readonly.test create mode 100644 parser/testdata/corpus/sql/create/create_or_replace.test create mode 100644 parser/testdata/corpus/sql/create/create_or_replace.test.metadata.json create mode 100644 parser/testdata/corpus/sql/create/create_table_as_duplicate_names.test create mode 100644 parser/testdata/corpus/sql/create/create_table_as_error.test create mode 100644 parser/testdata/corpus/sql/create/create_table_as_error.test.metadata.json create mode 100644 parser/testdata/corpus/sql/create/create_table_compression.test create mode 100644 parser/testdata/corpus/sql/create/create_table_empty_name.test create mode 100644 parser/testdata/corpus/sql/create/create_table_empty_name.test.metadata.json create mode 100644 parser/testdata/corpus/sql/create/create_table_extra_options.test create mode 100644 parser/testdata/corpus/sql/create/create_table_with_arraybounds.test create mode 100644 parser/testdata/corpus/sql/create/create_using_index.test create mode 100644 parser/testdata/corpus/sql/cte/cte_bc.test create mode 100644 parser/testdata/corpus/sql/cte/cte_colname_issue_10074.test create mode 100644 parser/testdata/corpus/sql/cte/cte_describe.test create mode 100644 parser/testdata/corpus/sql/cte/cte_describe.test.metadata.json create mode 100644 parser/testdata/corpus/sql/cte/cte_issue_17311.test create mode 100644 parser/testdata/corpus/sql/cte/cte_null_values.test create mode 100644 parser/testdata/corpus/sql/cte/cte_on_conflict_issue.test create mode 100644 parser/testdata/corpus/sql/cte/cte_schema.test create mode 100644 parser/testdata/corpus/sql/cte/cte_with_replacement_scan.test create mode 100644 parser/testdata/corpus/sql/cte/dml_cte.test create mode 100644 parser/testdata/corpus/sql/cte/dml_cte.test.metadata.json create mode 100644 parser/testdata/corpus/sql/cte/incorrect_recursive_cte.test create mode 100644 parser/testdata/corpus/sql/cte/insert_cte_bug_3417.test create mode 100644 parser/testdata/corpus/sql/cte/lazy_cte_bind.test create mode 100644 parser/testdata/corpus/sql/cte/lazy_cte_bind_correlated.test create mode 100644 parser/testdata/corpus/sql/cte/materialized/annotated_and_auto_materialized.test create mode 100644 parser/testdata/corpus/sql/cte/materialized/cte_filter_pusher.test create mode 100644 parser/testdata/corpus/sql/cte/materialized/dml_materialized_cte.test create mode 100644 parser/testdata/corpus/sql/cte/materialized/incorrect_recursive_cte_materialized.test create mode 100644 parser/testdata/corpus/sql/cte/materialized/internal_3004.test create mode 100644 parser/testdata/corpus/sql/cte/materialized/materialized_cte_modifiers.test create mode 100644 parser/testdata/corpus/sql/cte/materialized/materialized_cte_order_preservation.test create mode 100644 parser/testdata/corpus/sql/cte/materialized/materialized_cte_parallel_buffered.test create mode 100644 parser/testdata/corpus/sql/cte/materialized/materialized_cte_prepared.test create mode 100644 parser/testdata/corpus/sql/cte/materialized/recursive_array_slice_materialized.test create mode 100644 parser/testdata/corpus/sql/cte/materialized/recursive_cte_complex_pipelines.test create mode 100644 parser/testdata/corpus/sql/cte/materialized/recursive_cte_error_materialized.test create mode 100644 parser/testdata/corpus/sql/cte/materialized/recursive_hang_2745_materialized.test create mode 100644 parser/testdata/corpus/sql/cte/materialized/test_bug_922_materialized.test create mode 100644 parser/testdata/corpus/sql/cte/materialized/test_correlated_recursive_cte_materialized.test create mode 100644 parser/testdata/corpus/sql/cte/materialized/test_cte_hash_join_exchange.test create mode 100644 parser/testdata/corpus/sql/cte/materialized/test_cte_in_cte_materialized.test create mode 100644 parser/testdata/corpus/sql/cte/materialized/test_cte_in_cte_materialized.test.metadata.json create mode 100644 parser/testdata/corpus/sql/cte/materialized/test_cte_materialized.test create mode 100644 parser/testdata/corpus/sql/cte/materialized/test_cte_overflow_materialized.test create mode 100644 parser/testdata/corpus/sql/cte/materialized/test_issue_10260.test create mode 100644 parser/testdata/corpus/sql/cte/materialized/test_materialized_cte.test create mode 100644 parser/testdata/corpus/sql/cte/materialized/test_nested_recursive_cte_materialized.test create mode 100644 parser/testdata/corpus/sql/cte/materialized/test_outer_joins_recursive_cte_materialized.test create mode 100644 parser/testdata/corpus/sql/cte/materialized/test_recursive_cte_tutorial_materialized.test create mode 100644 parser/testdata/corpus/sql/cte/materialized/test_recursive_cte_union_all_materialized.test create mode 100644 parser/testdata/corpus/sql/cte/materialized/test_recursive_cte_union_all_materialized.test.metadata.json create mode 100644 parser/testdata/corpus/sql/cte/materialized/test_recursive_cte_union_materialized.test create mode 100644 parser/testdata/corpus/sql/cte/materialized/test_recursive_cte_union_materialized.test.metadata.json create mode 100644 parser/testdata/corpus/sql/cte/recursive_array_slice.test create mode 100644 parser/testdata/corpus/sql/cte/recursive_cte_batch_index.test create mode 100644 parser/testdata/corpus/sql/cte/recursive_cte_column_pruning.test create mode 100644 parser/testdata/corpus/sql/cte/recursive_cte_complex_pipelines.test create mode 100644 parser/testdata/corpus/sql/cte/recursive_cte_correlated_complex.test create mode 100644 parser/testdata/corpus/sql/cte/recursive_cte_error.test create mode 100644 parser/testdata/corpus/sql/cte/recursive_cte_invariant_build.test create mode 100644 parser/testdata/corpus/sql/cte/recursive_cte_invariant_build_logging.test create mode 100644 parser/testdata/corpus/sql/cte/recursive_cte_key_aggregation.test create mode 100644 parser/testdata/corpus/sql/cte/recursive_cte_key_final_drain.test create mode 100644 parser/testdata/corpus/sql/cte/recursive_cte_key_hll_aggregation.test create mode 100644 parser/testdata/corpus/sql/cte/recursive_cte_key_probe.test create mode 100644 parser/testdata/corpus/sql/cte/recursive_cte_key_snapshot.test create mode 100644 parser/testdata/corpus/sql/cte/recursive_cte_limit.test create mode 100644 parser/testdata/corpus/sql/cte/recursive_cte_logging.test create mode 100644 parser/testdata/corpus/sql/cte/recursive_cte_parallel_union_all_sink.test create mode 100644 parser/testdata/corpus/sql/cte/recursive_cte_parallel_union_distinct_sink.test create mode 100644 parser/testdata/corpus/sql/cte/recursive_hang_2745.test create mode 100644 parser/testdata/corpus/sql/cte/test_bug_922.test create mode 100644 parser/testdata/corpus/sql/cte/test_cte.test create mode 100644 parser/testdata/corpus/sql/cte/test_cte.test.metadata.json create mode 100644 parser/testdata/corpus/sql/cte/test_cte_in_cte.test create mode 100644 parser/testdata/corpus/sql/cte/test_cte_overflow.test create mode 100644 parser/testdata/corpus/sql/cte/test_issue_5673.test create mode 100644 parser/testdata/corpus/sql/cte/test_moderate_union_all.test create mode 100644 parser/testdata/corpus/sql/cte/test_nested_recursive_cte.test create mode 100644 parser/testdata/corpus/sql/cte/test_outer_joins_recursive_cte.test create mode 100644 parser/testdata/corpus/sql/cte/test_recursive_cte_recurring.test create mode 100644 parser/testdata/corpus/sql/cte/test_recursive_cte_tutorial.test create mode 100644 parser/testdata/corpus/sql/cte/test_recursive_cte_union.test create mode 100644 parser/testdata/corpus/sql/cte/test_recursive_cte_union.test.metadata.json create mode 100644 parser/testdata/corpus/sql/cte/test_recursive_cte_union_all.test create mode 100644 parser/testdata/corpus/sql/cte/test_recursive_cte_union_all.test.metadata.json create mode 100644 parser/testdata/corpus/sql/cte/warn_deprecated_union_in_using_key.test create mode 100644 parser/testdata/corpus/sql/delete/bulk_delete_version_info_memory.test create mode 100644 parser/testdata/corpus/sql/delete/cleanup_delete_on_conflict.test create mode 100644 parser/testdata/corpus/sql/delete/delete_compression_after_restart.test create mode 100644 parser/testdata/corpus/sql/delete/delete_compression_blocked_by_old_snapshot.test create mode 100644 parser/testdata/corpus/sql/delete/delete_query_node.test create mode 100644 parser/testdata/corpus/sql/delete/full_vector_delete_conflict.test create mode 100644 parser/testdata/corpus/sql/delete/full_vector_delete_rollback.test create mode 100644 parser/testdata/corpus/sql/delete/large_deletes_transactions.test create mode 100644 parser/testdata/corpus/sql/delete/list_delete.test create mode 100644 parser/testdata/corpus/sql/delete/masked_vector_further_delete.test create mode 100644 parser/testdata/corpus/sql/delete/masked_vector_rollback.test create mode 100644 parser/testdata/corpus/sql/delete/partial_delete_version_info_memory.test create mode 100644 parser/testdata/corpus/sql/delete/test_delete.test create mode 100644 parser/testdata/corpus/sql/delete/test_delete_indexed.test create mode 100644 parser/testdata/corpus/sql/delete/test_large_delete.test create mode 100644 parser/testdata/corpus/sql/delete/test_segment_deletes.test create mode 100644 parser/testdata/corpus/sql/delete/test_truncate.test create mode 100644 parser/testdata/corpus/sql/delete/test_using_delete.test create mode 100644 parser/testdata/corpus/sql/delete/test_using_delete_duplicates.test create mode 100644 parser/testdata/corpus/sql/detailed_profiler/test_detailed_profiler.test create mode 100644 parser/testdata/corpus/sql/error/aggregate_order_by.test create mode 100644 parser/testdata/corpus/sql/error/correlated_at_clause.test create mode 100644 parser/testdata/corpus/sql/error/error_location_multicaret.test create mode 100644 parser/testdata/corpus/sql/error/error_location_not_duplicated.test create mode 100644 parser/testdata/corpus/sql/error/error_position.test create mode 100644 parser/testdata/corpus/sql/error/error_position_json_execute.test create mode 100644 parser/testdata/corpus/sql/error/escape_percent_sign.test create mode 100644 parser/testdata/corpus/sql/error/extension_function_error.test create mode 100644 parser/testdata/corpus/sql/error/incorrect_sql.test create mode 100644 parser/testdata/corpus/sql/error/lineitem_errors.test create mode 100644 parser/testdata/corpus/sql/error/missing_type.test create mode 100644 parser/testdata/corpus/sql/error/mix_aggregate_and_non_aggregate.test create mode 100644 parser/testdata/corpus/sql/error/qualified_column_error.test create mode 100644 parser/testdata/corpus/sql/error/subquery_single_column.test create mode 100644 parser/testdata/corpus/sql/error/table_function_as_scalar_function.test create mode 100644 parser/testdata/corpus/sql/error/unknown_window_function.test create mode 100644 parser/testdata/corpus/sql/explain/explain_all_statements.test create mode 100644 parser/testdata/corpus/sql/explain/explain_execute.test create mode 100644 parser/testdata/corpus/sql/explain/explain_formats.test create mode 100644 parser/testdata/corpus/sql/explain/order_by_topn_explain_fqn.test create mode 100644 parser/testdata/corpus/sql/explain/test_explain.test create mode 100644 parser/testdata/corpus/sql/explain/test_explain_analyze.test create mode 100644 parser/testdata/corpus/sql/explain/test_explain_analyze.test.metadata.json create mode 100644 parser/testdata/corpus/sql/explain/test_explain_limit.test create mode 100644 parser/testdata/corpus/sql/export/empty_export.test create mode 100644 parser/testdata/corpus/sql/export/export_compression_level.test create mode 100644 parser/testdata/corpus/sql/export/export_database.test create mode 100644 parser/testdata/corpus/sql/export/export_database.test.metadata.json create mode 100644 parser/testdata/corpus/sql/export/export_external_access.test create mode 100644 parser/testdata/corpus/sql/export/export_functions.test create mode 100644 parser/testdata/corpus/sql/export/export_generated_columns.test create mode 100644 parser/testdata/corpus/sql/export/export_hive_path.test create mode 100644 parser/testdata/corpus/sql/export/export_indexes.test create mode 100644 parser/testdata/corpus/sql/export/export_macros.test create mode 100644 parser/testdata/corpus/sql/export/export_quoted_enum.test create mode 100644 parser/testdata/corpus/sql/export/export_quoted_structs.test create mode 100644 parser/testdata/corpus/sql/export/export_quoted_union.test create mode 100644 parser/testdata/corpus/sql/export/export_temp_tables.test create mode 100644 parser/testdata/corpus/sql/export/export_types.test create mode 100644 parser/testdata/corpus/sql/export/parquet/export_parquet_bit.test create mode 100644 parser/testdata/corpus/sql/export/parquet/export_parquet_enum.test create mode 100644 parser/testdata/corpus/sql/export/parquet/export_parquet_hugeint.test create mode 100644 parser/testdata/corpus/sql/export/parquet/export_parquet_json.test create mode 100644 parser/testdata/corpus/sql/export/parquet/export_parquet_list.test create mode 100644 parser/testdata/corpus/sql/export/parquet/export_parquet_map.test create mode 100644 parser/testdata/corpus/sql/export/parquet/export_parquet_struct.test create mode 100644 parser/testdata/corpus/sql/export/parquet/export_parquet_union.test create mode 100644 parser/testdata/corpus/sql/export/parquet_export.test create mode 100644 parser/testdata/corpus/sql/extensions/aliasing.test create mode 100644 parser/testdata/corpus/sql/extensions/allowed_directories_install.test create mode 100644 parser/testdata/corpus/sql/extensions/attach_type_alias_conflict.test create mode 100644 parser/testdata/corpus/sql/extensions/checked_load.test create mode 100644 parser/testdata/corpus/sql/extensions/load_arbitrary_path.test create mode 100644 parser/testdata/corpus/sql/extensions/load_use_extension_one_query.test create mode 100644 parser/testdata/corpus/sql/extensions/load_use_extension_one_query.test.metadata.json create mode 100644 parser/testdata/corpus/sql/extensions/permissions_duckdb_extension.test create mode 100644 parser/testdata/corpus/sql/extensions/quack_peeling.test create mode 100644 parser/testdata/corpus/sql/extensions/quack_peeling.test.metadata.json create mode 100644 parser/testdata/corpus/sql/extensions/sqlite_alter_table_add_pk.test create mode 100644 parser/testdata/corpus/sql/extensions/version_is_valid_sqlite.test create mode 100644 parser/testdata/corpus/sql/filter/filter_cache.test create mode 100644 parser/testdata/corpus/sql/filter/filter_cache_dictionary.test create mode 100644 parser/testdata/corpus/sql/filter/test_alias_filter.test create mode 100644 parser/testdata/corpus/sql/filter/test_constant_comparisons.test create mode 100644 parser/testdata/corpus/sql/filter/test_expression_executor_select.test create mode 100644 parser/testdata/corpus/sql/filter/test_illegal_filters.test create mode 100644 parser/testdata/corpus/sql/filter/test_last_option_corruption.test create mode 100644 parser/testdata/corpus/sql/filter/test_obsolete_filters.test create mode 100644 parser/testdata/corpus/sql/filter/test_or_pushdown.test create mode 100644 parser/testdata/corpus/sql/filter/test_struct_pushdown.test create mode 100644 parser/testdata/corpus/sql/filter/test_transitive_filters.test create mode 100644 parser/testdata/corpus/sql/filter/test_try_filter_doesnt_mutate_columns.test create mode 100644 parser/testdata/corpus/sql/filter/test_variant_filter.test create mode 100644 parser/testdata/corpus/sql/filter/test_zonemap_segment.test create mode 100644 parser/testdata/corpus/sql/function/array/array_and_map.test create mode 100644 parser/testdata/corpus/sql/function/array/array_cosine_distance.test create mode 100644 parser/testdata/corpus/sql/function/array/array_cosine_similarity.test create mode 100644 parser/testdata/corpus/sql/function/array/array_cross_product.test create mode 100644 parser/testdata/corpus/sql/function/array/array_distance.test create mode 100644 parser/testdata/corpus/sql/function/array/array_flatten.test create mode 100644 parser/testdata/corpus/sql/function/array/array_inner_product.test create mode 100644 parser/testdata/corpus/sql/function/array/array_length.test create mode 100644 parser/testdata/corpus/sql/function/array/array_list_functions.test create mode 100644 parser/testdata/corpus/sql/function/autocomplete/alter_table.test create mode 100644 parser/testdata/corpus/sql/function/autocomplete/copy.test create mode 100644 parser/testdata/corpus/sql/function/autocomplete/create_function.test create mode 100644 parser/testdata/corpus/sql/function/autocomplete/create_schema.test create mode 100644 parser/testdata/corpus/sql/function/autocomplete/create_sequence.test create mode 100644 parser/testdata/corpus/sql/function/autocomplete/create_table.test create mode 100644 parser/testdata/corpus/sql/function/autocomplete/create_type.test create mode 100644 parser/testdata/corpus/sql/function/autocomplete/drop.test create mode 100644 parser/testdata/corpus/sql/function/autocomplete/expressions.test create mode 100644 parser/testdata/corpus/sql/function/autocomplete/identical_schema_table.test create mode 100644 parser/testdata/corpus/sql/function/autocomplete/insert_into.test create mode 100644 parser/testdata/corpus/sql/function/autocomplete/pragma.test create mode 100644 parser/testdata/corpus/sql/function/autocomplete/scalar_functions.test create mode 100644 parser/testdata/corpus/sql/function/autocomplete/select.test create mode 100644 parser/testdata/corpus/sql/function/autocomplete/setting.test create mode 100644 parser/testdata/corpus/sql/function/autocomplete/show.test create mode 100644 parser/testdata/corpus/sql/function/autocomplete/sql_format.test create mode 100644 parser/testdata/corpus/sql/function/autocomplete/suggest_file.test create mode 100644 parser/testdata/corpus/sql/function/autocomplete/table_functions.test create mode 100644 parser/testdata/corpus/sql/function/autocomplete/tpch.test create mode 100644 parser/testdata/corpus/sql/function/autocomplete/views.test create mode 100644 parser/testdata/corpus/sql/function/autocomplete/window.test create mode 100644 parser/testdata/corpus/sql/function/blob/base64.test create mode 100644 parser/testdata/corpus/sql/function/blob/create_sort_key.test create mode 100644 parser/testdata/corpus/sql/function/blob/create_sort_key_blob_escapes.test create mode 100644 parser/testdata/corpus/sql/function/blob/encode.test create mode 100644 parser/testdata/corpus/sql/function/blob/test_blob_array_slice.test create mode 100644 parser/testdata/corpus/sql/function/blob/test_concat_blob.test create mode 100644 parser/testdata/corpus/sql/function/date/date_add.test create mode 100644 parser/testdata/corpus/sql/function/date/date_diff_extreme_dates.test create mode 100644 parser/testdata/corpus/sql/function/date/date_part_stats.test create mode 100644 parser/testdata/corpus/sql/function/date/date_trunc_4202.test create mode 100644 parser/testdata/corpus/sql/function/date/date_trunc_stats.test create mode 100644 parser/testdata/corpus/sql/function/date/test_date_part.test create mode 100644 parser/testdata/corpus/sql/function/date/test_date_trunc.test create mode 100644 parser/testdata/corpus/sql/function/date/test_extract.test create mode 100644 parser/testdata/corpus/sql/function/date/test_extract_edge_cases.test create mode 100644 parser/testdata/corpus/sql/function/date/test_extract_month.test create mode 100644 parser/testdata/corpus/sql/function/date/test_extract_year.test create mode 100644 parser/testdata/corpus/sql/function/date/test_strftime.test create mode 100644 parser/testdata/corpus/sql/function/date/test_strftime_exhaustive.test create mode 100644 parser/testdata/corpus/sql/function/date/test_time_bucket_date.test create mode 100644 parser/testdata/corpus/sql/function/enum/test_enum_code.test create mode 100644 parser/testdata/corpus/sql/function/enum/test_enum_first.test create mode 100644 parser/testdata/corpus/sql/function/enum/test_enum_last.test create mode 100644 parser/testdata/corpus/sql/function/enum/test_enum_range.test create mode 100644 parser/testdata/corpus/sql/function/generic/assert_true.test create mode 100644 parser/testdata/corpus/sql/function/generic/can_cast_implicitly.test create mode 100644 parser/testdata/corpus/sql/function/generic/case_condition.test create mode 100644 parser/testdata/corpus/sql/function/generic/case_short_circuit.test create mode 100644 parser/testdata/corpus/sql/function/generic/case_varchar.test create mode 100644 parser/testdata/corpus/sql/function/generic/cast_to_type.test create mode 100644 parser/testdata/corpus/sql/function/generic/constant_or_null.test create mode 100644 parser/testdata/corpus/sql/function/generic/error.test create mode 100644 parser/testdata/corpus/sql/function/generic/hash_func.test create mode 100644 parser/testdata/corpus/sql/function/generic/invoke.test create mode 100644 parser/testdata/corpus/sql/function/generic/least_greatest_enum.test create mode 100644 parser/testdata/corpus/sql/function/generic/least_greatest_types.test create mode 100644 parser/testdata/corpus/sql/function/generic/replace_type.test create mode 100644 parser/testdata/corpus/sql/function/generic/table_func_varargs.test create mode 100644 parser/testdata/corpus/sql/function/generic/test_approx_database_count.test create mode 100644 parser/testdata/corpus/sql/function/generic/test_between.test create mode 100644 parser/testdata/corpus/sql/function/generic/test_between_sideeffects.test create mode 100644 parser/testdata/corpus/sql/function/generic/test_boolean_test.test create mode 100644 parser/testdata/corpus/sql/function/generic/test_connection_count.test create mode 100644 parser/testdata/corpus/sql/function/generic/test_if.test create mode 100644 parser/testdata/corpus/sql/function/generic/test_if_null.test create mode 100644 parser/testdata/corpus/sql/function/generic/test_in.test create mode 100644 parser/testdata/corpus/sql/function/generic/test_least_greatest.test create mode 100644 parser/testdata/corpus/sql/function/generic/test_null_if.test create mode 100644 parser/testdata/corpus/sql/function/generic/test_set.test create mode 100644 parser/testdata/corpus/sql/function/generic/test_set.test.metadata.json create mode 100644 parser/testdata/corpus/sql/function/generic/test_sleep.test create mode 100644 parser/testdata/corpus/sql/function/generic/test_sleep.test.metadata.json create mode 100644 parser/testdata/corpus/sql/function/generic/test_stats.test create mode 100644 parser/testdata/corpus/sql/function/generic/test_table_param.test create mode 100644 parser/testdata/corpus/sql/function/index/index_key.test create mode 100644 parser/testdata/corpus/sql/function/interval/test_date_part.test create mode 100644 parser/testdata/corpus/sql/function/interval/test_extract.test create mode 100644 parser/testdata/corpus/sql/function/interval/test_interval_muldiv.test create mode 100644 parser/testdata/corpus/sql/function/interval/test_interval_trunc.test create mode 100644 parser/testdata/corpus/sql/function/list/aggregates/any_value.test create mode 100644 parser/testdata/corpus/sql/function/list/aggregates/approx_count_distinct.test create mode 100644 parser/testdata/corpus/sql/function/list/aggregates/avg.test create mode 100644 parser/testdata/corpus/sql/function/list/aggregates/bigints_sum_avg.test create mode 100644 parser/testdata/corpus/sql/function/list/aggregates/bit_and.test create mode 100644 parser/testdata/corpus/sql/function/list/aggregates/bit_or.test create mode 100644 parser/testdata/corpus/sql/function/list/aggregates/bit_xor.test create mode 100644 parser/testdata/corpus/sql/function/list/aggregates/bool_and_or.test create mode 100644 parser/testdata/corpus/sql/function/list/aggregates/count.test create mode 100644 parser/testdata/corpus/sql/function/list/aggregates/entropy.test create mode 100644 parser/testdata/corpus/sql/function/list/aggregates/first.test create mode 100644 parser/testdata/corpus/sql/function/list/aggregates/histogram.test create mode 100644 parser/testdata/corpus/sql/function/list/aggregates/histogram_decimal.test create mode 100644 parser/testdata/corpus/sql/function/list/aggregates/hugeint.test create mode 100644 parser/testdata/corpus/sql/function/list/aggregates/incorrect.test create mode 100644 parser/testdata/corpus/sql/function/list/aggregates/kurtosis.test create mode 100644 parser/testdata/corpus/sql/function/list/aggregates/last.test create mode 100644 parser/testdata/corpus/sql/function/list/aggregates/mad.test create mode 100644 parser/testdata/corpus/sql/function/list/aggregates/max.test create mode 100644 parser/testdata/corpus/sql/function/list/aggregates/median.test create mode 100644 parser/testdata/corpus/sql/function/list/aggregates/min.test create mode 100644 parser/testdata/corpus/sql/function/list/aggregates/minmax_nested.test create mode 100644 parser/testdata/corpus/sql/function/list/aggregates/mode.test create mode 100644 parser/testdata/corpus/sql/function/list/aggregates/nested.test create mode 100644 parser/testdata/corpus/sql/function/list/aggregates/null_or_empty.test create mode 100644 parser/testdata/corpus/sql/function/list/aggregates/product.test create mode 100644 parser/testdata/corpus/sql/function/list/aggregates/sem.test create mode 100644 parser/testdata/corpus/sql/function/list/aggregates/skewness.test create mode 100644 parser/testdata/corpus/sql/function/list/aggregates/string_agg.test create mode 100644 parser/testdata/corpus/sql/function/list/aggregates/sum.test create mode 100644 parser/testdata/corpus/sql/function/list/aggregates/sum_bool.test create mode 100644 parser/testdata/corpus/sql/function/list/aggregates/sum_no_overflow.test create mode 100644 parser/testdata/corpus/sql/function/list/aggregates/uhugeint.test create mode 100644 parser/testdata/corpus/sql/function/list/aggregates/var_stddev.test create mode 100644 parser/testdata/corpus/sql/function/list/array_length.test create mode 100644 parser/testdata/corpus/sql/function/list/array_to_string.test create mode 100644 parser/testdata/corpus/sql/function/list/array_to_string_comma_default.test create mode 100644 parser/testdata/corpus/sql/function/list/flatten.test create mode 100644 parser/testdata/corpus/sql/function/list/generate_series.test create mode 100644 parser/testdata/corpus/sql/function/list/generate_series_timestamp.test create mode 100644 parser/testdata/corpus/sql/function/list/generate_subscripts.test create mode 100644 parser/testdata/corpus/sql/function/list/icu_generate_series_timestamptz.test create mode 100644 parser/testdata/corpus/sql/function/list/lambda_constant_null.test create mode 100644 parser/testdata/corpus/sql/function/list/lambdas/arrow/expression_iterator_cases_deprecated.test create mode 100644 parser/testdata/corpus/sql/function/list/lambdas/arrow/filter_deprecated.test create mode 100644 parser/testdata/corpus/sql/function/list/lambdas/arrow/lambda_scope_deprecated.test create mode 100644 parser/testdata/corpus/sql/function/list/lambdas/arrow/lambdas_and_functions_deprecated.test create mode 100644 parser/testdata/corpus/sql/function/list/lambdas/arrow/lambdas_and_group_by_deprecated.test create mode 100644 parser/testdata/corpus/sql/function/list/lambdas/arrow/lambdas_and_macros_deprecated.test create mode 100644 parser/testdata/corpus/sql/function/list/lambdas/arrow/list_comprehension_deprecated.test create mode 100644 parser/testdata/corpus/sql/function/list/lambdas/arrow/reduce_deprecated.test create mode 100644 parser/testdata/corpus/sql/function/list/lambdas/arrow/reduce_initial_deprecated.test create mode 100644 parser/testdata/corpus/sql/function/list/lambdas/arrow/rhs_parameters_deprecated.test create mode 100644 parser/testdata/corpus/sql/function/list/lambdas/arrow/storage_deprecated.test create mode 100644 parser/testdata/corpus/sql/function/list/lambdas/arrow/table_functions_deprecated.test create mode 100644 parser/testdata/corpus/sql/function/list/lambdas/arrow/test_deprecated_lambda.test create mode 100644 parser/testdata/corpus/sql/function/list/lambdas/arrow/test_lambda_arrow_storage_deprecated.test create mode 100644 parser/testdata/corpus/sql/function/list/lambdas/arrow/transform_deprecated.test create mode 100644 parser/testdata/corpus/sql/function/list/lambdas/arrow/transform_with_index_deprecated.test create mode 100644 parser/testdata/corpus/sql/function/list/lambdas/arrow/warn_deprecated_arrow.test create mode 100644 parser/testdata/corpus/sql/function/list/lambdas/expression_iterator_cases.test create mode 100644 parser/testdata/corpus/sql/function/list/lambdas/filter.test create mode 100644 parser/testdata/corpus/sql/function/list/lambdas/incorrect.test create mode 100644 parser/testdata/corpus/sql/function/list/lambdas/lambda_scope.test create mode 100644 parser/testdata/corpus/sql/function/list/lambdas/lambdas_and_functions.test create mode 100644 parser/testdata/corpus/sql/function/list/lambdas/lambdas_and_group_by.test create mode 100644 parser/testdata/corpus/sql/function/list/lambdas/lambdas_and_macros.test create mode 100644 parser/testdata/corpus/sql/function/list/lambdas/list_comprehension.test create mode 100644 parser/testdata/corpus/sql/function/list/lambdas/reduce.test create mode 100644 parser/testdata/corpus/sql/function/list/lambdas/reduce_initial.test create mode 100644 parser/testdata/corpus/sql/function/list/lambdas/rhs_parameters.test create mode 100644 parser/testdata/corpus/sql/function/list/lambdas/storage.test create mode 100644 parser/testdata/corpus/sql/function/list/lambdas/table_functions.test create mode 100644 parser/testdata/corpus/sql/function/list/lambdas/test_lambda_storage.test create mode 100644 parser/testdata/corpus/sql/function/list/lambdas/transform.test create mode 100644 parser/testdata/corpus/sql/function/list/lambdas/transform_with_index.test create mode 100644 parser/testdata/corpus/sql/function/list/lambdas/vector_types.test create mode 100644 parser/testdata/corpus/sql/function/list/list_concat.test create mode 100644 parser/testdata/corpus/sql/function/list/list_contains.test create mode 100644 parser/testdata/corpus/sql/function/list/list_cosine_similarity.test create mode 100644 parser/testdata/corpus/sql/function/list/list_distance.test create mode 100644 parser/testdata/corpus/sql/function/list/list_distinct.test create mode 100644 parser/testdata/corpus/sql/function/list/list_has_any_and_has_all.test create mode 100644 parser/testdata/corpus/sql/function/list/list_inner_product.test create mode 100644 parser/testdata/corpus/sql/function/list/list_intersect.test create mode 100644 parser/testdata/corpus/sql/function/list/list_position.test create mode 100644 parser/testdata/corpus/sql/function/list/list_position_nan.test create mode 100644 parser/testdata/corpus/sql/function/list/list_resize.test create mode 100644 parser/testdata/corpus/sql/function/list/list_resize_error.test create mode 100644 parser/testdata/corpus/sql/function/list/list_reverse.test create mode 100644 parser/testdata/corpus/sql/function/list/list_sort_having.test create mode 100644 parser/testdata/corpus/sql/function/list/list_sort_vector_types.test create mode 100644 parser/testdata/corpus/sql/function/list/list_unique.test create mode 100644 parser/testdata/corpus/sql/function/list/list_value_arrays.test create mode 100644 parser/testdata/corpus/sql/function/list/list_value_nested_lists.test create mode 100644 parser/testdata/corpus/sql/function/list/list_value_structs.test create mode 100644 parser/testdata/corpus/sql/function/list/list_where.test create mode 100644 parser/testdata/corpus/sql/function/list/list_zip.test create mode 100644 parser/testdata/corpus/sql/function/list/repeat_list.test create mode 100644 parser/testdata/corpus/sql/function/list/test_lambda_with_struct_aliases.test create mode 100644 parser/testdata/corpus/sql/function/nested/array_extract_unnamed_struct.test create mode 100644 parser/testdata/corpus/sql/function/nested/test_issue_5437.test create mode 100644 parser/testdata/corpus/sql/function/nested/test_struct_insert.test create mode 100644 parser/testdata/corpus/sql/function/nested/test_struct_update.test create mode 100644 parser/testdata/corpus/sql/function/numeric/abs.test create mode 100644 parser/testdata/corpus/sql/function/numeric/decimal_mod.test create mode 100644 parser/testdata/corpus/sql/function/numeric/set_seed_for_sample.test create mode 100644 parser/testdata/corpus/sql/function/numeric/test_arithmetic_aliases.test create mode 100644 parser/testdata/corpus/sql/function/numeric/test_binom.test create mode 100644 parser/testdata/corpus/sql/function/numeric/test_bit_count.test create mode 100644 parser/testdata/corpus/sql/function/numeric/test_even.test create mode 100644 parser/testdata/corpus/sql/function/numeric/test_factorial.test create mode 100644 parser/testdata/corpus/sql/function/numeric/test_fdiv_fmod.test create mode 100644 parser/testdata/corpus/sql/function/numeric/test_floor_ceil.test create mode 100644 parser/testdata/corpus/sql/function/numeric/test_gamma.test create mode 100644 parser/testdata/corpus/sql/function/numeric/test_gcd_lcm.test create mode 100644 parser/testdata/corpus/sql/function/numeric/test_geomean.test create mode 100644 parser/testdata/corpus/sql/function/numeric/test_invalid_math.test create mode 100644 parser/testdata/corpus/sql/function/numeric/test_is_nan.test create mode 100644 parser/testdata/corpus/sql/function/numeric/test_mod.test create mode 100644 parser/testdata/corpus/sql/function/numeric/test_nextafter.test create mode 100644 parser/testdata/corpus/sql/function/numeric/test_pg_math.test create mode 100644 parser/testdata/corpus/sql/function/numeric/test_pow.test create mode 100644 parser/testdata/corpus/sql/function/numeric/test_random.test create mode 100644 parser/testdata/corpus/sql/function/numeric/test_round.test create mode 100644 parser/testdata/corpus/sql/function/numeric/test_round_even.test create mode 100644 parser/testdata/corpus/sql/function/numeric/test_round_integers.test create mode 100644 parser/testdata/corpus/sql/function/numeric/test_sign_bit.test create mode 100644 parser/testdata/corpus/sql/function/numeric/test_trigo.test create mode 100644 parser/testdata/corpus/sql/function/numeric/test_trunc.test create mode 100644 parser/testdata/corpus/sql/function/numeric/test_trunc_precision.test create mode 100644 parser/testdata/corpus/sql/function/numeric/test_type_resolution.test create mode 100644 parser/testdata/corpus/sql/function/numeric/test_unary.test create mode 100644 parser/testdata/corpus/sql/function/operator/test_arithmetic.test create mode 100644 parser/testdata/corpus/sql/function/operator/test_arithmetic_sqllogic.test create mode 100644 parser/testdata/corpus/sql/function/operator/test_bitwise_ops.test create mode 100644 parser/testdata/corpus/sql/function/operator/test_bitwise_ops_types.test create mode 100644 parser/testdata/corpus/sql/function/operator/test_comparison.test create mode 100644 parser/testdata/corpus/sql/function/operator/test_comparison.test.metadata.json create mode 100644 parser/testdata/corpus/sql/function/operator/test_conjunction.test create mode 100644 parser/testdata/corpus/sql/function/operator/test_date_arithmetic.test create mode 100644 parser/testdata/corpus/sql/function/operator/test_division_overflow.test create mode 100644 parser/testdata/corpus/sql/function/operator/test_in_empty_table.test create mode 100644 parser/testdata/corpus/sql/function/string/format_bytes.test create mode 100644 parser/testdata/corpus/sql/function/string/hex.test create mode 100644 parser/testdata/corpus/sql/function/string/like_unicode.test create mode 100644 parser/testdata/corpus/sql/function/string/md5.test create mode 100644 parser/testdata/corpus/sql/function/string/null_byte.test create mode 100644 parser/testdata/corpus/sql/function/string/overlay.test create mode 100644 parser/testdata/corpus/sql/function/string/parse_formatted_bytes.test create mode 100644 parser/testdata/corpus/sql/function/string/parse_path.test create mode 100644 parser/testdata/corpus/sql/function/string/parse_path_windows.test create mode 100644 parser/testdata/corpus/sql/function/string/path_join.test create mode 100644 parser/testdata/corpus/sql/function/string/regex_capture.test create mode 100644 parser/testdata/corpus/sql/function/string/regex_escape.test create mode 100644 parser/testdata/corpus/sql/function/string/regex_extract.test create mode 100644 parser/testdata/corpus/sql/function/string/regex_extract_all.test create mode 100644 parser/testdata/corpus/sql/function/string/regex_extract_all_struct.test create mode 100644 parser/testdata/corpus/sql/function/string/regex_filter_pushdown.test create mode 100644 parser/testdata/corpus/sql/function/string/regex_operators.test create mode 100644 parser/testdata/corpus/sql/function/string/regex_operators_v1_5_view.test create mode 100644 parser/testdata/corpus/sql/function/string/regex_replace.test create mode 100644 parser/testdata/corpus/sql/function/string/regex_search.test create mode 100644 parser/testdata/corpus/sql/function/string/regexp_split_to_table.test create mode 100644 parser/testdata/corpus/sql/function/string/regexp_unicode_literal.test create mode 100644 parser/testdata/corpus/sql/function/string/sha1.test create mode 100644 parser/testdata/corpus/sql/function/string/sha256.test create mode 100644 parser/testdata/corpus/sql/function/string/strip_accents.test create mode 100644 parser/testdata/corpus/sql/function/string/test_array_extract.test create mode 100644 parser/testdata/corpus/sql/function/string/test_ascii.test create mode 100644 parser/testdata/corpus/sql/function/string/test_bar.test create mode 100644 parser/testdata/corpus/sql/function/string/test_bit_length.test create mode 100644 parser/testdata/corpus/sql/function/string/test_caseconvert.test create mode 100644 parser/testdata/corpus/sql/function/string/test_complex_unicode.test create mode 100644 parser/testdata/corpus/sql/function/string/test_concat.test create mode 100644 parser/testdata/corpus/sql/function/string/test_concat_binding.test create mode 100644 parser/testdata/corpus/sql/function/string/test_concat_function.test create mode 100644 parser/testdata/corpus/sql/function/string/test_concat_ws.test create mode 100644 parser/testdata/corpus/sql/function/string/test_contains.test create mode 100644 parser/testdata/corpus/sql/function/string/test_contains_utf8.test create mode 100644 parser/testdata/corpus/sql/function/string/test_damerau_levenshtein.test create mode 100644 parser/testdata/corpus/sql/function/string/test_format.test create mode 100644 parser/testdata/corpus/sql/function/string/test_format_extensions.test create mode 100644 parser/testdata/corpus/sql/function/string/test_glob.test create mode 100644 parser/testdata/corpus/sql/function/string/test_ilike.test create mode 100644 parser/testdata/corpus/sql/function/string/test_ilike_constant_pattern.test create mode 100644 parser/testdata/corpus/sql/function/string/test_ilike_embedded_null.test create mode 100644 parser/testdata/corpus/sql/function/string/test_ilike_escape.test create mode 100644 parser/testdata/corpus/sql/function/string/test_ilike_escape_constant_pattern.test create mode 100644 parser/testdata/corpus/sql/function/string/test_instr.test create mode 100644 parser/testdata/corpus/sql/function/string/test_instr_utf8.test create mode 100644 parser/testdata/corpus/sql/function/string/test_issue_1812.test create mode 100644 parser/testdata/corpus/sql/function/string/test_jaccard.test create mode 100644 parser/testdata/corpus/sql/function/string/test_jaro_winkler.test create mode 100644 parser/testdata/corpus/sql/function/string/test_left.test create mode 100644 parser/testdata/corpus/sql/function/string/test_length.test create mode 100644 parser/testdata/corpus/sql/function/string/test_levenshtein.test create mode 100644 parser/testdata/corpus/sql/function/string/test_like.test create mode 100644 parser/testdata/corpus/sql/function/string/test_like_escape.test create mode 100644 parser/testdata/corpus/sql/function/string/test_mismatches.test create mode 100644 parser/testdata/corpus/sql/function/string/test_pad.test create mode 100644 parser/testdata/corpus/sql/function/string/test_prefix.test create mode 100644 parser/testdata/corpus/sql/function/string/test_printf.test create mode 100644 parser/testdata/corpus/sql/function/string/test_repeat.test create mode 100644 parser/testdata/corpus/sql/function/string/test_replace.test create mode 100644 parser/testdata/corpus/sql/function/string/test_reverse.test create mode 100644 parser/testdata/corpus/sql/function/string/test_right.test create mode 100644 parser/testdata/corpus/sql/function/string/test_similar_to.test create mode 100644 parser/testdata/corpus/sql/function/string/test_split_part.test create mode 100644 parser/testdata/corpus/sql/function/string/test_starts_with_function.test create mode 100644 parser/testdata/corpus/sql/function/string/test_starts_with_function_utf8.test create mode 100644 parser/testdata/corpus/sql/function/string/test_starts_with_operator.test create mode 100644 parser/testdata/corpus/sql/function/string/test_starts_with_operator_utf8.test create mode 100644 parser/testdata/corpus/sql/function/string/test_string_array_slice.test create mode 100644 parser/testdata/corpus/sql/function/string/test_string_slice.test create mode 100644 parser/testdata/corpus/sql/function/string/test_string_slice.test.metadata.json create mode 100644 parser/testdata/corpus/sql/function/string/test_string_split.test create mode 100644 parser/testdata/corpus/sql/function/string/test_subscript.test create mode 100644 parser/testdata/corpus/sql/function/string/test_subscript.test.metadata.json create mode 100644 parser/testdata/corpus/sql/function/string/test_substring.test create mode 100644 parser/testdata/corpus/sql/function/string/test_substring_utf8.test create mode 100644 parser/testdata/corpus/sql/function/string/test_suffix.test create mode 100644 parser/testdata/corpus/sql/function/string/test_to_base.test create mode 100644 parser/testdata/corpus/sql/function/string/test_translate.test create mode 100644 parser/testdata/corpus/sql/function/string/test_trim.test create mode 100644 parser/testdata/corpus/sql/function/string/test_unicode.test create mode 100644 parser/testdata/corpus/sql/function/string/test_url_encode.test create mode 100644 parser/testdata/corpus/sql/function/test_scalar_executor.test create mode 100644 parser/testdata/corpus/sql/function/time/epoch.test create mode 100644 parser/testdata/corpus/sql/function/time/test_date_part.test create mode 100644 parser/testdata/corpus/sql/function/time/test_extract.test create mode 100644 parser/testdata/corpus/sql/function/time/test_extract_stats.test create mode 100644 parser/testdata/corpus/sql/function/time/test_time_bucket_time.test create mode 100644 parser/testdata/corpus/sql/function/timestamp/age.test create mode 100644 parser/testdata/corpus/sql/function/timestamp/current_time.test create mode 100644 parser/testdata/corpus/sql/function/timestamp/current_timestamp.test create mode 100644 parser/testdata/corpus/sql/function/timestamp/epoch.test create mode 100644 parser/testdata/corpus/sql/function/timestamp/make_date.test create mode 100644 parser/testdata/corpus/sql/function/timestamp/test_date_diff_epoch.test create mode 100644 parser/testdata/corpus/sql/function/timestamp/test_date_part.test create mode 100644 parser/testdata/corpus/sql/function/timestamp/test_extract.test create mode 100644 parser/testdata/corpus/sql/function/timestamp/test_extract_ms.test create mode 100644 parser/testdata/corpus/sql/function/timestamp/test_icu_age.test create mode 100644 parser/testdata/corpus/sql/function/timestamp/test_icu_dateadd.test create mode 100644 parser/testdata/corpus/sql/function/timestamp/test_icu_datediff.test create mode 100644 parser/testdata/corpus/sql/function/timestamp/test_icu_datepart.test create mode 100644 parser/testdata/corpus/sql/function/timestamp/test_icu_datesub.test create mode 100644 parser/testdata/corpus/sql/function/timestamp/test_icu_datetrunc.test create mode 100644 parser/testdata/corpus/sql/function/timestamp/test_icu_makedate.test create mode 100644 parser/testdata/corpus/sql/function/timestamp/test_icu_strftime.test create mode 100644 parser/testdata/corpus/sql/function/timestamp/test_icu_strptime.test create mode 100644 parser/testdata/corpus/sql/function/timestamp/test_icu_time_bucket_timestamptz.test create mode 100644 parser/testdata/corpus/sql/function/timestamp/test_last_modified.test create mode 100644 parser/testdata/corpus/sql/function/timestamp/test_now.test create mode 100644 parser/testdata/corpus/sql/function/timestamp/test_now_prepared.test create mode 100644 parser/testdata/corpus/sql/function/timestamp/test_strftime_timestamp.test create mode 100644 parser/testdata/corpus/sql/function/timestamp/test_strftime_timestamp_ns.test create mode 100644 parser/testdata/corpus/sql/function/timestamp/test_strptime.test create mode 100644 parser/testdata/corpus/sql/function/timestamp/test_strptime_nonascii.test create mode 100644 parser/testdata/corpus/sql/function/timestamp/test_time_bucket_timestamp.test create mode 100644 parser/testdata/corpus/sql/function/timestamp/test_try_strptime.test create mode 100644 parser/testdata/corpus/sql/function/timetz/test_date_part.test create mode 100644 parser/testdata/corpus/sql/function/timetz/test_extract.test create mode 100644 parser/testdata/corpus/sql/function/timetz/timetz_group_by.test create mode 100644 parser/testdata/corpus/sql/function/tokenize/simple_tokenize.test create mode 100644 parser/testdata/corpus/sql/function/uuid/test_uuid.test create mode 100644 parser/testdata/corpus/sql/function/uuid/test_uuid_function.test create mode 100644 parser/testdata/corpus/sql/function/variant/variant_array_length.test create mode 100644 parser/testdata/corpus/sql/function/variant/variant_array_length_shredded.test create mode 100644 parser/testdata/corpus/sql/function/variant/variant_contains.test create mode 100644 parser/testdata/corpus/sql/function/variant/variant_contains_shredded.test create mode 100644 parser/testdata/corpus/sql/function/variant/variant_exists.test create mode 100644 parser/testdata/corpus/sql/function/variant/variant_exists_shredded.test create mode 100644 parser/testdata/corpus/sql/function/variant/variant_extract.test create mode 100644 parser/testdata/corpus/sql/function/variant/variant_extract_string.test create mode 100644 parser/testdata/corpus/sql/function/variant/variant_extract_string_shredded.test create mode 100644 parser/testdata/corpus/sql/function/variant/variant_extract_try_cast.test create mode 100644 parser/testdata/corpus/sql/function/variant/variant_group_array.test create mode 100644 parser/testdata/corpus/sql/function/variant/variant_group_array_shredded.test create mode 100644 parser/testdata/corpus/sql/function/variant/variant_keys.test create mode 100644 parser/testdata/corpus/sql/function/variant/variant_keys_shredded.test create mode 100644 parser/testdata/corpus/sql/function/variant/variant_shredded_extract_nested.test create mode 100644 parser/testdata/corpus/sql/function/variant/variant_type.test create mode 100644 parser/testdata/corpus/sql/function/variant/variant_type_shredded.test create mode 100644 parser/testdata/corpus/sql/function/variant/variant_typeof.test create mode 100644 parser/testdata/corpus/sql/generated_columns/stored/basic.test create mode 100644 parser/testdata/corpus/sql/generated_columns/virtual/alter_table.test create mode 100644 parser/testdata/corpus/sql/generated_columns/virtual/alter_table.test.metadata.json create mode 100644 parser/testdata/corpus/sql/generated_columns/virtual/ambiguity.test create mode 100644 parser/testdata/corpus/sql/generated_columns/virtual/ambiguity.test.metadata.json create mode 100644 parser/testdata/corpus/sql/generated_columns/virtual/cascading_delete.test create mode 100644 parser/testdata/corpus/sql/generated_columns/virtual/casting.test create mode 100644 parser/testdata/corpus/sql/generated_columns/virtual/check.test create mode 100644 parser/testdata/corpus/sql/generated_columns/virtual/circular_dependency_stresstest.test create mode 100644 parser/testdata/corpus/sql/generated_columns/virtual/collate.test create mode 100644 parser/testdata/corpus/sql/generated_columns/virtual/collate.test.metadata.json create mode 100644 parser/testdata/corpus/sql/generated_columns/virtual/create_table.test create mode 100644 parser/testdata/corpus/sql/generated_columns/virtual/create_table.test.metadata.json create mode 100644 parser/testdata/corpus/sql/generated_columns/virtual/default.test create mode 100644 parser/testdata/corpus/sql/generated_columns/virtual/default.test.metadata.json create mode 100644 parser/testdata/corpus/sql/generated_columns/virtual/drop_dependency.test create mode 100644 parser/testdata/corpus/sql/generated_columns/virtual/foreign_key.test create mode 100644 parser/testdata/corpus/sql/generated_columns/virtual/foreign_key_extensive.test create mode 100644 parser/testdata/corpus/sql/generated_columns/virtual/from_generated_column.test create mode 100644 parser/testdata/corpus/sql/generated_columns/virtual/from_generated_column.test.metadata.json create mode 100644 parser/testdata/corpus/sql/generated_columns/virtual/gcol_duckdb_columns.test create mode 100644 parser/testdata/corpus/sql/generated_columns/virtual/group_by.test create mode 100644 parser/testdata/corpus/sql/generated_columns/virtual/implicit_type.test create mode 100644 parser/testdata/corpus/sql/generated_columns/virtual/implicit_type.test.metadata.json create mode 100644 parser/testdata/corpus/sql/generated_columns/virtual/insert.test create mode 100644 parser/testdata/corpus/sql/generated_columns/virtual/not_referencing_columns.test create mode 100644 parser/testdata/corpus/sql/generated_columns/virtual/null.test create mode 100644 parser/testdata/corpus/sql/generated_columns/virtual/partition.test create mode 100644 parser/testdata/corpus/sql/generated_columns/virtual/preserve_order.test create mode 100644 parser/testdata/corpus/sql/generated_columns/virtual/primary_key.test create mode 100644 parser/testdata/corpus/sql/generated_columns/virtual/referencing_gencols.test create mode 100644 parser/testdata/corpus/sql/generated_columns/virtual/rename.test create mode 100644 parser/testdata/corpus/sql/generated_columns/virtual/rename_dependency.test create mode 100644 parser/testdata/corpus/sql/generated_columns/virtual/rename_table.test create mode 100644 parser/testdata/corpus/sql/generated_columns/virtual/row_group_fetch.test create mode 100644 parser/testdata/corpus/sql/generated_columns/virtual/rowid.test create mode 100644 parser/testdata/corpus/sql/generated_columns/virtual/rowid.test.metadata.json create mode 100644 parser/testdata/corpus/sql/generated_columns/virtual/select.test create mode 100644 parser/testdata/corpus/sql/generated_columns/virtual/select_alias.test create mode 100644 parser/testdata/corpus/sql/generated_columns/virtual/type_resolution_bug.test create mode 100644 parser/testdata/corpus/sql/generated_columns/virtual/typechange.test create mode 100644 parser/testdata/corpus/sql/generated_columns/virtual/typechange_dependency.test create mode 100644 parser/testdata/corpus/sql/generated_columns/virtual/unique.test create mode 100644 parser/testdata/corpus/sql/generated_columns/virtual/update.test create mode 100644 parser/testdata/corpus/sql/generated_columns/virtual/update_index.test create mode 100644 parser/testdata/corpus/sql/index/art/constraints/test_art_compound_key_changes.test create mode 100644 parser/testdata/corpus/sql/index/art/constraints/test_art_eager_batch_insert.test create mode 100644 parser/testdata/corpus/sql/index/art/constraints/test_art_eager_constraint_checking.test create mode 100644 parser/testdata/corpus/sql/index/art/constraints/test_art_eager_with_wal.test create mode 100644 parser/testdata/corpus/sql/index/art/constraints/test_art_large_abort.test create mode 100644 parser/testdata/corpus/sql/index/art/constraints/test_art_simple_update.test create mode 100644 parser/testdata/corpus/sql/index/art/constraints/test_art_tx_conflict_revert.test create mode 100644 parser/testdata/corpus/sql/index/art/constraints/test_art_tx_delete_with_global_nested.test create mode 100644 parser/testdata/corpus/sql/index/art/constraints/test_art_tx_deletes_list.test create mode 100644 parser/testdata/corpus/sql/index/art/constraints/test_art_tx_deletes_rollback.test create mode 100644 parser/testdata/corpus/sql/index/art/constraints/test_art_tx_deletes_varchar.test create mode 100644 parser/testdata/corpus/sql/index/art/constraints/test_art_tx_over_eager.test create mode 100644 parser/testdata/corpus/sql/index/art/constraints/test_art_tx_returning.test create mode 100644 parser/testdata/corpus/sql/index/art/constraints/test_art_tx_same_row_id.test create mode 100644 parser/testdata/corpus/sql/index/art/constraints/test_art_tx_update_with_global_nested.test create mode 100644 parser/testdata/corpus/sql/index/art/constraints/test_art_tx_updates_list.test create mode 100644 parser/testdata/corpus/sql/index/art/constraints/test_art_tx_updates_pk_col.test create mode 100644 parser/testdata/corpus/sql/index/art/constraints/test_art_tx_updates_rollback.test create mode 100644 parser/testdata/corpus/sql/index/art/constraints/test_art_tx_upsert_with_global_nested.test create mode 100644 parser/testdata/corpus/sql/index/art/constraints/test_art_tx_upserts_list.test create mode 100644 parser/testdata/corpus/sql/index/art/constraints/test_art_tx_upserts_local.test create mode 100644 parser/testdata/corpus/sql/index/art/constraints/test_art_tx_upserts_rollback.test create mode 100644 parser/testdata/corpus/sql/index/art/constraints/test_art_upsert_duplicate.test create mode 100644 parser/testdata/corpus/sql/index/art/constraints/test_art_upsert_other_index.test create mode 100644 parser/testdata/corpus/sql/index/art/create_drop/test_art_big_compound_key.test create mode 100644 parser/testdata/corpus/sql/index/art/create_drop/test_art_create_if_exists.test create mode 100644 parser/testdata/corpus/sql/index/art/create_drop/test_art_create_index_delete.test create mode 100644 parser/testdata/corpus/sql/index/art/create_drop/test_art_create_index_duplicate_deletes.test create mode 100644 parser/testdata/corpus/sql/index/art/create_drop/test_art_create_many_duplicates.test create mode 100644 parser/testdata/corpus/sql/index/art/create_drop/test_art_create_many_duplicates_deletes.test create mode 100644 parser/testdata/corpus/sql/index/art/create_drop/test_art_create_unique.test create mode 100644 parser/testdata/corpus/sql/index/art/create_drop/test_art_drop_index.test create mode 100644 parser/testdata/corpus/sql/index/art/create_drop/test_art_invalid_create_index.test create mode 100644 parser/testdata/corpus/sql/index/art/create_drop/test_art_many_versions.test create mode 100644 parser/testdata/corpus/sql/index/art/create_drop/test_art_single_value.test create mode 100644 parser/testdata/corpus/sql/index/art/insert_update_delete/test_art_sel_vector.test create mode 100644 parser/testdata/corpus/sql/index/art/insert_update_delete/test_art_simple_update.test create mode 100644 parser/testdata/corpus/sql/index/art/insert_update_delete/test_art_update.test create mode 100644 parser/testdata/corpus/sql/index/art/insert_update_delete/test_art_update_other_column.test create mode 100644 parser/testdata/corpus/sql/index/art/insert_update_delete/test_art_update_same_value.test create mode 100644 parser/testdata/corpus/sql/index/art/insert_update_delete/test_art_update_with_dict_fsst.test create mode 100644 parser/testdata/corpus/sql/index/art/issues/test_art_fuzzer.test create mode 100644 parser/testdata/corpus/sql/index/art/issues/test_art_fuzzer_persisted.test create mode 100644 parser/testdata/corpus/sql/index/art/issues/test_art_internal_issue_4742.test create mode 100644 parser/testdata/corpus/sql/index/art/issues/test_art_issue_21394.test create mode 100644 parser/testdata/corpus/sql/index/art/issues/test_art_issue_4976.test create mode 100644 parser/testdata/corpus/sql/index/art/issues/test_art_issue_6603.test create mode 100644 parser/testdata/corpus/sql/index/art/issues/test_art_issue_6799.test create mode 100644 parser/testdata/corpus/sql/index/art/issues/test_art_issue_7349.test create mode 100644 parser/testdata/corpus/sql/index/art/issues/test_art_issue_7530.test create mode 100644 parser/testdata/corpus/sql/index/art/issues/test_art_view_col_binding.test create mode 100644 parser/testdata/corpus/sql/index/art/multi_column/test_art_multi_column.test create mode 100644 parser/testdata/corpus/sql/index/art/multi_column/test_art_multi_predicate.test create mode 100644 parser/testdata/corpus/sql/index/art/nodes/test_art_leaf_coverage.test create mode 100644 parser/testdata/corpus/sql/index/art/nodes/test_art_nested_leaf_coverage.test create mode 100644 parser/testdata/corpus/sql/index/art/nodes/test_art_node_16.test create mode 100644 parser/testdata/corpus/sql/index/art/nodes/test_art_node_256.test create mode 100644 parser/testdata/corpus/sql/index/art/nodes/test_art_node_4.test create mode 100644 parser/testdata/corpus/sql/index/art/nodes/test_art_node_48.test create mode 100644 parser/testdata/corpus/sql/index/art/nodes/test_art_prefix_transform_deprecated_create.test create mode 100644 parser/testdata/corpus/sql/index/art/nodes/test_art_prefix_transform_deprecated_gated.test create mode 100644 parser/testdata/corpus/sql/index/art/nodes/test_art_prefixes_restart.test create mode 100644 parser/testdata/corpus/sql/index/art/nodes/test_art_sparse_merge.test create mode 100644 parser/testdata/corpus/sql/index/art/scan/test_art_adaptive_scan.test create mode 100644 parser/testdata/corpus/sql/index/art/scan/test_art_many_matches.test create mode 100644 parser/testdata/corpus/sql/index/art/scan/test_art_negative_range_scan.test create mode 100644 parser/testdata/corpus/sql/index/art/scan/test_art_node256_byte_edges.test create mode 100644 parser/testdata/corpus/sql/index/art/scan/test_art_null_bytes.test create mode 100644 parser/testdata/corpus/sql/index/art/scan/test_art_prepared_scan.test create mode 100644 parser/testdata/corpus/sql/index/art/scan/test_art_range_scan.test create mode 100644 parser/testdata/corpus/sql/index/art/scan/test_art_scan_coverage.test create mode 100644 parser/testdata/corpus/sql/index/art/scan/test_art_scan_duplicate_filters.test create mode 100644 parser/testdata/corpus/sql/index/art/scan/test_art_scan_normal_to_nested.test create mode 100644 parser/testdata/corpus/sql/index/art/scan/test_art_scan_thresholds.test create mode 100644 parser/testdata/corpus/sql/index/art/scan/test_hash_join_in_filter_index_scan.test create mode 100644 parser/testdata/corpus/sql/index/art/scan/test_in_filter_index_scan.test create mode 100644 parser/testdata/corpus/sql/index/art/scan/test_not_distinct_index_scan.test create mode 100644 parser/testdata/corpus/sql/index/art/scan/test_random_uuid.test create mode 100644 parser/testdata/corpus/sql/index/art/storage/test_art_auto_checkpoint.test create mode 100644 parser/testdata/corpus/sql/index/art/storage/test_art_buffered_replays_chunk_edges.test create mode 100644 parser/testdata/corpus/sql/index/art/storage/test_art_buffered_replays_interleaved.test create mode 100644 parser/testdata/corpus/sql/index/art/storage/test_art_buffered_replays_interval_merging.test create mode 100644 parser/testdata/corpus/sql/index/art/storage/test_art_buffered_replays_multi_col.test create mode 100644 parser/testdata/corpus/sql/index/art/storage/test_art_checkpoint.test create mode 100644 parser/testdata/corpus/sql/index/art/storage/test_art_duckdb_versions.test create mode 100644 parser/testdata/corpus/sql/index/art/storage/test_art_import.test create mode 100644 parser/testdata/corpus/sql/index/art/storage/test_art_import_export.test create mode 100644 parser/testdata/corpus/sql/index/art/storage/test_art_mem_limit.test create mode 100644 parser/testdata/corpus/sql/index/art/storage/test_art_names.test create mode 100644 parser/testdata/corpus/sql/index/art/storage/test_art_readonly.test create mode 100644 parser/testdata/corpus/sql/index/art/storage/test_art_storage.test create mode 100644 parser/testdata/corpus/sql/index/art/storage/test_art_storage_long_prefixes.test create mode 100644 parser/testdata/corpus/sql/index/art/storage/test_art_storage_multi_checkpoint.test create mode 100644 parser/testdata/corpus/sql/index/art/storage/test_art_wal_checkpoint_minimal.test create mode 100644 parser/testdata/corpus/sql/index/art/storage/test_art_wal_replay_drop_table.test create mode 100644 parser/testdata/corpus/sql/index/art/storage/test_art_wal_replay_in_tx.test create mode 100644 parser/testdata/corpus/sql/index/art/storage/test_art_wal_replay_with_buffer.test create mode 100644 parser/testdata/corpus/sql/index/art/storage/test_art_wal_replay_with_buffer_concurrent.test create mode 100644 parser/testdata/corpus/sql/index/art/test_art_empty_close_range.test create mode 100644 parser/testdata/corpus/sql/index/art/test_art_tx_update_key.test create mode 100644 parser/testdata/corpus/sql/index/art/test_index_key_rebind.test create mode 100644 parser/testdata/corpus/sql/index/art/types/test_art_boolean.test create mode 100644 parser/testdata/corpus/sql/index/art/types/test_art_coverage_types.test create mode 100644 parser/testdata/corpus/sql/index/art/types/test_art_double.test create mode 100644 parser/testdata/corpus/sql/index/art/types/test_art_expression_key.test create mode 100644 parser/testdata/corpus/sql/index/art/types/test_art_integer_types.test create mode 100644 parser/testdata/corpus/sql/index/art/types/test_art_real.test create mode 100644 parser/testdata/corpus/sql/index/art/types/test_art_real_pk.test create mode 100644 parser/testdata/corpus/sql/index/art/types/test_art_union.test create mode 100644 parser/testdata/corpus/sql/index/art/types/test_art_varchar.test create mode 100644 parser/testdata/corpus/sql/index/art/vacuum/test_art_vacuum_rollback.test create mode 100644 parser/testdata/corpus/sql/index/create_index_options.test create mode 100644 parser/testdata/corpus/sql/insert/insert_by_name.test create mode 100644 parser/testdata/corpus/sql/insert/insert_from_many_grouping_sets.test create mode 100644 parser/testdata/corpus/sql/insert/insert_query_node.test create mode 100644 parser/testdata/corpus/sql/insert/insert_rollback.test create mode 100644 parser/testdata/corpus/sql/insert/null_values.test create mode 100644 parser/testdata/corpus/sql/insert/test_big_insert.test create mode 100644 parser/testdata/corpus/sql/insert/test_insert.test create mode 100644 parser/testdata/corpus/sql/insert/test_insert_invalid.test create mode 100644 parser/testdata/corpus/sql/insert/test_insert_invalid.test.metadata.json create mode 100644 parser/testdata/corpus/sql/insert/test_insert_query.test create mode 100644 parser/testdata/corpus/sql/insert/test_insert_type.test create mode 100644 parser/testdata/corpus/sql/insert/unaligned_interleaved_appends.test create mode 100644 parser/testdata/corpus/sql/join/asof/test_asof_empty_right.test create mode 100644 parser/testdata/corpus/sql/join/asof/test_asof_join.test create mode 100644 parser/testdata/corpus/sql/join/asof/test_asof_join_doubles.test create mode 100644 parser/testdata/corpus/sql/join/asof/test_asof_join_filter_pushdown.test create mode 100644 parser/testdata/corpus/sql/join/asof/test_asof_join_inequalities.test create mode 100644 parser/testdata/corpus/sql/join/asof/test_asof_join_integers.test create mode 100644 parser/testdata/corpus/sql/join/asof/test_asof_join_nulls.test create mode 100644 parser/testdata/corpus/sql/join/asof/test_asof_join_predicates.test create mode 100644 parser/testdata/corpus/sql/join/asof/test_asof_join_prefix.test create mode 100644 parser/testdata/corpus/sql/join/asof/test_asof_join_pushdown.test create mode 100644 parser/testdata/corpus/sql/join/asof/test_asof_join_setops.test create mode 100644 parser/testdata/corpus/sql/join/asof/test_asof_join_subquery.test create mode 100644 parser/testdata/corpus/sql/join/asof/test_asof_join_timestamps.test create mode 100644 parser/testdata/corpus/sql/join/asof/test_asof_join_types.test create mode 100644 parser/testdata/corpus/sql/join/asof/test_asof_join_varchar.test create mode 100644 parser/testdata/corpus/sql/join/asof/test_asof_limit.test create mode 100644 parser/testdata/corpus/sql/join/asof/test_asof_semi_anti_mark.test create mode 100644 parser/testdata/corpus/sql/join/cross_product/test_cross_product.test create mode 100644 parser/testdata/corpus/sql/join/empty_joins.test create mode 100644 parser/testdata/corpus/sql/join/full_outer/full_outer_join_cache.test create mode 100644 parser/testdata/corpus/sql/join/full_outer/full_outer_join_union.test create mode 100644 parser/testdata/corpus/sql/join/full_outer/test_full_outer_join.test create mode 100644 parser/testdata/corpus/sql/join/full_outer/test_full_outer_join_complex.test create mode 100644 parser/testdata/corpus/sql/join/full_outer/test_full_outer_join_inequality.test create mode 100644 parser/testdata/corpus/sql/join/full_outer/test_full_outer_join_issue_4252.test create mode 100644 parser/testdata/corpus/sql/join/full_outer/test_full_outer_join_range.test create mode 100644 parser/testdata/corpus/sql/join/hash_join/hash_join_constant_probe.test create mode 100644 parser/testdata/corpus/sql/join/hash_join/hash_join_dict_surviving.test create mode 100644 parser/testdata/corpus/sql/join/hash_join/hash_join_dictionary_probe.test create mode 100644 parser/testdata/corpus/sql/join/hash_join/hash_join_residual_predicates.test create mode 100644 parser/testdata/corpus/sql/join/iejoin/iejoin_issue_6861.test create mode 100644 parser/testdata/corpus/sql/join/iejoin/iejoin_issue_7278.test create mode 100644 parser/testdata/corpus/sql/join/iejoin/merge_join_switch.test create mode 100644 parser/testdata/corpus/sql/join/iejoin/predicate_expressions.test create mode 100644 parser/testdata/corpus/sql/join/iejoin/test_countzeros.test create mode 100644 parser/testdata/corpus/sql/join/iejoin/test_ieantijoin.test create mode 100644 parser/testdata/corpus/sql/join/iejoin/test_iejoin.test create mode 100644 parser/testdata/corpus/sql/join/iejoin/test_iejoin_east_west.test create mode 100644 parser/testdata/corpus/sql/join/iejoin/test_iejoin_events.test create mode 100644 parser/testdata/corpus/sql/join/iejoin/test_iejoin_null_keys.test create mode 100644 parser/testdata/corpus/sql/join/iejoin/test_iejoin_overlaps.test create mode 100644 parser/testdata/corpus/sql/join/iejoin/test_iejoin_predicate.test create mode 100644 parser/testdata/corpus/sql/join/iejoin/test_iesemijoin.test create mode 100644 parser/testdata/corpus/sql/join/inner/empty_tinyint_column.test create mode 100644 parser/testdata/corpus/sql/join/inner/equality_join_limits.test create mode 100644 parser/testdata/corpus/sql/join/inner/join_cache.test create mode 100644 parser/testdata/corpus/sql/join/inner/join_cross_product.test create mode 100644 parser/testdata/corpus/sql/join/inner/list_join.test create mode 100644 parser/testdata/corpus/sql/join/inner/not_between_is_null.test create mode 100644 parser/testdata/corpus/sql/join/inner/right_semi_dict_emission_dead_end.test create mode 100644 parser/testdata/corpus/sql/join/inner/test_eq_ineq_join.test create mode 100644 parser/testdata/corpus/sql/join/inner/test_inner_join_filter_pushdown.test create mode 100644 parser/testdata/corpus/sql/join/inner/test_join.test create mode 100644 parser/testdata/corpus/sql/join/inner/test_join_duplicates.test create mode 100644 parser/testdata/corpus/sql/join/inner/test_join_filter_precedence.test create mode 100644 parser/testdata/corpus/sql/join/inner/test_join_is_distinct.test create mode 100644 parser/testdata/corpus/sql/join/inner/test_join_is_not_distinct.test create mode 100644 parser/testdata/corpus/sql/join/inner/test_lt_join.test create mode 100644 parser/testdata/corpus/sql/join/inner/test_prefix_range_filter_non_utf8.test create mode 100644 parser/testdata/corpus/sql/join/inner/test_prefix_range_filter_pushdown.test create mode 100644 parser/testdata/corpus/sql/join/inner/test_prefix_range_filter_pushdown_strinline.test create mode 100644 parser/testdata/corpus/sql/join/inner/test_range_join.test create mode 100644 parser/testdata/corpus/sql/join/inner/test_unequal_join.test create mode 100644 parser/testdata/corpus/sql/join/inner/test_unequal_join_duplicates.test create mode 100644 parser/testdata/corpus/sql/join/inner/test_using_chain.test create mode 100644 parser/testdata/corpus/sql/join/inner/test_using_join.test create mode 100644 parser/testdata/corpus/sql/join/inner/test_varchar_join.test create mode 100644 parser/testdata/corpus/sql/join/left_outer/left_join_issue_1172.test create mode 100644 parser/testdata/corpus/sql/join/left_outer/left_join_issue_15316.test create mode 100644 parser/testdata/corpus/sql/join/left_outer/left_join_issue_23805.test create mode 100644 parser/testdata/corpus/sql/join/left_outer/left_join_issue_6341.test create mode 100644 parser/testdata/corpus/sql/join/left_outer/left_join_issue_7905.test create mode 100644 parser/testdata/corpus/sql/join/left_outer/non_foldable_left_join.test create mode 100644 parser/testdata/corpus/sql/join/left_outer/test_left_join_filter_pushdown.test create mode 100644 parser/testdata/corpus/sql/join/left_outer/test_left_join_on_true.test create mode 100644 parser/testdata/corpus/sql/join/left_outer/test_left_outer.test create mode 100644 parser/testdata/corpus/sql/join/left_outer/unique_left_join.test create mode 100644 parser/testdata/corpus/sql/join/natural/natural_join.test create mode 100644 parser/testdata/corpus/sql/join/nearest/nearest_basic.test create mode 100644 parser/testdata/corpus/sql/join/nearest/nearest_errors.test create mode 100644 parser/testdata/corpus/sql/join/nearest/nearest_errors.test.metadata.json create mode 100644 parser/testdata/corpus/sql/join/nearest/nearest_parser.test create mode 100644 parser/testdata/corpus/sql/join/nearest/nearest_storage.test create mode 100644 parser/testdata/corpus/sql/join/non_inner_decorrelation_regressions.test create mode 100644 parser/testdata/corpus/sql/join/non_inner_join_subquery.test create mode 100644 parser/testdata/corpus/sql/join/non_inner_join_subquery_binding.test create mode 100644 parser/testdata/corpus/sql/join/pair_dependent_full_outer_join_subquery.test create mode 100644 parser/testdata/corpus/sql/join/pair_dependent_full_outer_join_subquery_bindings.test create mode 100644 parser/testdata/corpus/sql/join/pair_dependent_full_outer_join_subquery_cte.test create mode 100644 parser/testdata/corpus/sql/join/pair_dependent_join_subquery.test create mode 100644 parser/testdata/corpus/sql/join/pair_dependent_outer_reference_subquery.test create mode 100644 parser/testdata/corpus/sql/join/pair_dependent_volatile_subquery.test create mode 100644 parser/testdata/corpus/sql/join/positional/issue20086.test create mode 100644 parser/testdata/corpus/sql/join/positional/test_positional_join.test create mode 100644 parser/testdata/corpus/sql/join/pushdown/pushdown_generated_columns.test create mode 100644 parser/testdata/corpus/sql/join/pushdown/pushdown_join_types.test create mode 100644 parser/testdata/corpus/sql/join/pushdown/pushdown_many_joins.test create mode 100644 parser/testdata/corpus/sql/join/right_outer/right_join_complex_null.test create mode 100644 parser/testdata/corpus/sql/join/right_outer/test_right_join_filter_pushdown.test create mode 100644 parser/testdata/corpus/sql/join/right_outer/test_right_outer.test create mode 100644 parser/testdata/corpus/sql/join/semianti/10406-anti-on-ints-strings.test create mode 100644 parser/testdata/corpus/sql/join/semianti/antijoin.test create mode 100644 parser/testdata/corpus/sql/join/semianti/mix_equality_inequality.test create mode 100644 parser/testdata/corpus/sql/join/semianti/plan_blockwise_NL_join_with_mutliple_conditions.test create mode 100644 parser/testdata/corpus/sql/join/semianti/right_anti.test create mode 100644 parser/testdata/corpus/sql/join/semianti/right_semi.test create mode 100644 parser/testdata/corpus/sql/join/semianti/semijoin.test create mode 100644 parser/testdata/corpus/sql/join/semianti/test_semianti_join_filter_pushdown.test create mode 100644 parser/testdata/corpus/sql/join/semianti/test_simple_anti_join.test create mode 100644 parser/testdata/corpus/sql/join/set_operators/test_set_operator_reordering_with_delim_joins.test create mode 100644 parser/testdata/corpus/sql/join/test_complex_join_expr.test create mode 100644 parser/testdata/corpus/sql/join/test_complex_range_join.test create mode 100644 parser/testdata/corpus/sql/join/test_join_always_true_conditions.test create mode 100644 parser/testdata/corpus/sql/join/test_join_by.test create mode 100644 parser/testdata/corpus/sql/join/test_join_by.test.metadata.json create mode 100644 parser/testdata/corpus/sql/join/test_join_on_aggregates.test create mode 100644 parser/testdata/corpus/sql/join/test_merge_join_predicate.test create mode 100644 parser/testdata/corpus/sql/join/test_nested_inequality.test create mode 100644 parser/testdata/corpus/sql/join/test_predicate_binding.test create mode 100644 parser/testdata/corpus/sql/join/test_string_payload.test create mode 100644 parser/testdata/corpus/sql/json/copy_geojson.test create mode 100644 parser/testdata/corpus/sql/json/copy_json_null_options.test create mode 100644 parser/testdata/corpus/sql/json/copy_json_partition_by.test create mode 100644 parser/testdata/corpus/sql/json/issues/internal_issue2732.test create mode 100644 parser/testdata/corpus/sql/json/issues/internal_issue3146.test create mode 100644 parser/testdata/corpus/sql/json/issues/internal_issue3197.test create mode 100644 parser/testdata/corpus/sql/json/issues/internal_issue391.test create mode 100644 parser/testdata/corpus/sql/json/issues/internal_issue4014.test create mode 100644 parser/testdata/corpus/sql/json/issues/internal_issue4389.test create mode 100644 parser/testdata/corpus/sql/json/issues/internal_issue4403.test create mode 100644 parser/testdata/corpus/sql/json/issues/internal_issue4794.test create mode 100644 parser/testdata/corpus/sql/json/issues/internal_issue5288.test create mode 100644 parser/testdata/corpus/sql/json/issues/issue10751and11152.test create mode 100644 parser/testdata/corpus/sql/json/issues/issue10784.test create mode 100644 parser/testdata/corpus/sql/json/issues/issue10866.test create mode 100644 parser/testdata/corpus/sql/json/issues/issue11804.test create mode 100644 parser/testdata/corpus/sql/json/issues/issue12188.test create mode 100644 parser/testdata/corpus/sql/json/issues/issue12861.test create mode 100644 parser/testdata/corpus/sql/json/issues/issue13212.test create mode 100644 parser/testdata/corpus/sql/json/issues/issue13725.test create mode 100644 parser/testdata/corpus/sql/json/issues/issue13948.test create mode 100644 parser/testdata/corpus/sql/json/issues/issue14167.test create mode 100644 parser/testdata/corpus/sql/json/issues/issue14245.test create mode 100644 parser/testdata/corpus/sql/json/issues/issue14259.test create mode 100644 parser/testdata/corpus/sql/json/issues/issue15038.test create mode 100644 parser/testdata/corpus/sql/json/issues/issue15601.test create mode 100644 parser/testdata/corpus/sql/json/issues/issue16568.test create mode 100644 parser/testdata/corpus/sql/json/issues/issue16570.test create mode 100644 parser/testdata/corpus/sql/json/issues/issue16684.test create mode 100644 parser/testdata/corpus/sql/json/issues/issue16968.test create mode 100644 parser/testdata/corpus/sql/json/issues/issue17135.test create mode 100644 parser/testdata/corpus/sql/json/issues/issue18301.test create mode 100644 parser/testdata/corpus/sql/json/issues/issue19357.test create mode 100644 parser/testdata/corpus/sql/json/issues/issue19366.test create mode 100644 parser/testdata/corpus/sql/json/issues/issue22764.test create mode 100644 parser/testdata/corpus/sql/json/issues/issue22764.test.metadata.json create mode 100644 parser/testdata/corpus/sql/json/issues/issue23114.test create mode 100644 parser/testdata/corpus/sql/json/issues/issue6722.test create mode 100644 parser/testdata/corpus/sql/json/issues/issue8695.test create mode 100644 parser/testdata/corpus/sql/json/issues/large_quoted_string_constant.test create mode 100644 parser/testdata/corpus/sql/json/issues/map_inference_threshold_internal_exception.test create mode 100644 parser/testdata/corpus/sql/json/issues/read_json_memory_usage.test create mode 100644 parser/testdata/corpus/sql/json/issues/test_json_temp_8062.test create mode 100644 parser/testdata/corpus/sql/json/scalar/json_nested_casts.test create mode 100644 parser/testdata/corpus/sql/json/scalar/test_geojson_cast.test create mode 100644 parser/testdata/corpus/sql/json/scalar/test_json_array_length.test create mode 100644 parser/testdata/corpus/sql/json/scalar/test_json_arrow_expr.test create mode 100644 parser/testdata/corpus/sql/json/scalar/test_json_contains.test create mode 100644 parser/testdata/corpus/sql/json/scalar/test_json_create.test create mode 100644 parser/testdata/corpus/sql/json/scalar/test_json_deep_merge.test create mode 100644 parser/testdata/corpus/sql/json/scalar/test_json_dot_syntax.test create mode 100644 parser/testdata/corpus/sql/json/scalar/test_json_exists.test create mode 100644 parser/testdata/corpus/sql/json/scalar/test_json_extract.test create mode 100644 parser/testdata/corpus/sql/json/scalar/test_json_extract_input_types.test create mode 100644 parser/testdata/corpus/sql/json/scalar/test_json_icu.test create mode 100644 parser/testdata/corpus/sql/json/scalar/test_json_insert.test create mode 100644 parser/testdata/corpus/sql/json/scalar/test_json_keys.test create mode 100644 parser/testdata/corpus/sql/json/scalar/test_json_merge_patch.test create mode 100644 parser/testdata/corpus/sql/json/scalar/test_json_merge_patch_diff.test create mode 100644 parser/testdata/corpus/sql/json/scalar/test_json_normalize.test create mode 100644 parser/testdata/corpus/sql/json/scalar/test_json_path.test create mode 100644 parser/testdata/corpus/sql/json/scalar/test_json_path_prepared.test create mode 100644 parser/testdata/corpus/sql/json/scalar/test_json_pretty.test create mode 100644 parser/testdata/corpus/sql/json/scalar/test_json_remove.test create mode 100644 parser/testdata/corpus/sql/json/scalar/test_json_replace.test create mode 100644 parser/testdata/corpus/sql/json/scalar/test_json_set.test create mode 100644 parser/testdata/corpus/sql/json/scalar/test_json_strip_nulls.test create mode 100644 parser/testdata/corpus/sql/json/scalar/test_json_structure.test create mode 100644 parser/testdata/corpus/sql/json/scalar/test_json_transform.test create mode 100644 parser/testdata/corpus/sql/json/scalar/test_json_type.test create mode 100644 parser/testdata/corpus/sql/json/scalar/test_json_valid.test create mode 100644 parser/testdata/corpus/sql/json/scalar/test_json_value.test create mode 100644 parser/testdata/corpus/sql/json/scalar/test_st_asgeojson.test create mode 100644 parser/testdata/corpus/sql/json/scalar/test_st_geomfromgeojson.test create mode 100644 parser/testdata/corpus/sql/json/table/auto_glob_directory.test create mode 100644 parser/testdata/corpus/sql/json/table/json_empty_array.test create mode 100644 parser/testdata/corpus/sql/json/table/json_multi_file_reader.test create mode 100644 parser/testdata/corpus/sql/json/table/json_table_in_out_fullkey_quoting.test create mode 100644 parser/testdata/corpus/sql/json/table/multi_file_hang.test create mode 100644 parser/testdata/corpus/sql/json/table/read_geojson_errors.test create mode 100644 parser/testdata/corpus/sql/json/table/read_geojson_featurecollection.test create mode 100644 parser/testdata/corpus/sql/json/table/read_geojson_ndjson.test create mode 100644 parser/testdata/corpus/sql/json/table/read_geojson_nested.test create mode 100644 parser/testdata/corpus/sql/json/table/read_geojson_pseudo_columns.test create mode 100644 parser/testdata/corpus/sql/json/table/read_json.test create mode 100644 parser/testdata/corpus/sql/json/table/read_json_dates.test create mode 100644 parser/testdata/corpus/sql/json/table/read_json_objects.test create mode 100644 parser/testdata/corpus/sql/json/table/read_json_union.test create mode 100644 parser/testdata/corpus/sql/json/table/read_json_unnest_heterogeneous_struct.test create mode 100644 parser/testdata/corpus/sql/json/table/test_json_copy_zstd.test create mode 100644 parser/testdata/corpus/sql/json/table/test_json_nested_struct_projection_pushdown.test create mode 100644 parser/testdata/corpus/sql/json/test_json_bool.test create mode 100644 parser/testdata/corpus/sql/json/test_json_cast.test create mode 100644 parser/testdata/corpus/sql/json/test_json_copy_serialize_plan.test create mode 100644 parser/testdata/corpus/sql/json/test_json_empty_object.test create mode 100644 parser/testdata/corpus/sql/json/test_json_export.test create mode 100644 parser/testdata/corpus/sql/json/test_json_geometry_format.test create mode 100644 parser/testdata/corpus/sql/json/test_json_group_window_macro.test create mode 100644 parser/testdata/corpus/sql/json/test_json_macros.test create mode 100644 parser/testdata/corpus/sql/json/test_json_persistence.test create mode 100644 parser/testdata/corpus/sql/json/test_json_serialize_plan.test create mode 100644 parser/testdata/corpus/sql/json/test_json_serialize_sql.test create mode 100644 parser/testdata/corpus/sql/json/test_json_serialize_sql.test.metadata.json create mode 100644 parser/testdata/corpus/sql/json/test_json_sqlite.test create mode 100644 parser/testdata/corpus/sql/keywords/escaped_quotes_expressions.test create mode 100644 parser/testdata/corpus/sql/keywords/keywords_in_expressions.test create mode 100644 parser/testdata/corpus/sql/limit/streaming_limit_pipeline_flush.test create mode 100644 parser/testdata/corpus/sql/limit/test_batch_limit_filters.test create mode 100644 parser/testdata/corpus/sql/limit/test_limit0.test create mode 100644 parser/testdata/corpus/sql/limit/test_preserve_insertion_order.test create mode 100644 parser/testdata/corpus/sql/logging/enable_logging_file_no_path.test create mode 100644 parser/testdata/corpus/sql/logging/file_system_logging_attach.test create mode 100644 parser/testdata/corpus/sql/logging/file_system_logging_attach_deadlock.test create mode 100644 parser/testdata/corpus/sql/logging/http_log_timing.test create mode 100644 parser/testdata/corpus/sql/logging/logging.test create mode 100644 parser/testdata/corpus/sql/logging/logging_buffer_size.test create mode 100644 parser/testdata/corpus/sql/logging/logging_call_functions.test create mode 100644 parser/testdata/corpus/sql/logging/logging_context_ids.test create mode 100644 parser/testdata/corpus/sql/logging/logging_csv.test create mode 100644 parser/testdata/corpus/sql/logging/logging_file_bind_replace.test create mode 100644 parser/testdata/corpus/sql/logging/logging_file_persistence.test create mode 100644 parser/testdata/corpus/sql/logging/logging_file_truncate_rewrite.test create mode 100644 parser/testdata/corpus/sql/logging/logging_memory_after_truncate.test create mode 100644 parser/testdata/corpus/sql/logging/logging_types.test create mode 100644 parser/testdata/corpus/sql/logging/test_logging_function.test create mode 100644 parser/testdata/corpus/sql/merge/merge_into.test create mode 100644 parser/testdata/corpus/sql/merge/merge_into.test.metadata.json create mode 100644 parser/testdata/corpus/sql/merge/merge_into_bind_matching_columns.test create mode 100644 parser/testdata/corpus/sql/merge/merge_into_by_source.test create mode 100644 parser/testdata/corpus/sql/merge/merge_into_constraint.test create mode 100644 parser/testdata/corpus/sql/merge/merge_into_default.test create mode 100644 parser/testdata/corpus/sql/merge/merge_into_error.test create mode 100644 parser/testdata/corpus/sql/merge/merge_into_index.test create mode 100644 parser/testdata/corpus/sql/merge/merge_into_insert_star.test create mode 100644 parser/testdata/corpus/sql/merge/merge_into_invalid_action.test create mode 100644 parser/testdata/corpus/sql/merge/merge_into_invalid_column.test create mode 100644 parser/testdata/corpus/sql/merge/merge_into_invalid_column_reference.test create mode 100644 parser/testdata/corpus/sql/merge/merge_into_join_as_filter.test create mode 100644 parser/testdata/corpus/sql/merge/merge_into_multiple_updates.test create mode 100644 parser/testdata/corpus/sql/merge/merge_into_parenthesis_bug.test create mode 100644 parser/testdata/corpus/sql/merge/merge_into_returning.test create mode 100644 parser/testdata/corpus/sql/merge/merge_into_subquery.test create mode 100644 parser/testdata/corpus/sql/merge/merge_into_subquery_action.test create mode 100644 parser/testdata/corpus/sql/merge/merge_into_subquery_condition.test create mode 100644 parser/testdata/corpus/sql/merge/merge_into_too_few_columns.test create mode 100644 parser/testdata/corpus/sql/merge/merge_into_update_star.test create mode 100644 parser/testdata/corpus/sql/merge/merge_multi_match_error.test create mode 100644 parser/testdata/corpus/sql/merge/trigger_merge_into.test create mode 100644 parser/testdata/corpus/sql/optimizer/any_extremum_rewrite.test create mode 100644 parser/testdata/corpus/sql/optimizer/array_extract_row_group_pruning.test create mode 100644 parser/testdata/corpus/sql/optimizer/boolean_row_group_pruning.test create mode 100644 parser/testdata/corpus/sql/optimizer/boolean_wrapper_pushdown.test create mode 100644 parser/testdata/corpus/sql/optimizer/empty_string_concat_pruning.test create mode 100644 parser/testdata/corpus/sql/optimizer/expression/list_comprehension_rewrite.test create mode 100644 parser/testdata/corpus/sql/optimizer/expression/test_casting_negative_integer_to_bit.test create mode 100644 parser/testdata/corpus/sql/optimizer/expression/test_common_aggregate.test create mode 100644 parser/testdata/corpus/sql/optimizer/expression/test_comparison_simplification.test create mode 100644 parser/testdata/corpus/sql/optimizer/expression/test_conjunction_optimization.test create mode 100644 parser/testdata/corpus/sql/optimizer/expression/test_cse.test create mode 100644 parser/testdata/corpus/sql/optimizer/expression/test_date_subtract_filter.test create mode 100644 parser/testdata/corpus/sql/optimizer/expression/test_enum_in_simplification.test create mode 100644 parser/testdata/corpus/sql/optimizer/expression/test_equal_or_null_optimization.test create mode 100644 parser/testdata/corpus/sql/optimizer/expression/test_in_clause_simplification.test create mode 100644 parser/testdata/corpus/sql/optimizer/expression/test_indistinct_aggregates.test create mode 100644 parser/testdata/corpus/sql/optimizer/expression/test_move_constants.test create mode 100644 parser/testdata/corpus/sql/optimizer/expression/test_negation_limits.test create mode 100644 parser/testdata/corpus/sql/optimizer/expression/test_nop_arithmetic.test create mode 100644 parser/testdata/corpus/sql/optimizer/expression/test_row_comparison_simplification.test create mode 100644 parser/testdata/corpus/sql/optimizer/expression/test_timestamp_offset.test create mode 100644 parser/testdata/corpus/sql/optimizer/in_list_row_group_pruning.test create mode 100644 parser/testdata/corpus/sql/optimizer/instr_zonemap_pruning.test create mode 100644 parser/testdata/corpus/sql/optimizer/interval_row_group_pruning.test create mode 100644 parser/testdata/corpus/sql/optimizer/late_materialization_pushdown_extract.test create mode 100644 parser/testdata/corpus/sql/optimizer/late_materialization_table_filters.test create mode 100644 parser/testdata/corpus/sql/optimizer/monotone_function_zonemap_pruning.test create mode 100644 parser/testdata/corpus/sql/optimizer/monotone_preimage.test create mode 100644 parser/testdata/corpus/sql/optimizer/nested_null_segment_pruning.test create mode 100644 parser/testdata/corpus/sql/optimizer/nested_null_segment_pruning.test.metadata.json create mode 100644 parser/testdata/corpus/sql/optimizer/not_conjunction_simplification.test create mode 100644 parser/testdata/corpus/sql/optimizer/nullable_row_group_pruning.test create mode 100644 parser/testdata/corpus/sql/optimizer/plan/plan_struct_projection_pushdown.test create mode 100644 parser/testdata/corpus/sql/optimizer/plan/test_anti_join_empty_child.test create mode 100644 parser/testdata/corpus/sql/optimizer/plan/test_disable_build_side_probe_side.test create mode 100644 parser/testdata/corpus/sql/optimizer/plan/test_equivalent_filter_mirroring.test create mode 100644 parser/testdata/corpus/sql/optimizer/plan/test_except_empty_rhs.test create mode 100644 parser/testdata/corpus/sql/optimizer/plan/test_filter_pushdown.test create mode 100644 parser/testdata/corpus/sql/optimizer/plan/test_filter_pushdown_duplicate.test create mode 100644 parser/testdata/corpus/sql/optimizer/plan/test_filter_pushdown_large.test create mode 100644 parser/testdata/corpus/sql/optimizer/plan/test_filter_pushdown_materialized_cte.test create mode 100644 parser/testdata/corpus/sql/optimizer/plan/test_recursive_build_side_probe_side.test create mode 100644 parser/testdata/corpus/sql/optimizer/plan/test_recursive_join_order_guard.test create mode 100644 parser/testdata/corpus/sql/optimizer/plan/test_table_filter_pushdown.test create mode 100644 parser/testdata/corpus/sql/optimizer/plan/test_unused_column_after_join.test create mode 100644 parser/testdata/corpus/sql/optimizer/power_zonemap_pruning.test create mode 100644 parser/testdata/corpus/sql/optimizer/predicate_factoring.test create mode 100644 parser/testdata/corpus/sql/optimizer/rewrite_nan_null.test create mode 100644 parser/testdata/corpus/sql/optimizer/rewrite_nan_null.test.metadata.json create mode 100644 parser/testdata/corpus/sql/optimizer/sign_row_group_pruning.test create mode 100644 parser/testdata/corpus/sql/optimizer/string_row_group_pruning.test create mode 100644 parser/testdata/corpus/sql/optimizer/string_stats_merge.test create mode 100644 parser/testdata/corpus/sql/optimizer/struct_segment_pruning.test create mode 100644 parser/testdata/corpus/sql/optimizer/struct_segment_pruning.test.metadata.json create mode 100644 parser/testdata/corpus/sql/optimizer/substring_zonemap_pruning.test create mode 100644 parser/testdata/corpus/sql/optimizer/table_filters.test create mode 100644 parser/testdata/corpus/sql/optimizer/temporal_cast_dst.test create mode 100644 parser/testdata/corpus/sql/optimizer/temporal_cast_zonemap.test create mode 100644 parser/testdata/corpus/sql/optimizer/test_common_subplan_cte_binding_order.test create mode 100644 parser/testdata/corpus/sql/optimizer/test_common_subplan_projection_maps.test create mode 100644 parser/testdata/corpus/sql/optimizer/test_common_subplan_table_filters.test create mode 100644 parser/testdata/corpus/sql/optimizer/test_duplicate_groups_optimizer.test create mode 100644 parser/testdata/corpus/sql/optimizer/test_fd_derived_groups.test create mode 100644 parser/testdata/corpus/sql/optimizer/test_glob_row_group_pruning.test create mode 100644 parser/testdata/corpus/sql/optimizer/test_in_rewrite_rule.test create mode 100644 parser/testdata/corpus/sql/optimizer/test_negated_filter_cardinality.test create mode 100644 parser/testdata/corpus/sql/optimizer/test_no_pushdown_cast_into_cte.test create mode 100644 parser/testdata/corpus/sql/optimizer/test_not_comparison_simplification.test create mode 100644 parser/testdata/corpus/sql/optimizer/test_rollup_column_pruning.test create mode 100644 parser/testdata/corpus/sql/optimizer/test_rowid_pruning.test create mode 100644 parser/testdata/corpus/sql/optimizer/test_rowid_pushdown.test create mode 100644 parser/testdata/corpus/sql/optimizer/test_rowid_pushdown_deletes.test create mode 100644 parser/testdata/corpus/sql/optimizer/test_rowid_pushdown_plan.test create mode 100644 parser/testdata/corpus/sql/optimizer/test_window_self_join.test create mode 100644 parser/testdata/corpus/sql/optimizer/tests_no_pushdown_under_samples.test create mode 100644 parser/testdata/corpus/sql/optimizer/topn_window_elimination_late_materialization.test create mode 100644 parser/testdata/corpus/sql/optimizer/topn_window_set_elimination.test create mode 100644 parser/testdata/corpus/sql/optimizer/window_self_join_optimizer_csv.test create mode 100644 parser/testdata/corpus/sql/order/hugeint_order_by_extremes.test create mode 100644 parser/testdata/corpus/sql/order/issue_11936.test create mode 100644 parser/testdata/corpus/sql/order/limit_full_outer_join.test create mode 100644 parser/testdata/corpus/sql/order/limit_parameter.test create mode 100644 parser/testdata/corpus/sql/order/limit_percent_view.test create mode 100644 parser/testdata/corpus/sql/order/limit_union.test create mode 100644 parser/testdata/corpus/sql/order/negative_offset.test create mode 100644 parser/testdata/corpus/sql/order/order_by_all.test create mode 100644 parser/testdata/corpus/sql/order/order_by_internal_5293.test create mode 100644 parser/testdata/corpus/sql/order/order_overflow.test create mode 100644 parser/testdata/corpus/sql/order/test_limit.test create mode 100644 parser/testdata/corpus/sql/order/test_limit_cte.test create mode 100644 parser/testdata/corpus/sql/order/test_limit_parameter.test create mode 100644 parser/testdata/corpus/sql/order/test_limit_percent.test create mode 100644 parser/testdata/corpus/sql/order/test_nulls_first.test create mode 100644 parser/testdata/corpus/sql/order/test_nulls_first.test.metadata.json create mode 100644 parser/testdata/corpus/sql/order/test_order_by.test create mode 100644 parser/testdata/corpus/sql/order/test_order_by_exceptions.test create mode 100644 parser/testdata/corpus/sql/order/test_order_by_non_ordinal_literal.test create mode 100644 parser/testdata/corpus/sql/order/test_order_large.test create mode 100644 parser/testdata/corpus/sql/order/test_order_pragma.test create mode 100644 parser/testdata/corpus/sql/order/test_order_range_mapping.test create mode 100644 parser/testdata/corpus/sql/order/test_order_unnest.test create mode 100644 parser/testdata/corpus/sql/order/top_n_issue_21623.test create mode 100644 parser/testdata/corpus/sql/order/top_n_nulls.test create mode 100644 parser/testdata/corpus/sql/ordinality/ordinality_constant.test create mode 100644 parser/testdata/corpus/sql/ordinality/ordinality_inout.test create mode 100644 parser/testdata/corpus/sql/overflow/bigint_overflow.test create mode 100644 parser/testdata/corpus/sql/overflow/double_float_overflow.test create mode 100644 parser/testdata/corpus/sql/overflow/expression_tree_depth.test create mode 100644 parser/testdata/corpus/sql/overflow/expression_tree_depth.test.metadata.json create mode 100644 parser/testdata/corpus/sql/overflow/integer_overflow.test create mode 100644 parser/testdata/corpus/sql/overflow/table_overflow.test create mode 100644 parser/testdata/corpus/sql/overflow/test_numeric_overflow.test create mode 100644 parser/testdata/corpus/sql/overflow/test_overflow.test create mode 100644 parser/testdata/corpus/sql/parallelism/async_task_schedule_pool.test create mode 100644 parser/testdata/corpus/sql/parallelism/interquery/concurrent_appends.test create mode 100644 parser/testdata/corpus/sql/parallelism/interquery/concurrent_checkpoint_insert.test create mode 100644 parser/testdata/corpus/sql/parallelism/interquery/concurrent_force_checkpoint.test create mode 100644 parser/testdata/corpus/sql/parallelism/interquery/concurrent_index_scans_while_appending.test create mode 100644 parser/testdata/corpus/sql/parallelism/interquery/concurrent_reads_while_altering.test create mode 100644 parser/testdata/corpus/sql/parallelism/interquery/concurrent_reads_while_renaming.test create mode 100644 parser/testdata/corpus/sql/parallelism/interquery/concurrent_set_async_threads_read_ahead.test create mode 100644 parser/testdata/corpus/sql/parallelism/intraquery/depth_first_evaluation_union_and_join.test create mode 100644 parser/testdata/corpus/sql/parallelism/intraquery/error_in_pipeline.test create mode 100644 parser/testdata/corpus/sql/parallelism/intraquery/parallel_sample.test create mode 100644 parser/testdata/corpus/sql/parallelism/intraquery/test_parallel_nested_aggregates.test create mode 100644 parser/testdata/corpus/sql/parallelism/intraquery/test_persistent_parallelism.test create mode 100644 parser/testdata/corpus/sql/parallelism/intraquery/test_simple_parallelism.test create mode 100644 parser/testdata/corpus/sql/parallelism/intraquery/test_verify_parallelism.test create mode 100644 parser/testdata/corpus/sql/parser/columns_aliases.test create mode 100644 parser/testdata/corpus/sql/parser/columns_issue9867.test create mode 100644 parser/testdata/corpus/sql/parser/digit_separators.test create mode 100644 parser/testdata/corpus/sql/parser/division_operator_precedence.test create mode 100644 parser/testdata/corpus/sql/parser/dollar_quotes_internal_issue2224.test create mode 100644 parser/testdata/corpus/sql/parser/empty_quoted_identifier.test create mode 100644 parser/testdata/corpus/sql/parser/expression_depth_limit.test create mode 100644 parser/testdata/corpus/sql/parser/external_resource_roundtrip.test create mode 100644 parser/testdata/corpus/sql/parser/fetch_first.test create mode 100644 parser/testdata/corpus/sql/parser/from_first.test create mode 100644 parser/testdata/corpus/sql/parser/function_chaining.test create mode 100644 parser/testdata/corpus/sql/parser/hex_string_literal.test create mode 100644 parser/testdata/corpus/sql/parser/indirection.test create mode 100644 parser/testdata/corpus/sql/parser/invalid_utf8_parser_location.test create mode 100644 parser/testdata/corpus/sql/parser/invisible_spaces.test create mode 100644 parser/testdata/corpus/sql/parser/join_alias.test create mode 100644 parser/testdata/corpus/sql/parser/position_prepare.test create mode 100644 parser/testdata/corpus/sql/parser/star_expression.test create mode 100644 parser/testdata/corpus/sql/parser/statement_tostring_roundtrip.test create mode 100644 parser/testdata/corpus/sql/parser/switch_case.test create mode 100644 parser/testdata/corpus/sql/parser/table_at_clause.test create mode 100644 parser/testdata/corpus/sql/parser/test_columns.test create mode 100644 parser/testdata/corpus/sql/parser/test_columns_lists.test create mode 100644 parser/testdata/corpus/sql/parser/test_columns_order.test create mode 100644 parser/testdata/corpus/sql/parser/test_columns_prepared.test create mode 100644 parser/testdata/corpus/sql/parser/test_columns_unpacked.test create mode 100644 parser/testdata/corpus/sql/parser/test_columns_where.test create mode 100644 parser/testdata/corpus/sql/parser/test_long_error.test create mode 100644 parser/testdata/corpus/sql/parser/test_operator_precedence.test create mode 100644 parser/testdata/corpus/sql/parser/test_value_functions.test create mode 100644 parser/testdata/corpus/sql/parser/trailing_commas.test create mode 100644 parser/testdata/corpus/sql/parser/unreserved_keyword_casing.test create mode 100644 parser/testdata/corpus/sql/parser/values_list_error.test create mode 100644 parser/testdata/corpus/sql/parser/values_list_error.test.metadata.json create mode 100644 parser/testdata/corpus/sql/parser/values_list_without_brackets.test create mode 100644 parser/testdata/corpus/sql/peg_parser/binary_type.test create mode 100644 parser/testdata/corpus/sql/peg_parser/enable_peg_parser.test create mode 100644 parser/testdata/corpus/sql/peg_parser/escape_string.test create mode 100644 parser/testdata/corpus/sql/peg_parser/escape_string.test.metadata.json create mode 100644 parser/testdata/corpus/sql/peg_parser/expression_statement.test create mode 100644 parser/testdata/corpus/sql/peg_parser/fuzzer/diverge_0000.test create mode 100644 parser/testdata/corpus/sql/peg_parser/fuzzer/diverge_0002.test create mode 100644 parser/testdata/corpus/sql/peg_parser/fuzzer/diverge_0004.test create mode 100644 parser/testdata/corpus/sql/peg_parser/fuzzer/diverge_0007.test create mode 100644 parser/testdata/corpus/sql/peg_parser/fuzzer/diverge_0009.test create mode 100644 parser/testdata/corpus/sql/peg_parser/fuzzer/diverge_0014.test create mode 100644 parser/testdata/corpus/sql/peg_parser/fuzzer/diverge_0020.test create mode 100644 parser/testdata/corpus/sql/peg_parser/fuzzer/diverge_0020.test.metadata.json create mode 100644 parser/testdata/corpus/sql/peg_parser/fuzzer/diverge_0039.test create mode 100644 parser/testdata/corpus/sql/peg_parser/fuzzer/diverge_0060.test create mode 100644 parser/testdata/corpus/sql/peg_parser/fuzzer/fuzzer_4434.test create mode 100644 parser/testdata/corpus/sql/peg_parser/fuzzer/fuzzer_4434.test.metadata.json create mode 100644 parser/testdata/corpus/sql/peg_parser/fuzzer/internal_0001.test create mode 100644 parser/testdata/corpus/sql/peg_parser/fuzzer/internal_0001.test.metadata.json create mode 100644 parser/testdata/corpus/sql/peg_parser/fuzzer/internal_0206.test create mode 100644 parser/testdata/corpus/sql/peg_parser/fuzzer/internal_0208.test create mode 100644 parser/testdata/corpus/sql/peg_parser/fuzzer/internal_0227.test create mode 100644 parser/testdata/corpus/sql/peg_parser/fuzzer/internal_0227.test.metadata.json create mode 100644 parser/testdata/corpus/sql/peg_parser/identifier.test create mode 100644 parser/testdata/corpus/sql/peg_parser/parser/alter.test create mode 100644 parser/testdata/corpus/sql/peg_parser/parser/analyze_vacuum.test create mode 100644 parser/testdata/corpus/sql/peg_parser/parser/array_subquery.test create mode 100644 parser/testdata/corpus/sql/peg_parser/parser/attach_or_replace.test create mode 100644 parser/testdata/corpus/sql/peg_parser/parser/collate.test create mode 100644 parser/testdata/corpus/sql/peg_parser/parser/colon_alias.test create mode 100644 parser/testdata/corpus/sql/peg_parser/parser/comments.test create mode 100644 parser/testdata/corpus/sql/peg_parser/parser/copy_expression.test create mode 100644 parser/testdata/corpus/sql/peg_parser/parser/create_macro.test create mode 100644 parser/testdata/corpus/sql/peg_parser/parser/create_table.test create mode 100644 parser/testdata/corpus/sql/peg_parser/parser/create_type.test create mode 100644 parser/testdata/corpus/sql/peg_parser/parser/custom_operator.test create mode 100644 parser/testdata/corpus/sql/peg_parser/parser/delete_from.test create mode 100644 parser/testdata/corpus/sql/peg_parser/parser/dollar_quoted.test create mode 100644 parser/testdata/corpus/sql/peg_parser/parser/dotted_functions.test create mode 100644 parser/testdata/corpus/sql/peg_parser/parser/empty_map.test create mode 100644 parser/testdata/corpus/sql/peg_parser/parser/ignore_nulls.test create mode 100644 parser/testdata/corpus/sql/peg_parser/parser/index.test create mode 100644 parser/testdata/corpus/sql/peg_parser/parser/insert.test create mode 100644 parser/testdata/corpus/sql/peg_parser/parser/insert_statement.test create mode 100644 parser/testdata/corpus/sql/peg_parser/parser/invisible_space.test create mode 100644 parser/testdata/corpus/sql/peg_parser/parser/lambda_functions.test create mode 100644 parser/testdata/corpus/sql/peg_parser/parser/list_slices.test create mode 100644 parser/testdata/corpus/sql/peg_parser/parser/load_extension.test create mode 100644 parser/testdata/corpus/sql/peg_parser/parser/map.test create mode 100644 parser/testdata/corpus/sql/peg_parser/parser/merge_into.test create mode 100644 parser/testdata/corpus/sql/peg_parser/parser/named_parameters.test create mode 100644 parser/testdata/corpus/sql/peg_parser/parser/nested_join.test create mode 100644 parser/testdata/corpus/sql/peg_parser/parser/on_conflict.test create mode 100644 parser/testdata/corpus/sql/peg_parser/parser/pivot_statement.test create mode 100644 parser/testdata/corpus/sql/peg_parser/parser/position.test create mode 100644 parser/testdata/corpus/sql/peg_parser/parser/recursive.test create mode 100644 parser/testdata/corpus/sql/peg_parser/parser/sample.test create mode 100644 parser/testdata/corpus/sql/peg_parser/parser/scientific_notation.test create mode 100644 parser/testdata/corpus/sql/peg_parser/parser/select_star.test create mode 100644 parser/testdata/corpus/sql/peg_parser/parser/show_table.test create mode 100644 parser/testdata/corpus/sql/peg_parser/parser/struct_identifier.test create mode 100644 parser/testdata/corpus/sql/peg_parser/parser/support_optional_not_null_constraint.test create mode 100644 parser/testdata/corpus/sql/peg_parser/parser/support_try.test create mode 100644 parser/testdata/corpus/sql/peg_parser/parser/support_unreserved_keywords.test create mode 100644 parser/testdata/corpus/sql/peg_parser/parser/type.test create mode 100644 parser/testdata/corpus/sql/peg_parser/parser/update_statement.test create mode 100644 parser/testdata/corpus/sql/peg_parser/parser/use_statement.test create mode 100644 parser/testdata/corpus/sql/peg_parser/parser/window_function.test create mode 100644 parser/testdata/corpus/sql/peg_parser/parser/with_ordinality.test create mode 100644 parser/testdata/corpus/sql/peg_parser/peg_syntax_error.test create mode 100644 parser/testdata/corpus/sql/peg_parser/peg_syntax_error.test.metadata.json create mode 100644 parser/testdata/corpus/sql/peg_parser/qualified_operator.test create mode 100644 parser/testdata/corpus/sql/peg_parser/qualified_operator.test.metadata.json create mode 100644 parser/testdata/corpus/sql/peg_parser/transformer/alter_statement.test create mode 100644 parser/testdata/corpus/sql/peg_parser/transformer/attach_statement.test create mode 100644 parser/testdata/corpus/sql/peg_parser/transformer/call_statement.test create mode 100644 parser/testdata/corpus/sql/peg_parser/transformer/delete_statement.test create mode 100644 parser/testdata/corpus/sql/peg_parser/transformer/drop_statement.test create mode 100644 parser/testdata/corpus/sql/peg_parser/transformer/load_statement.test create mode 100644 parser/testdata/corpus/sql/peg_parser/transformer/peg_transformer.test create mode 100644 parser/testdata/corpus/sql/peg_parser/transformer/set_statement.test create mode 100644 parser/testdata/corpus/sql/peg_parser/transformer/set_statement.test.metadata.json create mode 100644 parser/testdata/corpus/sql/peg_parser/transformer/special_string.test create mode 100644 parser/testdata/corpus/sql/peg_parser/transformer/statement_length.test create mode 100644 parser/testdata/corpus/sql/peg_parser/transformer/transaction_statement.test create mode 100644 parser/testdata/corpus/sql/peg_parser/transformer/trim.test create mode 100644 parser/testdata/corpus/sql/peg_parser/transformer/unary_expression.test create mode 100644 parser/testdata/corpus/sql/peg_parser/transformer/update_extensions.test create mode 100644 parser/testdata/corpus/sql/peg_parser/transformer/use_statement_trampoline.test create mode 100644 parser/testdata/corpus/sql/peg_parser/transformer/use_statement_trampoline.test.metadata.json create mode 100644 parser/testdata/corpus/sql/peg_parser/unterminated_literals.test create mode 100644 parser/testdata/corpus/sql/pg_catalog/pg_attribute.test create mode 100644 parser/testdata/corpus/sql/pg_catalog/pg_constraint.test create mode 100644 parser/testdata/corpus/sql/pg_catalog/pg_database.test create mode 100644 parser/testdata/corpus/sql/pg_catalog/pg_depend.test create mode 100644 parser/testdata/corpus/sql/pg_catalog/pg_enum.test create mode 100644 parser/testdata/corpus/sql/pg_catalog/pg_index.test create mode 100644 parser/testdata/corpus/sql/pg_catalog/pg_namespace.test create mode 100644 parser/testdata/corpus/sql/pg_catalog/pg_prepared_statements.test create mode 100644 parser/testdata/corpus/sql/pg_catalog/pg_privilege.test create mode 100644 parser/testdata/corpus/sql/pg_catalog/pg_sequence.test create mode 100644 parser/testdata/corpus/sql/pg_catalog/pg_sequences.test create mode 100644 parser/testdata/corpus/sql/pg_catalog/pg_settings.test create mode 100644 parser/testdata/corpus/sql/pg_catalog/pg_tablespace.test create mode 100644 parser/testdata/corpus/sql/pg_catalog/pg_type.test create mode 100644 parser/testdata/corpus/sql/pg_catalog/pg_views.test create mode 100644 parser/testdata/corpus/sql/pg_catalog/sqlalchemy.test create mode 100644 parser/testdata/corpus/sql/pg_catalog/system_functions.test create mode 100644 parser/testdata/corpus/sql/pivot/optional_pivots.test create mode 100644 parser/testdata/corpus/sql/pivot/pivot_15141.test create mode 100644 parser/testdata/corpus/sql/pivot/pivot_6390.test create mode 100644 parser/testdata/corpus/sql/pivot/pivot_bigquery.test create mode 100644 parser/testdata/corpus/sql/pivot/pivot_case_insensitive.test create mode 100644 parser/testdata/corpus/sql/pivot/pivot_databricks.test create mode 100644 parser/testdata/corpus/sql/pivot/pivot_empty.test create mode 100644 parser/testdata/corpus/sql/pivot/pivot_enum.test create mode 100644 parser/testdata/corpus/sql/pivot/pivot_errors.test create mode 100644 parser/testdata/corpus/sql/pivot/pivot_expressions.test create mode 100644 parser/testdata/corpus/sql/pivot/pivot_expressions.test.metadata.json create mode 100644 parser/testdata/corpus/sql/pivot/pivot_generated.test create mode 100644 parser/testdata/corpus/sql/pivot/pivot_in_boolean.test create mode 100644 parser/testdata/corpus/sql/pivot/pivot_in_subquery.test create mode 100644 parser/testdata/corpus/sql/pivot/pivot_operator_expression.test create mode 100644 parser/testdata/corpus/sql/pivot/pivot_prepare.test create mode 100644 parser/testdata/corpus/sql/pivot/pivot_prepare.test.metadata.json create mode 100644 parser/testdata/corpus/sql/pivot/pivot_query_text.test create mode 100644 parser/testdata/corpus/sql/pivot/pivot_star.test create mode 100644 parser/testdata/corpus/sql/pivot/pivot_storage.test create mode 100644 parser/testdata/corpus/sql/pivot/pivot_struct_aggregate.test create mode 100644 parser/testdata/corpus/sql/pivot/pivot_subquery.test create mode 100644 parser/testdata/corpus/sql/pivot/pivot_subquery.test.metadata.json create mode 100644 parser/testdata/corpus/sql/pivot/test_multi_pivot.test create mode 100644 parser/testdata/corpus/sql/pivot/test_pivot.test create mode 100644 parser/testdata/corpus/sql/pivot/test_pivot_duplicate_aggregates.test create mode 100644 parser/testdata/corpus/sql/pivot/test_unpivot.test create mode 100644 parser/testdata/corpus/sql/pivot/test_unpivot.test.metadata.json create mode 100644 parser/testdata/corpus/sql/pivot/test_unpivot_stmt.test create mode 100644 parser/testdata/corpus/sql/pivot/top_level_pivot_syntax.test create mode 100644 parser/testdata/corpus/sql/pivot/top_level_pivot_syntax.test.metadata.json create mode 100644 parser/testdata/corpus/sql/pivot/unpivot_expression.test create mode 100644 parser/testdata/corpus/sql/pivot/unpivot_internal_names.test create mode 100644 parser/testdata/corpus/sql/pivot/unpivot_no_columns.test create mode 100644 parser/testdata/corpus/sql/pivot/unpivot_non_aligned_columns.test create mode 100644 parser/testdata/corpus/sql/pivot/unpivot_types.test create mode 100644 parser/testdata/corpus/sql/pivot/unpivot_unnamed_subquery.test create mode 100644 parser/testdata/corpus/sql/pivot/unpivot_view.test create mode 100644 parser/testdata/corpus/sql/pragma/pragma_database_size_readonly.test create mode 100644 parser/testdata/corpus/sql/pragma/profiling/call_enable_profiling_function.test create mode 100644 parser/testdata/corpus/sql/pragma/profiling/call_enable_profiling_function.test.metadata.json create mode 100644 parser/testdata/corpus/sql/pragma/profiling/test_all_profiling_settings.test create mode 100644 parser/testdata/corpus/sql/pragma/profiling/test_attach_and_checkpoint_latency.test create mode 100644 parser/testdata/corpus/sql/pragma/profiling/test_attach_and_checkpoint_latency.test.metadata.json create mode 100644 parser/testdata/corpus/sql/pragma/profiling/test_autocheckpoint_latency.test create mode 100644 parser/testdata/corpus/sql/pragma/profiling/test_autocheckpoint_latency.test.metadata.json create mode 100644 parser/testdata/corpus/sql/pragma/profiling/test_checkpoint_profiling.test create mode 100644 parser/testdata/corpus/sql/pragma/profiling/test_checkpoint_profiling.test.metadata.json create mode 100644 parser/testdata/corpus/sql/pragma/profiling/test_commit_write_wal_latency_and_count.test create mode 100644 parser/testdata/corpus/sql/pragma/profiling/test_commit_write_wal_latency_and_count.test.metadata.json create mode 100644 parser/testdata/corpus/sql/pragma/profiling/test_custom_profiling_blocked_thread_time.test create mode 100644 parser/testdata/corpus/sql/pragma/profiling/test_custom_profiling_disable_metrics.test create mode 100644 parser/testdata/corpus/sql/pragma/profiling/test_custom_profiling_disable_metrics.test.metadata.json create mode 100644 parser/testdata/corpus/sql/pragma/profiling/test_custom_profiling_errors.test create mode 100644 parser/testdata/corpus/sql/pragma/profiling/test_custom_profiling_optimizer_settings.test create mode 100644 parser/testdata/corpus/sql/pragma/profiling/test_custom_profiling_result_set_size.test create mode 100644 parser/testdata/corpus/sql/pragma/profiling/test_custom_profiling_row_group_metrics_local_storage.test create mode 100644 parser/testdata/corpus/sql/pragma/profiling/test_custom_profiling_rows_scanned.test create mode 100644 parser/testdata/corpus/sql/pragma/profiling/test_custom_profiling_rows_scanned_parquet.test create mode 100644 parser/testdata/corpus/sql/pragma/profiling/test_custom_profiling_total_memory_allocated.test create mode 100644 parser/testdata/corpus/sql/pragma/profiling/test_custom_profiling_using_groups.test create mode 100644 parser/testdata/corpus/sql/pragma/profiling/test_duckdb_profiling_settings_function.test create mode 100644 parser/testdata/corpus/sql/pragma/profiling/test_duckdb_profiling_settings_function.test.metadata.json create mode 100644 parser/testdata/corpus/sql/pragma/profiling/test_empty_profiling_settings.test create mode 100644 parser/testdata/corpus/sql/pragma/profiling/test_legacy_metrics_format.test create mode 100644 parser/testdata/corpus/sql/pragma/profiling/test_logging_interaction.test create mode 100644 parser/testdata/corpus/sql/pragma/profiling/test_logging_interaction.test.metadata.json create mode 100644 parser/testdata/corpus/sql/pragma/profiling/test_no_reset_setting.test create mode 100644 parser/testdata/corpus/sql/pragma/profiling/test_no_reset_setting.test.metadata.json create mode 100644 parser/testdata/corpus/sql/pragma/profiling/test_operator_info_suppression.test create mode 100644 parser/testdata/corpus/sql/pragma/profiling/test_profiling_all.test create mode 100644 parser/testdata/corpus/sql/pragma/profiling/test_profiling_fs.test create mode 100644 parser/testdata/corpus/sql/pragma/profiling/test_profiling_output_file_overwrite.test create mode 100644 parser/testdata/corpus/sql/pragma/profiling/test_profiling_output_file_overwrite.test.metadata.json create mode 100644 parser/testdata/corpus/sql/pragma/test_db_invalidation_after_load.test create mode 100644 parser/testdata/corpus/sql/pragma/test_disabled_compression.test create mode 100644 parser/testdata/corpus/sql/pragma/test_enable_profile.test create mode 100644 parser/testdata/corpus/sql/pragma/test_enable_profile.test.metadata.json create mode 100644 parser/testdata/corpus/sql/pragma/test_force_compression.test create mode 100644 parser/testdata/corpus/sql/pragma/test_memory_limit.test create mode 100644 parser/testdata/corpus/sql/pragma/test_memory_limit.test.metadata.json create mode 100644 parser/testdata/corpus/sql/pragma/test_metadata_info.test create mode 100644 parser/testdata/corpus/sql/pragma/test_pragma_database_list.test create mode 100644 parser/testdata/corpus/sql/pragma/test_pragma_database_size.test create mode 100644 parser/testdata/corpus/sql/pragma/test_pragma_functions.test create mode 100644 parser/testdata/corpus/sql/pragma/test_pragma_parsing.test create mode 100644 parser/testdata/corpus/sql/pragma/test_pragma_sanitized_inputs.test create mode 100644 parser/testdata/corpus/sql/pragma/test_pragma_version.test create mode 100644 parser/testdata/corpus/sql/pragma/test_query_log.test create mode 100644 parser/testdata/corpus/sql/pragma/test_show_tables.test create mode 100644 parser/testdata/corpus/sql/pragma/test_show_tables_from.test create mode 100644 parser/testdata/corpus/sql/pragma/test_show_tables_temp_views.test create mode 100644 parser/testdata/corpus/sql/pragma/test_storage_info.test create mode 100644 parser/testdata/corpus/sql/pragma/test_table_info.test create mode 100644 parser/testdata/corpus/sql/pragma/test_table_info_quoted_names.test create mode 100644 parser/testdata/corpus/sql/pragma/test_table_info_quoted_names.test.metadata.json create mode 100644 parser/testdata/corpus/sql/pragma/test_various_pragmas.test create mode 100644 parser/testdata/corpus/sql/prepared/invalid_prepare.test create mode 100644 parser/testdata/corpus/sql/prepared/parameter_order_subquery.test create mode 100644 parser/testdata/corpus/sql/prepared/parameter_variants.test create mode 100644 parser/testdata/corpus/sql/prepared/prepare_copy.test create mode 100644 parser/testdata/corpus/sql/prepared/prepare_default_varchar.test create mode 100644 parser/testdata/corpus/sql/prepared/prepare_from_first.test create mode 100644 parser/testdata/corpus/sql/prepared/prepare_in.test create mode 100644 parser/testdata/corpus/sql/prepared/prepare_lambda.test create mode 100644 parser/testdata/corpus/sql/prepared/prepare_list_functions.test create mode 100644 parser/testdata/corpus/sql/prepared/prepare_maintain_types.test create mode 100644 parser/testdata/corpus/sql/prepared/prepare_mixed_types.test create mode 100644 parser/testdata/corpus/sql/prepared/prepare_offset_first.test create mode 100644 parser/testdata/corpus/sql/prepared/prepare_summarize.test create mode 100644 parser/testdata/corpus/sql/prepared/prepare_window_functions.test create mode 100644 parser/testdata/corpus/sql/prepared/prepared_named_param.test create mode 100644 parser/testdata/corpus/sql/prepared/prepared_null_binding.test create mode 100644 parser/testdata/corpus/sql/prepared/prepared_select.test create mode 100644 parser/testdata/corpus/sql/prepared/prepared_stale_statistics.test create mode 100644 parser/testdata/corpus/sql/prepared/prepared_statistics_optimization.test create mode 100644 parser/testdata/corpus/sql/prepared/prepared_update.test create mode 100644 parser/testdata/corpus/sql/prepared/test_basic_prepare.test create mode 100644 parser/testdata/corpus/sql/prepared/test_issue_2079.test create mode 100644 parser/testdata/corpus/sql/prepared/test_issue_21077.test create mode 100644 parser/testdata/corpus/sql/prepared/test_issue_4010.test create mode 100644 parser/testdata/corpus/sql/prepared/test_issue_4042.test create mode 100644 parser/testdata/corpus/sql/prepared/test_issue_6276.test create mode 100644 parser/testdata/corpus/sql/prepared/test_prepare_ambiguous_type.test create mode 100644 parser/testdata/corpus/sql/prepared/test_prepare_delete.test create mode 100644 parser/testdata/corpus/sql/prepared/test_prepare_delete_update.test create mode 100644 parser/testdata/corpus/sql/prepared/test_prepare_drop.test create mode 100644 parser/testdata/corpus/sql/prepared/test_prepare_error.test create mode 100644 parser/testdata/corpus/sql/prepared/test_prepare_issue_5132.test create mode 100644 parser/testdata/corpus/sql/prepared/test_prepare_issue_8500.test create mode 100644 parser/testdata/corpus/sql/prepared/test_prepare_null.test create mode 100644 parser/testdata/corpus/sql/prepared/test_prepare_select.test create mode 100644 parser/testdata/corpus/sql/prepared/test_prepare_subquery.test create mode 100644 parser/testdata/corpus/sql/prepared/test_prepare_types.test create mode 100644 parser/testdata/corpus/sql/prepared/test_prepare_unused_cte.test create mode 100644 parser/testdata/corpus/sql/projection/coalesce_error.test create mode 100644 parser/testdata/corpus/sql/projection/coalesce_rowid.test create mode 100644 parser/testdata/corpus/sql/projection/select_star_exclude.test create mode 100644 parser/testdata/corpus/sql/projection/select_star_exclude.test.metadata.json create mode 100644 parser/testdata/corpus/sql/projection/select_star_like.test create mode 100644 parser/testdata/corpus/sql/projection/select_star_rename.test create mode 100644 parser/testdata/corpus/sql/projection/select_star_rename.test.metadata.json create mode 100644 parser/testdata/corpus/sql/projection/select_star_replace.test create mode 100644 parser/testdata/corpus/sql/projection/select_star_replace.test.metadata.json create mode 100644 parser/testdata/corpus/sql/projection/select_struct_star.test create mode 100644 parser/testdata/corpus/sql/projection/test_columns_replace_using.test create mode 100644 parser/testdata/corpus/sql/projection/test_complex_expressions.test create mode 100644 parser/testdata/corpus/sql/projection/test_row_id.test create mode 100644 parser/testdata/corpus/sql/projection/test_row_id_expression.test create mode 100644 parser/testdata/corpus/sql/projection/test_scalar_projection.test create mode 100644 parser/testdata/corpus/sql/projection/test_scalar_projection.test.metadata.json create mode 100644 parser/testdata/corpus/sql/projection/test_simple_projection.test create mode 100644 parser/testdata/corpus/sql/projection/test_table_star.test create mode 100644 parser/testdata/corpus/sql/projection/test_value_list.test create mode 100644 parser/testdata/corpus/sql/projection/test_value_list.test.metadata.json create mode 100644 parser/testdata/corpus/sql/returning/no_crash_when_no_returning_columns.test create mode 100644 parser/testdata/corpus/sql/returning/returning_delete.test create mode 100644 parser/testdata/corpus/sql/returning/returning_delete_list.test create mode 100644 parser/testdata/corpus/sql/returning/returning_delete_same_transaction.test create mode 100644 parser/testdata/corpus/sql/returning/returning_insert.test create mode 100644 parser/testdata/corpus/sql/returning/returning_large.test create mode 100644 parser/testdata/corpus/sql/returning/returning_update.test create mode 100644 parser/testdata/corpus/sql/sample/can_sample_from_ingested_files.test create mode 100644 parser/testdata/corpus/sql/sample/same_seed_same_sample.test create mode 100644 parser/testdata/corpus/sql/sample/table_samples/basic_sample_tests.test create mode 100644 parser/testdata/corpus/sql/sample/table_samples/table_sample_converts_to_block_sample.test create mode 100644 parser/testdata/corpus/sql/sample/table_samples/test_sample_is_destroyed_on_updates.test create mode 100644 parser/testdata/corpus/sql/sample/table_samples/test_sample_types.test create mode 100644 parser/testdata/corpus/sql/sample/table_samples/test_table_sample_errors.test create mode 100644 parser/testdata/corpus/sql/sample/test_sample_too_big.test create mode 100644 parser/testdata/corpus/sql/sample/test_sample_too_big.test.metadata.json create mode 100644 parser/testdata/corpus/sql/sample/test_system_rows.test create mode 100644 parser/testdata/corpus/sql/sample/test_system_rows_pushdown.test create mode 100644 parser/testdata/corpus/sql/secrets/create_secret_expression.test create mode 100644 parser/testdata/corpus/sql/secrets/create_secret_expression.test.metadata.json create mode 100644 parser/testdata/corpus/sql/secrets/create_secret_filesystem_logging.test create mode 100644 parser/testdata/corpus/sql/secrets/create_secret_hffs_autoload.test create mode 100644 parser/testdata/corpus/sql/secrets/create_secret_persistence_no_client_context.test create mode 100644 parser/testdata/corpus/sql/secrets/create_transaction_secret.test create mode 100644 parser/testdata/corpus/sql/secrets/drop_persistent_secret_if_exists.test create mode 100644 parser/testdata/corpus/sql/secrets/secret_autoloading_errors.test create mode 100644 parser/testdata/corpus/sql/secrets/secret_compatibility_http.test create mode 100644 parser/testdata/corpus/sql/select/test_multi_column_reference.test create mode 100644 parser/testdata/corpus/sql/select/test_positional_reference.test create mode 100644 parser/testdata/corpus/sql/select/test_positional_reference.test.metadata.json create mode 100644 parser/testdata/corpus/sql/select/test_projection_names.test create mode 100644 parser/testdata/corpus/sql/select/test_schema_reference.test create mode 100644 parser/testdata/corpus/sql/select/test_select_alias_prefix_colon.test create mode 100644 parser/testdata/corpus/sql/select/test_select_into.test create mode 100644 parser/testdata/corpus/sql/select/test_select_locking.test create mode 100644 parser/testdata/corpus/sql/select/test_select_qualified_view.test create mode 100644 parser/testdata/corpus/sql/setops/ambiguous_order_by.test create mode 100644 parser/testdata/corpus/sql/setops/setops_pushdown.test create mode 100644 parser/testdata/corpus/sql/setops/test_except.test create mode 100644 parser/testdata/corpus/sql/setops/test_full_outer_join_union.test create mode 100644 parser/testdata/corpus/sql/setops/test_nested_except.test create mode 100644 parser/testdata/corpus/sql/setops/test_pg_union.test create mode 100644 parser/testdata/corpus/sql/setops/test_setops.test create mode 100644 parser/testdata/corpus/sql/setops/test_union_all_by_name.test create mode 100644 parser/testdata/corpus/sql/setops/test_union_binding.test create mode 100644 parser/testdata/corpus/sql/setops/test_union_by_name.test create mode 100644 parser/testdata/corpus/sql/setops/test_union_error.test create mode 100644 parser/testdata/corpus/sql/setops/test_union_except_empty.test create mode 100644 parser/testdata/corpus/sql/setops/test_union_order.test create mode 100644 parser/testdata/corpus/sql/setops/test_union_subquery.test create mode 100644 parser/testdata/corpus/sql/setops/test_union_type_cast.test create mode 100644 parser/testdata/corpus/sql/setops/union_aggregate.test create mode 100644 parser/testdata/corpus/sql/setops/union_all_projection_pushdown.test create mode 100644 parser/testdata/corpus/sql/setops/union_limit.test create mode 100644 parser/testdata/corpus/sql/setops/union_pipeline.test create mode 100644 parser/testdata/corpus/sql/setops/union_shared_scan.test create mode 100644 parser/testdata/corpus/sql/setops/value_union.test create mode 100644 parser/testdata/corpus/sql/settings/access_mode.test create mode 100644 parser/testdata/corpus/sql/settings/allowed_configs.test create mode 100644 parser/testdata/corpus/sql/settings/allowed_configs_extensions.test create mode 100644 parser/testdata/corpus/sql/settings/allowed_directories.test create mode 100644 parser/testdata/corpus/sql/settings/allowed_paths.test create mode 100644 parser/testdata/corpus/sql/settings/block_allocator_memory.test create mode 100644 parser/testdata/corpus/sql/settings/connection_local_settings.test create mode 100644 parser/testdata/corpus/sql/settings/default_null_order_extended.test create mode 100644 parser/testdata/corpus/sql/settings/dialect_compatibility_mode.test create mode 100644 parser/testdata/corpus/sql/settings/drop_set_schema.test create mode 100644 parser/testdata/corpus/sql/settings/errors_as_json.test create mode 100644 parser/testdata/corpus/sql/settings/integer_division_setting.test create mode 100644 parser/testdata/corpus/sql/settings/lock_configuration_schema.test create mode 100644 parser/testdata/corpus/sql/settings/max_execution_time.test create mode 100644 parser/testdata/corpus/sql/settings/operator_memory_limit.test create mode 100644 parser/testdata/corpus/sql/settings/reset/reset_memory_limit.test create mode 100644 parser/testdata/corpus/sql/settings/reset/reset_threads.test create mode 100644 parser/testdata/corpus/sql/settings/set_schema_temp_main.test create mode 100644 parser/testdata/corpus/sql/settings/setting_alias.test create mode 100644 parser/testdata/corpus/sql/settings/setting_collation.test create mode 100644 parser/testdata/corpus/sql/settings/setting_disabled_optimizer.test create mode 100644 parser/testdata/corpus/sql/settings/setting_disabled_optimizer.test.metadata.json create mode 100644 parser/testdata/corpus/sql/settings/setting_exhaustive.test create mode 100644 parser/testdata/corpus/sql/settings/setting_null_order.test create mode 100644 parser/testdata/corpus/sql/settings/setting_order.test create mode 100644 parser/testdata/corpus/sql/settings/setting_preserve_identifier_case.test create mode 100644 parser/testdata/corpus/sql/settings/setting_profiling_mode.test create mode 100644 parser/testdata/corpus/sql/settings/setting_profiling_mode.test.metadata.json create mode 100644 parser/testdata/corpus/sql/settings/setting_threads.test create mode 100644 parser/testdata/corpus/sql/settings/settings_icu.test create mode 100644 parser/testdata/corpus/sql/settings/test_disabled_file_systems.test create mode 100644 parser/testdata/corpus/sql/settings/test_disabled_local_filesystem_metadata.test create mode 100644 parser/testdata/corpus/sql/settings/test_disabled_local_filesystem_secrets.test create mode 100644 parser/testdata/corpus/sql/settings/test_external_access_secrets.test create mode 100644 parser/testdata/corpus/sql/settings/test_lock_configuration.test create mode 100644 parser/testdata/corpus/sql/settings/user_agent.test create mode 100644 parser/testdata/corpus/sql/show_select/describe_rowid.test create mode 100644 parser/testdata/corpus/sql/show_select/describe_subquery.test create mode 100644 parser/testdata/corpus/sql/show_select/show_quote_identifier.test create mode 100644 parser/testdata/corpus/sql/show_select/show_select_constraints.test create mode 100644 parser/testdata/corpus/sql/show_select/summarize_subquery.test create mode 100644 parser/testdata/corpus/sql/show_select/test_describe_all.test create mode 100644 parser/testdata/corpus/sql/show_select/test_describe_quoted.test create mode 100644 parser/testdata/corpus/sql/show_select/test_show_select.test create mode 100644 parser/testdata/corpus/sql/show_select/test_summarize.test create mode 100644 parser/testdata/corpus/sql/show_select/test_summarize_quoted.test create mode 100644 parser/testdata/corpus/sql/storage/adaptive_segment_allocation.test create mode 100644 parser/testdata/corpus/sql/storage/alter/alter_add_col_defaultexpr_sequence.test create mode 100644 parser/testdata/corpus/sql/storage/alter/alter_based_on_unfinished_insert_fails.test create mode 100644 parser/testdata/corpus/sql/storage/alter/alter_column_constraint.test create mode 100644 parser/testdata/corpus/sql/storage/alter/alter_lazy_metadata_load.test create mode 100644 parser/testdata/corpus/sql/storage/append_strings_to_persistent.test create mode 100644 parser/testdata/corpus/sql/storage/attach/attach_autocheckpoint_in_memory.test create mode 100644 parser/testdata/corpus/sql/storage/attach/attach_autocheckpoint_no_wal_writes.test create mode 100644 parser/testdata/corpus/sql/storage/attach/attach_autocheckpoint_propagation.test create mode 100644 parser/testdata/corpus/sql/storage/attach/attach_invalidation.test create mode 100644 parser/testdata/corpus/sql/storage/attach/attach_invalidation_default_db.test create mode 100644 parser/testdata/corpus/sql/storage/attach/attach_invalidation_sibling_commit.test create mode 100644 parser/testdata/corpus/sql/storage/attach/attach_invalidation_sibling_rollback.test create mode 100644 parser/testdata/corpus/sql/storage/attach_mmap.test create mode 100644 parser/testdata/corpus/sql/storage/attach_mmap.test.metadata.json create mode 100644 parser/testdata/corpus/sql/storage/bc/internal_schemas_0102.test create mode 100644 parser/testdata/corpus/sql/storage/bc/test_broken_view_v092.test create mode 100644 parser/testdata/corpus/sql/storage/bc/test_view_v092.test create mode 100644 parser/testdata/corpus/sql/storage/buffer_manager_temp_dir.test create mode 100644 parser/testdata/corpus/sql/storage/catalog/generated_columns/virtual/basic.test create mode 100644 parser/testdata/corpus/sql/storage/catalog/generated_columns/virtual/constraints.test create mode 100644 parser/testdata/corpus/sql/storage/catalog/test_check_constraint.test create mode 100644 parser/testdata/corpus/sql/storage/catalog/test_drop_table.test create mode 100644 parser/testdata/corpus/sql/storage/catalog/test_macro_storage.test create mode 100644 parser/testdata/corpus/sql/storage/catalog/test_not_distinct_from_default.test create mode 100644 parser/testdata/corpus/sql/storage/catalog/test_not_null_constraint.test create mode 100644 parser/testdata/corpus/sql/storage/catalog/test_prepared_storage.test create mode 100644 parser/testdata/corpus/sql/storage/catalog/test_store_add_column.test create mode 100644 parser/testdata/corpus/sql/storage/catalog/test_store_alter_type.test create mode 100644 parser/testdata/corpus/sql/storage/catalog/test_store_default_sequence.test create mode 100644 parser/testdata/corpus/sql/storage/catalog/test_store_defaults.test create mode 100644 parser/testdata/corpus/sql/storage/catalog/test_store_remove_column.test create mode 100644 parser/testdata/corpus/sql/storage/catalog/test_store_rename_column.test create mode 100644 parser/testdata/corpus/sql/storage/catalog/test_store_rename_table.test create mode 100644 parser/testdata/corpus/sql/storage/catalog/test_store_rename_view.test create mode 100644 parser/testdata/corpus/sql/storage/catalog/test_store_sequences.test create mode 100644 parser/testdata/corpus/sql/storage/catalog/test_store_temporary.test create mode 100644 parser/testdata/corpus/sql/storage/catalog/test_table_macro_storage.test create mode 100644 parser/testdata/corpus/sql/storage/catalog/test_view_explicit_aliases.test create mode 100644 parser/testdata/corpus/sql/storage/catalog/test_view_storage.test create mode 100644 parser/testdata/corpus/sql/storage/checkpoint/checkpoint_in_transaction.test create mode 100644 parser/testdata/corpus/sql/storage/checkpoint/checkpoint_with_outstanding_insertions.test create mode 100644 parser/testdata/corpus/sql/storage/checkpoint/indexed_table_delete_insert_fragmentation.test create mode 100644 parser/testdata/corpus/sql/storage/checkpoint/initial_database_autocheckpoint_failure.test create mode 100644 parser/testdata/corpus/sql/storage/checkpoint/test_checkpoint_failure_delayed_commit.test create mode 100644 parser/testdata/corpus/sql/storage/checkpoint/test_checkpoint_failure_on_detach.test create mode 100644 parser/testdata/corpus/sql/storage/checkpointed_self_append.test create mode 100644 parser/testdata/corpus/sql/storage/checkpointed_self_append_tinyint.test create mode 100644 parser/testdata/corpus/sql/storage/commit_abort.test create mode 100644 parser/testdata/corpus/sql/storage/commit_abort_medium.test create mode 100644 parser/testdata/corpus/sql/storage/commit_index_deletes.test create mode 100644 parser/testdata/corpus/sql/storage/compact_block_size/block_size_with_rollback.test create mode 100644 parser/testdata/corpus/sql/storage/compact_block_size/compact_block_size.test create mode 100644 parser/testdata/corpus/sql/storage/compact_block_size/compact_vector_size.test create mode 100644 parser/testdata/corpus/sql/storage/compact_block_size/create_table_compression.test create mode 100644 parser/testdata/corpus/sql/storage/compact_block_size/default_block_size.test create mode 100644 parser/testdata/corpus/sql/storage/compact_block_size/ensure_bitpacking.test create mode 100644 parser/testdata/corpus/sql/storage/compact_block_size/ensure_no_bitpacking.test create mode 100644 parser/testdata/corpus/sql/storage/compact_block_size/insertion_order_odd_batches.test create mode 100644 parser/testdata/corpus/sql/storage/compact_block_size/mixed_block_sizes.test create mode 100644 parser/testdata/corpus/sql/storage/compression/alp/alp_corrupted_exception_position.test create mode 100644 parser/testdata/corpus/sql/storage/compression/alp/alp_corrupted_file.test create mode 100644 parser/testdata/corpus/sql/storage/compression/alp/alp_corrupted_offsets.test create mode 100644 parser/testdata/corpus/sql/storage/compression/alp/alp_corrupted_vector_size.test create mode 100644 parser/testdata/corpus/sql/storage/compression/alp/alp_inf_null_nan.test create mode 100644 parser/testdata/corpus/sql/storage/compression/alp/alp_list_skip.test create mode 100644 parser/testdata/corpus/sql/storage/compression/alp/alp_min_max.test create mode 100644 parser/testdata/corpus/sql/storage/compression/alp/alp_negative_numbers.test create mode 100644 parser/testdata/corpus/sql/storage/compression/alp/alp_nulls.test create mode 100644 parser/testdata/corpus/sql/storage/compression/alp/alp_out_of_range.test create mode 100644 parser/testdata/corpus/sql/storage/compression/alp/alp_simple.test create mode 100644 parser/testdata/corpus/sql/storage/compression/alp/alp_simple_float.test create mode 100644 parser/testdata/corpus/sql/storage/compression/alp/alp_storage_version.test create mode 100644 parser/testdata/corpus/sql/storage/compression/alp/alp_zeros.test create mode 100644 parser/testdata/corpus/sql/storage/compression/alprd/alprd_corrupted_dict_size.test create mode 100644 parser/testdata/corpus/sql/storage/compression/alprd/alprd_corrupted_exception_position.test create mode 100644 parser/testdata/corpus/sql/storage/compression/alprd/alprd_inf_null_nan.test create mode 100644 parser/testdata/corpus/sql/storage/compression/alprd/alprd_min_max.test create mode 100644 parser/testdata/corpus/sql/storage/compression/alprd/alprd_negative_numbers.test create mode 100644 parser/testdata/corpus/sql/storage/compression/alprd/alprd_nulls.test create mode 100644 parser/testdata/corpus/sql/storage/compression/alprd/alprd_simple.test create mode 100644 parser/testdata/corpus/sql/storage/compression/alprd/alprd_simple_float.test create mode 100644 parser/testdata/corpus/sql/storage/compression/alprd/alprd_storage_version.test create mode 100644 parser/testdata/corpus/sql/storage/compression/bitpacking/bitpacking_constant_delta.test create mode 100644 parser/testdata/corpus/sql/storage/compression/bitpacking/bitpacking_delta_for.test create mode 100644 parser/testdata/corpus/sql/storage/compression/bitpacking/bitpacking_filter_pushdown.test create mode 100644 parser/testdata/corpus/sql/storage/compression/bitpacking/bitpacking_hugeint.test create mode 100644 parser/testdata/corpus/sql/storage/compression/bitpacking/bitpacking_mode.test create mode 100644 parser/testdata/corpus/sql/storage/compression/bitpacking/bitpacking_nulls.test create mode 100644 parser/testdata/corpus/sql/storage/compression/bitpacking/bitpacking_simple.test create mode 100644 parser/testdata/corpus/sql/storage/compression/bitpacking/bitpacking_simple_hugeint.test create mode 100644 parser/testdata/corpus/sql/storage/compression/bitpacking/bitpacking_size_calculation.test create mode 100644 parser/testdata/corpus/sql/storage/compression/bitpacking/bitpacking_storage_info.test create mode 100644 parser/testdata/corpus/sql/storage/compression/bitpacking/bitpacking_table_copy.test create mode 100644 parser/testdata/corpus/sql/storage/compression/bitpacking/bitpacking_uhugeint.test create mode 100644 parser/testdata/corpus/sql/storage/compression/bitpacking/force_bitpacking.test create mode 100644 parser/testdata/corpus/sql/storage/compression/bitpacking/struct_bitpacking.test create mode 100644 parser/testdata/corpus/sql/storage/compression/compression_selection.test create mode 100644 parser/testdata/corpus/sql/storage/compression/default_storage_dict_fsst.test create mode 100644 parser/testdata/corpus/sql/storage/compression/dict_fsst/dict_fsst_expression_filter.test create mode 100644 parser/testdata/corpus/sql/storage/compression/dict_fsst/dict_fsst_test.test create mode 100644 parser/testdata/corpus/sql/storage/compression/dict_fsst/dictionary_covers_validity.test create mode 100644 parser/testdata/corpus/sql/storage/compression/dict_fsst/dictionary_storage_info.test create mode 100644 parser/testdata/corpus/sql/storage/compression/dict_fsst/fetch_row.test create mode 100644 parser/testdata/corpus/sql/storage/compression/dict_fsst/force_dictionary.test create mode 100644 parser/testdata/corpus/sql/storage/compression/dict_fsst/invalid_symbol_table.test create mode 100644 parser/testdata/corpus/sql/storage/compression/dict_fsst/issue_5675.test create mode 100644 parser/testdata/corpus/sql/storage/compression/dict_fsst/issue_5675_followup.test create mode 100644 parser/testdata/corpus/sql/storage/compression/dict_fsst/issue_5759.test create mode 100644 parser/testdata/corpus/sql/storage/compression/dict_fsst/repeated_string_stats.test create mode 100644 parser/testdata/corpus/sql/storage/compression/dict_fsst/test_dict_fsst_with_smaller_block_size.test create mode 100644 parser/testdata/corpus/sql/storage/compression/dict_fsst/test_null_filter_pushdown.test create mode 100644 parser/testdata/corpus/sql/storage/compression/dict_fsst/test_null_update.test create mode 100644 parser/testdata/corpus/sql/storage/compression/dictionary/dict_corrupted_offset.test create mode 100644 parser/testdata/corpus/sql/storage/compression/dictionary/dictionary_storage_info.test create mode 100644 parser/testdata/corpus/sql/storage/compression/dictionary/fetch_row.test create mode 100644 parser/testdata/corpus/sql/storage/compression/dictionary/invalid_dictionary_metadata.test create mode 100644 parser/testdata/corpus/sql/storage/compression/dictionary/total_string_length_dictionary.test create mode 100644 parser/testdata/corpus/sql/storage/compression/fsst/fsst_disable_compression.test create mode 100644 parser/testdata/corpus/sql/storage/compression/fsst/fsst_greedy_long_strings.test create mode 100644 parser/testdata/corpus/sql/storage/compression/fsst/fsst_small_symbol_table.test create mode 100644 parser/testdata/corpus/sql/storage/compression/fsst/fsst_storage_info.test create mode 100644 parser/testdata/corpus/sql/storage/compression/fsst/invalid_fsst_bitpacking_width.test create mode 100644 parser/testdata/corpus/sql/storage/compression/fsst/issue_5675.test create mode 100644 parser/testdata/corpus/sql/storage/compression/fsst/issue_5759.test create mode 100644 parser/testdata/corpus/sql/storage/compression/patas/patas_corrupted_file.test create mode 100644 parser/testdata/corpus/sql/storage/compression/rle/force_rle.test create mode 100644 parser/testdata/corpus/sql/storage/compression/rle/rle_bool.test create mode 100644 parser/testdata/corpus/sql/storage/compression/rle/rle_constant.test create mode 100644 parser/testdata/corpus/sql/storage/compression/rle/rle_corrupted_count_offset.test create mode 100644 parser/testdata/corpus/sql/storage/compression/rle/rle_filter.test create mode 100644 parser/testdata/corpus/sql/storage/compression/rle/rle_filter_pushdown.test create mode 100644 parser/testdata/corpus/sql/storage/compression/rle/rle_index_fetch.test create mode 100644 parser/testdata/corpus/sql/storage/compression/rle/rle_medium.test create mode 100644 parser/testdata/corpus/sql/storage/compression/rle/rle_nulls_edge_case.test create mode 100644 parser/testdata/corpus/sql/storage/compression/rle/rle_select.test create mode 100644 parser/testdata/corpus/sql/storage/compression/rle/rle_select_list.test create mode 100644 parser/testdata/corpus/sql/storage/compression/rle/struct_rle.test create mode 100644 parser/testdata/corpus/sql/storage/compression/roaring/roaring_analyze_array.test create mode 100644 parser/testdata/corpus/sql/storage/compression/roaring/roaring_analyze_bitset.test create mode 100644 parser/testdata/corpus/sql/storage/compression/roaring/roaring_analyze_run.test create mode 100644 parser/testdata/corpus/sql/storage/compression/roaring/roaring_array_simple.test create mode 100644 parser/testdata/corpus/sql/storage/compression/roaring/roaring_bitset_simple.test create mode 100644 parser/testdata/corpus/sql/storage/compression/roaring/roaring_bool_analyze_array.test create mode 100644 parser/testdata/corpus/sql/storage/compression/roaring/roaring_bool_analyze_bitset.test create mode 100644 parser/testdata/corpus/sql/storage/compression/roaring/roaring_bool_analyze_run.test create mode 100644 parser/testdata/corpus/sql/storage/compression/roaring/roaring_bool_array_simple.test create mode 100644 parser/testdata/corpus/sql/storage/compression/roaring/roaring_bool_array_simple_w_null.test create mode 100644 parser/testdata/corpus/sql/storage/compression/roaring/roaring_bool_bitset_simple.test create mode 100644 parser/testdata/corpus/sql/storage/compression/roaring/roaring_bool_bitset_simple_w_null.test create mode 100644 parser/testdata/corpus/sql/storage/compression/roaring/roaring_bool_fetch_row.test create mode 100644 parser/testdata/corpus/sql/storage/compression/roaring/roaring_bool_first_is_null.test create mode 100644 parser/testdata/corpus/sql/storage/compression/roaring/roaring_bool_inverted_array_simple.test create mode 100644 parser/testdata/corpus/sql/storage/compression/roaring/roaring_bool_inverted_run_simple.test create mode 100644 parser/testdata/corpus/sql/storage/compression/roaring/roaring_bool_run_simple.test create mode 100644 parser/testdata/corpus/sql/storage/compression/roaring/roaring_bool_run_simple_w_null.test create mode 100644 parser/testdata/corpus/sql/storage/compression/roaring/roaring_bool_smaller_than_vector.test create mode 100644 parser/testdata/corpus/sql/storage/compression/roaring/roaring_bool_uncompressed_under_v1_5_0.test create mode 100644 parser/testdata/corpus/sql/storage/compression/roaring/roaring_corrupted_file.test create mode 100644 parser/testdata/corpus/sql/storage/compression/roaring/roaring_fetch_row.test create mode 100644 parser/testdata/corpus/sql/storage/compression/roaring/roaring_inverted_array_simple.test create mode 100644 parser/testdata/corpus/sql/storage/compression/roaring/roaring_inverted_run_simple.test create mode 100644 parser/testdata/corpus/sql/storage/compression/roaring/roaring_run_simple.test create mode 100644 parser/testdata/corpus/sql/storage/compression/roaring/roaring_smaller_than_vector.test create mode 100644 parser/testdata/corpus/sql/storage/compression/simple_compression.test create mode 100644 parser/testdata/corpus/sql/storage/compression/skip_explicit_compression_analyze.test create mode 100644 parser/testdata/corpus/sql/storage/compression/string/big_strings.test create mode 100644 parser/testdata/corpus/sql/storage/compression/string/blob.test create mode 100644 parser/testdata/corpus/sql/storage/compression/string/empty.test create mode 100644 parser/testdata/corpus/sql/storage/compression/string/filter_pushdown.test create mode 100644 parser/testdata/corpus/sql/storage/compression/string/index_fetch.test create mode 100644 parser/testdata/corpus/sql/storage/compression/string/medium.test create mode 100644 parser/testdata/corpus/sql/storage/compression/string/simple.test create mode 100644 parser/testdata/corpus/sql/storage/compression/string/struct.test create mode 100644 parser/testdata/corpus/sql/storage/compression/string/table_copy.test create mode 100644 parser/testdata/corpus/sql/storage/compression/test_using_compression.test create mode 100644 parser/testdata/corpus/sql/storage/compression/zstd/fetch_row.test create mode 100644 parser/testdata/corpus/sql/storage/compression/zstd/nulls.test create mode 100644 parser/testdata/corpus/sql/storage/compression/zstd/test_skipping.test create mode 100644 parser/testdata/corpus/sql/storage/compression/zstd/zstd.test create mode 100644 parser/testdata/corpus/sql/storage/compression/zstd/zstd_force_compression.test create mode 100644 parser/testdata/corpus/sql/storage/concurrent_attach_if_not_exists_create.test create mode 100644 parser/testdata/corpus/sql/storage/constraints/foreignkey/foreign_key_persistent.test create mode 100644 parser/testdata/corpus/sql/storage/constraints/foreignkey/foreign_key_persistent_memory_limit.test create mode 100644 parser/testdata/corpus/sql/storage/corrupt/corrupt_catalog_entry.test create mode 100644 parser/testdata/corpus/sql/storage/corrupt/corrupt_encoding_overflow.test create mode 100644 parser/testdata/corpus/sql/storage/delete/load_delete_modify.test create mode 100644 parser/testdata/corpus/sql/storage/delete/repeated_deletes.test create mode 100644 parser/testdata/corpus/sql/storage/delete/test_store_deletes.test create mode 100644 parser/testdata/corpus/sql/storage/delete/test_unchanged_deletes.test create mode 100644 parser/testdata/corpus/sql/storage/delete/test_unchanged_deletes_large.test create mode 100644 parser/testdata/corpus/sql/storage/distinct_statistics_storage.test create mode 100644 parser/testdata/corpus/sql/storage/encryption/temp_files/encrypted_tmp_file_setting.test create mode 100644 parser/testdata/corpus/sql/storage/encryption/temp_files/temp_directory_enable_external_access.test create mode 100644 parser/testdata/corpus/sql/storage/encryption/wal/encrypted_wal_blob_storage.test create mode 100644 parser/testdata/corpus/sql/storage/encryption/wal/encrypted_wal_lazy_creation.test create mode 100644 parser/testdata/corpus/sql/storage/encryption/wal/encrypted_wal_pragmas.test create mode 100644 parser/testdata/corpus/sql/storage/extended_string_stats.test create mode 100644 parser/testdata/corpus/sql/storage/extensions/extension_default.test create mode 100644 parser/testdata/corpus/sql/storage/extensions/extension_views.test create mode 100644 parser/testdata/corpus/sql/storage/external_file_cache/external_file_cache_async_toggle.test create mode 100644 parser/testdata/corpus/sql/storage/external_file_cache/external_file_cache_block_size.test create mode 100644 parser/testdata/corpus/sql/storage/external_file_cache/external_file_cache_validate.test create mode 100644 parser/testdata/corpus/sql/storage/filter_pushdown_struct.test create mode 100644 parser/testdata/corpus/sql/storage/full_vector_delete_checkpoint.test create mode 100644 parser/testdata/corpus/sql/storage/issue3789_node_segment_tree.test create mode 100644 parser/testdata/corpus/sql/storage/issue7582_list_storage.test create mode 100644 parser/testdata/corpus/sql/storage/lazy_load/lazy_load_limit.test create mode 100644 parser/testdata/corpus/sql/storage/many_checkpoints.test create mode 100644 parser/testdata/corpus/sql/storage/many_self_append.test create mode 100644 parser/testdata/corpus/sql/storage/memory/in_memory_disabled_zstd.test create mode 100644 parser/testdata/corpus/sql/storage/metadata/full_table_metadata_reuse.test create mode 100644 parser/testdata/corpus/sql/storage/metadata/full_table_metadata_reuse_v7.test create mode 100644 parser/testdata/corpus/sql/storage/metadata/multi_table_metadata_reuse.test create mode 100644 parser/testdata/corpus/sql/storage/metadata/partial_column_metadata_reuse.test create mode 100644 parser/testdata/corpus/sql/storage/metadata/partial_column_metadata_reuse_drop_column.test create mode 100644 parser/testdata/corpus/sql/storage/metadata/partial_column_metadata_reuse_small_block.test create mode 100644 parser/testdata/corpus/sql/storage/metadata/partial_column_metadata_reuse_v7.test create mode 100644 parser/testdata/corpus/sql/storage/metadata/partial_table_metadata_reuse.test create mode 100644 parser/testdata/corpus/sql/storage/mix/test_update_delete_string.test create mode 100644 parser/testdata/corpus/sql/storage/mix/updates_deletes_big_table.test create mode 100644 parser/testdata/corpus/sql/storage/mix/updates_deletes_persistent_segments.test create mode 100644 parser/testdata/corpus/sql/storage/multiple_clients_checkpoint_pending_updates.test create mode 100644 parser/testdata/corpus/sql/storage/nested/struct_of_lists_unaligned.test create mode 100644 parser/testdata/corpus/sql/storage/null_byte_storage.test create mode 100644 parser/testdata/corpus/sql/storage/optimistic_write/optimistic_write_delete.test create mode 100644 parser/testdata/corpus/sql/storage/optimistic_write/optimistic_write_large_strings.test create mode 100644 parser/testdata/corpus/sql/storage/optimistic_write/optimistic_write_not_trigger_checkpoint.test create mode 100644 parser/testdata/corpus/sql/storage/optimistic_write/optimistic_write_temp_table.test create mode 100644 parser/testdata/corpus/sql/storage/optimistic_write/optimistic_write_update.test create mode 100644 parser/testdata/corpus/sql/storage/partial_blocks/many_columns_drop_table.test create mode 100644 parser/testdata/corpus/sql/storage/partial_blocks/many_columns_rle.test create mode 100644 parser/testdata/corpus/sql/storage/partial_blocks/many_columns_storage.test create mode 100644 parser/testdata/corpus/sql/storage/partial_blocks/many_columns_strings.test create mode 100644 parser/testdata/corpus/sql/storage/partial_blocks/many_columns_validity.test create mode 100644 parser/testdata/corpus/sql/storage/partial_delete_checkpoint_mask.test create mode 100644 parser/testdata/corpus/sql/storage/partial_delete_pending_compress.test create mode 100644 parser/testdata/corpus/sql/storage/piecemeal_delete_checkpoint_compress.test create mode 100644 parser/testdata/corpus/sql/storage/pragma_storage_info_scan_type.test create mode 100644 parser/testdata/corpus/sql/storage/prefetch/async_native_scan_pool.test create mode 100644 parser/testdata/corpus/sql/storage/prefetch/async_native_scan_positional.test create mode 100644 parser/testdata/corpus/sql/storage/read_duckdb/read_duckdb_basic.test create mode 100644 parser/testdata/corpus/sql/storage/read_duckdb/read_duckdb_generated.test create mode 100644 parser/testdata/corpus/sql/storage/read_duckdb/read_duckdb_index.test create mode 100644 parser/testdata/corpus/sql/storage/read_duckdb/read_duckdb_schema.test create mode 100644 parser/testdata/corpus/sql/storage/read_duckdb/read_duckdb_suggested.test create mode 100644 parser/testdata/corpus/sql/storage/read_duckdb/read_duckdb_top_n.test create mode 100644 parser/testdata/corpus/sql/storage/read_duckdb/read_duckdb_transaction.test create mode 100644 parser/testdata/corpus/sql/storage/read_duckdb/read_duckdb_union_by_name.test create mode 100644 parser/testdata/corpus/sql/storage/read_duckdb/read_duckdb_virtual_columns.test create mode 100644 parser/testdata/corpus/sql/storage/reclaim_space/test_reclaim_space_update_large_string.test create mode 100644 parser/testdata/corpus/sql/storage/row_group_fetch_bulk.test create mode 100644 parser/testdata/corpus/sql/storage/rowid_gaps/alter_preserves_rowid_gaps.test create mode 100644 parser/testdata/corpus/sql/storage/rowid_gaps/append_after_gap_checkpoint.test create mode 100644 parser/testdata/corpus/sql/storage/rowid_gaps/bulk_append_after_gap_checkpoint.test create mode 100644 parser/testdata/corpus/sql/storage/rowid_gaps/indexed_checkpoint_drop_row_group.test create mode 100644 parser/testdata/corpus/sql/storage/rowid_gaps/indexed_dense_vacuum_merge.test create mode 100644 parser/testdata/corpus/sql/storage/rowid_gaps/indexed_geometry_legacy_no_remap.test create mode 100644 parser/testdata/corpus/sql/storage/rowid_gaps/indexed_geometry_vacuum_remap.test create mode 100644 parser/testdata/corpus/sql/storage/rowid_gaps/indexed_incremental_vacuum_remap.test create mode 100644 parser/testdata/corpus/sql/storage/rowid_gaps/indexed_live_vacuum_no_rebuild.test create mode 100644 parser/testdata/corpus/sql/storage/rowid_gaps/indexed_live_vacuum_no_rebuild.test.metadata.json create mode 100644 parser/testdata/corpus/sql/storage/rowid_gaps/indexed_old_storage_keeps_deleted_row_group.test create mode 100644 parser/testdata/corpus/sql/storage/rowid_gaps/indexed_rebuild_fallback_then_remap.test create mode 100644 parser/testdata/corpus/sql/storage/rowid_gaps/indexed_remap_duplicate_key_across_tasks.test create mode 100644 parser/testdata/corpus/sql/storage/rowid_gaps/indexed_remap_merges_across_gap.test create mode 100644 parser/testdata/corpus/sql/storage/rowid_gaps/indexed_remap_partial_chunk.test create mode 100644 parser/testdata/corpus/sql/storage/rowid_gaps/indexed_remap_same_key_rowid_collision.test create mode 100644 parser/testdata/corpus/sql/storage/rowid_gaps/indexes_geometry_legacy_no_merge_across_gap.test create mode 100644 parser/testdata/corpus/sql/storage/rowid_gaps/leading_gap_lookup.test create mode 100644 parser/testdata/corpus/sql/storage/rowid_gaps/old_storage_dense_rewrite.test create mode 100644 parser/testdata/corpus/sql/storage/rowid_gaps/wal_replay_after_gap_checkpoint.test create mode 100644 parser/testdata/corpus/sql/storage/shutdown_create_index.test create mode 100644 parser/testdata/corpus/sql/storage/shutdown_running_transaction.test create mode 100644 parser/testdata/corpus/sql/storage/shutdown_unique_index.test create mode 100644 parser/testdata/corpus/sql/storage/storage_exceeds_block_large_string.test create mode 100644 parser/testdata/corpus/sql/storage/storage_exceeds_single_block.test create mode 100644 parser/testdata/corpus/sql/storage/storage_exceeds_single_block_strings.test create mode 100644 parser/testdata/corpus/sql/storage/storage_exceeds_single_block_types.test create mode 100644 parser/testdata/corpus/sql/storage/storage_types.test create mode 100644 parser/testdata/corpus/sql/storage/storage_version_65.test create mode 100644 parser/testdata/corpus/sql/storage/storage_versions.test create mode 100644 parser/testdata/corpus/sql/storage/store_group_order_all.test create mode 100644 parser/testdata/corpus/sql/storage/temp_directory/max_swap_space_error.test create mode 100644 parser/testdata/corpus/sql/storage/temp_directory/max_swap_space_explicit.test create mode 100644 parser/testdata/corpus/sql/storage/temp_directory/max_swap_space_inmemory.test create mode 100644 parser/testdata/corpus/sql/storage/temp_directory/max_swap_space_persistent.test create mode 100644 parser/testdata/corpus/sql/storage/temp_directory/max_swap_space_unlimited.test create mode 100644 parser/testdata/corpus/sql/storage/temp_directory/temp_directory_null.test create mode 100644 parser/testdata/corpus/sql/storage/temp_directory/test_default_temp_directory.test create mode 100644 parser/testdata/corpus/sql/storage/test_empty_table.test create mode 100644 parser/testdata/corpus/sql/storage/test_eviction_queue_dead_nodes_underflow.test create mode 100644 parser/testdata/corpus/sql/storage/test_ignore_duplicate_deletes_unique_index.test create mode 100644 parser/testdata/corpus/sql/storage/test_index_checkpoint.test create mode 100644 parser/testdata/corpus/sql/storage/test_large_commits.test create mode 100644 parser/testdata/corpus/sql/storage/test_read_only_wal_replay.test create mode 100644 parser/testdata/corpus/sql/storage/test_restart_extension.test create mode 100644 parser/testdata/corpus/sql/storage/test_show_tables_persistent.test create mode 100644 parser/testdata/corpus/sql/storage/test_storage_scan.test create mode 100644 parser/testdata/corpus/sql/storage/test_store_integers.test create mode 100644 parser/testdata/corpus/sql/storage/test_store_nulls_strings.test create mode 100644 parser/testdata/corpus/sql/storage/test_truncate_persistent.test create mode 100644 parser/testdata/corpus/sql/storage/test_unaligned_scan.test create mode 100644 parser/testdata/corpus/sql/storage/test_unique_index_checkpoint.test create mode 100644 parser/testdata/corpus/sql/storage/total_string_length_nested_types.test create mode 100644 parser/testdata/corpus/sql/storage/total_string_length_repeated_insert.test create mode 100644 parser/testdata/corpus/sql/storage/types/list/default_list.test create mode 100644 parser/testdata/corpus/sql/storage/types/list/empty_float_arrays.test create mode 100644 parser/testdata/corpus/sql/storage/types/list/list_index_compression.test create mode 100644 parser/testdata/corpus/sql/storage/types/list/persistent_list_storage.test create mode 100644 parser/testdata/corpus/sql/storage/types/list/store_list_of_struct.test create mode 100644 parser/testdata/corpus/sql/storage/types/map/map_storage.test create mode 100644 parser/testdata/corpus/sql/storage/types/struct/default_struct.test create mode 100644 parser/testdata/corpus/sql/storage/types/struct/nested_struct_storage.test create mode 100644 parser/testdata/corpus/sql/storage/types/struct/pushdown_extract_validity.test create mode 100644 parser/testdata/corpus/sql/storage/types/struct/struct_of_empty_list.test create mode 100644 parser/testdata/corpus/sql/storage/types/struct/struct_storage.test create mode 100644 parser/testdata/corpus/sql/storage/types/test_bit_storage.test create mode 100644 parser/testdata/corpus/sql/storage/types/test_blob_storage.test create mode 100644 parser/testdata/corpus/sql/storage/types/test_hugeint_storage.test create mode 100644 parser/testdata/corpus/sql/storage/types/test_interval_storage.test create mode 100644 parser/testdata/corpus/sql/storage/types/test_timestamp_storage.test create mode 100644 parser/testdata/corpus/sql/storage/types/test_uhugeint_storage.test create mode 100644 parser/testdata/corpus/sql/storage/types/test_unsigned_storage.test create mode 100644 parser/testdata/corpus/sql/storage/types/test_uuid.storage.test create mode 100644 parser/testdata/corpus/sql/storage/types/variant/append_shredded.test create mode 100644 parser/testdata/corpus/sql/storage/types/variant/extension_types.test create mode 100644 parser/testdata/corpus/sql/storage/types/variant/index_fetch.test create mode 100644 parser/testdata/corpus/sql/storage/types/variant/struct_of_variant.test create mode 100644 parser/testdata/corpus/sql/storage/types/variant/test_all_types.test create mode 100644 parser/testdata/corpus/sql/storage/types/variant/test_all_types_single_object.test create mode 100644 parser/testdata/corpus/sql/storage/types/variant/test_all_types_single_table.test create mode 100644 parser/testdata/corpus/sql/storage/types/variant/test_all_types_variant.test create mode 100644 parser/testdata/corpus/sql/storage/types/variant/update.test create mode 100644 parser/testdata/corpus/sql/storage/types/variant/variant_case_sensitive_fields_shredded.test create mode 100644 parser/testdata/corpus/sql/storage/types/variant/variant_comparator_shredded.test create mode 100644 parser/testdata/corpus/sql/storage/types/variant/variant_comparator_stats.test create mode 100644 parser/testdata/corpus/sql/storage/types/variant/variant_duplicate_keys_shredding.test create mode 100644 parser/testdata/corpus/sql/storage/types/variant/variant_extract_filter_pushdown.test create mode 100644 parser/testdata/corpus/sql/storage/types/variant/variant_extract_stats.test create mode 100644 parser/testdata/corpus/sql/storage/types/variant/variant_index.test create mode 100644 parser/testdata/corpus/sql/storage/types/variant/variant_null_missing.test create mode 100644 parser/testdata/corpus/sql/storage/types/variant/variant_null_shredding_inconsistency_issue.test create mode 100644 parser/testdata/corpus/sql/storage/types/variant/variant_shredded_extract_non_object.test create mode 100644 parser/testdata/corpus/sql/storage/types/variant/variant_shredded_slice.test create mode 100644 parser/testdata/corpus/sql/storage/types/variant/variant_shredding_empty_keys.test create mode 100644 parser/testdata/corpus/sql/storage/types/variant/variant_shredding_inconsistent.test create mode 100644 parser/testdata/corpus/sql/storage/types/variant/variant_shredding_omit_untyped.test create mode 100644 parser/testdata/corpus/sql/storage/types/variant/variant_shredding_small.test create mode 100644 parser/testdata/corpus/sql/storage/types/variant/variant_storage_version.test create mode 100644 parser/testdata/corpus/sql/storage/unzip.test create mode 100644 parser/testdata/corpus/sql/storage/update/dictionary_update_null.test create mode 100644 parser/testdata/corpus/sql/storage/update/test_store_null_updates.test create mode 100644 parser/testdata/corpus/sql/storage/update/wal_restart_update_insert.test create mode 100644 parser/testdata/corpus/sql/storage/wal/wal_autocheckpoint_entries.test create mode 100644 parser/testdata/corpus/sql/storage/wal/wal_create_index.test create mode 100644 parser/testdata/corpus/sql/storage/wal/wal_create_insert_drop.test create mode 100644 parser/testdata/corpus/sql/storage/wal/wal_index_delete.test create mode 100644 parser/testdata/corpus/sql/storage/wal/wal_index_delete_gen.test create mode 100644 parser/testdata/corpus/sql/storage/wal/wal_index_interleaved.test create mode 100644 parser/testdata/corpus/sql/storage/wal/wal_index_large_batch_interleaved.test create mode 100644 parser/testdata/corpus/sql/storage/wal/wal_index_replay.test create mode 100644 parser/testdata/corpus/sql/storage/wal/wal_lazy_creation.test create mode 100644 parser/testdata/corpus/sql/storage/wal/wal_null_update_row_group_pruning.test create mode 100644 parser/testdata/corpus/sql/storage/wal/wal_promote_version.test create mode 100644 parser/testdata/corpus/sql/storage/wal/wal_replay_consistency_add_column_current_timestamp.test create mode 100644 parser/testdata/corpus/sql/storage/wal/wal_replay_consistency_add_column_random.test create mode 100644 parser/testdata/corpus/sql/storage/wal/wal_replay_unbound_index_create_index_during_wal.test create mode 100644 parser/testdata/corpus/sql/storage/wal/wal_replay_unbound_index_generated_column.test create mode 100644 parser/testdata/corpus/sql/storage/wal/wal_replay_unbound_index_mixed_inserts.test create mode 100644 parser/testdata/corpus/sql/storage/wal/wal_replay_unbound_index_multi_index.test create mode 100644 parser/testdata/corpus/sql/storage/wal/wal_replay_with_function.test create mode 100644 parser/testdata/corpus/sql/storage/wal/wal_storage_types.test create mode 100644 parser/testdata/corpus/sql/storage/wal/wal_store_mixed_updates_big.test create mode 100644 parser/testdata/corpus/sql/storage/wal/wal_store_mixed_updates_big_null.test create mode 100644 parser/testdata/corpus/sql/storage/wal/wal_store_sequences.test create mode 100644 parser/testdata/corpus/sql/storage/wal/wal_store_updates_big.test create mode 100644 parser/testdata/corpus/sql/storage/wal/wal_store_updates_big_varchar.test create mode 100644 parser/testdata/corpus/sql/storage/wal/wal_timestamp_storage.test create mode 100644 parser/testdata/corpus/sql/storage/wal/wal_uhugeint_storage.test create mode 100644 parser/testdata/corpus/sql/storage/wal/wal_view_storage.test create mode 100644 parser/testdata/corpus/sql/storage_version/storage_hyperloglog.test create mode 100644 parser/testdata/corpus/sql/storage_version/storage_version_bump.test create mode 100644 parser/testdata/corpus/sql/subquery/any_all/issue_2999.test create mode 100644 parser/testdata/corpus/sql/subquery/any_all/subquery_in.test create mode 100644 parser/testdata/corpus/sql/subquery/any_all/test_any_all.test create mode 100644 parser/testdata/corpus/sql/subquery/any_all/test_any_all.test.metadata.json create mode 100644 parser/testdata/corpus/sql/subquery/any_all/test_correlated_any_all.test create mode 100644 parser/testdata/corpus/sql/subquery/any_all/test_multi_column_mark_join_nulls.test create mode 100644 parser/testdata/corpus/sql/subquery/any_all/test_row_comparison_any_all.test create mode 100644 parser/testdata/corpus/sql/subquery/any_all/test_row_not_equal_any_null_semantics.test create mode 100644 parser/testdata/corpus/sql/subquery/any_all/test_scalar_any_all.test create mode 100644 parser/testdata/corpus/sql/subquery/any_all/test_scalar_in.test create mode 100644 parser/testdata/corpus/sql/subquery/any_all/test_simple_not_in.test create mode 100644 parser/testdata/corpus/sql/subquery/any_all/test_uncorrelated_all_subquery.test create mode 100644 parser/testdata/corpus/sql/subquery/any_all/test_uncorrelated_any_subquery.test create mode 100644 parser/testdata/corpus/sql/subquery/complex/complex_correlated_subquery_issue.test create mode 100644 parser/testdata/corpus/sql/subquery/complex/correlated_internal_issue_5975.test create mode 100644 parser/testdata/corpus/sql/subquery/complex/correlated_list_any_join.test create mode 100644 parser/testdata/corpus/sql/subquery/complex/nested_unnest_subquery.test create mode 100644 parser/testdata/corpus/sql/subquery/exists/test_correlated_exists.test create mode 100644 parser/testdata/corpus/sql/subquery/exists/test_correlated_exists_with_derived_table.test create mode 100644 parser/testdata/corpus/sql/subquery/exists/test_exists_union_by_name.test create mode 100644 parser/testdata/corpus/sql/subquery/exists/test_issue_22267.test create mode 100644 parser/testdata/corpus/sql/subquery/exists/test_issue_23979.test create mode 100644 parser/testdata/corpus/sql/subquery/exists/test_issue_9308.test create mode 100644 parser/testdata/corpus/sql/subquery/exists/test_scalar_exists.test create mode 100644 parser/testdata/corpus/sql/subquery/exists/test_uncorrelated_exists_subquery.test create mode 100644 parser/testdata/corpus/sql/subquery/lateral/lateral_arrays.test create mode 100644 parser/testdata/corpus/sql/subquery/lateral/lateral_binding_views.test create mode 100644 parser/testdata/corpus/sql/subquery/lateral/lateral_fuzzer_1463.test create mode 100644 parser/testdata/corpus/sql/subquery/lateral/lateral_fuzzer_5984_23.test create mode 100644 parser/testdata/corpus/sql/subquery/lateral/lateral_grouping_sets.test create mode 100644 parser/testdata/corpus/sql/subquery/lateral/lateral_join_aggregate.test create mode 100644 parser/testdata/corpus/sql/subquery/lateral/lateral_join_chain.test create mode 100644 parser/testdata/corpus/sql/subquery/lateral/lateral_join_generated_columns.test create mode 100644 parser/testdata/corpus/sql/subquery/lateral/lateral_join_macro.test create mode 100644 parser/testdata/corpus/sql/subquery/lateral/lateral_large_lists.test create mode 100644 parser/testdata/corpus/sql/subquery/lateral/lateral_left_join.test create mode 100644 parser/testdata/corpus/sql/subquery/lateral/lateral_qualify.test create mode 100644 parser/testdata/corpus/sql/subquery/lateral/lateral_values.test create mode 100644 parser/testdata/corpus/sql/subquery/lateral/pg_lateral.test create mode 100644 parser/testdata/corpus/sql/subquery/lateral/test_lateral_join.test create mode 100644 parser/testdata/corpus/sql/subquery/scalar/array_order_subquery.test create mode 100644 parser/testdata/corpus/sql/subquery/scalar/array_subquery.test create mode 100644 parser/testdata/corpus/sql/subquery/scalar/coalesce_subquery.test create mode 100644 parser/testdata/corpus/sql/subquery/scalar/correlated_missing_columns.test create mode 100644 parser/testdata/corpus/sql/subquery/scalar/correlated_pivot.test create mode 100644 parser/testdata/corpus/sql/subquery/scalar/correlated_pivot_error.test create mode 100644 parser/testdata/corpus/sql/subquery/scalar/in_multiple_columns.test create mode 100644 parser/testdata/corpus/sql/subquery/scalar/nested_subquery_window.test create mode 100644 parser/testdata/corpus/sql/subquery/scalar/order_by_correlated.test create mode 100644 parser/testdata/corpus/sql/subquery/scalar/subquery_row_in_any.test create mode 100644 parser/testdata/corpus/sql/subquery/scalar/test_complex_correlated_subquery.test create mode 100644 parser/testdata/corpus/sql/subquery/scalar/test_complex_nested_correlated_subquery.test create mode 100644 parser/testdata/corpus/sql/subquery/scalar/test_correlated_grouping_set.test create mode 100644 parser/testdata/corpus/sql/subquery/scalar/test_correlated_set_op.test create mode 100644 parser/testdata/corpus/sql/subquery/scalar/test_correlated_side_effects.test create mode 100644 parser/testdata/corpus/sql/subquery/scalar/test_correlated_subquery.test create mode 100644 parser/testdata/corpus/sql/subquery/scalar/test_correlated_subquery_cte.test create mode 100644 parser/testdata/corpus/sql/subquery/scalar/test_correlated_subquery_where.test create mode 100644 parser/testdata/corpus/sql/subquery/scalar/test_correlated_window.test create mode 100644 parser/testdata/corpus/sql/subquery/scalar/test_count_star_subquery.test create mode 100644 parser/testdata/corpus/sql/subquery/scalar/test_delete_subquery.test create mode 100644 parser/testdata/corpus/sql/subquery/scalar/test_grouped_correlated_subquery.test create mode 100644 parser/testdata/corpus/sql/subquery/scalar/test_issue_4216.test create mode 100644 parser/testdata/corpus/sql/subquery/scalar/test_issue_6136.test create mode 100644 parser/testdata/corpus/sql/subquery/scalar/test_issue_6184.test create mode 100644 parser/testdata/corpus/sql/subquery/scalar/test_issue_7079.test create mode 100644 parser/testdata/corpus/sql/subquery/scalar/test_join_in_subquery.test create mode 100644 parser/testdata/corpus/sql/subquery/scalar/test_many_correlated_columns.test create mode 100644 parser/testdata/corpus/sql/subquery/scalar/test_scalar_subquery.test create mode 100644 parser/testdata/corpus/sql/subquery/scalar/test_scalar_subquery_cte.test create mode 100644 parser/testdata/corpus/sql/subquery/scalar/test_subquery_any_join.test create mode 100644 parser/testdata/corpus/sql/subquery/scalar/test_tpcds_correlated_subquery.test create mode 100644 parser/testdata/corpus/sql/subquery/scalar/test_uncorrelated_scalar_subquery.test create mode 100644 parser/testdata/corpus/sql/subquery/scalar/test_uncorrelated_varchar_subquery.test create mode 100644 parser/testdata/corpus/sql/subquery/scalar/test_unnest_subquery.test create mode 100644 parser/testdata/corpus/sql/subquery/scalar/test_update_subquery.test create mode 100644 parser/testdata/corpus/sql/subquery/scalar/test_varchar_correlated_subquery.test create mode 100644 parser/testdata/corpus/sql/subquery/scalar/test_window_function_subquery.test create mode 100644 parser/testdata/corpus/sql/subquery/table/test_aliasing.test create mode 100644 parser/testdata/corpus/sql/subquery/table/test_subquery_union.test create mode 100644 parser/testdata/corpus/sql/subquery/table/test_table_subquery.test create mode 100644 parser/testdata/corpus/sql/subquery/table/test_unnamed_subquery.test create mode 100644 parser/testdata/corpus/sql/subquery/test_neumann.test create mode 100644 parser/testdata/corpus/sql/subquery/test_offset.test create mode 100644 parser/testdata/corpus/sql/table_function/create_external_resource.test create mode 100644 parser/testdata/corpus/sql/table_function/database_oid.test create mode 100644 parser/testdata/corpus/sql/table_function/duckdb_available_metrics.test create mode 100644 parser/testdata/corpus/sql/table_function/duckdb_columns.test create mode 100644 parser/testdata/corpus/sql/table_function/duckdb_constraints.test create mode 100644 parser/testdata/corpus/sql/table_function/duckdb_constraints_fk.test create mode 100644 parser/testdata/corpus/sql/table_function/duckdb_constraints_issue11284.test create mode 100644 parser/testdata/corpus/sql/table_function/duckdb_constraints_issue12863.test create mode 100644 parser/testdata/corpus/sql/table_function/duckdb_databases.test create mode 100644 parser/testdata/corpus/sql/table_function/duckdb_dependencies.test create mode 100644 parser/testdata/corpus/sql/table_function/duckdb_dialects.test create mode 100644 parser/testdata/corpus/sql/table_function/duckdb_eviction_queues.test create mode 100644 parser/testdata/corpus/sql/table_function/duckdb_eviction_queues_transactions.test create mode 100644 parser/testdata/corpus/sql/table_function/duckdb_extensions.test create mode 100644 parser/testdata/corpus/sql/table_function/duckdb_functions_window.test create mode 100644 parser/testdata/corpus/sql/table_function/duckdb_indexes.test create mode 100644 parser/testdata/corpus/sql/table_function/duckdb_keywords.test create mode 100644 parser/testdata/corpus/sql/table_function/duckdb_memory_convert_to_persistent.test create mode 100644 parser/testdata/corpus/sql/table_function/duckdb_optimizers.test create mode 100644 parser/testdata/corpus/sql/table_function/duckdb_prepared_statements.test create mode 100644 parser/testdata/corpus/sql/table_function/duckdb_schemas.test create mode 100644 parser/testdata/corpus/sql/table_function/duckdb_sequences.test create mode 100644 parser/testdata/corpus/sql/table_function/duckdb_settings.test create mode 100644 parser/testdata/corpus/sql/table_function/duckdb_tables.test create mode 100644 parser/testdata/corpus/sql/table_function/duckdb_types.test create mode 100644 parser/testdata/corpus/sql/table_function/duckdb_views.test create mode 100644 parser/testdata/corpus/sql/table_function/external_resource_discovery.test create mode 100644 parser/testdata/corpus/sql/table_function/external_resource_discovery_error.test create mode 100644 parser/testdata/corpus/sql/table_function/external_resource_logging.test create mode 100644 parser/testdata/corpus/sql/table_function/external_resource_types.test create mode 100644 parser/testdata/corpus/sql/table_function/icu_range_timestamptz.test create mode 100644 parser/testdata/corpus/sql/table_function/information_schema.test create mode 100644 parser/testdata/corpus/sql/table_function/information_schema_fkey_constraint_names.test create mode 100644 parser/testdata/corpus/sql/table_function/information_schema_issue12867.test create mode 100644 parser/testdata/corpus/sql/table_function/information_schema_types.test create mode 100644 parser/testdata/corpus/sql/table_function/lateral_table_function.test create mode 100644 parser/testdata/corpus/sql/table_function/postgres_setof_compatibility.test create mode 100644 parser/testdata/corpus/sql/table_function/range_function_different_iterators.test create mode 100644 parser/testdata/corpus/sql/table_function/range_function_lateral.test create mode 100644 parser/testdata/corpus/sql/table_function/range_non_foldable.test create mode 100644 parser/testdata/corpus/sql/table_function/range_timestamp.test create mode 100644 parser/testdata/corpus/sql/table_function/range_timestamp_lateral_empty.test create mode 100644 parser/testdata/corpus/sql/table_function/read_text_and_blob.test create mode 100644 parser/testdata/corpus/sql/table_function/register_external_resource.test create mode 100644 parser/testdata/corpus/sql/table_function/sqlite_master.test create mode 100644 parser/testdata/corpus/sql/table_function/sqlite_master_connections.test create mode 100644 parser/testdata/corpus/sql/table_function/sqlite_master_quotes.test create mode 100644 parser/testdata/corpus/sql/table_function/test_information_schema_columns.test create mode 100644 parser/testdata/corpus/sql/table_function/test_range_function.test create mode 100644 parser/testdata/corpus/sql/table_function/test_repeat_function.test create mode 100644 parser/testdata/corpus/sql/table_function/test_table_function.test create mode 100644 parser/testdata/corpus/sql/table_function/warn_deprecated_identifier_conversion.test create mode 100644 parser/testdata/corpus/sql/timezone/disable_timestamptz_casts.test create mode 100644 parser/testdata/corpus/sql/timezone/icu_calendar_operations.test create mode 100644 parser/testdata/corpus/sql/timezone/test_icu_calendar.test create mode 100644 parser/testdata/corpus/sql/timezone/test_icu_calendar_chinese.test create mode 100644 parser/testdata/corpus/sql/timezone/test_icu_calendar_coptic.test create mode 100644 parser/testdata/corpus/sql/timezone/test_icu_calendar_hebrew.test create mode 100644 parser/testdata/corpus/sql/timezone/test_icu_calendar_islamic.test create mode 100644 parser/testdata/corpus/sql/timezone/test_icu_calendar_islamic_observed.test create mode 100644 parser/testdata/corpus/sql/timezone/test_icu_calendar_japanese.test create mode 100644 parser/testdata/corpus/sql/timezone/test_icu_calendar_persian.test create mode 100644 parser/testdata/corpus/sql/timezone/test_icu_calendar_systems.test create mode 100644 parser/testdata/corpus/sql/timezone/test_icu_casts.test create mode 100644 parser/testdata/corpus/sql/timezone/test_icu_datetime_overflow.test create mode 100644 parser/testdata/corpus/sql/timezone/test_icu_datetime_sweep.test create mode 100644 parser/testdata/corpus/sql/timezone/test_icu_timezone.test create mode 100644 parser/testdata/corpus/sql/timezone/test_icu_timezone_edge_cases.test create mode 100644 parser/testdata/corpus/sql/timezone/test_icu_timezone_far_future.test create mode 100644 parser/testdata/corpus/sql/timezone/test_icu_timezone_properties.test create mode 100644 parser/testdata/corpus/sql/topn/test_top_n.test create mode 100644 parser/testdata/corpus/sql/topn/test_top_n_distinct_row_group_pruner.test create mode 100644 parser/testdata/corpus/sql/topn/test_top_n_lists.test create mode 100644 parser/testdata/corpus/sql/topn/test_top_n_medium.test create mode 100644 parser/testdata/corpus/sql/topn/test_top_n_nested_struct.test create mode 100644 parser/testdata/corpus/sql/topn/test_top_n_nulls_first.test create mode 100644 parser/testdata/corpus/sql/topn/test_top_n_nulls_first_row_group_reorderer_edge_cases.test create mode 100644 parser/testdata/corpus/sql/topn/test_top_n_nulls_row_group_pruner.test create mode 100644 parser/testdata/corpus/sql/topn/test_top_n_nulls_row_group_pruner_extensive.test create mode 100644 parser/testdata/corpus/sql/topn/test_top_n_nulls_small.test create mode 100644 parser/testdata/corpus/sql/topn/test_top_n_offset_no_limit_pruner.test create mode 100644 parser/testdata/corpus/sql/topn/test_top_n_structs.test create mode 100644 parser/testdata/corpus/sql/topn/top_n_materialization.test create mode 100644 parser/testdata/corpus/sql/topn/top_n_pruning.test create mode 100644 parser/testdata/corpus/sql/topn/topn_nulls_first.test create mode 100644 parser/testdata/corpus/sql/topn/tpcds_q14_topn.test create mode 100644 parser/testdata/corpus/sql/topn/tpcds_q59_topn.test create mode 100644 parser/testdata/corpus/sql/tpcds/dsdgen_readonly.test create mode 100644 parser/testdata/corpus/sql/tpcds/dsdgen_sync_scan.test create mode 100644 parser/testdata/corpus/sql/tpcds/tpcds_sf0.test create mode 100644 parser/testdata/corpus/sql/tpch/dbgen_readonly.test create mode 100644 parser/testdata/corpus/sql/tpch/tpch_sf0.test create mode 100644 parser/testdata/corpus/sql/transactions/aborted_transaction_commit.test create mode 100644 parser/testdata/corpus/sql/transactions/commit_revert_failure.test create mode 100644 parser/testdata/corpus/sql/transactions/concurrent_drop_index.test create mode 100644 parser/testdata/corpus/sql/transactions/concurrent_drop_table.test create mode 100644 parser/testdata/corpus/sql/transactions/conflict_drop_then_delete.test create mode 100644 parser/testdata/corpus/sql/transactions/conflict_rename_append.test create mode 100644 parser/testdata/corpus/sql/transactions/count_star_transactions.test create mode 100644 parser/testdata/corpus/sql/transactions/delete_and_drop_in_same_transaction.test create mode 100644 parser/testdata/corpus/sql/transactions/delete_index_lookup_transactions.test create mode 100644 parser/testdata/corpus/sql/transactions/min_max_deletes.test create mode 100644 parser/testdata/corpus/sql/transactions/min_max_updates.test create mode 100644 parser/testdata/corpus/sql/transactions/revert_commit_index_corruption_drop_table.test create mode 100644 parser/testdata/corpus/sql/transactions/rollback_drop.test create mode 100644 parser/testdata/corpus/sql/transactions/rollback_drop_column.test create mode 100644 parser/testdata/corpus/sql/transactions/rollback_drop_index.test create mode 100644 parser/testdata/corpus/sql/transactions/rollback_drop_table.test create mode 100644 parser/testdata/corpus/sql/transactions/rollback_drop_table_with_delete.test create mode 100644 parser/testdata/corpus/sql/transactions/statement-preprocessor/invalidation_policy_is_respected_by_preprocessor.test create mode 100644 parser/testdata/corpus/sql/transactions/statement-preprocessor/multistatement_is_transactional.test create mode 100644 parser/testdata/corpus/sql/transactions/statement-preprocessor/multistatement_is_transactional_after_BEGIN_chained_COMMIT.test create mode 100644 parser/testdata/corpus/sql/transactions/statement-preprocessor/multistatement_is_transactional_chained_BEGIN.test create mode 100644 parser/testdata/corpus/sql/transactions/statement-preprocessor/multistatement_is_transactional_chained_BEGIN_body_COMMIT.test create mode 100644 parser/testdata/corpus/sql/transactions/statement-preprocessor/multistatement_is_transactional_chained_PRAGMA.test create mode 100644 parser/testdata/corpus/sql/transactions/statement-preprocessor/multistatement_is_transactional_chained_PRAGMA_BEGIN.test create mode 100644 parser/testdata/corpus/sql/transactions/statement-preprocessor/pivot_is_handled_correctly.test create mode 100644 parser/testdata/corpus/sql/transactions/test_alter_sequence_ownership_conflict.test create mode 100644 parser/testdata/corpus/sql/transactions/test_alter_sequence_ownership_conflict2.test create mode 100644 parser/testdata/corpus/sql/transactions/test_basic_transactions.test create mode 100644 parser/testdata/corpus/sql/transactions/test_cardinality_estimation_uncommitted.test create mode 100644 parser/testdata/corpus/sql/transactions/test_create_drop_conflict.test create mode 100644 parser/testdata/corpus/sql/transactions/test_create_drop_conflict_variation1.test create mode 100644 parser/testdata/corpus/sql/transactions/test_ddl_after_dml.test create mode 100644 parser/testdata/corpus/sql/transactions/test_from_update_conflict.test create mode 100644 parser/testdata/corpus/sql/transactions/test_index_abort.test create mode 100644 parser/testdata/corpus/sql/transactions/test_index_delete_cleanup_non_main_storage.test create mode 100644 parser/testdata/corpus/sql/transactions/test_index_huge_aborted_append.test create mode 100644 parser/testdata/corpus/sql/transactions/test_index_large_aborted_append.test create mode 100644 parser/testdata/corpus/sql/transactions/test_index_local_update.test create mode 100644 parser/testdata/corpus/sql/transactions/test_index_pending_delete.test create mode 100644 parser/testdata/corpus/sql/transactions/test_index_pending_update.test create mode 100644 parser/testdata/corpus/sql/transactions/test_index_rollback_flushed_data.test create mode 100644 parser/testdata/corpus/sql/transactions/test_index_transaction_local.test create mode 100644 parser/testdata/corpus/sql/transactions/test_index_versioned_deletes.test create mode 100644 parser/testdata/corpus/sql/transactions/test_index_versioned_updates.test create mode 100644 parser/testdata/corpus/sql/transactions/test_multi_transaction_append.test create mode 100644 parser/testdata/corpus/sql/transactions/test_multi_version.test create mode 100644 parser/testdata/corpus/sql/transactions/test_multi_version_large.test create mode 100644 parser/testdata/corpus/sql/transactions/test_null_version.test create mode 100644 parser/testdata/corpus/sql/transactions/test_read_only_transactions.test create mode 100644 parser/testdata/corpus/sql/transactions/test_stacked_schema_change.test create mode 100644 parser/testdata/corpus/sql/transactions/test_transaction_abort.test create mode 100644 parser/testdata/corpus/sql/transactions/test_transaction_local_add.test create mode 100644 parser/testdata/corpus/sql/transactions/test_transaction_local_alter_type.test create mode 100644 parser/testdata/corpus/sql/transactions/test_transaction_local_data.test create mode 100644 parser/testdata/corpus/sql/transactions/test_transaction_local_drop.test create mode 100644 parser/testdata/corpus/sql/transactions/test_transaction_local_unique_ops.test create mode 100644 parser/testdata/corpus/sql/transactions/transaction_insert_delete_chunks.test create mode 100644 parser/testdata/corpus/sql/transactions/transaction_insert_mixed_deletes.test create mode 100644 parser/testdata/corpus/sql/transactions/types/test_hugeint_transactions.test create mode 100644 parser/testdata/corpus/sql/transactions/types/test_interval_transactions.test create mode 100644 parser/testdata/corpus/sql/transactions/types/test_uhugeint_transactions.test create mode 100644 parser/testdata/corpus/sql/trigger/create_trigger_catalog.test create mode 100644 parser/testdata/corpus/sql/trigger/create_trigger_parse.test create mode 100644 parser/testdata/corpus/sql/trigger/create_trigger_wal.test create mode 100644 parser/testdata/corpus/sql/trigger/drop_trigger.test create mode 100644 parser/testdata/corpus/sql/trigger/drop_trigger_parse.test create mode 100644 parser/testdata/corpus/sql/trigger/drop_trigger_wal.test create mode 100644 parser/testdata/corpus/sql/trigger/trigger_after_delete.test create mode 100644 parser/testdata/corpus/sql/trigger/trigger_after_delete_referencing.test create mode 100644 parser/testdata/corpus/sql/trigger/trigger_after_insert.test create mode 100644 parser/testdata/corpus/sql/trigger/trigger_after_insert_referencing.test create mode 100644 parser/testdata/corpus/sql/trigger/trigger_after_update.test create mode 100644 parser/testdata/corpus/sql/trigger/trigger_after_update_old_new.test create mode 100644 parser/testdata/corpus/sql/trigger/trigger_after_update_old_new_wal.test create mode 100644 parser/testdata/corpus/sql/trigger/trigger_after_update_referencing.test create mode 100644 parser/testdata/corpus/sql/trigger/trigger_alter_table.test create mode 100644 parser/testdata/corpus/sql/trigger/trigger_before_after_mixed.test create mode 100644 parser/testdata/corpus/sql/trigger/trigger_before_delete.test create mode 100644 parser/testdata/corpus/sql/trigger/trigger_before_insert.test create mode 100644 parser/testdata/corpus/sql/trigger/trigger_before_update.test create mode 100644 parser/testdata/corpus/sql/trigger/trigger_for_each_row.test create mode 100644 parser/testdata/corpus/sql/trigger/trigger_multiple_per_event.test create mode 100644 parser/testdata/corpus/sql/trigger/trigger_referencing_validation.test create mode 100644 parser/testdata/corpus/sql/trigger/trigger_referencing_validation.test.metadata.json create mode 100644 parser/testdata/corpus/sql/trigger/trigger_returning.test create mode 100644 parser/testdata/corpus/sql/trigger/trigger_returning_binder_parity.test create mode 100644 parser/testdata/corpus/sql/trigger/trigger_update_from_multi_match.test create mode 100644 parser/testdata/corpus/sql/types/alias/nested_alias.test create mode 100644 parser/testdata/corpus/sql/types/alias/recursive_alias.test create mode 100644 parser/testdata/corpus/sql/types/alias/test_alias.test create mode 100644 parser/testdata/corpus/sql/types/alias/test_alias_functions.test create mode 100644 parser/testdata/corpus/sql/types/alias/test_alias_map.test create mode 100644 parser/testdata/corpus/sql/types/alias/test_alias_struct.test create mode 100644 parser/testdata/corpus/sql/types/alias/test_alias_struct_nested_alias.test create mode 100644 parser/testdata/corpus/sql/types/alias/test_alias_table.test create mode 100644 parser/testdata/corpus/sql/types/alias/type_with_schema.test create mode 100644 parser/testdata/corpus/sql/types/bignum/test_big_bignum.test create mode 100644 parser/testdata/corpus/sql/types/bignum/test_bignum_boundaries.test create mode 100644 parser/testdata/corpus/sql/types/bignum/test_bignum_comparisons.test create mode 100644 parser/testdata/corpus/sql/types/bignum/test_bignum_double.test create mode 100644 parser/testdata/corpus/sql/types/bignum/test_bignum_float_string_cast.test create mode 100644 parser/testdata/corpus/sql/types/bignum/test_bignum_hugeint.test create mode 100644 parser/testdata/corpus/sql/types/bignum/test_bignum_implicit_cast.test create mode 100644 parser/testdata/corpus/sql/types/bignum/test_bignum_not_cast.test create mode 100644 parser/testdata/corpus/sql/types/bignum/test_bignum_subtract.test create mode 100644 parser/testdata/corpus/sql/types/bignum/test_bignum_sum.test create mode 100644 parser/testdata/corpus/sql/types/bignum/test_bignum_try_cast.test create mode 100644 parser/testdata/corpus/sql/types/bignum/test_bignum_varchar_invalid.test create mode 100644 parser/testdata/corpus/sql/types/bignum/test_double_bignum.test create mode 100644 parser/testdata/corpus/sql/types/bignum/test_int_bignum_conversion.test create mode 100644 parser/testdata/corpus/sql/types/bignum/test_varchar_bignum_conversion.test create mode 100644 parser/testdata/corpus/sql/types/bignum/test_varchar_bignum_unhappy.test create mode 100644 parser/testdata/corpus/sql/types/bit/bit_issue_11211.test create mode 100644 parser/testdata/corpus/sql/types/bit/bit_issue_22527.test create mode 100644 parser/testdata/corpus/sql/types/bit/bit_try_cast.test create mode 100644 parser/testdata/corpus/sql/types/bit/test_bit.test create mode 100644 parser/testdata/corpus/sql/types/bit/test_bit_bitwise_operations.test create mode 100644 parser/testdata/corpus/sql/types/bit/test_bit_equality.test create mode 100644 parser/testdata/corpus/sql/types/bit/test_bit_functions.test create mode 100644 parser/testdata/corpus/sql/types/bit/test_hex_to_bit.test create mode 100644 parser/testdata/corpus/sql/types/blob/test_blob.test create mode 100644 parser/testdata/corpus/sql/types/blob/test_blob_cast.test create mode 100644 parser/testdata/corpus/sql/types/blob/test_blob_function.test create mode 100644 parser/testdata/corpus/sql/types/blob/test_blob_invalid_utf8.test create mode 100644 parser/testdata/corpus/sql/types/blob/test_blob_operator.test create mode 100644 parser/testdata/corpus/sql/types/blob/test_blob_string.test create mode 100644 parser/testdata/corpus/sql/types/blob/test_blob_try_cast.test create mode 100644 parser/testdata/corpus/sql/types/date/date_implicit_cast.test create mode 100644 parser/testdata/corpus/sql/types/date/date_limits.test create mode 100644 parser/testdata/corpus/sql/types/date/date_parsing.test create mode 100644 parser/testdata/corpus/sql/types/date/date_try_cast.test create mode 100644 parser/testdata/corpus/sql/types/date/test_bc_dates.test create mode 100644 parser/testdata/corpus/sql/types/date/test_date.test create mode 100644 parser/testdata/corpus/sql/types/date/test_date_2411.test create mode 100644 parser/testdata/corpus/sql/types/date/test_incorrect_dates.test create mode 100644 parser/testdata/corpus/sql/types/decimal/cast_from_decimal.test create mode 100644 parser/testdata/corpus/sql/types/decimal/cast_to_decimal.test create mode 100644 parser/testdata/corpus/sql/types/decimal/decimal_aggregates.test create mode 100644 parser/testdata/corpus/sql/types/decimal/decimal_arithmetic.test create mode 100644 parser/testdata/corpus/sql/types/decimal/decimal_automatic_cast.test create mode 100644 parser/testdata/corpus/sql/types/decimal/decimal_average.test create mode 100644 parser/testdata/corpus/sql/types/decimal/decimal_decimal_overflow_cast.test create mode 100644 parser/testdata/corpus/sql/types/decimal/decimal_division.test create mode 100644 parser/testdata/corpus/sql/types/decimal/decimal_exception.test create mode 100644 parser/testdata/corpus/sql/types/decimal/decimal_exponent.test create mode 100644 parser/testdata/corpus/sql/types/decimal/decimal_overflow.test create mode 100644 parser/testdata/corpus/sql/types/decimal/decimal_overflow_table.test create mode 100644 parser/testdata/corpus/sql/types/decimal/decimal_promotion.test create mode 100644 parser/testdata/corpus/sql/types/decimal/decimal_try_cast.test create mode 100644 parser/testdata/corpus/sql/types/decimal/large_decimal_constants.test create mode 100644 parser/testdata/corpus/sql/types/decimal/test_decimal.test create mode 100644 parser/testdata/corpus/sql/types/decimal/test_decimal_2411.test create mode 100644 parser/testdata/corpus/sql/types/decimal/test_decimal_2975.test create mode 100644 parser/testdata/corpus/sql/types/decimal/test_decimal_4106.test create mode 100644 parser/testdata/corpus/sql/types/decimal/test_decimal_from_string.test create mode 100644 parser/testdata/corpus/sql/types/decimal/test_decimal_ops.test create mode 100644 parser/testdata/corpus/sql/types/decimal/test_decimal_small_precision_behavior.test create mode 100644 parser/testdata/corpus/sql/types/decimal/test_empty_dec.test create mode 100644 parser/testdata/corpus/sql/types/decimal/test_empty_decimal.test create mode 100644 parser/testdata/corpus/sql/types/enum/standalone_enum.test create mode 100644 parser/testdata/corpus/sql/types/enum/test_3479.test create mode 100644 parser/testdata/corpus/sql/types/enum/test_3641.test create mode 100644 parser/testdata/corpus/sql/types/enum/test_5983.test create mode 100644 parser/testdata/corpus/sql/types/enum/test_6356.test create mode 100644 parser/testdata/corpus/sql/types/enum/test_alter_enum.test create mode 100644 parser/testdata/corpus/sql/types/enum/test_enum.test create mode 100644 parser/testdata/corpus/sql/types/enum/test_enum_case.test create mode 100644 parser/testdata/corpus/sql/types/enum/test_enum_cast.test create mode 100644 parser/testdata/corpus/sql/types/enum/test_enum_comparisons.test create mode 100644 parser/testdata/corpus/sql/types/enum/test_enum_constraints.test create mode 100644 parser/testdata/corpus/sql/types/enum/test_enum_duckdb_types.test create mode 100644 parser/testdata/corpus/sql/types/enum/test_enum_schema.test create mode 100644 parser/testdata/corpus/sql/types/enum/test_enum_structs.test create mode 100644 parser/testdata/corpus/sql/types/enum/test_enum_table.test create mode 100644 parser/testdata/corpus/sql/types/enum/test_enum_temp_tbl.test create mode 100644 parser/testdata/corpus/sql/types/enum/test_enum_to_numbers.test create mode 100644 parser/testdata/corpus/sql/types/enum/test_enums_and_built_in_types.test create mode 100644 parser/testdata/corpus/sql/types/float/ieee_floating_points.test create mode 100644 parser/testdata/corpus/sql/types/float/infinity_test.test create mode 100644 parser/testdata/corpus/sql/types/float/nan_aggregate.test create mode 100644 parser/testdata/corpus/sql/types/float/nan_aggregates.test create mode 100644 parser/testdata/corpus/sql/types/float/nan_arithmetic.test create mode 100644 parser/testdata/corpus/sql/types/float/nan_cast.test create mode 100644 parser/testdata/corpus/sql/types/float/nan_functions.test create mode 100644 parser/testdata/corpus/sql/types/float/nan_join.test create mode 100644 parser/testdata/corpus/sql/types/float/nan_ordering.test create mode 100644 parser/testdata/corpus/sql/types/float/nan_test.test create mode 100644 parser/testdata/corpus/sql/types/float/nan_window.test create mode 100644 parser/testdata/corpus/sql/types/float/nested_nan.test create mode 100644 parser/testdata/corpus/sql/types/geo/geometry.test create mode 100644 parser/testdata/corpus/sql/types/geo/geometry_compatability.test create mode 100644 parser/testdata/corpus/sql/types/geo/geometry_crs.test create mode 100644 parser/testdata/corpus/sql/types/geo/geometry_crs.test.metadata.json create mode 100644 parser/testdata/corpus/sql/types/geo/geometry_crs_projjson.test create mode 100644 parser/testdata/corpus/sql/types/geo/geometry_crs_wkt2.test create mode 100644 parser/testdata/corpus/sql/types/geo/geometry_from_wkb_stats.test create mode 100644 parser/testdata/corpus/sql/types/geo/geometry_intersection_filter_parquet.test create mode 100644 parser/testdata/corpus/sql/types/geo/geometry_intersects.test create mode 100644 parser/testdata/corpus/sql/types/geo/geometry_legacy_recheckpoint.test create mode 100644 parser/testdata/corpus/sql/types/geo/geometry_nonascii_cast.test create mode 100644 parser/testdata/corpus/sql/types/geo/geometry_parquet_pushdown.test create mode 100644 parser/testdata/corpus/sql/types/geo/geometry_parquet_pushdown.test.metadata.json create mode 100644 parser/testdata/corpus/sql/types/geo/geometry_persist.test create mode 100644 parser/testdata/corpus/sql/types/geo/geometry_persist_wal.test create mode 100644 parser/testdata/corpus/sql/types/geo/geometry_shred.test create mode 100644 parser/testdata/corpus/sql/types/geo/geometry_shred_deletes.test create mode 100644 parser/testdata/corpus/sql/types/geo/geometry_shred_empty.test create mode 100644 parser/testdata/corpus/sql/types/geo/geometry_shred_fetch.test create mode 100644 parser/testdata/corpus/sql/types/geo/geometry_shred_limit.test create mode 100644 parser/testdata/corpus/sql/types/geo/geometry_shred_list.test create mode 100644 parser/testdata/corpus/sql/types/geo/geometry_shred_more.test create mode 100644 parser/testdata/corpus/sql/types/geo/geometry_shred_pk_append.test create mode 100644 parser/testdata/corpus/sql/types/geo/geometry_stats.test create mode 100644 parser/testdata/corpus/sql/types/geo/geometry_stats_prune.test create mode 100644 parser/testdata/corpus/sql/types/geo/geometry_stats_prune_shredded.test create mode 100644 parser/testdata/corpus/sql/types/geo/geometry_storage_version.test create mode 100644 parser/testdata/corpus/sql/types/geo/geometry_update.test create mode 100644 parser/testdata/corpus/sql/types/geo/geometry_vertex_extract.test create mode 100644 parser/testdata/corpus/sql/types/geo/geometry_wkb.test create mode 100644 parser/testdata/corpus/sql/types/hugeint/hugeint_multiply.test create mode 100644 parser/testdata/corpus/sql/types/hugeint/hugeint_sum_overflow.test create mode 100644 parser/testdata/corpus/sql/types/hugeint/hugeint_try_cast.test create mode 100644 parser/testdata/corpus/sql/types/hugeint/test_hugeint_aggregates.test create mode 100644 parser/testdata/corpus/sql/types/hugeint/test_hugeint_arithmetic.test create mode 100644 parser/testdata/corpus/sql/types/hugeint/test_hugeint_auto_cast.test create mode 100644 parser/testdata/corpus/sql/types/hugeint/test_hugeint_bitwise.test create mode 100644 parser/testdata/corpus/sql/types/hugeint/test_hugeint_conversion.test create mode 100644 parser/testdata/corpus/sql/types/hugeint/test_hugeint_exponent.test create mode 100644 parser/testdata/corpus/sql/types/hugeint/test_hugeint_functions.test create mode 100644 parser/testdata/corpus/sql/types/hugeint/test_hugeint_null_value.test create mode 100644 parser/testdata/corpus/sql/types/hugeint/test_hugeint_ops.test create mode 100644 parser/testdata/corpus/sql/types/interval/frac_interval.test create mode 100644 parser/testdata/corpus/sql/types/interval/interval_alias.test create mode 100644 parser/testdata/corpus/sql/types/interval/interval_constants.test create mode 100644 parser/testdata/corpus/sql/types/interval/interval_constants.test.metadata.json create mode 100644 parser/testdata/corpus/sql/types/interval/interval_try_cast.test create mode 100644 parser/testdata/corpus/sql/types/interval/test_interval.test create mode 100644 parser/testdata/corpus/sql/types/interval/test_interval_addition.test create mode 100644 parser/testdata/corpus/sql/types/interval/test_interval_between.test create mode 100644 parser/testdata/corpus/sql/types/interval/test_interval_comparison.test create mode 100644 parser/testdata/corpus/sql/types/interval/test_interval_ops.test create mode 100644 parser/testdata/corpus/sql/types/list/list_case.test create mode 100644 parser/testdata/corpus/sql/types/list/list_comparison.test create mode 100644 parser/testdata/corpus/sql/types/list/list_concat_null.test create mode 100644 parser/testdata/corpus/sql/types/list/list_cross_product.test create mode 100644 parser/testdata/corpus/sql/types/list/list_distinct.test create mode 100644 parser/testdata/corpus/sql/types/list/list_extract_internal_issue2747.test create mode 100644 parser/testdata/corpus/sql/types/list/list_extract_struct.test create mode 100644 parser/testdata/corpus/sql/types/list/list_index.test create mode 100644 parser/testdata/corpus/sql/types/list/list_index_abort_small.test create mode 100644 parser/testdata/corpus/sql/types/list/list_index_abort_small_nested.test create mode 100644 parser/testdata/corpus/sql/types/list/list_indexing.test create mode 100644 parser/testdata/corpus/sql/types/list/list_null_members.test create mode 100644 parser/testdata/corpus/sql/types/list/list_null_members_small.test create mode 100644 parser/testdata/corpus/sql/types/list/list_of_struct.test create mode 100644 parser/testdata/corpus/sql/types/list/list_parse_recursion.test create mode 100644 parser/testdata/corpus/sql/types/list/list_stats.test create mode 100644 parser/testdata/corpus/sql/types/list/list_test_many_deletes.test create mode 100644 parser/testdata/corpus/sql/types/list/list_to_varchar_cast.test create mode 100644 parser/testdata/corpus/sql/types/list/list_update_with_many_matches.test create mode 100644 parser/testdata/corpus/sql/types/list/list_updates.test create mode 100644 parser/testdata/corpus/sql/types/list/list_updates_varchar.test create mode 100644 parser/testdata/corpus/sql/types/list/mix_numeric_types.test create mode 100644 parser/testdata/corpus/sql/types/list/nested_list_extract.test create mode 100644 parser/testdata/corpus/sql/types/list/nested_list_slice.test create mode 100644 parser/testdata/corpus/sql/types/list/nested_list_updates.test create mode 100644 parser/testdata/corpus/sql/types/list/recursive_unnest.test create mode 100644 parser/testdata/corpus/sql/types/list/unnest_aggregate.test create mode 100644 parser/testdata/corpus/sql/types/list/unnest_array.test create mode 100644 parser/testdata/corpus/sql/types/list/unnest_complex_types.test create mode 100644 parser/testdata/corpus/sql/types/list/unnest_expand.test create mode 100644 parser/testdata/corpus/sql/types/list/unnest_group_by.test create mode 100644 parser/testdata/corpus/sql/types/list/unnest_having_qualify.test create mode 100644 parser/testdata/corpus/sql/types/list/unnest_null_empty.test create mode 100644 parser/testdata/corpus/sql/types/list/unnest_table_function.test create mode 100644 parser/testdata/corpus/sql/types/list/unnest_types.test create mode 100644 parser/testdata/corpus/sql/types/map/map_cast.test create mode 100644 parser/testdata/corpus/sql/types/map/map_const_and_col_combination.test create mode 100644 parser/testdata/corpus/sql/types/map/map_empty.test create mode 100644 parser/testdata/corpus/sql/types/map/map_extract_nested_null.test create mode 100644 parser/testdata/corpus/sql/types/map/map_null.test create mode 100644 parser/testdata/corpus/sql/types/nested/array/array_aggregate.test create mode 100644 parser/testdata/corpus/sql/types/nested/array/array_cast.test create mode 100644 parser/testdata/corpus/sql/types/nested/array/array_coverage.test create mode 100644 parser/testdata/corpus/sql/types/nested/array/array_fuzzer_failures.test create mode 100644 parser/testdata/corpus/sql/types/nested/array/array_invalid.test create mode 100644 parser/testdata/corpus/sql/types/nested/array/array_invalid.test.metadata.json create mode 100644 parser/testdata/corpus/sql/types/nested/array/array_joins.test create mode 100644 parser/testdata/corpus/sql/types/nested/array/array_joins_2.test create mode 100644 parser/testdata/corpus/sql/types/nested/array/array_large.test create mode 100644 parser/testdata/corpus/sql/types/nested/array/array_limit_offset.test create mode 100644 parser/testdata/corpus/sql/types/nested/array/array_list_agg.test create mode 100644 parser/testdata/corpus/sql/types/nested/array/array_list_aggregate.test create mode 100644 parser/testdata/corpus/sql/types/nested/array/array_misc.test create mode 100644 parser/testdata/corpus/sql/types/nested/array/array_roundtrip_csv.test create mode 100644 parser/testdata/corpus/sql/types/nested/array/array_roundtrip_json.test create mode 100644 parser/testdata/corpus/sql/types/nested/array/array_roundtrip_parquet.test create mode 100644 parser/testdata/corpus/sql/types/nested/array/array_rowgroup.test create mode 100644 parser/testdata/corpus/sql/types/nested/array/array_simple.test create mode 100644 parser/testdata/corpus/sql/types/nested/array/array_statistics.test create mode 100644 parser/testdata/corpus/sql/types/nested/array/array_storage_3.test create mode 100644 parser/testdata/corpus/sql/types/nested/array/array_summarize.test create mode 100644 parser/testdata/corpus/sql/types/nested/array/array_try_cast.test create mode 100644 parser/testdata/corpus/sql/types/nested/array/array_try_cast_vector_types.test create mode 100644 parser/testdata/corpus/sql/types/nested/array/array_tupleformat.test create mode 100644 parser/testdata/corpus/sql/types/nested/array/array_unnest.test create mode 100644 parser/testdata/corpus/sql/types/nested/list/any_list.test create mode 100644 parser/testdata/corpus/sql/types/nested/list/array.test create mode 100644 parser/testdata/corpus/sql/types/nested/list/array_agg.test create mode 100644 parser/testdata/corpus/sql/types/nested/list/internal_issue_2457.test create mode 100644 parser/testdata/corpus/sql/types/nested/list/list_aggr_parameter.test create mode 100644 parser/testdata/corpus/sql/types/nested/list/list_aggregate_dict.test create mode 100644 parser/testdata/corpus/sql/types/nested/list/list_aggregates.test create mode 100644 parser/testdata/corpus/sql/types/nested/list/list_subquery.test create mode 100644 parser/testdata/corpus/sql/types/nested/list/test_list_extract.test create mode 100644 parser/testdata/corpus/sql/types/nested/list/test_list_functions_with_null_structs.test create mode 100644 parser/testdata/corpus/sql/types/nested/list/test_list_index.test create mode 100644 parser/testdata/corpus/sql/types/nested/list/test_list_slice.test create mode 100644 parser/testdata/corpus/sql/types/nested/list/test_list_slice_negative_step.test create mode 100644 parser/testdata/corpus/sql/types/nested/list/test_list_slice_numeric_limits.test create mode 100644 parser/testdata/corpus/sql/types/nested/list/test_list_slice_step.test create mode 100644 parser/testdata/corpus/sql/types/nested/list/test_nested_list.test create mode 100644 parser/testdata/corpus/sql/types/nested/list/test_scalar_list.test create mode 100644 parser/testdata/corpus/sql/types/nested/map/map_error.test create mode 100644 parser/testdata/corpus/sql/types/nested/map/map_from_entries/column.test create mode 100644 parser/testdata/corpus/sql/types/nested/map/map_from_entries/column_null_entry.test create mode 100644 parser/testdata/corpus/sql/types/nested/map/map_from_entries/data_types.test create mode 100644 parser/testdata/corpus/sql/types/nested/map/map_from_entries/dictionary_vector.test create mode 100644 parser/testdata/corpus/sql/types/nested/map/map_from_entries/empty.test create mode 100644 parser/testdata/corpus/sql/types/nested/map/map_from_entries/invalid.test create mode 100644 parser/testdata/corpus/sql/types/nested/map/map_from_entries/nested.test create mode 100644 parser/testdata/corpus/sql/types/nested/map/map_from_entries/null.test create mode 100644 parser/testdata/corpus/sql/types/nested/map/map_from_entries/null_entry.test create mode 100644 parser/testdata/corpus/sql/types/nested/map/test_map.test create mode 100644 parser/testdata/corpus/sql/types/nested/map/test_map_and_lambdas.test create mode 100644 parser/testdata/corpus/sql/types/nested/map/test_map_cardinality.test create mode 100644 parser/testdata/corpus/sql/types/nested/map/test_map_concat.test create mode 100644 parser/testdata/corpus/sql/types/nested/map/test_map_constant.test create mode 100644 parser/testdata/corpus/sql/types/nested/map/test_map_contains.test create mode 100644 parser/testdata/corpus/sql/types/nested/map/test_map_entries.test create mode 100644 parser/testdata/corpus/sql/types/nested/map/test_map_keys.test create mode 100644 parser/testdata/corpus/sql/types/nested/map/test_map_nested_keys.test create mode 100644 parser/testdata/corpus/sql/types/nested/map/test_map_subscript.test create mode 100644 parser/testdata/corpus/sql/types/nested/map/test_map_subscript_composite.test create mode 100644 parser/testdata/corpus/sql/types/nested/map/test_map_subscript_from_column.test create mode 100644 parser/testdata/corpus/sql/types/nested/map/test_map_subscript_vector_types.test create mode 100644 parser/testdata/corpus/sql/types/nested/map/test_map_subscript_where.test create mode 100644 parser/testdata/corpus/sql/types/nested/map/test_map_values.test create mode 100644 parser/testdata/corpus/sql/types/nested/map/test_map_vector_types.test create mode 100644 parser/testdata/corpus/sql/types/nested/map/test_null_map_interaction.test create mode 100644 parser/testdata/corpus/sql/types/nested/nested_nested_types.test create mode 100644 parser/testdata/corpus/sql/types/nested/struct/struct_aggregates.test create mode 100644 parser/testdata/corpus/sql/types/nested/struct/struct_aggregates_types.test create mode 100644 parser/testdata/corpus/sql/types/nested/struct/struct_dict.test create mode 100644 parser/testdata/corpus/sql/types/nested/struct/struct_is_null.test create mode 100644 parser/testdata/corpus/sql/types/nested/struct/struct_of_lists_where.test create mode 100644 parser/testdata/corpus/sql/types/nested/struct/struct_subquery.test create mode 100644 parser/testdata/corpus/sql/types/nested/struct/test_struct.test create mode 100644 parser/testdata/corpus/sql/types/nested/struct/test_struct_keys.test create mode 100644 parser/testdata/corpus/sql/types/nested/struct/test_struct_values.test create mode 100644 parser/testdata/corpus/sql/types/nested/unnest_range_plan.test create mode 100644 parser/testdata/corpus/sql/types/null/test_boolean_null.test create mode 100644 parser/testdata/corpus/sql/types/null/test_is_null.test create mode 100644 parser/testdata/corpus/sql/types/null/test_null.test create mode 100644 parser/testdata/corpus/sql/types/null/test_null_aggr.test create mode 100644 parser/testdata/corpus/sql/types/null/test_null_cast.test create mode 100644 parser/testdata/corpus/sql/types/numeric/arithmetic_vector_types.test create mode 100644 parser/testdata/corpus/sql/types/numeric/bigint_try_cast.test create mode 100644 parser/testdata/corpus/sql/types/numeric/bool_casts.test create mode 100644 parser/testdata/corpus/sql/types/numeric/combinations/decimal_combinations.test create mode 100644 parser/testdata/corpus/sql/types/numeric/combinations/usmallint_combinations.test create mode 100644 parser/testdata/corpus/sql/types/numeric/combinations/utinyint_combinations.test create mode 100644 parser/testdata/corpus/sql/types/numeric/hugeint_try_cast.test create mode 100644 parser/testdata/corpus/sql/types/numeric/integer_try_cast.test create mode 100644 parser/testdata/corpus/sql/types/numeric/smallint_try_cast.test create mode 100644 parser/testdata/corpus/sql/types/numeric/test_empty_numeric.test create mode 100644 parser/testdata/corpus/sql/types/numeric/tinyint_try_cast.test create mode 100644 parser/testdata/corpus/sql/types/numeric/ubigint_arithmetic_casting.test create mode 100644 parser/testdata/corpus/sql/types/numeric/ubigint_try_cast.test create mode 100644 parser/testdata/corpus/sql/types/numeric/uhugeint_try_cast.test create mode 100644 parser/testdata/corpus/sql/types/numeric/uinteger_try_cast.test create mode 100644 parser/testdata/corpus/sql/types/numeric/usmallint_try_cast.test create mode 100644 parser/testdata/corpus/sql/types/numeric/utinyint_try_cast.test create mode 100644 parser/testdata/corpus/sql/types/string/test_big_strings.test create mode 100644 parser/testdata/corpus/sql/types/string/test_unicode.test create mode 100644 parser/testdata/corpus/sql/types/struct/create_qualified_type_array.test create mode 100644 parser/testdata/corpus/sql/types/struct/create_type_struct.test create mode 100644 parser/testdata/corpus/sql/types/struct/empty_struct.test create mode 100644 parser/testdata/corpus/sql/types/struct/inet_struct_comparison.test create mode 100644 parser/testdata/corpus/sql/types/struct/nested_struct_projection_pushdown.test create mode 100644 parser/testdata/corpus/sql/types/struct/nested_structs.test create mode 100644 parser/testdata/corpus/sql/types/struct/remap_struct.test create mode 100644 parser/testdata/corpus/sql/types/struct/remap_struct_in_list.test create mode 100644 parser/testdata/corpus/sql/types/struct/remap_struct_in_map.test create mode 100644 parser/testdata/corpus/sql/types/struct/remap_struct_list_source_name.test create mode 100644 parser/testdata/corpus/sql/types/struct/remap_struct_size.test create mode 100644 parser/testdata/corpus/sql/types/struct/struct_case.test create mode 100644 parser/testdata/corpus/sql/types/struct/struct_case_insensitivity.test create mode 100644 parser/testdata/corpus/sql/types/struct/struct_cast.test create mode 100644 parser/testdata/corpus/sql/types/struct/struct_cast_superset.test create mode 100644 parser/testdata/corpus/sql/types/struct/struct_comparison.test create mode 100644 parser/testdata/corpus/sql/types/struct/struct_concat.test create mode 100644 parser/testdata/corpus/sql/types/struct/struct_contains.test create mode 100644 parser/testdata/corpus/sql/types/struct/struct_cross_product.test create mode 100644 parser/testdata/corpus/sql/types/struct/struct_different_names.test create mode 100644 parser/testdata/corpus/sql/types/struct/struct_distinct.test create mode 100644 parser/testdata/corpus/sql/types/struct/struct_equality_bug.test create mode 100644 parser/testdata/corpus/sql/types/struct/struct_index.test create mode 100644 parser/testdata/corpus/sql/types/struct/struct_named_cast.test create mode 100644 parser/testdata/corpus/sql/types/struct/struct_null_members.test create mode 100644 parser/testdata/corpus/sql/types/struct/struct_operations.test create mode 100644 parser/testdata/corpus/sql/types/struct/struct_pack_list.test create mode 100644 parser/testdata/corpus/sql/types/struct/struct_position.test create mode 100644 parser/testdata/corpus/sql/types/struct/struct_projection_pushdown.test create mode 100644 parser/testdata/corpus/sql/types/struct/struct_projection_pushdown_in_storage.test create mode 100644 parser/testdata/corpus/sql/types/struct/struct_projection_pushdown_optimizer_bug.test create mode 100644 parser/testdata/corpus/sql/types/struct/struct_projection_pushdown_unnamed.test create mode 100644 parser/testdata/corpus/sql/types/struct/struct_stats.test create mode 100644 parser/testdata/corpus/sql/types/struct/struct_subquery.test create mode 100644 parser/testdata/corpus/sql/types/struct/struct_tables.test create mode 100644 parser/testdata/corpus/sql/types/struct/struct_unnest_recursion.test create mode 100644 parser/testdata/corpus/sql/types/struct/struct_updates.test create mode 100644 parser/testdata/corpus/sql/types/struct/test_tuple.test create mode 100644 parser/testdata/corpus/sql/types/struct/unnamed_struct_casts.test create mode 100644 parser/testdata/corpus/sql/types/struct/unnamed_struct_comparison.test create mode 100644 parser/testdata/corpus/sql/types/struct/unnamed_struct_mix.test create mode 100644 parser/testdata/corpus/sql/types/struct/unnest_column_names.test create mode 100644 parser/testdata/corpus/sql/types/struct/unnest_struct.test create mode 100644 parser/testdata/corpus/sql/types/struct/unnest_struct_mix.test create mode 100644 parser/testdata/corpus/sql/types/struct/unnest_struct_subquery.test create mode 100644 parser/testdata/corpus/sql/types/struct/update_empty_row.test create mode 100644 parser/testdata/corpus/sql/types/struct/update_empty_row.test.metadata.json create mode 100644 parser/testdata/corpus/sql/types/test_date_cast.test create mode 100644 parser/testdata/corpus/sql/types/test_null_type.test create mode 100644 parser/testdata/corpus/sql/types/test_qualified_type_cast.test create mode 100644 parser/testdata/corpus/sql/types/test_quotes.test create mode 100644 parser/testdata/corpus/sql/types/test_typeof.test create mode 100644 parser/testdata/corpus/sql/types/test_user_type_errors_18452.test create mode 100644 parser/testdata/corpus/sql/types/test_user_type_errors_18452.test.metadata.json create mode 100644 parser/testdata/corpus/sql/types/time/test_time.test create mode 100644 parser/testdata/corpus/sql/types/time/test_time_2411.test create mode 100644 parser/testdata/corpus/sql/types/time/test_time_ns.test create mode 100644 parser/testdata/corpus/sql/types/time/test_time_tz.test create mode 100644 parser/testdata/corpus/sql/types/time/test_time_tz_collate.test create mode 100644 parser/testdata/corpus/sql/types/time/test_time_tz_icu.test create mode 100644 parser/testdata/corpus/sql/types/time/time_limits.test create mode 100644 parser/testdata/corpus/sql/types/time/time_parsing.test create mode 100644 parser/testdata/corpus/sql/types/time/time_try_cast.test create mode 100644 parser/testdata/corpus/sql/types/timestamp/alternative_timestamp_casts.test create mode 100644 parser/testdata/corpus/sql/types/timestamp/bc_timestamp.test create mode 100644 parser/testdata/corpus/sql/types/timestamp/infinity_cast_coverage.test create mode 100644 parser/testdata/corpus/sql/types/timestamp/test_incorrect_timestamp.test create mode 100644 parser/testdata/corpus/sql/types/timestamp/test_infinite_time.test create mode 100644 parser/testdata/corpus/sql/types/timestamp/test_timestamp.test create mode 100644 parser/testdata/corpus/sql/types/timestamp/test_timestamp_2411.test create mode 100644 parser/testdata/corpus/sql/types/timestamp/test_timestamp_auto_casting.test create mode 100644 parser/testdata/corpus/sql/types/timestamp/test_timestamp_ms.test create mode 100644 parser/testdata/corpus/sql/types/timestamp/test_timestamp_to_tz_cast.test create mode 100644 parser/testdata/corpus/sql/types/timestamp/test_timestamp_types.test create mode 100644 parser/testdata/corpus/sql/types/timestamp/test_timestamp_tz.test create mode 100644 parser/testdata/corpus/sql/types/timestamp/timestamp_limits.test create mode 100644 parser/testdata/corpus/sql/types/timestamp/timestamp_precision.test create mode 100644 parser/testdata/corpus/sql/types/timestamp/timestamp_precision.test.metadata.json create mode 100644 parser/testdata/corpus/sql/types/timestamp/timestamp_timezone_cast.test create mode 100644 parser/testdata/corpus/sql/types/timestamp/timestamp_try_cast.test create mode 100644 parser/testdata/corpus/sql/types/timestamp/utc_offset.test create mode 100644 parser/testdata/corpus/sql/types/type/test_make_get_type.test create mode 100644 parser/testdata/corpus/sql/types/type/test_type_storage.test create mode 100644 parser/testdata/corpus/sql/types/type_literal.test create mode 100644 parser/testdata/corpus/sql/types/uhugeint/test_uhugeint_aggregates.test create mode 100644 parser/testdata/corpus/sql/types/uhugeint/test_uhugeint_arithmetic.test create mode 100644 parser/testdata/corpus/sql/types/uhugeint/test_uhugeint_auto_cast.test create mode 100644 parser/testdata/corpus/sql/types/uhugeint/test_uhugeint_conversion.test create mode 100644 parser/testdata/corpus/sql/types/uhugeint/test_uhugeint_exponent.test create mode 100644 parser/testdata/corpus/sql/types/uhugeint/test_uhugeint_functions.test create mode 100644 parser/testdata/corpus/sql/types/uhugeint/test_uhugeint_null_value.test create mode 100644 parser/testdata/corpus/sql/types/uhugeint/test_uhugeint_ops.test create mode 100644 parser/testdata/corpus/sql/types/uhugeint/uhugeint_literal.test create mode 100644 parser/testdata/corpus/sql/types/uhugeint/uhugeint_multiply.test create mode 100644 parser/testdata/corpus/sql/types/uhugeint/uhugeint_try_cast.test create mode 100644 parser/testdata/corpus/sql/types/union/struct_to_json_union.test create mode 100644 parser/testdata/corpus/sql/types/union/struct_to_union.test create mode 100644 parser/testdata/corpus/sql/types/union/union_aggregate.test create mode 100644 parser/testdata/corpus/sql/types/union/union_ambiguous.test create mode 100644 parser/testdata/corpus/sql/types/union/union_cast.test create mode 100644 parser/testdata/corpus/sql/types/union/union_compare.test create mode 100644 parser/testdata/corpus/sql/types/union/union_extract.test create mode 100644 parser/testdata/corpus/sql/types/union/union_join.test create mode 100644 parser/testdata/corpus/sql/types/union/union_limit_offset.test create mode 100644 parser/testdata/corpus/sql/types/union/union_limits.test create mode 100644 parser/testdata/corpus/sql/types/union/union_list.test create mode 100644 parser/testdata/corpus/sql/types/union/union_sort.test create mode 100644 parser/testdata/corpus/sql/types/union/union_struct.test create mode 100644 parser/testdata/corpus/sql/types/union/union_tag.test create mode 100644 parser/testdata/corpus/sql/types/union/union_test.test create mode 100644 parser/testdata/corpus/sql/types/union/union_validity.test create mode 100644 parser/testdata/corpus/sql/types/union/union_value.test create mode 100644 parser/testdata/corpus/sql/types/unsigned/test_unsigned_arithmetic.test create mode 100644 parser/testdata/corpus/sql/types/unsigned/test_unsigned_auto_cast.test create mode 100644 parser/testdata/corpus/sql/types/unsigned/test_unsigned_conversion.test create mode 100644 parser/testdata/corpus/sql/types/unsigned/test_unsigned_verify.test create mode 100644 parser/testdata/corpus/sql/types/uuid/test_uuid_cast.test create mode 100644 parser/testdata/corpus/sql/types/uuid/test_uuid_uhugeint_cast.test create mode 100644 parser/testdata/corpus/sql/types/variant/implicit_cast_from_variant.test create mode 100644 parser/testdata/corpus/sql/types/variant/json_cast.test create mode 100644 parser/testdata/corpus/sql/types/variant/test_all_types.test create mode 100644 parser/testdata/corpus/sql/types/variant/tpch_test.test create mode 100644 parser/testdata/corpus/sql/types/variant/tpch_test_through_json.test create mode 100644 parser/testdata/corpus/sql/types/variant/try_cast_from_variant.test create mode 100644 parser/testdata/corpus/sql/types/variant/variant_cast_stats.test create mode 100644 parser/testdata/corpus/sql/types/variant/variant_casts.test create mode 100644 parser/testdata/corpus/sql/types/variant/variant_distinct.test create mode 100644 parser/testdata/corpus/sql/types/variant/variant_map_to_variant_filter.test create mode 100644 parser/testdata/corpus/sql/update/compact_update_allocation.test create mode 100644 parser/testdata/corpus/sql/update/force_update_to_del_and_insert.test create mode 100644 parser/testdata/corpus/sql/update/issue_22392.test create mode 100644 parser/testdata/corpus/sql/update/null_update_merge.test create mode 100644 parser/testdata/corpus/sql/update/null_update_merge_transaction.test create mode 100644 parser/testdata/corpus/sql/update/string_update_null_heap.test create mode 100644 parser/testdata/corpus/sql/update/string_update_transaction_local_7348.test create mode 100644 parser/testdata/corpus/sql/update/test_big_string_update.test create mode 100644 parser/testdata/corpus/sql/update/test_cascading_updates.test create mode 100644 parser/testdata/corpus/sql/update/test_multiple_assignment.test create mode 100644 parser/testdata/corpus/sql/update/test_multiple_assignment.test.metadata.json create mode 100644 parser/testdata/corpus/sql/update/test_null_update.test create mode 100644 parser/testdata/corpus/sql/update/test_repeated_string_update.test create mode 100644 parser/testdata/corpus/sql/update/test_stress_update_issue_19688.test create mode 100644 parser/testdata/corpus/sql/update/test_string_update.test create mode 100644 parser/testdata/corpus/sql/update/test_string_update_many_strings.test create mode 100644 parser/testdata/corpus/sql/update/test_string_update_null.test create mode 100644 parser/testdata/corpus/sql/update/test_string_update_rollback.test create mode 100644 parser/testdata/corpus/sql/update/test_string_update_rollback_null.test create mode 100644 parser/testdata/corpus/sql/update/test_update.test create mode 100644 parser/testdata/corpus/sql/update/test_update_delete_same_tuple.test create mode 100644 parser/testdata/corpus/sql/update/test_update_from.test create mode 100644 parser/testdata/corpus/sql/update/test_update_issue_3170.test create mode 100644 parser/testdata/corpus/sql/update/test_update_many_updaters.test create mode 100644 parser/testdata/corpus/sql/update/test_update_many_updaters_nulls.test create mode 100644 parser/testdata/corpus/sql/update/test_update_mix.test create mode 100644 parser/testdata/corpus/sql/update/test_update_same_value.test create mode 100644 parser/testdata/corpus/sql/update/test_update_with_non_regular_type.test create mode 100644 parser/testdata/corpus/sql/update/update_after_commit.test create mode 100644 parser/testdata/corpus/sql/update/update_default.test create mode 100644 parser/testdata/corpus/sql/update/update_delete_wal.test create mode 100644 parser/testdata/corpus/sql/update/update_error_suggestions.test create mode 100644 parser/testdata/corpus/sql/update/update_error_suggestions.test.metadata.json create mode 100644 parser/testdata/corpus/sql/update/update_from_multi_match.test create mode 100644 parser/testdata/corpus/sql/update/update_join_nulls.test create mode 100644 parser/testdata/corpus/sql/update/update_null_integers.test create mode 100644 parser/testdata/corpus/sql/update/update_query_node.test create mode 100644 parser/testdata/corpus/sql/update/update_string_null_merge_dict_fsst.test create mode 100644 parser/testdata/corpus/sql/upsert/concurrent_insert_or_replace.test create mode 100644 parser/testdata/corpus/sql/upsert/insert_or_replace/issue_20952_non_pk_index_column.test create mode 100644 parser/testdata/corpus/sql/upsert/insert_or_replace/pk_and_non_unique_index.test create mode 100644 parser/testdata/corpus/sql/upsert/insert_or_replace/returning.test create mode 100644 parser/testdata/corpus/sql/upsert/insert_or_replace/returning_nothing.test create mode 100644 parser/testdata/corpus/sql/upsert/insert_or_replace/unique_and_non_unique_index.test create mode 100644 parser/testdata/corpus/sql/upsert/insert_or_replace/unique_constraint.test create mode 100644 parser/testdata/corpus/sql/upsert/insert_or_replace/unique_index.test create mode 100644 parser/testdata/corpus/sql/upsert/minimal_reproducable_example.test create mode 100644 parser/testdata/corpus/sql/upsert/no_complex_default.test create mode 100644 parser/testdata/corpus/sql/upsert/postgres/composite_key.test create mode 100644 parser/testdata/corpus/sql/upsert/postgres/non_spurious_duplicate_violation.test create mode 100644 parser/testdata/corpus/sql/upsert/postgres/planner_preprocessing.test create mode 100644 parser/testdata/corpus/sql/upsert/postgres/single_key.test create mode 100644 parser/testdata/corpus/sql/upsert/test_big_insert.test create mode 100644 parser/testdata/corpus/sql/upsert/test_big_insert_no_vector_verification.test create mode 100644 parser/testdata/corpus/sql/upsert/test_generated_column.test create mode 100644 parser/testdata/corpus/sql/upsert/test_problematic_conditional_do_update.test create mode 100644 parser/testdata/corpus/sql/upsert/upsert_aliased.test create mode 100644 parser/testdata/corpus/sql/upsert/upsert_basic.test create mode 100644 parser/testdata/corpus/sql/upsert/upsert_conflict_target.test create mode 100644 parser/testdata/corpus/sql/upsert/upsert_conflict_target_index.test create mode 100644 parser/testdata/corpus/sql/upsert/upsert_coverage.test create mode 100644 parser/testdata/corpus/sql/upsert/upsert_default.test create mode 100644 parser/testdata/corpus/sql/upsert/upsert_default_expressions.test create mode 100644 parser/testdata/corpus/sql/upsert/upsert_default_value_causes_conflict.test create mode 100644 parser/testdata/corpus/sql/upsert/upsert_default_values.test create mode 100644 parser/testdata/corpus/sql/upsert/upsert_distinct_bug.test create mode 100644 parser/testdata/corpus/sql/upsert/upsert_duplicates_issue.test create mode 100644 parser/testdata/corpus/sql/upsert/upsert_excluded_references.test create mode 100644 parser/testdata/corpus/sql/upsert/upsert_explicit_index.test create mode 100644 parser/testdata/corpus/sql/upsert/upsert_global_mixed_conflicts.test create mode 100644 parser/testdata/corpus/sql/upsert/upsert_inner_conflict_do_nothing.test create mode 100644 parser/testdata/corpus/sql/upsert/upsert_lambda.test create mode 100644 parser/testdata/corpus/sql/upsert/upsert_local_no_tuples.test create mode 100644 parser/testdata/corpus/sql/upsert/upsert_multiple_constraints.test create mode 100644 parser/testdata/corpus/sql/upsert/upsert_order_coverage.test create mode 100644 parser/testdata/corpus/sql/upsert/upsert_partial_update.test create mode 100644 parser/testdata/corpus/sql/upsert/upsert_returning.test create mode 100644 parser/testdata/corpus/sql/upsert/upsert_set_expressions.test create mode 100644 parser/testdata/corpus/sql/upsert/upsert_shorthand.test create mode 100644 parser/testdata/corpus/sql/upsert/upsert_shorthand.test.metadata.json create mode 100644 parser/testdata/corpus/sql/upsert/upsert_transaction.test create mode 100644 parser/testdata/corpus/sql/upsert/upsert_unique_null.test create mode 100644 parser/testdata/corpus/sql/vacuum/test_analyze.test create mode 100644 parser/testdata/corpus/sql/vacuum/vacuum_nested_types.test create mode 100644 parser/testdata/corpus/sql/variables/test_variable_syntax.test create mode 100644 parser/testdata/corpus/sql/variables/test_variables.test create mode 100644 parser/testdata/corpus/sql/variant/variant_comparator.test create mode 100644 parser/testdata/corpus/sql/vector_types/list_vector_types.test create mode 100644 parser/testdata/corpus/sql/vector_types/vector_types_errors.test create mode 100644 parser/testdata/corpus/sql/window/test_basic_window.test create mode 100644 parser/testdata/corpus/sql/window/test_boundary_expr.test create mode 100644 parser/testdata/corpus/sql/window/test_constant_orderby.test create mode 100644 parser/testdata/corpus/sql/window/test_cume_dist_orderby.test create mode 100644 parser/testdata/corpus/sql/window/test_dense_rank.test create mode 100644 parser/testdata/corpus/sql/window/test_duplicate_partition.test create mode 100644 parser/testdata/corpus/sql/window/test_empty_frames.test create mode 100644 parser/testdata/corpus/sql/window/test_evil_window.test create mode 100644 parser/testdata/corpus/sql/window/test_fill_orderby.test create mode 100644 parser/testdata/corpus/sql/window/test_ignore_nulls.test create mode 100644 parser/testdata/corpus/sql/window/test_invalid_window.test create mode 100644 parser/testdata/corpus/sql/window/test_invalid_window.test.metadata.json create mode 100644 parser/testdata/corpus/sql/window/test_lead_lag.test create mode 100644 parser/testdata/corpus/sql/window/test_leadlag_orderby.test create mode 100644 parser/testdata/corpus/sql/window/test_list_window.test create mode 100644 parser/testdata/corpus/sql/window/test_mad_window.test create mode 100644 parser/testdata/corpus/sql/window/test_mode_window.test create mode 100644 parser/testdata/corpus/sql/window/test_naive_aggregation.test create mode 100644 parser/testdata/corpus/sql/window/test_negative_range.test create mode 100644 parser/testdata/corpus/sql/window/test_no_default_window_spec.test create mode 100644 parser/testdata/corpus/sql/window/test_nthvalue.test create mode 100644 parser/testdata/corpus/sql/window/test_ntile.test create mode 100644 parser/testdata/corpus/sql/window/test_order_by_all.test create mode 100644 parser/testdata/corpus/sql/window/test_order_by_all.test.metadata.json create mode 100644 parser/testdata/corpus/sql/window/test_quantile_window.test create mode 100644 parser/testdata/corpus/sql/window/test_range_optimisation.test create mode 100644 parser/testdata/corpus/sql/window/test_rank.test create mode 100644 parser/testdata/corpus/sql/window/test_rank_orderby.test create mode 100644 parser/testdata/corpus/sql/window/test_rownumber_orderby.test create mode 100644 parser/testdata/corpus/sql/window/test_scalar_window.test create mode 100644 parser/testdata/corpus/sql/window/test_scalar_window.test.metadata.json create mode 100644 parser/testdata/corpus/sql/window/test_split_partition_heap.test create mode 100644 parser/testdata/corpus/sql/window/test_streaming_lead_lag.test create mode 100644 parser/testdata/corpus/sql/window/test_streaming_nthvalue.test create mode 100644 parser/testdata/corpus/sql/window/test_streaming_window.test create mode 100644 parser/testdata/corpus/sql/window/test_streaming_window_distinct.test create mode 100644 parser/testdata/corpus/sql/window/test_thread_count.test create mode 100644 parser/testdata/corpus/sql/window/test_tpcc_results.test create mode 100644 parser/testdata/corpus/sql/window/test_tpcds_q49.test create mode 100644 parser/testdata/corpus/sql/window/test_value_exclude.test create mode 100644 parser/testdata/corpus/sql/window/test_value_orderby.test create mode 100644 parser/testdata/corpus/sql/window/test_volatile_independence.test create mode 100644 parser/testdata/corpus/sql/window/test_wide_orderby.test create mode 100644 parser/testdata/corpus/sql/window/test_window_aggregate_macro.test create mode 100644 parser/testdata/corpus/sql/window/test_window_binding.test create mode 100644 parser/testdata/corpus/sql/window/test_window_binding_ctes.test create mode 100644 parser/testdata/corpus/sql/window/test_window_binding_ctes.test.metadata.json create mode 100644 parser/testdata/corpus/sql/window/test_window_bool.test create mode 100644 parser/testdata/corpus/sql/window/test_window_clause.test create mode 100644 parser/testdata/corpus/sql/window/test_window_clause.test.metadata.json create mode 100644 parser/testdata/corpus/sql/window/test_window_constant_aggregate.test create mode 100644 parser/testdata/corpus/sql/window/test_window_constant_allocator.test create mode 100644 parser/testdata/corpus/sql/window/test_window_cse.test create mode 100644 parser/testdata/corpus/sql/window/test_window_dbplyr.test create mode 100644 parser/testdata/corpus/sql/window/test_window_distinct.test create mode 100644 parser/testdata/corpus/sql/window/test_window_filter.test create mode 100644 parser/testdata/corpus/sql/window/test_window_finalize_race.test create mode 100644 parser/testdata/corpus/sql/window/test_window_fusion.test create mode 100644 parser/testdata/corpus/sql/window/test_window_interval.test create mode 100644 parser/testdata/corpus/sql/window/test_window_order_collate.test create mode 100644 parser/testdata/corpus/sql/window/test_window_rows.test create mode 100644 parser/testdata/corpus/sql/window/test_window_string_agg.test create mode 100644 parser/testdata/corpus/sql/window/test_window_tpcds.test create mode 100644 parser/testdata/corpus/sql/window/test_window_types.test create mode 100644 parser/testdata/corpus/sql/window/test_window_unnest_error.test create mode 100644 parser/testdata/corpus/sql/window/test_window_wisconsin.test create mode 100644 parser/testdata/corpus/sql/window/window_mtcars.test diff --git a/.gitignore b/.gitignore new file mode 100644 index 0000000..d991716 --- /dev/null +++ b/.gitignore @@ -0,0 +1,4 @@ +duckdb +*.db +*.db.wal +*.zip diff --git a/CLAUDE.md b/CLAUDE.md index 16165d8..955a76c 100644 --- a/CLAUDE.md +++ b/CLAUDE.md @@ -18,6 +18,19 @@ in `internal/grammar/README.md`. `parser_packrat.cpp` and `matcher/*.hpp`. - `cmd/debug-parse/` — dump tokens or the raw `ParseResult` tree for SQL passed on the command line. +- `internal/sqltest/` — sqllogictest `.test` reader (statement extraction + only; template substitutions are skipped, never expanded). +- `internal/testfile/` — corpus storage format (cases separated by `==`, + SQL/expectation separated by `--`) plus `*.metadata.json` todo/skip + sidecars keyed by case content hash. +- `internal/duckdbsrc/` — the pinned DuckDB CLI (oracle): locate, verify + version against the pin, run statements against `:memory:` and classify + Parser Error vs post-parse. +- `cmd/regenerate/` — rebuild `parser/testdata/` from a DuckDB source tree + + the pinned binary. The only way corpus expectations change. +- `cmd/next-test/` — print the next todo case from the corpus metadata. +- `parser/` — corpus conformance harness (`parser_test.go`); the public + Parse API and AST arrive in milestone 3. ## Rules of the port @@ -45,5 +58,29 @@ go run ./cmd/debug-parse 'SELECT 1' # ParseResult tree go run ./cmd/debug-parse -tokens 'SELECT 1' # token dump ``` -Corpus tooling (`cmd/next-test`, `cmd/regenerate`, `-check-parse`) arrives in -milestone 2; until then upstream-transcribed unit tests are the safety net. +## Conformance loop + +The milestone-2 gate: darkwing accepts a statement iff the pinned DuckDB +binary parses it, over the whole corpus (`go test ./parser`). + +``` +go run ./cmd/next-test # pick the next todo case +go test ./parser -run TestCorpus -check-parse 'FRAGMENT' # dump detail for it +# ...fix the engine... +go test ./parser # gate +``` + +Some oracle rejects come from upstream's *transformer* (Parser Errors whose +message is not "syntax error at or near ..."): the matcher alone cannot +reject those, so they stay in todo metadata until the matching transformer +lands (milestones 3-5). Todo entries carry a note saying why. + +Regenerating the corpus (needs a DuckDB checkout at the pinned commit and +the matching nightly CLI; see `internal/grammar/README.md` for the pin): + +``` +DARKWING_DUCKDB=/path/to/duckdb-cli \ + go run ./cmd/regenerate -duckdb-src /path/to/duckdb +``` + +Never commit binaries (the CLI, *.db files) — only source and corpus text. diff --git a/README.md b/README.md index 30c7a3b..7939a27 100644 --- a/README.md +++ b/README.md @@ -20,6 +20,12 @@ loader, and matcher (with packrat memoization) — to Go. ## Status +Milestone 2 (corpus + accept/reject conformance) is in place: the corpus +under `parser/testdata/` is extracted from DuckDB's own test suite and +classified by the pinned DuckDB CLI (`cmd/regenerate`); `go test ./parser` +enforces *darkwing accepts iff pinned DuckDB parses*, with remaining +disagreements tracked in todo metadata (`cmd/next-test`). + Milestone 1 (engine) is complete: - `token/` — token kinds and DuckDB's keyword categories @@ -31,8 +37,7 @@ Milestone 1 (engine) is complete: - `cmd/debug-parse` — dump tokens or the raw parse tree for SQL on the command line -Next: corpus extraction and the accept/reject conformance gate against a -pinned DuckDB binary (milestone 2), then the AST and transformers. +Next: the typed AST and transformer core (milestone 3). ``` $ go run ./cmd/debug-parse 'SELECT 1' diff --git a/cmd/next-test/main.go b/cmd/next-test/main.go new file mode 100644 index 0000000..31d5977 --- /dev/null +++ b/cmd/next-test/main.go @@ -0,0 +1,86 @@ +// Command next-test picks the next todo case from the conformance corpus: +// the dev loop is next-test -> implement -> `go test ./parser +// -check-parse ''` (see CLAUDE.md). +// +// Usage: +// +// next-test [-testdata parser/testdata] [-all] +package main + +import ( + "flag" + "fmt" + "io/fs" + "log" + "os" + "path/filepath" + "sort" + "strings" + + "github.com/sqlc-dev/darkwing/internal/testfile" +) + +func main() { + log.SetFlags(0) + testdata := flag.String("testdata", "parser/testdata", "testdata directory") + all := flag.Bool("all", false, "list every todo case instead of just the first") + flag.Parse() + + root := filepath.Join(*testdata, "corpus") + var paths []string + err := filepath.WalkDir(root, func(path string, d fs.DirEntry, err error) error { + if err != nil { + return err + } + if !d.IsDir() && strings.HasSuffix(path, ".test") { + paths = append(paths, path) + } + return nil + }) + if err != nil { + log.Fatalf("error: %v", err) + } + sort.Strings(paths) + + total := 0 + for _, path := range paths { + meta, err := testfile.ReadMetadata(path) + if err != nil { + log.Fatalf("error: %v", err) + } + if len(meta.Todo) == 0 { + continue + } + file, err := testfile.Read(path) + if err != nil { + log.Fatalf("error: %v", err) + } + byKey := make(map[string]*testfile.Case) + for i := range file.Cases { + byKey[file.Cases[i].Key()] = &file.Cases[i] + } + for _, key := range testfile.SortKeys(meta.Todo) { + c, ok := byKey[key] + if !ok { + continue + } + total++ + want := "accept" + if c.Reject { + want = "reject: " + c.Error + } + fmt.Printf("%s\ncase: %s (%s)\nwant: %s\nsql:\n%s\n\n", path, key, meta.Todo[key], want, c.SQL) + if !*all { + return + } + } + } + if total == 0 { + fmt.Println("no todo cases - the corpus gate is green") + return + } + if *all { + fmt.Printf("%d todo cases\n", total) + } + os.Exit(0) +} diff --git a/cmd/regenerate/main.go b/cmd/regenerate/main.go new file mode 100644 index 0000000..868fd2a --- /dev/null +++ b/cmd/regenerate/main.go @@ -0,0 +1,287 @@ +// Command regenerate rebuilds darkwing's conformance corpus from a DuckDB +// source tree and the pinned DuckDB CLI binary: it extracts every SQL +// statement from test/sql/**/*.test and test/fuzzer/**/*.test, asks the +// pinned binary for an accept/reject verdict (Parser Error => reject; +// success or any post-parse error => accept), and writes the meyer-style +// corpus under parser/testdata/corpus/. Expected outputs are never edited +// by hand — rerun this command instead. +// +// Usage: +// +// regenerate -duckdb-src /path/to/duckdb [-binary /path/to/duckdb-cli] +// [-out parser/testdata] [-j 8] [-only substring] [-limit N] +package main + +import ( + "flag" + "fmt" + "io/fs" + "log" + "os" + "path/filepath" + "runtime" + "sort" + "strings" + "sync" + "time" + + "github.com/sqlc-dev/darkwing/internal/duckdbsrc" + "github.com/sqlc-dev/darkwing/internal/sqltest" + "github.com/sqlc-dev/darkwing/internal/testfile" +) + +// maxStatementLen bounds one corpus statement; fuzzer inputs can be huge +// and add nothing past this size. +const maxStatementLen = 32 * 1024 + +func main() { + log.SetFlags(0) + srcDir := flag.String("duckdb-src", "", "path to a DuckDB source tree at the pinned commit (required)") + binary := flag.String("binary", "", "pinned DuckDB CLI binary (default: $DARKWING_DUCKDB or duckdb on PATH)") + outDir := flag.String("out", "parser/testdata", "output directory") + workers := flag.Int("j", runtime.NumCPU()*2, "oracle worker processes") + timeout := flag.Duration("timeout", 5*time.Second, "per-statement oracle timeout") + only := flag.String("only", "", "only regenerate source files whose path contains this substring") + limit := flag.Int("limit", 0, "stop after this many unique statements (0 = no limit)") + flag.Parse() + + if *srcDir == "" { + flag.Usage() + os.Exit(2) + } + if err := run(*srcDir, *binary, *outDir, *workers, *timeout, *only, *limit); err != nil { + log.Fatalf("error: %v", err) + } +} + +type fileStatements struct { + // rel is the corpus-relative path (e.g. "sql/select/foo.test"). + rel string + stmts []string +} + +func run(srcDir, binary, outDir string, workers int, timeout time.Duration, only string, limit int) error { + if binary == "" { + b, err := duckdbsrc.Find() + if err != nil { + return err + } + binary = b + } else if err := duckdbsrc.Verify(binary); err != nil { + return err + } + + files, err := collectFiles(srcDir, only) + if err != nil { + return err + } + log.Printf("extracting from %d .test files", len(files)) + + var perFile []fileStatements + seen := make(map[string]bool) + extracted, skippedUnstorable, skippedDot, skippedLong, duplicates := 0, 0, 0, 0, 0 + for _, path := range files { + stmts, err := sqltest.ExtractFile(path) + if err != nil { + return fmt.Errorf("extracting %s: %w", path, err) + } + rel, err := filepath.Rel(filepath.Join(srcDir, "test"), path) + if err != nil { + return err + } + var kept []string + for _, stmt := range stmts { + extracted++ + sql := stmt.SQL + switch { + case len(sql) > maxStatementLen: + skippedLong++ + case !testfile.CanStore(sql): + skippedUnstorable++ + case hasDotCommandLine(sql): + skippedDot++ + case seen[sql]: + duplicates++ + default: + seen[sql] = true + kept = append(kept, sql) + } + if limit > 0 && len(seen) >= limit { + break + } + } + if len(kept) > 0 { + perFile = append(perFile, fileStatements{rel: filepath.ToSlash(rel), stmts: kept}) + } + if limit > 0 && len(seen) >= limit { + break + } + } + log.Printf("extracted %d statements: %d unique kept, %d duplicates, %d unstorable, %d dot-prefixed, %d oversized", + extracted, len(seen), duplicates, skippedUnstorable, skippedDot, skippedLong) + + verdicts, err := runOracle(binary, timeout, workers, perFile) + if err != nil { + return err + } + + corpusDir := filepath.Join(outDir, "corpus") + accepted, rejected := 0, 0 + for _, pf := range perFile { + out := testfile.File{ + Header: []string{ + "source: test/" + pf.rel, + "pin: " + duckdbsrc.PinnedCommit, + "oracle: " + duckdbsrc.PinnedVersion, + "generated by cmd/regenerate - do not edit", + }, + } + for _, sql := range pf.stmts { + v := verdicts[sql] + c := testfile.Case{SQL: sql, Reject: v.Reject, Error: v.Error} + if v.Reject { + rejected++ + } else { + accepted++ + } + out.Cases = append(out.Cases, c) + } + dest := filepath.Join(corpusDir, filepath.FromSlash(pf.rel)) + if err := os.MkdirAll(filepath.Dir(dest), 0o755); err != nil { + return err + } + if err := testfile.Write(dest, &out); err != nil { + return err + } + } + log.Printf("corpus written: %d files, %d must-accept, %d must-reject", len(perFile), accepted, rejected) + + readme := fmt.Sprintf(`# darkwing conformance corpus + +Generated by cmd/regenerate - do not edit corpus files or expectations by +hand; rerun the tool instead (see PLAN.md, § Conformance oracle and corpus). + +- Source: DuckDB test/sql/**/*.test and test/fuzzer/**/*.test +- Pinned commit: %s +- Oracle: DuckDB CLI %s (nightly build of the pinned commit) +- Files: %d, cases: %d (%d must-accept, %d must-reject) + +Classification: the oracle runs each statement against :memory: with +extension autoloading disabled. An error starting with "Parser Error" +means must-reject (first error line recorded); success or any post-parse +error (Binder, Catalog, ...) means must-accept. + +Sidecar files (*.metadata.json) carry todo/skip lists keyed by case +content hash; they are maintained by hand and survive regeneration. +`, duckdbsrc.PinnedCommit, duckdbsrc.PinnedVersion, len(perFile), accepted+rejected, accepted, rejected) + if err := os.MkdirAll(outDir, 0o755); err != nil { + return err + } + return os.WriteFile(filepath.Join(outDir, "README.md"), []byte(readme), 0o644) +} + +func collectFiles(srcDir, only string) ([]string, error) { + var files []string + for _, root := range []string{ + filepath.Join(srcDir, "test", "sql"), + filepath.Join(srcDir, "test", "fuzzer"), + } { + err := filepath.WalkDir(root, func(path string, d fs.DirEntry, err error) error { + if err != nil { + return err + } + if d.IsDir() || !strings.HasSuffix(path, ".test") { + return nil + } + if only != "" && !strings.Contains(path, only) { + return nil + } + files = append(files, path) + return nil + }) + if err != nil { + return nil, err + } + } + sort.Strings(files) + return files, nil +} + +// hasDotCommandLine reports whether any line could be taken for a CLI dot +// command when fed to the oracle (the CLI interprets a leading '.' at a +// statement boundary). +func hasDotCommandLine(sql string) bool { + for _, line := range strings.Split(sql, "\n") { + if strings.HasPrefix(line, ".") { + return true + } + } + return false +} + +func runOracle(binary string, timeout time.Duration, workers int, perFile []fileStatements) (map[string]duckdbsrc.Verdict, error) { + var all []string + for _, pf := range perFile { + all = append(all, pf.stmts...) + } + log.Printf("running oracle (%s) over %d statements with %d workers", binary, len(all), workers) + + scratch, err := os.MkdirTemp("", "darkwing-oracle-*") + if err != nil { + return nil, err + } + defer os.RemoveAll(scratch) + + type result struct { + sql string + v duckdbsrc.Verdict + err error + } + jobs := make(chan string) + results := make(chan result) + var wg sync.WaitGroup + for i := 0; i < workers; i++ { + wg.Add(1) + go func() { + defer wg.Done() + oracle := &duckdbsrc.Oracle{Binary: binary, Timeout: timeout, Dir: scratch} + for sql := range jobs { + v, err := oracle.Run(sql) + results <- result{sql: sql, v: v, err: err} + } + }() + } + go func() { + for _, sql := range all { + jobs <- sql + } + close(jobs) + wg.Wait() + close(results) + }() + + verdicts := make(map[string]duckdbsrc.Verdict, len(all)) + start := time.Now() + done, timeouts, crashes := 0, 0, 0 + for r := range results { + if r.err != nil { + return nil, r.err + } + verdicts[r.sql] = r.v + if r.v.TimedOut { + timeouts++ + } + if r.v.Crashed { + crashes++ + } + done++ + if done%5000 == 0 { + elapsed := time.Since(start) + log.Printf(" %d/%d (%.0f/s, %d timeouts, %d crashes)", + done, len(all), float64(done)/elapsed.Seconds(), timeouts, crashes) + } + } + log.Printf("oracle done: %d statements in %s (%d timeouts, %d crashes)", + done, time.Since(start).Round(time.Second), timeouts, crashes) + return verdicts, nil +} diff --git a/internal/duckdbsrc/duckdbsrc.go b/internal/duckdbsrc/duckdbsrc.go new file mode 100644 index 0000000..bd6c1e1 --- /dev/null +++ b/internal/duckdbsrc/duckdbsrc.go @@ -0,0 +1,160 @@ +// Package duckdbsrc locates and drives the pinned DuckDB CLI binary — the +// conformance oracle. The pin is a source commit plus the nightly CLI build +// of that commit; grammar, corpus expectations, and oracle must all come +// from the same commit (see internal/grammar/README.md). +package duckdbsrc + +import ( + "bytes" + "context" + "fmt" + "os" + "os/exec" + "strings" + "time" +) + +// Pinned build identity. Advancing the pin means updating these alongside +// the vendored grammar and regenerated corpus. +const ( + // PinnedCommit is the DuckDB source commit of the pin. + PinnedCommit = "8cbdaba6acb50db7780d22a65dd131584d472262" + // PinnedVersion is the CLI version string of the matching nightly. + PinnedVersion = "v2.0.0-alpha38195" + // NightlyURL is where DuckDB serves the current nightly CLI bundle. + // "latest" moves: once it no longer matches PinnedCommit, the pin + // must be advanced (or a cached binary used). + NightlyURL = "https://artifacts.duckdb.org/latest/duckdb-binaries-linux-amd64.zip" +) + +// EnvBinary is the environment variable naming the pinned CLI binary. +const EnvBinary = "DARKWING_DUCKDB" + +// Find locates the pinned DuckDB CLI: $DARKWING_DUCKDB, or "duckdb" on +// PATH. The binary's version is verified against the pin. +func Find() (string, error) { + path := os.Getenv(EnvBinary) + if path == "" { + p, err := exec.LookPath("duckdb") + if err != nil { + return "", fmt.Errorf("pinned DuckDB CLI not found: set %s or put duckdb on PATH (want %s @ %.10s, from %s)", + EnvBinary, PinnedVersion, PinnedCommit, NightlyURL) + } + path = p + } + if err := Verify(path); err != nil { + return "", err + } + return path, nil +} + +// Verify checks that the binary at path reports the pinned version and +// commit. +func Verify(path string) error { + out, err := exec.Command(path, "--version").Output() + if err != nil { + return fmt.Errorf("running %s --version: %w", path, err) + } + version := strings.TrimSpace(string(out)) + if !strings.Contains(version, PinnedVersion) || !strings.Contains(version, PinnedCommit[:10]) { + return fmt.Errorf("binary %s reports %q, want %s @ %.10s: advance the pin or point %s at the matching nightly", + path, version, PinnedVersion, PinnedCommit, EnvBinary) + } + return nil +} + +// Verdict is the oracle's classification of one statement. +type Verdict struct { + // Reject is true when the CLI raised a Parser Error. Success and any + // post-parse error (Binder, Catalog, ...) are must-accept, as are + // timeouts and crashes (execution ran, so parsing succeeded). + Reject bool + // Error is the first "Parser Error" line for rejected statements. + Error string + // TimedOut records that execution was cut short (still must-accept). + TimedOut bool + // Crashed records a CLI crash after parsing (still must-accept). + Crashed bool +} + +// Oracle runs statements through the pinned CLI against :memory:. +type Oracle struct { + Binary string + // Timeout bounds one statement's execution (parsing is instant; the + // bound is for statements that execute expensive work). Default 5s. + Timeout time.Duration + // Dir is the working directory for the CLI (statements may create + // files); default os.TempDir(). + Dir string +} + +// preamble disables extension auto-loading and bounds resource use so the +// oracle's verdicts depend only on parsing and cheap post-parse checks. +const preamble = "SET autoinstall_known_extensions=false;\n" + + "SET autoload_known_extensions=false;\n" + + "SET memory_limit='512MB';\n" + + "SET threads=1;\n" + +// Run classifies one statement. +func (o *Oracle) Run(sql string) (Verdict, error) { + timeout := o.Timeout + if timeout == 0 { + timeout = 5 * time.Second + } + ctx, cancel := context.WithTimeout(context.Background(), timeout) + defer cancel() + + cmd := exec.CommandContext(ctx, o.Binary, "-batch", "-noheader", ":memory:") + cmd.Dir = o.Dir + if cmd.Dir == "" { + cmd.Dir = os.TempDir() + } + cmd.Stdin = strings.NewReader(preamble + sql + "\n") + var stderr bytes.Buffer + cmd.Stdout = nil + cmd.Stderr = &stderr + err := cmd.Run() + + if v, found := classify(stderr.String()); found { + return v, nil + } + if ctx.Err() == context.DeadlineExceeded { + // execution ran long: parsing succeeded + return Verdict{TimedOut: true}, nil + } + if err != nil { + var exitErr *exec.ExitError + if isExit(err, &exitErr) { + if exitErr.ExitCode() == -1 || exitErr.ExitCode() > 1 { + // killed by a signal or an abnormal exit: the CLI got past + // parsing and died executing (fuzzer statements do this) + return Verdict{Crashed: true}, nil + } + // plain error exit with a non-parser error on stderr: + // post-parse failure, must-accept + return Verdict{}, nil + } + return Verdict{}, fmt.Errorf("running oracle: %w", err) + } + return Verdict{}, nil +} + +func isExit(err error, target **exec.ExitError) bool { + if e, ok := err.(*exec.ExitError); ok { + *target = e + return true + } + return false +} + +// classify scans CLI stderr for the first error line. Only "Parser Error" +// means reject; everything else is post-parse. +func classify(stderr string) (Verdict, bool) { + for _, line := range strings.Split(stderr, "\n") { + line = strings.TrimSpace(line) + if strings.HasPrefix(line, "Parser Error") { + return Verdict{Reject: true, Error: line}, true + } + } + return Verdict{}, false +} diff --git a/internal/grammar/README.md b/internal/grammar/README.md index 5709875..dc4f2f7 100644 --- a/internal/grammar/README.md +++ b/internal/grammar/README.md @@ -7,7 +7,13 @@ edit them by hand — changes happen only by advancing the pin (see PLAN.md, - Upstream: https://github.com/duckdb/duckdb - Source tree: `src/parser/peg/grammar/` -- Pinned commit: `044a04a7cd39e6e8235f756597ae42dde084e5e5` (main, 2026-08-20) +- Pinned commit: `8cbdaba6acb50db7780d22a65dd131584d472262` (main, 2026-08-18) +- Matching oracle binary: DuckDB CLI `v2.0.0-alpha38195 (Cyanoptera) 8cbdaba6ac` + (the nightly build served by https://artifacts.duckdb.org; see + `internal/duckdbsrc`) + +The pin follows the oracle binary: grammar, corpus expectations, and the +CLI used to derive them must come from the same commit. DuckDB is MIT-licensed; see `LICENSE.DUCKDB` at the repository root. @@ -31,10 +37,10 @@ d145c7659cbda441cd380b7cbdda88adf84307c18148aeed46dbefbc41c72ec5 statements/cre 2b68d04246879ca3b8162d942484e59731d367882ee18d3461dcea918589e3ad statements/create_table.gram 15ec6922853cdae4e1d51e7c10c1a25da70f5f2969b8b2993185c37fd81c6fe7 statements/create_trigger.gram 0da80da21a0660a2c59b4a1312a70bb3fdf51cbfb3211925fee894db89233f21 statements/create_type.gram -9ede97c886fa89f1c617914f88e3657192d34ae72bcf4803dee01e57cc2300c4 statements/create_view.gram +c21f5da90d789335c80a8aee162fc834157c3dda69b3d9e95c58d821299cb853 statements/create_view.gram d62c7218252ad6f762cc05125dc6cfe02c3c5f906df1e3a599a958296f78ff69 statements/deallocate.gram f9ded93197d1133107d3ec6d48210c1c5ccdb588cc61d03d164cadebfb06881d statements/delete.gram -c1242ea8a05cf628e152e189df9c94d866494e1b092553fcbb45142d0b3b92e7 statements/describe.gram +d7376c4de5b04bd8a5ac2b5453af3514c1a168e0db3a30abad61be34a3adde99 statements/describe.gram ec5f4bd0ba34ecfefbf09f2d637bfaec2f7b84311a639aeee589b997d72abba9 statements/detach.gram ca141624e02e3f1542e4b1251359b8938cd4d02c563f32bbbc5fff1fbc178643 statements/drop.gram 9f2ad89280ac00af9f6ab462a693f21a54383738ddcbb8d144409481ef85923b statements/execute.gram @@ -48,7 +54,7 @@ f150e2176c4a7398f8380c5ca8be43ec1d9ad63018f1e974ebf3b6e525529ae4 statements/ext f01099ef498cd6dd3e32f008e8600fc2e3da9715d1f8b84d0b46d559ee7f72da statements/pivot.gram 68ba82f61baed8fd57bb29043d025b2aaff86da0bfde49bee711f67e1f0ff8c3 statements/pragma.gram a8ce0da5078fa6d07c3376ff0f3b9db21a214f53cba43f7f39c0112f9dee228c statements/prepare.gram -27f075e3a594815f016e851f04922d5b65ba59d818663307e147779b262fd6e5 statements/select.gram +3b3ffd33489e8b25c74b0f547fff72c8fcf1b8ecf73b7f40d3df3b3baddff352 statements/select.gram 1d500aeb6bdd88fc8e434bb116dde8192c13c9e7354017e596dc2ef46424288a statements/set.gram 2de0cc72aeb00b6b6247348bd06db8e9a088cecb2c20516e678fe4261c909877 statements/transaction.gram d13cc52137a903fa42b4e476341b2f08cbe24ed4ad31b41df76001151f1b58d7 statements/update.gram @@ -58,5 +64,5 @@ d13cc52137a903fa42b4e476341b2f08cbe24ed4ad31b41df76001151f1b58d7 statements/upd 6e0d26e4f6a6b47b4392542ed4c4a3f68db3792781d349874bd0cce537dfe877 keywords/func_name_keyword.list 0e66c73b69c650f44d542840de6936fd6adc72bd6d8f80703209bc93aa7f4c41 keywords/reserved_keyword.list f999e346c982a548c8ede53d8a9022e4c366a1c54fb6380b7d97afedcf5ccad3 keywords/type_name_keyword.list -d95aa28d78cbe3cd9dd2e0b9c77a0f32988d78e29cd8b4feedfe4044b451b609 keywords/unreserved_keyword.list +4af9cce1fa0031eee19170211dde58af9bd782bb9cc6a2b4569957875a30da7e keywords/unreserved_keyword.list ``` diff --git a/internal/grammar/duckdb/keywords/unreserved_keyword.list b/internal/grammar/duckdb/keywords/unreserved_keyword.list index 5ac11f9..fb3d73b 100644 --- a/internal/grammar/duckdb/keywords/unreserved_keyword.list +++ b/internal/grammar/duckdb/keywords/unreserved_keyword.list @@ -256,7 +256,6 @@ SEARCH SECRET SECOND SECONDS -SECURE SECURITY SEQUENCE SEQUENCES diff --git a/internal/grammar/duckdb/statements/create_view.gram b/internal/grammar/duckdb/statements/create_view.gram index 4f598dc..e58319c 100644 --- a/internal/grammar/duckdb/statements/create_view.gram +++ b/internal/grammar/duckdb/statements/create_view.gram @@ -1,3 +1,2 @@ -CreateViewStmt <- CreateSecure? CreateRecursive? 'VIEW' IfNotExists? QualifiedName InsertColumnList? WithList? 'AS' SelectStatementInternal +CreateViewStmt <- CreateRecursive? 'VIEW' IfNotExists? QualifiedName InsertColumnList? WithList? 'AS' SelectStatementInternal CreateRecursive <- 'RECURSIVE' -CreateSecure <- 'SECURE' diff --git a/internal/grammar/duckdb/statements/describe.gram b/internal/grammar/duckdb/statements/describe.gram index fbf71f3..b873808 100644 --- a/internal/grammar/duckdb/statements/describe.gram +++ b/internal/grammar/duckdb/statements/describe.gram @@ -1,35 +1,14 @@ -DescribeStatement <- ShowTables / ShowDeprecatedSelect / DescribeSelect / ShowAllTables / ShowByName / DescribeByName +DescribeStatement <- ShowTables / ShowSelect / ShowAllTables / ShowQualifiedName -# "DESCRIBE (query)" and "SUMMARIZE (query)" describe the query's columns. "SHOW (query)" does too but is deprecated, -# so ShowDeprecatedSelect is parsed yet suppressed from autocomplete (matcher_factory.cpp) - SHOW won't offer to complete a query. -ShowDeprecatedSelect <- ShowRule SelectStatementInternal -DescribeSelect <- DescribeOrSummarize SelectStatementInternal +ShowSelect <- ShowOrDescribeOrSummarize SelectStatementInternal ShowAllTables <- ShowOrDescribe 'ALL' 'TABLES'? +ShowQualifiedName <- ShowOrDescribeOrSummarize DescribeTarget? ShowTables <- ShowOrDescribe 'TABLES' 'FROM' QualifiedName - -# "SHOW name" is settings-first, so its target autocompletes setting names (and the special MySQL forms), not -# arbitrary tables. "DESCRIBE"/"SUMMARIZE" describe a relation, so their target autocompletes table names. -ShowByName <- ShowRule ShowTarget? -DescribeByName <- DescribeOrSummarize DescribeTarget? -DescribeOrSummarize <- DescribeRule / Summarize - -# SHOW's own forms (a settings-first name and the special MySQL forms) plus the describe-style targets it still -# tolerates for the deprecated "describe via SHOW". Only settings and the special forms are autocompleted after SHOW; -# a qualified table is parsed but its suggestions are suppressed (see matcher.cpp). -ShowTarget <- ShowDeprecatedQualifiedTableName / ShowSettingName / DescribeStringLiteral / ShowSpecialForm -# "SHOW cat.tbl" still describes a table (deprecated), but is suppressed from autocomplete (see matcher.cpp) so SHOW -# does not complete qualified tables (unlike DESCRIBE, which does). Wraps the generic QualifiedTableName (select.gram). -ShowDeprecatedQualifiedTableName <- QualifiedTableName -# A bare identifier is suggested as a setting name (SettingName is overridden to SUGGEST_SETTING_NAME). -ShowSettingName <- SettingName -# The special MySQL forms are only here so autocomplete suggests these keywords after SHOW; parsing of e.g. -# "SHOW databases" resolves through ShowSettingName (the identifier) above, which the transformer special-cases. -ShowSpecialForm <- 'DATABASES' / 'SCHEMAS' / 'TABLES' / 'VARIABLES' - DescribeTarget <- DescribeBaseTableName / DescribeStringLiteral DescribeBaseTableName <- BaseTableName DescribeStringLiteral <- StringLiteral +ShowOrDescribeOrSummarize <- ShowOrDescribe / Summarize Summarize <- SummarizeRule SummarizeRule <- 'SUMMARIZE' ShowOrDescribe <- ShowRule / DescribeRule diff --git a/internal/grammar/duckdb/statements/select.gram b/internal/grammar/duckdb/statements/select.gram index 94cd199..11b7b33 100644 --- a/internal/grammar/duckdb/statements/select.gram +++ b/internal/grammar/duckdb/statements/select.gram @@ -75,9 +75,8 @@ UnpivotTargetList <- Parens(TargetList) Lateral <- 'LATERAL' -BaseTableName <- QualifiedTableName / UnqualifiedBaseTableName +BaseTableName <- CatalogReservedSchemaTable / SchemaReservedTable / UnqualifiedBaseTableName UnqualifiedBaseTableName <- TableName -QualifiedTableName <- CatalogReservedSchemaTable / SchemaReservedTable SchemaReservedTable <- SchemaQualification ReservedTableName CatalogReservedSchemaTable <- CatalogQualification ReservedSchemaQualification ReservedTableName diff --git a/internal/sqltest/sqltest.go b/internal/sqltest/sqltest.go new file mode 100644 index 0000000..63b36c6 --- /dev/null +++ b/internal/sqltest/sqltest.go @@ -0,0 +1,134 @@ +// Package sqltest extracts SQL statements from sqllogictest .test files in +// DuckDB's dialect (test/sql/**/*.test and test/fuzzer/**). It is a small, +// tolerant reader: it understands just enough of the format to find the SQL +// blocks, and keeps every statement literal — loop/foreach template +// substitutions are never performed, and statements that contain +// substitution syntax are skipped. +package sqltest + +import ( + "bufio" + "io" + "os" + "strings" +) + +// Statement is one SQL statement extracted from a .test file. +type Statement struct { + SQL string + // Line is the 1-based line number of the first SQL line. + Line int +} + +// directivePrefixes start a record whose body is SQL. +var sqlDirectives = []string{ + "statement ", + "query", +} + +// conditionPrefixes precede a record and are skipped. +var conditionPrefixes = []string{ + "skipif ", + "onlyif ", +} + +func hasSQLDirective(line string) bool { + for _, p := range sqlDirectives { + if strings.HasPrefix(line, p) { + return true + } + } + // bare "query" with no type string + return line == "query" +} + +func isCondition(line string) bool { + for _, p := range conditionPrefixes { + if strings.HasPrefix(line, p) { + return true + } + } + return false +} + +// ExtractFile extracts the statements of one .test file. +func ExtractFile(path string) ([]Statement, error) { + f, err := os.Open(path) + if err != nil { + return nil, err + } + defer f.Close() + return Extract(f) +} + +// Extract reads sqllogictest input and returns the SQL statements in +// order. Statements containing template substitutions (${...}) are +// skipped; all other statements are returned exactly as written. +func Extract(r io.Reader) ([]Statement, error) { + scanner := bufio.NewScanner(r) + scanner.Buffer(make([]byte, 0, 64*1024), 8*1024*1024) + + var statements []Statement + lineNo := 0 + for scanner.Scan() { + lineNo++ + line := scanner.Text() + trimmed := strings.TrimSpace(line) + if trimmed == "" || strings.HasPrefix(trimmed, "#") { + continue + } + if isCondition(trimmed) { + continue + } + if !hasSQLDirective(trimmed) { + // some other directive (require, mode, loop, restart, set, + // sleep, load, ...) - not a SQL record + continue + } + // SQL block: lines until an empty-or-comment line or the ---- + // separator. This matches upstream's SQLLogicParser: a record ends + // at `line.empty() || StartsWith(line, "#")` (after \r stripping), + // so a whitespace-only line does NOT end the record, and a comment + // line does. + var sql []string + start := 0 + sawSeparator := false + for scanner.Scan() { + lineNo++ + body := strings.ReplaceAll(scanner.Text(), "\r", "") + if body == "----" { + sawSeparator = true + break + } + if body == "" || strings.HasPrefix(body, "#") { + break + } + if start == 0 { + start = lineNo + } + sql = append(sql, body) + } + if sawSeparator { + // skim the expected results / error text until the + // record-ending line, so result rows are never mistaken for + // directives + for scanner.Scan() { + lineNo++ + body := strings.ReplaceAll(scanner.Text(), "\r", "") + if body == "" || strings.HasPrefix(body, "#") { + break + } + } + } + if len(sql) == 0 { + continue + } + text := strings.Join(sql, "\n") + if strings.Contains(text, "${") { + // loop/foreach template substitution - skipped, never expanded + continue + } + statements = append(statements, Statement{SQL: text, Line: start}) + } + return statements, scanner.Err() +} diff --git a/internal/sqltest/sqltest_test.go b/internal/sqltest/sqltest_test.go new file mode 100644 index 0000000..eaa99d8 --- /dev/null +++ b/internal/sqltest/sqltest_test.go @@ -0,0 +1,85 @@ +package sqltest + +import ( + "strings" + "testing" +) + +const sample = `# name: test/sql/sample.test +# group: [sample] + +statement ok +CREATE TABLE a (i INTEGER); +# trailing comment glued to the record must not join the SQL + +query I +SELECT i +FROM a +---- +42 + +statement error +SELECT ) +---- +Parser Error + +# a query whose results could be mistaken for directives +query I +SELECT 'statement ok' +---- +statement ok + +skipif threads=1 +statement ok +SELECT 2 + +loop i 0 10 + +statement ok +SELECT ${i} + +statement ok +SELECT 'literal inside loop' + +endloop + +require parquet + +statement maybe +COPY a TO 'x.parquet' +---- +IO Error +` + +func TestExtract(t *testing.T) { + stmts, err := Extract(strings.NewReader(sample)) + if err != nil { + t.Fatal(err) + } + want := []string{ + "CREATE TABLE a (i INTEGER);", + "SELECT i\nFROM a", + "SELECT )", + "SELECT 'statement ok'", + "SELECT 2", + // SELECT ${i} skipped: template substitution + "SELECT 'literal inside loop'", + "COPY a TO 'x.parquet'", + } + if len(stmts) != len(want) { + var got []string + for _, s := range stmts { + got = append(got, s.SQL) + } + t.Fatalf("extracted %d statements %q, want %d", len(stmts), got, len(want)) + } + for i, w := range want { + if stmts[i].SQL != w { + t.Errorf("statement %d = %q, want %q", i, stmts[i].SQL, w) + } + } + // line numbers point at the first SQL line + if stmts[0].Line != 5 { + t.Errorf("statement 0 line = %d, want 5", stmts[0].Line) + } +} diff --git a/internal/testfile/testfile.go b/internal/testfile/testfile.go new file mode 100644 index 0000000..9c08f0f --- /dev/null +++ b/internal/testfile/testfile.go @@ -0,0 +1,257 @@ +// Package testfile reads and writes darkwing's consolidated corpus format: +// one corpus file per upstream .test file, cases separated by a line +// containing only "==", the SQL and its expectation separated by a line +// containing only "--" (the meyer-style storage from PLAN.md). Expectations +// are derived from the pinned DuckDB binary by cmd/regenerate and are never +// edited by hand. +// +// A per-file JSON sidecar (.metadata.json) carries todo/skip lists, +// keyed by the case's content hash so entries survive corpus regeneration. +package testfile + +import ( + "bufio" + "crypto/sha256" + "encoding/hex" + "encoding/json" + "fmt" + "os" + "sort" + "strings" +) + +const ( + caseSeparator = "==" + partSeparator = "--" +) + +// Case is one corpus entry: a statement and the pinned oracle's verdict. +type Case struct { + SQL string + // Reject is true when the pinned DuckDB binary raised a Parser Error + // for this statement. Success and post-parse errors (Binder, Catalog, + // ...) are both must-accept. + Reject bool + // Error is the first line of the oracle's error message for rejected + // statements ("Parser Error: ..."). + Error string + // Index is the 0-based position within the file. + Index int +} + +// Key returns the case's content hash: the stable identity used by +// metadata sidecars. +func (c *Case) Key() string { + return CaseKey(c.SQL) +} + +// CaseKey hashes a statement's text into a short stable identifier. +func CaseKey(sql string) string { + sum := sha256.Sum256([]byte(sql)) + return hex.EncodeToString(sum[:8]) +} + +// File is one corpus file. +type File struct { + // Header lines are written as leading '#' comments (provenance). + Header []string + Cases []Case +} + +// CanStore reports whether a statement can be represented in the corpus +// format: the format delimits with whole lines "==" and "--", so a +// statement containing either as an exact line cannot be stored. +func CanStore(sql string) bool { + for _, line := range strings.Split(sql, "\n") { + if line == caseSeparator || line == partSeparator { + return false + } + } + return true +} + +// Read parses a corpus file. +func Read(path string) (*File, error) { + f, err := os.Open(path) + if err != nil { + return nil, err + } + defer f.Close() + + scanner := bufio.NewScanner(f) + scanner.Buffer(make([]byte, 0, 64*1024), 8*1024*1024) + + file := &File{} + var sql []string + var expectation []string + inExpectation := false + sawContent := false + lineNo := 0 + + flush := func() error { + if !sawContent { + return nil + } + if !inExpectation { + return fmt.Errorf("%s: case %d has no expectation (missing %q separator)", + path, len(file.Cases), partSeparator) + } + c := Case{SQL: strings.Join(sql, "\n"), Index: len(file.Cases)} + if len(expectation) == 0 { + return fmt.Errorf("%s: case %d has an empty expectation", path, len(file.Cases)) + } + verdict := expectation[0] + switch { + case verdict == "ok": + // must-accept + case strings.HasPrefix(verdict, "error: "): + c.Reject = true + c.Error = strings.TrimPrefix(verdict, "error: ") + default: + return fmt.Errorf("%s: case %d has an unrecognized expectation %q", path, len(file.Cases), verdict) + } + file.Cases = append(file.Cases, c) + sql, expectation = nil, nil + inExpectation = false + sawContent = false + return nil + } + + headerDone := false + for scanner.Scan() { + lineNo++ + line := scanner.Text() + if !headerDone { + if strings.HasPrefix(line, "#") { + file.Header = append(file.Header, strings.TrimPrefix(strings.TrimPrefix(line, "#"), " ")) + continue + } + if line == "" { + continue + } + headerDone = true + } + switch line { + case caseSeparator: + if err := flush(); err != nil { + return nil, err + } + case partSeparator: + if inExpectation { + return nil, fmt.Errorf("%s:%d: duplicate %q separator", path, lineNo, partSeparator) + } + inExpectation = true + sawContent = true + default: + if line == "" && !sawContent { + // stray blank line between cases + continue + } + sawContent = true + if inExpectation { + expectation = append(expectation, line) + } else { + sql = append(sql, line) + } + } + } + if err := scanner.Err(); err != nil { + return nil, err + } + if err := flush(); err != nil { + return nil, err + } + return file, nil +} + +// Write renders the corpus file. +func Write(path string, file *File) error { + var sb strings.Builder + for _, h := range file.Header { + sb.WriteString("# ") + sb.WriteString(h) + sb.WriteString("\n") + } + if len(file.Header) > 0 { + sb.WriteString("\n") + } + for i := range file.Cases { + c := &file.Cases[i] + sb.WriteString(c.SQL) + sb.WriteString("\n") + sb.WriteString(partSeparator) + sb.WriteString("\n") + if c.Reject { + sb.WriteString("error: ") + sb.WriteString(c.Error) + } else { + sb.WriteString("ok") + } + sb.WriteString("\n") + sb.WriteString(caseSeparator) + sb.WriteString("\n") + } + return os.WriteFile(path, []byte(sb.String()), 0o644) +} + +// Metadata is the per-file todo/skip sidecar. Keys are case content +// hashes (Case.Key); values are free-form notes on why the case is +// deferred or excluded. +type Metadata struct { + // Todo cases are expected to disagree with the oracle for now: the + // harness inverts them (a todo case that starts passing must be + // removed from the list). + Todo map[string]string `json:"todo,omitempty"` + // Skip cases are not run at all (e.g. statements that hit engine + // limits unrelated to conformance). + Skip map[string]string `json:"skip,omitempty"` +} + +// MetadataPath returns the sidecar path for a corpus file. +func MetadataPath(corpusPath string) string { + return corpusPath + ".metadata.json" +} + +// ReadMetadata loads the sidecar; a missing sidecar is an empty Metadata. +func ReadMetadata(corpusPath string) (*Metadata, error) { + data, err := os.ReadFile(MetadataPath(corpusPath)) + if os.IsNotExist(err) { + return &Metadata{}, nil + } + if err != nil { + return nil, err + } + var m Metadata + if err := json.Unmarshal(data, &m); err != nil { + return nil, fmt.Errorf("%s: %w", MetadataPath(corpusPath), err) + } + return &m, nil +} + +// WriteMetadata saves the sidecar, deleting it when empty. +func WriteMetadata(corpusPath string, m *Metadata) error { + path := MetadataPath(corpusPath) + if len(m.Todo) == 0 && len(m.Skip) == 0 { + err := os.Remove(path) + if os.IsNotExist(err) { + return nil + } + return err + } + data, err := json.MarshalIndent(m, "", " ") + if err != nil { + return err + } + return os.WriteFile(path, append(data, '\n'), 0o644) +} + +// SortKeys returns the map's keys in stable order (for deterministic +// reporting). +func SortKeys(m map[string]string) []string { + keys := make([]string, 0, len(m)) + for k := range m { + keys = append(keys, k) + } + sort.Strings(keys) + return keys +} diff --git a/internal/testfile/testfile_test.go b/internal/testfile/testfile_test.go new file mode 100644 index 0000000..64c2e1f --- /dev/null +++ b/internal/testfile/testfile_test.go @@ -0,0 +1,97 @@ +package testfile + +import ( + "path/filepath" + "testing" +) + +func TestRoundTrip(t *testing.T) { + file := &File{ + Header: []string{"source: test/sql/sample.test", "pin: abc"}, + Cases: []Case{ + {SQL: "SELECT 1;", Index: 0}, + {SQL: "SELECT\n 2", Index: 1}, + {SQL: "SELECT )", Reject: true, Error: `Parser Error: syntax error at or near ")"`, Index: 2}, + }, + } + path := filepath.Join(t.TempDir(), "sample.test") + if err := Write(path, file); err != nil { + t.Fatal(err) + } + got, err := Read(path) + if err != nil { + t.Fatal(err) + } + if len(got.Header) != 2 || got.Header[0] != "source: test/sql/sample.test" { + t.Errorf("header = %q", got.Header) + } + if len(got.Cases) != len(file.Cases) { + t.Fatalf("cases = %d, want %d", len(got.Cases), len(file.Cases)) + } + for i := range file.Cases { + a, b := file.Cases[i], got.Cases[i] + if a.SQL != b.SQL || a.Reject != b.Reject || a.Error != b.Error { + t.Errorf("case %d = %+v, want %+v", i, b, a) + } + if got.Cases[i].Index != i { + t.Errorf("case %d index = %d", i, got.Cases[i].Index) + } + } +} + +func TestCanStore(t *testing.T) { + if CanStore("SELECT 1\n--\nSELECT 2") { + t.Error("a lone -- line must not be storable") + } + if CanStore("==") { + t.Error("a lone == line must not be storable") + } + if !CanStore("SELECT 1 -- comment\nFROM t") { + t.Error("-- with trailing text is storable") + } +} + +func TestMetadataRoundTrip(t *testing.T) { + corpus := filepath.Join(t.TempDir(), "sample.test") + m, err := ReadMetadata(corpus) + if err != nil { + t.Fatal(err) + } + if len(m.Todo) != 0 || len(m.Skip) != 0 { + t.Errorf("missing sidecar should read empty, got %+v", m) + } + m.Todo = map[string]string{CaseKey("SELECT 1"): "needs transformer"} + if err := WriteMetadata(corpus, m); err != nil { + t.Fatal(err) + } + got, err := ReadMetadata(corpus) + if err != nil { + t.Fatal(err) + } + if got.Todo[CaseKey("SELECT 1")] != "needs transformer" { + t.Errorf("todo = %+v", got.Todo) + } + // clearing removes the sidecar file + if err := WriteMetadata(corpus, &Metadata{}); err != nil { + t.Fatal(err) + } + got, err = ReadMetadata(corpus) + if err != nil { + t.Fatal(err) + } + if len(got.Todo) != 0 { + t.Errorf("cleared sidecar still has todos: %+v", got) + } +} + +func TestCaseKeyStable(t *testing.T) { + if CaseKey("SELECT 1") != CaseKey("SELECT 1") { + t.Error("CaseKey must be deterministic") + } + if CaseKey("SELECT 1") == CaseKey("SELECT 2") { + t.Error("CaseKey must differ for different SQL") + } + if len(CaseKey("SELECT 1")) != 16 { + t.Errorf("CaseKey length = %d, want 16", len(CaseKey("SELECT 1"))) + } +} diff --git a/parser/parser_test.go b/parser/parser_test.go new file mode 100644 index 0000000..95f22bf --- /dev/null +++ b/parser/parser_test.go @@ -0,0 +1,238 @@ +// Corpus conformance harness (milestone 2): darkwing must accept a +// statement iff the pinned DuckDB binary parses it. Corpus files and +// expectations under testdata/ are generated by cmd/regenerate and never +// edited by hand; per-file *.metadata.json sidecars carry todo/skip lists +// (see cmd/next-test for picking the next todo case). +// +// The parser package itself (Parse/ParseStatement/ParseExpr and the typed +// AST) arrives in milestone 3; accept/reject needs only the engine. +package parser + +import ( + "flag" + "fmt" + "io/fs" + "path/filepath" + "strings" + "testing" + + "github.com/sqlc-dev/darkwing/internal/matcher" + "github.com/sqlc-dev/darkwing/internal/testfile" + "github.com/sqlc-dev/darkwing/lexer" + "github.com/sqlc-dev/darkwing/token" +) + +var ( + checkParse = flag.String("check-parse", "", "dump tokens and parse detail for corpus cases whose SQL contains this substring") + recordTodos = flag.String("record-todos", "", "triage mode: record oracle disagreements as todo entries with this note instead of failing") +) + +// verdict is darkwing's accept/reject classification of one statement, +// mirroring the oracle's: tokenizer errors and matcher syntax errors are +// rejects; anything else is an accept. +type verdict struct { + reject bool + detail string +} + +func classify(engine *matcher.Engine, sql string) verdict { + tokens, err := lexer.Tokenize(sql) + if err != nil { + return verdict{reject: true, detail: err.Error()} + } + pos := 0 + for pos < len(tokens) { + result, newPos, err := engine.MatchTopLevel(tokens, pos) + if err != nil { + return verdict{reject: true, detail: err.Error()} + } + if newPos == pos { + return verdict{reject: true, detail: fmt.Sprintf("matcher made no progress at token %d", pos)} + } + _ = result + pos = newPos + } + return verdict{} +} + +func corpusFiles(t *testing.T) []string { + t.Helper() + var files []string + root := filepath.Join("testdata", "corpus") + err := filepath.WalkDir(root, func(path string, d fs.DirEntry, err error) error { + if err != nil { + return err + } + if !d.IsDir() && strings.HasSuffix(path, ".test") { + files = append(files, path) + } + return nil + }) + if err != nil { + t.Fatalf("walking corpus: %v (run cmd/regenerate first)", err) + } + if len(files) == 0 { + t.Skip("no corpus files under testdata/corpus (run cmd/regenerate)") + } + return files +} + +func TestCorpus(t *testing.T) { + engine, err := matcher.Default() + if err != nil { + t.Fatal(err) + } + for _, path := range corpusFiles(t) { + rel, _ := filepath.Rel("testdata", path) + t.Run(filepath.ToSlash(rel), func(t *testing.T) { + t.Parallel() + file, err := testfile.Read(path) + if err != nil { + t.Fatal(err) + } + meta, err := testfile.ReadMetadata(path) + if err != nil { + t.Fatal(err) + } + metaDirty := false + for i := range file.Cases { + c := &file.Cases[i] + key := c.Key() + if _, skip := meta.Skip[key]; skip { + continue + } + got := classify(engine, c.SQL) + if *checkParse != "" && strings.Contains(c.SQL, *checkParse) { + dumpCase(t, engine, c, got) + } + agrees := got.reject == c.Reject + if note, isTodo := meta.Todo[key]; isTodo { + if agrees { + t.Errorf("case %s agrees with the oracle now - remove it from todo (%s)\nSQL: %s", key, note, c.SQL) + } + continue + } + if !agrees { + // Transformer-raised rejects: the oracle's Parser Error + // comes from upstream's transformer, not the grammar + // (message is not "syntax error at or near"). The + // matcher alone cannot reject these; they are the only + // category -record-todos will auto-record. + transformerRaised := c.Reject && !got.reject && + !strings.HasPrefix(c.Error, "Parser Error: syntax error at or near") + if *recordTodos != "" && transformerRaised { + if meta.Todo == nil { + meta.Todo = make(map[string]string) + } + meta.Todo[key] = *recordTodos + metaDirty = true + continue + } + want := "accept" + if c.Reject { + want = "reject (" + c.Error + ")" + } + gotStr := "accept" + if got.reject { + gotStr = "reject (" + got.detail + ")" + } + t.Errorf("case %s: oracle says %s, darkwing says %s\nSQL: %s", key, want, gotStr, c.SQL) + } + } + if metaDirty { + if err := testfile.WriteMetadata(path, meta); err != nil { + t.Fatal(err) + } + } + }) + } +} + +func dumpCase(t *testing.T, engine *matcher.Engine, c *testfile.Case, got verdict) { + t.Helper() + var sb strings.Builder + fmt.Fprintf(&sb, "case %s\nSQL: %s\noracle reject=%v %s\ndarkwing reject=%v %s\n", + c.Key(), c.SQL, c.Reject, c.Error, got.reject, got.detail) + tokens, err := lexer.Tokenize(c.SQL) + if err == nil { + sb.WriteString("tokens:\n") + for _, tk := range tokens { + fmt.Fprintf(&sb, " %-16s %4d..%-4d %q\n", tk.Kind, tk.Span.Start, tk.Span.End, tk.Text) + } + pos := 0 + for pos < len(tokens) { + result, newPos, err := engine.MatchTopLevel(tokens, pos) + if err != nil || newPos == pos { + fmt.Fprintf(&sb, "match error at token %d: %v\n", pos, err) + break + } + sb.WriteString(matcher.Dump(result)) + pos = newPos + } + } + t.Log(sb.String()) +} + +// TestCorpusMetadataHygiene keeps the sidecars honest: every todo/skip key +// must refer to a case that still exists in its corpus file. +func TestCorpusMetadataHygiene(t *testing.T) { + for _, path := range corpusFiles(t) { + meta, err := testfile.ReadMetadata(path) + if err != nil { + t.Fatal(err) + } + if len(meta.Todo) == 0 && len(meta.Skip) == 0 { + continue + } + file, err := testfile.Read(path) + if err != nil { + t.Fatal(err) + } + known := make(map[string]bool, len(file.Cases)) + for i := range file.Cases { + known[file.Cases[i].Key()] = true + } + for _, m := range []map[string]string{meta.Todo, meta.Skip} { + for _, key := range testfile.SortKeys(m) { + if !known[key] { + t.Errorf("%s: metadata key %s has no matching case", testfile.MetadataPath(path), key) + } + } + } + } +} + +// TestCorpusRoundTrip guards the storage format: re-serializing a parsed +// corpus file must reproduce its cases exactly. +func TestCorpusRoundTrip(t *testing.T) { + files := corpusFiles(t) + if len(files) > 25 { + files = files[:25] + } + for _, path := range files { + file, err := testfile.Read(path) + if err != nil { + t.Fatal(err) + } + tmp := filepath.Join(t.TempDir(), "roundtrip.test") + if err := testfile.Write(tmp, file); err != nil { + t.Fatal(err) + } + again, err := testfile.Read(tmp) + if err != nil { + t.Fatalf("re-reading %s: %v", path, err) + } + if len(again.Cases) != len(file.Cases) { + t.Fatalf("%s: round trip changed case count %d -> %d", path, len(file.Cases), len(again.Cases)) + } + for i := range file.Cases { + a, b := file.Cases[i], again.Cases[i] + if a.SQL != b.SQL || a.Reject != b.Reject || a.Error != b.Error { + t.Errorf("%s: case %d changed in round trip", path, i) + } + } + } +} + +// keep the token package linked in for -check-parse dumps +var _ = token.EndOfInput diff --git a/parser/testdata/README.md b/parser/testdata/README.md new file mode 100644 index 0000000..ff0c960 --- /dev/null +++ b/parser/testdata/README.md @@ -0,0 +1,17 @@ +# darkwing conformance corpus + +Generated by cmd/regenerate - do not edit corpus files or expectations by +hand; rerun the tool instead (see PLAN.md, § Conformance oracle and corpus). + +- Source: DuckDB test/sql/**/*.test and test/fuzzer/**/*.test +- Pinned commit: 8cbdaba6acb50db7780d22a65dd131584d472262 +- Oracle: DuckDB CLI v2.0.0-alpha38195 (nightly build of the pinned commit) +- Files: 4071, cases: 45226 (43819 must-accept, 1407 must-reject) + +Classification: the oracle runs each statement against :memory: with +extension autoloading disabled. An error starting with "Parser Error" +means must-reject (first error line recorded); success or any post-parse +error (Binder, Catalog, ...) means must-accept. + +Sidecar files (*.metadata.json) carry todo/skip lists keyed by case +content hash; they are maintained by hand and survive regeneration. diff --git a/parser/testdata/corpus/fuzzer/afl/alter_if_exists.test b/parser/testdata/corpus/fuzzer/afl/alter_if_exists.test new file mode 100644 index 0000000..2a178c4 --- /dev/null +++ b/parser/testdata/corpus/fuzzer/afl/alter_if_exists.test @@ -0,0 +1,13 @@ +# source: test/fuzzer/afl/alter_if_exists.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +ALTER TABLE IF EXISTS t0 ADD COLUMN c1 INT; +-- +ok +== +ALTER TABLE t0 ADD COLUMN c1 INT; +-- +ok +== diff --git a/parser/testdata/corpus/fuzzer/afl/analyze_empty_table.test b/parser/testdata/corpus/fuzzer/afl/analyze_empty_table.test new file mode 100644 index 0000000..1fa4d94 --- /dev/null +++ b/parser/testdata/corpus/fuzzer/afl/analyze_empty_table.test @@ -0,0 +1,17 @@ +# source: test/fuzzer/afl/analyze_empty_table.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +PRAGMA disable_optimizer +-- +ok +== +CREATE TABLE t0 (c0 int); +-- +ok +== +ANALYZE t0; +-- +ok +== diff --git a/parser/testdata/corpus/fuzzer/afl/case_map_cast.test b/parser/testdata/corpus/fuzzer/afl/case_map_cast.test new file mode 100644 index 0000000..32d539c --- /dev/null +++ b/parser/testdata/corpus/fuzzer/afl/case_map_cast.test @@ -0,0 +1,9 @@ +# source: test/fuzzer/afl/case_map_cast.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +SELECT TRUE WHERE CASE MAP { } WHEN 'abc' [ ('any_string' IN (NULL::VARCHAR)): ] THEN TRUE END ; +-- +ok +== diff --git a/parser/testdata/corpus/fuzzer/afl/decimal_string_roundtrip.test b/parser/testdata/corpus/fuzzer/afl/decimal_string_roundtrip.test new file mode 100644 index 0000000..cec6cc4 --- /dev/null +++ b/parser/testdata/corpus/fuzzer/afl/decimal_string_roundtrip.test @@ -0,0 +1,37 @@ +# source: test/fuzzer/afl/decimal_string_roundtrip.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +SELECT .0 +-- +ok +== +SELECT .123456 +-- +ok +== +SELECT .1234567890123 +-- +ok +== +SELECT .123456789012345678901234567890 +-- +ok +== +SELECT .0::VARCHAR +-- +ok +== +SELECT .123456::VARCHAR +-- +ok +== +SELECT .1234567890123::VARCHAR +-- +ok +== +SELECT .123456789012345678901234567890::VARCHAR +-- +ok +== diff --git a/parser/testdata/corpus/fuzzer/afl/generate_series_null.test b/parser/testdata/corpus/fuzzer/afl/generate_series_null.test new file mode 100644 index 0000000..36c4f84 --- /dev/null +++ b/parser/testdata/corpus/fuzzer/afl/generate_series_null.test @@ -0,0 +1,41 @@ +# source: test/fuzzer/afl/generate_series_null.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +SELECT c0 FROM generate_series(NULL) t3(c0); +-- +ok +== +SELECT c0 FROM generate_series(0, NULL) t3(c0); +-- +ok +== +SELECT c0 FROM generate_series(0, 0, NULL) t3(c0); +-- +ok +== +SELECT c0 FROM generate_series(NULL, NULL, NULL) t3(c0); +-- +ok +== +SELECT c0 FROM range(NULL) t3(c0); +-- +ok +== +SELECT c0 FROM range(1, NULL) t3(c0); +-- +ok +== +SELECT c0 FROM range(1, 1, NULL) t3(c0); +-- +ok +== +SELECT c0 FROM range(NULL, NULL, NULL) t3(c0); +-- +ok +== +SELECT c0, c0 FROM generate_series(1) t3(c0); +-- +ok +== diff --git a/parser/testdata/corpus/fuzzer/afl/grouping_empty_table.test b/parser/testdata/corpus/fuzzer/afl/grouping_empty_table.test new file mode 100644 index 0000000..8f3911d --- /dev/null +++ b/parser/testdata/corpus/fuzzer/afl/grouping_empty_table.test @@ -0,0 +1,13 @@ +# source: test/fuzzer/afl/grouping_empty_table.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +CREATE TABLE t0(c1 INT); +-- +ok +== +SELECT GROUPING(c1) FROM t0 GROUP BY CUBE(c1) ORDER BY 1; +-- +ok +== diff --git a/parser/testdata/corpus/fuzzer/afl/invalid_foreign_key.test b/parser/testdata/corpus/fuzzer/afl/invalid_foreign_key.test new file mode 100644 index 0000000..3b151d2 --- /dev/null +++ b/parser/testdata/corpus/fuzzer/afl/invalid_foreign_key.test @@ -0,0 +1,9 @@ +# source: test/fuzzer/afl/invalid_foreign_key.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +create table y(y int, foreign key (y) references y(y)); +-- +ok +== diff --git a/parser/testdata/corpus/fuzzer/afl/issue_7551.test b/parser/testdata/corpus/fuzzer/afl/issue_7551.test new file mode 100644 index 0000000..f82ccb4 --- /dev/null +++ b/parser/testdata/corpus/fuzzer/afl/issue_7551.test @@ -0,0 +1,29 @@ +# source: test/fuzzer/afl/issue_7551.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +CREATE TABLE t0(c0 VARCHAR); +-- +ok +== +CREATE TABLE t1(c0 DATE); +-- +ok +== +INSERT INTO t1(c0) VALUES ((TIMESTAMP '1970-01-25 15:59:18')); +-- +ok +== +INSERT INTO t0(c0) VALUES ((DATE '1969-12-20')), ((TIMESTAMP '1970-01-11 21:25:45')), (DEFAULT), (('1')), (('')), ((TIMESTAMP '1969-12-15 21:35:22')); +-- +ok +== +CREATE VIEW v0(c0) AS SELECT t1.c0 FROM t1, t0; +-- +ok +== +SELECT t0.rowid FROM t0, t1 LEFT JOIN v0 ON (1) WHERE t0.c0 >= v0.c0 AND t0.c0 <= v0.c0; +-- +ok +== diff --git a/parser/testdata/corpus/fuzzer/afl/issue_8185.test b/parser/testdata/corpus/fuzzer/afl/issue_8185.test new file mode 100644 index 0000000..e6a68ea --- /dev/null +++ b/parser/testdata/corpus/fuzzer/afl/issue_8185.test @@ -0,0 +1,13 @@ +# source: test/fuzzer/afl/issue_8185.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +CREATE TABLE v0 ( v1 INTEGER , v2 INTEGER) ; +-- +ok +== +SELECT * FROM v0 WHERE v2 <= 2 AND v2 <= v1 AND v1 < v2 ORDER BY v1 DESC ; +-- +ok +== diff --git a/parser/testdata/corpus/fuzzer/afl/limit_out_of_range.test b/parser/testdata/corpus/fuzzer/afl/limit_out_of_range.test new file mode 100644 index 0000000..5e19f7f --- /dev/null +++ b/parser/testdata/corpus/fuzzer/afl/limit_out_of_range.test @@ -0,0 +1,17 @@ +# source: test/fuzzer/afl/limit_out_of_range.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +SELECT 1 LIMIT 3493690519702624888078795276804013381392711238711408854154521934990547605008475834286773858253643735619391784938186674922945640543537290894084514784093972720748475288610394187481276081350259062592878908961890372712236217855377408.000000%; +-- +ok +== +SELECT 1 LIMIT 3493690519702624888078795276804013381392711238711408854154521934990547605008475834286773858253643735619391784938186674922945640543537290894084514784093972720748475288610394187481276081350259062592878908961890372712236217855377408.000000; +-- +ok +== +SELECT 1 LIMIT CAST('NaN' AS REAL)%; +-- +ok +== diff --git a/parser/testdata/corpus/fuzzer/afl/non_foldable_parameter.test b/parser/testdata/corpus/fuzzer/afl/non_foldable_parameter.test new file mode 100644 index 0000000..f51cdfb --- /dev/null +++ b/parser/testdata/corpus/fuzzer/afl/non_foldable_parameter.test @@ -0,0 +1,13 @@ +# source: test/fuzzer/afl/non_foldable_parameter.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +PREPARE p AS SELECT ?; +-- +ok +== +EXECUTE p (random()); +-- +ok +== diff --git a/parser/testdata/corpus/fuzzer/afl/random_join.test b/parser/testdata/corpus/fuzzer/afl/random_join.test new file mode 100644 index 0000000..51749ca --- /dev/null +++ b/parser/testdata/corpus/fuzzer/afl/random_join.test @@ -0,0 +1,13 @@ +# source: test/fuzzer/afl/random_join.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +CREATE TABLE t1(c1 INT); +-- +ok +== +SELECT * FROM (SELECT 1) JOIN t1 ON random(); +-- +ok +== diff --git a/parser/testdata/corpus/fuzzer/afl/self_referential_alias.test b/parser/testdata/corpus/fuzzer/afl/self_referential_alias.test new file mode 100644 index 0000000..1ea9d05 --- /dev/null +++ b/parser/testdata/corpus/fuzzer/afl/self_referential_alias.test @@ -0,0 +1,21 @@ +# source: test/fuzzer/afl/self_referential_alias.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +SELECT x x WHERE x = 0; +-- +ok +== +CREATE TABLE integers (a INT); +-- +ok +== +INSERT INTO integers VALUES (0), (1), (2); +-- +ok +== +SELECT a as b, d as c, c as d from integers; +-- +ok +== diff --git a/parser/testdata/corpus/fuzzer/afl/window_function_binder_error.test b/parser/testdata/corpus/fuzzer/afl/window_function_binder_error.test new file mode 100644 index 0000000..eaaffb0 --- /dev/null +++ b/parser/testdata/corpus/fuzzer/afl/window_function_binder_error.test @@ -0,0 +1,13 @@ +# source: test/fuzzer/afl/window_function_binder_error.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +SELECT count(x) OVER () FROM (SELECT 1) x(x); +-- +ok +== +SELECT count(x) OVER () FROM (SELECT 1) x(x) GROUP BY ALL; +-- +ok +== diff --git a/parser/testdata/corpus/fuzzer/afl/window_type_mismatch.test b/parser/testdata/corpus/fuzzer/afl/window_type_mismatch.test new file mode 100644 index 0000000..a3f0297 --- /dev/null +++ b/parser/testdata/corpus/fuzzer/afl/window_type_mismatch.test @@ -0,0 +1,13 @@ +# source: test/fuzzer/afl/window_type_mismatch.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +SELECT rank() OVER (), lag(NULL) OVER (); +-- +ok +== +SELECT rank() OVER (), lag(NULL) OVER (ORDER BY x) FROM (VALUES (1)) tbl(x); +-- +ok +== diff --git a/parser/testdata/corpus/fuzzer/duckfuzz/arg_minmax_by_decimal.test b/parser/testdata/corpus/fuzzer/duckfuzz/arg_minmax_by_decimal.test new file mode 100644 index 0000000..b40ec5c --- /dev/null +++ b/parser/testdata/corpus/fuzzer/duckfuzz/arg_minmax_by_decimal.test @@ -0,0 +1,23 @@ +# source: test/fuzzer/duckfuzz/arg_minmax_by_decimal.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +create table all_types as + select * exclude(small_enum, medium_enum, large_enum) + from test_all_types() + limit 0; +-- +ok +== +SELECT min_by(DISTINCT c23, c22) +FROM all_types AS t43(c1, c2, c3, c4, c5, c6, c7, c8, c9, c10, c11, c12, c13, c14, c15, c16, c17, c18, c19, c20, c21, c22, c23, c24, c25, c26, c27, c28, c29, c30, c31, c32, c33, c34, c35, c36, c37, c38, c39, c40, c41, c42) +-- +ok +== +SELECT c6 +FROM all_types AS t43(c1, c2, c3, c4, c5, c6, c7, c8, c9, c10, c11, c12, c13, c14, c15, c16, c17, c18, c19, c20, c21, c22, c23, c24, c25, c26, c27, c28, c29, c30, c31, c32, c33, c34, c35, c36, c37, c38, c39, c40, c41, c42) +PIVOT (argmin(c23, c6) FOR (c6, c33) IN ((8899, 4068))) +-- +ok +== diff --git a/parser/testdata/corpus/fuzzer/duckfuzz/array_const_columndatacopy.test b/parser/testdata/corpus/fuzzer/duckfuzz/array_const_columndatacopy.test new file mode 100644 index 0000000..fd237f6 --- /dev/null +++ b/parser/testdata/corpus/fuzzer/duckfuzz/array_const_columndatacopy.test @@ -0,0 +1,21 @@ +# source: test/fuzzer/duckfuzz/array_const_columndatacopy.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +CREATE TABLE uuids(uuid UUID); +-- +ok +== +INSERT INTO uuids VALUES('00000000-0000-0000-0000-000000000000'); +-- +ok +== +INSERT INTO uuids VALUES('ffffffff-ffff-ffff-ffff-ffffffffffff'); +-- +ok +== +SELECT TRY_CAST(uuid AS STRUCT(b VARCHAR[3])) FROM uuids; +-- +ok +== diff --git a/parser/testdata/corpus/fuzzer/duckfuzz/array_const_null_cast.test b/parser/testdata/corpus/fuzzer/duckfuzz/array_const_null_cast.test new file mode 100644 index 0000000..0a18c00 --- /dev/null +++ b/parser/testdata/corpus/fuzzer/duckfuzz/array_const_null_cast.test @@ -0,0 +1,17 @@ +# source: test/fuzzer/duckfuzz/array_const_null_cast.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +create table tbl(c8 UTINYINT); +-- +ok +== +INSERT INTO tbl VALUES (0), (255), (NULL); +-- +ok +== +SELECT CAST(TRY_CAST(c8 AS ENUM('DUCK_DUCK_ENUM', 'GOOSE')) AS VARCHAR[3]) FROM tbl; +-- +ok +== diff --git a/parser/testdata/corpus/fuzzer/duckfuzz/array_distance.test b/parser/testdata/corpus/fuzzer/duckfuzz/array_distance.test new file mode 100644 index 0000000..dc0d749 --- /dev/null +++ b/parser/testdata/corpus/fuzzer/duckfuzz/array_distance.test @@ -0,0 +1,17 @@ +# source: test/fuzzer/duckfuzz/array_distance.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +SELECT array_distance('asdf', [42]::INTEGER[1]); +-- +ok +== +create table all_types as select * exclude(small_enum, medium_enum, large_enum) from test_all_types(); +-- +ok +== +SELECT array_distance('db6d3411-3fe9-4668-bf60-06d94108c0f7', c46) FROM all_types AS t51(c1, c2, c3, c4, c5, c6, c7, c8, c9, c10, c11, c12, c13, c14, c15, c16, c17, c18, c19, c20, c21, c22, c23, c24, c25, c26, c27, c28, c29, c30, c31, c32, c33, c34, c35, c36, c37, c38, c39, c40, c41, c42, c43, c44, c45, c46, c47, c48, c49, c50, c51) +-- +ok +== diff --git a/parser/testdata/corpus/fuzzer/duckfuzz/array_group_by_sample.test b/parser/testdata/corpus/fuzzer/duckfuzz/array_group_by_sample.test new file mode 100644 index 0000000..0a3886a --- /dev/null +++ b/parser/testdata/corpus/fuzzer/duckfuzz/array_group_by_sample.test @@ -0,0 +1,37 @@ +# source: test/fuzzer/duckfuzz/array_group_by_sample.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +CREATE TABLE array_tbl(c50 INTEGER[2][]); +-- +ok +== +INSERT INTO array_tbl VALUES('[[1, 2], [1, 2]]'); +-- +ok +== +INSERT INTO array_tbl VALUES('[[3, 4], [3, 4]]'); +-- +ok +== +SELECT c50 FROM array_tbl GROUP BY ALL USING SAMPLE 3; +-- +ok +== +CREATE TABLE array_tbl_three_level(c50 INTEGER[2][2][]); +-- +ok +== +INSERT INTO array_tbl_three_level VALUES('[[[42, 43], [44, 45]], [[46, 47], [48, 49]]]'); +-- +ok +== +INSERT INTO array_tbl_three_level VALUES('[[[12, 13], [14, 15]], [[16, 17], [18, 19]]]'); +-- +ok +== +SELECT c50 FROM array_tbl_three_level GROUP BY ALL USING SAMPLE 3 ORDER BY ALL; +-- +ok +== diff --git a/parser/testdata/corpus/fuzzer/duckfuzz/array_hash.test b/parser/testdata/corpus/fuzzer/duckfuzz/array_hash.test new file mode 100644 index 0000000..e9e3869 --- /dev/null +++ b/parser/testdata/corpus/fuzzer/duckfuzz/array_hash.test @@ -0,0 +1,23 @@ +# source: test/fuzzer/duckfuzz/array_hash.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +PRAGMA threads = 1 +-- +ok +== +SELECT subq_0.c2 AS c4 +FROM ( + SELECT ref_1.fixed_nested_int_array AS c2 + FROM main.all_types AS ref_0 + LEFT JOIN main.all_types + AS ref_1 + ON ((ref_0."varchar" !~~* ref_1."varchar")) + ) AS subq_0 +RIGHT JOIN main.all_types + AS ref_2 + ON ((subq_0.c2 IS NOT DISTINCT FROM ref_2.fixed_nested_int_array)) +-- +ok +== diff --git a/parser/testdata/corpus/fuzzer/duckfuzz/array_list_gather_cast.test b/parser/testdata/corpus/fuzzer/duckfuzz/array_list_gather_cast.test new file mode 100644 index 0000000..978959a --- /dev/null +++ b/parser/testdata/corpus/fuzzer/duckfuzz/array_list_gather_cast.test @@ -0,0 +1,22 @@ +# source: test/fuzzer/duckfuzz/array_list_gather_cast.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +create table my_table as select * exclude(small_enum, medium_enum, large_enum) from test_all_types(); +-- +ok +== +FROM main.my_table ref_0 + INNER JOIN + main.my_table AS ref_1 + ON ( + SELECT + ref_1.struct_of_arrays AS c6 + FROM main.my_table AS ref_2 + WHERE + EXISTS(SELECT ref_2.fixed_nested_varchar_array WHERE ref_1."union") + ) and ref_1."varchar" ~~ ref_1."varchar"; +-- +ok +== diff --git a/parser/testdata/corpus/fuzzer/duckfuzz/array_serialization_flattening.test b/parser/testdata/corpus/fuzzer/duckfuzz/array_serialization_flattening.test new file mode 100644 index 0000000..647ed73 --- /dev/null +++ b/parser/testdata/corpus/fuzzer/duckfuzz/array_serialization_flattening.test @@ -0,0 +1,13 @@ +# source: test/fuzzer/duckfuzz/array_serialization_flattening.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +CREATE TABLE test(c2 BOOL, c48 STRUCT(a INTEGER[3], b VARCHAR[3]));; +-- +ok +== +INSERT INTO test VALUES(false, '{''a'': [NULL, 2, 3], ''b'': [a, NULL, c]}'); +-- +ok +== diff --git a/parser/testdata/corpus/fuzzer/duckfuzz/array_slice_nullness.test b/parser/testdata/corpus/fuzzer/duckfuzz/array_slice_nullness.test new file mode 100644 index 0000000..099ebc6 --- /dev/null +++ b/parser/testdata/corpus/fuzzer/duckfuzz/array_slice_nullness.test @@ -0,0 +1,13 @@ +# source: test/fuzzer/duckfuzz/array_slice_nullness.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +SELECT array_reverse(NULL::INTEGER[]) +-- +ok +== +SELECT NULL LIMIT array_reverse(TRY_CAST(5722 AS TIMESTAMP WITH TIME ZONE[])) +-- +ok +== diff --git a/parser/testdata/corpus/fuzzer/duckfuzz/array_slice_underflow.test b/parser/testdata/corpus/fuzzer/duckfuzz/array_slice_underflow.test new file mode 100644 index 0000000..eb9b868 --- /dev/null +++ b/parser/testdata/corpus/fuzzer/duckfuzz/array_slice_underflow.test @@ -0,0 +1,13 @@ +# source: test/fuzzer/duckfuzz/array_slice_underflow.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +SELECT ([1, 2, 3])[0:-9223372036854775808]; +-- +ok +== +SELECT ([1, 2, 3])[-9223372036854775808:0]; +-- +ok +== diff --git a/parser/testdata/corpus/fuzzer/duckfuzz/array_slice_vector_type.test b/parser/testdata/corpus/fuzzer/duckfuzz/array_slice_vector_type.test new file mode 100644 index 0000000..eb79341 --- /dev/null +++ b/parser/testdata/corpus/fuzzer/duckfuzz/array_slice_vector_type.test @@ -0,0 +1,46 @@ +# source: test/fuzzer/duckfuzz/array_slice_vector_type.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +SELECT + length(original) == length(altered) + 1 +from ( + select + x as original, + array_pop_front(x) as altered + FROM test_vector_types('x') AS t1(x) +); +-- +ok +== +select case + when x IS NULL + then + NULL + else + true + end + from test_vector_types('x') t1(x); +-- +ok +== +create table tbl (i integer[]); +-- +ok +== +insert into tbl VALUES +(NULL), +([5,3,2,1]), +(NULL), +(NULL), +([1]), +([NULL]), +([345,2,31,23,123,1,2,1,1,1]) +-- +ok +== +select array_pop_front(i) from tbl; +-- +ok +== diff --git a/parser/testdata/corpus/fuzzer/duckfuzz/arrow_scan_subquery_nullptr.test b/parser/testdata/corpus/fuzzer/duckfuzz/arrow_scan_subquery_nullptr.test new file mode 100644 index 0000000..9a15807 --- /dev/null +++ b/parser/testdata/corpus/fuzzer/duckfuzz/arrow_scan_subquery_nullptr.test @@ -0,0 +1,9 @@ +# source: test/fuzzer/duckfuzz/arrow_scan_subquery_nullptr.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +SELECT * FROM (SELECT * FROM arrow_scan(NULL, NULL, NULL)); +-- +ok +== diff --git a/parser/testdata/corpus/fuzzer/duckfuzz/bitstring_agg_minmax.test b/parser/testdata/corpus/fuzzer/duckfuzz/bitstring_agg_minmax.test new file mode 100644 index 0000000..7de53ca --- /dev/null +++ b/parser/testdata/corpus/fuzzer/duckfuzz/bitstring_agg_minmax.test @@ -0,0 +1,25 @@ +# source: test/fuzzer/duckfuzz/bitstring_agg_minmax.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +select bitstring_agg(4741, 1706, -128); +-- +ok +== +select bitstring_agg(4741, 1706, 1706); +-- +ok +== +select bitstring_agg(1706, 1706, 1706); +-- +ok +== +select bitstring_agg(4741::hugeint, 1706::hugeint, -128::hugeint); +-- +ok +== +select bitstring_agg(4741::uhugeint, 1706::uhugeint, 40::uhugeint); +-- +ok +== diff --git a/parser/testdata/corpus/fuzzer/duckfuzz/bitstring_agg_uhugeint.test b/parser/testdata/corpus/fuzzer/duckfuzz/bitstring_agg_uhugeint.test new file mode 100644 index 0000000..056a912 --- /dev/null +++ b/parser/testdata/corpus/fuzzer/duckfuzz/bitstring_agg_uhugeint.test @@ -0,0 +1,17 @@ +# source: test/fuzzer/duckfuzz/bitstring_agg_uhugeint.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +create table all_types as select hugeint, uhugeint from test_all_types(); +-- +ok +== +SELECT bitstring_agg(uhugeint) FROM all_types; +-- +ok +== +SELECT bitstring_agg(hugeint) FROM all_types; +-- +ok +== diff --git a/parser/testdata/corpus/fuzzer/duckfuzz/bitstring_agg_unfoldable.test b/parser/testdata/corpus/fuzzer/duckfuzz/bitstring_agg_unfoldable.test new file mode 100644 index 0000000..d4679d6 --- /dev/null +++ b/parser/testdata/corpus/fuzzer/duckfuzz/bitstring_agg_unfoldable.test @@ -0,0 +1,25 @@ +# source: test/fuzzer/duckfuzz/bitstring_agg_unfoldable.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +SELECT bitstring_agg(i, i, 42) FROM range(10) t(i); +-- +ok +== +SELECT bitstring_agg(i, 42, i) FROM range(10) t(i); +-- +ok +== +SELECT bitstring_agg(i, 0, (100 + random())::BIGINT) FROM range(10) t(i); +-- +ok +== +PRAGMA disable_verification +-- +ok +== +SELECT bitstring_agg(i, 0, 3) FROM range(10) t(i); +-- +ok +== diff --git a/parser/testdata/corpus/fuzzer/duckfuzz/column_alias_exist.test b/parser/testdata/corpus/fuzzer/duckfuzz/column_alias_exist.test new file mode 100644 index 0000000..e5039a3 --- /dev/null +++ b/parser/testdata/corpus/fuzzer/duckfuzz/column_alias_exist.test @@ -0,0 +1,13 @@ +# source: test/fuzzer/duckfuzz/column_alias_exist.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +create table all_types as select * exclude(small_enum, medium_enum, large_enum) from test_all_types() limit 0 +-- +ok +== +SELECT COLUMNS(*) FROM all_types AS t52(c1, c2, c3, c4, c5, c6, c7, c8, c9, c10, c11, c12, c13, c14, c15, c16, c17, c18, c19, c20, c21, c22, c23, c24, c25, c26, c27, c28, c29, c30, c31, c32, c33, c34, c35, c36, c37, c38, c39, c40, c41, c42, c43, c44, c45, c46, c47, c48, c49, c50, c51) GROUP BY ALL HAVING c51 +-- +ok +== diff --git a/parser/testdata/corpus/fuzzer/duckfuzz/complex_join_cardinality_assert.test b/parser/testdata/corpus/fuzzer/duckfuzz/complex_join_cardinality_assert.test new file mode 100644 index 0000000..eb2507a --- /dev/null +++ b/parser/testdata/corpus/fuzzer/duckfuzz/complex_join_cardinality_assert.test @@ -0,0 +1,13 @@ +# source: test/fuzzer/duckfuzz/complex_join_cardinality_assert.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +create table integers(i int); +-- +ok +== +SELECT NULL FROM integers AS t1 RIGHT JOIN integers AS t2 ON (NULL) WHERE EXISTS(SELECT NULL FROM integers AS t3 INNER JOIN integers ON ((t3.i + t1.i)) , (SELECT t2.i AS c0)) +-- +ok +== diff --git a/parser/testdata/corpus/fuzzer/duckfuzz/compressed_materialization_hugeint.test b/parser/testdata/corpus/fuzzer/duckfuzz/compressed_materialization_hugeint.test new file mode 100644 index 0000000..093729e --- /dev/null +++ b/parser/testdata/corpus/fuzzer/duckfuzz/compressed_materialization_hugeint.test @@ -0,0 +1,13 @@ +# source: test/fuzzer/duckfuzz/compressed_materialization_hugeint.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +SELECT DISTINCT TRY_CAST(COLUMNS(*) AS HUGEINT) FROM all_types AS t51(c1, c2, c3, c4, c5, c6, c7, c8, c9, c10, c11, c12, c13, c14, c15, c16, c17, c18, c19, c20, c21, c22, c23, c24, c25, c26, c27, c28, c29, c30, c31, c32, c33, c34, c35, c36, c37, c38, c39, c40, c41, c42, c43, c44, c45, c46, c47, c48, c49, c50) ORDER BY c14 DESC NULLS FIRST +-- +ok +== +SELECT DISTINCT TRY_CAST(COLUMNS(*) AS UHUGEINT) FROM all_types AS t51(c1, c2, c3, c4, c5, c6, c7, c8, c9, c10, c11, c12, c13, c14, c15, c16, c17, c18, c19, c20, c21, c22, c23, c24, c25, c26, c27, c28, c29, c30, c31, c32, c33, c34, c35, c36, c37, c38, c39, c40, c41, c42, c43, c44, c45, c46, c47, c48, c49, c50) ORDER BY c14 DESC NULLS FIRST +-- +ok +== diff --git a/parser/testdata/corpus/fuzzer/duckfuzz/compressed_materialization_json.test b/parser/testdata/corpus/fuzzer/duckfuzz/compressed_materialization_json.test new file mode 100644 index 0000000..38f4e2d --- /dev/null +++ b/parser/testdata/corpus/fuzzer/duckfuzz/compressed_materialization_json.test @@ -0,0 +1,9 @@ +# source: test/fuzzer/duckfuzz/compressed_materialization_json.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +select distinct json_array(); +-- +ok +== diff --git a/parser/testdata/corpus/fuzzer/duckfuzz/correlated_subqueries.test b/parser/testdata/corpus/fuzzer/duckfuzz/correlated_subqueries.test new file mode 100644 index 0000000..bd30418 --- /dev/null +++ b/parser/testdata/corpus/fuzzer/duckfuzz/correlated_subqueries.test @@ -0,0 +1,43 @@ +# source: test/fuzzer/duckfuzz/correlated_subqueries.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +CREATE TABLE mytable(i INT) +-- +ok +== +SELECT + ( + SELECT + ( + SELECT (SELECT ref_2.i) + FROM mytable AS ref_2 + ) + WHERE + ( + SELECT subq_0.i AS c1 + ) + ) +FROM mytable AS subq_0 +-- +ok +== +create table all_types as select * exclude(small_enum, medium_enum, large_enum) from test_all_types() limit 0; +-- +ok +== +SELECT +NULL +FROM main.all_types AS ref_0 +WHERE +EXISTS( + SELECT EXISTS( + SELECT NULL + FROM main.all_types AS ref_3 + WHERE EXISTS(SELECT NULL WHERE ref_3."varchar") + ) + FROM (SELECT NULL WHERE EXISTS(SELECT NULL WHERE ref_0."varchar"))) +-- +ok +== diff --git a/parser/testdata/corpus/fuzzer/duckfuzz/corrupted_parquet.test b/parser/testdata/corpus/fuzzer/duckfuzz/corrupted_parquet.test new file mode 100644 index 0000000..a3031b5 --- /dev/null +++ b/parser/testdata/corpus/fuzzer/duckfuzz/corrupted_parquet.test @@ -0,0 +1,15 @@ +# source: test/fuzzer/duckfuzz/corrupted_parquet.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +from read_parquet('data/parquet-testing/broken/fuzzer4360.parquet', filename=true, filename=map { + 1: {name: 'cool_column', type: 'VARCHAR', default_value: NULL} + }); +-- +ok +== +from read_parquet('data/parquet-testing/broken/fuzzer4362.parquet', union_by_name=true); +-- +ok +== diff --git a/parser/testdata/corpus/fuzzer/duckfuzz/create_sort_key_strings.test b/parser/testdata/corpus/fuzzer/duckfuzz/create_sort_key_strings.test new file mode 100644 index 0000000..e4a738c --- /dev/null +++ b/parser/testdata/corpus/fuzzer/duckfuzz/create_sort_key_strings.test @@ -0,0 +1,25 @@ +# source: test/fuzzer/duckfuzz/create_sort_key_strings.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +CREATE TABLE t2(c38 STRUCT(a INTEGER, b VARCHAR)); +-- +ok +== +INSERT INTO t2 VALUES({'a': NULL, 'b': NULL}); +-- +ok +== +INSERT INTO t2 VALUES({'a': 42, 'b': '🦆🦆🦆🦆🦆🦆'}); +-- +ok +== +INSERT INTO t2 VALUES(NULL); +-- +ok +== +SELECT any_value(NULL ORDER BY c38 ASC) FROM t2 +-- +ok +== diff --git a/parser/testdata/corpus/fuzzer/duckfuzz/duck_fuzz_column_binding_tests.test b/parser/testdata/corpus/fuzzer/duckfuzz/duck_fuzz_column_binding_tests.test new file mode 100644 index 0000000..b8d67fb --- /dev/null +++ b/parser/testdata/corpus/fuzzer/duckfuzz/duck_fuzz_column_binding_tests.test @@ -0,0 +1,21 @@ +# source: test/fuzzer/duckfuzz/duck_fuzz_column_binding_tests.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +SELECT ref_8.uint AS c0, + Argmin(Cast(ref_8."timestamp" AS TIMESTAMP), Cast(ref_10."timestamp" AS TIMESTAMP)) OVER (partition BY ref_10."nested_int_array", ref_10."timestamp" ORDER BY ref_8.hugeint) AS c1 +FROM main.all_types AS ref_8 +INNER JOIN main.all_types AS ref_9 +INNER JOIN main.all_types AS ref_10 +ON ( ref_10.dec38_10 IS NOT NULL) + OR EXISTS + ( SELECT ref_9."float" FROM main.all_types) +ON ((ref_9."smallint" = ref_8."smallint")) +-- +ok +== +SELECT subq_0.c6 AS c1, subq_0.c14 AS c2, subq_0.c7 AS c4, subq_0.c4 AS c5 FROM (SELECT (SELECT date FROM main.all_types LIMIT 1 OFFSET 6) AS c3, ref_2."time" AS c4, (SELECT uuid FROM main.all_types LIMIT 1 OFFSET 1) AS c5, ref_3.array_of_structs AS c6, CASE WHEN (((ref_0."varchar" !~~* ref_1."varchar") OR (ref_5."varchar" ~~~ ref_6."varchar"))) THEN (ref_2."bigint") ELSE ref_2."bigint" END AS c7, rtrim(CAST(CASE WHEN ((((ref_8."varchar" ~~~ ref_2."varchar") AND (ref_2."varchar" ~~~ ref_0."varchar")) OR (1 AND (ref_7."varchar" ~~ ref_2."varchar")))) THEN (ref_8."varchar") ELSE ref_8."varchar" END AS VARCHAR), CAST(ref_2."varchar" AS VARCHAR)) AS c9, ref_8.ubigint AS c14 FROM main.all_types AS ref_0 INNER JOIN main.all_types AS ref_1 INNER JOIN main.all_types AS ref_2 ON ((ref_1.int_array = ref_2.int_array)) ON (((ref_2."varchar" !~~ ref_1."varchar") OR (ref_1.blob IS NOT NULL))) INNER JOIN main.all_types AS ref_3 INNER JOIN main.all_types AS ref_4 RIGHT JOIN main.all_types AS ref_5 ON ((ref_4.dec_18_6 = ref_5.dec_18_6)) ON (ref_5."varchar") LEFT JOIN main.all_types AS ref_6 RIGHT JOIN main.all_types AS ref_7 INNER JOIN main.all_types AS ref_8 ON ((ref_7.timestamp_array = ref_8.timestamp_array)) ON (1) ON (NULL) ON ((ref_0.dec_18_6 = ref_3.dec_18_6)) WHERE (ref_5."varchar" ^@ (SELECT "varchar" FROM main.all_types LIMIT 1 OFFSET 6)) LIMIT 96) AS subq_0 WHERE subq_0.c9; +-- +ok +== diff --git a/parser/testdata/corpus/fuzzer/duckfuzz/duckdb_fuzzer_4430.test b/parser/testdata/corpus/fuzzer/duckfuzz/duckdb_fuzzer_4430.test new file mode 100644 index 0000000..9a5404a --- /dev/null +++ b/parser/testdata/corpus/fuzzer/duckfuzz/duckdb_fuzzer_4430.test @@ -0,0 +1,29 @@ +# source: test/fuzzer/duckfuzz/duckdb_fuzzer_4430.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +ATTACH '{TEST_DIR}/duckdb_fuzzer_4430.db' AS db1 +-- +ok +== +BEGIN +-- +ok +== +CREATE TABLE db1.tbl(i INTEGER) +-- +ok +== +DETACH db1 +-- +ok +== +ROLLBACK +-- +ok +== +SELECT * FROM db1.tbl +-- +ok +== diff --git a/parser/testdata/corpus/fuzzer/duckfuzz/empty_result_pullup_delim_joins.test b/parser/testdata/corpus/fuzzer/duckfuzz/empty_result_pullup_delim_joins.test new file mode 100644 index 0000000..1ebfa9a --- /dev/null +++ b/parser/testdata/corpus/fuzzer/duckfuzz/empty_result_pullup_delim_joins.test @@ -0,0 +1,30 @@ +# source: test/fuzzer/duckfuzz/empty_result_pullup_delim_joins.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +call dbgen(sf=0.1); +-- +ok +== +SELECT + NULL +FROM +main.partsupp AS ref_1 +INNER JOIN main.region ON (NULL) +INNER JOIN main.customer AS ref_3 ON +(EXISTS(SELECT NULL FROM (SELECT ref_3.c_acctbal AS c0))) +INNER JOIN +(SELECT + ref_9.s_phone AS c0, + ref_8.r_regionkey AS c1, + ref_9.s_phone AS c2 +FROM main.region AS ref_8 +RIGHT JOIN + main.supplier AS ref_9 ON ((1 AND (ref_9.s_comment ~~ ref_9.s_address) AND 0 AND (ref_9.s_name !~~ ref_9.s_name))) +LEFT JOIN main.customer AS ref_10 ON ((ref_10.c_address ~~* ref_10.c_comment)) +WHERE (ref_9.s_phone IS NOT NULL) LIMIT 53) AS subq_2 +ON ((CASE WHEN (1) THEN (subq_2.c2) ELSE subq_2.c2 END !~~ ref_1.ps_comment)) +-- +ok +== diff --git a/parser/testdata/corpus/fuzzer/duckfuzz/enum_const_cast.test b/parser/testdata/corpus/fuzzer/duckfuzz/enum_const_cast.test new file mode 100644 index 0000000..7b34401 --- /dev/null +++ b/parser/testdata/corpus/fuzzer/duckfuzz/enum_const_cast.test @@ -0,0 +1,9 @@ +# source: test/fuzzer/duckfuzz/enum_const_cast.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +SELECT CAST(TRY_CAST((ceil(2918) AND shobj_description(5, (NOT 6203))) AS ENUM('enum_0', 'enum_1', 'enum_2', 'enum_3', 'enum_4', 'enum_5', 'enum_6', 'enum_7', 'enum_8', 'enum_9', 'enum_10', 'enum_11', 'enum_12', 'enum_13', 'enum_14', 'enum_15', 'enum_16', 'enum_17', 'enum_18', 'enum_19', 'enum_20', 'enum_21', 'enum_22', 'enum_23', 'enum_24', 'enum_25', 'enum_26', 'enum_27', 'enum_28', 'enum_29', 'enum_30', 'enum_31', 'enum_32', 'enum_33', 'enum_34', 'enum_35', 'enum_36', 'enum_37', 'enum_38', 'enum_39', 'enum_40', 'enum_41', 'enum_42', 'enum_43', 'enum_44', 'enum_45', 'enum_46', 'enum_47', 'enum_48', 'enum_49', 'enum_50', 'enum_51', 'enum_52', 'enum_53', 'enum_54', 'enum_55', 'enum_56', 'enum_57', 'enum_58', 'enum_59', 'enum_60', 'enum_61', 'enum_62', 'enum_63', 'enum_64', 'enum_65', 'enum_66', 'enum_67', 'enum_68', 'enum_69', 'enum_70', 'enum_71', 'enum_72', 'enum_73', 'enum_74', 'enum_75', 'enum_76', 'enum_77', 'enum_78', 'enum_79', 'enum_80', 'enum_81', 'enum_82', 'enum_83', 'enum_84', 'enum_85', 'enum_86', 'enum_87', 'enum_88', 'enum_89', 'enum_90', 'enum_91', 'enum_92', 'enum_93', 'enum_94', 'enum_95', 'enum_96', 'enum_97', 'enum_98', 'enum_99', 'enum_100', 'enum_101', 'enum_102', 'enum_103', 'enum_104', 'enum_105', 'enum_106', 'enum_107', 'enum_108', 'enum_109', 'enum_110', 'enum_111', 'enum_112', 'enum_113', 'enum_114', 'enum_115', 'enum_116', 'enum_117', 'enum_118', 'enum_119', 'enum_120', 'enum_121', 'enum_122', 'enum_123', 'enum_124', 'enum_125', 'enum_126', 'enum_127', 'enum_128', 'enum_129', 'enum_130', 'enum_131', 'enum_132', 'enum_133', 'enum_134', 'enum_135', 'enum_136', 'enum_137', 'enum_138', 'enum_139', 'enum_140', 'enum_141', 'enum_142', 'enum_143', 'enum_144', 'enum_145', 'enum_146', 'enum_147', 'enum_148', 'enum_149', 'enum_150', 'enum_151', 'enum_152', 'enum_153', 'enum_154', 'enum_155', 'enum_156', 'enum_157', 'enum_158', 'enum_159', 'enum_160', 'enum_161', 'enum_162', 'enum_163', 'enum_164', 'enum_165', 'enum_166', 'enum_167', 'enum_168', 'enum_169', 'enum_170', 'enum_171', 'enum_172', 'enum_173', 'enum_174', 'enum_175', 'enum_176', 'enum_177', 'enum_178', 'enum_179', 'enum_180', 'enum_181', 'enum_182', 'enum_183', 'enum_184', 'enum_185', 'enum_186', 'enum_187', 'enum_188', 'enum_189', 'enum_190', 'enum_191', 'enum_192', 'enum_193', 'enum_194', 'enum_195', 'enum_196', 'enum_197', 'enum_198', 'enum_199', 'enum_200', 'enum_201', 'enum_202', 'enum_203', 'enum_204', 'enum_205', 'enum_206', 'enum_207', 'enum_208', 'enum_209', 'enum_210', 'enum_211', 'enum_212', 'enum_213', 'enum_214', 'enum_215', 'enum_216', 'enum_217', 'enum_218', 'enum_219', 'enum_220', 'enum_221', 'enum_222', 'enum_223', 'enum_224', 'enum_225', 'enum_226', 'enum_227', 'enum_228', 'enum_229', 'enum_230', 'enum_231', 'enum_232', 'enum_233', 'enum_234', 'enum_235', 'enum_236', 'enum_237', 'enum_238', 'enum_239', 'enum_240', 'enum_241', 'enum_242', 'enum_243', 'enum_244', 'enum_245', 'enum_246', 'enum_247', 'enum_248', 'enum_249', 'enum_250', 'enum_251', 'enum_252', 'enum_253', 'enum_254', 'enum_255', 'enum_256', 'enum_257', 'enum_258', 'enum_259', 'enum_260', 'enum_261', 'enum_262', 'enum_263', 'enum_264', 'enum_265', 'enum_266', 'enum_267', 'enum_268', 'enum_269', 'enum_270', 'enum_271', 'enum_272', 'enum_273', 'enum_274', 'enum_275', 'enum_276', 'enum_277', 'enum_278', 'enum_279', 'enum_280', 'enum_281', 'enum_282', 'enum_283', 'enum_284', 'enum_285', 'enum_286', 'enum_287', 'enum_288', 'enum_289', 'enum_290', 'enum_291', 'enum_292', 'enum_293', 'enum_294', 'enum_295', 'enum_296', 'enum_297', 'enum_298', 'enum_299')) AS ENUM('enum_0', 'enum_69999')) +-- +ok +== diff --git a/parser/testdata/corpus/fuzzer/duckfuzz/filter_combiner_assert.test b/parser/testdata/corpus/fuzzer/duckfuzz/filter_combiner_assert.test new file mode 100644 index 0000000..4c87e12 --- /dev/null +++ b/parser/testdata/corpus/fuzzer/duckfuzz/filter_combiner_assert.test @@ -0,0 +1,13 @@ +# source: test/fuzzer/duckfuzz/filter_combiner_assert.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +CREATE TABLE partsupp(ps_partkey INTEGER, ps_suppkey INTEGER, ps_availqty INTEGER, ps_supplycost DECIMAL(15,2), ps_comment VARCHAR); +-- +ok +== +SELECT NULL FROM partsupp AS t6(c1, c2, c3, c4, c5) WHERE (c4 = COLUMNS(* REPLACE (3947 AS c3))) +-- +ok +== diff --git a/parser/testdata/corpus/fuzzer/duckfuzz/fuzzer_issue_2698.test b/parser/testdata/corpus/fuzzer/duckfuzz/fuzzer_issue_2698.test new file mode 100644 index 0000000..13d40e8 --- /dev/null +++ b/parser/testdata/corpus/fuzzer/duckfuzz/fuzzer_issue_2698.test @@ -0,0 +1,9 @@ +# source: test/fuzzer/duckfuzz/fuzzer_issue_2698.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +SELECT (TRY_CAST(5572 AS INTEGER[3][3]) BETWEEN json(c48) AND NULL) FROM all_types AS t51(c1, c2, c3, c4, c5, c6, c7, c8, c9, c10, c11, c12, c13, c14, c15, c16, c17, c18, c19, c20, c21, c22, c23, c24, c25, c26, c27, c28, c29, c30, c31, c32, c33, c34, c35, c36, c37, c38, c39, c40, c41, c42, c43, c44, c45, c46, c47, c48, c49, c50); +-- +ok +== diff --git a/parser/testdata/corpus/fuzzer/duckfuzz/fuzzer_issue_2980.test b/parser/testdata/corpus/fuzzer/duckfuzz/fuzzer_issue_2980.test new file mode 100644 index 0000000..cbcfce2 --- /dev/null +++ b/parser/testdata/corpus/fuzzer/duckfuzz/fuzzer_issue_2980.test @@ -0,0 +1,9 @@ +# source: test/fuzzer/duckfuzz/fuzzer_issue_2980.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +SELECT DISTINCT NULL FROM query_table(NULL, NULL) AS t6(c1, c2, c3, c4, c5) , region AS t10(c7, c8, c9) HAVING TRY_CAST(c3 AS STRUCT(a INTEGER, b VARCHAR)[3]) QUALIFY (c3 BETWEEN c8 AND (c4 BETWEEN c4 AND c5)); +-- +ok +== diff --git a/parser/testdata/corpus/fuzzer/duckfuzz/fuzzer_issue_4325.test b/parser/testdata/corpus/fuzzer/duckfuzz/fuzzer_issue_4325.test new file mode 100644 index 0000000..ceca0e2 --- /dev/null +++ b/parser/testdata/corpus/fuzzer/duckfuzz/fuzzer_issue_4325.test @@ -0,0 +1,9 @@ +# source: test/fuzzer/duckfuzz/fuzzer_issue_4325.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +SELECT NULL FROM (VALUES (0, 1, 2, 3, 4)) AS _("0", "1", "2", "3", "4") INNER JOIN (SELECT NULL LIMIT rank_dense() OVER (PARTITION BY #4, NULL, NULL, NULL ROWS BETWEEN c83 PRECEDING AND CURRENT ROW)) USING (c19) +-- +ok +== diff --git a/parser/testdata/corpus/fuzzer/duckfuzz/generate_null_timestamp.test b/parser/testdata/corpus/fuzzer/duckfuzz/generate_null_timestamp.test new file mode 100644 index 0000000..6ccb54d --- /dev/null +++ b/parser/testdata/corpus/fuzzer/duckfuzz/generate_null_timestamp.test @@ -0,0 +1,10 @@ +# source: test/fuzzer/duckfuzz/generate_null_timestamp.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +SELECT NULL +FROM generate_series(CAST('294247-01-10 04:00:54.775806' AS TIMESTAMP), NULL, NULL) AS t3(c1, c2) +-- +ok +== diff --git a/parser/testdata/corpus/fuzzer/duckfuzz/group_by_all_positional_ref.test b/parser/testdata/corpus/fuzzer/duckfuzz/group_by_all_positional_ref.test new file mode 100644 index 0000000..d433453 --- /dev/null +++ b/parser/testdata/corpus/fuzzer/duckfuzz/group_by_all_positional_ref.test @@ -0,0 +1,13 @@ +# source: test/fuzzer/duckfuzz/group_by_all_positional_ref.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +create table integers(c1 int, c2 int); +-- +ok +== +SELECT c1, #2 FROM integers GROUP BY ALL +-- +ok +== diff --git a/parser/testdata/corpus/fuzzer/duckfuzz/hash_constant.test b/parser/testdata/corpus/fuzzer/duckfuzz/hash_constant.test new file mode 100644 index 0000000..38bc1f2 --- /dev/null +++ b/parser/testdata/corpus/fuzzer/duckfuzz/hash_constant.test @@ -0,0 +1,9 @@ +# source: test/fuzzer/duckfuzz/hash_constant.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +SELECT hash(main.list_value(main.list_value(), main.list_value(42, 999, NULL, NULL, -42), NULL, main.list_value(), main.list_value(42, 999, NULL, NULL, -42))) FROM all_types; +-- +ok +== diff --git a/parser/testdata/corpus/fuzzer/duckfuzz/having_window_bind.test b/parser/testdata/corpus/fuzzer/duckfuzz/having_window_bind.test new file mode 100644 index 0000000..1f94290 --- /dev/null +++ b/parser/testdata/corpus/fuzzer/duckfuzz/having_window_bind.test @@ -0,0 +1,47 @@ +# source: test/fuzzer/duckfuzz/having_window_bind.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +call dbgen(sf=0); +-- +ok +== +SELECT + DISTINCT c7, + (c3 < NULL), + c9 +FROM + ( + SELECT + DISTINCT c8, + c2, + rank() OVER ( + ORDER BY + c6 RANGE BETWEEN CURRENT ROW + AND c2 FOLLOWING + ) + FROM + nation AS t5(c1, c2, c3, c4) ASOF + INNER JOIN ( + SELECT + DISTINCT c1 + FROM + nation AS t10(c6, c7, c8, c9) + HAVING + nth_value( + c8, + #8) OVER ( + RANGE BETWEEN '24:00:00-15:59:59'::TIME WITH TIME ZONE PRECEDING + AND 'c7607984-ed9f-4f50-a6e3-62b94b3a6e9c' PRECEDING) + USING SAMPLE 19% (System) + ORDER BY * DESC NULLS FIRST + ) AS t11 ON (8252) + WHERE 'enum_299' + HAVING c2 + ORDER BY * + ) AS t12 +ORDER BY * ASC; +-- +ok +== diff --git a/parser/testdata/corpus/fuzzer/duckfuzz/hugeint_negate_underflow.test b/parser/testdata/corpus/fuzzer/duckfuzz/hugeint_negate_underflow.test new file mode 100644 index 0000000..10b5ef1 --- /dev/null +++ b/parser/testdata/corpus/fuzzer/duckfuzz/hugeint_negate_underflow.test @@ -0,0 +1,9 @@ +# source: test/fuzzer/duckfuzz/hugeint_negate_underflow.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +select -(-170141183460469231731687303715884105728)::HUGEINT; +-- +ok +== diff --git a/parser/testdata/corpus/fuzzer/duckfuzz/invalid_make_time.test b/parser/testdata/corpus/fuzzer/duckfuzz/invalid_make_time.test new file mode 100644 index 0000000..bf03c8b --- /dev/null +++ b/parser/testdata/corpus/fuzzer/duckfuzz/invalid_make_time.test @@ -0,0 +1,33 @@ +# source: test/fuzzer/duckfuzz/invalid_make_time.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +SELECT make_time(64, 64, 157); +-- +ok +== +SELECT make_time(-1, 64, 157); +-- +ok +== +SELECT make_time(1, 64, 157); +-- +ok +== +SELECT make_time(1, -1, 157); +-- +ok +== +SELECT make_time(1, 1, -1); +-- +ok +== +SELECT make_time(1, 1, 157); +-- +ok +== +SELECT make_time(1, 1, 9999999); +-- +ok +== diff --git a/parser/testdata/corpus/fuzzer/duckfuzz/json_execute_serialized_null.test b/parser/testdata/corpus/fuzzer/duckfuzz/json_execute_serialized_null.test new file mode 100644 index 0000000..96382b0 --- /dev/null +++ b/parser/testdata/corpus/fuzzer/duckfuzz/json_execute_serialized_null.test @@ -0,0 +1,13 @@ +# source: test/fuzzer/duckfuzz/json_execute_serialized_null.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +call dbgen(sf=0.01); +-- +ok +== +SELECT lead(c9, c18) OVER (ORDER BY 2399 DESC NULLS FIRST ROWS BETWEEN c2 PRECEDING AND #10 FOLLOWING) FROM (SELECT c4 FROM json_execute_serialized_sql(NULL) AS t5(c1, c2, c3, c4)) AS t6 , (SELECT * FROM (SELECT * FROM (SELECT * FROM (SELECT * FROM (SELECT * FROM (SELECT * FROM (SELECT * FROM (SELECT * FROM (VALUES (3579, 426, main.list_value(), 5272, CAST('290309-12-22 (BC) 00:00:00' AS TIMESTAMP_S), '356f1b18-7a3d-417e-97eb-710eae92f600', NULL, 634), (CAST('290309-12-22 (BC) 00:00:00' AS TIMESTAMP), NULL, 1138, NULL, NULL, 8922, 1726, 5539), (main.list_value(42.0, CAST('nan' AS DOUBLE), 1e1000, -1e1000, NULL, -42.0), 'enum_69999', 'dcf24776-2f79-4878-a175-8daabf453cd0', '9d4c7f67-bdcb-46c5-bd44-1d04be3b94ab', NULL, 9021, 1124, 6294)) AS valueslist) AS valueslist) AS valueslist) AS valueslist) AS valueslist) AS valueslist) AS valueslist) AS valueslist) FULL JOIN lineitem AS t23(c7, c8, c9, c10, c11, c12, c13, c14, c15, c16, c17, c18, c19, c20, c21, c22) ON (c8); +-- +ok +== diff --git a/parser/testdata/corpus/fuzzer/duckfuzz/json_extract_null.test b/parser/testdata/corpus/fuzzer/duckfuzz/json_extract_null.test new file mode 100644 index 0000000..c3e2bbb --- /dev/null +++ b/parser/testdata/corpus/fuzzer/duckfuzz/json_extract_null.test @@ -0,0 +1,9 @@ +# source: test/fuzzer/duckfuzz/json_extract_null.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +SELECT json_extract('hello world', CAST(NULL AS json)) AS c1 +-- +ok +== diff --git a/parser/testdata/corpus/fuzzer/duckfuzz/json_extract_string_null.test b/parser/testdata/corpus/fuzzer/duckfuzz/json_extract_string_null.test new file mode 100644 index 0000000..85cded0 --- /dev/null +++ b/parser/testdata/corpus/fuzzer/duckfuzz/json_extract_string_null.test @@ -0,0 +1,13 @@ +# source: test/fuzzer/duckfuzz/json_extract_string_null.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +insert into integers values (1); +-- +ok +== +SELECT json_extract_string(false, COALESCE(CASE WHEN (i) THEN (CAST(NULL AS "json")) ELSE NULL END, NULL)) FROM integers; +-- +ok +== diff --git a/parser/testdata/corpus/fuzzer/duckfuzz/json_functions_null_params.test b/parser/testdata/corpus/fuzzer/duckfuzz/json_functions_null_params.test new file mode 100644 index 0000000..3fd6ccc --- /dev/null +++ b/parser/testdata/corpus/fuzzer/duckfuzz/json_functions_null_params.test @@ -0,0 +1,25 @@ +# source: test/fuzzer/duckfuzz/json_functions_null_params.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +SELECT from_json('{"duck": 42}', NULL::JSON) +-- +ok +== +SELECT json_extract('{"duck": 42}', NULL::VARCHAR[]) +-- +ok +== +SELECT json_keys('{"duck": 42}', NULL::VARCHAR[]) +-- +ok +== +SELECT json_valid(NULL) +-- +ok +== +SELECT json_extract('{"duck": 42}', NULL::VARCHAR) +-- +ok +== diff --git a/parser/testdata/corpus/fuzzer/duckfuzz/julian_overflow.test b/parser/testdata/corpus/fuzzer/duckfuzz/julian_overflow.test new file mode 100644 index 0000000..dce329a --- /dev/null +++ b/parser/testdata/corpus/fuzzer/duckfuzz/julian_overflow.test @@ -0,0 +1,21 @@ +# source: test/fuzzer/duckfuzz/julian_overflow.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +SELECT julian(c1) +FROM test_vector_types(CAST(NULL AS DATE)) AS test_vector_types(c1); +-- +ok +== +create table all_types as + select * exclude(small_enum, medium_enum, large_enum) + from test_all_types(); +-- +ok +== +SELECT julian(CAST(ref_0.date AS DATE)) AS c1 +FROM main.all_types AS ref_0 +-- +ok +== diff --git a/parser/testdata/corpus/fuzzer/duckfuzz/late_materialization_filter.test b/parser/testdata/corpus/fuzzer/duckfuzz/late_materialization_filter.test new file mode 100644 index 0000000..6cf61d8 --- /dev/null +++ b/parser/testdata/corpus/fuzzer/duckfuzz/late_materialization_filter.test @@ -0,0 +1,20 @@ +# source: test/fuzzer/duckfuzz/late_materialization_filter.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +create table tbl(z int, i bool, j bool, k uhugeint); +-- +ok +== +insert into tbl (i, j, k) values (true, 'true', 3), (NULL, NULL, NULL), (false, 'false', 1); +-- +ok +== +select k +from tbl +where i and j +limit 30; +-- +ok +== diff --git a/parser/testdata/corpus/fuzzer/duckfuzz/limit_offset_macro_subquery.test b/parser/testdata/corpus/fuzzer/duckfuzz/limit_offset_macro_subquery.test new file mode 100644 index 0000000..66ecac6 --- /dev/null +++ b/parser/testdata/corpus/fuzzer/duckfuzz/limit_offset_macro_subquery.test @@ -0,0 +1,9 @@ +# source: test/fuzzer/duckfuzz/limit_offset_macro_subquery.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +SELECT 42 OFFSET format_type(NULL, 2515); +-- +ok +== diff --git a/parser/testdata/corpus/fuzzer/duckfuzz/limit_percent_subquery.test b/parser/testdata/corpus/fuzzer/duckfuzz/limit_percent_subquery.test new file mode 100644 index 0000000..a9dad3d --- /dev/null +++ b/parser/testdata/corpus/fuzzer/duckfuzz/limit_percent_subquery.test @@ -0,0 +1,17 @@ +# source: test/fuzzer/duckfuzz/limit_percent_subquery.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +create table tbl(i INT); +-- +ok +== +FROM tbl LIMIT (EXISTS(SELECT 42))% +-- +ok +== +INSERT INTO tbl VALUES (42); +-- +ok +== diff --git a/parser/testdata/corpus/fuzzer/duckfuzz/list_try_cast.test b/parser/testdata/corpus/fuzzer/duckfuzz/list_try_cast.test new file mode 100644 index 0000000..b53657e --- /dev/null +++ b/parser/testdata/corpus/fuzzer/duckfuzz/list_try_cast.test @@ -0,0 +1,33 @@ +# source: test/fuzzer/duckfuzz/list_try_cast.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +create table integers(i INT[]); +-- +ok +== +INSERT INTO integers VALUES ([42, 999, NULL, NULL, -42]); +-- +ok +== +SELECT TRY_CAST(i AS TIMESTAMP WITH TIME ZONE[]) FROM integers; +-- +ok +== +create table strings(v VARCHAR[]); +-- +ok +== +INSERT INTO strings VALUES (['42', NULL, '84', 'hello world', '100']); +-- +ok +== +SELECT TRY_CAST(v AS INTEGER[]) FROM strings; +-- +ok +== +SELECT DISTINCT OPERATOR ( / ) + ARRAY [ ] :: INTERVAL SECONDS [ ] [ ] :: SETOF NCHAR ARRAY :: FLOAT ; +-- +ok +== diff --git a/parser/testdata/corpus/fuzzer/duckfuzz/list_zip_no_args.test b/parser/testdata/corpus/fuzzer/duckfuzz/list_zip_no_args.test new file mode 100644 index 0000000..e12f098 --- /dev/null +++ b/parser/testdata/corpus/fuzzer/duckfuzz/list_zip_no_args.test @@ -0,0 +1,13 @@ +# source: test/fuzzer/duckfuzz/list_zip_no_args.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +SELECT array_zip() AS c0; +-- +ok +== +SELECT list_zip() +-- +ok +== diff --git a/parser/testdata/corpus/fuzzer/duckfuzz/logger_null.test b/parser/testdata/corpus/fuzzer/duckfuzz/logger_null.test new file mode 100644 index 0000000..a1d398b --- /dev/null +++ b/parser/testdata/corpus/fuzzer/duckfuzz/logger_null.test @@ -0,0 +1,9 @@ +# source: test/fuzzer/duckfuzz/logger_null.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +FROM duckdb_logs(denormalized_table := NULL) +-- +ok +== diff --git a/parser/testdata/corpus/fuzzer/duckfuzz/map_concat_type_mismatch.test b/parser/testdata/corpus/fuzzer/duckfuzz/map_concat_type_mismatch.test new file mode 100644 index 0000000..e4cf985 --- /dev/null +++ b/parser/testdata/corpus/fuzzer/duckfuzz/map_concat_type_mismatch.test @@ -0,0 +1,17 @@ +# source: test/fuzzer/duckfuzz/map_concat_type_mismatch.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +SELECT map_concat(42, 42); +-- +ok +== +SELECT map_concat(map { 'a': 42 }, 42); +-- +ok +== +SELECT map_concat(map { 'a': 42 }, NULL); +-- +ok +== diff --git a/parser/testdata/corpus/fuzzer/duckfuzz/null_arguments.test b/parser/testdata/corpus/fuzzer/duckfuzz/null_arguments.test new file mode 100644 index 0000000..7419234 --- /dev/null +++ b/parser/testdata/corpus/fuzzer/duckfuzz/null_arguments.test @@ -0,0 +1,45 @@ +# source: test/fuzzer/duckfuzz/null_arguments.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +SELECT NULL FROM parquet_scan(NULL, "schema" := NULL); +-- +error: Parser Error: parquet_scan cannot take NULL list as parameter +== +SELECT NULL FROM read_ndjson_auto(NULL, timestamp_format := 5469, "compression" := NULL) +-- +error: Parser Error: read_ndjson_auto cannot take NULL list as parameter +== +COPY (VALUES (NULL), (NULL)) TO '{TEST_DIR}/test_null_args.parquet' (FORMAT PARQUET); +-- +ok +== +SELECT NULL FROM read_parquet('{TEST_DIR}/test_null_args.parquet', filename = NULL); +-- +ok +== +FROM read_ndjson(NULL, filename := NULL) AS t14(c11, c12, c13) +-- +error: Parser Error: read_ndjson cannot take NULL list as parameter +== +COPY (VALUES (NULL), (NULL)) TO '{TEST_DIR}/test_null_args.csv' (FORMAT CSV); +-- +ok +== +SELECT NULL FROM read_csv('{TEST_DIR}/test_null_args.csv', names=NULL); +-- +ok +== +SELECT NULL FROM ( + SELECT + hex(CAST(CAST(NULL AS BLOB) AS BLOB)) AS c7, + ref_0.r_comment AS c11 + FROM main.region AS ref_0 +) AS subq_0 +WHERE ( + (subq_0.c11 ~~ subq_0.c7) +); +-- +ok +== diff --git a/parser/testdata/corpus/fuzzer/duckfuzz/null_arguments.test.metadata.json b/parser/testdata/corpus/fuzzer/duckfuzz/null_arguments.test.metadata.json new file mode 100644 index 0000000..dfd9891 --- /dev/null +++ b/parser/testdata/corpus/fuzzer/duckfuzz/null_arguments.test.metadata.json @@ -0,0 +1,7 @@ +{ + "todo": { + "04d20d2d40f4c383": "transformer-raised parser error: upstream rejects in the transformer, not the grammar; expected to clear as transformers land (milestones 3-5)", + "372c3f6998a25c4f": "transformer-raised parser error: upstream rejects in the transformer, not the grammar; expected to clear as transformers land (milestones 3-5)", + "ae69580fe9b6f013": "transformer-raised parser error: upstream rejects in the transformer, not the grammar; expected to clear as transformers land (milestones 3-5)" + } +} diff --git a/parser/testdata/corpus/fuzzer/duckfuzz/null_checkpoint.test b/parser/testdata/corpus/fuzzer/duckfuzz/null_checkpoint.test new file mode 100644 index 0000000..711ad18 --- /dev/null +++ b/parser/testdata/corpus/fuzzer/duckfuzz/null_checkpoint.test @@ -0,0 +1,9 @@ +# source: test/fuzzer/duckfuzz/null_checkpoint.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +CALL checkpoint(NULL) +-- +ok +== diff --git a/parser/testdata/corpus/fuzzer/duckfuzz/ordagg_nargs.test b/parser/testdata/corpus/fuzzer/duckfuzz/ordagg_nargs.test new file mode 100644 index 0000000..47faf2c --- /dev/null +++ b/parser/testdata/corpus/fuzzer/duckfuzz/ordagg_nargs.test @@ -0,0 +1,16 @@ +# source: test/fuzzer/duckfuzz/ordagg_nargs.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +SELECT cume_dist() OVER (ROWS + BETWEEN UNBOUNDED PRECEDING + AND regr_sxx(6311, 8320 + ORDER BY 1726 ASC NULLS FIRST, + 10101, + (946 BETWEEN 2053 AND 182) DESC NULLS LAST) + FILTER (WHERE 118) PRECEDING + ) +-- +ok +== diff --git a/parser/testdata/corpus/fuzzer/duckfuzz/order_by_positional_reference.test b/parser/testdata/corpus/fuzzer/duckfuzz/order_by_positional_reference.test new file mode 100644 index 0000000..4301736 --- /dev/null +++ b/parser/testdata/corpus/fuzzer/duckfuzz/order_by_positional_reference.test @@ -0,0 +1,9 @@ +# source: test/fuzzer/duckfuzz/order_by_positional_reference.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +SELECT c1, c2, NULL FROM integers ORDER BY #10 +-- +ok +== diff --git a/parser/testdata/corpus/fuzzer/duckfuzz/pivot_aggregate_mismatch.test b/parser/testdata/corpus/fuzzer/duckfuzz/pivot_aggregate_mismatch.test new file mode 100644 index 0000000..3d7e362 --- /dev/null +++ b/parser/testdata/corpus/fuzzer/duckfuzz/pivot_aggregate_mismatch.test @@ -0,0 +1,9 @@ +# source: test/fuzzer/duckfuzz/pivot_aggregate_mismatch.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +FROM (VALUES (42)) t(i) PIVOT (current_date() FOR (i) IN (41)) +-- +ok +== diff --git a/parser/testdata/corpus/fuzzer/duckfuzz/qualify_column_reference.test b/parser/testdata/corpus/fuzzer/duckfuzz/qualify_column_reference.test new file mode 100644 index 0000000..f21efc7 --- /dev/null +++ b/parser/testdata/corpus/fuzzer/duckfuzz/qualify_column_reference.test @@ -0,0 +1,17 @@ +# source: test/fuzzer/duckfuzz/qualify_column_reference.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +create table tbl(c1 int, c2 int); +-- +ok +== +SELECT c1 FROM tbl GROUP BY c1 QUALIFY cume_dist() OVER (ROWS BETWEEN c2 PRECEDING AND CURRENT ROW); +-- +ok +== +SELECT c1 FROM tbl GROUP BY c1 QUALIFY cume_dist() OVER (ROWS BETWEEN c1 PRECEDING AND CURRENT ROW); +-- +ok +== diff --git a/parser/testdata/corpus/fuzzer/duckfuzz/read_ndjson_non_varchar_input.test b/parser/testdata/corpus/fuzzer/duckfuzz/read_ndjson_non_varchar_input.test new file mode 100644 index 0000000..abde81a --- /dev/null +++ b/parser/testdata/corpus/fuzzer/duckfuzz/read_ndjson_non_varchar_input.test @@ -0,0 +1,13 @@ +# source: test/fuzzer/duckfuzz/read_ndjson_non_varchar_input.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +FROM read_ndjson([42]) +-- +ok +== +FROM read_csv_auto([42]) +-- +ok +== diff --git a/parser/testdata/corpus/fuzzer/duckfuzz/regex_syntax_2889.test b/parser/testdata/corpus/fuzzer/duckfuzz/regex_syntax_2889.test new file mode 100644 index 0000000..1412423 --- /dev/null +++ b/parser/testdata/corpus/fuzzer/duckfuzz/regex_syntax_2889.test @@ -0,0 +1,13 @@ +# source: test/fuzzer/duckfuzz/regex_syntax_2889.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +SELECT 42 +-- +ok +== +SELECT +-- +error: Parser Error: SELECT clause without selection list +== diff --git a/parser/testdata/corpus/fuzzer/duckfuzz/regex_syntax_2889.test.metadata.json b/parser/testdata/corpus/fuzzer/duckfuzz/regex_syntax_2889.test.metadata.json new file mode 100644 index 0000000..3748dc6 --- /dev/null +++ b/parser/testdata/corpus/fuzzer/duckfuzz/regex_syntax_2889.test.metadata.json @@ -0,0 +1,5 @@ +{ + "todo": { + "6e4261695ad1aa36": "transformer-raised parser error: upstream rejects in the transformer, not the grammar; expected to clear as transformers land (milestones 3-5)" + } +} diff --git a/parser/testdata/corpus/fuzzer/duckfuzz/regexp_replace_constant.test b/parser/testdata/corpus/fuzzer/duckfuzz/regexp_replace_constant.test new file mode 100644 index 0000000..853d16a --- /dev/null +++ b/parser/testdata/corpus/fuzzer/duckfuzz/regexp_replace_constant.test @@ -0,0 +1,13 @@ +# source: test/fuzzer/duckfuzz/regexp_replace_constant.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +SELECT regexp_extract('foobarbaz', 'B..', 0, NULL); +-- +ok +== +SELECT regexp_extract('foobarbaz', 'B..', 0, 42); +-- +ok +== diff --git a/parser/testdata/corpus/fuzzer/duckfuzz/repeat_row_null.test b/parser/testdata/corpus/fuzzer/duckfuzz/repeat_row_null.test new file mode 100644 index 0000000..6ad24d1 --- /dev/null +++ b/parser/testdata/corpus/fuzzer/duckfuzz/repeat_row_null.test @@ -0,0 +1,17 @@ +# source: test/fuzzer/duckfuzz/repeat_row_null.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +FROM repeat_row(NULL) +-- +ok +== +FROM repeat_row(NULL, num_rows=3) +-- +ok +== +FROM repeat_row(num_rows=3) +-- +ok +== diff --git a/parser/testdata/corpus/fuzzer/duckfuzz/repeat_wrong_number.test b/parser/testdata/corpus/fuzzer/duckfuzz/repeat_wrong_number.test new file mode 100644 index 0000000..ab369b6 --- /dev/null +++ b/parser/testdata/corpus/fuzzer/duckfuzz/repeat_wrong_number.test @@ -0,0 +1,29 @@ +# source: test/fuzzer/duckfuzz/repeat_wrong_number.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +FROM repeat(42, 1) +-- +ok +== +FROM repeat(42, 0) +-- +ok +== +FROM repeat(42, -1) +-- +ok +== +SELECT NULL FROM repeat('7fb6658b-4f42-44ce-bbd0-b22ba2faf7ad', -32768) +-- +ok +== +SELECT NULL FROM repeat(NULL, -9223372036854775808) +-- +ok +== +SELECT NULL FROM repeat(1050, -128) +-- +ok +== diff --git a/parser/testdata/corpus/fuzzer/duckfuzz/semi_join_has_correct_left_right_relations.test b/parser/testdata/corpus/fuzzer/duckfuzz/semi_join_has_correct_left_right_relations.test new file mode 100644 index 0000000..e0ca19b --- /dev/null +++ b/parser/testdata/corpus/fuzzer/duckfuzz/semi_join_has_correct_left_right_relations.test @@ -0,0 +1,51 @@ +# source: test/fuzzer/duckfuzz/semi_join_has_correct_left_right_relations.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +create table t1 as select range a from range(300); +-- +ok +== +create table t2 as select range b from range(500); +-- +ok +== +create table t3 as select range c from range (600); +-- +ok +== +select * from t1, t2 where a = b and a in (select c from t3); +-- +ok +== +pragma disabled_optimizers='empty_result_pullup'; +-- +ok +== +SELECT NULL +FROM all_types + INNER JOIN (SELECT NULL) + RIGHT JOIN all_types AS ref_2 + LEFT JOIN all_types AS ref_7 + INNER JOIN all_types AS ref_8 + ON (( ref_7.int_array = ref_8.int_array )) + ON ( NULL ) + INNER JOIN all_types AS ref_9 + ON ( ref_2."varchar" ) + ON (( "Version"() IS NULL )) + ON ( EXISTS(SELECT ref_7."bit" AS c0 + FROM all_types AS ref_10 + WHERE 0 + )); +-- +ok +== +SELECT NULL FROM main.all_types AS ref_0 INNER JOIN main.all_types AS ref_1 INNER JOIN main.all_types AS ref_2 ON ((SELECT NULL)) INNER JOIN main.all_types ON ((SELECT NULL)) ON (NULL) INNER JOIN main.all_types AS ref_4 ON (ref_4."varchar") INNER JOIN main.all_types AS ref_5 ON (EXISTS(SELECT 79 AS c0 FROM main.all_types AS ref_6 INNER JOIN main.all_types AS ref_7 INNER JOIN main.all_types ON (NULL) ON ((EXISTS(SELECT ref_2.uint AS c0, ref_4."time" AS c1 FROM main.all_types AS ref_9 WHERE (ref_2."varchar" ~~~ ref_5."varchar")) AND (ref_1."varchar" !~~* ref_7."varchar"))) , (SELECT ref_6.utinyint AS c0, (SELECT bit_or(ubigint) FROM main.all_types) AS c1, ref_5.fixed_varchar_array AS c2, ref_10."union" AS c3 FROM main.all_types AS ref_10 WHERE (ref_2."varchar" !~~* ref_0."varchar") LIMIT 159) AS subq_0 WHERE 0 LIMIT 67)) LEFT JOIN main.all_types AS ref_11 ON ((ref_1."time" = ref_11."time")) LIMIT 115 +-- +ok +== +set disabled_optimizers to 'filter_pullup,empty_result_pullup' +-- +ok +== diff --git a/parser/testdata/corpus/fuzzer/duckfuzz/string_to_nested_cast_sample.test b/parser/testdata/corpus/fuzzer/duckfuzz/string_to_nested_cast_sample.test new file mode 100644 index 0000000..75f06fa --- /dev/null +++ b/parser/testdata/corpus/fuzzer/duckfuzz/string_to_nested_cast_sample.test @@ -0,0 +1,16 @@ +# source: test/fuzzer/duckfuzz/string_to_nested_cast_sample.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +CREATE TABLE part AS SELECT concat('this is a long part name', i) AS p_name FROM range(20000) t(i); +-- +ok +== +SELECT COUNT(*) FILTER (cast_part IS NULL) +FROM ( + SELECT TRY_CAST(p_name AS STRUCT(a INTEGER[], b VARCHAR[])) FROM part USING SAMPLE 81.0% (Reservoir) +) t(cast_part) +-- +ok +== diff --git a/parser/testdata/corpus/fuzzer/duckfuzz/strptime_const_arg.test b/parser/testdata/corpus/fuzzer/duckfuzz/strptime_const_arg.test new file mode 100644 index 0000000..d860a18 --- /dev/null +++ b/parser/testdata/corpus/fuzzer/duckfuzz/strptime_const_arg.test @@ -0,0 +1,15 @@ +# source: test/fuzzer/duckfuzz/strptime_const_arg.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +CREATE TABLE all_types AS +SELECT * EXCLUDE(small_enum, medium_enum, large_enum) FROM test_all_types() LIMIT 0; +-- +ok +== +SELECT COLUMNS(list_filter(*, (lambda c43: try_strptime('c29', 'c24')))) +FROM all_types AS t42(c1, c2, c3, c4, c5, c6, c7, c8, c9, c10, c11, c12, c13, c14, c15, c16, c17, c18, c19, c20, c21, c22, c23, c24, c25, c26, c27, c28, c29, c30, c31, c32, c33, c34, c35, c36, c37, c38, c39, c40, c41) +-- +ok +== diff --git a/parser/testdata/corpus/fuzzer/duckfuzz/temporal_avg.test b/parser/testdata/corpus/fuzzer/duckfuzz/temporal_avg.test new file mode 100644 index 0000000..dbdf8dc --- /dev/null +++ b/parser/testdata/corpus/fuzzer/duckfuzz/temporal_avg.test @@ -0,0 +1,9 @@ +# source: test/fuzzer/duckfuzz/temporal_avg.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +SELECT avg(c1) FROM test_vector_types(CAST(NULL AS TIMESTAMP)) AS test_vector_types(c1); +-- +ok +== diff --git a/parser/testdata/corpus/fuzzer/duckfuzz/test_vector_types_double_3.test b/parser/testdata/corpus/fuzzer/duckfuzz/test_vector_types_double_3.test new file mode 100644 index 0000000..e047536 --- /dev/null +++ b/parser/testdata/corpus/fuzzer/duckfuzz/test_vector_types_double_3.test @@ -0,0 +1,9 @@ +# source: test/fuzzer/duckfuzz/test_vector_types_double_3.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +FROM test_vector_types(CAST(NULL AS DOUBLE[3]), CAST(NULL AS DOUBLE[3])) +-- +ok +== diff --git a/parser/testdata/corpus/fuzzer/duckfuzz/to_weeks_overflow.test b/parser/testdata/corpus/fuzzer/duckfuzz/to_weeks_overflow.test new file mode 100644 index 0000000..f237fe5 --- /dev/null +++ b/parser/testdata/corpus/fuzzer/duckfuzz/to_weeks_overflow.test @@ -0,0 +1,11 @@ +# source: test/fuzzer/duckfuzz/to_weeks_overflow.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +SELECT to_weeks(#4) +FROM all_types AS t43(c1, c2, c3, c4, c5, c6, c7, c8, c9, c10, c11, c12, c13, c14, c15, c16, c17, c18, c19, c20, c21, c22, c23, c24, c25, c26, c27, c28, c29, c30, c31, c32, c33, c34, c35, c36, c37, c38, c39, c40, c41, c42) +WHERE c9 +-- +ok +== diff --git a/parser/testdata/corpus/fuzzer/duckfuzz/tuple_data_empty_heap.test b/parser/testdata/corpus/fuzzer/duckfuzz/tuple_data_empty_heap.test new file mode 100644 index 0000000..f733c33 --- /dev/null +++ b/parser/testdata/corpus/fuzzer/duckfuzz/tuple_data_empty_heap.test @@ -0,0 +1,13 @@ +# source: test/fuzzer/duckfuzz/tuple_data_empty_heap.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +set threads=4; +-- +ok +== +SELECT DISTINCT c1, #1, c3, c1, c3, c1, c2 FROM tpch_answers() AS t4(c1, c2, c3) GROUP BY ALL; +-- +ok +== diff --git a/parser/testdata/corpus/fuzzer/duckfuzz/union_dict_tag.test b/parser/testdata/corpus/fuzzer/duckfuzz/union_dict_tag.test new file mode 100644 index 0000000..a56deba --- /dev/null +++ b/parser/testdata/corpus/fuzzer/duckfuzz/union_dict_tag.test @@ -0,0 +1,9 @@ +# source: test/fuzzer/duckfuzz/union_dict_tag.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +SELECT encode("union"::varchar), "double" FROM all_types where "double"; +-- +ok +== diff --git a/parser/testdata/corpus/fuzzer/duckfuzz/unpivot_multiple_in.test b/parser/testdata/corpus/fuzzer/duckfuzz/unpivot_multiple_in.test new file mode 100644 index 0000000..6c0f1c5 --- /dev/null +++ b/parser/testdata/corpus/fuzzer/duckfuzz/unpivot_multiple_in.test @@ -0,0 +1,9 @@ +# source: test/fuzzer/duckfuzz/unpivot_multiple_in.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +FROM (SELECT 42) AS t1 UNPIVOT (c2 FOR c2 IN (6317) c2 IN (NULL)) +-- +error: Parser Error: UNPIVOT requires a single pivot element +== diff --git a/parser/testdata/corpus/fuzzer/duckfuzz/unpivot_multiple_in.test.metadata.json b/parser/testdata/corpus/fuzzer/duckfuzz/unpivot_multiple_in.test.metadata.json new file mode 100644 index 0000000..6f816c6 --- /dev/null +++ b/parser/testdata/corpus/fuzzer/duckfuzz/unpivot_multiple_in.test.metadata.json @@ -0,0 +1,5 @@ +{ + "todo": { + "bb751ab7f05fe5f5": "transformer-raised parser error: upstream rejects in the transformer, not the grammar; expected to clear as transformers land (milestones 3-5)" + } +} diff --git a/parser/testdata/corpus/fuzzer/duckfuzz/vector_size_out_of_range.test b/parser/testdata/corpus/fuzzer/duckfuzz/vector_size_out_of_range.test new file mode 100644 index 0000000..2ec4007 --- /dev/null +++ b/parser/testdata/corpus/fuzzer/duckfuzz/vector_size_out_of_range.test @@ -0,0 +1,9 @@ +# source: test/fuzzer/duckfuzz/vector_size_out_of_range.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +SELECT DISTINCT OPERATOR ( / ) + ARRAY [ ] :: INTERVAL SECONDS [9] [ ] :: SETOF NCHAR ARRAY :: FLOAT ; +-- +ok +== diff --git a/parser/testdata/corpus/fuzzer/duckfuzz/vector_type.test b/parser/testdata/corpus/fuzzer/duckfuzz/vector_type.test new file mode 100644 index 0000000..b4fb8d6 --- /dev/null +++ b/parser/testdata/corpus/fuzzer/duckfuzz/vector_type.test @@ -0,0 +1,29 @@ +# source: test/fuzzer/duckfuzz/vector_type.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +SELECT vector_type(42::INTEGER) +-- +ok +== +SELECT vector_type(NULL::INTEGER) +-- +ok +== +CREATE TABLE fuu (i INTEGER, j INTEGER); +-- +ok +== +INSERT INTO fuu VALUES (42, NULL), (43, NULL); +-- +ok +== +SELECT vector_type(i), vector_type(j) FROM fuu; +-- +ok +== +SELECT vector_type(COLUMNS(*)) FROM all_types +-- +ok +== diff --git a/parser/testdata/corpus/fuzzer/duckfuzz/visit_operator_expressions_in_column_lifetime_analyzer.test b/parser/testdata/corpus/fuzzer/duckfuzz/visit_operator_expressions_in_column_lifetime_analyzer.test new file mode 100644 index 0000000..5ccfdb9 --- /dev/null +++ b/parser/testdata/corpus/fuzzer/duckfuzz/visit_operator_expressions_in_column_lifetime_analyzer.test @@ -0,0 +1,53 @@ +# source: test/fuzzer/duckfuzz/visit_operator_expressions_in_column_lifetime_analyzer.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +SELECT arg_min(CAST(ref_19."varchar" AS VARCHAR), CAST(ref_3."varchar" AS VARCHAR)) OVER (PARTITION BY ref_23."bit" ORDER BY ref_6.ubigint) FROM (SELECT (SELECT "time" FROM main.all_types LIMIT 1 OFFSET 4) AS c1 FROM main.all_types AS ref_0 WHERE ref_0."varchar") AS subq_0 INNER JOIN (SELECT ref_1."varchar" AS c5 FROM main.all_types AS ref_1 LEFT JOIN main.all_types AS ref_2 ON ((ref_1."varchar" !~~* ref_2."varchar")) WHERE (ref_2."varchar" ~~* ref_2."varchar")) AS subq_1 INNER JOIN main.all_types AS ref_3 ON ((subq_1.c5 ~~ ref_3."varchar")) ON ((ref_3."varchar" ~~ subq_1.c5)) INNER JOIN main.all_types AS ref_4 RIGHT JOIN main.all_types AS ref_5 RIGHT JOIN main.all_types AS ref_6 ON ((ref_6."varchar" ^@ ref_6."varchar")) ON ((ref_6.timestamp_ms IS NOT NULL)) INNER JOIN main.all_types AS ref_7 INNER JOIN main.all_types AS ref_8 ON ((ref_7.dec_4_1 = ref_8.dec_4_1)) LEFT JOIN main.all_types AS ref_9 RIGHT JOIN main.all_types AS ref_10 ON ((ref_9.timestamp_array = ref_10.timestamp_array)) ON ((ref_10."varchar" ^@ ref_8."varchar")) INNER JOIN main.all_types AS ref_11 RIGHT JOIN main.all_types AS ref_12 ON ((ref_11."float" = ref_12."float")) LEFT JOIN main.all_types AS ref_13 ON ((ref_11."varchar" ~~~ ref_12."varchar")) ON ((CAST(NULL AS VARCHAR) ~~~ ref_7."varchar")) ON (((((ref_8."varchar" !~~ ref_8."varchar") AND (ref_6."varchar" ~~~ ref_12."varchar")) OR (ref_9."varchar" ~~ CAST(NULL AS VARCHAR))) AND (ref_6."varchar" ^@ ref_8."varchar") AND (ref_11.hugeint IS NOT NULL))) RIGHT JOIN (SELECT (SELECT bool FROM main.all_types LIMIT 1 OFFSET 6) AS c4) AS subq_2 ON ((ref_9."varchar" !~~ ref_8."varchar")) ON ((ref_3."int" = ref_10."int")) INNER JOIN (SELECT 41 AS c0 FROM main.all_types AS ref_15 RIGHT JOIN main.all_types AS ref_16 ON ((ref_15."varchar" = ref_16."varchar"))) AS subq_3 INNER JOIN (SELECT ref_17.timestamp_s AS c5 FROM main.all_types AS ref_17) AS subq_4 ON ((subq_3.c0 IS NULL)) INNER JOIN main.all_types AS ref_18 LEFT JOIN main.all_types AS ref_19 INNER JOIN main.all_types AS ref_20 INNER JOIN main.all_types AS ref_21 ON (((SELECT "varchar" FROM main.all_types LIMIT 1 OFFSET 4) ~~~ ref_21."varchar")) ON ((ref_21."timestamp" IS NULL)) ON ((ref_19."varchar" ~~~ ref_20."varchar")) RIGHT JOIN main.all_types AS ref_22 LEFT JOIN main.all_types AS ref_23 ON (1) ON (0) ON ((0 OR (ref_20."varchar" !~~* ref_19."varchar") OR ((EXISTS(SELECT (SELECT tinyint FROM main.all_types LIMIT 1 OFFSET 1) AS c0 FROM main.all_types AS ref_24 WHERE (ref_23."bigint" IS NOT NULL) LIMIT 110) OR (ref_23.timestamp_array IS NULL)) AND (ref_21."varchar" ^@ ref_21."varchar")))) ON ((ref_9."varchar" ~~* chr(CAST(ref_18."int" AS INTEGER)))) WHERE (ref_12."varchar" ^@ ref_20."varchar"); +-- +ok +== +SELECT count_star() +OVER (PARTITION BY ref_1.hugeint, ref_1."timestamp" ORDER BY subq_0.c0) AS c0 +FROM +(SELECT +ref_0."int" AS c0, +ref_0.timestamp_s AS c1 +FROM main.all_types AS ref_0 +WHERE +ref_0."varchar") AS subq_0 +INNER JOIN +main.all_types AS ref_1 +ON +((subq_0.c1 = ref_1.timestamp_s)) +WHERE (ref_1."time" IS NOT NULL); +-- +ok +== +SELECT arg_min(CAST(ref_5."varchar" AS VARCHAR), CAST(ref_4."varchar" AS VARCHAR)) OVER (PARTITION BY ref_5."bit") +FROM main.all_types AS ref_4 +INNER JOIN main.all_types AS ref_5 ON (ref_5.hugeint IS NOT NULL) +INNER JOIN main.all_types AS ref_7 ON (ref_4."int" = ref_5."int") +-- +ok +== +SELECT subq_0.c3 AS c3 FROM (SELECT ref_1.timestamp_s AS c0, ref_2.date_array AS c1, ref_2.struct_of_arrays AS c2, ref_2."smallint" AS c3 FROM main.all_types AS ref_0 INNER JOIN main.all_types AS ref_1 LEFT JOIN main.all_types AS ref_2 INNER JOIN main.all_types AS ref_3 ON (1) ON ((ref_1.dec_4_1 = ref_2.dec_4_1)) ON ((ref_2."float" IS NOT NULL)) WHERE (ref_3."varchar" !~~* ref_1."varchar")) AS subq_0 , (SELECT subq_0.c1 AS c2, subq_0.c2 AS c5, subq_0.c0 AS c13) AS subq_1; +-- +ok +== +SELECT subq_0.c4 AS c1 FROM (SELECT ref_5.varchar_array AS c4, ref_2.usmallint AS c5 FROM main.all_types AS ref_0 INNER JOIN main.all_types AS ref_1 ON ((ref_1."varchar" !~~* ref_0."varchar")) LEFT JOIN main.all_types AS ref_2 RIGHT JOIN main.all_types AS ref_3 ON ((ref_2."bigint" = ref_3."bigint")) ON ((ref_0.timestamp_tz = ref_2.timestamp_tz)) INNER JOIN main.all_types AS ref_4 ON ((ref_3.dec_18_6 IS NOT NULL)) INNER JOIN main.all_types AS ref_5 ON ((ref_3."varchar" ^@ ref_1."varchar")) WHERE EXISTS(SELECT ref_5.blob AS c0, ref_3.ubigint AS c1 FROM main.all_types AS ref_6 WHERE (ref_2."varchar" !~~* ref_4."varchar") LIMIT 120)) AS subq_0 WHERE EXISTS(SELECT ref_7."map" AS c0, subq_0.c5 AS c1 FROM main.all_types AS ref_7 WHERE (ref_7."varchar" ~~~ ref_7."varchar") LIMIT 118) +-- +ok +== +SELECT NULL FROM (SELECT ref_0."int" AS c3 FROM main.all_types AS ref_0 RIGHT JOIN main.all_types AS ref_1 INNER JOIN main.all_types AS ref_2 ON ((ref_1."int" = ref_2."int")) INNER JOIN main.all_types AS ref_3 ON ((ref_2.tinyint = ref_3.tinyint)) ON ((ref_2."varchar" ~~* ref_3."varchar")) WHERE (ref_2."smallint" IS NOT NULL)) AS subq_0 +-- +ok +== +insert into all_types select * exclude(small_enum, medium_enum, large_enum) from test_all_types(); +-- +ok +== +SELECT arg_min(CAST(ref_19."varchar" AS VARCHAR), CAST(ref_3."varchar" AS VARCHAR)) OVER (PARTITION BY ref_23."bit" ORDER BY ref_6.ubigint) FROM (SELECT (SELECT "time" FROM main.all_types LIMIT 1 OFFSET 4) AS c1 FROM main.all_types AS ref_0) AS subq_0 INNER JOIN (SELECT ref_1."varchar" AS c5 FROM main.all_types AS ref_1 LEFT JOIN main.all_types AS ref_2 ON ((ref_1."varchar" !~~* ref_2."varchar")) WHERE (ref_2."varchar" ~~* ref_2."varchar")) AS subq_1 INNER JOIN main.all_types AS ref_3 ON ((subq_1.c5 ~~ ref_3."varchar")) ON ((ref_3."varchar" ~~ subq_1.c5)) INNER JOIN main.all_types AS ref_4 RIGHT JOIN main.all_types AS ref_5 RIGHT JOIN main.all_types AS ref_6 ON ((ref_6."varchar" ^@ ref_6."varchar")) ON ((ref_6.timestamp_ms IS NOT NULL)) INNER JOIN main.all_types AS ref_7 INNER JOIN main.all_types AS ref_8 ON ((ref_7.dec_4_1 = ref_8.dec_4_1)) LEFT JOIN main.all_types AS ref_9 RIGHT JOIN main.all_types AS ref_10 ON ((ref_9.timestamp_array = ref_10.timestamp_array)) ON ((ref_10."varchar" ^@ ref_8."varchar")) INNER JOIN main.all_types AS ref_11 RIGHT JOIN main.all_types AS ref_12 ON ((ref_11."float" = ref_12."float")) LEFT JOIN main.all_types AS ref_13 ON ((ref_11."varchar" ~~~ ref_12."varchar")) ON ((CAST(NULL AS VARCHAR) ~~~ ref_7."varchar")) ON (((((ref_8."varchar" !~~ ref_8."varchar") AND (ref_6."varchar" ~~~ ref_12."varchar")) OR (ref_9."varchar" ~~ CAST(NULL AS VARCHAR))) AND (ref_6."varchar" ^@ ref_8."varchar") AND (ref_11.hugeint IS NOT NULL))) RIGHT JOIN (SELECT (SELECT bool FROM main.all_types LIMIT 1 OFFSET 6) AS c4) AS subq_2 ON ((ref_9."varchar" !~~ ref_8."varchar")) ON ((ref_3."int" = ref_10."int")) INNER JOIN (SELECT 41 AS c0 FROM main.all_types AS ref_15 RIGHT JOIN main.all_types AS ref_16 ON ((ref_15."varchar" = ref_16."varchar"))) AS subq_3 INNER JOIN (SELECT ref_17.timestamp_s AS c5 FROM main.all_types AS ref_17) AS subq_4 ON ((subq_3.c0 IS NULL)) INNER JOIN main.all_types AS ref_18 LEFT JOIN main.all_types AS ref_19 INNER JOIN main.all_types AS ref_20 INNER JOIN main.all_types AS ref_21 ON (((SELECT "varchar" FROM main.all_types LIMIT 1 OFFSET 4) ~~~ ref_21."varchar")) ON ((ref_21."timestamp" IS NULL)) ON ((ref_19."varchar" ~~~ ref_20."varchar")) RIGHT JOIN main.all_types AS ref_22 LEFT JOIN main.all_types AS ref_23 ON (1) ON (0) ON ((0 OR (ref_20."varchar" !~~* ref_19."varchar") OR ((EXISTS(SELECT (SELECT tinyint FROM main.all_types LIMIT 1 OFFSET 1) AS c0 FROM main.all_types AS ref_24 WHERE (ref_23."bigint" IS NOT NULL) LIMIT 110) OR (ref_23.timestamp_array IS NULL)) AND (ref_21."varchar" ^@ ref_21."varchar")))) ON ((ref_9."varchar" ~~* chr(CAST(ref_18."int" AS INTEGER)))) WHERE (ref_12."varchar" ^@ ref_20."varchar"); +-- +ok +== diff --git a/parser/testdata/corpus/fuzzer/duckfuzz/window_expression_equality.test b/parser/testdata/corpus/fuzzer/duckfuzz/window_expression_equality.test new file mode 100644 index 0000000..96eb1dd --- /dev/null +++ b/parser/testdata/corpus/fuzzer/duckfuzz/window_expression_equality.test @@ -0,0 +1,16 @@ +# source: test/fuzzer/duckfuzz/window_expression_equality.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +create table all_types(c1 BOOL, c9 SMALLINT, c10 UINTEGER, c36 VARCHAR[]); +-- +ok +== +SELECT + first_value(c9) OVER (PARTITION BY c10, c1, c9, (c36 IS NOT DISTINCT FROM c36) ROWS BETWEEN 8201 PRECEDING AND CURRENT ROW), + first_value(c9) OVER (PARTITION BY c10, c9, c9, (c36 IS NOT DISTINCT FROM c36) ROWS BETWEEN 8201 PRECEDING AND CURRENT ROW) +FROM all_types +-- +ok +== diff --git a/parser/testdata/corpus/fuzzer/duckfuzz/window_negate_stats.test b/parser/testdata/corpus/fuzzer/duckfuzz/window_negate_stats.test new file mode 100644 index 0000000..15c21b9 --- /dev/null +++ b/parser/testdata/corpus/fuzzer/duckfuzz/window_negate_stats.test @@ -0,0 +1,11 @@ +# source: test/fuzzer/duckfuzz/window_negate_stats.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +SELECT max(c34) FILTER (WHERE c26) OVER (PARTITION BY c23 ROWS BETWEEN COALESCE(c5, 0) PRECEDING AND CURRENT ROW) +FROM all_types AS t43(c1, c2, c3, c4, c5, c6, c7, c8, c9, c10, c11, c12, c13, c14, c15, c16, c17, c18, c19, c20, c21, c22, c23, c24, c25, c26, c27, c28, c29, c30, c31, c32, c33, c34, c35, c36, c37, c38, c39, c40, c41, c42, c43) +ORDER BY ALL NULLS LAST +-- +ok +== diff --git a/parser/testdata/corpus/fuzzer/duckfuzz/window_null_range.test b/parser/testdata/corpus/fuzzer/duckfuzz/window_null_range.test new file mode 100644 index 0000000..2e0211e --- /dev/null +++ b/parser/testdata/corpus/fuzzer/duckfuzz/window_null_range.test @@ -0,0 +1,15 @@ +# source: test/fuzzer/duckfuzz/window_null_range.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +create table all_types as select * exclude(small_enum, medium_enum, large_enum) +from test_all_types(); +-- +ok +== +SELECT percent_rank() OVER (PARTITION BY c21 ORDER BY c37 ASC NULLS FIRST RANGE BETWEEN NULL FOLLOWING AND UNBOUNDED FOLLOWING) +FROM all_types AS t43(c1, c2, c3, c4, c5, c6, c7, c8, c9, c10, c11, c12, c13, c14, c15, c16, c17, c18, c19, c20, c21, c22, c23, c24, c25, c26, c27, c28, c29, c30, c31, c32, c33, c34, c35, c36, c37, c38, c39, c40, c41, c42) +-- +ok +== diff --git a/parser/testdata/corpus/fuzzer/duckfuzz/window_order_bind_failure.test b/parser/testdata/corpus/fuzzer/duckfuzz/window_order_bind_failure.test new file mode 100644 index 0000000..38ed11c --- /dev/null +++ b/parser/testdata/corpus/fuzzer/duckfuzz/window_order_bind_failure.test @@ -0,0 +1,21 @@ +# source: test/fuzzer/duckfuzz/window_order_bind_failure.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +CREATE TABLE all_types AS SELECT * EXCLUDE(small_enum, medium_enum, large_enum) +FROM test_all_types(); +-- +ok +== +SELECT lead(#1) OVER (PARTITION BY 2378 ORDER BY ((c70 BETWEEN c90 AND c19) AND c51) ASC NULLS FIRST RANGE BETWEEN CURRENT ROW AND c7 FOLLOWING) +FROM all_types AS t91(c49, c50, c51, c52, c53, c54, c55, c56, c57, c58, c59, c60, c61, c62, c63, c64, c65, c66, c67, c68, c69, c70, c71, c72, c73, c74, c75, c76, c77, c78, c79, c80, c81, c82, c83, c84, c85, c86, c87, c88, c89, c90) +-- +ok +== +SELECT #3, first_value(c20) OVER (ORDER BY c40 NULLS LAST ROWS BETWEEN generate_subscripts(c35, -2147483648) PRECEDING AND c14 PRECEDING) +FROM all_types AS t42(c1, c2, c3, c4, c5, c6, c7, c8, c9, c10, c11, c12, c13, c14, c15, c16, c17, c18, c19, c20, c21, c22, c23, c24, c25, c26, c27, c28, c29, c30, c31, c32, c33, c34, c35, c36, c37, c38, c39, c40, c41) +WHERE c28 +-- +ok +== diff --git a/parser/testdata/corpus/fuzzer/fuzz_not_operator.test b/parser/testdata/corpus/fuzzer/fuzz_not_operator.test new file mode 100644 index 0000000..3ab1aab --- /dev/null +++ b/parser/testdata/corpus/fuzzer/fuzz_not_operator.test @@ -0,0 +1,13 @@ +# source: test/fuzzer/fuzz_not_operator.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +SELECT i FROM (select 1) tbl(i) WHERE ( 2060771621 != i + -2134619525 ) +-- +ok +== +select i FROM (select 4195391146) tbl(i) WHERE ( 2060771621 != i + -2134619525) +-- +ok +== diff --git a/parser/testdata/corpus/fuzzer/fuzz_not_unpacked_columns.test b/parser/testdata/corpus/fuzzer/fuzz_not_unpacked_columns.test new file mode 100644 index 0000000..9b4693d --- /dev/null +++ b/parser/testdata/corpus/fuzzer/fuzz_not_unpacked_columns.test @@ -0,0 +1,37 @@ +# source: test/fuzzer/fuzz_not_unpacked_columns.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +CREATE TABLE v00 (c01 INT, c02 STRING); +-- +ok +== +SELECT NOT (*COLUMNS(*)) FROM v00; +-- +ok +== +SELECT (*COLUMNS(*) IS NOT NULL) FROM v00; +-- +ok +== +SELECT (*COLUMNS(*) IS NULL) FROM v00; +-- +ok +== +SELECT (*COLUMNS(*))[2] FROM v00; +-- +ok +== +SELECT (*COLUMNS(*))[2:1:0] FROM v00; +-- +ok +== +SELECT (*COLUMNS(*)).a FROM v00; +-- +ok +== +SELECT construct_array(*COLUMNS(*)) FROM v00; +-- +ok +== diff --git a/parser/testdata/corpus/fuzzer/issue4298.test b/parser/testdata/corpus/fuzzer/issue4298.test new file mode 100644 index 0000000..408fe58 --- /dev/null +++ b/parser/testdata/corpus/fuzzer/issue4298.test @@ -0,0 +1,21 @@ +# source: test/fuzzer/issue4298.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +select * FROM test_all_types(use_large_bignum := -32768, use_large_enum := NULL); +-- +ok +== +select * FROM test_all_types(use_large_bignum := NULL); +-- +ok +== +SELECT COUNT(n) FROM test_vector_types(NULL::INT, all_flat=NULL) t(n); +-- +ok +== +select * from duckdb_secrets(redact=NULL); +-- +ok +== diff --git a/parser/testdata/corpus/fuzzer/nthvalue_indexing.test b/parser/testdata/corpus/fuzzer/nthvalue_indexing.test new file mode 100644 index 0000000..27108fa --- /dev/null +++ b/parser/testdata/corpus/fuzzer/nthvalue_indexing.test @@ -0,0 +1,11 @@ +# source: test/fuzzer/nthvalue_indexing.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +SELECT DISTINCT nth_value(NULL, (c2 IS NOT NULL)::BIGINT) OVER (PARTITION BY 1585 ROWS BETWEEN CURRENT ROW AND CURRENT ROW) +FROM part AS t10(c1, c2, c3, c4, c5, c6, c7, c8, c9) +ORDER BY * ASC NULLS LAST +-- +ok +== diff --git a/parser/testdata/corpus/fuzzer/pedro/C_C++_API_query_verification.test b/parser/testdata/corpus/fuzzer/pedro/C_C++_API_query_verification.test new file mode 100644 index 0000000..7a21039 --- /dev/null +++ b/parser/testdata/corpus/fuzzer/pedro/C_C++_API_query_verification.test @@ -0,0 +1,25 @@ +# source: test/fuzzer/pedro/C_C++_API_query_verification.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +CREATE TABLE t0 (c0 INT); +-- +ok +== +INSERT INTO t0 VALUES (1), (-2), (0); +-- +ok +== +UPDATE t0 SET c0 = (~1); +-- +ok +== +SELECT c0 FROM t0; +-- +ok +== +SELECT CAST((((1!) << CASE WHEN 1 THEN 1 WHEN 1 THEN 1 END) IS NULL) AS USMALLINT) +-- +ok +== diff --git a/parser/testdata/corpus/fuzzer/pedro/aggregate_assertion_errors.test b/parser/testdata/corpus/fuzzer/pedro/aggregate_assertion_errors.test new file mode 100644 index 0000000..d455b00 --- /dev/null +++ b/parser/testdata/corpus/fuzzer/pedro/aggregate_assertion_errors.test @@ -0,0 +1,29 @@ +# source: test/fuzzer/pedro/aggregate_assertion_errors.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +SELECT reservoir_quantile(1, 1 ORDER BY 1); +-- +ok +== +CREATE TABLE t1 (c0 INT); +-- +ok +== +SELECT entropy(1 ORDER BY 1) FROM t1; +-- +ok +== +SELECT approx_count_distinct(1 ORDER BY 1) FROM t1; +-- +ok +== +SELECT count(c0 ORDER BY 0) FROM (SELECT 2 EXCEPT SELECT 2) c0; +-- +ok +== +SELECT mode((c0, 0)) FROM (SELECT 1 c0), (SELECT 2); +-- +ok +== diff --git a/parser/testdata/corpus/fuzzer/pedro/alter_column_generated.test b/parser/testdata/corpus/fuzzer/pedro/alter_column_generated.test new file mode 100644 index 0000000..cf8a4e9 --- /dev/null +++ b/parser/testdata/corpus/fuzzer/pedro/alter_column_generated.test @@ -0,0 +1,25 @@ +# source: test/fuzzer/pedro/alter_column_generated.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +CREATE TABLE t0(c0 AS (1), c1 INT); +-- +ok +== +ALTER TABLE t0 ALTER c1 SET NOT NULL; +-- +ok +== +ALTER TABLE t0 ALTER c0 SET NOT NULL; +-- +ok +== +INSERT INTO t0 VALUES (NULL); +-- +ok +== +DROP TABLE t0; +-- +ok +== diff --git a/parser/testdata/corpus/fuzzer/pedro/alter_dependencies.test b/parser/testdata/corpus/fuzzer/pedro/alter_dependencies.test new file mode 100644 index 0000000..1fcd195 --- /dev/null +++ b/parser/testdata/corpus/fuzzer/pedro/alter_dependencies.test @@ -0,0 +1,29 @@ +# source: test/fuzzer/pedro/alter_dependencies.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +CREATE TABLE t1 (c2 INT, c1 INT); +-- +ok +== +CREATE INDEX i1 ON t1 (c1); +-- +ok +== +START TRANSACTION; +-- +ok +== +ALTER TABLE t1 ALTER c2 TYPE BOOLEAN; +-- +ok +== +COMMIT; +-- +ok +== +ALTER TABLE t1 ALTER c2 SET NOT NULL; +-- +ok +== diff --git a/parser/testdata/corpus/fuzzer/pedro/alter_dependency_conflict.test b/parser/testdata/corpus/fuzzer/pedro/alter_dependency_conflict.test new file mode 100644 index 0000000..3d453aa --- /dev/null +++ b/parser/testdata/corpus/fuzzer/pedro/alter_dependency_conflict.test @@ -0,0 +1,25 @@ +# source: test/fuzzer/pedro/alter_dependency_conflict.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +CREATE TABLE t4 (c0 DATE, c3 VARCHAR(10)); +-- +ok +== +CREATE INDEX i2 ON t4 (c3); +-- +ok +== +ALTER TABLE t4 ADD c1 BLOB; +-- +ok +== +INSERT INTO t4 VALUES (NULL, NULL, NULL) +-- +ok +== +CREATE INDEX i3 ON t4 (c3); +-- +ok +== diff --git a/parser/testdata/corpus/fuzzer/pedro/alter_table_rowid.test b/parser/testdata/corpus/fuzzer/pedro/alter_table_rowid.test new file mode 100644 index 0000000..8451e9e --- /dev/null +++ b/parser/testdata/corpus/fuzzer/pedro/alter_table_rowid.test @@ -0,0 +1,25 @@ +# source: test/fuzzer/pedro/alter_table_rowid.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +CREATE TABLE t0(c0 INTEGER, c1 INTEGER); +-- +ok +== +ALTER TABLE t0 DROP COLUMN rowid; +-- +ok +== +ALTER TABLE t0 RENAME rowid TO ups; +-- +ok +== +ALTER TABLE t0 ALTER rowid TYPE VARCHAR; +-- +ok +== +ALTER TABLE t0 ALTER rowidx SET DEFAULT 0; +-- +ok +== diff --git a/parser/testdata/corpus/fuzzer/pedro/alter_type_null_mix.test b/parser/testdata/corpus/fuzzer/pedro/alter_type_null_mix.test new file mode 100644 index 0000000..e642dee --- /dev/null +++ b/parser/testdata/corpus/fuzzer/pedro/alter_type_null_mix.test @@ -0,0 +1,17 @@ +# source: test/fuzzer/pedro/alter_type_null_mix.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +CREATE TABLE t1 (c0 USMALLINT); +-- +ok +== +INSERT INTO t1 SELECT CASE WHEN i%2=0 THEN NULL ELSE 0 END FROM range(3000) t(i); +-- +ok +== +ALTER TABLE t1 ALTER c0 TYPE USMALLINT; +-- +ok +== diff --git a/parser/testdata/corpus/fuzzer/pedro/alter_virtual_column_segfault.test b/parser/testdata/corpus/fuzzer/pedro/alter_virtual_column_segfault.test new file mode 100644 index 0000000..4255e29 --- /dev/null +++ b/parser/testdata/corpus/fuzzer/pedro/alter_virtual_column_segfault.test @@ -0,0 +1,13 @@ +# source: test/fuzzer/pedro/alter_virtual_column_segfault.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +CREATE TABLE t1(c2 AS (1) VIRTUAL, c1 TIME WITH TIME ZONE); +-- +ok +== +ALTER TABLE t1 ALTER c1 TYPE TIME USING(c2); +-- +ok +== diff --git a/parser/testdata/corpus/fuzzer/pedro/analyze_nonexistant.test b/parser/testdata/corpus/fuzzer/pedro/analyze_nonexistant.test new file mode 100644 index 0000000..9ae1580 --- /dev/null +++ b/parser/testdata/corpus/fuzzer/pedro/analyze_nonexistant.test @@ -0,0 +1,13 @@ +# source: test/fuzzer/pedro/analyze_nonexistant.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +CREATE TABLE t0(c0 TINYINT); +-- +ok +== +ANALYZE t0(c4); +-- +ok +== diff --git a/parser/testdata/corpus/fuzzer/pedro/another_binder_error.test b/parser/testdata/corpus/fuzzer/pedro/another_binder_error.test new file mode 100644 index 0000000..0abc406 --- /dev/null +++ b/parser/testdata/corpus/fuzzer/pedro/another_binder_error.test @@ -0,0 +1,25 @@ +# source: test/fuzzer/pedro/another_binder_error.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +SELECT avg(0) c0, (SELECT 0 OFFSET c0); +-- +ok +== +SELECT avg(0) c0, (SELECT 0 OFFSET c0 + 1); +-- +ok +== +SELECT 1 c0, (SELECT 0 OFFSET c0 - 1); +-- +ok +== +SELECT (SELECT avg(0)) c0, (SELECT 0 OFFSET c0 + 1); +-- +ok +== +select avg(0) AS c0, (SELECT c0); +-- +ok +== diff --git a/parser/testdata/corpus/fuzzer/pedro/art_concatenate_prefix.test b/parser/testdata/corpus/fuzzer/pedro/art_concatenate_prefix.test new file mode 100644 index 0000000..609dcd3 --- /dev/null +++ b/parser/testdata/corpus/fuzzer/pedro/art_concatenate_prefix.test @@ -0,0 +1,21 @@ +# source: test/fuzzer/pedro/art_concatenate_prefix.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +CREATE TABLE t0(c0 INT); +-- +ok +== +CREATE INDEX i0 ON t0 (c0, (BLOB '\xE7\x1F\x8B&\xF0')); +-- +ok +== +INSERT INTO t0 VALUES (-2041046163), (35016222); +-- +ok +== +TRUNCATE t0; +-- +ok +== diff --git a/parser/testdata/corpus/fuzzer/pedro/art_prefix_error.test b/parser/testdata/corpus/fuzzer/pedro/art_prefix_error.test new file mode 100644 index 0000000..6aac757 --- /dev/null +++ b/parser/testdata/corpus/fuzzer/pedro/art_prefix_error.test @@ -0,0 +1,13 @@ +# source: test/fuzzer/pedro/art_prefix_error.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +CREATE TABLE t0 (c0 BLOB PRIMARY KEY); +-- +ok +== +INSERT INTO t0(c0) VALUES (BLOB '\x00a'), (BLOB ''); +-- +ok +== diff --git a/parser/testdata/corpus/fuzzer/pedro/between_mark_reference.test b/parser/testdata/corpus/fuzzer/pedro/between_mark_reference.test new file mode 100644 index 0000000..c88b6e7 --- /dev/null +++ b/parser/testdata/corpus/fuzzer/pedro/between_mark_reference.test @@ -0,0 +1,13 @@ +# source: test/fuzzer/pedro/between_mark_reference.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +SELECT 1 WHERE '23:' > ALL(SELECT '0') BETWEEN false AND true; +-- +ok +== +SELECT 1 WHERE '23:' > ALL(SELECT '0') BETWEEN '0' AND '0:'; +-- +ok +== diff --git a/parser/testdata/corpus/fuzzer/pedro/between_type_mismatch.test b/parser/testdata/corpus/fuzzer/pedro/between_type_mismatch.test new file mode 100644 index 0000000..aaf4cb2 --- /dev/null +++ b/parser/testdata/corpus/fuzzer/pedro/between_type_mismatch.test @@ -0,0 +1,13 @@ +# source: test/fuzzer/pedro/between_type_mismatch.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +CREATE TABLE t0 (c1 USMALLINT); +-- +ok +== +SELECT 1 FROM (SELECT 1) t1(c0) JOIN t0 ON c1 BETWEEN c0 AND 1; +-- +ok +== diff --git a/parser/testdata/corpus/fuzzer/pedro/binder_assertion_error.test b/parser/testdata/corpus/fuzzer/pedro/binder_assertion_error.test new file mode 100644 index 0000000..361f3b5 --- /dev/null +++ b/parser/testdata/corpus/fuzzer/pedro/binder_assertion_error.test @@ -0,0 +1,43 @@ +# source: test/fuzzer/pedro/binder_assertion_error.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +SELECT (SELECT 2) c0 WHERE (SELECT (SELECT (SELECT c0))); +-- +ok +== +SELECT (SELECT 0) c0 WHERE (SELECT c0); +-- +ok +== +select (select 42) as a, (select a); +-- +ok +== +select (select 1) a where (select (select 3) b where (select b) > (select a)); +-- +ok +== +select (select 5) a where (select (select 3) b where (select b) > (select a)); +-- +ok +== +select (select 5) a, (select 7) c where (select (select 3) b where (select a) > (select b) and (select c) > (select a)); +-- +ok +== +INSERT INTO t0 VALUES (1), (2), (3), (4); +-- +ok +== +select (select 1) a1, (select 3) as a3, c0 + from t0 where a1 + c0 in (select c0 as a1 from t0 where a1 + 1 = a3); +-- +ok +== +select (select 1) a1, (select 3) as a3, c0 + from t0 where a1 + c0 in (select c0 as a1 from t0 where a1 + 5 = a3); +-- +ok +== diff --git a/parser/testdata/corpus/fuzzer/pedro/binder_error_with_having_statement.test b/parser/testdata/corpus/fuzzer/pedro/binder_error_with_having_statement.test new file mode 100644 index 0000000..9d5b3a3 --- /dev/null +++ b/parser/testdata/corpus/fuzzer/pedro/binder_error_with_having_statement.test @@ -0,0 +1,29 @@ +# source: test/fuzzer/pedro/binder_error_with_having_statement.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +CREATE TABLE t2(c1 INT, c2 INT); +-- +ok +== +SELECT 1 alias1 FROM (SELECT 1) t2(c1) GROUP BY ALL HAVING (SELECT c1); +-- +ok +== +SELECT 1 alias1 FROM (SELECT 1) t2(c1) GROUP BY ALL HAVING (SELECT alias1); +-- +ok +== +SELECT 1 alias1 FROM (SELECT 1) t2(c1) GROUP BY c1 HAVING (SELECT c1); +-- +ok +== +SELECT 0 c0 FROM t1 GROUP BY ALL HAVING c0 < ALL(SELECT 0 FROM ((SELECT 2) UNION (SELECT 2)) t2 WHERE substr('b', 1, c0) GROUP BY ALL); +-- +ok +== +SELECT 1 FROM (SELECT 1) t1(c0) GROUP BY ALL HAVING EXISTS (SELECT 1 FROM (SELECT 1) t0(c2) HAVING c0); +-- +ok +== diff --git a/parser/testdata/corpus/fuzzer/pedro/blob_wrong_optimization.test b/parser/testdata/corpus/fuzzer/pedro/blob_wrong_optimization.test new file mode 100644 index 0000000..a46d36a --- /dev/null +++ b/parser/testdata/corpus/fuzzer/pedro/blob_wrong_optimization.test @@ -0,0 +1,41 @@ +# source: test/fuzzer/pedro/blob_wrong_optimization.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +CREATE VIEW t1(c1, c0) AS (SELECT 1, max(c0) FROM t0); +-- +ok +== +SELECT 1 FROM t1; +-- +ok +== +SELECT 1 FROM t1 WHERE '\x96'::BLOB IN (1); +-- +ok +== +SELECT 1 FROM t1 WHERE NOT ('\x96'::BLOB IN (1)); +-- +ok +== +SELECT 1 FROM t1 WHERE ('\x96'::BLOB IN (1)) IS NULL; +-- +ok +== +CREATE OR REPLACE VIEW t1(c0) AS (SELECT (SELECT 1 WHERE FALSE)); +-- +ok +== +SELECT 1 FROM t1 WHERE decode('\xC0'::BLOB) IS NULL; --1 row, wrong? +-- +ok +== +SELECT 1 FROM t1 WHERE NOT (decode('\xC0'::BLOB) IS NULL); --1 row +-- +ok +== +SELECT 1 FROM t1 WHERE (decode('\xC0'::BLOB) IS NULL) IS NULL; --1 row, wrong? +-- +ok +== diff --git a/parser/testdata/corpus/fuzzer/pedro/buffer_manager_out_of_memory.test b/parser/testdata/corpus/fuzzer/pedro/buffer_manager_out_of_memory.test new file mode 100644 index 0000000..3434c37 --- /dev/null +++ b/parser/testdata/corpus/fuzzer/pedro/buffer_manager_out_of_memory.test @@ -0,0 +1,33 @@ +# source: test/fuzzer/pedro/buffer_manager_out_of_memory.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +PRAGMA MEMORY_LIMIT='10MB'; +-- +ok +== +SET threads=8; +-- +ok +== +SELECT ((SELECT 1::VARCHAR) EXCEPT (SELECT ('\xF1\x85\x96\xBA'::BLOB)::VARCHAR GROUP BY 1 ORDER BY 1)); +-- +ok +== +PRAGMA MEMORY_LIMIT='8MB'; +-- +ok +== +SELECT t0.*, min(1 ORDER BY *) FROM (VALUES ('1')) t0(c0) GROUP BY ALL; +-- +ok +== +SELECT t0.*, min(1 ORDER BY COLUMNS(*)) FROM (VALUES ('1')) t0(c0) GROUP BY ALL; +-- +ok +== +SELECT t0.*, min(1 ORDER BY ALL) FROM (VALUES ('1')) t0(c0) GROUP BY ALL; +-- +ok +== diff --git a/parser/testdata/corpus/fuzzer/pedro/buffer_manager_resize_issue.test b/parser/testdata/corpus/fuzzer/pedro/buffer_manager_resize_issue.test new file mode 100644 index 0000000..1c68759 --- /dev/null +++ b/parser/testdata/corpus/fuzzer/pedro/buffer_manager_resize_issue.test @@ -0,0 +1,33 @@ +# source: test/fuzzer/pedro/buffer_manager_resize_issue.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +CREATE TABLE t1 (c1 INT, c0 INT); +-- +ok +== +CREATE TABLE t2 (c1 INT, c0 INT); +-- +ok +== +CREATE INDEX i1 ON t2 (c1); +-- +ok +== +CREATE INDEX i1 ON t1 (c0); +-- +ok +== +CREATE UNIQUE INDEX i1 ON t2 (c1); +-- +ok +== +INSERT INTO t2(c1,c0) VALUES (235,36), (43,81), (246,187), (28,149), (206,20), (135,11), (170,205), (202,63), (69,78), (160,50), (6,34), (207,28); +-- +ok +== +INSERT INTO t2(c1,c0) VALUES (86,98), (96,107), (237,190), (253,242), (229,9), (6,147); +-- +ok +== diff --git a/parser/testdata/corpus/fuzzer/pedro/cardinality_estimator_assertion_error.test b/parser/testdata/corpus/fuzzer/pedro/cardinality_estimator_assertion_error.test new file mode 100644 index 0000000..41e1e73 --- /dev/null +++ b/parser/testdata/corpus/fuzzer/pedro/cardinality_estimator_assertion_error.test @@ -0,0 +1,17 @@ +# source: test/fuzzer/pedro/cardinality_estimator_assertion_error.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +SELECT 1 FROM (SELECT 2) t0, (SELECT 3) t1 WHERE INTERVAL '1' DAYS USING SAMPLE (1 ROWS) REPEATABLE (1); +-- +ok +== +SELECT (SELECT 1 WHERE INTERVAL '1' DAY HAVING EXISTS (SELECT 1)); +-- +ok +== +SELECT 1 FROM (SELECT 2) t0, (SELECT 3) t1 WHERE (SELECT 1 NOT IN (SELECT 2)); +-- +ok +== diff --git a/parser/testdata/corpus/fuzzer/pedro/cardinality_estimator_runtime_issue.test b/parser/testdata/corpus/fuzzer/pedro/cardinality_estimator_runtime_issue.test new file mode 100644 index 0000000..92229b5 --- /dev/null +++ b/parser/testdata/corpus/fuzzer/pedro/cardinality_estimator_runtime_issue.test @@ -0,0 +1,17 @@ +# source: test/fuzzer/pedro/cardinality_estimator_runtime_issue.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +CREATE TABLE t0 AS (SELECT 2); +-- +ok +== +DELETE FROM t0 USING generate_series(1); +-- +ok +== +SELECT * FROM t0 +-- +ok +== diff --git a/parser/testdata/corpus/fuzzer/pedro/comparison_to_string.test b/parser/testdata/corpus/fuzzer/pedro/comparison_to_string.test new file mode 100644 index 0000000..8a153b6 --- /dev/null +++ b/parser/testdata/corpus/fuzzer/pedro/comparison_to_string.test @@ -0,0 +1,13 @@ +# source: test/fuzzer/pedro/comparison_to_string.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +SELECT 1 WHERE (1 IS DISTINCT FROM 1) > ANY(SELECT 2); +-- +ok +== +SELECT 1 WHERE (1 IS DISTINCT FROM 1) IS NULL; +-- +ok +== diff --git a/parser/testdata/corpus/fuzzer/pedro/complex_offset_clause_crash.test b/parser/testdata/corpus/fuzzer/pedro/complex_offset_clause_crash.test new file mode 100644 index 0000000..7fb1928 --- /dev/null +++ b/parser/testdata/corpus/fuzzer/pedro/complex_offset_clause_crash.test @@ -0,0 +1,9 @@ +# source: test/fuzzer/pedro/complex_offset_clause_crash.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +SELECT 6 OFFSET count(*) FILTER ((SELECT 2 UNION (SELECT 2) OFFSET (SELECT LAST))) OVER (); +-- +ok +== diff --git a/parser/testdata/corpus/fuzzer/pedro/complex_type_all_subquery.test b/parser/testdata/corpus/fuzzer/pedro/complex_type_all_subquery.test new file mode 100644 index 0000000..bc2acdb --- /dev/null +++ b/parser/testdata/corpus/fuzzer/pedro/complex_type_all_subquery.test @@ -0,0 +1,37 @@ +# source: test/fuzzer/pedro/complex_type_all_subquery.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +VALUES((0, 0) = ALL(SELECT 2)); +-- +ok +== +SELECT (1, 0, 0) < ANY(SELECT 1, 0, ); +-- +ok +== +SELECT {'a': 42} = ALL(SELECT {'a': '42'}) +-- +ok +== +SELECT {val} = ALL(SELECT {val}) +-- +error: Parser Error: syntax error at or near "}" +== +SELECT {val} = ALL(SELECT {val} UNION ALL SELECT NULL) +-- +error: Parser Error: syntax error at or near "}" +== +SELECT {val} = ALL(SELECT {val} FROM range(3000)) +-- +error: Parser Error: syntax error at or near "}" +== +SELECT {val} > ANY(SELECT {val} FROM range(3000)) +-- +error: Parser Error: syntax error at or near "}" +== +SELECT {val} >= ANY(SELECT {val} FROM range(3000)) +-- +error: Parser Error: syntax error at or near "}" +== diff --git a/parser/testdata/corpus/fuzzer/pedro/concurrent_catalog_usage.test b/parser/testdata/corpus/fuzzer/pedro/concurrent_catalog_usage.test new file mode 100644 index 0000000..0facd65 --- /dev/null +++ b/parser/testdata/corpus/fuzzer/pedro/concurrent_catalog_usage.test @@ -0,0 +1,13 @@ +# source: test/fuzzer/pedro/concurrent_catalog_usage.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +CREATE TABLE t2 AS (SELECT 42); +-- +ok +== +CREATE OR REPLACE TABLE t2 AS (SELECT -54124033386577348004002656426531535114 FROM t2 LIMIT 70%); +-- +ok +== diff --git a/parser/testdata/corpus/fuzzer/pedro/concurrent_set_threads.test b/parser/testdata/corpus/fuzzer/pedro/concurrent_set_threads.test new file mode 100644 index 0000000..f4aa34a --- /dev/null +++ b/parser/testdata/corpus/fuzzer/pedro/concurrent_set_threads.test @@ -0,0 +1,9 @@ +# source: test/fuzzer/pedro/concurrent_set_threads.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +SET threads={i} +-- +error: Parser Error: syntax error at or near "}" +== diff --git a/parser/testdata/corpus/fuzzer/pedro/constraints_temp_table.test b/parser/testdata/corpus/fuzzer/pedro/constraints_temp_table.test new file mode 100644 index 0000000..a1eabc1 --- /dev/null +++ b/parser/testdata/corpus/fuzzer/pedro/constraints_temp_table.test @@ -0,0 +1,25 @@ +# source: test/fuzzer/pedro/constraints_temp_table.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +CREATE TABLE t0 (c1 INT, c0 INT CONSTRAINT k1 REFERENCES t0(c0) UNIQUE); +-- +ok +== +CREATE TABLE t1 AS (SELECT 1); +-- +ok +== +CREATE TEMP TABLE t0 AS (SELECT 1); +-- +ok +== +SELECT * FROM duckdb_constraints() +-- +ok +== +SHOW +-- +ok +== diff --git a/parser/testdata/corpus/fuzzer/pedro/correlated_in_segv.test b/parser/testdata/corpus/fuzzer/pedro/correlated_in_segv.test new file mode 100644 index 0000000..9d954f5 --- /dev/null +++ b/parser/testdata/corpus/fuzzer/pedro/correlated_in_segv.test @@ -0,0 +1,17 @@ +# source: test/fuzzer/pedro/correlated_in_segv.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +SELECT (SELECT 1 WHERE 1 IN (c0) GROUP BY ()) FROM (SELECT 1) t0(c0); +-- +ok +== +SELECT ((SELECT 1) EXCEPT (SELECT c0 LIMIT 0)) FROM VALUES (0), t0(c0); +-- +ok +== +SELECT 1 + count() FILTER (WHERE EXISTS (SELECT EXISTS (SELECT 1))); +-- +ok +== diff --git a/parser/testdata/corpus/fuzzer/pedro/correlated_limit_rowid.test b/parser/testdata/corpus/fuzzer/pedro/correlated_limit_rowid.test new file mode 100644 index 0000000..7795c9c --- /dev/null +++ b/parser/testdata/corpus/fuzzer/pedro/correlated_limit_rowid.test @@ -0,0 +1,9 @@ +# source: test/fuzzer/pedro/correlated_limit_rowid.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +SELECT (SELECT 1 LIMIT t1.rowid) FROM t1 NATURAL JOIN t0; +-- +ok +== diff --git a/parser/testdata/corpus/fuzzer/pedro/correlated_offset_subquery.test b/parser/testdata/corpus/fuzzer/pedro/correlated_offset_subquery.test new file mode 100644 index 0000000..64503e6 --- /dev/null +++ b/parser/testdata/corpus/fuzzer/pedro/correlated_offset_subquery.test @@ -0,0 +1,13 @@ +# source: test/fuzzer/pedro/correlated_offset_subquery.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +SELECT (SELECT 1 OFFSET c0) FROM (VALUES(1)) c0; +-- +ok +== +SELECT 0 FROM (SELECT 8 c0) WHERE (SELECT 1 LIMIT c0); +-- +ok +== diff --git a/parser/testdata/corpus/fuzzer/pedro/correlated_subquery_downcast_error.test b/parser/testdata/corpus/fuzzer/pedro/correlated_subquery_downcast_error.test new file mode 100644 index 0000000..219e950 --- /dev/null +++ b/parser/testdata/corpus/fuzzer/pedro/correlated_subquery_downcast_error.test @@ -0,0 +1,9 @@ +# source: test/fuzzer/pedro/correlated_subquery_downcast_error.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +SELECT count(*) OVER() = ANY(SELECT * FROM t0 t1 WHERE(c0 = t0.c0)) FROM t0; +-- +ok +== diff --git a/parser/testdata/corpus/fuzzer/pedro/create_index_error.test b/parser/testdata/corpus/fuzzer/pedro/create_index_error.test new file mode 100644 index 0000000..543b282 --- /dev/null +++ b/parser/testdata/corpus/fuzzer/pedro/create_index_error.test @@ -0,0 +1,69 @@ +# source: test/fuzzer/pedro/create_index_error.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +CREATE TABLE t0 (c0 VARCHAR, c1 INT); +-- +ok +== +INSERT INTO t0(c0) VALUES ('a'); +-- +ok +== +CREATE INDEX i1 ON t0 (c1, CAST('c' AS INT)); +-- +ok +== +CREATE INDEX i0 ON t0 (c0); +-- +ok +== +DROP TABLE t0 +-- +ok +== +CREATE TABLE t0 (c1 INT, c0 INT); +-- +ok +== +INSERT INTO t0(c0) VALUES (1); +-- +ok +== +CREATE INDEX i1 ON t0 ((decode('\x0C\xE4\x85\xF5'::BLOB)::VARCHAR), c1); +-- +ok +== +DELETE FROM t0; +-- +ok +== +CREATE TABLE t1 (c1 BOOLEAN); +-- +ok +== +INSERT INTO t1 VALUES (0); +-- +ok +== +DELETE FROM t1; +-- +ok +== +CREATE INDEX i0 ON t1 (c1, (decode('\x81\x5C\xE5'::BLOB)::VARCHAR)); +-- +ok +== +INSERT INTO t1 VALUES (1); +-- +ok +== +CREATE INDEX i1 ON t1 USING ART (c1); +-- +ok +== +create index i2 ON t1(c1) WHERE c1 != TRUE; +-- +ok +== diff --git a/parser/testdata/corpus/fuzzer/pedro/create_replace_table_union.test b/parser/testdata/corpus/fuzzer/pedro/create_replace_table_union.test new file mode 100644 index 0000000..7d286ee --- /dev/null +++ b/parser/testdata/corpus/fuzzer/pedro/create_replace_table_union.test @@ -0,0 +1,25 @@ +# source: test/fuzzer/pedro/create_replace_table_union.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +CREATE OR REPLACE TABLE t0 AS ((SELECT 1) UNION ALL ((SELECT 2) INTERSECT ALL (SELECT 2))); +-- +ok +== +CREATE VIEW t1(c1) AS ((SELECT 1) UNION DISTINCT (SELECT 1)); +-- +ok +== +CREATE OR REPLACE TABLE t1 AS (SELECT * FROM range(10) ORDER BY 1) UNION ALL (SELECT * FROM range(10) ORDER BY 1); +-- +ok +== +CREATE OR REPLACE TABLE t1 AS (SELECT 1) UNION ALL (SELECT * FROM range(10) ORDER BY 1); +-- +ok +== +CREATE OR REPLACE TABLE t1 AS ((SELECT 1) UNION ALL ((SELECT 2) INTERSECT ALL (SELECT 2))); +-- +ok +== diff --git a/parser/testdata/corpus/fuzzer/pedro/currval_sequence_dependency.test b/parser/testdata/corpus/fuzzer/pedro/currval_sequence_dependency.test new file mode 100644 index 0000000..067f3b6 --- /dev/null +++ b/parser/testdata/corpus/fuzzer/pedro/currval_sequence_dependency.test @@ -0,0 +1,25 @@ +# source: test/fuzzer/pedro/currval_sequence_dependency.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +CREATE SEQUENCE seq; +-- +ok +== +CREATE TABLE t1(c1 INT, CHECK({fun}('seq'))); +-- +error: Parser Error: syntax error at or near "}" +== +DROP SEQUENCE seq; +-- +ok +== +DROP SEQUENCE seq CASCADE; +-- +ok +== +INSERT INTO t1 VALUES (1) +-- +ok +== diff --git a/parser/testdata/corpus/fuzzer/pedro/date_int_optimizer_error.test b/parser/testdata/corpus/fuzzer/pedro/date_int_optimizer_error.test new file mode 100644 index 0000000..d776836 --- /dev/null +++ b/parser/testdata/corpus/fuzzer/pedro/date_int_optimizer_error.test @@ -0,0 +1,13 @@ +# source: test/fuzzer/pedro/date_int_optimizer_error.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +SELECT 1 FROM t0 WHERE DATE '2010-1-1' = 2; +-- +ok +== +SELECT 1 FROM (VALUES (1),(2),(NULL),(4)) t0(c0) WHERE c0 BETWEEN 3 AND (CAST('inf' AS REAL) - 2); +-- +ok +== diff --git a/parser/testdata/corpus/fuzzer/pedro/decimal_with_invalid_scale.test b/parser/testdata/corpus/fuzzer/pedro/decimal_with_invalid_scale.test new file mode 100644 index 0000000..13f41b1 --- /dev/null +++ b/parser/testdata/corpus/fuzzer/pedro/decimal_with_invalid_scale.test @@ -0,0 +1,9 @@ +# source: test/fuzzer/pedro/decimal_with_invalid_scale.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +CREATE TABLE x(x DECIMAL(38763269, 77914819)); +-- +ok +== diff --git a/parser/testdata/corpus/fuzzer/pedro/delete_add_column.test b/parser/testdata/corpus/fuzzer/pedro/delete_add_column.test new file mode 100644 index 0000000..c9781d5 --- /dev/null +++ b/parser/testdata/corpus/fuzzer/pedro/delete_add_column.test @@ -0,0 +1,37 @@ +# source: test/fuzzer/pedro/delete_add_column.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +CREATE TABLE t1 AS SELECT 1 c1; +-- +ok +== +ALTER TABLE t1 ADD c0 INT; +-- +ok +== +SELECT * FROM t1 +-- +ok +== +TRUNCATE t1; +-- +ok +== +DROP TABLE t1 +-- +ok +== +CREATE TABLE t1(c0 VARCHAR); +-- +ok +== +ALTER TABLE t1 ADD c1 INT; +-- +ok +== +INSERT INTO t1 AS t0(c0) VALUES(4); +-- +ok +== diff --git a/parser/testdata/corpus/fuzzer/pedro/delete_using_bindings.test b/parser/testdata/corpus/fuzzer/pedro/delete_using_bindings.test new file mode 100644 index 0000000..aafcbda --- /dev/null +++ b/parser/testdata/corpus/fuzzer/pedro/delete_using_bindings.test @@ -0,0 +1,13 @@ +# source: test/fuzzer/pedro/delete_using_bindings.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +DELETE FROM t0 USING ((SELECT 1) t1 INNER JOIN (SELECT 2) t2 ON t0.c0); +-- +ok +== +DELETE FROM t0 USING ((SELECT 1) t1 INNER JOIN (SELECT 2) t2 ON c0); +-- +ok +== diff --git a/parser/testdata/corpus/fuzzer/pedro/drop_gcol.test b/parser/testdata/corpus/fuzzer/pedro/drop_gcol.test new file mode 100644 index 0000000..4951c75 --- /dev/null +++ b/parser/testdata/corpus/fuzzer/pedro/drop_gcol.test @@ -0,0 +1,13 @@ +# source: test/fuzzer/pedro/drop_gcol.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +CREATE TABLE t0 (c0 INT AS (0), c1 INT, CHECK(c1 > 0)); +-- +ok +== +ALTER TABLE t0 DROP c0; +-- +ok +== diff --git a/parser/testdata/corpus/fuzzer/pedro/duplicate_cte.test b/parser/testdata/corpus/fuzzer/pedro/duplicate_cte.test new file mode 100644 index 0000000..41f2f7c --- /dev/null +++ b/parser/testdata/corpus/fuzzer/pedro/duplicate_cte.test @@ -0,0 +1,9 @@ +# source: test/fuzzer/pedro/duplicate_cte.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +WITH t0 AS (SELECT 2) INSERT INTO t0 (WITH t0 AS (SELECT 2) SELECT 2); +-- +ok +== diff --git a/parser/testdata/corpus/fuzzer/pedro/duplicate_using_clause.test b/parser/testdata/corpus/fuzzer/pedro/duplicate_using_clause.test new file mode 100644 index 0000000..9e0d403 --- /dev/null +++ b/parser/testdata/corpus/fuzzer/pedro/duplicate_using_clause.test @@ -0,0 +1,45 @@ +# source: test/fuzzer/pedro/duplicate_using_clause.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +CREATE TABLE t1(c0 INT); +-- +ok +== +SELECT * FROM t1 JOIN t1 t2 USING (c0, c0) +-- +ok +== +SELECT * FROM (t1 JOIN t1 t2 USING (c0)), (SELECT 42) +-- +ok +== +SELECT * FROM (t1 JOIN t1 t2 USING (c0, c0)), (SELECT 42) +-- +ok +== +create table tbl as select 42 AS i; +-- +ok +== +select * from tbl t1 join tbl t2 using (i) join tbl t3 using (i); +-- +ok +== +select * from tbl t1 join tbl t2 using (i, i) join tbl t3 using (i, i, i); +-- +ok +== +create or replace table tbl as select 42 AS i, 84 as j; +-- +ok +== +select * from tbl t1 join tbl t2 using (i, j) join tbl t3 using (i, j); +-- +ok +== +select * from tbl t1 join tbl t2 using (i, j, i) join tbl t3 using (i, i, i, j, i); +-- +ok +== diff --git a/parser/testdata/corpus/fuzzer/pedro/escaped_trim_function_call.test b/parser/testdata/corpus/fuzzer/pedro/escaped_trim_function_call.test new file mode 100644 index 0000000..31415d8 --- /dev/null +++ b/parser/testdata/corpus/fuzzer/pedro/escaped_trim_function_call.test @@ -0,0 +1,13 @@ +# source: test/fuzzer/pedro/escaped_trim_function_call.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +SELECT "trim"('hello'); +-- +ok +== +SELECT trim('hello'); +-- +ok +== diff --git a/parser/testdata/corpus/fuzzer/pedro/export_parquet_generated.test b/parser/testdata/corpus/fuzzer/pedro/export_parquet_generated.test new file mode 100644 index 0000000..4de50af --- /dev/null +++ b/parser/testdata/corpus/fuzzer/pedro/export_parquet_generated.test @@ -0,0 +1,41 @@ +# source: test/fuzzer/pedro/export_parquet_generated.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +BEGIN; +-- +ok +== +CREATE TABLE t0 (c0 INT AS (1), c1 INT); +-- +ok +== +EXPORT DATABASE '{TEST_DIR}/parquet_generated_dump' (FORMAT PARQUET); +-- +ok +== +ROLLBACK; +-- +ok +== +IMPORT DATABASE '{TEST_DIR}/parquet_generated_dump'; +-- +ok +== +COPY (SELECT 42) TO '{TEST_DIR}/parquet_single.parquet' +-- +ok +== +COPY t0 FROM '{TEST_DIR}/parquet_single.parquet' +-- +ok +== +FROM t0 +-- +ok +== +COPY t0 (c1) FROM '{TEST_DIR}/parquet_single.parquet' +-- +ok +== diff --git a/parser/testdata/corpus/fuzzer/pedro/first_value_window_crash.test b/parser/testdata/corpus/fuzzer/pedro/first_value_window_crash.test new file mode 100644 index 0000000..08da5d4 --- /dev/null +++ b/parser/testdata/corpus/fuzzer/pedro/first_value_window_crash.test @@ -0,0 +1,9 @@ +# source: test/fuzzer/pedro/first_value_window_crash.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +SELECT first_value((1 || mode() WITHIN GROUP (ORDER BY 1)) IGNORE NULLS) OVER () FROM t1; +-- +ok +== diff --git a/parser/testdata/corpus/fuzzer/pedro/floating_point_conversion_overflow.test b/parser/testdata/corpus/fuzzer/pedro/floating_point_conversion_overflow.test new file mode 100644 index 0000000..79f3509 --- /dev/null +++ b/parser/testdata/corpus/fuzzer/pedro/floating_point_conversion_overflow.test @@ -0,0 +1,61 @@ +# source: test/fuzzer/pedro/floating_point_conversion_overflow.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +SELECT 0::{float_type}::{type} +-- +error: Parser Error: syntax error at or near "{" +== +SELECT (-1)::{float_type}::{type} +-- +error: Parser Error: syntax error at or near "{" +== +SELECT 255::{float_type}::UTINYINT +-- +error: Parser Error: syntax error at or near "{" +== +SELECT 256::{float_type}::UTINYINT +-- +error: Parser Error: syntax error at or near "{" +== +SELECT 65535::{float_type}::USMALLINT +-- +error: Parser Error: syntax error at or near "{" +== +SELECT 65536::{float_type}::USMALLINT +-- +error: Parser Error: syntax error at or near "{" +== +SELECT 4294967167::REAL::UINTEGER +-- +ok +== +SELECT 4294967168::REAL::UINTEGER +-- +ok +== +SELECT 4294967295::DOUBLE::UINTEGER +-- +ok +== +SELECT 4294967296::DOUBLE::UINTEGER +-- +ok +== +SELECT 18446743523953736703::REAL::UBIGINT +-- +ok +== +SELECT 18446743523953736704::REAL::UBIGINT +-- +ok +== +SELECT 18446744073709550591::DOUBLE::UBIGINT +-- +ok +== +SELECT 18446744073709550592::DOUBLE::UBIGINT +-- +ok +== diff --git a/parser/testdata/corpus/fuzzer/pedro/floating_point_inequality.test b/parser/testdata/corpus/fuzzer/pedro/floating_point_inequality.test new file mode 100644 index 0000000..459d92e --- /dev/null +++ b/parser/testdata/corpus/fuzzer/pedro/floating_point_inequality.test @@ -0,0 +1,13 @@ +# source: test/fuzzer/pedro/floating_point_inequality.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +SELECT -0::DOUBLE, 0::DOUBLE; +-- +ok +== +SELECT '+nan'::DOUBLE, '-nan'::DOUBLE; +-- +ok +== diff --git a/parser/testdata/corpus/fuzzer/pedro/force_external_blob.test b/parser/testdata/corpus/fuzzer/pedro/force_external_blob.test new file mode 100644 index 0000000..019332a --- /dev/null +++ b/parser/testdata/corpus/fuzzer/pedro/force_external_blob.test @@ -0,0 +1,13 @@ +# source: test/fuzzer/pedro/force_external_blob.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +PRAGMA DEBUG_FORCE_EXTERNAL=1; +-- +ok +== +SELECT BLOB 't\xF0\xC0\xD3\x86\xF1p?\xCE;\xC6~H' ORDER BY 1; +-- +ok +== diff --git a/parser/testdata/corpus/fuzzer/pedro/force_no_cross_product.test b/parser/testdata/corpus/fuzzer/pedro/force_no_cross_product.test new file mode 100644 index 0000000..621886b --- /dev/null +++ b/parser/testdata/corpus/fuzzer/pedro/force_no_cross_product.test @@ -0,0 +1,13 @@ +# source: test/fuzzer/pedro/force_no_cross_product.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +PRAGMA debug_force_no_cross_product=1; +-- +ok +== +SELECT 1 FROM (SELECT 1), (SELECT 1); +-- +ok +== diff --git a/parser/testdata/corpus/fuzzer/pedro/forced_parallelism_empty_select.test b/parser/testdata/corpus/fuzzer/pedro/forced_parallelism_empty_select.test new file mode 100644 index 0000000..0c11995 --- /dev/null +++ b/parser/testdata/corpus/fuzzer/pedro/forced_parallelism_empty_select.test @@ -0,0 +1,17 @@ +# source: test/fuzzer/pedro/forced_parallelism_empty_select.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +PRAGMA verify_parallelism; +-- +ok +== +CREATE TABLE t0 (c0 INT, c1 INT); +-- +ok +== +SELECT c1 FROM t0 WHERE (c0 + c1) = 2; +-- +ok +== diff --git a/parser/testdata/corpus/fuzzer/pedro/foreign_key_binding_issue.test b/parser/testdata/corpus/fuzzer/pedro/foreign_key_binding_issue.test new file mode 100644 index 0000000..858f6cd --- /dev/null +++ b/parser/testdata/corpus/fuzzer/pedro/foreign_key_binding_issue.test @@ -0,0 +1,21 @@ +# source: test/fuzzer/pedro/foreign_key_binding_issue.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +CREATE TABLE t0 (c0 INT, UNIQUE (c0, c0)); +-- +error: Parser Error: column "c0" appears twice in primary key constraint +== +CREATE TABLE t0 (c0 INT, FOREIGN KEY (c0, c0) REFERENCES t0(c0, c0), UNIQUE (c0, c0)); +-- +error: Parser Error: duplicate primary key referenced in FOREIGN KEY constraint +== +CREATE TABLE t0 (c0 INT, c1 INT, FOREIGN KEY (c0, c0) REFERENCES t0(c0, c1), UNIQUE (c0, c1)); +-- +error: Parser Error: duplicate key specified in FOREIGN KEY constraint +== +CREATE TABLE t0 (c0 INT, c1 INT, FOREIGN KEY (c0, c1) REFERENCES t0(c0, c1), UNIQUE (c0, c1)); +-- +ok +== diff --git a/parser/testdata/corpus/fuzzer/pedro/foreign_key_binding_issue.test.metadata.json b/parser/testdata/corpus/fuzzer/pedro/foreign_key_binding_issue.test.metadata.json new file mode 100644 index 0000000..4552362 --- /dev/null +++ b/parser/testdata/corpus/fuzzer/pedro/foreign_key_binding_issue.test.metadata.json @@ -0,0 +1,7 @@ +{ + "todo": { + "3dd4680747d25c85": "transformer-raised parser error: upstream rejects in the transformer, not the grammar; expected to clear as transformers land (milestones 3-5)", + "f630e248a8b93d80": "transformer-raised parser error: upstream rejects in the transformer, not the grammar; expected to clear as transformers land (milestones 3-5)", + "fff2fa19f530201f": "transformer-raised parser error: upstream rejects in the transformer, not the grammar; expected to clear as transformers land (milestones 3-5)" + } +} diff --git a/parser/testdata/corpus/fuzzer/pedro/foreign_key_type_mismatch.test b/parser/testdata/corpus/fuzzer/pedro/foreign_key_type_mismatch.test new file mode 100644 index 0000000..44b40c4 --- /dev/null +++ b/parser/testdata/corpus/fuzzer/pedro/foreign_key_type_mismatch.test @@ -0,0 +1,17 @@ +# source: test/fuzzer/pedro/foreign_key_type_mismatch.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +CREATE TABLE t0 (c2 INT CONSTRAINT k0 UNIQUE, c0 DECIMAL, CONSTRAINT k1 FOREIGN KEY (c0) REFERENCES t0 (c2)); +-- +ok +== +CREATE TABLE t0 (c2 INT CONSTRAINT k0 UNIQUE); +-- +ok +== +CREATE TABLE t1 (c0 DECIMAL, CONSTRAINT k1 FOREIGN KEY (c0) REFERENCES t0 (c2)); +-- +ok +== diff --git a/parser/testdata/corpus/fuzzer/pedro/gcol_stack_overflow.test b/parser/testdata/corpus/fuzzer/pedro/gcol_stack_overflow.test new file mode 100644 index 0000000..6bb591f --- /dev/null +++ b/parser/testdata/corpus/fuzzer/pedro/gcol_stack_overflow.test @@ -0,0 +1,25 @@ +# source: test/fuzzer/pedro/gcol_stack_overflow.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +CREATE TABLE t0 (c2 AS (c0) VIRTUAL, c0 INT); +-- +ok +== +insert into t0 VALUES(5); +-- +ok +== +SELECT 1 FROM t0 as {table_alias}(c0) WHERE c0 = 0; +-- +error: Parser Error: syntax error at or near "{" +== +select 1 from t0 as {table_alias}(c0); +-- +error: Parser Error: syntax error at or near "{" +== +select c0 from t0 as {table_alias}(c0); +-- +error: Parser Error: syntax error at or near "{" +== diff --git a/parser/testdata/corpus/fuzzer/pedro/group_by_all_row_alias.test b/parser/testdata/corpus/fuzzer/pedro/group_by_all_row_alias.test new file mode 100644 index 0000000..f87375d --- /dev/null +++ b/parser/testdata/corpus/fuzzer/pedro/group_by_all_row_alias.test @@ -0,0 +1,13 @@ +# source: test/fuzzer/pedro/group_by_all_row_alias.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +SELECT c1 c2, ROW(t0.c1, c2) FROM t0 GROUP BY ALL; +-- +ok +== +SELECT rowid c2 FROM t0 GROUP BY ALL ORDER BY (t0.rowid, c2); +-- +ok +== diff --git a/parser/testdata/corpus/fuzzer/pedro/hash_finalize_race.test b/parser/testdata/corpus/fuzzer/pedro/hash_finalize_race.test new file mode 100644 index 0000000..3cc2721 --- /dev/null +++ b/parser/testdata/corpus/fuzzer/pedro/hash_finalize_race.test @@ -0,0 +1,13 @@ +# source: test/fuzzer/pedro/hash_finalize_race.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +CREATE SEQUENCE t4; +-- +ok +== +SELECT 1 FROM ((SELECT 2) INTERSECT (SELECT 2)) t2(c3) WHERE "currval"('t4') = EXISTS (SELECT 2); +-- +ok +== diff --git a/parser/testdata/corpus/fuzzer/pedro/having_query_wrong_result.test b/parser/testdata/corpus/fuzzer/pedro/having_query_wrong_result.test new file mode 100644 index 0000000..8c87831 --- /dev/null +++ b/parser/testdata/corpus/fuzzer/pedro/having_query_wrong_result.test @@ -0,0 +1,17 @@ +# source: test/fuzzer/pedro/having_query_wrong_result.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +SELECT nextval('seq'); +-- +ok +== +SELECT currval('seq'); +-- +ok +== +SELECT 1 FROM (SELECT 1) t0(c0) GROUP BY CUBE (1) HAVING (currval('seq') IS NULL); +-- +ok +== diff --git a/parser/testdata/corpus/fuzzer/pedro/having_subquery_failed_to_bind.test b/parser/testdata/corpus/fuzzer/pedro/having_subquery_failed_to_bind.test new file mode 100644 index 0000000..9074d5d --- /dev/null +++ b/parser/testdata/corpus/fuzzer/pedro/having_subquery_failed_to_bind.test @@ -0,0 +1,29 @@ +# source: test/fuzzer/pedro/having_subquery_failed_to_bind.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +SELECT sum(c2) c0 FROM (SELECT 1) t1(c2) HAVING (SELECT c0); +-- +ok +== +SELECT count() as c0 FROM (SELECT 1) t1(c2) HAVING 1 = (SELECT c0 WHERE EXISTS (SELECT 1)); +-- +ok +== +SELECT count() as c0 FROM (SELECT 1) t1(c2) GROUP BY c0 HAVING 1 = (SELECT c0 WHERE EXISTS (SELECT 1)); +-- +ok +== +SELECT count() c0 FROM (SELECT 1) t1(c2) HAVING c0 = 1 +-- +ok +== +SELECT count(*) c1 HAVING EXISTS (SELECT 1 FROM t1 WHERE c1 BETWEEN c0 AND 0); +-- +ok +== +SELECT count(*) c1 HAVING EXISTS (SELECT 1 FROM t1 WHERE c1 = c0); +-- +ok +== diff --git a/parser/testdata/corpus/fuzzer/pedro/in_clause_optimization_error.test b/parser/testdata/corpus/fuzzer/pedro/in_clause_optimization_error.test new file mode 100644 index 0000000..78d2bdb --- /dev/null +++ b/parser/testdata/corpus/fuzzer/pedro/in_clause_optimization_error.test @@ -0,0 +1,37 @@ +# source: test/fuzzer/pedro/in_clause_optimization_error.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +INSERT INTO t0 VALUES (42) +-- +ok +== +SELECT 0 FROM t0 WHERE ? IN (1); +-- +ok +== +PREPARE v1 AS SELECT 0 FROM t0 WHERE ? IN (1); +-- +ok +== +EXECUTE v1(0) +-- +ok +== +EXECUTE v1(1) +-- +ok +== +PREPARE v2 AS SELECT $1 FROM t0 WHERE $1 IN (1); +-- +ok +== +EXECUTE v2(0) +-- +ok +== +EXECUTE v2(1) +-- +ok +== diff --git a/parser/testdata/corpus/fuzzer/pedro/in_clause_setop_rewrite.test b/parser/testdata/corpus/fuzzer/pedro/in_clause_setop_rewrite.test new file mode 100644 index 0000000..87f9b2f --- /dev/null +++ b/parser/testdata/corpus/fuzzer/pedro/in_clause_setop_rewrite.test @@ -0,0 +1,21 @@ +# source: test/fuzzer/pedro/in_clause_setop_rewrite.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +create table t0(id int); +-- +ok +== +insert into t0 values(1); +-- +ok +== +SELECT c1 FROM ((SELECT 1 AS c1) UNION (SELECT id AS c1 FROM t0 limit 1)) A where c1 IN (1, 2, 3, 4); +-- +ok +== +SELECT c1 FROM ((SELECT 1 AS c1) UNION (SELECT id AS c1 FROM t0 limit 1)) A where c1 IN (1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16); +-- +ok +== diff --git a/parser/testdata/corpus/fuzzer/pedro/incomplete_checkpoint.test b/parser/testdata/corpus/fuzzer/pedro/incomplete_checkpoint.test new file mode 100644 index 0000000..7f7034f --- /dev/null +++ b/parser/testdata/corpus/fuzzer/pedro/incomplete_checkpoint.test @@ -0,0 +1,33 @@ +# source: test/fuzzer/pedro/incomplete_checkpoint.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +PRAGMA wal_autocheckpoint='1TB'; +-- +ok +== +CREATE SCHEMA s1; +-- +ok +== +CHECKPOINT; +-- +ok +== +DROP SCHEMA s1; +-- +ok +== +PRAGMA DEBUG_CHECKPOINT_ABORT = 'after_free_list_write'; +-- +ok +== +CREATE SCHEMA s3; +-- +ok +== +CREATE TABLE s3.integers(i INTEGER) +-- +ok +== diff --git a/parser/testdata/corpus/fuzzer/pedro/incorrect_offset_result.test b/parser/testdata/corpus/fuzzer/pedro/incorrect_offset_result.test new file mode 100644 index 0000000..7501ac2 --- /dev/null +++ b/parser/testdata/corpus/fuzzer/pedro/incorrect_offset_result.test @@ -0,0 +1,13 @@ +# source: test/fuzzer/pedro/incorrect_offset_result.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +INSERT INTO t0 (VALUES (1, 1),(2, 2),(3, 3)); +-- +ok +== +SELECT c0 FROM t0 WHERE ((c0 + c1) = 2) OFFSET 10; +-- +ok +== diff --git a/parser/testdata/corpus/fuzzer/pedro/index_current_timestamp.test b/parser/testdata/corpus/fuzzer/pedro/index_current_timestamp.test new file mode 100644 index 0000000..d253bb0 --- /dev/null +++ b/parser/testdata/corpus/fuzzer/pedro/index_current_timestamp.test @@ -0,0 +1,33 @@ +# source: test/fuzzer/pedro/index_current_timestamp.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +CREATE TABLE t1(c0 INT, c1 VARCHAR); +-- +ok +== +INSERT INTO t1(c1) VALUES(1); +-- +ok +== +CREATE SEQUENCE seq +-- +ok +== +CREATE INDEX i1 ON t1((get_current_timestamp()), c1); +-- +ok +== +CREATE INDEX i1 ON t1((random()), c1); +-- +ok +== +CREATE INDEX i1 ON t1((nextval('seq')), c1); +-- +ok +== +INSERT INTO t1 VALUES (42, 'hello') +-- +ok +== diff --git a/parser/testdata/corpus/fuzzer/pedro/index_generated_column.test b/parser/testdata/corpus/fuzzer/pedro/index_generated_column.test new file mode 100644 index 0000000..72ffa1e --- /dev/null +++ b/parser/testdata/corpus/fuzzer/pedro/index_generated_column.test @@ -0,0 +1,21 @@ +# source: test/fuzzer/pedro/index_generated_column.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +CREATE INDEX i0 ON t0 USING ART ((c0 + c1)); +-- +ok +== +SELECT * FROM t0 WHERE (c0 + c1) = 3 +-- +ok +== +INSERT INTO t0 VALUES (2) +-- +ok +== +DELETE FROM t0 +-- +ok +== diff --git a/parser/testdata/corpus/fuzzer/pedro/index_insert_from_union.test b/parser/testdata/corpus/fuzzer/pedro/index_insert_from_union.test new file mode 100644 index 0000000..1aa5f93 --- /dev/null +++ b/parser/testdata/corpus/fuzzer/pedro/index_insert_from_union.test @@ -0,0 +1,41 @@ +# source: test/fuzzer/pedro/index_insert_from_union.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +CREATE TABLE t2 (c1 INT, PRIMARY KEY (c1)); +-- +ok +== +INSERT INTO t2 VALUES (2), (2); +-- +ok +== +INSERT INTO t2 SELECT 2 FROM range(10); +-- +ok +== +INSERT INTO t2 SELECT 2 UNION ALL SELECT 2; +-- +ok +== +BEGIN TRANSACTION +-- +ok +== +INSERT INTO t2 SELECT 1 UNION ALL SELECT 2; +-- +ok +== +SELECT * FROM t2 WHERE c1>1 +-- +ok +== +SELECT * FROM t2 WHERE c1<2 +-- +ok +== +COMMIT +-- +ok +== diff --git a/parser/testdata/corpus/fuzzer/pedro/index_not_updated_returning.test b/parser/testdata/corpus/fuzzer/pedro/index_not_updated_returning.test new file mode 100644 index 0000000..d2fffad --- /dev/null +++ b/parser/testdata/corpus/fuzzer/pedro/index_not_updated_returning.test @@ -0,0 +1,17 @@ +# source: test/fuzzer/pedro/index_not_updated_returning.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +CREATE TABLE t2 AS SELECT 1 c1, 1 c2; +-- +ok +== +CREATE INDEX i0 ON t2 (c1); +-- +ok +== +UPDATE t2 SET c2 = 2 RETURNING *; +-- +ok +== diff --git a/parser/testdata/corpus/fuzzer/pedro/index_on_altered_table.test b/parser/testdata/corpus/fuzzer/pedro/index_on_altered_table.test new file mode 100644 index 0000000..1f9e43d --- /dev/null +++ b/parser/testdata/corpus/fuzzer/pedro/index_on_altered_table.test @@ -0,0 +1,9 @@ +# source: test/fuzzer/pedro/index_on_altered_table.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +CHECKPOINT +-- +ok +== diff --git a/parser/testdata/corpus/fuzzer/pedro/insert_or_replace_only_pk.test b/parser/testdata/corpus/fuzzer/pedro/insert_or_replace_only_pk.test new file mode 100644 index 0000000..8d940ea --- /dev/null +++ b/parser/testdata/corpus/fuzzer/pedro/insert_or_replace_only_pk.test @@ -0,0 +1,17 @@ +# source: test/fuzzer/pedro/insert_or_replace_only_pk.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +CREATE TABLE t2 (c1 INT PRIMARY KEY); +-- +ok +== +INSERT OR REPLACE INTO t2 VALUES (1); +-- +ok +== +SELECT * FROM t2 +-- +ok +== diff --git a/parser/testdata/corpus/fuzzer/pedro/intersect_correlated_subquery.test b/parser/testdata/corpus/fuzzer/pedro/intersect_correlated_subquery.test new file mode 100644 index 0000000..68a10f3 --- /dev/null +++ b/parser/testdata/corpus/fuzzer/pedro/intersect_correlated_subquery.test @@ -0,0 +1,21 @@ +# source: test/fuzzer/pedro/intersect_correlated_subquery.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +CREATE TABLE t0 (c1 TINYINT); +-- +ok +== +SELECT (SELECT 1 INTERSECT SELECT 1 HAVING true) FROM t0; +-- +ok +== +SELECT (SELECT 1 INTERSECT SELECT 1 HAVING false) FROM t0; +-- +ok +== +SELECT (SELECT 1 INTERSECT SELECT 1 HAVING t0.rowid) FROM t0; +-- +ok +== diff --git a/parser/testdata/corpus/fuzzer/pedro/intersect_empty_array.test b/parser/testdata/corpus/fuzzer/pedro/intersect_empty_array.test new file mode 100644 index 0000000..246f58d --- /dev/null +++ b/parser/testdata/corpus/fuzzer/pedro/intersect_empty_array.test @@ -0,0 +1,9 @@ +# source: test/fuzzer/pedro/intersect_empty_array.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +SELECT 2 INTERSECT VALUES([]); +-- +ok +== diff --git a/parser/testdata/corpus/fuzzer/pedro/is_distinct_from_validation.test b/parser/testdata/corpus/fuzzer/pedro/is_distinct_from_validation.test new file mode 100644 index 0000000..b591e8c --- /dev/null +++ b/parser/testdata/corpus/fuzzer/pedro/is_distinct_from_validation.test @@ -0,0 +1,13 @@ +# source: test/fuzzer/pedro/is_distinct_from_validation.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +SELECT (0 IS DISTINCT FROM 2) = 0; +-- +ok +== +SELECT CASE 8 WHEN(0 IS DISTINCT FROM 0) THEN 2 END; +-- +ok +== diff --git a/parser/testdata/corpus/fuzzer/pedro/lag_window_function.test b/parser/testdata/corpus/fuzzer/pedro/lag_window_function.test new file mode 100644 index 0000000..525744b --- /dev/null +++ b/parser/testdata/corpus/fuzzer/pedro/lag_window_function.test @@ -0,0 +1,9 @@ +# source: test/fuzzer/pedro/lag_window_function.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +SELECT lag(1) OVER (ORDER BY 0 RANGE BETWEEN CURRENT ROW AND 1 FOLLOWING); +-- +ok +== diff --git a/parser/testdata/corpus/fuzzer/pedro/last_memory_leak.test b/parser/testdata/corpus/fuzzer/pedro/last_memory_leak.test new file mode 100644 index 0000000..5147205 --- /dev/null +++ b/parser/testdata/corpus/fuzzer/pedro/last_memory_leak.test @@ -0,0 +1,17 @@ +# source: test/fuzzer/pedro/last_memory_leak.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +CREATE TABLE t0 (c1 VARCHAR); +-- +ok +== +INSERT INTO t0(c1) VALUES (NULL), ('a'),('-801673450963'); +-- +ok +== +SELECT "last"(c1) FROM t0; +-- +ok +== diff --git a/parser/testdata/corpus/fuzzer/pedro/lateral_join.test b/parser/testdata/corpus/fuzzer/pedro/lateral_join.test new file mode 100644 index 0000000..e17094b --- /dev/null +++ b/parser/testdata/corpus/fuzzer/pedro/lateral_join.test @@ -0,0 +1,17 @@ +# source: test/fuzzer/pedro/lateral_join.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +CREATE TABLE t1 (c1 INT); +-- +ok +== +CREATE INDEX i0 ON t1 (c1); +-- +ok +== +SELECT 1 FROM t1 JOIN (SELECT t1.c1) t0(c0) ON 1 = CAST(72837647112 AS UINTEGER); +-- +ok +== diff --git a/parser/testdata/corpus/fuzzer/pedro/like_empty_list.test b/parser/testdata/corpus/fuzzer/pedro/like_empty_list.test new file mode 100644 index 0000000..a05edd9 --- /dev/null +++ b/parser/testdata/corpus/fuzzer/pedro/like_empty_list.test @@ -0,0 +1,21 @@ +# source: test/fuzzer/pedro/like_empty_list.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +SELECT '1' LIKE []; +-- +ok +== +SELECT [] LIKE 1; +-- +ok +== +SELECT [] LIKE []; +-- +ok +== +SELECT 1 FROM (SELECT 2) t1(c0) NATURAL RIGHT JOIN (SELECT 2) t0(c0) WHERE (0, t1.c0) NOT LIKE '0'; +-- +ok +== diff --git a/parser/testdata/corpus/fuzzer/pedro/limit_on_any_subquery.test b/parser/testdata/corpus/fuzzer/pedro/limit_on_any_subquery.test new file mode 100644 index 0000000..f28b909 --- /dev/null +++ b/parser/testdata/corpus/fuzzer/pedro/limit_on_any_subquery.test @@ -0,0 +1,17 @@ +# source: test/fuzzer/pedro/limit_on_any_subquery.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +SELECT 1 WHERE 1 < ANY(SELECT 2 LIMIT 0%); +-- +ok +== +CREATE TABLE test (x INT); +-- +ok +== +SELECT 1 WHERE 1 < ANY(SELECT 2 FROM test); +-- +ok +== diff --git a/parser/testdata/corpus/fuzzer/pedro/local_transaction_delete_empty_tree.test b/parser/testdata/corpus/fuzzer/pedro/local_transaction_delete_empty_tree.test new file mode 100644 index 0000000..3808e53 --- /dev/null +++ b/parser/testdata/corpus/fuzzer/pedro/local_transaction_delete_empty_tree.test @@ -0,0 +1,9 @@ +# source: test/fuzzer/pedro/local_transaction_delete_empty_tree.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +DELETE FROM t1 RETURNING 1; +-- +ok +== diff --git a/parser/testdata/corpus/fuzzer/pedro/logical_column_index_out_of_range.test b/parser/testdata/corpus/fuzzer/pedro/logical_column_index_out_of_range.test new file mode 100644 index 0000000..cc5e43f --- /dev/null +++ b/parser/testdata/corpus/fuzzer/pedro/logical_column_index_out_of_range.test @@ -0,0 +1,21 @@ +# source: test/fuzzer/pedro/logical_column_index_out_of_range.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +CREATE TABLE t1(c0 INT, c2 INT); +-- +ok +== +SELECT 1 FROM t1 t2(c1) NATURAL RIGHT JOIN t0, t2 t1(c0) WHERE t2.c2 >= c0; +-- +ok +== +SELECT 1 FROM t1 t2(c1) NATURAL LEFT JOIN t0, t2 t1(c0) WHERE t2.c2 >= c0; +-- +ok +== +SELECT 1 FROM t1 t2(c1) NATURAL INNER JOIN t0, t2 t1(c0) WHERE t2.c2 >= c0; +-- +ok +== diff --git a/parser/testdata/corpus/fuzzer/pedro/missing_subquery_error.test b/parser/testdata/corpus/fuzzer/pedro/missing_subquery_error.test new file mode 100644 index 0000000..161bbc1 --- /dev/null +++ b/parser/testdata/corpus/fuzzer/pedro/missing_subquery_error.test @@ -0,0 +1,17 @@ +# source: test/fuzzer/pedro/missing_subquery_error.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +WITH t2 AS (SELECT 3 WHERE count(*) FILTER (1)) SELECT 0 FROM t2 +-- +ok +== +SELECT (WITH t2 AS (SELECT 3 WHERE count(*)) SELECT 0 FROM t2); +-- +ok +== +SELECT (WITH t2 AS (SELECT 3 WHERE count(*) FILTER (1)) SELECT 0 FROM t2); +-- +ok +== diff --git a/parser/testdata/corpus/fuzzer/pedro/multiplication_verification.test b/parser/testdata/corpus/fuzzer/pedro/multiplication_verification.test new file mode 100644 index 0000000..433c8a8 --- /dev/null +++ b/parser/testdata/corpus/fuzzer/pedro/multiplication_verification.test @@ -0,0 +1,13 @@ +# source: test/fuzzer/pedro/multiplication_verification.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +SELECT 1 * (1 < 1); +-- +ok +== +SELECT 2 * (1 << 2); +-- +ok +== diff --git a/parser/testdata/corpus/fuzzer/pedro/nan_as_seed.test b/parser/testdata/corpus/fuzzer/pedro/nan_as_seed.test new file mode 100644 index 0000000..9b77acb --- /dev/null +++ b/parser/testdata/corpus/fuzzer/pedro/nan_as_seed.test @@ -0,0 +1,25 @@ +# source: test/fuzzer/pedro/nan_as_seed.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +create table test as select range i from range(10000) +-- +ok +== +SELECT setseed('{val}'::{type}); +-- +error: Parser Error: syntax error at or near "{" +== +SELECT setseed(0.5); +-- +ok +== +SELECT 1, random(); +-- +ok +== +select * from test using sample 100; +-- +ok +== diff --git a/parser/testdata/corpus/fuzzer/pedro/natural_join_generated_heap_overflow.test b/parser/testdata/corpus/fuzzer/pedro/natural_join_generated_heap_overflow.test new file mode 100644 index 0000000..e0303ec --- /dev/null +++ b/parser/testdata/corpus/fuzzer/pedro/natural_join_generated_heap_overflow.test @@ -0,0 +1,21 @@ +# source: test/fuzzer/pedro/natural_join_generated_heap_overflow.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +CREATE TABLE t0 (c1 AS (1), c0 INT); +-- +ok +== +SELECT 1 FROM t0 JOIN (SELECT 8) t1(c0) USING (c0); +-- +ok +== +SELECT 1 FROM t0 NATURAL INNER JOIN (SELECT 8) t1(c0); +-- +ok +== +INSERT INTO t0 VALUES (8) +-- +ok +== diff --git a/parser/testdata/corpus/fuzzer/pedro/nested_limit_subquery.test b/parser/testdata/corpus/fuzzer/pedro/nested_limit_subquery.test new file mode 100644 index 0000000..be7717f --- /dev/null +++ b/parser/testdata/corpus/fuzzer/pedro/nested_limit_subquery.test @@ -0,0 +1,25 @@ +# source: test/fuzzer/pedro/nested_limit_subquery.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +SELECT 1 FROM (SELECT 1) t0(c0) WHERE (SELECT c0); +-- +ok +== +SELECT 1 FROM (SELECT 1) t0(c0) WHERE (SELECT (SELECT c0)); +-- +ok +== +SELECT 1 FROM (SELECT 1) t0(c0) WHERE (SELECT (SELECT 1 ORDER BY c0)); +-- +ok +== +SELECT 1 FROM (SELECT 1) t0(c0) WHERE (SELECT 1 LIMIT c0); +-- +ok +== +SELECT 1 FROM (SELECT 1) t0(c0) WHERE (SELECT (SELECT 1 LIMIT c0)); +-- +ok +== diff --git a/parser/testdata/corpus/fuzzer/pedro/nested_subquery_table_function.test b/parser/testdata/corpus/fuzzer/pedro/nested_subquery_table_function.test new file mode 100644 index 0000000..86908c5 --- /dev/null +++ b/parser/testdata/corpus/fuzzer/pedro/nested_subquery_table_function.test @@ -0,0 +1,17 @@ +# source: test/fuzzer/pedro/nested_subquery_table_function.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +SELECT 1 FROM range((SELECT 1) - 0); +-- +ok +== +SELECT (SELECT 1 FROM range((SELECT 1) - 0)); +-- +ok +== +FROM range((SELECT 3) - 1) +-- +ok +== diff --git a/parser/testdata/corpus/fuzzer/pedro/non_boolean_aggregate_filter.test b/parser/testdata/corpus/fuzzer/pedro/non_boolean_aggregate_filter.test new file mode 100644 index 0000000..1e3f067 --- /dev/null +++ b/parser/testdata/corpus/fuzzer/pedro/non_boolean_aggregate_filter.test @@ -0,0 +1,13 @@ +# source: test/fuzzer/pedro/non_boolean_aggregate_filter.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +SELECT mode(1) FILTER (0); +-- +ok +== +SELECT SUM(i), SUM(i) FILTER (i%2) FROM range(10) tbl(i); +-- +ok +== diff --git a/parser/testdata/corpus/fuzzer/pedro/offset_query_allocator_assertion.test b/parser/testdata/corpus/fuzzer/pedro/offset_query_allocator_assertion.test new file mode 100644 index 0000000..028fea4 --- /dev/null +++ b/parser/testdata/corpus/fuzzer/pedro/offset_query_allocator_assertion.test @@ -0,0 +1,9 @@ +# source: test/fuzzer/pedro/offset_query_allocator_assertion.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +SELECT c0 FROM t0 OFFSET 42949672960; +-- +ok +== diff --git a/parser/testdata/corpus/fuzzer/pedro/order_by_all_with_union.test b/parser/testdata/corpus/fuzzer/pedro/order_by_all_with_union.test new file mode 100644 index 0000000..e576472 --- /dev/null +++ b/parser/testdata/corpus/fuzzer/pedro/order_by_all_with_union.test @@ -0,0 +1,9 @@ +# source: test/fuzzer/pedro/order_by_all_with_union.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +(SELECT 2 ORDER BY(SELECT 2)) UNION SELECT 1 ORDER BY ALL; +-- +ok +== diff --git a/parser/testdata/corpus/fuzzer/pedro/overflow_parsing_interval.test b/parser/testdata/corpus/fuzzer/pedro/overflow_parsing_interval.test new file mode 100644 index 0000000..ce7d8de --- /dev/null +++ b/parser/testdata/corpus/fuzzer/pedro/overflow_parsing_interval.test @@ -0,0 +1,21 @@ +# source: test/fuzzer/pedro/overflow_parsing_interval.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +SELECT INTERVAL '-9223372036854775808' MICROSECONDS; +-- +ok +== +SELECT INTERVAL '-9223372036854775807' MICROSECONDS; +-- +ok +== +SELECT INTERVAL '9223372036854775296' MICROSECONDS; +-- +ok +== +SELECT INTERVAL '9223372036854775295' MICROSECONDS; +-- +ok +== diff --git a/parser/testdata/corpus/fuzzer/pedro/overflow_varchar_decimal_cast.test b/parser/testdata/corpus/fuzzer/pedro/overflow_varchar_decimal_cast.test new file mode 100644 index 0000000..19c1e96 --- /dev/null +++ b/parser/testdata/corpus/fuzzer/pedro/overflow_varchar_decimal_cast.test @@ -0,0 +1,21 @@ +# source: test/fuzzer/pedro/overflow_varchar_decimal_cast.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +SELECT CAST(strftime(TIMESTAMP '1-1-1 0:00:00',340282346638528859811704183484516925440.0) AS DECIMAL(10,2)); +-- +ok +== +SELECT '552.123242346e+11'::DECIMAL; +-- +ok +== +SELECT '-3.4028234663852886e+16'::DECIMAL(30); +-- +ok +== +SELECT '-3.4028234663852886e+38'::DECIMAL; +-- +ok +== diff --git a/parser/testdata/corpus/fuzzer/pedro/parser_roundtrip.test b/parser/testdata/corpus/fuzzer/pedro/parser_roundtrip.test new file mode 100644 index 0000000..a5df898 --- /dev/null +++ b/parser/testdata/corpus/fuzzer/pedro/parser_roundtrip.test @@ -0,0 +1,29 @@ +# source: test/fuzzer/pedro/parser_roundtrip.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +SELECT BLOB '\x27' +-- +ok +== +SELECT "/"(42, 84); +-- +ok +== +SELECT "x-x"."y-y" FROM (SELECT 42) AS "x-x"("y-y"); +-- +ok +== +SELECT 1 FROM ((SELECT 2) t0(c0) JOIN (SELECT 3) t1(c0) ON TRUE), ((SELECT 4) t2(c0) JOIN ((SELECT 5) t3(c0) CROSS JOIN (SELECT 6) t4(c0)) ON TRUE); +-- +ok +== +SELECT CAST('1' COLLATE "nocase" AS INT); +-- +ok +== +INSERT INTO t0 VALUES (42); +-- +ok +== diff --git a/parser/testdata/corpus/fuzzer/pedro/prepared_statement_recursive_cte.test b/parser/testdata/corpus/fuzzer/pedro/prepared_statement_recursive_cte.test new file mode 100644 index 0000000..d60fea7 --- /dev/null +++ b/parser/testdata/corpus/fuzzer/pedro/prepared_statement_recursive_cte.test @@ -0,0 +1,13 @@ +# source: test/fuzzer/pedro/prepared_statement_recursive_cte.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +PREPARE p0 AS WITH RECURSIVE t1(c2) AS ((SELECT 1) UNION DISTINCT (SELECT (c2 + 1) FROM t1 WHERE (c2 < 3))) SELECT * FROM t1 ORDER BY c2 NULLS LAST; +-- +ok +== +EXECUTE p0; +-- +ok +== diff --git a/parser/testdata/corpus/fuzzer/pedro/pushdown_assertion_error.test b/parser/testdata/corpus/fuzzer/pedro/pushdown_assertion_error.test new file mode 100644 index 0000000..6cdccf2 --- /dev/null +++ b/parser/testdata/corpus/fuzzer/pedro/pushdown_assertion_error.test @@ -0,0 +1,21 @@ +# source: test/fuzzer/pedro/pushdown_assertion_error.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +CREATE TABLE t2 (c2 INT); +-- +ok +== +CREATE SEQUENCE t0; +-- +ok +== +SELECT 1 FROM t2 WHERE currval('t0') BETWEEN TRY_CAST(0 AS TIMESTAMP WITH TIME ZONE) AND 1; +-- +ok +== +SELECT 1 FROM t2 WHERE currval('t0') BETWEEN TRY_CAST(0 AS TIMESTAMP WITH TIME ZONE) AND -156587962151166338620429995158284936977; +-- +ok +== diff --git a/parser/testdata/corpus/fuzzer/pedro/pushdown_error.test b/parser/testdata/corpus/fuzzer/pedro/pushdown_error.test new file mode 100644 index 0000000..23cbacc --- /dev/null +++ b/parser/testdata/corpus/fuzzer/pedro/pushdown_error.test @@ -0,0 +1,33 @@ +# source: test/fuzzer/pedro/pushdown_error.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +CREATE TABLE t2(c1 INT); +-- +ok +== +CREATE INDEX i0 ON t2(c1); +-- +ok +== +SET wal_autocheckpoint='1TB'; +-- +ok +== +PRAGMA disable_checkpoint_on_shutdown; +-- +ok +== +DROP INDEX i0; +-- +ok +== +ALTER TABLE t2 ALTER c1 SET DEFAULT 0; +-- +ok +== +SELECT * FROM t2; +-- +ok +== diff --git a/parser/testdata/corpus/fuzzer/pedro/pushdown_simplification_overflow.test b/parser/testdata/corpus/fuzzer/pedro/pushdown_simplification_overflow.test new file mode 100644 index 0000000..22a591a --- /dev/null +++ b/parser/testdata/corpus/fuzzer/pedro/pushdown_simplification_overflow.test @@ -0,0 +1,21 @@ +# source: test/fuzzer/pedro/pushdown_simplification_overflow.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +INSERT INTO t1(c0) VALUES (1),(2),(3); +-- +ok +== +SELECT 1 FROM t1 WHERE -9223372036854775808 >= (6892203265207104503 - (-7595956987701092486)); +-- +ok +== +SELECT 1 FROM t1 WHERE NOT (-9223372036854775808 >= (6892203265207104503 - (-7595956987701092486))); +-- +ok +== +SELECT 1 FROM t1 WHERE (-9223372036854775808 >= (6892203265207104503 - (-7595956987701092486))) IS NULL; +-- +ok +== diff --git a/parser/testdata/corpus/fuzzer/pedro/qualify_binder_error.test b/parser/testdata/corpus/fuzzer/pedro/qualify_binder_error.test new file mode 100644 index 0000000..552dcfe --- /dev/null +++ b/parser/testdata/corpus/fuzzer/pedro/qualify_binder_error.test @@ -0,0 +1,29 @@ +# source: test/fuzzer/pedro/qualify_binder_error.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +SELECT c0, count(c0) over () AS count_window FROM (SELECT 1) t0(c0) GROUP BY c0 QUALIFY count_window; +-- +ok +== +SELECT * FROM (SELECT 1) t0(c0) GROUP BY c0 QUALIFY count(c0) OVER (); +-- +ok +== +SELECT * FROM (SELECT 1) t0(c0) GROUP BY ALL QUALIFY count(c0) OVER (); +-- +ok +== +SELECT 1 FROM (SELECT 2) t0(c0) QUALIFY (c0, dense_rank() OVER(), mode(0)); +-- +ok +== +SELECT 1 FROM (SELECT 2) t0(c0) QUALIFY (count(sum(42)) OVER()); +-- +ok +== +SELECT 1 FROM (SELECT 2) t0(c0) QUALIFY (count(sum(c0)) OVER()); +-- +ok +== diff --git a/parser/testdata/corpus/fuzzer/pedro/random_engine_use_after_free.test b/parser/testdata/corpus/fuzzer/pedro/random_engine_use_after_free.test new file mode 100644 index 0000000..8e5a67c --- /dev/null +++ b/parser/testdata/corpus/fuzzer/pedro/random_engine_use_after_free.test @@ -0,0 +1,13 @@ +# source: test/fuzzer/pedro/random_engine_use_after_free.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +CREATE TABLE t1 (c0 INT CHECK (current_schema()='main')); +-- +ok +== +INSERT INTO t1 VALUES(0); +-- +ok +== diff --git a/parser/testdata/corpus/fuzzer/pedro/recursive_cte_dependent_join.test b/parser/testdata/corpus/fuzzer/pedro/recursive_cte_dependent_join.test new file mode 100644 index 0000000..2747aa2 --- /dev/null +++ b/parser/testdata/corpus/fuzzer/pedro/recursive_cte_dependent_join.test @@ -0,0 +1,9 @@ +# source: test/fuzzer/pedro/recursive_cte_dependent_join.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +SELECT (WITH RECURSIVE t1 AS (SELECT 1 UNION SELECT 1 FROM t1 WHERE c2 < 3) SELECT 2 FROM t1) FROM (SELECT 1 c2) t1; +-- +ok +== diff --git a/parser/testdata/corpus/fuzzer/pedro/recursive_cte_limit_percent.test b/parser/testdata/corpus/fuzzer/pedro/recursive_cte_limit_percent.test new file mode 100644 index 0000000..508bde8 --- /dev/null +++ b/parser/testdata/corpus/fuzzer/pedro/recursive_cte_limit_percent.test @@ -0,0 +1,13 @@ +# source: test/fuzzer/pedro/recursive_cte_limit_percent.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +WITH RECURSIVE t1(c0) AS ((SELECT 1, 1 c1) UNION (SELECT 1, 1 FROM (SELECT 1) x(x) JOIN t1 ON FALSE LIMIT 1%)) SELECT 1 FROM t1 JOIN t1 t0 USING (c1); +-- +ok +== +WITH RECURSIVE t1(c0) AS ((SELECT 1, 1 c1) UNION (SELECT 1, 1 FROM (SELECT 1) x(x) JOIN t1 ON FALSE LIMIT 1)) SELECT 1 FROM t1 JOIN t1 t0 USING (c1); +-- +ok +== diff --git a/parser/testdata/corpus/fuzzer/pedro/regr_count_validity.test b/parser/testdata/corpus/fuzzer/pedro/regr_count_validity.test new file mode 100644 index 0000000..0f2d1ba --- /dev/null +++ b/parser/testdata/corpus/fuzzer/pedro/regr_count_validity.test @@ -0,0 +1,9 @@ +# source: test/fuzzer/pedro/regr_count_validity.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +SELECT regr_count(1,1) FROM t0; +-- +ok +== diff --git a/parser/testdata/corpus/fuzzer/pedro/rename_column_assertion.test b/parser/testdata/corpus/fuzzer/pedro/rename_column_assertion.test new file mode 100644 index 0000000..80f85c3 --- /dev/null +++ b/parser/testdata/corpus/fuzzer/pedro/rename_column_assertion.test @@ -0,0 +1,21 @@ +# source: test/fuzzer/pedro/rename_column_assertion.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +CREATE TABLE t1 (c1 INT, c2 INT); +-- +ok +== +CREATE INDEX i0 ON t1 (c2); +-- +ok +== +ALTER TABLE t1 ALTER c2 DROP NOT NULL; +-- +ok +== +ALTER TABLE t1 RENAME c1 TO c3; +-- +ok +== diff --git a/parser/testdata/corpus/fuzzer/pedro/rename_restart.test b/parser/testdata/corpus/fuzzer/pedro/rename_restart.test new file mode 100644 index 0000000..83a001d --- /dev/null +++ b/parser/testdata/corpus/fuzzer/pedro/rename_restart.test @@ -0,0 +1,25 @@ +# source: test/fuzzer/pedro/rename_restart.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +SET wal_autocheckpoint='10MB'; +-- +ok +== +CREATE VIEW t1 AS SELECT 1 c0; +-- +ok +== +CREATE INDEX i1 ON t0(c0); +-- +ok +== +ALTER TABLE t0 RENAME TO t1; +-- +ok +== +select 42 +-- +ok +== diff --git a/parser/testdata/corpus/fuzzer/pedro/rename_table_index_rollback.test b/parser/testdata/corpus/fuzzer/pedro/rename_table_index_rollback.test new file mode 100644 index 0000000..2e89431 --- /dev/null +++ b/parser/testdata/corpus/fuzzer/pedro/rename_table_index_rollback.test @@ -0,0 +1,9 @@ +# source: test/fuzzer/pedro/rename_table_index_rollback.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +CREATE OR REPLACE VIEW t1 AS (SELECT 1); +-- +ok +== diff --git a/parser/testdata/corpus/fuzzer/pedro/rename_table_index_storage.test b/parser/testdata/corpus/fuzzer/pedro/rename_table_index_storage.test new file mode 100644 index 0000000..9ae4dcf --- /dev/null +++ b/parser/testdata/corpus/fuzzer/pedro/rename_table_index_storage.test @@ -0,0 +1,13 @@ +# source: test/fuzzer/pedro/rename_table_index_storage.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +CREATE INDEX i0 ON t1 (c0); +-- +ok +== +CREATE OR REPLACE VIEW t0 AS (SELECT 1); +-- +ok +== diff --git a/parser/testdata/corpus/fuzzer/pedro/restart_current_time.test b/parser/testdata/corpus/fuzzer/pedro/restart_current_time.test new file mode 100644 index 0000000..51e441a --- /dev/null +++ b/parser/testdata/corpus/fuzzer/pedro/restart_current_time.test @@ -0,0 +1,9 @@ +# source: test/fuzzer/pedro/restart_current_time.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +CREATE TABLE t0 (c1 INT, CHECK (CURRENT_TIME >= TIME '00:00:00')); +-- +ok +== diff --git a/parser/testdata/corpus/fuzzer/pedro/restart_random.test b/parser/testdata/corpus/fuzzer/pedro/restart_random.test new file mode 100644 index 0000000..7513c25 --- /dev/null +++ b/parser/testdata/corpus/fuzzer/pedro/restart_random.test @@ -0,0 +1,13 @@ +# source: test/fuzzer/pedro/restart_random.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +CREATE TABLE t0 (c1 INT, CHECK (RANDOM() >= 0)); +-- +ok +== +INSERT INTO t0(c1) VALUES (0); +-- +ok +== diff --git a/parser/testdata/corpus/fuzzer/pedro/returning_clause_sizes_not_match.test b/parser/testdata/corpus/fuzzer/pedro/returning_clause_sizes_not_match.test new file mode 100644 index 0000000..5718125 --- /dev/null +++ b/parser/testdata/corpus/fuzzer/pedro/returning_clause_sizes_not_match.test @@ -0,0 +1,61 @@ +# source: test/fuzzer/pedro/returning_clause_sizes_not_match.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +CREATE TABLE test (x INT, y AS(x + 100)); +-- +ok +== +INSERT INTO test VALUES (1), (2) RETURNING *; +-- +ok +== +SELECT test FROM test +-- +ok +== +INSERT INTO test VALUES (1), (2) RETURNING *, *; +-- +ok +== +DELETE FROM test WHERE x=2 RETURNING *; +-- +ok +== +UPDATE test SET x=0 WHERE x = 1 RETURNING *; +-- +ok +== +INSERT INTO test VALUES(1) RETURNING y.y; +-- +ok +== +INSERT INTO test VALUES(1) RETURNING y.*; +-- +ok +== +INSERT INTO test VALUES(1) RETURNING test; +-- +ok +== +INSERT INTO test VALUES(1) RETURNING test.y; +-- +ok +== +INSERT INTO test VALUES(1) RETURNING {'i' : x, 'j' : y}; +-- +ok +== +INSERT INTO test VALUES (1), (2) RETURNING y; +-- +ok +== +INSERT INTO test VALUES (1), (2) RETURNING y, y, y, x; +-- +ok +== +INSERT INTO test VALUES (1), (2) RETURNING y + y, x + y; +-- +ok +== diff --git a/parser/testdata/corpus/fuzzer/pedro/returning_clause_with_rowid.test b/parser/testdata/corpus/fuzzer/pedro/returning_clause_with_rowid.test new file mode 100644 index 0000000..e8594a9 --- /dev/null +++ b/parser/testdata/corpus/fuzzer/pedro/returning_clause_with_rowid.test @@ -0,0 +1,53 @@ +# source: test/fuzzer/pedro/returning_clause_with_rowid.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +INSERT INTO t0 VALUES (1) RETURNING c0, rowid; +-- +ok +== +INSERT INTO t0 VALUES (1), (2), (3) RETURNING *, rowid; +-- +ok +== +INSERT INTO t0 VALUES (4) RETURNING c0 + rowid; +-- +ok +== +INSERT INTO t0 VALUES (1) RETURNING rowid c2; +-- +ok +== +UPDATE t0 SET c0 = 5 WHERE c0 = 0 RETURNING rowid; +-- +ok +== +INSERT INTO t0 VALUES (0); +-- +ok +== +DELETE FROM t0 WHERE c0 = 0 RETURNING rowid; +-- +ok +== +INSERT INTO t0 VALUES (1) RETURNING c0 as rowid; +-- +ok +== +INSERT INTO t0 VALUES (1) RETURNING sum(c0) as rowid; +-- +ok +== +select struct_pack(row_id := 42); +-- +ok +== +CREATE TABLE t1 (c1 AS ('abc'), c2 INT); +-- +ok +== +INSERT INTO t1 SELECT 1 RETURNING rowid c1; +-- +ok +== diff --git a/parser/testdata/corpus/fuzzer/pedro/rollup_wrong_result.test b/parser/testdata/corpus/fuzzer/pedro/rollup_wrong_result.test new file mode 100644 index 0000000..6e7e1f9 --- /dev/null +++ b/parser/testdata/corpus/fuzzer/pedro/rollup_wrong_result.test @@ -0,0 +1,33 @@ +# source: test/fuzzer/pedro/rollup_wrong_result.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +SET default_null_order='nulls_first'; +-- +ok +== +INSERT INTO t1(c1) VALUES (24),(-100); +-- +ok +== +SELECT 1 FROM t1 GROUP BY 1, ROLLUP (c1); +-- +ok +== +SELECT c1 FROM t1 GROUP BY 'hello', ROLLUP (c1) ORDER BY 1; +-- +ok +== +SELECT 1 FROM t1 GROUP BY 1, ROLLUP (c1) HAVING (c1 > 1); +-- +ok +== +SELECT 1 FROM t1 GROUP BY 1, ROLLUP (c1) HAVING (NOT (c1 > 1)); +-- +ok +== +SELECT 1 FROM t1 GROUP BY 1, ROLLUP (c1) HAVING ((c1 > 1) IS NULL); +-- +ok +== diff --git a/parser/testdata/corpus/fuzzer/pedro/sample_limit_overflow.test b/parser/testdata/corpus/fuzzer/pedro/sample_limit_overflow.test new file mode 100644 index 0000000..52687d2 --- /dev/null +++ b/parser/testdata/corpus/fuzzer/pedro/sample_limit_overflow.test @@ -0,0 +1,9 @@ +# source: test/fuzzer/pedro/sample_limit_overflow.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +SELECT 1 FROM (SELECT 1 ORDER BY ALL LIMIT 514322393620248226) USING SAMPLE SYSTEM (36%); +-- +ok +== diff --git a/parser/testdata/corpus/fuzzer/pedro/segment_tree_index_issue.test b/parser/testdata/corpus/fuzzer/pedro/segment_tree_index_issue.test new file mode 100644 index 0000000..d97d80e --- /dev/null +++ b/parser/testdata/corpus/fuzzer/pedro/segment_tree_index_issue.test @@ -0,0 +1,25 @@ +# source: test/fuzzer/pedro/segment_tree_index_issue.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +CREATE TABLE t0 (c1 INT); +-- +ok +== +INSERT INTO t0 VALUES (1); +-- +ok +== +DELETE FROM t0 USING (SELECT 1) t1; +-- +ok +== +CREATE TABLE t0 (c1 INT PRIMARY KEY); +-- +ok +== +CREATE TABLE fk_integers(id INTEGER REFERENCES t0(c1)) +-- +ok +== diff --git a/parser/testdata/corpus/fuzzer/pedro/setop_type_mismatch.test b/parser/testdata/corpus/fuzzer/pedro/setop_type_mismatch.test new file mode 100644 index 0000000..c260da1 --- /dev/null +++ b/parser/testdata/corpus/fuzzer/pedro/setop_type_mismatch.test @@ -0,0 +1,53 @@ +# source: test/fuzzer/pedro/setop_type_mismatch.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +SELECT '\x1E' FROM (SELECT 1) t1(c0) ORDER BY ALL OFFSET (SELECT DISTINCT 6.5 FROM (SELECT 1) t1(c0) UNION ALL SELECT 3); +-- +ok +== +SET scalar_subquery_error_on_multiple_rows=false +-- +ok +== +CREATE TABLE t1 (c0 BOOLEAN, c1 BIGINT); +-- +ok +== +INSERT INTO t1 (c1) VALUES (1); +-- +ok +== +SELECT ((SELECT 0) UNION (SELECT t1.c0) OFFSET 2) FROM t1; +-- +ok +== +SELECT ((SELECT 0) UNION (SELECT t1.c0) ORDER BY 1 NULLS FIRST OFFSET 1) FROM t1; +-- +ok +== +SELECT ((SELECT 0) UNION (SELECT t1.c0) ORDER BY 1 NULLS LAST OFFSET 1) FROM t1; +-- +ok +== +CREATE TABLE t2 (c0 DECIMAL); +-- +ok +== +SELECT (SELECT 0 WHERE CAST(c0 AS VARCHAR) LIKE '1' INTERSECT (SELECT 1)) FROM t2; +-- +ok +== +CREATE TABLE t3 (c1 INT); +-- +ok +== +CREATE TABLE t4 (c0 BOOLEAN, c1 INT); +-- +ok +== +SELECT 1 FROM t4 JOIN t3 ON 0 WHERE EXISTS (SELECT 1 INTERSECT SELECT 1 FROM t4 JOIN t3 t0(c1) ON 0 WHERE NOT c0); +-- +ok +== diff --git a/parser/testdata/corpus/fuzzer/pedro/signed_and_unsigned_comparison.test b/parser/testdata/corpus/fuzzer/pedro/signed_and_unsigned_comparison.test new file mode 100644 index 0000000..a978ae8 --- /dev/null +++ b/parser/testdata/corpus/fuzzer/pedro/signed_and_unsigned_comparison.test @@ -0,0 +1,20 @@ +# source: test/fuzzer/pedro/signed_and_unsigned_comparison.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +CREATE TABLE t1 ( + c1 UINT32, + c2 INT32 +); +-- +ok +== +INSERT INTO t1 VALUES (0,0); +-- +ok +== +SELECT 1 FROM t1 WHERE t1.c2 = t1.c1 AND t1.c2 < t1.c1; +-- +ok +== diff --git a/parser/testdata/corpus/fuzzer/pedro/statistics_propagation_set_op.test b/parser/testdata/corpus/fuzzer/pedro/statistics_propagation_set_op.test new file mode 100644 index 0000000..3f9deea --- /dev/null +++ b/parser/testdata/corpus/fuzzer/pedro/statistics_propagation_set_op.test @@ -0,0 +1,9 @@ +# source: test/fuzzer/pedro/statistics_propagation_set_op.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +SELECT 1 FROM (SELECT 1) t0(c0) WHERE ((VALUES(1), (c0) LIMIT 1) INTERSECT (SELECT 1)); +-- +ok +== diff --git a/parser/testdata/corpus/fuzzer/pedro/strftime_constant_null.test b/parser/testdata/corpus/fuzzer/pedro/strftime_constant_null.test new file mode 100644 index 0000000..58eb8bb --- /dev/null +++ b/parser/testdata/corpus/fuzzer/pedro/strftime_constant_null.test @@ -0,0 +1,21 @@ +# source: test/fuzzer/pedro/strftime_constant_null.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +CREATE TABLE t0 (c1 TIMESTAMP); +-- +ok +== +INSERT INTO t0 VALUES (TIMESTAMP '91288-5-25 0:5:30'),(TIMESTAMP '253915-8-21 3:7:0'); +-- +ok +== +PRAGMA DISABLE_OPTIMIZER; +-- +ok +== +SELECT strftime(TIMESTAMP '2608-11-25 3:4:35',coalesce('a', 'b')) FROM t0; +-- +ok +== diff --git a/parser/testdata/corpus/fuzzer/pedro/strptime_null_argument.test b/parser/testdata/corpus/fuzzer/pedro/strptime_null_argument.test new file mode 100644 index 0000000..b0f1763 --- /dev/null +++ b/parser/testdata/corpus/fuzzer/pedro/strptime_null_argument.test @@ -0,0 +1,9 @@ +# source: test/fuzzer/pedro/strptime_null_argument.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +SELECT strptime(NULL,'p') IS DISTINCT FROM DATE '-543572-1-1'; +-- +ok +== diff --git a/parser/testdata/corpus/fuzzer/pedro/subquery_assertion_error.test b/parser/testdata/corpus/fuzzer/pedro/subquery_assertion_error.test new file mode 100644 index 0000000..edbd418 --- /dev/null +++ b/parser/testdata/corpus/fuzzer/pedro/subquery_assertion_error.test @@ -0,0 +1,9 @@ +# source: test/fuzzer/pedro/subquery_assertion_error.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +SELECT (VALUES(1 != ALL(SELECT 2))); +-- +ok +== diff --git a/parser/testdata/corpus/fuzzer/pedro/temp_sequence_durability.test b/parser/testdata/corpus/fuzzer/pedro/temp_sequence_durability.test new file mode 100644 index 0000000..9f164e9 --- /dev/null +++ b/parser/testdata/corpus/fuzzer/pedro/temp_sequence_durability.test @@ -0,0 +1,17 @@ +# source: test/fuzzer/pedro/temp_sequence_durability.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +PRAGMA DISABLE_CHECKPOINT_ON_SHUTDOWN; +-- +ok +== +CREATE TEMP SEQUENCE s0; +-- +ok +== +SELECT nextval('s0'); +-- +ok +== diff --git a/parser/testdata/corpus/fuzzer/pedro/temp_sequence_reconnect.test b/parser/testdata/corpus/fuzzer/pedro/temp_sequence_reconnect.test new file mode 100644 index 0000000..73ec287 --- /dev/null +++ b/parser/testdata/corpus/fuzzer/pedro/temp_sequence_reconnect.test @@ -0,0 +1,28 @@ +# source: test/fuzzer/pedro/temp_sequence_reconnect.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +CREATE SEQUENCE t1; +-- +ok +== +CREATE TABLE t1 ( + c1 INT, + CHECK(nextval('t1')) +); +-- +ok +== +CREATE TEMP SEQUENCE t1; +-- +ok +== +DROP SEQUENCE temp.t1 +-- +ok +== +INSERT INTO t1 VALUES (1,1); +-- +ok +== diff --git a/parser/testdata/corpus/fuzzer/pedro/temp_table_cleanup.test b/parser/testdata/corpus/fuzzer/pedro/temp_table_cleanup.test new file mode 100644 index 0000000..3c7eafe --- /dev/null +++ b/parser/testdata/corpus/fuzzer/pedro/temp_table_cleanup.test @@ -0,0 +1,17 @@ +# source: test/fuzzer/pedro/temp_table_cleanup.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +CREATE TEMP TABLE t2 AS (SELECT 1); +-- +ok +== +INSERT INTO t2 VALUES (42); +-- +ok +== +DELETE FROM t2 +-- +ok +== diff --git a/parser/testdata/corpus/fuzzer/pedro/test_segv_argmax.test b/parser/testdata/corpus/fuzzer/pedro/test_segv_argmax.test new file mode 100644 index 0000000..53a36d1 --- /dev/null +++ b/parser/testdata/corpus/fuzzer/pedro/test_segv_argmax.test @@ -0,0 +1,28 @@ +# source: test/fuzzer/pedro/test_segv_argmax.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +CREATE TABLE t1 ( + c0 VARCHAR, + c1 TINYINT +); +-- +ok +== +INSERT INTO t1(c0,c1) VALUES ('test1',43); +-- +ok +== +delete from t1; +-- +ok +== +INSERT INTO t1(c0,c1) VALUES ('test2',52); +-- +ok +== +SELECT argmax(c1,c0) FROM t1 group by c0; +-- +ok +== diff --git a/parser/testdata/corpus/fuzzer/pedro/test_truncate_heap_use_after_free.test b/parser/testdata/corpus/fuzzer/pedro/test_truncate_heap_use_after_free.test new file mode 100644 index 0000000..df2c320 --- /dev/null +++ b/parser/testdata/corpus/fuzzer/pedro/test_truncate_heap_use_after_free.test @@ -0,0 +1,17 @@ +# source: test/fuzzer/pedro/test_truncate_heap_use_after_free.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +INSERT INTO t2 VALUES (1),(0); +-- +ok +== +UPDATE t2 SET c2 = DEFAULT; +-- +ok +== +TRUNCATE t2; +-- +ok +== diff --git a/parser/testdata/corpus/fuzzer/pedro/test_window_function_nullptr.test b/parser/testdata/corpus/fuzzer/pedro/test_window_function_nullptr.test new file mode 100644 index 0000000..ccbd831 --- /dev/null +++ b/parser/testdata/corpus/fuzzer/pedro/test_window_function_nullptr.test @@ -0,0 +1,17 @@ +# source: test/fuzzer/pedro/test_window_function_nullptr.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +PRAGMA DEBUG_WINDOW_MODE='separate'; +-- +ok +== +INSERT INTO t1(c1) VALUES (1); +-- +ok +== +SELECT count(*) OVER () FROM t1; +-- +ok +== diff --git a/parser/testdata/corpus/fuzzer/pedro/update_default_segv.test b/parser/testdata/corpus/fuzzer/pedro/update_default_segv.test new file mode 100644 index 0000000..438637b --- /dev/null +++ b/parser/testdata/corpus/fuzzer/pedro/update_default_segv.test @@ -0,0 +1,21 @@ +# source: test/fuzzer/pedro/update_default_segv.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +CREATE TABLE t0(c0 VARCHAR, c2 AS(1), c3 INT, UNIQUE(c0)); +-- +ok +== +UPDATE t0 SET c0 = DEFAULT; +-- +ok +== +CREATE TABLE t1(c4 UUID, c0 REAL AS(0)); +-- +ok +== +ALTER TABLE t1 ALTER c0 SET DEFAULT 0; +-- +ok +== diff --git a/parser/testdata/corpus/fuzzer/pedro/update_join_bind_error.test b/parser/testdata/corpus/fuzzer/pedro/update_join_bind_error.test new file mode 100644 index 0000000..fa7e6c3 --- /dev/null +++ b/parser/testdata/corpus/fuzzer/pedro/update_join_bind_error.test @@ -0,0 +1,21 @@ +# source: test/fuzzer/pedro/update_join_bind_error.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +CREATE TABLE t1 AS SELECT 1 +-- +ok +== +CREATE TABLE t2 AS SELECT 1 +-- +ok +== +UPDATE t0 SET c1 = 0 FROM t2 JOIN t1 ON (c1); +-- +ok +== +UPDATE t0 SET c1 = 0 FROM (SELECT 1) t2 JOIN (SELECT 1) t1 ON (0, c1); +-- +ok +== diff --git a/parser/testdata/corpus/fuzzer/pedro/update_join_statistics.test b/parser/testdata/corpus/fuzzer/pedro/update_join_statistics.test new file mode 100644 index 0000000..e047ba3 --- /dev/null +++ b/parser/testdata/corpus/fuzzer/pedro/update_join_statistics.test @@ -0,0 +1,13 @@ +# source: test/fuzzer/pedro/update_join_statistics.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +CREATE TABLE t1 (c0 INT, c2 BIGINT, PRIMARY KEY (c0)); +-- +ok +== +PREPARE p2 AS UPDATE t1 SET c0 = (SELECT 2) FROM ((SELECT 1) UNION ALL (SELECT 2)) t2(c1); +-- +ok +== diff --git a/parser/testdata/corpus/fuzzer/pedro/utf8_invalid_unicode.test b/parser/testdata/corpus/fuzzer/pedro/utf8_invalid_unicode.test new file mode 100644 index 0000000..58616d9 --- /dev/null +++ b/parser/testdata/corpus/fuzzer/pedro/utf8_invalid_unicode.test @@ -0,0 +1,101 @@ +# source: test/fuzzer/pedro/utf8_invalid_unicode.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +SELECT upper(decode('\xF6\x96\xB0\x85'::BLOB)::VARCHAR); +-- +ok +== +SELECT decode('\xF6\x96\xB0\x85'::BLOB)::VARCHAR ILIKE '1'; +-- +ok +== +SELECT upper(decode('\xF6\x96\xB0\x85'::BLOB, 'strict')::VARCHAR); +-- +ok +== +SELECT decode('\xA0\x50\x51\xA0\xA0'::BLOB, 'replace')::VARCHAR; +-- +ok +== +SELECT decode('\xA0\x50\x51\xA0\xA0'::BLOB, 'ignore')::VARCHAR; +-- +ok +== +SELECT decode('\xA0ABCDEFGHIJKL'::BLOB, 'ignore')::VARCHAR; +-- +ok +== +SELECT upper(decode('\xF0\x9F\x98\x84'::BLOB)::VARCHAR); +-- +ok +== +SELECT decode('\xF0\x9F\x98\x84'::BLOB)::VARCHAR ILIKE '😄'; +-- +ok +== +SELECT upper(decode('\xC2\xA3'::BLOB)::VARCHAR); +-- +ok +== +SELECT decode('\xC2\xA3'::BLOB)::VARCHAR ILIKE '£'; +-- +ok +== +SELECT upper(decode('\xF0\x90\x8D\x88'::BLOB)::VARCHAR); +-- +ok +== +SELECT decode('\xF0\x90\x8D\x88'::BLOB)::VARCHAR ILIKE '𐍈'; +-- +ok +== +SELECT upper(decode('\xF0\x9F\x98\x84\x00'::BLOB)::VARCHAR); +-- +ok +== +SELECT upper(decode('\xE0\x9F\x98\x84'::BLOB)::VARCHAR); +-- +ok +== +SELECT upper(decode('\xF0\xDF\x98\x84'::BLOB)::VARCHAR); +-- +ok +== +SELECT upper(decode('\xF0\x9F\x98'::BLOB)::VARCHAR); +-- +ok +== +SELECT upper(decode('\xED\xA0\xBD'::BLOB)::VARCHAR); +-- +ok +== +SELECT upper(decode('\xED\xB8\x8D'::BLOB)::VARCHAR); +-- +ok +== +SELECT upper(decode('\xc0\x80'::BLOB)::VARCHAR); +-- +ok +== +SELECT upper(decode('\xc1\x80'::BLOB)::VARCHAR); +-- +ok +== +SELECT upper(decode('\xc0\x81'::BLOB)::VARCHAR); +-- +ok +== +SELECT upper(decode('\xc1\x81'::BLOB)::VARCHAR); +-- +ok +== +SELECT upper(decode('\xc0\x82'::BLOB)::VARCHAR); +-- +ok +== +SELECT upper(decode('\xc1\x82'::BLOB)::VARCHAR); +-- +ok +== diff --git a/parser/testdata/corpus/fuzzer/pedro/vacuum_table_with_generated_column.test b/parser/testdata/corpus/fuzzer/pedro/vacuum_table_with_generated_column.test new file mode 100644 index 0000000..0a46902 --- /dev/null +++ b/parser/testdata/corpus/fuzzer/pedro/vacuum_table_with_generated_column.test @@ -0,0 +1,45 @@ +# source: test/fuzzer/pedro/vacuum_table_with_generated_column.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +CREATE TABLE test (x INT, y AS (x + 100)); +-- +ok +== +ANALYZE test(x, x); +-- +ok +== +ANALYZE test(y); +-- +ok +== +ANALYZE test(y, x); +-- +ok +== +INSERT INTO test SELECT range % 5000 FROM range(10000); +-- +ok +== +SELECT s.min, s.max, s.has_null, s.has_no_null, s.approx_unique FROM (SELECT stats(x) s FROM test LIMIT 1); +-- +ok +== +SELECT s.min, s.max, s.has_null, s.has_no_null FROM (SELECT stats(y) s FROM test LIMIT 1); +-- +ok +== +ANALYZE test +-- +ok +== +ANALYZE test(x); +-- +ok +== +PRAGMA disable_verify_parallelism; +-- +ok +== diff --git a/parser/testdata/corpus/fuzzer/pedro/vacuum_unsupported_type.test b/parser/testdata/corpus/fuzzer/pedro/vacuum_unsupported_type.test new file mode 100644 index 0000000..0eb69e4 --- /dev/null +++ b/parser/testdata/corpus/fuzzer/pedro/vacuum_unsupported_type.test @@ -0,0 +1,13 @@ +# source: test/fuzzer/pedro/vacuum_unsupported_type.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +CREATE TABLE t1 AS (VALUES ([], {'a': []})); +-- +ok +== +VACUUM t1; +-- +ok +== diff --git a/parser/testdata/corpus/fuzzer/pedro/verify_parallelism_batch_index.test b/parser/testdata/corpus/fuzzer/pedro/verify_parallelism_batch_index.test new file mode 100644 index 0000000..b6929b4 --- /dev/null +++ b/parser/testdata/corpus/fuzzer/pedro/verify_parallelism_batch_index.test @@ -0,0 +1,13 @@ +# source: test/fuzzer/pedro/verify_parallelism_batch_index.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +CREATE TABLE t0 AS VALUES (1), (2), (3); +-- +ok +== +SELECT 1 FROM range(1) t2, t0; +-- +ok +== diff --git a/parser/testdata/corpus/fuzzer/pedro/view_not_rebound_error.test b/parser/testdata/corpus/fuzzer/pedro/view_not_rebound_error.test new file mode 100644 index 0000000..4f6d6ad --- /dev/null +++ b/parser/testdata/corpus/fuzzer/pedro/view_not_rebound_error.test @@ -0,0 +1,33 @@ +# source: test/fuzzer/pedro/view_not_rebound_error.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +set enable_view_dependencies=true +-- +ok +== +CREATE VIEW t0 AS SELECT 1 FROM t1 GROUP BY c1; +-- +ok +== +DROP TABLE t1; +-- +ok +== +DROP TABLE t1 CASCADE; +-- +ok +== +CREATE TABLE t2 (c1 INT); +-- +ok +== +CREATE TABLE t1 (c2 INT); +-- +ok +== +SELECT 1 FROM t2 JOIN t1 ON (SELECT TRUE FROM t0); +-- +ok +== diff --git a/parser/testdata/corpus/fuzzer/pedro/wal_rename_table.test b/parser/testdata/corpus/fuzzer/pedro/wal_rename_table.test new file mode 100644 index 0000000..d181a7d --- /dev/null +++ b/parser/testdata/corpus/fuzzer/pedro/wal_rename_table.test @@ -0,0 +1,13 @@ +# source: test/fuzzer/pedro/wal_rename_table.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +ALTER TABLE t1 RENAME TO t0; +-- +ok +== +CREATE INDEX i0 ON t0(c0); +-- +ok +== diff --git a/parser/testdata/corpus/fuzzer/pedro/window_function_timeout.test b/parser/testdata/corpus/fuzzer/pedro/window_function_timeout.test new file mode 100644 index 0000000..67d5f35 --- /dev/null +++ b/parser/testdata/corpus/fuzzer/pedro/window_function_timeout.test @@ -0,0 +1,21 @@ +# source: test/fuzzer/pedro/window_function_timeout.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +CREATE TABLE t0 (c0 TIME); +-- +ok +== +SELECT INTERVAL '17768853205' HOUR +-- +ok +== +SELECT count(*) OVER (ORDER BY INTERVAL '17' HOUR) FROM t0 GROUP BY ROLLUP (c0); +-- +ok +== +SELECT count(*) OVER (ORDER BY INTERVAL '17768853205' HOUR) FROM t0 GROUP BY ROLLUP (c0); +-- +ok +== diff --git a/parser/testdata/corpus/fuzzer/pedro/window_self_reference.test b/parser/testdata/corpus/fuzzer/pedro/window_self_reference.test new file mode 100644 index 0000000..82bf0eb --- /dev/null +++ b/parser/testdata/corpus/fuzzer/pedro/window_self_reference.test @@ -0,0 +1,13 @@ +# source: test/fuzzer/pedro/window_self_reference.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +SELECT count(*) OVER w1 WINDOW w1 AS (ORDER BY count(*) OVER w1); +-- +error: Parser Error: window functions are not allowed in window definitions +== +SELECT count(*) OVER w1 WINDOW w1 AS (ORDER BY count(*) OVER w2), w2 AS (ORDER BY count(*) OVER w1); +-- +error: Parser Error: window functions are not allowed in window definitions +== diff --git a/parser/testdata/corpus/fuzzer/pedro/window_self_reference.test.metadata.json b/parser/testdata/corpus/fuzzer/pedro/window_self_reference.test.metadata.json new file mode 100644 index 0000000..1c5726f --- /dev/null +++ b/parser/testdata/corpus/fuzzer/pedro/window_self_reference.test.metadata.json @@ -0,0 +1,6 @@ +{ + "todo": { + "45c9e3c8c8f61530": "transformer-raised parser error: upstream rejects in the transformer, not the grammar; expected to clear as transformers land (milestones 3-5)", + "88f8d8e5fc7e9ec8": "transformer-raised parser error: upstream rejects in the transformer, not the grammar; expected to clear as transformers land (milestones 3-5)" + } +} diff --git a/parser/testdata/corpus/fuzzer/public/cast_index_expression.test b/parser/testdata/corpus/fuzzer/public/cast_index_expression.test new file mode 100644 index 0000000..74fb290 --- /dev/null +++ b/parser/testdata/corpus/fuzzer/public/cast_index_expression.test @@ -0,0 +1,9 @@ +# source: test/fuzzer/public/cast_index_expression.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +CREATE INDEX i_index ON v00 USING ART ( NULLIF ( v00, 'string' ) ); +-- +ok +== diff --git a/parser/testdata/corpus/fuzzer/public/columns_using.test b/parser/testdata/corpus/fuzzer/public/columns_using.test new file mode 100644 index 0000000..37e9f11 --- /dev/null +++ b/parser/testdata/corpus/fuzzer/public/columns_using.test @@ -0,0 +1,19 @@ +# source: test/fuzzer/public/columns_using.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +CREATE TABLE v00 (c01 INT); +-- +ok +== +SELECT COLUMNS('v00') +FROM v00 AS t1 FULL JOIN v00 AS t2 USING (c01) ; +-- +ok +== +SELECT COLUMNS('c01') +FROM v00 AS t1 FULL JOIN v00 AS t2 USING (c01) ; +-- +ok +== diff --git a/parser/testdata/corpus/fuzzer/public/distinct_on_non_integer_literal.test b/parser/testdata/corpus/fuzzer/public/distinct_on_non_integer_literal.test new file mode 100644 index 0000000..0174ed5 --- /dev/null +++ b/parser/testdata/corpus/fuzzer/public/distinct_on_non_integer_literal.test @@ -0,0 +1,13 @@ +# source: test/fuzzer/public/distinct_on_non_integer_literal.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +SET order_by_non_integer_literal=true; +-- +ok +== +SELECT DISTINCT ON ('string') 'x' AS c02; +-- +ok +== diff --git a/parser/testdata/corpus/fuzzer/public/duplicate_alias_using.test b/parser/testdata/corpus/fuzzer/public/duplicate_alias_using.test new file mode 100644 index 0000000..078f669 --- /dev/null +++ b/parser/testdata/corpus/fuzzer/public/duplicate_alias_using.test @@ -0,0 +1,11 @@ +# source: test/fuzzer/public/duplicate_alias_using.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +SELECT c1 +FROM t1 AS same_alias JOIN t1 AS same_alias2 USING (c1), + t1 AS same_alias JOIN t1 AS same_alias2 USING (c1); +-- +ok +== diff --git a/parser/testdata/corpus/fuzzer/public/enum_empty_type.test b/parser/testdata/corpus/fuzzer/public/enum_empty_type.test new file mode 100644 index 0000000..2169da0 --- /dev/null +++ b/parser/testdata/corpus/fuzzer/public/enum_empty_type.test @@ -0,0 +1,21 @@ +# source: test/fuzzer/public/enum_empty_type.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +CREATE TYPE c AS ENUM(''); +-- +ok +== +CREATE TYPE c AS ENUM('', ''); +-- +ok +== +CREATE TYPE f AS M(); +-- +ok +== +SELECT * FROM(VALUES(''::text)) +-- +ok +== diff --git a/parser/testdata/corpus/fuzzer/public/insert_by_name_default.test b/parser/testdata/corpus/fuzzer/public/insert_by_name_default.test new file mode 100644 index 0000000..aeae0bc --- /dev/null +++ b/parser/testdata/corpus/fuzzer/public/insert_by_name_default.test @@ -0,0 +1,13 @@ +# source: test/fuzzer/public/insert_by_name_default.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +CREATE TABLE t0(i INT) +-- +ok +== +INSERT INTO t0 BY NAME DEFAULT VALUES; +-- +ok +== diff --git a/parser/testdata/corpus/fuzzer/public/insert_or_replace_default_values.test b/parser/testdata/corpus/fuzzer/public/insert_or_replace_default_values.test new file mode 100644 index 0000000..9d7a001 --- /dev/null +++ b/parser/testdata/corpus/fuzzer/public/insert_or_replace_default_values.test @@ -0,0 +1,25 @@ +# source: test/fuzzer/public/insert_or_replace_default_values.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +CREATE TABLE tbl(id INTEGER PRIMARY KEY DEFAULT 1, payload INTEGER DEFAULT nextval('seq')); +-- +ok +== +INSERT OR REPLACE INTO tbl DEFAULT VALUES; +-- +ok +== +FROM tbl +-- +ok +== +INSERT OR IGNORE INTO tbl DEFAULT VALUES; +-- +ok +== +INSERT INTO tbl DEFAULT VALUES; +-- +ok +== diff --git a/parser/testdata/corpus/fuzzer/public/insert_returning.test b/parser/testdata/corpus/fuzzer/public/insert_returning.test new file mode 100644 index 0000000..0659790 --- /dev/null +++ b/parser/testdata/corpus/fuzzer/public/insert_returning.test @@ -0,0 +1,13 @@ +# source: test/fuzzer/public/insert_returning.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +INSERT INTO v00 (c01, c02) VALUES (0, 'abc'); +-- +ok +== +INSERT INTO v00 FROM v00 ORDER BY ALL DESC RETURNING 'abc'; +-- +ok +== diff --git a/parser/testdata/corpus/fuzzer/public/lateral_in_right_side_of_join.test b/parser/testdata/corpus/fuzzer/public/lateral_in_right_side_of_join.test new file mode 100644 index 0000000..9efdb58 --- /dev/null +++ b/parser/testdata/corpus/fuzzer/public/lateral_in_right_side_of_join.test @@ -0,0 +1,29 @@ +# source: test/fuzzer/public/lateral_in_right_side_of_join.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +CREATE TABLE t0(c0 INT , c1 VARCHAR); +-- +ok +== +CREATE TABLE t1( c1 INT); +-- +ok +== +INSERT INTO t0 VALUES(4, 3); +-- +ok +== +INSERT INTO t1 VALUES(2); +-- +ok +== +SELECT * FROM t1, t0 JOIN LATERAL (SELECT t1.c1 AS col0) _subq ON true; +-- +ok +== +SELECT * FROM t1, t0 INNER JOIN (SELECT t1.c1 AS col0) ON true; +-- +ok +== diff --git a/parser/testdata/corpus/fuzzer/public/lateral_join_subquery.test b/parser/testdata/corpus/fuzzer/public/lateral_join_subquery.test new file mode 100644 index 0000000..9639876 --- /dev/null +++ b/parser/testdata/corpus/fuzzer/public/lateral_join_subquery.test @@ -0,0 +1,13 @@ +# source: test/fuzzer/public/lateral_join_subquery.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +FROM t1 INNER JOIN (SELECT t1.c1) ON (SELECT 42); +-- +ok +== +SELECT c01 from values('string') as _(c01), LATERAL ( WITH ta02 AS MATERIALIZED ( SELECT 'string' ) ( SELECT 'string' ) INTERSECT ALL ( SELECT 'string' ) ); +-- +ok +== diff --git a/parser/testdata/corpus/fuzzer/public/lateral_right_join.test b/parser/testdata/corpus/fuzzer/public/lateral_right_join.test new file mode 100644 index 0000000..a6b3b71 --- /dev/null +++ b/parser/testdata/corpus/fuzzer/public/lateral_right_join.test @@ -0,0 +1,21 @@ +# source: test/fuzzer/public/lateral_right_join.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +CREATE TABLE tbl (c01 INT, c02 VARCHAR); +-- +ok +== +INSERT INTO tbl (c01, c02) VALUES (0, 'abc'); +-- +ok +== +SELECT * FROM tbl, LATERAL (SELECT tbl.c01 AS lat_c01) AS subq CROSS JOIN tbl AS t1 RIGHT JOIN tbl AS t2 USING (c02); +-- +ok +== +SELECT * FROM tbl, LATERAL (SELECT tbl.c01 AS lat_c01) AS subq CROSS JOIN tbl AS t1 RIGHT JOIN tbl AS t2 USING (c02, c01); +-- +ok +== diff --git a/parser/testdata/corpus/fuzzer/public/pivot_empty_enum.test b/parser/testdata/corpus/fuzzer/public/pivot_empty_enum.test new file mode 100644 index 0000000..f737f38 --- /dev/null +++ b/parser/testdata/corpus/fuzzer/public/pivot_empty_enum.test @@ -0,0 +1,13 @@ +# source: test/fuzzer/public/pivot_empty_enum.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +CREATE TABLE t1 (c01 INT); +-- +ok +== +PIVOT_WIDER t1 ON c01 IN ENUM; +-- +ok +== diff --git a/parser/testdata/corpus/fuzzer/public/pivot_full_join_using.test b/parser/testdata/corpus/fuzzer/public/pivot_full_join_using.test new file mode 100644 index 0000000..d963c0f --- /dev/null +++ b/parser/testdata/corpus/fuzzer/public/pivot_full_join_using.test @@ -0,0 +1,17 @@ +# source: test/fuzzer/public/pivot_full_join_using.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +CREATE TABLE t1 (c01 INT, c02 INT); +-- +ok +== +CREATE TABLE t2 (c01 INT, c03 INT); +-- +ok +== +PIVOT t1 FULL JOIN t2 USING ( c01 ) ON c01; +-- +ok +== diff --git a/parser/testdata/corpus/fuzzer/public/positional_join_correlated_subquery.test b/parser/testdata/corpus/fuzzer/public/positional_join_correlated_subquery.test new file mode 100644 index 0000000..6db92b1 --- /dev/null +++ b/parser/testdata/corpus/fuzzer/public/positional_join_correlated_subquery.test @@ -0,0 +1,10 @@ +# source: test/fuzzer/public/positional_join_correlated_subquery.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +SELECT (SELECT 42 FROM (SELECT c01) POSITIONAL JOIN (SELECT c02)) +FROM v00; +-- +ok +== diff --git a/parser/testdata/corpus/fuzzer/public/pragma_named_parameters.test b/parser/testdata/corpus/fuzzer/public/pragma_named_parameters.test new file mode 100644 index 0000000..9807fe5 --- /dev/null +++ b/parser/testdata/corpus/fuzzer/public/pragma_named_parameters.test @@ -0,0 +1,9 @@ +# source: test/fuzzer/public/pragma_named_parameters.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +PRAGMA e=r=0,0; +-- +error: Parser Error: PRAGMA statement with assignment should contain exactly one parameter +== diff --git a/parser/testdata/corpus/fuzzer/public/pragma_named_parameters.test.metadata.json b/parser/testdata/corpus/fuzzer/public/pragma_named_parameters.test.metadata.json new file mode 100644 index 0000000..f40c09a --- /dev/null +++ b/parser/testdata/corpus/fuzzer/public/pragma_named_parameters.test.metadata.json @@ -0,0 +1,5 @@ +{ + "todo": { + "7f4418d74ce6552f": "transformer-raised parser error: upstream rejects in the transformer, not the grammar; expected to clear as transformers land (milestones 3-5)" + } +} diff --git a/parser/testdata/corpus/fuzzer/public/regex_range_filter_mismatch.test b/parser/testdata/corpus/fuzzer/public/regex_range_filter_mismatch.test new file mode 100644 index 0000000..3fd626e --- /dev/null +++ b/parser/testdata/corpus/fuzzer/public/regex_range_filter_mismatch.test @@ -0,0 +1,13 @@ +# source: test/fuzzer/public/regex_range_filter_mismatch.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +CREATE TABLE v00 ( c01 INTEGER ) ; +-- +ok +== +SELECT * FROM v00 WHERE concat(c01 IS NOT NULL, 'string') SIMILAR TO 'string'; +-- +ok +== diff --git a/parser/testdata/corpus/fuzzer/public/semi_anti_join_using.test b/parser/testdata/corpus/fuzzer/public/semi_anti_join_using.test new file mode 100644 index 0000000..bf28e2c --- /dev/null +++ b/parser/testdata/corpus/fuzzer/public/semi_anti_join_using.test @@ -0,0 +1,17 @@ +# source: test/fuzzer/public/semi_anti_join_using.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +INSERT INTO v00 VALUES (42); +-- +ok +== +SELECT c01 FROM ( v00 AS ta03 SEMI JOIN ( v00 AS ta04 JOIN v00 AS ta05 USING ( c01 ) ) ON 42 ) ; +-- +ok +== +SELECT c01 FROM ( v00 AS ta03 ANTI JOIN ( v00 AS ta04 JOIN v00 AS ta05 USING ( c01 ) ) ON 42 ) ; +-- +ok +== diff --git a/parser/testdata/corpus/fuzzer/public/semi_join_using.test b/parser/testdata/corpus/fuzzer/public/semi_join_using.test new file mode 100644 index 0000000..14d4a04 --- /dev/null +++ b/parser/testdata/corpus/fuzzer/public/semi_join_using.test @@ -0,0 +1,27 @@ +# source: test/fuzzer/public/semi_join_using.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +SELECT c02 +FROM ( + v00 AS t1 + NATURAL JOIN + v00 AS t2 ), + ( v00 AS ta04 + SEMI JOIN v00 AS ta05 + USING ( c02 ) ) ; +-- +ok +== +SELECT t1.c02, t2.c02, ta04.c02 +FROM ( + v00 AS t1 + NATURAL JOIN + v00 AS t2 ), + ( v00 AS ta04 + SEMI JOIN v00 AS ta05 + USING ( c02 ) ) ; +-- +ok +== diff --git a/parser/testdata/corpus/fuzzer/public/unpivot_partial_values.test b/parser/testdata/corpus/fuzzer/public/unpivot_partial_values.test new file mode 100644 index 0000000..ce8dfee --- /dev/null +++ b/parser/testdata/corpus/fuzzer/public/unpivot_partial_values.test @@ -0,0 +1,9 @@ +# source: test/fuzzer/public/unpivot_partial_values.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +FROM (SELECT 42 c1) AS ta06 UNPIVOT (c1 FOR 'v' IN ( ( c1, 'a' || 'b' ) ) ) ; +-- +ok +== diff --git a/parser/testdata/corpus/fuzzer/public/unsatisfiable_filter_prune.test b/parser/testdata/corpus/fuzzer/public/unsatisfiable_filter_prune.test new file mode 100644 index 0000000..f05b7e2 --- /dev/null +++ b/parser/testdata/corpus/fuzzer/public/unsatisfiable_filter_prune.test @@ -0,0 +1,21 @@ +# source: test/fuzzer/public/unsatisfiable_filter_prune.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +CREATE TABLE t0(c0 INT, c1 INT); +-- +ok +== +INSERT INTO t0( c0, c1) VALUES ( -1, -1); +-- +ok +== +SELECT c0 FROM t0 WHERE (((CASE t0.c0 WHEN t0.c0 THEN t0.c0 END ) BETWEEN 1 AND t0.c0)AND(t0.c0 <= 0)) ; +-- +ok +== +SELECT * FROM t0 WHERE c0 >= 1 AND c0 <= t0.c1 AND t0.c1 <= 0; +-- +ok +== diff --git a/parser/testdata/corpus/fuzzer/public/window_subquery_error.test b/parser/testdata/corpus/fuzzer/public/window_subquery_error.test new file mode 100644 index 0000000..6f40309 --- /dev/null +++ b/parser/testdata/corpus/fuzzer/public/window_subquery_error.test @@ -0,0 +1,9 @@ +# source: test/fuzzer/public/window_subquery_error.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +SELECT 'string' IN ( SELECT string_agg ('str') OVER ( PARTITION BY c02 + 'string' IN ( SELECT 'string' )) ); +-- +ok +== diff --git a/parser/testdata/corpus/fuzzer/public/window_subquery_with_functions_error.test b/parser/testdata/corpus/fuzzer/public/window_subquery_with_functions_error.test new file mode 100644 index 0000000..088613d --- /dev/null +++ b/parser/testdata/corpus/fuzzer/public/window_subquery_with_functions_error.test @@ -0,0 +1,13 @@ +# source: test/fuzzer/public/window_subquery_with_functions_error.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +CREATE TABLE v0 ( v1 INTEGER ) ; +-- +ok +== +SELECT ( SELECT to_centuries ( v1 ) FROM v0 WHERE fmod ( fmod ( v1 , 3.100000 ) , 3.100000 ) OVER( ORDER BY v1 ) = 70000 ) AS century_result; +-- +ok +== diff --git a/parser/testdata/corpus/fuzzer/sqlsmith/bitstring_agg_executor.test b/parser/testdata/corpus/fuzzer/sqlsmith/bitstring_agg_executor.test new file mode 100644 index 0000000..111fde3 --- /dev/null +++ b/parser/testdata/corpus/fuzzer/sqlsmith/bitstring_agg_executor.test @@ -0,0 +1,13 @@ +# source: test/fuzzer/sqlsmith/bitstring_agg_executor.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +CREATE TABLE tbl(v UBIGINT); +-- +ok +== +SELECT bitstring_agg(v, CAST(v AS UBIGINT), CAST(v AS UBIGINT)) FROM tbl; +-- +ok +== diff --git a/parser/testdata/corpus/fuzzer/sqlsmith/bitstring_agg_overflow.test b/parser/testdata/corpus/fuzzer/sqlsmith/bitstring_agg_overflow.test new file mode 100644 index 0000000..48daa8e --- /dev/null +++ b/parser/testdata/corpus/fuzzer/sqlsmith/bitstring_agg_overflow.test @@ -0,0 +1,29 @@ +# source: test/fuzzer/sqlsmith/bitstring_agg_overflow.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +CREATE OR REPLACE TABLE integers(i {type}); +-- +error: Parser Error: syntax error at or near "{" +== +INSERT INTO integers VALUES (0), (255); +-- +ok +== +SELECT bitstring_agg(i) FROM integers +-- +ok +== +CREATE TABLE all_types AS FROM test_all_types(); +-- +ok +== +SELECT bitstring_agg("{small_type}") FROM all_types; +-- +ok +== +SELECT bitstring_agg("{type}") FROM all_types; +-- +ok +== diff --git a/parser/testdata/corpus/fuzzer/sqlsmith/current_schemas_null.test b/parser/testdata/corpus/fuzzer/sqlsmith/current_schemas_null.test new file mode 100644 index 0000000..8b63557 --- /dev/null +++ b/parser/testdata/corpus/fuzzer/sqlsmith/current_schemas_null.test @@ -0,0 +1,25 @@ +# source: test/fuzzer/sqlsmith/current_schemas_null.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +CREATE TABLE booleans(bool BOOLEAN); +-- +ok +== +INSERT INTO booleans VALUES(NULL); +-- +ok +== +SELECT current_schemas(false); +-- +ok +== +SELECT current_schemas(NULL); +-- +ok +== +SELECT current_schemas(ref_0.bool) AS c4 FROM booleans AS ref_0; +-- +ok +== diff --git a/parser/testdata/corpus/fuzzer/sqlsmith/dayofweek_overflow.test b/parser/testdata/corpus/fuzzer/sqlsmith/dayofweek_overflow.test new file mode 100644 index 0000000..5a22243 --- /dev/null +++ b/parser/testdata/corpus/fuzzer/sqlsmith/dayofweek_overflow.test @@ -0,0 +1,21 @@ +# source: test/fuzzer/sqlsmith/dayofweek_overflow.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +CREATE TABLE dates(date DATE); +-- +ok +== +INSERT INTO dates VALUES('5877642-06-25 (BC)'); +-- +ok +== +INSERT INTO dates VALUES('5881580-07-10'); +-- +ok +== +SELECT dayofweek(CAST(ref_0.date AS DATE)) AS c9 FROM dates AS ref_0 +-- +ok +== diff --git a/parser/testdata/corpus/fuzzer/sqlsmith/fuzzer_window_varchar.test b/parser/testdata/corpus/fuzzer/sqlsmith/fuzzer_window_varchar.test new file mode 100644 index 0000000..0e1ec41 --- /dev/null +++ b/parser/testdata/corpus/fuzzer/sqlsmith/fuzzer_window_varchar.test @@ -0,0 +1,21 @@ +# source: test/fuzzer/sqlsmith/fuzzer_window_varchar.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +CREATE TABLE all_types("varchar" VARCHAR, "double" DOUBLE);; +-- +ok +== +INSERT INTO all_types VALUES('🦆🦆🦆🦆🦆🦆',0); +-- +ok +== +INSERT INTO all_types VALUES('goose',1); +-- +ok +== +SELECT mode(t0."varchar") OVER (PARTITION BY t0."double") AS c18 FROM all_types AS t0; +-- +ok +== diff --git a/parser/testdata/corpus/fuzzer/sqlsmith/generate_series_overflow.test b/parser/testdata/corpus/fuzzer/sqlsmith/generate_series_overflow.test new file mode 100644 index 0000000..31c22ec --- /dev/null +++ b/parser/testdata/corpus/fuzzer/sqlsmith/generate_series_overflow.test @@ -0,0 +1,37 @@ +# source: test/fuzzer/sqlsmith/generate_series_overflow.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +CREATE TABLE tbl(bigint BIGINT); +-- +ok +== +INSERT INTO tbl VALUES(-9223372036854775808); +-- +ok +== +INSERT INTO tbl VALUES(9223372036854775807); +-- +ok +== +INSERT INTO tbl VALUES(NULL); +-- +ok +== +SELECT generate_series(CAST(ref_0."bigint" AS BIGINT)) AS c1 FROM tbl AS ref_0 +-- +ok +== +SELECT generate_series(-9223372036854775808, 9223372036854775807, 1) AS c1 +-- +ok +== +SELECT generate_series(9223372036854775805, 9223372036854775807, 1) AS c1 +-- +ok +== +SELECT generate_series(-9223372036854775806, -9223372036854775808, -1) AS c1 +-- +ok +== diff --git a/parser/testdata/corpus/fuzzer/sqlsmith/interval_diff_overflow.test b/parser/testdata/corpus/fuzzer/sqlsmith/interval_diff_overflow.test new file mode 100644 index 0000000..bd0441c --- /dev/null +++ b/parser/testdata/corpus/fuzzer/sqlsmith/interval_diff_overflow.test @@ -0,0 +1,26 @@ +# source: test/fuzzer/sqlsmith/interval_diff_overflow.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +SELECT subtract( + CAST(main.all_types."interval" AS INTERVAL), + CAST(to_months(CAST(main.all_types."int" AS INTEGER)) AS INTERVAL)) +FROM main.all_types +-- +ok +== +SELECT subtract( + CAST(main.all_types."interval" AS INTERVAL), + CAST(to_days(CAST(main.all_types."int" AS INTEGER)) AS INTERVAL)) +FROM main.all_types +-- +ok +== +SELECT subtract( + CAST(main.all_types."interval" AS INTERVAL), + CAST(to_microseconds(CAST(main.all_types."bigint" AS BIGINT)) AS INTERVAL)) +FROM main.all_types +-- +ok +== diff --git a/parser/testdata/corpus/fuzzer/sqlsmith/interval_multiply_overflow.test b/parser/testdata/corpus/fuzzer/sqlsmith/interval_multiply_overflow.test new file mode 100644 index 0000000..87b9515 --- /dev/null +++ b/parser/testdata/corpus/fuzzer/sqlsmith/interval_multiply_overflow.test @@ -0,0 +1,10 @@ +# source: test/fuzzer/sqlsmith/interval_multiply_overflow.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +SELECT multiply("interval", "bigint") +FROM all_types; +-- +ok +== diff --git a/parser/testdata/corpus/fuzzer/sqlsmith/json_contains_null.test b/parser/testdata/corpus/fuzzer/sqlsmith/json_contains_null.test new file mode 100644 index 0000000..7501a7c --- /dev/null +++ b/parser/testdata/corpus/fuzzer/sqlsmith/json_contains_null.test @@ -0,0 +1,18 @@ +# source: test/fuzzer/sqlsmith/json_contains_null.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +SELECT json_contains(NULL::VARCHAR, NULL::VARCHAR); +-- +ok +== +WITH cte AS ( + SELECT NULL::VARCHAR j + FROM range(1) +) +SELECT json_contains(j, j) +FROM cte +-- +ok +== diff --git a/parser/testdata/corpus/fuzzer/sqlsmith/like_null_pattern.test b/parser/testdata/corpus/fuzzer/sqlsmith/like_null_pattern.test new file mode 100644 index 0000000..08b6372 --- /dev/null +++ b/parser/testdata/corpus/fuzzer/sqlsmith/like_null_pattern.test @@ -0,0 +1,9 @@ +# source: test/fuzzer/sqlsmith/like_null_pattern.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +SELECT current_schema() ~~ CAST(NULL AS VARCHAR) +-- +ok +== diff --git a/parser/testdata/corpus/fuzzer/sqlsmith/mad_overflow.test b/parser/testdata/corpus/fuzzer/sqlsmith/mad_overflow.test new file mode 100644 index 0000000..71b95c9 --- /dev/null +++ b/parser/testdata/corpus/fuzzer/sqlsmith/mad_overflow.test @@ -0,0 +1,10 @@ +# source: test/fuzzer/sqlsmith/mad_overflow.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +SELECT mad(dec38_10) +FROM all_types; +-- +ok +== diff --git a/parser/testdata/corpus/fuzzer/sqlsmith/makedate_overflow.test b/parser/testdata/corpus/fuzzer/sqlsmith/makedate_overflow.test new file mode 100644 index 0000000..b226f08 --- /dev/null +++ b/parser/testdata/corpus/fuzzer/sqlsmith/makedate_overflow.test @@ -0,0 +1,15 @@ +# source: test/fuzzer/sqlsmith/makedate_overflow.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +SELECT make_timestamp("bigint", "bigint", "bigint", "bigint", "bigint", "double") +FROM all_types; +-- +ok +== +SELECT make_date(c1) +FROM test_vector_types(CAST(NULL AS STRUCT("year" BIGINT, "month" BIGINT, "day" BIGINT))) AS test_vector_types(c1); +-- +ok +== diff --git a/parser/testdata/corpus/fuzzer/sqlsmith/nested_correlated_subquery.test b/parser/testdata/corpus/fuzzer/sqlsmith/nested_correlated_subquery.test new file mode 100644 index 0000000..8aea6f0 --- /dev/null +++ b/parser/testdata/corpus/fuzzer/sqlsmith/nested_correlated_subquery.test @@ -0,0 +1,52 @@ +# source: test/fuzzer/sqlsmith/nested_correlated_subquery.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +CREATE TABLE t(ps_supplycost INT, n_name INT); +-- +ok +== +SELECT NULL +FROM + t AS ref_2, + (SELECT (SELECT NULL + FROM (FROM t AS ref_5, + (SELECT ref_2.n_name AS c1)))); +-- +ok +== +SELECT NULL +FROM + t AS ref_2, + (SELECT (SELECT NULL + FROM (FROM t AS ref_5, + (SELECT ref_5.ps_supplycost AS c0, + ref_2.n_name AS c1)))); +-- +ok +== +SELECT NULL +FROM + t AS ref_2, + LATERAL (SELECT (SELECT NULL + FROM (SELECT * FROM t AS ref_5, + LATERAL (SELECT ref_5.ps_supplycost AS c0, + ref_2.n_name AS c1) AS alias1) AS alias2) AS alias3) AS alias4; +-- +ok +== +INSERT INTO t VALUES (1, 100); +-- +ok +== +SELECT * +FROM + t AS ref_2, + LATERAL (SELECT (SELECT NULL + FROM (SELECT * FROM t AS ref_5, + LATERAL (SELECT ref_5.ps_supplycost AS c0, + ref_2.n_name AS c1) AS alias1) AS alias2) AS alias3) AS alias4; +-- +ok +== diff --git a/parser/testdata/corpus/fuzzer/sqlsmith/nullif_map.test b/parser/testdata/corpus/fuzzer/sqlsmith/nullif_map.test new file mode 100644 index 0000000..f362d38 --- /dev/null +++ b/parser/testdata/corpus/fuzzer/sqlsmith/nullif_map.test @@ -0,0 +1,21 @@ +# source: test/fuzzer/sqlsmith/nullif_map.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +CREATE TABLE tbl(map MAP(VARCHAR, VARCHAR));; +-- +ok +== +INSERT INTO tbl VALUES(MAP([], [])); +-- +ok +== +INSERT INTO tbl VALUES(MAP(['key1', 'key2'], ['🦆🦆🦆🦆🦆🦆', 'goose'])); +-- +ok +== +SELECT nullif(ref_2."map", ref_2."map") FROM tbl AS ref_2 ORDER BY rowid; +-- +ok +== diff --git a/parser/testdata/corpus/fuzzer/sqlsmith/nullif_map_with_config.test b/parser/testdata/corpus/fuzzer/sqlsmith/nullif_map_with_config.test new file mode 100644 index 0000000..7c746fc --- /dev/null +++ b/parser/testdata/corpus/fuzzer/sqlsmith/nullif_map_with_config.test @@ -0,0 +1,49 @@ +# source: test/fuzzer/sqlsmith/nullif_map_with_config.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +SET default_block_size = 262144; +-- +ok +== +SET storage_compatibility_version = 'latest'; +-- +ok +== +SET max_memory = '1234kb'; +-- +ok +== +ATTACH '{TEST_DIR}/issue5232.db' AS issue5232 (STORAGE_VERSION 'latest'); +-- +ok +== +USE issue5232; +-- +ok +== +CREATE TABLE tbl(map MAP(VARCHAR, VARCHAR)); +-- +ok +== +USE nullif_map_issue; +-- +ok +== +DETACH issue5232; +-- +ok +== +SET default_block_size = 16384; +-- +ok +== +ATTACH '{TEST_DIR}/issue5232_small.db' (STORAGE_VERSION 'latest'); +-- +ok +== +USE issue5232_small; +-- +ok +== diff --git a/parser/testdata/corpus/fuzzer/sqlsmith/statistics_assertion_trigger.test b/parser/testdata/corpus/fuzzer/sqlsmith/statistics_assertion_trigger.test new file mode 100644 index 0000000..d13140c --- /dev/null +++ b/parser/testdata/corpus/fuzzer/sqlsmith/statistics_assertion_trigger.test @@ -0,0 +1,49 @@ +# source: test/fuzzer/sqlsmith/statistics_assertion_trigger.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +SELECT NULL AS c3 +FROM + (SELECT NULL AS c0, + NULL AS c1, + NULL AS c2 + FROM main.all_types AS ref_0 + INNER JOIN main.all_types AS ref_1 + INNER JOIN main.all_types AS ref_2 + LEFT JOIN main.all_types AS ref_3 ON (ref_2."struct" = ref_3."struct") ON (ref_3."varchar") ON (ref_1."varchar") + LEFT JOIN main.all_types AS ref_4 + INNER JOIN main.all_types AS ref_5 ON (NULL) ON (ref_0."double" = ref_5."double")) AS subq_0 +WHERE EXISTS + (SELECT NULL AS c0, + NULL AS c1, + NULL AS c2, + NULL AS c3, + NULL AS c4, + NULL AS c5, + NULL AS c6, + NULL AS c7 + FROM + (SELECT NULL AS c1) AS subq_1 + WHERE ( + (SELECT 'duck') ~~ CASE + WHEN ((subq_0.c1 IS NOT NULL)) THEN (CASE + WHEN (( + (SELECT 'duck') ~~ + (SELECT 'duck'))) THEN ( + (SELECT 'duck')) + ELSE + (SELECT 'duck') + END) + ELSE CASE + WHEN (( + (SELECT 'duck') ~~ + (SELECT 'duck'))) THEN ( + (SELECT 'duck')) + ELSE + (SELECT 'duck') + END + END)) +-- +ok +== diff --git a/parser/testdata/corpus/fuzzer/sqlsmith/strptime_nullpointer.test b/parser/testdata/corpus/fuzzer/sqlsmith/strptime_nullpointer.test new file mode 100644 index 0000000..5212976 --- /dev/null +++ b/parser/testdata/corpus/fuzzer/sqlsmith/strptime_nullpointer.test @@ -0,0 +1,17 @@ +# source: test/fuzzer/sqlsmith/strptime_nullpointer.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +CREATE TABLE t0(c0 BOOLEAN DEFAULT(true), c1 VARCHAR); +-- +ok +== +INSERT INTO t0(c0, c1) VALUES (534898561, 1156365055), (524523641, '0.46680525959210206'); +-- +ok +== +SELECT NULL FROM t0 ORDER BY strptime(NOT(t0.c0 BETWEEN t0.rowid AND t0.rowid), 1407974306) +-- +ok +== diff --git a/parser/testdata/corpus/fuzzer/sqlsmith/struct_null_coalesce_assert.test b/parser/testdata/corpus/fuzzer/sqlsmith/struct_null_coalesce_assert.test new file mode 100644 index 0000000..5828c0c --- /dev/null +++ b/parser/testdata/corpus/fuzzer/sqlsmith/struct_null_coalesce_assert.test @@ -0,0 +1,17 @@ +# source: test/fuzzer/sqlsmith/struct_null_coalesce_assert.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +CREATE TABLE struct_tbl("struct" STRUCT(a INTEGER, b VARCHAR)); +-- +ok +== +SELECT CAST(COALESCE(CAST(NULL AS STRUCT(a INTEGER, b VARCHAR)), CAST(NULL AS STRUCT(a INTEGER, b VARCHAR))) AS STRUCT(a INTEGER, b VARCHAR)) +-- +ok +== +INSERT INTO struct_tbl (VALUES (CAST(COALESCE(CAST(NULL AS STRUCT(a INTEGER, b VARCHAR)), CAST(NULL AS STRUCT(a INTEGER, b VARCHAR))) AS STRUCT(a INTEGER, b VARCHAR)))); +-- +ok +== diff --git a/parser/testdata/corpus/fuzzer/sqlsmith/struct_verify_crash.test b/parser/testdata/corpus/fuzzer/sqlsmith/struct_verify_crash.test new file mode 100644 index 0000000..d31fbad --- /dev/null +++ b/parser/testdata/corpus/fuzzer/sqlsmith/struct_verify_crash.test @@ -0,0 +1,21 @@ +# source: test/fuzzer/sqlsmith/struct_verify_crash.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +CREATE TABLE tbl(array_of_structs STRUCT(a INTEGER, b VARCHAR)[]); +-- +ok +== +INSERT INTO tbl VALUES([]); +-- +ok +== +INSERT INTO tbl VALUES([{'a': 42, 'b': '🦆🦆🦆🦆🦆🦆'}]); +-- +ok +== +SELECT EXISTS(SELECT ref_1.array_of_structs AS c1) FROM tbl AS ref_0, tbl AS ref_1 +-- +ok +== diff --git a/parser/testdata/corpus/fuzzer/sqlsmith/subquery_binding_error.test b/parser/testdata/corpus/fuzzer/sqlsmith/subquery_binding_error.test new file mode 100644 index 0000000..8ff8463 --- /dev/null +++ b/parser/testdata/corpus/fuzzer/sqlsmith/subquery_binding_error.test @@ -0,0 +1,26 @@ +# source: test/fuzzer/sqlsmith/subquery_binding_error.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +CREATE TABLE all_types("varchar" VARCHAR); +-- +ok +== +INSERT INTO all_types VALUES('🦆🦆🦆🦆🦆🦆'); +-- +ok +== +SELECT NULL AS c1 +FROM + (SELECT NULL AS c2) AS subq_0 +LEFT JOIN + (SELECT DISTINCT + ref_3."varchar" AS c7 + FROM all_types AS ref_3 + WHERE EXISTS( + SELECT ref_3."varchar" AS c3)) AS subq_1 + ON ((subq_1.c7 ~~ (SELECT "varchar" FROM all_types))) +-- +ok +== diff --git a/parser/testdata/corpus/fuzzer/sqlsmith/test_abs_overflow.test b/parser/testdata/corpus/fuzzer/sqlsmith/test_abs_overflow.test new file mode 100644 index 0000000..af48b25 --- /dev/null +++ b/parser/testdata/corpus/fuzzer/sqlsmith/test_abs_overflow.test @@ -0,0 +1,17 @@ +# source: test/fuzzer/sqlsmith/test_abs_overflow.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +CREATE TABLE numerics AS SELECT tinyint, smallint, int, bigint, hugeint FROM test_all_types(); +-- +ok +== +SELECT abs({type}) FROM numerics; +-- +error: Parser Error: syntax error at or near "}" +== +SELECT abs({type}) FROM numerics WHERE {type} > 0; +-- +error: Parser Error: syntax error at or near "}" +== diff --git a/parser/testdata/corpus/fuzzer/sqlsmith/timestamp_diff_overflow.test b/parser/testdata/corpus/fuzzer/sqlsmith/timestamp_diff_overflow.test new file mode 100644 index 0000000..d0c5866 --- /dev/null +++ b/parser/testdata/corpus/fuzzer/sqlsmith/timestamp_diff_overflow.test @@ -0,0 +1,30 @@ +# source: test/fuzzer/sqlsmith/timestamp_diff_overflow.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +CREATE TABLE ts("timestamp" TIMESTAMP);; +-- +ok +== +INSERT INTO ts VALUES('290309-12-22 (BC) 00:00:00'); +-- +ok +== +INSERT INTO ts VALUES('294247-01-10 04:00:54.775806'); +-- +ok +== +INSERT INTO ts VALUES(NULL); +-- +ok +== +select + subtract( + cast(now() as timestamp), + cast(ref_0.timestamp as timestamp)) as c10 +from + ts as ref_0 +-- +ok +== diff --git a/parser/testdata/corpus/fuzzer/sqlsmith/timestamp_overflow.test b/parser/testdata/corpus/fuzzer/sqlsmith/timestamp_overflow.test new file mode 100644 index 0000000..891ac20 --- /dev/null +++ b/parser/testdata/corpus/fuzzer/sqlsmith/timestamp_overflow.test @@ -0,0 +1,13 @@ +# source: test/fuzzer/sqlsmith/timestamp_overflow.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +SELECT c15 +FROM + all_types AS t41(c1, c2, c3, c4, c5, c6, c7, c8, c9, c10, c11, c12, c13, c14, c15, c16, c17, c18, c19, c20, c21, c22, c23, c24, c25, c26, c27, c28, c29, c30, c31, c32, c33, c34, c35, c36, c37, c38, c39, c40) +FULL JOIN + (SELECT NULL) ON (list_mad(c35)) +-- +ok +== diff --git a/parser/testdata/corpus/fuzzer/sqlsmith/timestamptz_double_cast.test b/parser/testdata/corpus/fuzzer/sqlsmith/timestamptz_double_cast.test new file mode 100644 index 0000000..084f1fc --- /dev/null +++ b/parser/testdata/corpus/fuzzer/sqlsmith/timestamptz_double_cast.test @@ -0,0 +1,19 @@ +# source: test/fuzzer/sqlsmith/timestamptz_double_cast.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +SELECT + arg_min(CAST(ref_0.timestamp_tz AS TIMESTAMP WITH TIME ZONE), + CAST(make_timestamptz( + CAST(ref_0."bigint" AS BIGINT), + CAST(ref_0."bigint" AS BIGINT), + CAST(ref_0."bigint" AS BIGINT), + CAST(ref_0."bigint" AS BIGINT), + CAST(txid_current() AS BIGINT), + CAST(ref_0."bigint" AS BIGINT)) AS TIMESTAMP WITH TIME ZONE)) + OVER (PARTITION BY ref_0."smallint" ORDER BY ref_0.int_array) AS c2 +FROM main.all_types AS ref_0 +-- +ok +== diff --git a/parser/testdata/corpus/fuzzer/sqlsmith/timestamptz_null_range.test b/parser/testdata/corpus/fuzzer/sqlsmith/timestamptz_null_range.test new file mode 100644 index 0000000..3eaa7be --- /dev/null +++ b/parser/testdata/corpus/fuzzer/sqlsmith/timestamptz_null_range.test @@ -0,0 +1,14 @@ +# source: test/fuzzer/sqlsmith/timestamptz_null_range.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +SELECT NULL FROM ( + SELECT 4767 + FROM generate_series(CAST('290309-12-22 (BC) 00:00:00+00' AS TIMESTAMP WITH TIME ZONE), NULL, NULL) + AS t6(c1, c2, c3, c4, c5) + ) + AS t64 +-- +ok +== diff --git a/parser/testdata/corpus/fuzzer/sqlsmith/validity_mask_out_of_bounds.test b/parser/testdata/corpus/fuzzer/sqlsmith/validity_mask_out_of_bounds.test new file mode 100644 index 0000000..d443995 --- /dev/null +++ b/parser/testdata/corpus/fuzzer/sqlsmith/validity_mask_out_of_bounds.test @@ -0,0 +1,21 @@ +# source: test/fuzzer/sqlsmith/validity_mask_out_of_bounds.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +CREATE TABLE all_types(struct_of_arrays STRUCT(a INTEGER[], b VARCHAR[]), "smallint" SMALLINT);; +-- +ok +== +INSERT INTO all_types VALUES({'a': NULL, 'b': NULL}, -32768); +-- +ok +== +INSERT INTO all_types VALUES({'a': [42, 999, NULL, NULL, -42], 'b': ['🦆🦆🦆🦆🦆🦆', 'goose', NULL, ]}, 32767); +-- +ok +== +SELECT ref_2.struct_of_arrays AS c3 FROM main.all_types AS ref_0 RIGHT JOIN main.all_types AS ref_1 INNER JOIN main.all_types AS ref_2 ON (ref_1."smallint" = ref_2."smallint") ON (NULL) +-- +ok +== diff --git a/parser/testdata/corpus/fuzzer/sqlsmith/window-leadlag-overflow.test b/parser/testdata/corpus/fuzzer/sqlsmith/window-leadlag-overflow.test new file mode 100644 index 0000000..65cc7fd --- /dev/null +++ b/parser/testdata/corpus/fuzzer/sqlsmith/window-leadlag-overflow.test @@ -0,0 +1,17 @@ +# source: test/fuzzer/sqlsmith/window-leadlag-overflow.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +WITH all_types AS ( + select * exclude(small_enum, medium_enum, large_enum) from test_all_types() +) +SELECT lag(c16, COLUMNS(*)) OVER (ROWS BETWEEN 1768 FOLLOWING AND UNBOUNDED FOLLOWING) +FROM all_types AS t42(c1, c2, c3, c4, c5, c6, c7, c8, c9, c10, c11, c12, c13, c14, c15, c16, c17, c18, c19, c20, c21, c22, c23, c24, c25, c26, c27, c28, c29, c30, c31, c32, c33, c34, c35, c36, c37, c38, c39, c40, c41) +-- +ok +== +SELECT lead('1e668c84-6cbc-4d41-843e-970c17446f9e', 8479, 3087) OVER (PARTITION BY 9136) +-- +ok +== diff --git a/parser/testdata/corpus/fuzzer/sqlsmith/window-list-value.test b/parser/testdata/corpus/fuzzer/sqlsmith/window-list-value.test new file mode 100644 index 0000000..2f20840 --- /dev/null +++ b/parser/testdata/corpus/fuzzer/sqlsmith/window-list-value.test @@ -0,0 +1,16 @@ +# source: test/fuzzer/sqlsmith/window-list-value.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +create table all_types as select * exclude(small_enum, medium_enum, large_enum) +from test_all_types(); +-- +ok +== +SELECT first_value(c40) OVER (PARTITION BY c42 ROWS BETWEEN COALESCE(#4, 0) FOLLOWING AND UNBOUNDED FOLLOWING) +FROM all_types AS t42(c1, c2, c3, c4, c5, c6, c7, c8, c9, c10, c11, c12, c13, c14, c15, c16, c17, c18, c19, c20, c21, c22, c23, c24, c25, c26, c27, c28, c29, c30, c31, c32, c33, c34, c35, c36, c37, c38, c39, c40, c41, c42) +ORDER BY ALL +-- +ok +== diff --git a/parser/testdata/corpus/fuzzer/sqlsmith/window-rows-overflow.test b/parser/testdata/corpus/fuzzer/sqlsmith/window-rows-overflow.test new file mode 100644 index 0000000..adce6f4 --- /dev/null +++ b/parser/testdata/corpus/fuzzer/sqlsmith/window-rows-overflow.test @@ -0,0 +1,51 @@ +# source: test/fuzzer/sqlsmith/window-rows-overflow.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +create table all_types as + select * exclude( + small_enum, + medium_enum, + large_enum, + ) +from test_all_types(); +-- +ok +== +SELECT nth_value(1929, 42) OVER ( + PARTITION BY ( + "usmallint" > "smallint" + ), 747 ROWS BETWEEN COALESCE("bigint", 0) PRECEDING AND CURRENT ROW +) +FROM all_types; +-- +ok +== +SELECT nth_value(1929, 42) OVER ( + PARTITION BY ( + "usmallint" > "smallint" + ), 747 ROWS BETWEEN 1 PRECEDING AND COALESCE("bigint", 0) PRECEDING +) +FROM all_types; +-- +ok +== +SELECT nth_value(1929, 42) OVER ( + PARTITION BY ( + "usmallint" > "smallint" + ), 747 ROWS BETWEEN COALESCE("bigint", 0) FOLLOWING AND 1 FOLLOWING +) +FROM all_types; +-- +ok +== +SELECT nth_value(1929, 42) OVER ( + PARTITION BY ( + "usmallint" > "smallint" + ), 747 ROWS BETWEEN CURRENT ROW AND COALESCE("bigint", 0) FOLLOWING +) +FROM all_types; +-- +ok +== diff --git a/parser/testdata/corpus/fuzzer/sqlsmith/window_function_error.test b/parser/testdata/corpus/fuzzer/sqlsmith/window_function_error.test new file mode 100644 index 0000000..2ab3bc5 --- /dev/null +++ b/parser/testdata/corpus/fuzzer/sqlsmith/window_function_error.test @@ -0,0 +1,14 @@ +# source: test/fuzzer/sqlsmith/window_function_error.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +CREATE TABLE tbl AS SELECT 'thisisastring42' AS r_name; +-- +ok +== +SELECT max(CAST(from_hex(CAST(ref_0.r_name AS VARCHAR)) AS BLOB)) OVER (ORDER BY ref_0.r_name) AS c5, +FROM tbl AS ref_0 +-- +ok +== diff --git a/parser/testdata/corpus/fuzzer/sqlsmith/window_scalar_range.test b/parser/testdata/corpus/fuzzer/sqlsmith/window_scalar_range.test new file mode 100644 index 0000000..311fbe1 --- /dev/null +++ b/parser/testdata/corpus/fuzzer/sqlsmith/window_scalar_range.test @@ -0,0 +1,23 @@ +# source: test/fuzzer/sqlsmith/window_scalar_range.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +CREATE TABLE partsupp AS SELECT (random() * 100)::INT AS c2 +FROM range(8000); +-- +ok +== +SELECT percent_rank() + OVER (ORDER BY 7543 ASC NULLS FIRST + RANGE BETWEEN c2 PRECEDING AND c2 FOLLOWING) +FROM partsupp; +-- +ok +== +SELECT NULL +FROM all_types AS t51(c1, c2, c3, c4, c5, c6, c7, c8, c9, c10, c11, c12, c13, c14, c15, c16, c17, c18, c19, c20, c21, c22, c23, c24, c25, c26, c27, c28, c29, c30, c31, c32, c33, c34, c35, c36, c37, c38, c39, c40, c41, c42, c43, c44, c45, c46, c47, c48, c49, c50, c51) +QUALIFY row_number() OVER (ORDER BY main.list_value() ASC NULLS FIRST RANGE BETWEEN c46 FOLLOWING AND UNBOUNDED FOLLOWING) +-- +ok +== diff --git a/parser/testdata/corpus/sql/aggregate/aggregate_state_export/approx_quantile_export_state.test b/parser/testdata/corpus/sql/aggregate/aggregate_state_export/approx_quantile_export_state.test new file mode 100644 index 0000000..1e66523 --- /dev/null +++ b/parser/testdata/corpus/sql/aggregate/aggregate_state_export/approx_quantile_export_state.test @@ -0,0 +1,82 @@ +# source: test/sql/aggregate/aggregate_state_export/approx_quantile_export_state.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +SELECT approx_quantile(i, 0.5) EXPORT_STATE FROM (SELECT 1 AS i WHERE false) t; +-- +ok +== +SELECT finalize(approx_quantile(i, 0.5) EXPORT_STATE) FROM (SELECT 1 AS i WHERE false) t; +-- +ok +== +SELECT finalize(approx_quantile(i, 0.5) EXPORT_STATE) = approx_quantile(i, 0.5) FROM range(1, 10001) t(i); +-- +ok +== +SELECT finalize(approx_quantile(i, [0.1, 0.5, 0.9]) EXPORT_STATE) = approx_quantile(i, [0.1, 0.5, 0.9]) FROM range(1, 10001) t(i); +-- +ok +== +SELECT finalize(approx_quantile(d, 0.5) EXPORT_STATE) = approx_quantile(d, 0.5) FROM (SELECT range / 100.0 AS d FROM range(1000)) t; +-- +ok +== +SELECT finalize(approx_quantile(ts, 0.5) EXPORT_STATE) = approx_quantile(ts, 0.5) FROM (SELECT TIMESTAMP '2000-01-01' + INTERVAL (range) DAY AS ts FROM range(100)) t; +-- +ok +== +SELECT finalize(approx_quantile(d, 0.5) EXPORT_STATE) = approx_quantile(d, 0.5) FROM (VALUES (1.5::DECIMAL(4,1)), (4.5::DECIMAL(4,1)), (2.5::DECIMAL(4,1))) t(d); +-- +ok +== +SELECT s."count", s."min", s."max" FROM ( + SELECT (approx_quantile(i, 0.5) EXPORT_STATE)::STRUCT("count" UBIGINT, "min" DOUBLE, "max" DOUBLE, centroids STRUCT(mean DOUBLE, weight DOUBLE)[]) s + FROM range(1, 101) t(i) +) t; +-- +ok +== +CREATE TABLE dummy AS SELECT range % 10 g, range d FROM range(1000); +-- +ok +== +SELECT g, approx_quantile(d, 0.5) FROM dummy GROUP BY g ORDER BY g; +-- +ok +== +SELECT g, finalize(approx_quantile(d, 0.5) EXPORT_STATE) FROM dummy GROUP BY g ORDER BY g; +-- +ok +== +CREATE TABLE approx_state AS SELECT g, approx_quantile(d, 0.5) EXPORT_STATE s FROM dummy GROUP BY g; +-- +ok +== +SELECT g, finalize(s) FROM approx_state ORDER BY g; +-- +ok +== +SELECT finalize(combine_aggr(s)) FROM ( + SELECT approx_quantile(i, 0.5) EXPORT_STATE AS s FROM range(1, 500) t(i) + UNION ALL + SELECT approx_quantile(i, 0.5) EXPORT_STATE AS s FROM range(500, 1001) t(i) + UNION ALL + SELECT approx_quantile(i, 0.5) EXPORT_STATE AS s FROM (SELECT 1 AS i WHERE false) t +) t; +-- +ok +== +SELECT finalize(combine(approx_quantile(i, 0.5) EXPORT_STATE, (SELECT approx_quantile(j, 0.5) EXPORT_STATE FROM range(500, 1001) s(j)))) FROM range(1, 500) t(i); +-- +ok +== +SELECT finalize(to_aggregate_state( + {'count': 1::UBIGINT, 'min': 0.0::DOUBLE, 'max': 0.0::DOUBLE, + 'centroids': []::STRUCT(mean DOUBLE, weight DOUBLE)[]}, + 'approx_quantile', ['DOUBLE', 'FLOAT'], [NULL, 0.5::FLOAT] +)); +-- +ok +== diff --git a/parser/testdata/corpus/sql/aggregate/aggregate_state_export/approx_top_k_export_state.test b/parser/testdata/corpus/sql/aggregate/aggregate_state_export/approx_top_k_export_state.test new file mode 100644 index 0000000..d2ce1a7 --- /dev/null +++ b/parser/testdata/corpus/sql/aggregate/aggregate_state_export/approx_top_k_export_state.test @@ -0,0 +1,91 @@ +# source: test/sql/aggregate/aggregate_state_export/approx_top_k_export_state.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +SET threads=1; +-- +ok +== +SELECT approx_top_k(x, 3) EXPORT_STATE FROM (SELECT 'a' AS x WHERE false) t; +-- +ok +== +SELECT finalize(approx_top_k(x, 3) EXPORT_STATE) FROM (SELECT 'a' AS x WHERE false) t; +-- +ok +== +SELECT approx_top_k(x, 2), approx_top_k(x, 1) FROM (VALUES ('a'), ('a'), ('b'), ('a'), ('c'), ('b')) t(x); +-- +ok +== +SELECT finalize(approx_top_k(x, 2) EXPORT_STATE), finalize(approx_top_k(x, 1) EXPORT_STATE) FROM (VALUES ('a'), ('a'), ('b'), ('a'), ('c'), ('b')) t(x); +-- +ok +== +SELECT (approx_top_k(x, 2) EXPORT_STATE)::STRUCT(k UBIGINT, "values" STRUCT("value" INTEGER, "count" UBIGINT)[], "filter" UBIGINT[])."values" FROM (VALUES (5), (5), (6)) t(x); +-- +ok +== +SELECT (approx_top_k(d, 1) EXPORT_STATE)::STRUCT(k UBIGINT, "values" STRUCT("value" DATE, "count" UBIGINT)[], "filter" UBIGINT[])."values" FROM (VALUES (DATE '2000-01-01'), (DATE '2000-01-01')) t(d); +-- +ok +== +SELECT approx_top_k(x, 2), approx_top_k(d, 2) FROM (VALUES (5, DATE '2000-01-01'), (5, DATE '2000-01-01'), (6, DATE '2010-01-01'), (5, DATE '2000-01-01')) t(x, d); +-- +ok +== +SELECT finalize(approx_top_k(x, 2) EXPORT_STATE), finalize(approx_top_k(d, 2) EXPORT_STATE) FROM (VALUES (5, DATE '2000-01-01'), (5, DATE '2000-01-01'), (6, DATE '2010-01-01'), (5, DATE '2000-01-01')) t(x, d); +-- +ok +== +SELECT finalize(approx_top_k(l, 2) EXPORT_STATE) FROM (VALUES ([1, 2]), ([1, 2]), ([3])) t(l); +-- +ok +== +SELECT (approx_top_k(x, 1) EXPORT_STATE)::STRUCT(k UBIGINT, "values" STRUCT("value" VARCHAR, "count" UBIGINT)[], "filter" UBIGINT[]).k FROM (VALUES ('a'), ('a'), ('b')) t(x); +-- +ok +== +SELECT (approx_top_k(x, 1) EXPORT_STATE)::STRUCT(k UBIGINT, "values" STRUCT("value" VARCHAR, "count" UBIGINT)[], "filter" UBIGINT[])."values" FROM (VALUES ('a'), ('a'), ('b')) t(x); +-- +ok +== +CREATE TABLE dummy AS SELECT range % 10 g, 'val' || (range % 3)::VARCHAR v FROM range(100); +-- +ok +== +SELECT g, approx_top_k(v, 2) FROM dummy GROUP BY g ORDER BY g; +-- +ok +== +SELECT g, finalize(approx_top_k(v, 2) EXPORT_STATE) FROM dummy GROUP BY g ORDER BY g; +-- +ok +== +CREATE TABLE topk_state AS SELECT g, approx_top_k(v, 2) EXPORT_STATE s FROM dummy GROUP BY g; +-- +ok +== +SELECT g, finalize(s) FROM topk_state ORDER BY g; +-- +ok +== +SELECT finalize(combine(approx_top_k(x, 2) EXPORT_STATE, (SELECT approx_top_k(y, 2) EXPORT_STATE FROM (VALUES ('a'), ('c')) s(y)))) FROM (VALUES ('a'), ('b'), ('a')) t(x); +-- +ok +== +SELECT finalize(combine_aggr(s)) FROM ( + SELECT approx_top_k(x, 3) EXPORT_STATE AS s FROM (VALUES ('a'), ('b'), ('a')) t(x) + UNION ALL + SELECT approx_top_k(x, 3) EXPORT_STATE AS s FROM (VALUES ('a'), ('c')) t(x) + UNION ALL + SELECT approx_top_k(x, 3) EXPORT_STATE AS s FROM (SELECT 'a' AS x WHERE false) t +) t; +-- +ok +== +SELECT finalize(combine(approx_top_k(x, 2) EXPORT_STATE, (SELECT approx_top_k(y, 3) EXPORT_STATE FROM (VALUES ('a')) s(y)))) FROM (VALUES ('a')) t(x); +-- +ok +== diff --git a/parser/testdata/corpus/sql/aggregate/aggregate_state_export/arg_min_max_export_state.test b/parser/testdata/corpus/sql/aggregate/aggregate_state_export/arg_min_max_export_state.test new file mode 100644 index 0000000..ffb43a2 --- /dev/null +++ b/parser/testdata/corpus/sql/aggregate/aggregate_state_export/arg_min_max_export_state.test @@ -0,0 +1,122 @@ +# source: test/sql/aggregate/aggregate_state_export/arg_min_max_export_state.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +SELECT arg_min(a, b) EXPORT_STATE FROM (SELECT 1 a, 1 b WHERE false) t; +-- +ok +== +SELECT finalize(arg_min(a, b) EXPORT_STATE) FROM (SELECT 1 a, 1 b WHERE false) t; +-- +ok +== +SELECT (arg_min(a, b) EXPORT_STATE)::STRUCT(arg INTEGER, "by" INTEGER) FROM (VALUES (1, 10), (2, 5), (3, 20)) t(a, b); +-- +ok +== +SELECT (arg_max(a, b) EXPORT_STATE)::STRUCT(arg INTEGER, "by" INTEGER) FROM (VALUES (1, 10), (2, 5), (3, 20)) t(a, b); +-- +ok +== +SELECT arg_min(a, b), arg_max(a, b) FROM (VALUES (1, 10), (2, 5), (3, 20)) t(a, b); +-- +ok +== +SELECT finalize(arg_min(a, b) EXPORT_STATE), finalize(arg_max(a, b) EXPORT_STATE) FROM (VALUES (1, 10), (2, 5), (3, 20)) t(a, b); +-- +ok +== +SELECT (arg_min_null(a, b) EXPORT_STATE)::STRUCT(arg INTEGER, "by" INTEGER) FROM (VALUES (NULL, 5), (2, 10)) t(a, b); +-- +ok +== +SELECT finalize(arg_min_null(a, b) EXPORT_STATE) FROM (VALUES (NULL, 5), (2, 10)) t(a, b); +-- +ok +== +SELECT finalize(arg_min(a, b) EXPORT_STATE), finalize(arg_max(a, b) EXPORT_STATE) +FROM (VALUES ('this-is-a-very-long-string-that-is-not-inlined', 'bbb'), ('apple', 'aaa-also-a-very-long-string')) t(a, b); +-- +ok +== +SELECT (arg_min(a, b) EXPORT_STATE)::STRUCT(arg VARCHAR, "by" VARCHAR) FROM (VALUES ('a-long-string-that-is-not-inlined', 'x')) t(a, b); +-- +ok +== +SELECT (arg_min(a, b) EXPORT_STATE)::STRUCT(arg STRUCT(x INTEGER), "by" INTEGER) FROM (VALUES ({'x': 1}, 10), ({'x': 2}, 5)) t(a, b); +-- +ok +== +SELECT finalize(arg_min(a, b) EXPORT_STATE) FROM (VALUES ([1, 2], 10), ([3], 5)) t(a, b); +-- +ok +== +SELECT (arg_min(a, b) EXPORT_STATE)::STRUCT(arg INTEGER[], "by" INTEGER[]) FROM (VALUES ([1, 2], [10]), ([3], [5])) t(a, b); +-- +ok +== +SELECT finalize(arg_max(a, b) EXPORT_STATE) FROM (VALUES ([1, 2], [10]), ([3], [5])) t(a, b); +-- +ok +== +CREATE TABLE dummy AS SELECT range % 10 g, range d FROM range(100); +-- +ok +== +SELECT g, arg_min(d, d % 7), arg_max(d, d % 7) FROM dummy GROUP BY g ORDER BY g; +-- +ok +== +SELECT g, finalize(arg_min(d, d % 7) EXPORT_STATE), finalize(arg_max(d, d % 7) EXPORT_STATE) FROM dummy GROUP BY g ORDER BY g; +-- +ok +== +CREATE TABLE argminmax_state AS SELECT g, arg_min(d, d % 7) EXPORT_STATE mn, arg_max(d, d % 7) EXPORT_STATE mx FROM dummy GROUP BY g; +-- +ok +== +SELECT g, finalize(mn), finalize(mx) FROM argminmax_state ORDER BY g; +-- +ok +== +SELECT finalize(combine_aggr(s)) FROM ( + SELECT arg_min(a, b) EXPORT_STATE AS s FROM (VALUES (1, 10), (2, 5)) t(a, b) + UNION ALL + SELECT arg_min(a, b) EXPORT_STATE AS s FROM (VALUES (3, 1)) t(a, b) + UNION ALL + SELECT arg_min(a, b) EXPORT_STATE AS s FROM (SELECT 1 a, 1 b WHERE false) t +) t; +-- +ok +== +SELECT finalize(to_aggregate_state(NULL::STRUCT(arg INTEGER, "by" INTEGER), 'arg_min', ['INTEGER', 'INTEGER'])); +-- +ok +== +SELECT finalize(to_aggregate_state({'arg': 42, 'by': 1}::STRUCT(arg INTEGER, "by" INTEGER), 'arg_min', ['INTEGER', 'INTEGER'])); +-- +ok +== +SELECT finalize(combine( + to_aggregate_state({'arg': 42, 'by': 5}::STRUCT(arg INTEGER, "by" INTEGER), 'arg_min', ['INTEGER', 'INTEGER']), + to_aggregate_state({'arg': 84, 'by': 1}::STRUCT(arg INTEGER, "by" INTEGER), 'arg_min', ['INTEGER', 'INTEGER']))); +-- +ok +== +SELECT typeof((arg_min(v, v) EXPORT_STATE)::STRUCT(arg BLOB, "by" BLOB)) FROM (VALUES ('\xAA\xBB'::BLOB)) t(v); +-- +ok +== +SELECT (arg_min(d, b) EXPORT_STATE)::STRUCT(arg DATE, "by" DATE) FROM (VALUES (DATE '2000-01-01', DATE '2010-01-01')) t(d, b); +-- +ok +== +SELECT arg_min(COLUMNS(*), COLUMNS(*)) EXPORT_STATE FROM test_all_types(); +-- +ok +== +SELECT list_bool_and([*COLUMNS(*)]) FROM (SELECT finalize(arg_min(COLUMNS(*), COLUMNS(*)) EXPORT_STATE) = min(COLUMNS(*)) FROM test_all_types()); +-- +ok +== diff --git a/parser/testdata/corpus/sql/aggregate/aggregate_state_export/bool_and_export_state.test b/parser/testdata/corpus/sql/aggregate/aggregate_state_export/bool_and_export_state.test new file mode 100644 index 0000000..acb8666 --- /dev/null +++ b/parser/testdata/corpus/sql/aggregate/aggregate_state_export/bool_and_export_state.test @@ -0,0 +1,81 @@ +# source: test/sql/aggregate/aggregate_state_export/bool_and_export_state.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +SELECT bool_and(NULL) EXPORT_STATE +-- +ok +== +SELECT finalize(bool_and(NULL) EXPORT_STATE) +-- +ok +== +SELECT bool_and(v) EXPORT_STATE FROM (VALUES (true), (true), (true)) t(v) +-- +ok +== +SELECT bool_and(v) EXPORT_STATE FROM (VALUES (true), (false), (true)) t(v) +-- +ok +== +SELECT bool_and(v) EXPORT_STATE FROM (VALUES (NULL::bool)) t(v) +-- +ok +== +SELECT finalize(bool_and(v) EXPORT_STATE) FROM (VALUES (true), (true)) t(v) +-- +ok +== +SELECT finalize(bool_and(v) EXPORT_STATE) FROM (VALUES (true), (false)) t(v) +-- +ok +== +SELECT finalize(bool_and(v) EXPORT_STATE) FROM (VALUES (NULL::bool)) t(v) +-- +ok +== +SELECT finalize(combine_aggr(s)) FROM ( + SELECT bool_and(v) EXPORT_STATE AS s FROM (VALUES (true), (true)) t(v) + UNION ALL + SELECT bool_and(NULL) EXPORT_STATE AS s +) +-- +ok +== +SELECT finalize(combine_aggr(s)) FROM ( + SELECT bool_and(v) EXPORT_STATE AS s FROM (VALUES (true), (true)) t(v) + UNION ALL + SELECT bool_and(v) EXPORT_STATE AS s FROM (VALUES (false)) t(v) +) +-- +ok +== +SELECT finalize(combine_aggr(s)) FROM ( + SELECT bool_and(v) EXPORT_STATE AS s FROM (VALUES (NULL::bool)) t(v) + UNION ALL + SELECT bool_and(v) EXPORT_STATE AS s FROM (VALUES (true)) t(v) +) +-- +ok +== +SELECT bool_or(v) EXPORT_STATE FROM (VALUES (false), (false)) t(v) +-- +ok +== +SELECT bool_or(v) EXPORT_STATE FROM (VALUES (false), (true)) t(v) +-- +ok +== +SELECT bool_or(v) EXPORT_STATE FROM (VALUES (NULL::bool)) t(v) +-- +ok +== +SELECT finalize(combine_aggr(s)) FROM ( + SELECT bool_or(v) EXPORT_STATE AS s FROM (VALUES (false)) t(v) + UNION ALL + SELECT bool_or(v) EXPORT_STATE AS s FROM (VALUES (true)) t(v) +) +-- +ok +== diff --git a/parser/testdata/corpus/sql/aggregate/aggregate_state_export/count_export_state.test b/parser/testdata/corpus/sql/aggregate/aggregate_state_export/count_export_state.test new file mode 100644 index 0000000..9f77cb3 --- /dev/null +++ b/parser/testdata/corpus/sql/aggregate/aggregate_state_export/count_export_state.test @@ -0,0 +1,17 @@ +# source: test/sql/aggregate/aggregate_state_export/count_export_state.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +SELECT COUNT(*) export_state +-- +ok +== +SELECT COUNT(*) export_state FROM range(10); +-- +ok +== +SELECT finalize(combine_aggr(s)) from (select COUNT(*) export_state AS s FROM range(10) union all select count(*) export_state AS s from range(5)); +-- +ok +== diff --git a/parser/testdata/corpus/sql/aggregate/aggregate_state_export/first_last_export_state.test b/parser/testdata/corpus/sql/aggregate/aggregate_state_export/first_last_export_state.test new file mode 100644 index 0000000..6b5e2ec --- /dev/null +++ b/parser/testdata/corpus/sql/aggregate/aggregate_state_export/first_last_export_state.test @@ -0,0 +1,126 @@ +# source: test/sql/aggregate/aggregate_state_export/first_last_export_state.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +SELECT first(i) EXPORT_STATE FROM (SELECT 1 AS i WHERE false) t; +-- +ok +== +SELECT finalize(first(i) EXPORT_STATE) FROM (SELECT 1 AS i WHERE false) t; +-- +ok +== +SELECT (first(NULL::INTEGER) EXPORT_STATE)::STRUCT(value INTEGER); +-- +ok +== +SELECT finalize(first(NULL::INTEGER) EXPORT_STATE); +-- +ok +== +SELECT (first(42) EXPORT_STATE)::STRUCT(value INTEGER); +-- +ok +== +SELECT finalize(first(42) EXPORT_STATE); +-- +ok +== +SELECT any_value(NULL::INTEGER) EXPORT_STATE; +-- +ok +== +SELECT (any_value(DATE '2000-01-01') EXPORT_STATE)::STRUCT(value DATE); +-- +ok +== +SELECT (last(d) EXPORT_STATE)::STRUCT(value DECIMAL(4,1)) FROM (VALUES (1.5), (4.2)) t(d); +-- +ok +== +SELECT finalize(first(i) EXPORT_STATE), finalize(last(i) EXPORT_STATE), finalize(any_value(i) EXPORT_STATE) +FROM (VALUES (NULL), (1), (2), (3)) t(i); +-- +ok +== +SELECT finalize(first(v) EXPORT_STATE), finalize(last(v) EXPORT_STATE) +FROM (VALUES ('this-is-a-very-long-string-that-is-not-inlined'), ('apple'), ('this-is-another-very-long-string')) t(v); +-- +ok +== +SELECT (first('a-string-that-is-not-inlined-either') EXPORT_STATE)::STRUCT(value VARCHAR); +-- +ok +== +SELECT finalize(last(r::VARCHAR || '-padding-to-make-it-long') EXPORT_STATE) FROM range(1000) t(r); +-- +ok +== +SELECT finalize(first(s) EXPORT_STATE), finalize(last(s) EXPORT_STATE) +FROM (VALUES ({'a': 1, 'b': 'x'}), (NULL), ({'a': 2, 'b': NULL})) t(s); +-- +ok +== +SELECT (first([1, 2, 3]) EXPORT_STATE)::STRUCT(value INTEGER[]); +-- +ok +== +SELECT (first(NULL::INTEGER[]) EXPORT_STATE)::STRUCT(value INTEGER[]); +-- +ok +== +SELECT finalize(first(l) EXPORT_STATE) FROM (VALUES ([['a'], ['bb', NULL]]), ([[]])) t(l); +-- +ok +== +SELECT g, first(d), last(d), any_value(d) FROM dummy GROUP BY g ORDER BY g; +-- +ok +== +SELECT g, finalize(first(d) EXPORT_STATE), finalize(last(d) EXPORT_STATE), finalize(any_value(d) EXPORT_STATE) FROM dummy GROUP BY g ORDER BY g; +-- +ok +== +CREATE TABLE first_state AS SELECT g, first(d) EXPORT_STATE f, last(d) EXPORT_STATE l FROM dummy GROUP BY g; +-- +ok +== +SELECT g, first(d), last(d) FROM dummy GROUP BY g ORDER BY g; +-- +ok +== +SELECT g, finalize(f), finalize(l) FROM first_state ORDER BY g; +-- +ok +== +SELECT finalize(combine(first(i) EXPORT_STATE, (SELECT first(j) EXPORT_STATE FROM (SELECT 1 j WHERE false) s))) FROM (VALUES (42)) t(i); +-- +ok +== +SELECT finalize(combine_aggr(s)) FROM ( + SELECT first(v) EXPORT_STATE AS s FROM (VALUES (1), (2)) t(v) + UNION ALL + SELECT first(v) EXPORT_STATE AS s FROM (SELECT NULL::INTEGER AS v WHERE false) t +) t; +-- +ok +== +SELECT finalize(to_aggregate_state(NULL::STRUCT(value INTEGER), 'first', ['INTEGER'])); +-- +ok +== +SELECT finalize(to_aggregate_state({'value': NULL}::STRUCT(value INTEGER), 'first', ['INTEGER'])); +-- +ok +== +SELECT finalize(to_aggregate_state({'value': 42}::STRUCT(value INTEGER), 'first', ['INTEGER'])); +-- +ok +== +SELECT finalize(combine( + to_aggregate_state({'value': NULL}::STRUCT(value INTEGER), 'first', ['INTEGER']), + to_aggregate_state(NULL::STRUCT(value INTEGER), 'first', ['INTEGER']))); +-- +ok +== diff --git a/parser/testdata/corpus/sql/aggregate/aggregate_state_export/kahan_avg_export_state.test b/parser/testdata/corpus/sql/aggregate/aggregate_state_export/kahan_avg_export_state.test new file mode 100644 index 0000000..6aaf9dd --- /dev/null +++ b/parser/testdata/corpus/sql/aggregate/aggregate_state_export/kahan_avg_export_state.test @@ -0,0 +1,26 @@ +# source: test/sql/aggregate/aggregate_state_export/kahan_avg_export_state.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +CREATE TABLE kahan_context1 AS +SELECT unnest([9007199254740992.0, 1.0, 1.0, 1.0, 1.0]) as val; +-- +ok +== +CREATE TABLE kahan_context2 AS +SELECT unnest([9007199254740990.0, 2.0, 2.0, 2.0, 2.0]) as val; +-- +ok +== + SELECT + finalize(combine( + (SELECT favg(val) EXPORT_STATE FROM kahan_context1), + (SELECT favg(val) EXPORT_STATE FROM kahan_context2) + )) - + (SELECT favg(val) FROM ( + SELECT val FROM kahan_context1 UNION ALL SELECT val FROM kahan_context2 + )); +-- +ok +== diff --git a/parser/testdata/corpus/sql/aggregate/aggregate_state_export/legacy_aggregate_state.test b/parser/testdata/corpus/sql/aggregate/aggregate_state_export/legacy_aggregate_state.test new file mode 100644 index 0000000..172578e --- /dev/null +++ b/parser/testdata/corpus/sql/aggregate/aggregate_state_export/legacy_aggregate_state.test @@ -0,0 +1,13 @@ +# source: test/sql/aggregate/aggregate_state_export/legacy_aggregate_state.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +ATTACH '{TEST_DIR}/legacy_aggregate_state.db' AS legacy +-- +ok +== +FROM legacy.t +-- +ok +== diff --git a/parser/testdata/corpus/sql/aggregate/aggregate_state_export/list_export_state.test b/parser/testdata/corpus/sql/aggregate/aggregate_state_export/list_export_state.test new file mode 100644 index 0000000..9151c05 --- /dev/null +++ b/parser/testdata/corpus/sql/aggregate/aggregate_state_export/list_export_state.test @@ -0,0 +1,129 @@ +# source: test/sql/aggregate/aggregate_state_export/list_export_state.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +SELECT finalize(list(i) EXPORT_STATE) FROM (VALUES (1), (2), (3)) t(i); +-- +ok +== +SELECT list(i) EXPORT_STATE FROM (VALUES (1), (2), (3)) t(i); +-- +ok +== +SELECT (list(42) EXPORT_STATE)::INTEGER[]; +-- +ok +== +SELECT finalize(list(i) EXPORT_STATE) FROM (VALUES (1), (NULL), (3)) t(i); +-- +ok +== +SELECT finalize(list(NULL::INTEGER) EXPORT_STATE); +-- +ok +== +SELECT list(i) EXPORT_STATE FROM (SELECT NULL::INTEGER AS i WHERE false) t; +-- +ok +== +SELECT finalize(list(i) EXPORT_STATE) FROM (SELECT NULL::INTEGER AS i WHERE false) t; +-- +ok +== +SELECT finalize(list(v) EXPORT_STATE) FROM (VALUES ('apple'), ('this-is-a-very-long-string-that-is-not-inlined'), (NULL), ('')) t(v); +-- +ok +== +SELECT finalize(list(l) EXPORT_STATE) FROM (VALUES ([1, 2]), ([]), (NULL), ([3])) t(l); +-- +ok +== +SELECT finalize(list(l) EXPORT_STATE) FROM (VALUES ([['a'], ['bb-cc-dd-ee-ff-gg-hh', NULL]]), ([[]]), ([NULL])) t(l); +-- +ok +== +SELECT finalize(list(s) EXPORT_STATE) FROM (VALUES ({'a': 1, 'b': 'x'}), (NULL), ({'a': 2, 'b': NULL})) t(s); +-- +ok +== +SELECT finalize(list(s) EXPORT_STATE) FROM (VALUES ({'l': [1, 2], 'v': 'abc'}), ({'l': NULL, 'v': NULL})) t(s); +-- +ok +== +SELECT finalize(list(a) EXPORT_STATE) FROM (VALUES ([1, 2, 3]::INTEGER[3]), ([4, 5, 6]::INTEGER[3])) t(a); +-- +ok +== +SELECT finalize(list(m) EXPORT_STATE) FROM (VALUES (MAP {'k': 1}), (MAP {})) t(m); +-- +ok +== +SELECT len(l), list_aggregate(l, 'sum') FROM (SELECT finalize(list(r) EXPORT_STATE) l FROM range(1000) t(r)); +-- +ok +== +SELECT g, list_sort(list(d)) FROM dummy GROUP BY g ORDER BY g; +-- +ok +== +SELECT g, list_sort(finalize(list(d) EXPORT_STATE)) FROM dummy GROUP BY g ORDER BY g; +-- +ok +== +CREATE TABLE list_state AS SELECT g, list(d) EXPORT_STATE l FROM dummy GROUP BY g; +-- +ok +== +SELECT g, list_sort(finalize(l)) FROM list_state ORDER BY g; +-- +ok +== +SELECT list_sort(finalize(combine(list(i) EXPORT_STATE, (SELECT list(j) EXPORT_STATE FROM (VALUES (3), (4)) s(j))))) FROM (VALUES (1), (2)) t(i); +-- +ok +== +SELECT finalize(combine(list(i) EXPORT_STATE, (SELECT list(j) EXPORT_STATE FROM (SELECT NULL::INTEGER j WHERE false) s))) FROM (VALUES (1), (2)) t(i); +-- +ok +== +SELECT finalize(combine(l, l)) FROM (SELECT list(i) EXPORT_STATE l FROM (SELECT NULL::INTEGER AS i WHERE false) t) s; +-- +ok +== +SELECT list_sort(finalize(combine_aggr(s))) FROM ( + SELECT list(v) EXPORT_STATE AS s FROM (VALUES (1), (2)) t(v) + UNION ALL + SELECT list(v) EXPORT_STATE AS s FROM (VALUES (3), (4)) t(v) +) t; +-- +ok +== +SELECT list_sort(finalize(combine_aggr(s))) FROM ( + SELECT list(v) EXPORT_STATE AS s FROM (VALUES (1), (2)) t(v) + UNION ALL + SELECT list(v) EXPORT_STATE AS s FROM (SELECT NULL::INTEGER AS v WHERE false) t +) t; +-- +ok +== +SELECT list_sort(finalize(combine_aggr(s))) FROM ( + SELECT list(v) EXPORT_STATE AS s FROM (VALUES ([1, 2]), ([NULL])) t(v) + UNION ALL + SELECT list(v) EXPORT_STATE AS s FROM (VALUES ([]::INTEGER[]), ([3])) t(v) +) t; +-- +ok +== +SELECT finalize(to_aggregate_state([1, 2, 3], 'list', ['INTEGER'])); +-- +ok +== +SELECT finalize(combine(to_aggregate_state([1, 2], 'list', ['INTEGER']), to_aggregate_state([3], 'list', ['INTEGER']))); +-- +ok +== +SELECT list_bool_and([*columns(*)]) = true FROM (SELECT finalize(list(columns(*)) EXPORT_STATE) IS NOT DISTINCT FROM list(columns(*)) FROM test_all_types()); +-- +ok +== diff --git a/parser/testdata/corpus/sql/aggregate/aggregate_state_export/minmax_export_state.test b/parser/testdata/corpus/sql/aggregate/aggregate_state_export/minmax_export_state.test new file mode 100644 index 0000000..0d9247a --- /dev/null +++ b/parser/testdata/corpus/sql/aggregate/aggregate_state_export/minmax_export_state.test @@ -0,0 +1,85 @@ +# source: test/sql/aggregate/aggregate_state_export/minmax_export_state.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +SELECT min(v) EXPORT_STATE FROM (SELECT NULL::varchar AS v WHERE false) t; +-- +ok +== +SELECT max(v) EXPORT_STATE FROM (SELECT NULL::varchar AS v WHERE false) t; +-- +ok +== +SELECT min(NULL::varchar) EXPORT_STATE; +-- +ok +== +SELECT min(v) EXPORT_STATE FROM (VALUES ('banana'), ('apple'), ('cherry')) t(v); +-- +ok +== +SELECT max(v) EXPORT_STATE FROM (VALUES ('banana'), ('apple'), ('cherry')) t(v); +-- +ok +== +SELECT min(v) EXPORT_STATE FROM (VALUES ('long-string-banana'), ('long-string-apple'), ('long-string-cherry')) t(v); +-- +ok +== +SELECT max(v) EXPORT_STATE FROM (VALUES ('long-string-banana'), ('long-string-apple'), ('long-string-cherry')) t(v); +-- +ok +== +SELECT finalize(combine(min('apple'::varchar) EXPORT_STATE, min('cherry'::varchar) EXPORT_STATE)); +-- +ok +== +SELECT finalize(combine(max('apple'::varchar) EXPORT_STATE, max('cherry'::varchar) EXPORT_STATE)); +-- +ok +== +SELECT finalize(combine_aggr(s)) FROM ( + SELECT min(v) EXPORT_STATE AS s FROM (VALUES ('banana'), ('apple')) t(v) + UNION ALL + SELECT min(v) EXPORT_STATE AS s FROM (VALUES ('cherry'), ('avocado')) t(v) +) t; +-- +ok +== +SELECT finalize(combine_aggr(s)) FROM ( + SELECT max(v) EXPORT_STATE AS s FROM (VALUES ('banana'), ('apple')) t(v) + UNION ALL + SELECT max(v) EXPORT_STATE AS s FROM (VALUES ('cherry'), ('avocado')) t(v) +) t; +-- +ok +== +SELECT finalize(combine_aggr(s)) FROM ( + SELECT min(v) EXPORT_STATE AS s FROM (VALUES ('banana')) t(v) + UNION ALL + SELECT min(v) EXPORT_STATE AS s FROM (SELECT NULL::varchar AS v WHERE false) t +) t; +-- +ok +== +SELECT typeof((min(v) EXPORT_STATE)::BLOB) FROM (VALUES ('\xAA\xBB'::BLOB)) t(v); +-- +ok +== +SELECT (min(d) EXPORT_STATE)::VARCHAR FROM (VALUES (DATE '2000-01-01'), (DATE '2010-01-01')) t(d); +-- +ok +== +SELECT (max(u) EXPORT_STATE)::VARCHAR FROM (VALUES (UUID '5ABF4945-15A5-4D27-8B25-1D9E0E9DDF0F')) t(u); +-- +ok +== +SELECT min(COLUMNS(*)) EXPORT_STATE FROM test_all_types(); +-- +ok +== +SELECT list_bool_and([*COLUMNS(*)]) FROM (SELECT finalize(min(COLUMNS(*)) EXPORT_STATE) = min(COLUMNS(*)) FROM test_all_types()); +-- +ok +== diff --git a/parser/testdata/corpus/sql/aggregate/aggregate_state_export/ordered_aggregate_export_state.test b/parser/testdata/corpus/sql/aggregate/aggregate_state_export/ordered_aggregate_export_state.test new file mode 100644 index 0000000..0076ca5 --- /dev/null +++ b/parser/testdata/corpus/sql/aggregate/aggregate_state_export/ordered_aggregate_export_state.test @@ -0,0 +1,244 @@ +# source: test/sql/aggregate/aggregate_state_export/ordered_aggregate_export_state.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +CREATE TABLE lineitem(l_orderkey BIGINT, l_quantity DECIMAL(15,2), l_shipdate DATE); +-- +ok +== +INSERT INTO lineitem VALUES (1, 10.0, '1995-01-01'), (2, 5.0, '1995-01-01'), (3, 20.0, '1995-01-02'), + (4, 1.0, '1995-01-02'), (5, 50.0, '1995-01-02'); +-- +ok +== +SELECT l_shipdate, finalize(list(l_orderkey ORDER BY l_quantity) EXPORT_STATE) +FROM lineitem GROUP BY l_shipdate ORDER BY l_shipdate; +-- +ok +== +SELECT finalize(list(l_orderkey ORDER BY l_quantity) EXPORT_STATE) FROM lineitem; +-- +ok +== +SELECT finalize(list(i ORDER BY i DESC) EXPORT_STATE) FROM (VALUES (1), (3), (2)) t(i); +-- +ok +== +SELECT finalize(list(i ORDER BY i) EXPORT_STATE) FROM (VALUES (1), (3), (2)) t(i); +-- +ok +== +SELECT list(i ORDER BY i DESC) EXPORT_STATE FROM (VALUES (1), (3), (2)) t(i); +-- +ok +== +SELECT list(i ORDER BY i % 2, i) EXPORT_STATE FROM (VALUES (1), (3), (2)) t(i); +-- +ok +== +SELECT finalize(list(i ORDER BY i DESC NULLS LAST) EXPORT_STATE) FROM (VALUES (1), (NULL), (2)) t(i); +-- +ok +== +SELECT finalize(list(i ORDER BY i ASC NULLS FIRST) EXPORT_STATE) FROM (VALUES (1), (NULL), (2)) t(i); +-- +ok +== +SELECT finalize(list(i ORDER BY i) EXPORT_STATE) FROM (SELECT 1 AS i WHERE false) t; +-- +ok +== +CREATE TABLE grp_ints(grp INTEGER, i INTEGER); +-- +ok +== +INSERT INTO grp_ints VALUES (1, 10), (2, 15), (1, 30), (2, 20); +-- +ok +== +SELECT grp, first(i ORDER BY grp, i DESC) EXPORT_STATE FROM grp_ints GROUP BY grp ORDER BY grp; +-- +ok +== +SELECT grp, finalize(first(i ORDER BY grp, i DESC) EXPORT_STATE) FROM grp_ints GROUP BY grp ORDER BY grp; +-- +ok +== +SELECT g, finalize(string_agg(v, ',' ORDER BY v) EXPORT_STATE) +FROM (VALUES (0, 'b'), (0, 'a'), (0, 'c'), (1, 'y'), (1, 'x')) t(g, v) GROUP BY g ORDER BY g; +-- +ok +== +SELECT g, finalize(first(v ORDER BY v) EXPORT_STATE), finalize(last(v ORDER BY v) EXPORT_STATE), + finalize(any_value(v ORDER BY v DESC) EXPORT_STATE) +FROM (VALUES (0, 30), (0, 10), (0, 20), (1, 5), (1, 9)) t(g, v) GROUP BY g ORDER BY g; +-- +ok +== +SELECT g, finalize(arg_max(v, v ORDER BY v) EXPORT_STATE) +FROM (VALUES (0, 30), (0, 10), (0, 20), (1, 5), (1, 9)) t(g, v) GROUP BY g ORDER BY g; +-- +ok +== +CREATE TABLE approx_t AS SELECT (range % 8)::TINYINT AS g, range AS v FROM range(4000); +-- +ok +== +SELECT count(*) FROM ( + SELECT g, list_sort(approx_top_k(v, 5 ORDER BY v)) AS direct FROM approx_t GROUP BY g +) d JOIN ( + SELECT g, list_sort(finalize(approx_top_k(v, 5 ORDER BY v) EXPORT_STATE)) AS exported FROM approx_t GROUP BY g +) e USING (g) +WHERE d.direct IS DISTINCT FROM e.exported; +-- +ok +== +SELECT count(*) FROM ( + SELECT g, approx_quantile(v, 0.5 ORDER BY v) AS direct FROM approx_t GROUP BY g +) d JOIN ( + SELECT g, finalize(approx_quantile(v, 0.5 ORDER BY v) EXPORT_STATE) AS exported FROM approx_t GROUP BY g +) e USING (g) +WHERE d.direct IS DISTINCT FROM e.exported; +-- +ok +== +CREATE TABLE wide AS SELECT range % 500 AS g, range AS v FROM range(20000); +-- +ok +== +SELECT count(*) FROM ( + SELECT g, list(v ORDER BY v DESC) AS direct FROM wide GROUP BY g +) d JOIN ( + SELECT g, finalize(list(v ORDER BY v DESC) EXPORT_STATE) AS exported FROM wide GROUP BY g +) e USING (g) +WHERE d.direct IS DISTINCT FROM e.exported; +-- +ok +== +CREATE TABLE narrow AS SELECT (range % 8)::TINYINT AS g, range AS v FROM range(1000); +-- +ok +== +SELECT count(*) FROM ( + SELECT g, list(v ORDER BY v) AS direct FROM narrow GROUP BY g +) d JOIN ( + SELECT g, finalize(list(v ORDER BY v) EXPORT_STATE) AS exported FROM narrow GROUP BY g +) e USING (g) +WHERE d.direct IS DISTINCT FROM e.exported; +-- +ok +== +SELECT len(l), l[1] FROM (SELECT finalize(list(v ORDER BY v DESC) EXPORT_STATE) l FROM range(5000) t(v)); +-- +ok +== +SELECT finalize(list(l ORDER BY k) EXPORT_STATE) +FROM (VALUES (3, [3]), (1, [1, 2]), (2, NULL)) t(k, l); +-- +ok +== +SELECT list(l ORDER BY k) EXPORT_STATE FROM (VALUES ([3, 3], 3), ([1], 1), ([2], 2)) t(l, k); +-- +ok +== +SELECT finalize(list(x ORDER BY k) EXPORT_STATE) FROM (VALUES (1, [2]), (2, [1]), (3, [1, 5])) t(x, k); +-- +ok +== +SELECT finalize(combine( + (SELECT list(s ORDER BY s) EXPORT_STATE FROM (VALUES ({'a': 1, 'b': 'x'}), ({'a': 3, 'b': 'z'})) t(s)), + (SELECT list(s ORDER BY s) EXPORT_STATE FROM (VALUES ({'a': 2, 'b': 'y'}), ({'a': 4, 'b': 'w'})) t(s)) +)); +-- +ok +== +SELECT finalize(to_aggregate_state( + [{'v0': [3, 3], 'v1': 3}, {'v0': [1], 'v1': 1}, {'v0': [2], 'v1': 2}], + 'list', ['INTEGER[]'], [NULL], [{'column': 1, 'order': 'ASC NULLS LAST'}] +)); +-- +ok +== +CREATE TABLE ordered_state AS SELECT g, list(v ORDER BY v) EXPORT_STATE l FROM narrow GROUP BY g; +-- +ok +== +SELECT count(*) FROM ordered_state os JOIN ( + SELECT g, list(v ORDER BY v) AS direct FROM narrow GROUP BY g +) d USING (g) +WHERE finalize(os.l) IS DISTINCT FROM d.direct; +-- +ok +== +SELECT finalize(combine( + (SELECT list(x ORDER BY y) EXPORT_STATE FROM (VALUES (1, 10), (2, 30)) t(x, y)), + (SELECT list(x ORDER BY y) EXPORT_STATE FROM (VALUES (3, 20), (4, 40)) t(x, y)) +)); +-- +ok +== +SELECT finalize(combine_aggr(state)) FROM ( + SELECT string_agg(v, ' ' ORDER BY i) EXPORT_STATE AS state FROM (VALUES ('c', 2), ('d', 2)) t(v, i) + UNION ALL + SELECT string_agg(v, ' ' ORDER BY i) EXPORT_STATE AS state FROM (VALUES ('a', 1), ('b', 1)) t(v, i) +); +-- +ok +== +CREATE TABLE parts AS SELECT (range * 2654435761) % 1000 AS x, ((range * 40503) % 97) AS y, range % 2 AS part +FROM range(4000); +-- +ok +== +SELECT count(*) FROM ( + SELECT finalize(combine(a.s, b.s)) AS combined FROM + (SELECT list(x ORDER BY y, x) EXPORT_STATE AS s FROM parts WHERE part = 0) a, + (SELECT list(x ORDER BY y, x) EXPORT_STATE AS s FROM parts WHERE part = 1) b +) c, (SELECT list(x ORDER BY y, x) AS direct FROM parts) d +WHERE c.combined IS DISTINCT FROM d.direct; +-- +ok +== +SELECT finalize(combine_aggr(s)) FROM ( + SELECT list(v ORDER BY v) EXPORT_STATE AS s FROM (VALUES (2), (1)) t(v) + UNION ALL + SELECT list(v ORDER BY v) EXPORT_STATE AS s FROM (VALUES (4), (3)) t(v) +) t; +-- +ok +== +SELECT finalize(to_aggregate_state( + [{'v0': 'b', 'v1': 2}, {'v0': 'a', 'v1': 1}, {'v0': 'c', 'v1': 3}], + 'string_agg', ['VARCHAR', 'VARCHAR'], [NULL, ' '], + [{'column': 1, 'order': 'ASC NULLS LAST'}] +)); +-- +ok +== +SELECT finalize(to_aggregate_state( + [{'v0': 'b', 'v1': 2}, {'v0': 'a', 'v1': 1}, {'v0': 'c', 'v1': 3}], + 'string_agg', ['VARCHAR', 'VARCHAR'], [NULL, '|'], + [{'column': 1, 'order': 'DESC NULLS LAST'}] +)); +-- +ok +== +SELECT finalize(to_aggregate_state( + (SELECT list(x ORDER BY y) EXPORT_STATE FROM (VALUES (10, 1), (30, 3), (20, 2)) t(x, y))::STRUCT(v0 INTEGER, v1 INTEGER)[], + 'list', ['INTEGER'], [NULL], [{'column': 1, 'order': 'ASC NULLS LAST'}] +)); +-- +ok +== +SELECT finalize(combine( + to_aggregate_state([{'v0': 1, 'v1': 10}, {'v0': 2, 'v1': 30}], 'list', ['INTEGER'], [NULL], [{'column': 1, 'order': 'ASC NULLS LAST'}]), + to_aggregate_state([{'v0': 3, 'v1': 20}, {'v0': 4, 'v1': 40}], 'list', ['INTEGER'], [NULL], [{'column': 1, 'order': 'ASC NULLS LAST'}]) +)); +-- +ok +== +SELECT to_aggregate_state([{'v0': 1, 'v1': 10}], 'list', ['INTEGER'], [NULL], [{'column': 5, 'order': 'ASC NULLS LAST'}]); +-- +ok +== diff --git a/parser/testdata/corpus/sql/aggregate/aggregate_state_export/product_export_state.test b/parser/testdata/corpus/sql/aggregate/aggregate_state_export/product_export_state.test new file mode 100644 index 0000000..1ec0309 --- /dev/null +++ b/parser/testdata/corpus/sql/aggregate/aggregate_state_export/product_export_state.test @@ -0,0 +1,52 @@ +# source: test/sql/aggregate/aggregate_state_export/product_export_state.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +SELECT product(v) EXPORT_STATE FROM (SELECT NULL::double AS v WHERE false) t; +-- +ok +== +SELECT product(NULL::double) EXPORT_STATE; +-- +ok +== +SELECT product(v) EXPORT_STATE FROM (VALUES (2.0), (3.0), (4.0)) t(v); +-- +ok +== +SELECT finalize(combine(product(2.0::double) EXPORT_STATE, product(3.0::double) EXPORT_STATE)); +-- +ok +== +SELECT finalize(combine( + product(v) EXPORT_STATE, + product(v) EXPORT_STATE +)) FROM (SELECT NULL::double AS v WHERE false) t; +-- +ok +== +SELECT finalize(combine_aggr(s)) FROM ( + SELECT product(v) EXPORT_STATE AS s FROM (VALUES (2.0), (3.0)) t(v) + UNION ALL + SELECT product(v) EXPORT_STATE AS s FROM (VALUES (4.0), (5.0)) t(v) +) t; +-- +ok +== +SELECT finalize(combine_aggr(s)) FROM ( + SELECT product(v) EXPORT_STATE AS s FROM (VALUES (2.0)) t(v) + UNION ALL + SELECT product(v) EXPORT_STATE AS s FROM (SELECT NULL::double AS v WHERE false) t +) t; +-- +ok +== +SELECT finalize(combine_aggr(s)) FROM ( + SELECT product(v) EXPORT_STATE AS s FROM (SELECT NULL::double AS v WHERE false) t + UNION ALL + SELECT product(v) EXPORT_STATE AS s FROM (SELECT NULL::double AS v WHERE false) t +) t; +-- +ok +== diff --git a/parser/testdata/corpus/sql/aggregate/aggregate_state_export/state_export_parquet.test b/parser/testdata/corpus/sql/aggregate/aggregate_state_export/state_export_parquet.test new file mode 100644 index 0000000..1fa9a16 --- /dev/null +++ b/parser/testdata/corpus/sql/aggregate/aggregate_state_export/state_export_parquet.test @@ -0,0 +1,17 @@ +# source: test/sql/aggregate/aggregate_state_export/state_export_parquet.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +COPY (SELECT SUM(42) EXPORT_STATE AS state) TO '{TEST_DIR}/exported_state.parquet'; +-- +ok +== +SELECT to_aggregate_state(state, 'sum', ['INTEGER']) FROM '{TEST_DIR}/exported_state.parquet' +-- +ok +== +SELECT finalize(to_aggregate_state(state, 'sum', ['INTEGER'])) FROM '{TEST_DIR}/exported_state.parquet' +-- +ok +== diff --git a/parser/testdata/corpus/sql/aggregate/aggregate_state_export/sum_export_state.test b/parser/testdata/corpus/sql/aggregate/aggregate_state_export/sum_export_state.test new file mode 100644 index 0000000..c448bd7 --- /dev/null +++ b/parser/testdata/corpus/sql/aggregate/aggregate_state_export/sum_export_state.test @@ -0,0 +1,41 @@ +# source: test/sql/aggregate/aggregate_state_export/sum_export_state.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +SELECT typeof(sum(1::INTEGER) EXPORT_STATE); +-- +ok +== +SELECT typeof(sum(1::BIGINT) EXPORT_STATE); +-- +ok +== +SELECT typeof(sum(1.0::DOUBLE) EXPORT_STATE); +-- +ok +== +SELECT typeof(sum(1.12::DECIMAL) EXPORT_STATE); +-- +ok +== +SELECT typeof(sum(true) EXPORT_STATE); +-- +ok +== +SELECT typeof(sum(1::SMALLINT) EXPORT_STATE); +-- +ok +== +SELECT typeof(sum(1.00::DECIMAL(4,2)) EXPORT_STATE); +-- +ok +== +SELECT kahan_sum(NULL::double) EXPORT_STATE; +-- +ok +== +SELECT kahan_sum(v) EXPORT_STATE FROM (VALUES (1.0), (2.0), (3.0)) t(v); +-- +ok +== diff --git a/parser/testdata/corpus/sql/aggregate/aggregate_state_export/test_aggregate_state_type.test b/parser/testdata/corpus/sql/aggregate/aggregate_state_export/test_aggregate_state_type.test new file mode 100644 index 0000000..4b0344f --- /dev/null +++ b/parser/testdata/corpus/sql/aggregate/aggregate_state_export/test_aggregate_state_type.test @@ -0,0 +1,209 @@ +# source: test/sql/aggregate/aggregate_state_export/test_aggregate_state_type.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +SELECT typeof(avg(1.0::{type}) EXPORT_STATE); +-- +error: Parser Error: syntax error at or near "{" +== +CREATE TABLE t1_{type} AS SELECT avg(range::{type}) EXPORT_STATE as state FROM range(10); +-- +error: Parser Error: syntax error at or near "{" +== +SELECT column_type FROM (DESCRIBE t1_{type}) WHERE column_name = 'state'; +-- +error: Parser Error: syntax error at or near "{" +== +SELECT finalize(combine(state, state)) FROM t1_{type}; +-- +error: Parser Error: syntax error at or near "{" +== +INSERT INTO t1_{type} SELECT avg((range::{type} + 10.0)::{type}) EXPORT_STATE FROM range(10); +-- +error: Parser Error: syntax error at or near "{" +== +SELECT finalize(state) FROM t1_{type} ORDER BY 1; +-- +error: Parser Error: syntax error at or near "{" +== +SELECT finalize(combine(state, state)) FROM t1_{type} ORDER BY 1; +-- +error: Parser Error: syntax error at or near "{" +== +SELECT typeof(count(1) EXPORT_STATE); +-- +ok +== +CREATE TABLE t2_count_int AS SELECT count(range::INT) EXPORT_STATE as state FROM range(10); +-- +ok +== +SELECT typeof(bit_xor(1::BIGINT) EXPORT_STATE); +-- +ok +== +SELECT typeof(skewness(1) EXPORT_STATE); +-- +ok +== +SELECT typeof(approx_count_distinct(1) EXPORT_STATE); +-- +ok +== +SELECT typeof(avg(INTERVAL '1 day' ) EXPORT_STATE); +-- +ok +== +SELECT typeof(avg(TIMESTAMP '2020-01-01 00:00:00' ) EXPORT_STATE); +-- +ok +== +SELECT typeof(avg(TIMESTAMPTZ '2020-01-01 00:00:00+00' ) EXPORT_STATE); +-- +ok +== +SELECT typeof(avg(TIME '12:00:00' ) EXPORT_STATE); +-- +ok +== +SELECT typeof(avg(TIMETZ '12:00:00+00' ) EXPORT_STATE); +-- +ok +== +SELECT typeof(avg(1.2) EXPORT_STATE); +-- +ok +== +SELECT (avg(42) export_state)::struct(count ubigint, "value" integer); +-- +ok +== +SELECT (avg(42) export_state)::struct(count ubigint, "value" double); +-- +ok +== +SELECT (count(42) export_state)::bigint; +-- +ok +== +SELECT (count(*) export_state)::bigint; +-- +ok +== +SELECT typeof(first(42) EXPORT_STATE); +-- +ok +== +SELECT typeof(last(42) EXPORT_STATE); +-- +ok +== +SELECT typeof(any_value(42) EXPORT_STATE); +-- +ok +== +SELECT (first(42) export_state)::struct("value" integer); +-- +ok +== +SELECT (last(42) export_state)::struct("value" integer); +-- +ok +== +SELECT (any_value(42) export_state)::struct("value" integer); +-- +ok +== +SELECT typeof(product(1.0::DOUBLE) EXPORT_STATE); +-- +ok +== +CREATE TABLE t3_product AS SELECT product(range::DOUBLE) EXPORT_STATE as state FROM range(1, 6); +-- +ok +== +SELECT column_type FROM (DESCRIBE t3_product) WHERE column_name = 'state'; +-- +ok +== +SELECT finalize(combine(state, state)) FROM t3_product; +-- +ok +== +INSERT INTO t3_product SELECT product((range::DOUBLE + 10.0)::DOUBLE) EXPORT_STATE FROM range(1, 6); +-- +ok +== +SELECT finalize(state) FROM t3_product ORDER BY 1; +-- +ok +== +SELECT finalize(combine(state, state)) FROM t3_product ORDER BY 1; +-- +ok +== +SELECT (product(2.0) export_state)::double; +-- +ok +== +SELECT finalize(product(1.0::DOUBLE) EXPORT_STATE) IS NULL FROM (SELECT 1 WHERE FALSE); +-- +ok +== +SELECT typeof(regr_count(1.0, 2.0) EXPORT_STATE); +-- +ok +== +SELECT typeof(regr_avgx(1.0, 2.0) EXPORT_STATE); +-- +ok +== +SELECT typeof(regr_avgy(1.0, 2.0) EXPORT_STATE); +-- +ok +== +SELECT typeof(regr_slope(1.0, 2.0) EXPORT_STATE); +-- +ok +== +SELECT typeof(regr_intercept(1.0, 2.0) EXPORT_STATE); +-- +ok +== +SELECT typeof(regr_r2(1.0, 2.0) EXPORT_STATE); +-- +ok +== +SELECT typeof(regr_sxx(1.0, 2.0) EXPORT_STATE); +-- +ok +== +SELECT typeof(regr_syy(1.0, 2.0) EXPORT_STATE); +-- +ok +== +SELECT typeof(regr_sxy(1.0, 2.0) EXPORT_STATE); +-- +ok +== +CREATE TABLE t_regr_count AS SELECT regr_count(range::DOUBLE, range::DOUBLE + 1) EXPORT_STATE as state FROM range(10); +-- +ok +== +SELECT column_type FROM (DESCRIBE t_regr_count) WHERE column_name = 'state'; +-- +ok +== +SELECT finalize(combine(state, state)) FROM t_regr_count; +-- +ok +== +SELECT (regr_count(1.0, 2.0) export_state)::ubigint; +-- +ok +== +SELECT (regr_avgx(1.0, 2.0) export_state)::struct(sum double, count ubigint); +-- +ok +== diff --git a/parser/testdata/corpus/sql/aggregate/aggregate_state_export/test_combine_aggr.test b/parser/testdata/corpus/sql/aggregate/aggregate_state_export/test_combine_aggr.test new file mode 100644 index 0000000..d22e931 --- /dev/null +++ b/parser/testdata/corpus/sql/aggregate/aggregate_state_export/test_combine_aggr.test @@ -0,0 +1,154 @@ +# source: test/sql/aggregate/aggregate_state_export/test_combine_aggr.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +create table dummy as select range % 10 g, range d from range(100); +-- +ok +== +create table states as select g, avg(d) export_state state from dummy group by g; +-- +ok +== +select finalize(combine_aggr(state))::integer from states; +-- +ok +== +select avg(d)::integer from dummy; +-- +ok +== +select g < 5 as bucket, finalize(combine_aggr(state))::integer from states group by bucket; +-- +ok +== +insert into states values (1, NULL); +-- +ok +== +select finalize(combine_aggr(state)) from states where false; +-- +ok +== +select finalize(combine_aggr(state))::integer from states where g = 0; +-- +ok +== +WITH states AS ( + SELECT + sum(v) EXPORT_STATE AS sum_s, + count(v) EXPORT_STATE AS count_s, + count(*) EXPORT_STATE AS count_star_s, + avg(v) EXPORT_STATE AS avg_s, + min(v) EXPORT_STATE AS min_s, + max(v) EXPORT_STATE AS max_s + FROM (VALUES (1), (3), (5)) t(v) +) +SELECT + finalize(combine_aggr(sum_s, 3)), + finalize(combine_aggr(count_s, 3)), + finalize(combine_aggr(count_star_s, 3)), + finalize(combine_aggr(avg_s, 3))::INTEGER, + finalize(combine_aggr(min_s, 3)), + finalize(combine_aggr(max_s, 3)) +FROM states; +-- +ok +== +WITH states AS ( + SELECT sum(v) EXPORT_STATE AS s + FROM (VALUES (2::BIGINT)) t(v) +) +SELECT + finalize(combine_aggr(s, 3::INTEGER)), + finalize(combine_aggr(s, 3::UINTEGER)), + finalize(combine_aggr(s, 3::SMALLINT)) +FROM states; +-- +ok +== +WITH states AS ( + SELECT g, sum(v) EXPORT_STATE AS s, count(*)::INTEGER AS n + FROM (VALUES (0, 1), (0, 2), (1, 10), (2, 5), (2, 7), (2, 8), (3, 20)) t(g, v) + GROUP BY g +) +SELECT g % 2 AS bucket, finalize(combine_aggr(s, n)) +FROM states +GROUP BY bucket +ORDER BY bucket; +-- +ok +== +WITH states AS ( + SELECT sum(v) EXPORT_STATE AS sum_s, count(v) EXPORT_STATE AS count_s + FROM (VALUES (1), (3), (5)) t(v) +) +SELECT + (finalize(combine_aggr(sum_s, 0)) IS NULL)::INTEGER, + finalize(combine_aggr(count_s, NULL::BIGINT)) +FROM states; +-- +ok +== +WITH states AS ( + SELECT sum(v) EXPORT_STATE AS sum_s, count(*) EXPORT_STATE AS count_s + FROM (VALUES (7::BIGINT)) t(v) +) +SELECT finalize(combine_aggr(sum_s, 1000000)), finalize(combine_aggr(count_s, 1000000)) +FROM states; +-- +ok +== +WITH states AS ( + SELECT kahan_sum(v) EXPORT_STATE AS kahan_s, favg(v) EXPORT_STATE AS favg_s + FROM (VALUES (1::DOUBLE), (2::DOUBLE), (3::DOUBLE)) t(v) +) +SELECT finalize(combine_aggr(kahan_s, 3))::INTEGER, finalize(combine_aggr(favg_s, 3))::INTEGER +FROM states; +-- +ok +== +WITH states AS ( + SELECT sum(v) EXPORT_STATE AS s FROM (VALUES (1), (2)) t(v) +) +SELECT finalize(combine_aggr(s, -1)) FROM states; +-- +ok +== +create table combined_states as select combine_aggr(state) as global_state from states; +-- +ok +== +create view combined_view as select combine_aggr(state) as global_state from states; +-- +ok +== +select finalize(global_state)::integer from combined_states; +-- +ok +== +select finalize(global_state)::integer from combined_view; +-- +ok +== +select finalize(combine(combine_aggr(state), (select avg(d) export_state from dummy where d < 10)))::integer from states; +-- +ok +== +select finalize(finalize(combine_aggr(state))) from states; +-- +ok +== +CREATE TABLE skew_states AS (SELECT g, (skewness(d) export_state) state FROM dummy GROUP BY g); +-- +ok +== +select skewness(d) from dummy; +-- +ok +== +select finalize(combine_aggr(state)) from skew_states; +-- +ok +== diff --git a/parser/testdata/corpus/sql/aggregate/aggregate_state_export/test_corr_state_export.test b/parser/testdata/corpus/sql/aggregate/aggregate_state_export/test_corr_state_export.test new file mode 100644 index 0000000..92b0193 --- /dev/null +++ b/parser/testdata/corpus/sql/aggregate/aggregate_state_export/test_corr_state_export.test @@ -0,0 +1,25 @@ +# source: test/sql/aggregate/aggregate_state_export/test_corr_state_export.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +SELECT corr(d, d+1) export_state FROM dummy; +-- +ok +== +SELECT corr(d, d+1), finalize(corr(d, d+1) EXPORT_STATE) FROM dummy; +-- +ok +== +CREATE TABLE state AS SELECT g, corr(d, d+1) EXPORT_STATE corr_state FROM dummy GROUP BY g; +-- +ok +== +SELECT g, corr(d, d+1) FROM dummy GROUP BY g ORDER BY g; +-- +ok +== +SELECT g, finalize(corr_state) FROM state ORDER BY g; +-- +ok +== diff --git a/parser/testdata/corpus/sql/aggregate/aggregate_state_export/test_covar_export_state.test b/parser/testdata/corpus/sql/aggregate/aggregate_state_export/test_covar_export_state.test new file mode 100644 index 0000000..2fca52e --- /dev/null +++ b/parser/testdata/corpus/sql/aggregate/aggregate_state_export/test_covar_export_state.test @@ -0,0 +1,45 @@ +# source: test/sql/aggregate/aggregate_state_export/test_covar_export_state.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +CREATE TABLE integers(x INTEGER, y INTEGER); +-- +ok +== +INSERT INTO integers VALUES (10,NULL), (10,11), (20,22), (25,NULL), (30,35) +-- +ok +== +CREATE TABLE covar_state AS SELECT COVAR_POP(x,y) EXPORT_STATE pop_state, COVAR_SAMP(x, y) EXPORT_STATE samp_state FROM integers; +-- +ok +== +SELECT pop_state::STRUCT(count UBIGINT, meanx DECIMAL(18,2), meany DECIMAL(18,2), co_moment DOUBLE) FROM covar_state; +-- +ok +== +SELECT samp_state::STRUCT(count UBIGINT, meanx DECIMAL(18,2), meany DECIMAL(18,2), co_moment DOUBLE) FROM covar_state; +-- +ok +== +SELECT covar_samp(x, y) FROM integers; +-- +ok +== +SELECT finalize(covar_samp(x, y) EXPORT_STATE) FROM integers; +-- +ok +== +CREATE TABLE grouped AS SELECT range % 3 g, range x, range + 1 y FROM range(30); +-- +ok +== +SELECT g, covar_samp(x, y) FROM grouped GROUP BY g ORDER BY g; +-- +ok +== +SELECT g, finalize(covar_samp(x, y) EXPORT_STATE) FROM grouped GROUP BY g ORDER BY g; +-- +ok +== diff --git a/parser/testdata/corpus/sql/aggregate/aggregate_state_export/test_state_export_opaque.test b/parser/testdata/corpus/sql/aggregate/aggregate_state_export/test_state_export_opaque.test new file mode 100644 index 0000000..74fc136 --- /dev/null +++ b/parser/testdata/corpus/sql/aggregate/aggregate_state_export/test_state_export_opaque.test @@ -0,0 +1,117 @@ +# source: test/sql/aggregate/aggregate_state_export/test_state_export_opaque.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +SELECT skewness(d) FROM dummy; +-- +ok +== +SELECT finalize(skewness(d) EXPORT_STATE) FROM dummy; +-- +ok +== +SELECT g, skewness(d) FROM dummy GROUP BY g ORDER BY g; +-- +ok +== +SELECT g, finalize(skewness(d) EXPORT_STATE) FROM dummy GROUP BY g ORDER BY g; +-- +ok +== +CREATE TABLE state AS SELECT g, skewness(d) EXPORT_STATE skewness_state FROM dummy GROUP BY g ORDER BY g; +-- +ok +== +SELECT g, finalize(skewness_state) FROM state ORDER BY g; +-- +ok +== +SELECT skewness(d) FROM dummy WHERE FALSE; +-- +ok +== +SELECT finalize(skewness(d) EXPORT_STATE) FROM dummy WHERE FALSE; +-- +ok +== +SELECT skewness(d) FROM (SELECT NULL::integer d); +-- +ok +== +SELECT finalize(skewness(d) EXPORT_STATE) FROM (SELECT NULL::integer d); +-- +ok +== +SELECT skewness(d) FROM (SELECT NULL::integer d, g FROM dummy); +-- +ok +== +SELECT finalize(skewness(d) EXPORT_STATE) FROM (SELECT NULL::integer d, g FROM dummy); +-- +ok +== +SELECT FINALIZE(COMBINE(skewness(d) EXPORT_STATE)) FROM dummy; +-- +ok +== +SELECT combine(NULL, NULL); +-- +ok +== +SELECT combine(42, 42); +-- +ok +== +SELECT finalize(NULL); +-- +ok +== +SELECT finalize(42); +-- +ok +== +SELECT finalize(skewness(d)) from dummy; +-- +ok +== +SELECT finalize(skewness(d)) from dummy group by g; +-- +ok +== +SELECT finalize(finalize(skewness(d) EXPORT_STATE)) from dummy; +-- +ok +== +select skewness(42) EXPORT_STATE over (); +-- +error: Parser Error: EXPORT_STATE is not supported for window functions! +== +CREATE VIEW state_view AS SELECT g, skewness(d) EXPORT_STATE skewness_state FROM dummy GROUP BY g ORDER BY g; +-- +ok +== +SELECT g, finalize(skewness_state) FROM state_view ORDER BY g; +-- +ok +== +SELECT (skewness(42) EXPORT_STATE)::BLOB; +-- +ok +== +SELECT (skewness(42) EXPORT_STATE)::STRUCT(n UBIGINT, sum DOUBLE, sum_sqr DOUBLE, sum_cub DOUBLE); +-- +ok +== +SELECT (skewness(42) EXPORT_STATE)::INTEGER; +-- +ok +== +SELECT COMBINE(skewness(42) EXPORT_STATE, 42); +-- +ok +== +SELECT COMBINE(skewness(42) EXPORT_STATE, 'ASDF'::BLOB); +-- +ok +== diff --git a/parser/testdata/corpus/sql/aggregate/aggregate_state_export/test_state_export_opaque.test.metadata.json b/parser/testdata/corpus/sql/aggregate/aggregate_state_export/test_state_export_opaque.test.metadata.json new file mode 100644 index 0000000..4ce1044 --- /dev/null +++ b/parser/testdata/corpus/sql/aggregate/aggregate_state_export/test_state_export_opaque.test.metadata.json @@ -0,0 +1,5 @@ +{ + "todo": { + "6bcef3fc22f8617b": "transformer-raised parser error: upstream rejects in the transformer, not the grammar; expected to clear as transformers land (milestones 3-5)" + } +} diff --git a/parser/testdata/corpus/sql/aggregate/aggregate_state_export/test_state_export_quantile.test b/parser/testdata/corpus/sql/aggregate/aggregate_state_export/test_state_export_quantile.test new file mode 100644 index 0000000..ef86808 --- /dev/null +++ b/parser/testdata/corpus/sql/aggregate/aggregate_state_export/test_state_export_quantile.test @@ -0,0 +1,173 @@ +# source: test/sql/aggregate/aggregate_state_export/test_state_export_quantile.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +SELECT quantile_disc(d, 0.5) FROM dummy; +-- +ok +== +SELECT finalize(quantile_disc(d, 0.5) EXPORT_STATE) FROM dummy; +-- +ok +== +SELECT quantile_cont(d, 0.5) FROM dummy; +-- +ok +== +SELECT finalize(quantile_cont(d, 0.5) EXPORT_STATE) FROM dummy; +-- +ok +== +SELECT median(d) FROM dummy; +-- +ok +== +SELECT finalize(median(d) EXPORT_STATE) FROM dummy; +-- +ok +== +SELECT quantile_disc(d, [0.25, 0.5, 0.75]) FROM dummy; +-- +ok +== +SELECT finalize(quantile_disc(d, [0.25, 0.5, 0.75]) EXPORT_STATE) FROM dummy; +-- +ok +== +SELECT quantile_cont(d, [0.25, 0.5, 0.75]) FROM dummy; +-- +ok +== +SELECT finalize(quantile_cont(d, [0.25, 0.5, 0.75]) EXPORT_STATE) FROM dummy; +-- +ok +== +SELECT quantile_disc(d, -0.25) FROM dummy; +-- +ok +== +SELECT finalize(quantile_disc(d, -0.25) EXPORT_STATE) FROM dummy; +-- +ok +== +SELECT g, quantile_cont(d, 0.5) FROM dummy GROUP BY g ORDER BY g; +-- +ok +== +SELECT g, finalize(quantile_cont(d, 0.5) EXPORT_STATE) FROM dummy GROUP BY g ORDER BY g; +-- +ok +== +SELECT quantile_disc(d, 0.5) FROM dummy WHERE FALSE; +-- +ok +== +SELECT finalize(quantile_disc(d, 0.5) EXPORT_STATE) FROM dummy WHERE FALSE; +-- +ok +== +SELECT quantile_disc(d::VARCHAR, 0.5) FROM dummy; +-- +ok +== +SELECT finalize(quantile_disc(d::VARCHAR, 0.5) EXPORT_STATE) FROM dummy; +-- +ok +== +SELECT quantile_cont((d / 10)::DECIMAL(8, 3), 0.5) FROM dummy; +-- +ok +== +SELECT finalize(quantile_cont((d / 10)::DECIMAL(8, 3), 0.5) EXPORT_STATE) FROM dummy; +-- +ok +== +SELECT finalize(combine( + (SELECT quantile_disc(d, 0.5) EXPORT_STATE FROM dummy WHERE d < 50), + (SELECT quantile_disc(d, 0.5) EXPORT_STATE FROM dummy WHERE d >= 50))) +-- +ok +== +SELECT quantile_disc(d, 0.5) FROM dummy WHERE d < 50; +-- +ok +== +SELECT finalize(combine( + (SELECT quantile_disc(d, 0.5) EXPORT_STATE FROM dummy WHERE d < 50), + (SELECT quantile_disc(d, 0.5) EXPORT_STATE FROM dummy WHERE FALSE))) +-- +ok +== +SELECT finalize(combine( + (SELECT quantile_disc(d, 0.5) EXPORT_STATE FROM dummy WHERE d < 50), + (SELECT quantile_disc(d, 0.25) EXPORT_STATE FROM dummy WHERE d >= 50))) +-- +ok +== +SELECT quantile_disc({'a': d, 'b': d::VARCHAR}, 0.5) FROM dummy; +-- +ok +== +SELECT finalize(quantile_disc({'a': d, 'b': d::VARCHAR}, 0.5) EXPORT_STATE) FROM dummy; +-- +ok +== +SELECT quantile_disc({'a': d, 'b': d::VARCHAR}, [0.25, 0.5, 0.75]) FROM dummy; +-- +ok +== +SELECT finalize(quantile_disc({'a': d, 'b': d::VARCHAR}, [0.25, 0.5, 0.75]) EXPORT_STATE) FROM dummy; +-- +ok +== +SELECT median([d, d + 1]) FROM dummy; +-- +ok +== +SELECT finalize(median([d, d + 1]) EXPORT_STATE) FROM dummy; +-- +ok +== +SELECT g, quantile_disc({'a': d}, 0.5) FROM dummy GROUP BY g ORDER BY g; +-- +ok +== +SELECT g, finalize(quantile_disc({'a': d}, 0.5) EXPORT_STATE) FROM dummy GROUP BY g ORDER BY g; +-- +ok +== +SELECT quantile_disc({'a': d}, 0.5) FROM dummy; +-- +ok +== +SELECT finalize(combine( + (SELECT quantile_disc({'a': d}, 0.5) EXPORT_STATE FROM dummy WHERE d < 50), + (SELECT quantile_disc({'a': d}, 0.5) EXPORT_STATE FROM dummy WHERE d >= 50))) +-- +ok +== +create table big as select range r, {'a': range} s from range(5000); +-- +ok +== +SELECT quantile_disc(s, [0.1, 0.5, 0.9]) FROM big; +-- +ok +== +SELECT finalize(quantile_disc(s, [0.1, 0.5, 0.9]) EXPORT_STATE) FROM big; +-- +ok +== +CREATE TABLE state_tbl AS SELECT g, quantile_cont(d, [0.25, 0.75]) EXPORT_STATE s FROM dummy GROUP BY g; +-- +ok +== +SELECT g, finalize(s) FROM state_tbl ORDER BY g; +-- +ok +== +SELECT g, quantile_cont(d, [0.25, 0.75]) FROM dummy GROUP BY g ORDER BY g; +-- +ok +== diff --git a/parser/testdata/corpus/sql/aggregate/aggregate_state_export/test_state_export_string_agg.test b/parser/testdata/corpus/sql/aggregate/aggregate_state_export/test_state_export_string_agg.test new file mode 100644 index 0000000..17c043c --- /dev/null +++ b/parser/testdata/corpus/sql/aggregate/aggregate_state_export/test_state_export_string_agg.test @@ -0,0 +1,107 @@ +# source: test/sql/aggregate/aggregate_state_export/test_state_export_string_agg.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +SELECT string_agg(d, '|') FROM dummy; +-- +ok +== +SELECT finalize(string_agg(d, '|') EXPORT_STATE) FROM dummy; +-- +ok +== +SELECT string_agg(d) FROM dummy; +-- +ok +== +SELECT finalize(string_agg(d) EXPORT_STATE) FROM dummy; +-- +ok +== +SELECT g, string_agg(d, '-') FROM dummy GROUP BY g ORDER BY g; +-- +ok +== +SELECT g, finalize(string_agg(d, '-') EXPORT_STATE) FROM dummy GROUP BY g ORDER BY g; +-- +ok +== +SELECT string_agg(d, '|') FROM dummy WHERE FALSE; +-- +ok +== +SELECT finalize(string_agg(d, '|') EXPORT_STATE) FROM dummy WHERE FALSE; +-- +ok +== +SELECT finalize(combine( + (SELECT string_agg(d, '|') EXPORT_STATE FROM dummy WHERE d < 3), + (SELECT string_agg(d, '|') EXPORT_STATE FROM dummy WHERE FALSE))) +-- +ok +== +SELECT finalize(combine( + (SELECT string_agg(d, '|') EXPORT_STATE FROM dummy WHERE d < 3), + (SELECT string_agg(d, '|') EXPORT_STATE FROM dummy WHERE d >= 3 AND d < 6))) +-- +ok +== +SELECT finalize(combine( + (SELECT string_agg(d, '|') EXPORT_STATE FROM dummy WHERE d < 3), + (SELECT string_agg(d, '-') EXPORT_STATE FROM dummy WHERE d >= 3 AND d < 6))) +-- +ok +== +SELECT string_agg(d, '''' || chr(10) || '🦆') FROM dummy; +-- +ok +== +SELECT finalize(string_agg(d, '''' || chr(10) || '🦆') EXPORT_STATE) FROM dummy; +-- +ok +== +SELECT finalize(string_agg(d, NULL) EXPORT_STATE) IS NULL FROM dummy; +-- +ok +== +SELECT g, finalize(to_aggregate_state(string_agg(d, '-') EXPORT_STATE, 'string_agg', ['VARCHAR', 'VARCHAR'], [NULL, '-'])) FROM dummy GROUP BY g ORDER BY g; +-- +ok +== +SELECT g, finalize(to_aggregate_state(string_agg(d, '-') EXPORT_STATE, 'string_agg', [make_type('VARCHAR'), make_type('VARCHAR')], [NULL, '-'])) FROM dummy GROUP BY g ORDER BY g; +-- +ok +== +SELECT finalize(to_aggregate_state(string_agg(d) EXPORT_STATE, 'string_agg', ['VARCHAR'])) FROM dummy; +-- +ok +== +SELECT g, string_agg(d, '-') || '-' || string_agg(d, '-') FROM dummy GROUP BY g ORDER BY g; +-- +ok +== +SELECT g, finalize(combine(string_agg(d, '-') EXPORT_STATE, + to_aggregate_state(string_agg(d, '-') EXPORT_STATE, 'string_agg', ['VARCHAR', 'VARCHAR'], [NULL, '-']))) +FROM dummy GROUP BY g ORDER BY g; +-- +ok +== +SELECT finalize(combine( + to_aggregate_state(string_agg(d, '-') EXPORT_STATE, 'string_agg', ['VARCHAR', 'VARCHAR'], [NULL, '-']), + string_agg(d, '|') EXPORT_STATE)) FROM dummy; +-- +ok +== +SELECT to_aggregate_state(string_agg(d, '-') EXPORT_STATE, 'string_agg', ['VARCHAR', 'VARCHAR'], [NULL, NULL, '-']) FROM dummy; +-- +ok +== +SELECT to_aggregate_state(string_agg(d, '-') EXPORT_STATE, 'string_agg', ['VARCHAR', 'VARCHAR'], {'1': '-'}) FROM dummy; +-- +ok +== +CREATE TABLE state_tbl AS SELECT g, string_agg(d, '-') EXPORT_STATE s FROM dummy GROUP BY g; +-- +ok +== diff --git a/parser/testdata/corpus/sql/aggregate/aggregate_state_export/test_state_export_struct.test b/parser/testdata/corpus/sql/aggregate/aggregate_state_export/test_state_export_struct.test new file mode 100644 index 0000000..5f34a87 --- /dev/null +++ b/parser/testdata/corpus/sql/aggregate/aggregate_state_export/test_state_export_struct.test @@ -0,0 +1,505 @@ +# source: test/sql/aggregate/aggregate_state_export/test_state_export_struct.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +SELECT sum(d), avg(d)::integer, count(d), min(d), max(d), first(d), last(d), kurtosis(d), kurtosis_pop(d) FROM dummy; +-- +ok +== +SELECT finalize(sum(d) EXPORT_STATE), finalize(avg(d) EXPORT_STATE)::integer, finalize(count(d) EXPORT_STATE), finalize(min(d) EXPORT_STATE), finalize(max(d) EXPORT_STATE), finalize(first(d) EXPORT_STATE), finalize(last(d) EXPORT_STATE), finalize(kurtosis(d) EXPORT_STATE), finalize(kurtosis_pop(d) EXPORT_STATE) FROM dummy; +-- +ok +== +SELECT g, sum(d), avg(d)::integer, count(d), min(d), max(d), stddev(d)::integer, first(d), last(d) FROM dummy GROUP BY g ORDER BY g; +-- +ok +== +SELECT corr(d, d+1) FROM dummy; +-- +ok +== +SELECT finalize(corr(d, d+1) EXPORT_STATE) FROM dummy; +-- +ok +== +SELECT covar_pop(d, d+1) FROM dummy; +-- +ok +== +SELECT finalize(covar_pop(d, d+1) EXPORT_STATE) FROM dummy; +-- +ok +== +SELECT var_pop(d) FROM dummy; +-- +ok +== +SELECT finalize(var_pop(d) EXPORT_STATE) FROM dummy; +-- +ok +== +SELECT regr_count(d, d+1) FROM dummy; +-- +ok +== +SELECT finalize(regr_count(d, d+1) EXPORT_STATE) FROM dummy; +-- +ok +== +SELECT regr_avgx(d, d+1) FROM dummy; +-- +ok +== +SELECT finalize(regr_avgx(d, d+1) EXPORT_STATE) FROM dummy; +-- +ok +== +SELECT regr_avgy(d, d+1) FROM dummy; +-- +ok +== +SELECT finalize(regr_avgy(d, d+1) EXPORT_STATE) FROM dummy; +-- +ok +== +SELECT regr_slope(d, d+1) FROM dummy; +-- +ok +== +SELECT finalize(regr_slope(d, d+1) EXPORT_STATE) FROM dummy; +-- +ok +== +SELECT regr_intercept(d, d+1) FROM dummy; +-- +ok +== +SELECT finalize(regr_intercept(d, d+1) EXPORT_STATE) FROM dummy; +-- +ok +== +SELECT regr_r2(d, d+1) FROM dummy; +-- +ok +== +SELECT finalize(regr_r2(d, d+1) EXPORT_STATE) FROM dummy; +-- +ok +== +SELECT regr_sxx(d, d+1) FROM dummy; +-- +ok +== +SELECT finalize(regr_sxx(d, d+1) EXPORT_STATE) FROM dummy; +-- +ok +== +SELECT regr_syy(d, d+1) FROM dummy; +-- +ok +== +SELECT finalize(regr_syy(d, d+1) EXPORT_STATE) FROM dummy; +-- +ok +== +SELECT regr_sxy(d, d+1) FROM dummy; +-- +ok +== +SELECT finalize(regr_sxy(d, d+1) EXPORT_STATE) FROM dummy; +-- +ok +== +SELECT g, regr_count(d, d+1), regr_avgx(d, d+1), regr_avgy(d, d+1), regr_slope(d, d+1), regr_intercept(d, d+1), regr_r2(d, d+1), regr_sxx(d, d+1), regr_syy(d, d+1), regr_sxy(d, d+1) FROM dummy GROUP BY g ORDER BY g; +-- +ok +== +SELECT g, finalize(regr_count(d, d+1) EXPORT_STATE), finalize(regr_avgx(d, d+1) EXPORT_STATE), finalize(regr_avgy(d, d+1) EXPORT_STATE), finalize(regr_slope(d, d+1) EXPORT_STATE), finalize(regr_intercept(d, d+1) EXPORT_STATE), finalize(regr_r2(d, d+1) EXPORT_STATE), finalize(regr_sxx(d, d+1) EXPORT_STATE), finalize(regr_syy(d, d+1) EXPORT_STATE), finalize(regr_sxy(d, d+1) EXPORT_STATE) FROM dummy GROUP BY g ORDER BY g; +-- +ok +== +CREATE TABLE state_regr AS SELECT g, regr_slope(d, d+1) EXPORT_STATE slope_state, regr_count(d, d+1) EXPORT_STATE count_state FROM dummy GROUP BY g ORDER BY g; +-- +ok +== +SELECT g, regr_slope(d, d+1), regr_count(d, d+1) FROM dummy GROUP BY g ORDER BY g; +-- +ok +== +SELECT g, finalize(slope_state), finalize(count_state) FROM state_regr ORDER BY g; +-- +ok +== +SELECT (regr_count(1, 2) export_state)::ubigint +-- +ok +== +SELECT (covar_pop(1.0, 2.0) export_state)::struct(count ubigint, meanx double, meany double, co_moment double); +-- +ok +== +SELECT (var_pop(42.0) export_state)::struct(count ubigint, mean double, dsquared double); +-- +ok +== +SELECT g, finalize(sum(d) EXPORT_STATE)::integer, finalize(avg(d) EXPORT_STATE)::integer, finalize(count(d) EXPORT_STATE), finalize(min(d) EXPORT_STATE), finalize(max(d) EXPORT_STATE), finalize(stddev(d) EXPORT_STATE)::integer, finalize(first(d) EXPORT_STATE), finalize(last(d) EXPORT_STATE) FROM dummy GROUP BY g ORDER BY g; +-- +ok +== +CREATE TABLE state AS SELECT g, sum(d) EXPORT_STATE sum_state, avg(d) EXPORT_STATE avg_state, count(d) EXPORT_STATE count_state, first(d) EXPORT_STATE first_state, last(d) EXPORT_STATE last_state, min(d) EXPORT_STATE min_state, max(d) EXPORT_STATE max_state, stddev(d) EXPORT_STATE stddev_state FROM dummy GROUP BY g ORDER BY g; +-- +ok +== +SELECT g, finalize(sum_state), finalize(avg_state)::integer, finalize(count_state), finalize(min_state), finalize(max_state), finalize(stddev_state)::integer, finalize(first_state), finalize(last_state) FROM state ORDER BY g; +-- +ok +== +SELECT g, sum(d)*2 combined_sum FROM dummy GROUP BY g ORDER BY g; +-- +ok +== +select g, finalize(combine(sum(d) EXPORT_STATE, sum_state)) combined_sum from dummy join state using (g) group by g, sum_state ORDER BY g; +-- +ok +== +CREATE TABLE state2 AS SELECT g, sum(d) EXPORT_STATE sum_state FROM dummy WHERE g < 5 GROUP BY g ORDER BY g; +-- +ok +== +select g, finalize(sum_state) * 2 combined_sum from (select g, sum(d) EXPORT_STATE sum_state from dummy where g >= 5 GROUP BY g union all SELECT * FROM state2) ORDER BY g; +-- +ok +== +with groups as (select distinct g from dummy) +select g, FINALIZE(COMBINE(sum_state, sum_state2)) * 2 from groups left join state2 using(g) left join (select g, sum(d) EXPORT_STATE sum_state2 from dummy where g >= 5 GROUP BY g) using (g); +-- +ok +== +SELECT avg(d)::integer, count(d), min(d), max(d), first(d), last(d), kurtosis(d), kurtosis_pop(d) FROM dummy WHERE FALSE; +-- +ok +== +SELECT finalize(avg(d) EXPORT_STATE)::integer, finalize(count(d) EXPORT_STATE), finalize(first(d) EXPORT_STATE), finalize(last(d) EXPORT_STATE), finalize(min(d) EXPORT_STATE), finalize(max(d) EXPORT_STATE), finalize(kurtosis(d) EXPORT_STATE), finalize(kurtosis_pop(d) EXPORT_STATE) FROM dummy WHERE FALSE; +-- +ok +== +SELECT avg(d)::integer, count(d), min(d), max(d), first(d), last(d), kurtosis(d), kurtosis_pop(d) FROM (SELECT NULL::integer d); +-- +ok +== +SELECT finalize(avg(d) EXPORT_STATE)::integer, finalize(count(d) EXPORT_STATE), finalize(first(d) EXPORT_STATE), finalize(last(d) EXPORT_STATE), finalize(min(d) EXPORT_STATE), finalize(max(d) EXPORT_STATE), finalize(kurtosis(d) EXPORT_STATE), finalize(kurtosis_pop(d) EXPORT_STATE) FROM (SELECT NULL::integer d); +-- +ok +== +SELECT avg(d)::integer, count(d), min(d), max(d), first(d), last(d), kurtosis(d), kurtosis_pop(d) FROM (SELECT NULL::integer d, g FROM dummy); +-- +ok +== +SELECT finalize(avg(d) EXPORT_STATE)::integer, finalize(count(d) EXPORT_STATE), finalize(first(d) EXPORT_STATE), finalize(last(d) EXPORT_STATE), finalize(min(d) EXPORT_STATE), finalize(max(d) EXPORT_STATE), finalize(kurtosis(d) EXPORT_STATE), finalize(kurtosis_pop(d) EXPORT_STATE) FROM (SELECT NULL::integer d, g FROM dummy); +-- +ok +== +SELECT g, favg(d) FROM dummy GROUP BY g ORDER BY g; +-- +ok +== +SELECT g, FINALIZE(favg(d) EXPORT_STATE) FROM dummy GROUP BY g ORDER BY g; +-- +ok +== +select argmin(a,b), argmax(a,b) from (values (1,1), (2,2), (8,8), (10,10)) s(a,b); +-- +ok +== +select FINALIZE(argmin(a,b) EXPORT_STATE), FINALIZE(argmax(a,b) EXPORT_STATE) from (values (1,1), (2,2), (8,8), (10,10)) s(a,b); +-- +ok +== +SELECT FINALIZE(covar_pop(d, d+1) EXPORT_STATE) FROM dummy; +-- +ok +== +SELECT g, bool_and(d > 50) FROM dummy GROUP BY g ORDER BY g; +-- +ok +== +SELECT g, FINALIZE(bool_and(d > 50) EXPORT_STATE) FROM dummy GROUP BY g ORDER BY g; +-- +ok +== +SELECT g, bool_or(d > 50) FROM dummy GROUP BY g ORDER BY g; +-- +ok +== +SELECT g, FINALIZE(bool_or(d > 50) EXPORT_STATE) FROM dummy GROUP BY g ORDER BY g; +-- +ok +== +SELECT g, bit_and(d), bit_or(d), bit_xor(d) FROM dummy GROUP BY g ORDER BY g; +-- +ok +== +SELECT g, FINALIZE(bit_and(d) EXPORT_STATE), FINALIZE(bit_or(d) EXPORT_STATE), FINALIZE(bit_xor(d) EXPORT_STATE) FROM dummy GROUP BY g ORDER BY g; +-- +ok +== +SELECT (bit_and(42) export_state)::UINTEGER; +-- +ok +== +SELECT (bit_xor(100) export_state)::UBIGINT; +-- +ok +== +SELECT kurtosis(d) FROM dummy; +-- +ok +== +SELECT finalize(kurtosis(d) EXPORT_STATE) FROM dummy; +-- +ok +== +SELECT kurtosis_pop(d) FROM dummy; +-- +ok +== +SELECT finalize(kurtosis_pop(d) EXPORT_STATE) FROM dummy; +-- +ok +== +SELECT g, kurtosis(d) FROM dummy GROUP BY g ORDER BY g; +-- +ok +== +SELECT g, finalize(kurtosis(d) EXPORT_STATE) FROM dummy GROUP BY g ORDER BY g; +-- +ok +== +SELECT g, kurtosis_pop(d) FROM dummy GROUP BY g ORDER BY g; +-- +ok +== +SELECT g, finalize(kurtosis_pop(d) EXPORT_STATE) FROM dummy GROUP BY g ORDER BY g; +-- +ok +== +SELECT kurtosis(d) EXPORT_STATE FROM dummy; +-- +ok +== +SELECT kurtosis_pop(d) EXPORT_STATE FROM dummy; +-- +ok +== +SELECT FINALIZE(COMBINE(SUM(d) EXPORT_STATE, AVG(d) EXPORT_STATE)) FROM dummy; +-- +ok +== +SELECT finalize(avg(d)) from dummy; +-- +ok +== +SELECT finalize(avg(d)) from dummy group by g; +-- +ok +== +SELECT FINALIZE(COMBINE(MIN(d) EXPORT_STATE)) FROM dummy; +-- +ok +== +SELECT finalize(finalize(avg(d) EXPORT_STATE)) from dummy; +-- +ok +== +SELECT (count(42) export_state)::bigint +-- +ok +== +SELECT (count(*) export_state)::bigint +-- +ok +== +SELECT (sum(42) export_state)::hugeint; +-- +ok +== +SELECT (sum(100) export_state)::hugeint; +-- +ok +== +select avg(42) EXPORT_STATE over (); +-- +error: Parser Error: EXPORT_STATE is not supported for window functions! +== +CREATE TABLE state AS SELECT g, avg(d) EXPORT_STATE avg_state, count(d) EXPORT_STATE count_state, first(d) EXPORT_STATE first_state, last(d) EXPORT_STATE last_state, min(d) EXPORT_STATE min_state, max(d) EXPORT_STATE max_state FROM dummy GROUP BY g ORDER BY g; +-- +ok +== +CREATE VIEW state_view AS SELECT g, avg(d) EXPORT_STATE avg_state, count(d) EXPORT_STATE count_state, first(d) EXPORT_STATE first_state, last(d) EXPORT_STATE last_state, min(d) EXPORT_STATE min_state, max(d) EXPORT_STATE max_state FROM dummy GROUP BY g ORDER BY g; +-- +ok +== +SELECT g, avg(d)::integer, count(d), min(d), max(d), first(d), last(d) FROM dummy GROUP BY g ORDER BY g; +-- +ok +== +SELECT g, finalize(avg_state)::integer, finalize(count_state), finalize(min_state), finalize(max_state), finalize(first_state), finalize(last_state) FROM state ORDER BY g; +-- +ok +== +SELECT g, finalize(avg_state)::integer, finalize(count_state), finalize(min_state), finalize(max_state), finalize(first_state), finalize(last_state) FROM state_view ORDER BY g; +-- +ok +== +CREATE TABLE big_string_test AS +SELECT + 'group_' || (range % 3)::VARCHAR as g, + 'This is a very long string that exceeds the 12 byte inlining threshold for string_t' || range::VARCHAR as big_str, + range as r +FROM range(20); +-- +ok +== +SELECT + g, + first(big_str) as normal_first, + finalize(first(big_str) EXPORT_STATE) as exported_first +FROM big_string_test +GROUP BY g +ORDER BY g; +-- +ok +== +CREATE TABLE stored_big_string_state AS +SELECT + g, + first(big_str) EXPORT_STATE as first_state +FROM big_string_test +GROUP BY g; +-- +ok +== +SELECT + g, + first(big_str) as expected_value +FROM big_string_test +GROUP BY g +ORDER BY g; +-- +ok +== +SELECT + g, + finalize(first_state) as finalized_from_stored +FROM stored_big_string_state +ORDER BY g; +-- +ok +== +WITH state1 AS ( + SELECT g, first(big_str) EXPORT_STATE as state1 + FROM big_string_test + WHERE r < 10 + GROUP BY g +), +state2 AS ( + SELECT g, first(big_str) EXPORT_STATE as state2 + FROM big_string_test + WHERE r >= 10 + GROUP BY g +) +SELECT + COALESCE(s1.g, s2.g) as g, + finalize(COMBINE(s1.state1, s2.state2)) as combined_and_finalized +FROM state1 s1 +FULL OUTER JOIN state2 s2 ON s1.g = s2.g +ORDER BY g; +-- +ok +== +CREATE TABLE combined_big_string_state AS +WITH state1 AS ( + SELECT g, first(big_str) EXPORT_STATE as state1 + FROM big_string_test + WHERE r < 10 + GROUP BY g +), +state2 AS ( + SELECT g, first(big_str) EXPORT_STATE as state2 + FROM big_string_test + WHERE r >= 10 + GROUP BY g +) +SELECT + COALESCE(s1.g, s2.g) as g, + COMBINE(s1.state1, s2.state2) as combined_state +FROM state1 s1 +FULL OUTER JOIN state2 s2 ON s1.g = s2.g; +-- +ok +== +SELECT + g, + finalize(combined_state) as finalized_combined +FROM combined_big_string_state +ORDER BY g; +-- +ok +== +WITH state1 AS ( + SELECT g, first(big_str) EXPORT_STATE as state1 + FROM big_string_test + WHERE r < 5 + GROUP BY g +), +state2 AS ( + SELECT g, first(big_str) EXPORT_STATE as state2 + FROM big_string_test + WHERE r >= 5 AND r < 10 + GROUP BY g +), +state3 AS ( + SELECT g, first(big_str) EXPORT_STATE as state3 + FROM big_string_test + WHERE r >= 10 + GROUP BY g +) +SELECT + COALESCE(COALESCE(s1.g, s2.g), s3.g) as g, + finalize(COMBINE(COMBINE(s1.state1, s2.state2), s3.state3)) as triple_combined +FROM state1 s1 +FULL OUTER JOIN state2 s2 ON s1.g = s2.g +FULL OUTER JOIN state3 s3 ON COALESCE(s1.g, s2.g) = s3.g +ORDER BY g; +-- +ok +== +COPY (SELECT g, count(d) EXPORT_STATE s1 FROM dummy GROUP BY g) TO '{TEST_DIR}/count_state.parquet' (FORMAT PARQUET); +-- +ok +== +SELECT g, FINALIZE(COMBINE(s2, s1)) FROM (SELECT g, count(d) EXPORT_STATE s2 FROM dummy GROUP BY g) q1 JOIN '{TEST_DIR}/count_state.parquet' USING(g) ORDER BY g; +-- +ok +== +COPY (SELECT g, avg(d::DOUBLE) EXPORT_STATE s1 FROM dummy GROUP BY g) TO '{TEST_DIR}/avg_state.parquet' (FORMAT PARQUET); +-- +ok +== +SELECT g, FINALIZE(COMBINE(s2, to_aggregate_state(s1, 'avg', ['DOUBLE']))) FROM (SELECT g, avg(d::DOUBLE) EXPORT_STATE s2 FROM dummy GROUP BY g) q1 JOIN '{TEST_DIR}/avg_state.parquet' USING(g) ORDER BY g; +-- +ok +== +SELECT g, FINALIZE(to_aggregate_state(s1, 'avg', [make_type('DOUBLE')])) FROM '{TEST_DIR}/avg_state.parquet' ORDER BY g; +-- +ok +== +SELECT to_aggregate_state(42, 'avg', ['DOUBLE']); +-- +ok +== +SELECT to_aggregate_state(s1, g::VARCHAR, ['DOUBLE']) FROM '{TEST_DIR}/avg_state.parquet'; +-- +ok +== diff --git a/parser/testdata/corpus/sql/aggregate/aggregate_state_export/test_state_export_struct.test.metadata.json b/parser/testdata/corpus/sql/aggregate/aggregate_state_export/test_state_export_struct.test.metadata.json new file mode 100644 index 0000000..1c5bc0f --- /dev/null +++ b/parser/testdata/corpus/sql/aggregate/aggregate_state_export/test_state_export_struct.test.metadata.json @@ -0,0 +1,5 @@ +{ + "todo": { + "98c1f858af0c93f2": "transformer-raised parser error: upstream rejects in the transformer, not the grammar; expected to clear as transformers land (milestones 3-5)" + } +} diff --git a/parser/testdata/corpus/sql/aggregate/aggregate_state_export/test_stddev_export_state.test b/parser/testdata/corpus/sql/aggregate/aggregate_state_export/test_stddev_export_state.test new file mode 100644 index 0000000..09ca279 --- /dev/null +++ b/parser/testdata/corpus/sql/aggregate/aggregate_state_export/test_stddev_export_state.test @@ -0,0 +1,43 @@ +# source: test/sql/aggregate/aggregate_state_export/test_stddev_export_state.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +create table stddev_test(val integer, grp integer) +-- +ok +== +insert into stddev_test values (42, 1), (43, 1), (42, 2), (1000, 2), (NULL, 1), (NULL, 3) +-- +ok +== +CREATE TABLE stddev_state AS SELECT + STDDEV_POP(val) EXPORT_STATE pop_state, + VAR_SAMP(val) EXPORT_STATE samp_state, + STDDEV_SAMP(val) EXPORT_STATE stddev_samp_state, + VAR_POP(val) EXPORT_STATE var_pop_state, + SEM(val) EXPORT_STATE sem_state +FROM stddev_test; +-- +ok +== +SELECT pop_state::STRUCT(count UBIGINT, mean DOUBLE, dsquared DECIMAL(18,2)) FROM stddev_state; +-- +ok +== +SELECT samp_state::STRUCT(count UBIGINT, mean DOUBLE, dsquared DECIMAL(18,2)) FROM stddev_state; +-- +ok +== +SELECT stddev_samp_state::STRUCT(count UBIGINT, mean DOUBLE, dsquared DECIMAL(18,2)) FROM stddev_state; +-- +ok +== +SELECT var_pop_state::STRUCT(count UBIGINT, mean DOUBLE, dsquared DECIMAL(18,2)) FROM stddev_state; +-- +ok +== +SELECT sem_state::STRUCT(count UBIGINT, mean DOUBLE, dsquared DECIMAL(18,2)) FROM stddev_state; +-- +ok +== diff --git a/parser/testdata/corpus/sql/aggregate/aggregate_state_export/vector_minmax_export_state.test b/parser/testdata/corpus/sql/aggregate/aggregate_state_export/vector_minmax_export_state.test new file mode 100644 index 0000000..08953f7 --- /dev/null +++ b/parser/testdata/corpus/sql/aggregate/aggregate_state_export/vector_minmax_export_state.test @@ -0,0 +1,95 @@ +# source: test/sql/aggregate/aggregate_state_export/vector_minmax_export_state.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +SELECT finalize(min(v) EXPORT_STATE) FROM (SELECT NULL::struct(a int, b varchar) AS v WHERE false) t; +-- +ok +== +SELECT finalize(max(v) EXPORT_STATE) FROM (SELECT NULL::int[] AS v WHERE false) t; +-- +ok +== +SELECT finalize(min(NULL::struct(a int)) EXPORT_STATE); +-- +ok +== +SELECT finalize(min({'a': v}) EXPORT_STATE) FROM (VALUES (3), (1), (5)) t(v); +-- +ok +== +SELECT finalize(max({'a': v}) EXPORT_STATE) FROM (VALUES (3), (1), (5)) t(v); +-- +ok +== +SELECT finalize(min({'a': v, 'b': v::varchar}) EXPORT_STATE) FROM (VALUES (3), (1), (5)) t(v); +-- +ok +== +SELECT finalize(max({'a': v, 'b': v::varchar}) EXPORT_STATE) FROM (VALUES (3), (1), (5)) t(v); +-- +ok +== +SELECT finalize(min(v) EXPORT_STATE) FROM (VALUES ([3, 2]), ([1, 5]), ([2, 0])) t(v); +-- +ok +== +SELECT finalize(max(v) EXPORT_STATE) FROM (VALUES ([3, 2]), ([1, 5]), ([2, 0])) t(v); +-- +ok +== +SELECT finalize(combine( + min({'a': v}) EXPORT_STATE, + min({'a': v}) EXPORT_STATE +)) FROM (SELECT v FROM (VALUES (3), (1)) t(v)); +-- +ok +== +SELECT finalize(combine( + max({'a': v}) EXPORT_STATE, + max({'a': v}) EXPORT_STATE +)) FROM (SELECT v FROM (VALUES (3), (1)) t(v)); +-- +ok +== +SELECT finalize(combine_aggr(s)) FROM ( + SELECT min({'a': v}) EXPORT_STATE AS s FROM (VALUES (3), (4)) t(v) + UNION ALL + SELECT min({'a': v}) EXPORT_STATE AS s FROM (VALUES (5), (1)) t(v) +) t; +-- +ok +== +SELECT finalize(combine_aggr(s)) FROM ( + SELECT max({'a': v}) EXPORT_STATE AS s FROM (VALUES (3), (4)) t(v) + UNION ALL + SELECT max({'a': v}) EXPORT_STATE AS s FROM (VALUES (5), (1)) t(v) +) t; +-- +ok +== +SELECT finalize(combine_aggr(s)) FROM ( + SELECT min({'a': v}) EXPORT_STATE AS s FROM (VALUES (3)) t(v) + UNION ALL + SELECT min({'a': v}) EXPORT_STATE AS s FROM (SELECT NULL::struct(a int) AS v WHERE false) t +) t; +-- +ok +== +SELECT finalize(combine_aggr(s)) FROM ( + SELECT min({'a': v}) EXPORT_STATE AS s FROM (SELECT NULL::struct(a int) AS v WHERE false) t + UNION ALL + SELECT min({'a': v}) EXPORT_STATE AS s FROM (SELECT NULL::struct(a int) AS v WHERE false) t +) t; +-- +ok +== +SELECT finalize(combine_aggr(s)) FROM ( + SELECT min(v) EXPORT_STATE AS s FROM (VALUES ([3, 1])) t(v) + UNION ALL + SELECT min(v) EXPORT_STATE AS s FROM (SELECT NULL::int[] AS v WHERE false) t +) t; +-- +ok +== diff --git a/parser/testdata/corpus/sql/aggregate/aggregates/approx_top_k.test b/parser/testdata/corpus/sql/aggregate/aggregates/approx_top_k.test new file mode 100644 index 0000000..4067363 --- /dev/null +++ b/parser/testdata/corpus/sql/aggregate/aggregates/approx_top_k.test @@ -0,0 +1,90 @@ +# source: test/sql/aggregate/aggregates/approx_top_k.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +CREATE TABLE integers AS SELECT i%5 as even_groups, log(1 + i*i)::int as skewed_groups FROM range(10000) t(i); +-- +ok +== +SELECT list_sort(approx_top_k(even_groups, 10)) FROM integers +-- +ok +== +SELECT approx_top_k(skewed_groups, 5) FROM integers +-- +ok +== +SELECT approx_top_k(concat('this is a long prefix', skewed_groups::VARCHAR), 5) FROM integers +-- +ok +== +SELECT approx_top_k([skewed_groups], 5) FROM integers +-- +ok +== +SELECT approx_top_k({'i': skewed_groups}, 5) FROM integers +-- +ok +== +select approx_top_k(i, 0) from range(5) t(i) +-- +ok +== +select approx_top_k(i, -1) from range(5) t(i) +-- +ok +== +select approx_top_k(i, 999999999999999) from range(5) t(i) +-- +ok +== +select approx_top_k(i, NULL) from range(5) t(i) +-- +ok +== +CREATE TABLE ordered_groups AS SELECT (i % 8)::TINYINT AS g, i AS v FROM range(4000) t(i); +-- +ok +== +SELECT count(*) FROM ( + SELECT g, list_sort(approx_top_k(v, 5 ORDER BY v)) AS ordered, + list_sort(approx_top_k(v, 5)) AS unordered + FROM ordered_groups GROUP BY g +) WHERE ordered IS DISTINCT FROM unordered; +-- +ok +== +SELECT g FROM (SELECT g, approx_top_k(v, 3 ORDER BY v DESC) k FROM ordered_groups GROUP BY g) +WHERE len(k) <> 3; +-- +ok +== +SELECT approx_top_k(x, k) actual +FROM (VALUES + (1, 100, 1), + (2, 1, 2), + (3, 50, 3), + (4, 2, 1), + (5, 49, 2) +) AS t(id, x, k) +-- +ok +== +SELECT id, + approx_top_k(x, k) OVER ( + ORDER BY id + ROWS BETWEEN UNBOUNDED PRECEDING AND UNBOUNDED FOLLOWING + EXCLUDE CURRENT ROW + ) AS actual +FROM (VALUES + (1, 100, 1), + (2, 1, 2), + (3, 50, 3), + (4, 2, 1), + (5, 49, 2) +) AS t(id, x, k) +ORDER BY id; +-- +ok +== diff --git a/parser/testdata/corpus/sql/aggregate/aggregates/arg_min_max_n.test b/parser/testdata/corpus/sql/aggregate/aggregates/arg_min_max_n.test new file mode 100644 index 0000000..8f45c73 --- /dev/null +++ b/parser/testdata/corpus/sql/aggregate/aggregates/arg_min_max_n.test @@ -0,0 +1,57 @@ +# source: test/sql/aggregate/aggregates/arg_min_max_n.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +CREATE TABLE t1 (val VARCHAR, arg INT); +-- +ok +== +INSERT INTO t1 VALUES ('a', 2), ('a', 1), ('b', 5), ('b', 4), ('a', 3), ('b', 6); +-- +ok +== +SELECT arg_max(val, arg, 3 ORDER BY val DESC) FROM t1; +-- +ok +== +SELECT list(rs.val) FROM (SELECT val, arg, row_number() OVER (ORDER BY arg DESC) as rid FROM t1 ORDER BY val) as rs WHERE rid < 4; +-- +ok +== +SELECT arg_max(arg, val, 2 ORDER BY arg) FROM t1 GROUP BY val; +-- +ok +== +CREATE TABLE t2 AS SELECT i%5 as even_groups, i FROM range(10000) t(i); +-- +ok +== +SELECT arg_max(even_groups, i, 3) FROM t2; +-- +ok +== +select {FUNC}(arg, NULL) from t1; +-- +error: Parser Error: syntax error at or near "}" +== +SELECT {FUNC}(arg, -1) FROM t1; +-- +error: Parser Error: syntax error at or near "}" +== +select {FUNC}(arg, 1000000) from t1; +-- +error: Parser Error: syntax error at or near "}" +== +select {FUNC}(arg, val, NULL) from t1; +-- +error: Parser Error: syntax error at or near "}" +== +SELECT {FUNC}(arg, val, -1) FROM t1; +-- +error: Parser Error: syntax error at or near "}" +== +select {FUNC}(arg, val, 1000000) from t1; +-- +error: Parser Error: syntax error at or near "}" +== diff --git a/parser/testdata/corpus/sql/aggregate/aggregates/arg_min_max_n_tpch.test b/parser/testdata/corpus/sql/aggregate/aggregates/arg_min_max_n_tpch.test new file mode 100644 index 0000000..a19932f --- /dev/null +++ b/parser/testdata/corpus/sql/aggregate/aggregates/arg_min_max_n_tpch.test @@ -0,0 +1,64 @@ +# source: test/sql/aggregate/aggregates/arg_min_max_n_tpch.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +select min(l_orderkey, 3) from lineitem; +-- +ok +== +select max(l_orderkey, 3) from lineitem; +-- +ok +== +SELECT l_returnflag, max( + CASE WHEN l_returnflag='R' THEN null ELSE l_orderkey END, + CASE WHEN l_returnflag='N' THEN 5 ELSE 3 END) +FROM lineitem GROUP BY ALL ORDER BY ALL; +-- +ok +== +CREATE MACRO compute_top_k(table_name, group_col, val_col, k) AS TABLE +SELECT rs.grp, array_agg(rs.val ORDER BY rid) +FROM ( + SELECT group_col AS grp, val_col AS val, row_number() OVER (PARTITION BY group_col ORDER BY val_col DESC) as rid + FROM query_table(table_name::VARCHAR) ORDER BY group_col DESC +) as rs +WHERE rid <= k +GROUP BY ALL +ORDER BY ALL; +-- +ok +== +SET disabled_optimizers = 'top_n_window_elimination' +-- +ok +== +SELECT * FROM compute_top_k(lineitem, l_returnflag, l_orderkey, 3); +-- +ok +== +SELECT l_returnflag, max(l_orderkey, 3) FROM lineitem GROUP BY ALL ORDER BY ALL; +-- +ok +== +CREATE MACRO compute_bottom_k(table_name, group_col, val_col, k) AS TABLE +SELECT rs.grp, array_agg(rs.val ORDER BY rid) +FROM ( + SELECT group_col AS grp, val_col AS val, row_number() OVER (PARTITION BY group_col ORDER BY val_col ASC) as rid + FROM query_table(table_name::VARCHAR) ORDER BY group_col ASC +) as rs +WHERE rid <= k +GROUP BY ALL +ORDER BY ALL; +-- +ok +== +SELECT * FROM compute_bottom_k(lineitem, l_returnflag, l_orderkey, 3); +-- +ok +== +SELECT l_returnflag, min(l_orderkey, 3) FROM lineitem GROUP BY ALL ORDER BY ALL; +-- +ok +== diff --git a/parser/testdata/corpus/sql/aggregate/aggregates/arg_min_max_nulls_last.test b/parser/testdata/corpus/sql/aggregate/aggregates/arg_min_max_nulls_last.test new file mode 100644 index 0000000..003bed6 --- /dev/null +++ b/parser/testdata/corpus/sql/aggregate/aggregates/arg_min_max_nulls_last.test @@ -0,0 +1,49 @@ +# source: test/sql/aggregate/aggregates/arg_min_max_nulls_last.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +CREATE TABLE tbl AS SELECT * FROM VALUES (1, 5, 1), (1, NULL, 2), (1, 3, NULL), (2, NULL, NULL), (3, 1, NULL) t(grp, arg, val) +-- +ok +== +SELECT arg_max_nulls_last(arg, val) FROM tbl +-- +ok +== +SELECT arg_max_nulls_last(arg, val, 1) FROM tbl +-- +ok +== +SELECT arg_max_nulls_last(val, val, 4) FROM tbl +-- +ok +== +SELECT grp, arg_max_nulls_last(arg, val) FROM tbl GROUP BY grp ORDER BY grp +-- +ok +== +SELECT grp, arg_max_nulls_last(arg, val, 2) FROM tbl GROUP BY grp ORDER BY grp +-- +ok +== +SELECT arg_min_nulls_last(arg, val) FROM tbl +-- +ok +== +SELECT arg_min_nulls_last(arg, val, 1) FROM tbl +-- +ok +== +SELECT arg_min_nulls_last(val, val, 4) FROM tbl +-- +ok +== +SELECT grp, arg_min_nulls_last(arg, val) FROM tbl GROUP BY grp ORDER BY grp +-- +ok +== +SELECT grp, arg_min_nulls_last(arg, val, 2) FROM tbl GROUP BY grp ORDER BY grp +-- +ok +== diff --git a/parser/testdata/corpus/sql/aggregate/aggregates/binning.test b/parser/testdata/corpus/sql/aggregate/aggregates/binning.test new file mode 100644 index 0000000..1826d9e --- /dev/null +++ b/parser/testdata/corpus/sql/aggregate/aggregates/binning.test @@ -0,0 +1,249 @@ +# source: test/sql/aggregate/aggregates/binning.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +SELECT equi_width_bins(0, 10, 2, true) +-- +ok +== +SELECT equi_width_bins(1000000, 1000010, 2, true) +-- +ok +== +SELECT equi_width_bins(99, 101, 2, true) +-- +ok +== +SELECT equi_width_bins(9, 11, 2, true) +-- +ok +== +SELECT equi_width_bins(10, 11, 2, true) +-- +ok +== +SELECT equi_width_bins(0, 5, 10, true) +-- +ok +== +SELECT equi_width_bins(0, 10, 5, true) +-- +ok +== +SELECT equi_width_bins(-10, 0, 5, true) +-- +ok +== +SELECT equi_width_bins(-10, 10, 5, true) +-- +ok +== +SELECT equi_width_bins(0, 9, 5, true) +-- +ok +== +SELECT equi_width_bins(0, 1734, 10, true) +-- +ok +== +SELECT equi_width_bins(0, 1724, 10, true) +-- +ok +== +SELECT equi_width_bins(0, 1734, 10, false) +-- +ok +== +SELECT equi_width_bins(0, 39343341, 10, true) +-- +ok +== +SELECT equi_width_bins(1, 6000000, 7, true) +-- +ok +== +SELECT equi_width_bins(1, 6000000, 7, false) +-- +ok +== +SELECT equi_width_bins(-9223372036854775808, 9223372036854775807, 5, true) +-- +ok +== +SELECT equi_width_bins(-9223372036854775808, 9223372036854775807, 10, true) +-- +ok +== +SELECT equi_width_bins(-9223372036854775808, 9223372036854775807, 20, true) +-- +ok +== +SELECT equi_width_bins(-9223372036854775808, 9223372036854775807, 30, true) +-- +ok +== +SELECT equi_width_bins(0.0, 9.0, 5, true); +-- +ok +== +SELECT equi_width_bins(0.0, 9.0, 7, true); +-- +ok +== +SELECT unnest(equi_width_bins(0.0, 9.0, 7, false)); +-- +ok +== +SELECT equi_width_bins(0.0, 90.0, 5, true); +-- +ok +== +SELECT equi_width_bins(0.0, 1.0, 5, true); +-- +ok +== +SELECT equi_width_bins(-1.0, 0.0, 5, true); +-- +ok +== +SELECT equi_width_bins(-1.0, 1.0, 5, true); +-- +ok +== +SELECT unnest(equi_width_bins(-1e308, 1e308, 5, true)); +-- +ok +== +select equi_width_bins(0.0, 6.347, 3, true) AS boundaries; +-- +ok +== +select equi_width_bins(0.0, 6.347, 7, true) AS boundaries; +-- +ok +== +select equi_width_bins(0.0, 6.347, 10, true) AS boundaries; +-- +ok +== +select equi_width_bins(0.0, 6.347, 20, true) AS boundaries; +-- +ok +== +select equi_width_bins(0.0, 6.347, 30, true) AS boundaries; +-- +ok +== +select equi_width_bins(0.0, 3.974, 5, true) AS boundaries; +-- +ok +== +select equi_width_bins(0.0, 3.974, 7, true) AS boundaries; +-- +ok +== +select equi_width_bins(0.0, 3.974, 10, true) AS boundaries; +-- +ok +== +select equi_width_bins(0.0, 3.974, 20, true) AS boundaries; +-- +ok +== +select equi_width_bins(0.0, 3.974, 40, true) AS boundaries; +-- +ok +== +select equi_width_bins(0, 101, 5, true); +-- +ok +== +select equi_width_bins(0, 101.5, 5, true); +-- +ok +== +SELECT equi_width_bins(date '1992-01-01', date '2000-01-01', 2, true) +-- +ok +== +SELECT equi_width_bins(timestamp '1992-01-01', timestamp '2000-01-01', 2, true) +-- +ok +== +SELECT equi_width_bins(timestamp '1992-01-01 12:23:37', timestamp '2000-01-01 04:03:21', 2, true) +-- +ok +== +SELECT equi_width_bins(timestamp '1992-01-01 12:23:37', timestamp '2000-01-01 04:03:21', 5, true) +-- +ok +== +SELECT equi_width_bins(timestamp '1992-01-01 12:23:37', timestamp '1992-12-01 04:03:21', 4, true) +-- +ok +== +SELECT equi_width_bins(timestamp '1992-01-01 12:23:37', timestamp '1992-01-31 04:03:21', 4, true) +-- +ok +== +SELECT equi_width_bins(timestamp '1992-01-01 01:23:37.999', timestamp '1992-01-01 23:03:21.3', 4, true) +-- +ok +== +SELECT equi_width_bins(timestamp '1992-01-01 01:23:37.999', timestamp '1992-01-01 01:53:21.3', 4, true) +-- +ok +== +SELECT equi_width_bins(timestamp '1992-01-01 01:23:01.999', timestamp '1992-01-01 01:23:49.377', 4, true) +-- +ok +== +SELECT equi_width_bins(timestamp '1992-01-01 01:23:01.2', timestamp '1992-01-01 01:23:01.943', 4, true) +-- +ok +== +select equi_width_bins(timestamp '2024-06-21 15:00:00', timestamp '2024-06-22 9:00:00', 4, true); +-- +ok +== +select equi_width_bins(timestamp '2024-06-21 15:00:00', timestamp '2024-07-21 9:00:00', 4, true); +-- +ok +== +select equi_width_bins(timestamp '2024-06-21 15:00:00.123456', timestamp '2024-06-21 15:00:00.123458', 10, true); +-- +ok +== +SELECT EQUI_WIDTH_BINS(0, 10, 5999, TRUE) +-- +ok +== +SELECT EQUI_WIDTH_BINS(0, 10, 5999, false) +-- +ok +== +SELECT equi_width_bins(-0.0, -1.0, 5, true); +-- +ok +== +SELECT equi_width_bins(0.0, 'inf'::double, 5, true); +-- +ok +== +SELECT equi_width_bins(0.0, 'nan'::double, 5, true); +-- +ok +== +SELECT equi_width_bins(0.0, 1.0, -1, true); +-- +ok +== +SELECT equi_width_bins(0.0, 1.0, 99999999, true); +-- +ok +== +SELECT equi_width_bins('a'::VARCHAR, 'z'::VARCHAR, 2, true) +-- +ok +== diff --git a/parser/testdata/corpus/sql/aggregate/aggregates/bitstring_agg_empty.test b/parser/testdata/corpus/sql/aggregate/aggregates/bitstring_agg_empty.test new file mode 100644 index 0000000..f3aa225 --- /dev/null +++ b/parser/testdata/corpus/sql/aggregate/aggregates/bitstring_agg_empty.test @@ -0,0 +1,32 @@ +# source: test/sql/aggregate/aggregates/bitstring_agg_empty.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +SET debug_force_external=true; +-- +ok +== +CREATE TABLE t1 (k VARCHAR, el VARCHAR); +-- +ok +== +CREATE VIEW t1_v AS (SELECT * FROM t1 LIMIT 0); +-- +ok +== +CREATE TABLE el_ids (el VARCHAR, idx INTEGER); +-- +ok +== +INSERT INTO el_ids VALUES ('el', 10); +-- +ok +== +SELECT k, bitstring_agg(idx) +FROM t1_v +JOIN el_ids USING (el) +GROUP BY k; +-- +ok +== diff --git a/parser/testdata/corpus/sql/aggregate/aggregates/duckdb_fuzzer_4313.test b/parser/testdata/corpus/sql/aggregate/aggregates/duckdb_fuzzer_4313.test new file mode 100644 index 0000000..6d35df2 --- /dev/null +++ b/parser/testdata/corpus/sql/aggregate/aggregates/duckdb_fuzzer_4313.test @@ -0,0 +1,9 @@ +# source: test/sql/aggregate/aggregates/duckdb_fuzzer_4313.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +SELECT is_histogram_other_bin(x::BIGINT) FROM(VALUES(1), (NULL)) t(x); +-- +ok +== diff --git a/parser/testdata/corpus/sql/aggregate/aggregates/histogram_exact.test b/parser/testdata/corpus/sql/aggregate/aggregates/histogram_exact.test new file mode 100644 index 0000000..e3d6c40 --- /dev/null +++ b/parser/testdata/corpus/sql/aggregate/aggregates/histogram_exact.test @@ -0,0 +1,79 @@ +# source: test/sql/aggregate/aggregates/histogram_exact.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +CREATE TABLE obs(n BIGINT); +-- +ok +== +INSERT INTO obs VALUES (0), (5), (7), (12), (20), (23), (24), (25), (26), (28), (31), (34), (36), (41), (47) +-- +ok +== +SELECT histogram_exact(n, [10, 20, 30, 40, 50]) FROM obs +-- +ok +== +SELECT histogram_exact(n::double, [10, 20, 30, 40, 50]) FROM obs +-- +ok +== +SELECT histogram_exact((date '2000-01-01' + interval (n) days)::date, [date '2000-01-01' + interval (x) days for x in [10, 20, 30, 40, 50]]) FROM obs +-- +ok +== +SELECT histogram_exact(n::varchar, [10, 20, 30, 40, 50]) FROM obs +-- +ok +== +SELECT histogram_exact([n], [[x] for x in [10, 20, 30, 40, 50]]) FROM obs +-- +ok +== +SELECT case when is_histogram_other_bin(bin) then '(other values)' else bin::varchar end as bin, + count +FROM ( + SELECT UNNEST(map_keys(hist)) AS bin, UNNEST(map_values(hist)) AS count + FROM (SELECT histogram_exact(n, [10, 20, 30, 40, 50]) AS hist FROM obs) +) +-- +ok +== +SELECT case when is_histogram_other_bin(bin) then '(other values)' else bin::varchar end as bin, + count +FROM ( + SELECT UNNEST(map_keys(hist)) AS bin, UNNEST(map_values(hist)) AS count + FROM (SELECT histogram(n, [10, 20, 30, 40]) AS hist FROM obs) +) +-- +ok +== +SELECT histogram_exact(r, [0, 1, 2, 3]) FROM range(4) t(r); +-- +ok +== +SELECT histogram_exact(n, [10, 10, 20]) FROM obs +-- +ok +== +SELECT list_aggregate(map_values(histogram_exact(n, [10, 10, 20])), 'sum') FROM obs +-- +ok +== +SELECT is_histogram_other_bin(NULL) +-- +ok +== +SELECT is_histogram_other_bin([[1]]) +-- +ok +== +SELECT is_histogram_other_bin([]::INT[][][]) +-- +ok +== +SELECT is_histogram_other_bin({'i': NULL::INT[][]}) +-- +ok +== diff --git a/parser/testdata/corpus/sql/aggregate/aggregates/histogram_table_function.test b/parser/testdata/corpus/sql/aggregate/aggregates/histogram_table_function.test new file mode 100644 index 0000000..03bbc12 --- /dev/null +++ b/parser/testdata/corpus/sql/aggregate/aggregates/histogram_table_function.test @@ -0,0 +1,81 @@ +# source: test/sql/aggregate/aggregates/histogram_table_function.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +insert into integers values (42); +-- +ok +== +insert into integers values (84); +-- +ok +== +SELECT * FROM histogram_values(integers, i, bin_count := 2) +-- +ok +== +SELECT * FROM histogram_values(integers, k) +-- +ok +== +INSERT INTO integers FROM range(127) +-- +ok +== +SELECT * FROM histogram_values(integers, i, bin_count => 10, technique => 'equi-width') +-- +ok +== +SELECT bin, count FROM histogram(integers, i, bin_count := 10, technique := 'equi-width') +-- +ok +== +INSERT INTO integers VALUES (99999999) +-- +ok +== +SELECT COUNT(*), AVG(count) FROM histogram_values(integers, i, technique := 'equi-height') +-- +ok +== +SELECT * FROM histogram_values(integers, i%2, technique := 'sample') +-- +ok +== +SELECT * FROM histogram_values(integers, (i%2)::VARCHAR) +-- +ok +== +SELECT * FROM histogram_values(integers, (i%2)::VARCHAR, technique := 'equi-width') +-- +ok +== +SELECT COUNT(*), AVG(count) FROM histogram_values(integers, i::VARCHAR, technique := 'equi-height') +-- +ok +== +SELECT COUNT(bin), AVG(count) FROM histogram(integers, i::VARCHAR, technique := 'equi-height') +-- +ok +== +create table booleans(b bool); +-- +ok +== +insert into booleans select case when i%4=0 then true else false end from range(100) t(i) +-- +ok +== +SELECT * FROM histogram_values(booleans, b::INTEGER) +-- +ok +== +SELECT * FROM histogram_values(booleans, b) +-- +ok +== +SELECT * FROM histogram_values(integers, [i%2]) +-- +ok +== diff --git a/parser/testdata/corpus/sql/aggregate/aggregates/lttb.test b/parser/testdata/corpus/sql/aggregate/aggregates/lttb.test new file mode 100644 index 0000000..e129478 --- /dev/null +++ b/parser/testdata/corpus/sql/aggregate/aggregates/lttb.test @@ -0,0 +1,210 @@ +# source: test/sql/aggregate/aggregates/lttb.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +SELECT lttb(x::DOUBLE, y::DOUBLE, 5 ORDER BY x) +FROM (SELECT i AS x, (i * i)::DOUBLE AS y FROM range(10) t(i)) +-- +ok +== +SELECT lttb(x::DOUBLE, y::DOUBLE, 4 ORDER BY x) +FROM (SELECT i AS x, (i * i)::DOUBLE AS y FROM range(10) t(i)) +-- +ok +== +SELECT p.x, p.y +FROM (SELECT UNNEST(lttb(x::DOUBLE, y::DOUBLE, 4 ORDER BY x)) AS p + FROM (SELECT i AS x, (i * i)::DOUBLE AS y FROM range(10) t(i))) +-- +ok +== +SELECT len(l), l[1], l[len(l)] +FROM (SELECT lttb(x::DOUBLE, y::DOUBLE, 5 ORDER BY x) AS l + FROM (SELECT i AS x, (i * i)::DOUBLE AS y FROM range(100) t(i))) +-- +ok +== +SELECT lttb(x::DOUBLE, y::DOUBLE, 100 ORDER BY x) +FROM (SELECT i AS x, i::DOUBLE AS y FROM range(4) t(i)) +-- +ok +== +SELECT lttb(x::DOUBLE, y::DOUBLE, 2 ORDER BY x) +FROM (SELECT i AS x, i::DOUBLE AS y FROM range(10) t(i)) +-- +ok +== +SELECT len(lttb(x::DOUBLE, y, 5 ORDER BY x)) +FROM (SELECT i AS x, CASE WHEN i % 2 = 0 THEN NULL ELSE i::DOUBLE END AS y FROM range(20) t(i)) +-- +ok +== +SELECT lttb(x::DOUBLE, y::DOUBLE, 5 ORDER BY x) FROM range(0) t(x), (SELECT 1.0 y) WHERE false +-- +ok +== +SELECT lttb(x::DOUBLE, NULL::DOUBLE, 5 ORDER BY x) FROM range(10) t(x) +-- +ok +== +SELECT g, len(lttb(x::DOUBLE, y::DOUBLE, 5 ORDER BY x)) AS l +FROM (SELECT i % 3 AS g, i AS x, (i * 2)::DOUBLE AS y FROM range(20) t(i)) +GROUP BY g ORDER BY g +-- +ok +== +SELECT g, len(l), l[1].x, l[len(l)].x +FROM ( + SELECT g, lttb(x::DOUBLE, y::DOUBLE, 4 ORDER BY x) AS l + FROM (SELECT CASE WHEN i < 100 THEN 0 WHEN i < 110 THEN 1 ELSE 2 END AS g, + i AS x, (i * i) AS y FROM range(115) t(i)) + GROUP BY g +) ORDER BY g +-- +ok +== +SELECT g, len(lttb(x::DOUBLE, y, 4 ORDER BY x)) +FROM (SELECT CASE WHEN i < 100 THEN 0 WHEN i < 110 THEN 1 ELSE 2 END AS g, + i AS x, CASE WHEN i % 3 = 0 THEN NULL ELSE (i % 7)::DOUBLE END AS y FROM range(115) t(i)) +GROUP BY g ORDER BY g +-- +ok +== +SELECT len(lttb(ts, v, 4 ORDER BY ts)) +FROM (SELECT TIMESTAMP '2020-01-01' + INTERVAL (i) HOUR AS ts, (i % 7)::DOUBLE AS v FROM range(50) t(i)) +-- +ok +== +SELECT len(lttb(ts::TIMESTAMP_S, v, 3 ORDER BY ts)), + len(lttb(ts::TIMESTAMP_MS, v, 3 ORDER BY ts)), + len(lttb(ts::TIMESTAMP_NS, v, 3 ORDER BY ts)) +FROM (SELECT TIMESTAMP '2020-01-01' + INTERVAL (i) HOUR AS ts, i::DOUBLE AS v FROM range(20) t(i)) +-- +ok +== +SELECT lttb(ts, v, 3 ORDER BY ts) +FROM (SELECT TIMESTAMP '2020-01-01' + INTERVAL (i) DAY AS ts, (i * i)::DOUBLE AS v FROM range(5) t(i)) +-- +ok +== +SELECT lttb(x::DOUBLE, ts, 3 ORDER BY x) +FROM (SELECT i AS x, TIMESTAMP '2020-01-01' + INTERVAL (i * i) DAY AS ts FROM range(5) t(i)) +-- +ok +== +SELECT lttb(ts, y, 3 ORDER BY ts) +FROM ( + VALUES + (TIMESTAMPTZ '2020-01-01 00:00:00+00', 0::DOUBLE), + (TIMESTAMPTZ '2020-01-01 01:00:00+00', 1::DOUBLE), + (TIMESTAMPTZ '2020-01-01 02:00:00+00', 2::DOUBLE), + (TIMESTAMPTZ '2020-01-01 03:00:00+00', 3::DOUBLE), + (TIMESTAMPTZ '2020-01-01 04:00:00+00', 4::DOUBLE) +) t(ts, y); +-- +ok +== +WITH data AS ( + SELECT i, + (CASE WHEN i = 37 THEN 1000 ELSE i % 7 END)::DOUBLE AS y, + make_timestamp_ns(1577836800000000000 + i) AS ts + FROM range(100) t(i) +), +num AS ( + SELECT UNNEST(lttb(i::DOUBLE, y, 10 ORDER BY i)) AS p + FROM data +), +ns AS ( + SELECT UNNEST(lttb(ts, y, 10 ORDER BY ts)) AS p + FROM data +) +SELECT (SELECT list(p.x ORDER BY p.x) FROM num) + = (SELECT list((epoch_ns(p.x) - 1577836800000000000)::DOUBLE ORDER BY epoch_ns(p.x)) FROM ns) +-- +ok +== +SELECT lttb(x::FLOAT, y::FLOAT, 4 ORDER BY x) +FROM (SELECT i AS x, (i * i) AS y FROM range(10) t(i)) +-- +ok +== +SELECT typeof(lttb(x::FLOAT, y::DOUBLE, 4 ORDER BY x)), typeof(lttb(x::DOUBLE, y::FLOAT, 4 ORDER BY x)) +FROM (SELECT i AS x, (i * i) AS y FROM range(10) t(i)) +-- +ok +== +SELECT lttb(x::DOUBLE, y::DOUBLE, x::BIGINT ORDER BY x) FROM (SELECT i x, i::DOUBLE y FROM range(10) t(i)) +-- +ok +== +SELECT lttb(x::DOUBLE, y::DOUBLE, 1 ORDER BY x) FROM (SELECT i x, i::DOUBLE y FROM range(10) t(i)) +-- +ok +== +SELECT lttb('a', 'b', 5) +-- +ok +== +SELECT (finalize(lttb(x::DOUBLE, y::DOUBLE, 5 ORDER BY x) EXPORT_STATE) + = (SELECT lttb(x::DOUBLE, y::DOUBLE, 5 ORDER BY x) FROM (SELECT i x, (i * i)::DOUBLE y FROM range(20) t(i)))) +FROM (SELECT i x, (i * i)::DOUBLE y FROM range(20) t(i)) +-- +ok +== +SELECT len(l), l[1], l[len(l)] +FROM (SELECT lttb(x::DOUBLE, y::DOUBLE, 100 ORDER BY x) AS l + FROM (SELECT i AS x, (i * i)::DOUBLE AS y FROM range(10000) t(i))) +-- +ok +== +SELECT len(lttb(x::DOUBLE, y, 100 ORDER BY x)) +FROM (SELECT i AS x, CASE WHEN i % 7 = 0 THEN NULL ELSE i::DOUBLE END AS y FROM range(10000) t(i)) +-- +ok +== +SELECT len(lttb((x // 2)::DOUBLE, x::DOUBLE, 4 ORDER BY x)) +FROM range(10) t(x) +-- +ok +== +SET memory_limit = '500MB' +-- +ok +== +SELECT lttb(x::DOUBLE, x::DOUBLE, 5000000000 ORDER BY x) FROM range(3) t(x) +-- +ok +== +CREATE TABLE lttb_states AS +SELECT lttb(x::DOUBLE, y::DOUBLE, 3) EXPORT_STATE AS st +FROM (SELECT i x, (i * i)::DOUBLE y FROM range(10) t(i)) WHERE false; +-- +ok +== +DELETE FROM lttb_states; +-- +ok +== +INSERT INTO lttb_states VALUES ([{'x':0.0,'y':0.0}, NULL, NULL, {'x':3.0,'y':3.0}, {'x':4.0,'y':4.0}, + {'x':5.0,'y':5.0}, {'x':6.0,'y':6.0}, {'x':7.0,'y':7.0}, {'x':8.0,'y':8.0}, + {'x':9.0,'y':9.0}]); +-- +ok +== +INSERT INTO lttb_states VALUES ([{'x':100.0,'y':1.0}, {'x':101.0,'y':2.0}, {'x':102.0,'y':3.0}]); +-- +ok +== +INSERT INTO lttb_states VALUES ([NULL, NULL]); +-- +ok +== +INSERT INTO lttb_states VALUES ([{'x':1.0,'y':NULL}, {'x':2.0,'y':5.0}, {'x':3.0,'y':6.0}]); +-- +ok +== +SELECT finalize(st) FROM lttb_states +-- +ok +== diff --git a/parser/testdata/corpus/sql/aggregate/aggregates/max_n_all_types_grouped.test b/parser/testdata/corpus/sql/aggregate/aggregates/max_n_all_types_grouped.test new file mode 100644 index 0000000..a12b3e5 --- /dev/null +++ b/parser/testdata/corpus/sql/aggregate/aggregates/max_n_all_types_grouped.test @@ -0,0 +1,43 @@ +# source: test/sql/aggregate/aggregates/max_n_all_types_grouped.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +CREATE MACRO compute_top_k(table_name, group_col, val_col, k) AS TABLE +SELECT rs.grp, array_agg(rs.val) +FROM ( + SELECT group_col AS grp, val_col AS val, row_number() OVER (PARTITION BY group_col ORDER BY val_col DESC) as rid + FROM query_table(table_name::VARCHAR) ORDER BY group_col DESC +) as rs +WHERE rid <= k +GROUP BY ALL +ORDER BY ALL; +-- +ok +== +create table all_types as from test_all_types() +-- +ok +== +CREATE OR REPLACE TABLE tbl AS SELECT * FROM + (SELECT {val_col} as val_col FROM all_types) + CROSS JOIN (SELECT i % 2 as grp_col FROM range(5) as r(i)); +-- +error: Parser Error: syntax error at or near "}" +== +CREATE OR REPLACE TABLE window_table AS SELECT * FROM compute_top_k(tbl, grp_col, val_col, 2) as rs(grp, res); +-- +ok +== +SET disabled_optimizers = '' +-- +ok +== +CREATE OR REPLACE TABLE agg_table AS SELECT grp_col as grp, max(val_col, 2) as res FROM tbl GROUP BY ALL ORDER BY ALL; +-- +ok +== +SELECT * FROM (SELECT * FROM window_table ORDER BY rowid) EXCEPT SELECT * FROM (SELECT * FROM agg_table ORDER BY rowid); +-- +ok +== diff --git a/parser/testdata/corpus/sql/aggregate/aggregates/mode_rewrite.test b/parser/testdata/corpus/sql/aggregate/aggregates/mode_rewrite.test new file mode 100644 index 0000000..fc610ba --- /dev/null +++ b/parser/testdata/corpus/sql/aggregate/aggregates/mode_rewrite.test @@ -0,0 +1,253 @@ +# source: test/sql/aggregate/aggregates/mode_rewrite.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +SET threads=4; +-- +ok +== +CREATE TABLE mode_rewrite(g INTEGER, v VARCHAR, ord INTEGER, keep BOOLEAN); +-- +ok +== +INSERT INTO mode_rewrite VALUES + (1, 'b', 1, true), + (1, 'a', 2, true), + (1, 'a', 3, false), + (1, 'b', 4, true), + (1, 'a', 5, false), + (2, 'z', 1, true), + (2, 'y', 2, true), + (3, NULL, 1, true), + (3, 'q', 2, false); +-- +ok +== +SELECT g, mode(v ORDER BY ord), mode(v ORDER BY ord DESC) +FROM mode_rewrite +GROUP BY g +ORDER BY g; +-- +ok +== +SELECT g, mode(v) FILTER (WHERE keep) +FROM mode_rewrite +WHERE g <> 2 +GROUP BY g +ORDER BY g; +-- +ok +== +SELECT mode(v) IN ('y', 'z'), count(*) +FROM mode_rewrite +WHERE g = 2; +-- +ok +== +SELECT mode(DISTINCT v ORDER BY v), mode(DISTINCT v ORDER BY v DESC) +FROM mode_rewrite +WHERE g = 1; +-- +ok +== +WITH d(v, ord) AS ( + VALUES ('a', NULL), ('a', 4), ('b', 3), ('b', 5) +) +SELECT mode(v ORDER BY ord ASC NULLS LAST), + mode(v ORDER BY ord DESC NULLS FIRST), + mode(v ORDER BY ord DESC NULLS LAST) +FROM d; +-- +ok +== +SELECT mode(v), count(DISTINCT ord), sum(ord) +FROM mode_rewrite +WHERE g = 1; +-- +ok +== +SELECT mode(v), round(entropy(v), 6), round(entropy(DISTINCT v), 6) +FROM mode_rewrite +WHERE g = 1; +-- +ok +== +WITH d(v) AS ( + VALUES ('nan'::DOUBLE), ('nan'::DOUBLE), ('nan'::DOUBLE), (1.0), (1.0) +) +SELECT mode(v)::VARCHAR, round(entropy(v), 6)::VARCHAR FROM d; +-- +ok +== +WITH d(v) AS ( + VALUES ('nan'::FLOAT), ('nan'::FLOAT), ('nan'::FLOAT), (1.0), (1.0) +) +SELECT mode(v)::VARCHAR, round(entropy(v), 6)::VARCHAR FROM d; +-- +ok +== +WITH d(v) AS ( + VALUES ('nan'::DOUBLE), ('nan'::DOUBLE), ('nan'::DOUBLE), (1.0), (1.0) +) +SELECT mode(v) OVER ()::VARCHAR, round(entropy(v) OVER (), 6)::VARCHAR +FROM d +LIMIT 1; +-- +ok +== +WITH d(i, v) AS ( + VALUES (1, 'nan'::DOUBLE), (2, 'nan'::DOUBLE), (3, 1.0), (4, 1.0), (5, 'nan'::DOUBLE) +) +SELECT i, mode(v) OVER (ORDER BY i ROWS BETWEEN 2 PRECEDING AND CURRENT ROW)::VARCHAR +FROM d +ORDER BY i; +-- +ok +== +SELECT list_mode(values)::VARCHAR, round(list_entropy(values), 6)::VARCHAR +FROM (VALUES (['nan'::DOUBLE, 'nan'::DOUBLE, 'nan'::DOUBLE, 1.0, 1.0])) t(values); +-- +ok +== +SELECT g, + mode(v ORDER BY ord) FILTER (WHERE keep), + mode(ord) FILTER (WHERE false) +FROM mode_rewrite +GROUP BY g +ORDER BY g; +-- +ok +== +SELECT mode(v) FROM mode_rewrite WHERE false; +-- +ok +== +SELECT mode([v]), mode({'v': v}) +FROM mode_rewrite +WHERE g = 1; +-- +ok +== +SELECT g, mode(v) AS m +FROM mode_rewrite +GROUP BY g +HAVING mode(v) = 'a' +ORDER BY mode(v); +-- +ok +== +SELECT g, mode(v), GROUPING(g) +FROM mode_rewrite +WHERE g IN (1, 3) +GROUP BY CUBE(g) +ORDER BY GROUPING(g), g; +-- +ok +== +SELECT mode(v) OVER (), list_mode(list(v ORDER BY ord) OVER ()) +FROM mode_rewrite +WHERE g = 1 +ORDER BY ord +LIMIT 1; +-- +ok +== +CREATE TABLE mode_rewrite_errors(value VARCHAR, keep BOOLEAN); +-- +ok +== +INSERT INTO mode_rewrite_errors VALUES ('bad', false), ('1', true); +-- +ok +== +SELECT mode(value::INTEGER) FILTER (WHERE keep) FROM mode_rewrite_errors; +-- +ok +== +SELECT mode(value ORDER BY value::INTEGER) FILTER (WHERE keep) FROM mode_rewrite_errors; +-- +ok +== +PRAGMA disable_verification; +-- +ok +== +CREATE SEQUENCE mode_rewrite_seq START 1; +-- +ok +== +SELECT m BETWEEN 1 AND 4, total +FROM ( + SELECT mode(nextval('mode_rewrite_seq')) AS m, sum(i) AS total + FROM range(4) tbl(i) +); +-- +ok +== +SELECT currval('mode_rewrite_seq'); +-- +ok +== +CREATE SEQUENCE mode_rewrite_order_seq START 1; +-- +ok +== +SELECT mode(v ORDER BY nextval('mode_rewrite_order_seq')) +FROM (VALUES ('b'), ('a')) tbl(v); +-- +ok +== +SELECT currval('mode_rewrite_order_seq'); +-- +ok +== +PRAGMA explain_output='optimized_only'; +-- +ok +== +EXPLAIN (FORMAT JSON) +SELECT g, mode(v), entropy(v) FROM mode_rewrite GROUP BY g; +-- +ok +== +SET disabled_optimizers='distinct_aggregate_rewrite'; +-- +ok +== +EXPLAIN (FORMAT JSON) +SELECT mode(v), count(DISTINCT ord) FROM mode_rewrite; +-- +ok +== +SET disabled_optimizers=''; +-- +ok +== +SET enable_optimizer=false; +-- +ok +== +EXPLAIN (FORMAT JSON) +SELECT mode(v), entropy(v), histogram(v) FROM mode_rewrite; +-- +ok +== +SET enable_optimizer=true; +-- +ok +== +SET debug_verify_serializer=true; +-- +ok +== +SELECT mode(v), round(entropy(v), 6) +FROM mode_rewrite +WHERE g = 1; +-- +ok +== +SET debug_verify_serializer=false; +-- +ok +== diff --git a/parser/testdata/corpus/sql/aggregate/aggregates/mode_rewrite_memory.test b/parser/testdata/corpus/sql/aggregate/aggregates/mode_rewrite_memory.test new file mode 100644 index 0000000..6e847f3 --- /dev/null +++ b/parser/testdata/corpus/sql/aggregate/aggregates/mode_rewrite_memory.test @@ -0,0 +1,14 @@ +# source: test/sql/aggregate/aggregates/mode_rewrite_memory.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +SET memory_limit='32MB'; +-- +ok +== +SELECT mode(i ORDER BY i DESC) = 999999, entropy(i ORDER BY i DESC) > 19 +FROM range(1000000) t(i); +-- +ok +== diff --git a/parser/testdata/corpus/sql/aggregate/aggregates/string_agg_union.test b/parser/testdata/corpus/sql/aggregate/aggregates/string_agg_union.test new file mode 100644 index 0000000..195c481 --- /dev/null +++ b/parser/testdata/corpus/sql/aggregate/aggregates/string_agg_union.test @@ -0,0 +1,27 @@ +# source: test/sql/aggregate/aggregates/string_agg_union.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +WITH my_data as ( + SELECT 'text1'::varchar(1000) as my_column union all + SELECT 'text1'::varchar(1000) as my_column union all + SELECT 'text1'::varchar(1000) as my_column + ) + SELECT string_agg(my_column,', ') as my_string_agg + FROM my_data +-- +ok +== +WITH my_data as ( + SELECT 1 as dummy, 'text1'::varchar(1000) as my_column union all + SELECT 1 as dummy, 'text1'::varchar(1000) as my_column union all + SELECT 1 as dummy, 'text1'::varchar(1000) as my_column + ) + SELECT string_agg(my_column,', ') as my_string_agg + FROM my_data + GROUP BY + dummy +-- +ok +== diff --git a/parser/testdata/corpus/sql/aggregate/aggregates/test_aggr_string.test b/parser/testdata/corpus/sql/aggregate/aggregates/test_aggr_string.test new file mode 100644 index 0000000..7a3eb6b --- /dev/null +++ b/parser/testdata/corpus/sql/aggregate/aggregates/test_aggr_string.test @@ -0,0 +1,54 @@ +# source: test/sql/aggregate/aggregates/test_aggr_string.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +SELECT NULL as a, NULL as b, NULL as c, NULL as d, 1 as id UNION SELECT 'Кирилл' as a, 'Müller' as b, '我是谁' as c, 'ASCII' as d, 2 as id ORDER BY 1 +-- +ok +== +CREATE TABLE test (a INTEGER, s VARCHAR); +-- +ok +== +INSERT INTO test VALUES (11, 'hello'), (12, 'world'), (11, NULL) +-- +ok +== +SELECT COUNT(*), COUNT(s) FROM test; +-- +ok +== +SELECT a, COUNT(*), COUNT(s) FROM test GROUP BY a ORDER BY a; +-- +ok +== +SELECT s, SUM(a) FROM test GROUP BY s ORDER BY s; +-- +ok +== +INSERT INTO test VALUES (11, 'hello'), (12, 'world') +-- +ok +== +SELECT COUNT(*), COUNT(s), COUNT(DISTINCT s) FROM test; +-- +ok +== +SELECT a, COUNT(*), COUNT(s), COUNT(DISTINCT s) FROM test GROUP BY a ORDER BY a; +-- +ok +== +SELECT a, COUNT(*), COUNT(s), COUNT(DISTINCT s) FROM test WHERE s IS NOT NULL GROUP BY a ORDER BY a; +-- +ok +== +CREATE TABLE test_strings(s VARCHAR); +INSERT INTO test_strings VALUES ('aaaaaaaahello'), ('bbbbbbbbbbbbbbbbbbbbhello'), ('ccccccccccccccchello'), ('aaaaaaaaaaaaaaaaaaaaaaaahello');; +-- +ok +== +SELECT MIN(s), MAX(s) FROM test_strings; +-- +ok +== diff --git a/parser/testdata/corpus/sql/aggregate/aggregates/test_aggregate_types.test b/parser/testdata/corpus/sql/aggregate/aggregates/test_aggregate_types.test new file mode 100644 index 0000000..41293f4 --- /dev/null +++ b/parser/testdata/corpus/sql/aggregate/aggregates/test_aggregate_types.test @@ -0,0 +1,105 @@ +# source: test/sql/aggregate/aggregates/test_aggregate_types.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +CREATE TABLE strings(s STRING, g INTEGER) +-- +ok +== +INSERT INTO strings VALUES ('hello', 0), ('world', 1), (NULL, 0), ('r', 1) +-- +ok +== +SELECT COUNT(*), COUNT(s), MIN(s), MAX(s) FROM strings +-- +ok +== +SELECT COUNT(*), COUNT(s), MIN(s), MAX(s) FROM strings WHERE s IS NULL +-- +ok +== +SELECT STRING_AGG(s, ' '), STRING_AGG(s, ''), STRING_AGG('', ''), STRING_AGG('hello', ' ') FROM strings +-- +ok +== +SELECT g, COUNT(*), COUNT(s), MIN(s), MAX(s), STRING_AGG(s, ' ') FROM strings GROUP BY g ORDER BY g +-- +ok +== +SELECT g, COUNT(*), COUNT(s), MIN(s), MAX(s), STRING_AGG(DISTINCT g::VARCHAR ORDER BY g::VARCHAR DESC) FROM strings GROUP BY g ORDER BY g; +-- +ok +== +SELECT g, COUNT(*), COUNT(s), MIN(s), MAX(s), STRING_AGG(DISTINCT s ORDER BY s ASC) FROM strings GROUP BY g ORDER BY g; +-- +ok +== +SELECT g, COUNT(*), COUNT(s), MIN(s), MAX(s), STRING_AGG(s, ' ') FROM strings WHERE s IS NULL OR s <> 'hello' GROUP BY g ORDER BY g +-- +ok +== +SELECT SUM(s) FROM strings GROUP BY g ORDER BY g +-- +ok +== +SELECT AVG(s) FROM strings GROUP BY g ORDER BY g +-- +ok +== +CREATE TABLE booleans(b BOOLEAN, g INTEGER) +-- +ok +== +INSERT INTO booleans VALUES (false, 0), (true, 1), (NULL, 0), (false, 1) +-- +ok +== +SELECT COUNT(*), COUNT(b), MIN(b), MAX(b) FROM booleans +-- +ok +== +SELECT COUNT(*), COUNT(b), MIN(b), MAX(b) FROM booleans WHERE b IS NULL +-- +ok +== +SELECT g, COUNT(*), COUNT(b), MIN(b), MAX(b) FROM booleans GROUP BY g ORDER BY g +-- +ok +== +SELECT g, COUNT(*), COUNT(b), MIN(b), MAX(b) FROM booleans WHERE b IS NULL OR b=true GROUP BY g ORDER BY g +-- +ok +== +SELECT SUM(b) FROM booleans GROUP BY g ORDER BY g +-- +ok +== +SELECT AVG(b) FROM booleans GROUP BY g ORDER BY g +-- +ok +== +CREATE TABLE integers(i INTEGER, g INTEGER) +-- +ok +== +INSERT INTO integers VALUES (12, 0), (22, 1), (NULL, 0), (14, 1) +-- +ok +== +SELECT COUNT(*), COUNT(i), MIN(i), MAX(i), SUM(i) FROM integers +-- +ok +== +SELECT COUNT(*), COUNT(i), MIN(i), MAX(i), SUM(i) FROM INTEGERS WHERE i IS NULL +-- +ok +== +SELECT g, COUNT(*), COUNT(i), MIN(i), MAX(i), SUM(i) FROM integers GROUP BY g ORDER BY g +-- +ok +== +SELECT g, COUNT(*), COUNT(i), MIN(i), MAX(i), SUM(i) FROM integers WHERE i IS NULL OR i > 15 GROUP BY g ORDER BY g +-- +ok +== diff --git a/parser/testdata/corpus/sql/aggregate/aggregates/test_aggregate_types_scalar.test b/parser/testdata/corpus/sql/aggregate/aggregates/test_aggregate_types_scalar.test new file mode 100644 index 0000000..1916137 --- /dev/null +++ b/parser/testdata/corpus/sql/aggregate/aggregates/test_aggregate_types_scalar.test @@ -0,0 +1,141 @@ +# source: test/sql/aggregate/aggregates/test_aggregate_types_scalar.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +SELECT COUNT(), COUNT(1), COUNT(*), COUNT(NULL), COUNT('hello'), COUNT(DATE '1992-02-02') +-- +ok +== +SELECT COUNT(1, 2) +-- +ok +== +SELECT SUM(1), SUM(NULL), SUM(33.3) +-- +ok +== +SELECT SUM(True) +-- +ok +== +SELECT SUM('hello') +-- +ok +== +SELECT SUM(DATE '1992-02-02') +-- +ok +== +SELECT SUM() +-- +ok +== +SELECT SUM(1, 2) +-- +ok +== +SELECT MIN(1), MIN(NULL), MIN(33.3), MIN('hello'), MIN(True), MIN(DATE '1992-02-02'), MIN(TIMESTAMP '2008-01-01 00:00:01') +-- +ok +== +SELECT MIN() +-- +ok +== +SELECT MIN(1, 2) +-- +ok +== +SELECT MAX(1), MAX(NULL), MAX(33.3), MAX('hello'), MAX(True), MAX(DATE '1992-02-02'), MAX(TIMESTAMP '2008-01-01 00:00:01') +-- +ok +== +SELECT MAX() +-- +ok +== +SELECT MAX(1, 2) +-- +ok +== +SELECT FIRST(1), FIRST(NULL), FIRST(33.3), FIRST('hello'), FIRST(True), FIRST(DATE '1992-02-02'), FIRST(TIMESTAMP '2008-01-01 00:00:01') +-- +ok +== +SELECT FIRST() +-- +ok +== +SELECT FIRST(1, 2) +-- +ok +== +SELECT LAST(1), LAST(NULL), LAST(33.3), LAST('hello'), LAST(True), LAST(DATE '1992-02-02'), LAST(TIMESTAMP '2008-01-01 00:00:01') +-- +ok +== +SELECT LAST() +-- +ok +== +SELECT LAST(1, 2) +-- +ok +== +SELECT AVG(1), AVG(NULL), AVG(33.3) +-- +ok +== +SELECT AVG(True) +-- +ok +== +SELECT AVG('hello') +-- +ok +== +SELECT AVG(DATE '1992-02-02') +-- +ok +== +SELECT AVG() +-- +ok +== +SELECT AVG(1, 2) +-- +ok +== +SELECT STRING_AGG('hello') +-- +ok +== +SELECT STRING_AGG('hello', ' '), STRING_AGG('hello', NULL), STRING_AGG(NULL, ' '), STRING_AGG(NULL, NULL), STRING_AGG('', '') +-- +ok +== +SELECT STRING_AGG() +-- +ok +== +SELECT STRING_AGG(1, 2, 3) +-- +ok +== +CREATE TABLE test_val(val INT) +-- +ok +== +INSERT INTO test_val VALUES(1), (2), (3), (3), (2) +-- +ok +== +SELECT STRING_AGG(DISTINCT val::VARCHAR ORDER BY val::VARCHAR DESC) from test_val; +-- +ok +== +SELECT COUNT(NULL), STRING_AGG(DISTINCT val::VARCHAR ORDER BY val::VARCHAR ASC) from test_val; +-- +ok +== diff --git a/parser/testdata/corpus/sql/aggregate/aggregates/test_any_value.test b/parser/testdata/corpus/sql/aggregate/aggregates/test_any_value.test new file mode 100644 index 0000000..41c2235 --- /dev/null +++ b/parser/testdata/corpus/sql/aggregate/aggregates/test_any_value.test @@ -0,0 +1,164 @@ +# source: test/sql/aggregate/aggregates/test_any_value.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +CREATE TABLE tbl(i INTEGER) +-- +ok +== +INSERT INTO tbl VALUES (NULL), (2), (3) +-- +ok +== +SELECT ANY_VALUE(i) AS a FROM tbl +-- +ok +== +DROP TABLE tbl +-- +ok +== +CREATE TABLE five AS SELECT i::{type} AS i FROM range(1, 6, 1) t1(i) +-- +error: Parser Error: syntax error at or near "{" +== +SELECT ANY_VALUE(i) FROM five +-- +ok +== +SELECT i % 3 AS g, ANY_VALUE(i) FROM five GROUP BY 1 ORDER BY 1 +-- +ok +== +SELECT ANY_VALUE(i ORDER BY 5-i) FROM five +-- +ok +== +SELECT i % 3 AS g, ANY_VALUE(i ORDER BY 5-i) FROM five GROUP BY 1 ORDER BY 1 +-- +ok +== +DROP TABLE five +-- +ok +== +SELECT i::INTEGER % 3 AS g, ANY_VALUE(i ORDER BY 5-i) FROM five GROUP BY 1 ORDER BY 1 +-- +ok +== +CREATE TABLE five_dates AS + SELECT 1 AS i, + NULL::DATE AS d, + NULL::TIMESTAMP AS dt, + NULL::TIME AS t, + NULL::INTERVAL AS s + UNION ALL + SELECT + i::integer AS i, + '2021-08-20'::DATE + i::INTEGER AS d, + '2021-08-20'::TIMESTAMP + INTERVAL (i) HOUR AS dt, + '14:59:37'::TIME + INTERVAL (i) MINUTE AS t, + INTERVAL (i) SECOND AS s + FROM range(1, 6, 1) t1(i) +-- +ok +== +SELECT ANY_VALUE(d), ANY_VALUE(dt), ANY_VALUE(t), ANY_VALUE(s) FROM five_dates +-- +ok +== +SELECT i % 3 AS g, ANY_VALUE(d), ANY_VALUE(dt), ANY_VALUE(t), ANY_VALUE(s) +FROM five_dates +GROUP BY 1 +ORDER BY 1 +-- +ok +== +SELECT ANY_VALUE(d ORDER BY 5-i), ANY_VALUE(dt ORDER BY 5-i), ANY_VALUE(t ORDER BY 5-i), ANY_VALUE(s ORDER BY 5-i) FROM five_dates +-- +ok +== +SELECT i % 3 AS g, ANY_VALUE(d ORDER BY 5-i), ANY_VALUE(dt ORDER BY 5-i), ANY_VALUE(t ORDER BY 5-i), ANY_VALUE(s ORDER BY 5-i) +FROM five_dates +GROUP BY 1 +ORDER BY 1 +-- +ok +== +SELECT ANY_VALUE(dt::TIMESTAMPTZ), ANY_VALUE(t::TIMETZ) FROM five_dates +-- +ok +== +SELECT i % 3 AS g, ANY_VALUE(dt::TIMESTAMPTZ), ANY_VALUE(t::TIMETZ) +FROM five_dates +GROUP BY 1 +ORDER BY 1 +-- +ok +== +SELECT ANY_VALUE(dt::TIMESTAMPTZ ORDER BY 5-i), ANY_VALUE(t::TIMETZ ORDER BY 5-i) FROM five_dates +-- +ok +== +SELECT i % 3 AS g, ANY_VALUE(dt::TIMESTAMPTZ ORDER BY 5-i), ANY_VALUE(t::TIMETZ ORDER BY 5-i) +FROM five_dates +GROUP BY 1 +ORDER BY 1 +-- +ok +== +DROP TABLE five_dates +-- +ok +== +CREATE TABLE five_complex AS + SELECT + 1 AS i, + NULL::VARCHAR AS s, + NULL::BIGINT[] AS l, + NULL AS r + UNION ALL + SELECT + i::integer AS i, + i::VARCHAR AS s, + [i] AS l, + {'a': i} AS r + FROM range(1, 6, 1) t1(i) +-- +ok +== +SELECT ANY_VALUE(s), ANY_VALUE(l), ANY_VALUE(r) +FROM five_complex +-- +ok +== +SELECT i % 3 AS g, ANY_VALUE(s), ANY_VALUE(l), ANY_VALUE(r) +FROM five_complex +GROUP BY 1 +ORDER BY 1 +-- +ok +== +SELECT ANY_VALUE(s ORDER BY 5-i), ANY_VALUE(l ORDER BY 5-i), ANY_VALUE(r ORDER BY 5-i) +FROM five_complex +-- +ok +== +SELECT i % 3 AS g, ANY_VALUE(s ORDER BY 5-i), ANY_VALUE(l ORDER BY 5-i), ANY_VALUE(r ORDER BY 5-i) +FROM five_complex +GROUP BY 1 +ORDER BY 1 +-- +ok +== +DROP TABLE five_complex +-- +ok +== +SELECT ANY_VALUE(i) OVER (PARTITION BY i) AS a +FROM generate_series(1, 5) t(i) +ORDER BY ALL +-- +ok +== diff --git a/parser/testdata/corpus/sql/aggregate/aggregates/test_any_value_noninlined.test b/parser/testdata/corpus/sql/aggregate/aggregates/test_any_value_noninlined.test new file mode 100644 index 0000000..7493cc6 --- /dev/null +++ b/parser/testdata/corpus/sql/aggregate/aggregates/test_any_value_noninlined.test @@ -0,0 +1,45 @@ +# source: test/sql/aggregate/aggregates/test_any_value_noninlined.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +CREATE TABLE tbl(a INTEGER, b VARCHAR) +-- +ok +== +INSERT INTO tbl VALUES (1, NULL), (2, 'thisisalongstring'), (3, 'thisisalsoalongstring') +-- +ok +== +SELECT ANY_VALUE(b) FROM tbl +-- +ok +== +SELECT ANY_VALUE(b) FROM tbl WHERE a=2 +-- +ok +== +SELECT ANY_VALUE(b) FROM tbl WHERE a=1 +-- +ok +== +SELECT ANY_VALUE(b) FROM tbl WHERE a=1 GROUP BY a +-- +ok +== +SELECT ANY_VALUE(b) FROM tbl WHERE a=0 +-- +ok +== +SELECT ANY_VALUE(b) FROM tbl WHERE a=0 GROUP BY b +-- +ok +== +SELECT a, ANY_VALUE(b) FROM tbl GROUP BY a ORDER BY a +-- +ok +== +SELECT ANY_VALUE(i) FROM (VALUES (NULL::INT32)) tbl(i) +-- +ok +== diff --git a/parser/testdata/corpus/sql/aggregate/aggregates/test_approx_quantile.test b/parser/testdata/corpus/sql/aggregate/aggregates/test_approx_quantile.test new file mode 100644 index 0000000..2d2da27 --- /dev/null +++ b/parser/testdata/corpus/sql/aggregate/aggregates/test_approx_quantile.test @@ -0,0 +1,301 @@ +# source: test/sql/aggregate/aggregates/test_approx_quantile.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +create table quantile as select range r, random() from range(10000) union all values (NULL, 0.1), (NULL, 0.5), (NULL, 0.9) order by 2; +-- +ok +== +SELECT return_type, count(*) AS defined +FROM duckdb_functions() +WHERE function_name = 'reservoir_quantile' +GROUP BY ALL +HAVING defined <> 2 +ORDER BY ALL; +-- +ok +== +SELECT CASE + WHEN ( approx_quantile between (true_quantile - 100) and (true_quantile + 100) ) + THEN TRUE + ELSE FALSE + END + FROM (SELECT approx_quantile(r, 0.5) as approx_quantile ,quantile(r,0.5) as true_quantile FROM quantile) AS T +-- +ok +== +SELECT CASE + WHEN ( approx_quantile between (true_quantile - 100) and (true_quantile + 100) ) + THEN TRUE + ELSE FALSE + END + FROM (SELECT approx_quantile(r, 1.0) as approx_quantile ,quantile(r, 1.0) as true_quantile FROM quantile) AS T +-- +ok +== +SELECT CASE + WHEN ( approx_quantile between (true_quantile - 100) and (true_quantile + 100) ) + THEN TRUE + ELSE FALSE + END + FROM (SELECT approx_quantile(r, 0.0) as approx_quantile ,quantile(r, 0.0) as true_quantile from quantile) AS T +-- +ok +== +SELECT approx_quantile(NULL, 0.5) as approx_quantile ,quantile(NULL, 0.5) as true_quantile +-- +ok +== +SELECT CASE + WHEN ( approx_quantile between (true_quantile - 100) and (true_quantile + 100) ) + THEN TRUE + ELSE FALSE + END + FROM (SELECT approx_quantile(42, 0.5) as approx_quantile ,quantile(42, 0.5) as true_quantile) AS T +-- +ok +== +SELECT approx_quantile(NULL, 0.5) as approx_quantile ,quantile(NULL, 0.5) as true_quantile FROM quantile +-- +ok +== +SELECT approx_quantile(1, 0.5) as approx_quantile ,quantile(1, 0.5) as true_quantile FROM quantile +-- +ok +== +SELECT CASE + WHEN ( approx_quantile between (true_quantile - 100) and (true_quantile + 100) ) + THEN TRUE + ELSE FALSE + END + FROM (SELECT approx_quantile(r, 0.1) as approx_quantile ,quantile(r, 0.1) as true_quantile from quantile) AS T +-- +ok +== +SELECT CASE + WHEN ( approx_quantile between (true_quantile - 100) and (true_quantile + 100) ) + THEN TRUE + ELSE FALSE + END + FROM (SELECT approx_quantile(r, 0.9) as approx_quantile ,quantile(r, 0.9) as true_quantile from quantile) AS T +-- +ok +== +SELECT approx_quantile('1:02:03.000000+05:30'::TIMETZ, 0.5); +-- +ok +== +SELECT + APPROX_QUANTILE(a, [0.43::float, 0.64::float, 0.7::float]) AS call_0_result +FROM ( + VALUES ( + (CAST('12:13:14' AS TIME)), + (CAST('12:13:14' AS TIME)), + (CAST('12:13:14' AS TIME)) + )) AS t(a); +-- +ok +== +SELECT [ + (a[1] BETWEEN (q[1] - 100) AND (q[1] + 100)), + (a[2] BETWEEN (q[2] - 100) AND (q[2] + 100)), + (a[3] BETWEEN (q[3] - 100) AND (q[3] + 100)), + ] +FROM ( + SELECT approx_quantile(r, [0.25, 0.5, 0.75]) AS a, + quantile(r, [0.25, 0.5, 0.75]) AS q, + FROM quantile +) tbl; +-- +ok +== +SELECT [ + (a[1] BETWEEN (q[1] - 100) AND (q[1] + 100)), + (a[2] BETWEEN (q[2] - 100) AND (q[2] + 100)), + (a[3] BETWEEN (q[3] - 100) AND (q[3] + 100)), + ] +FROM ( + SELECT reservoir_quantile(r, [0.25, 0.5, 0.75], 4096) AS a, + quantile(r, [0.25, 0.5, 0.75]) AS q, + FROM quantile +) tbl; +-- +ok +== +SELECT approx_quantile(col, [0.5, 0.4, 0.1]) AS percentile +FROM VALUES (0), (1), (2), (10) AS tab(col); +-- +ok +== +SELECT approx_quantile(col, ARRAY_VALUE(0.5, 0.4, 0.1)) AS percentile +FROM VALUES (0), (1), (2), (10) AS tab(col); +-- +ok +== +SELECT approx_quantile(r, -0.1) FROM quantile +-- +ok +== +SELECT approx_quantile(r, 1.1) FROM quantile +-- +ok +== +SELECT approx_quantile(r, NULL) FROM quantile +-- +ok +== +SELECT approx_quantile(r, r) FROM quantile +-- +ok +== +SELECT approx_quantile(r::string, 0.5) FROM quantile +-- +ok +== +SELECT approx_quantile(r) FROM quantile +-- +ok +== +SELECT approx_quantile(r, 0.1, 0.2) FROM quantile +-- +ok +== +SELECT approx_quantile(42, CAST(NULL AS INT[])); +-- +ok +== +pragma threads=4 +-- +ok +== +PRAGMA verify_parallelism +-- +ok +== +SELECT CASE + WHEN (approx_quantile between (true_quantile - (sumr * 0.01)) and (true_quantile + (sumr * 0.01))) + THEN TRUE + ELSE FALSE + END + FROM (SELECT approx_quantile(r, 0.1) as approx_quantile, quantile(r, 0.1) as true_quantile, SUM(r) as sumr from quantile) AS T +-- +ok +== +SELECT CASE + WHEN (approx_quantile between (true_quantile - (sumr * 0.01)) and (true_quantile + (sumr * 0.01))) + THEN TRUE + ELSE FALSE + END + FROM (SELECT approx_quantile(r, 0.9) as approx_quantile, quantile(r, 0.9) as true_quantile, SUM(r) as sumr from quantile) AS T +-- +ok +== +SELECT CASE + WHEN (approx_quantile between (true_quantile - (sumr * 0.01)) and (true_quantile + (sumr * 0.01))) + THEN TRUE + ELSE FALSE + END + FROM (SELECT approx_quantile(r, 0.5) as approx_quantile, quantile(r, 0.5) as true_quantile, SUM(r) as sumr from quantile) AS T +-- +ok +== +CREATE TABLE repro (i DECIMAL(15,2)); +-- +ok +== +SELECT approx_quantile(i, 0.5) FROM repro; +-- +ok +== +SELECT approx_quantile(i, [0.5]) FROM repro; +-- +ok +== +SET debug_force_external=false; +-- +ok +== +SELECT reservoir_quantile(r, 0.9) from quantile +-- +ok +== +SELECT reservoir_quantile(r, 0.9,1000) from quantile +-- +ok +== +SELECT reservoir_quantile(1, 0.5, 1) FROM quantile +-- +ok +== +SELECT RESERVOIR_QUANTILE(b, 0.5) +FROM (SELECT 'a' AS a, 1.0 AS b) y +GROUP BY a +-- +ok +== +SELECT APPROX_QUANTILE(b, 0.5) +FROM ( + SELECT 'a' AS a, 1.0 AS b + UNION ALL SELECT 'a' AS a, 1.0 AS b + UNION ALL SELECT 'b' AS a, 1.0 AS b + ) y +GROUP BY a +-- +ok +== +SELECT reservoir_quantile(r, r) from quantile +-- +ok +== +SELECT reservoir_quantile(r, NULL) from quantile +-- +ok +== +SELECT reservoir_quantile(r, r, r) from quantile +-- +ok +== +SELECT reservoir_quantile(r, 0.9, NULL) from quantile +-- +ok +== +SELECT reservoir_quantile(r, 0.9, r) from quantile +-- +ok +== +SELECT reservoir_quantile(r, random()::float) from quantile +-- +ok +== +SELECT reservoir_quantile(r, 0.9, random()::float) from quantile +-- +ok +== +SELECT RESERVOIR_QUANTILE(0., 0.9, 1000); +-- +ok +== +SET memory_limit='80MB'; +-- +ok +== +CREATE OR REPLACE TABLE tdigest_memory_test AS + SELECT i AS grp, random() AS r + FROM range(100000) g(i) + CROSS JOIN range(4) h(j); +-- +ok +== +SELECT grp, APPROX_QUANTILE(r, 0.5) FROM tdigest_memory_test GROUP BY grp; +-- +ok +== +RESET memory_limit; +-- +ok +== +RESET threads; +-- +ok +== diff --git a/parser/testdata/corpus/sql/aggregate/aggregates/test_approximate_distinct_count.test b/parser/testdata/corpus/sql/aggregate/aggregates/test_approximate_distinct_count.test new file mode 100644 index 0000000..75301fc --- /dev/null +++ b/parser/testdata/corpus/sql/aggregate/aggregates/test_approximate_distinct_count.test @@ -0,0 +1,109 @@ +# source: test/sql/aggregate/aggregates/test_approximate_distinct_count.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +select approx_count_distinct(*) +-- +ok +== +select approx_count_distinct(1) +-- +ok +== +select approx_count_distinct(NULL) +-- +ok +== +select approx_count_distinct('hello') +-- +ok +== +select approx_count_distinct(10), approx_count_distinct('hello') from range(100); +-- +ok +== +select approx_count_distinct(i) from range (100) tbl(i) WHERE 1 == 0; +-- +ok +== +CREATE TABLE IF NOT EXISTS dates (t date); +-- +ok +== +INSERT INTO dates VALUES ('2008-01-01'), (NULL), ('2007-01-01'), ('2008-02-01'), ('2008-01-02'), ('2008-01-01'), ('2008-01-01'), ('2008-01-01') +-- +ok +== +CREATE TABLE IF NOT EXISTS timestamp (t TIMESTAMP); +-- +ok +== +INSERT INTO timestamp VALUES ('2008-01-01 00:00:01'), (NULL), ('2007-01-01 00:00:01'), ('2008-02-01 00:00:01'), ('2008-01-02 00:00:01'), ('2008-01-01 10:00:00'), ('2008-01-01 00:10:00'), ('2008-01-01 00:00:10') +-- +ok +== +CREATE TABLE IF NOT EXISTS names (t string); +-- +ok +== +INSERT INTO names VALUES ('Pedro'), (NULL), ('Pedro'), ('Pedro'), ('Mark'), ('Mark'),('Mark'),('Hannes-Muehleisen'),('Hannes-Muehleisen') +-- +ok +== +create table t as select range a, mod(range,10) b from range(2000); +-- +ok +== +SELECT COUNT( a),approx_count_distinct(a),approx_count_distinct(b) from t +-- +ok +== +SELECT approx_count_distinct(a) from t group by a %2 order by all; +-- +ok +== +SELECT count(*) from t where a < 10; +-- +ok +== +SELECT approx_count_distinct(a) over (partition by a%2) from t where a < 10; +-- +ok +== +SELECT COUNT( t),approx_count_distinct(t) from timestamp +-- +ok +== +SELECT COUNT( t),approx_count_distinct(t) from dates +-- +ok +== +SELECT COUNT(t),approx_count_distinct(t) from names +-- +ok +== +create table customers (cname varchar) +-- +ok +== +insert into customers values ('Customer#000000001'), ('Customer#000000002'), ('Customer#000000003'), ('Customer#000000004') +-- +ok +== +select approx_count_distinct(cname) from customers +-- +ok +== +create table issue5259(c0 int); +-- +ok +== +insert into issue5259 values (1),(2),(3); +-- +ok +== +SELECT approx_count_distinct(c0 ORDER BY (c0, 1)) FROM issue5259; +-- +ok +== diff --git a/parser/testdata/corpus/sql/aggregate/aggregates/test_arg_min_max.test b/parser/testdata/corpus/sql/aggregate/aggregates/test_arg_min_max.test new file mode 100644 index 0000000..509ea3e --- /dev/null +++ b/parser/testdata/corpus/sql/aggregate/aggregates/test_arg_min_max.test @@ -0,0 +1,185 @@ +# source: test/sql/aggregate/aggregates/test_arg_min_max.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +select argmin() +-- +ok +== +select argmin(NULL,NULL) +-- +ok +== +select argmin(1,1) +-- +ok +== +select argmin(*) +-- +ok +== +select argmin(i,i) from range (100) tbl(i); +-- +ok +== +select argmin(i,i) from range (100) tbl(i) where 1 = 0; +-- +ok +== +select argmax() +-- +ok +== +select argmax(NULL,NULL) +-- +ok +== +select argmax(1,1) +-- +ok +== +select argmax(*) +-- +ok +== +select argmax(i,i) from range (100) tbl(i); +-- +ok +== +select argmax(i,i) from range (100) tbl(i) where 1 = 0; +-- +ok +== +create table args (a integer, b integer) +-- +ok +== +insert into args values (1,1), (2,2), (8,8), (10,10) +-- +ok +== +select argmin(a,b), argmax(a,b) from args; +-- +ok +== +select argmin(a,b), argmax(a,b) from args group by a%2 ORDER BY argmin(a,b); +-- +ok +== +CREATE TABLE hugeints (z HUGEINT); +-- +ok +== +insert into hugeints values + (-168123123123200005565479978461862821890), + (-168123123123200005565479978461862821889), + (-168123123123200005565479978461862821888), + (-168123123123200005565479978461862821893) +-- +ok +== +SELECT min(z) - arg_min(z,z) FROM hugeints; +-- +ok +== +CREATE TABLE blobs (b BYTEA, a BIGINT); +-- +ok +== +INSERT INTO blobs VALUES('\xaa\xff\xaa',5), ('\xAA\xFF\xAA\xAA\xFF\xAA',30), ('\xAA\xFF\xAA\xAA\xFF\xAA\xAA\xFF\xAA',20) +-- +ok +== +select argmin(b,a), argmax(b,a) from blobs ; +-- +ok +== +select argmin(a,b), argmax(a,b) from blobs; +-- +ok +== +select argmin(a,b) over ( partition by a%2) from args; +-- +ok +== +select argmax(a,b) over ( partition by a%2) from args; +-- +ok +== +create table names (name string, salary integer) +-- +ok +== +insert into names values ('Pedro',10), ('Hannes',20), ('Mark',15), ('Hubert-Blaine-Wolfeschlegelsteinhausenbergerdorff',30) +-- +ok +== +select argmin(name,salary),argmax(name,salary) from names; +-- +ok +== +select argmin(salary,name),argmax(salary,name) from names; +-- +ok +== +select min_by(name,salary),max_by(name,salary) from names; +-- +ok +== +select arg_min(name,salary),arg_max(name,salary) from names; +-- +ok +== +drop table names; +-- +ok +== +CREATE OR REPLACE TABLE employees( + employee_id NUMERIC, + department_id NUMERIC, + salary NUMERIC); +-- +ok +== +INSERT INTO employees VALUES + (1001, 10, 10000), + (1020, 10, 9000), + (1030, 10, 8000), + (900, 20, 15000), + (2000, 20, NULL), + (2010, 20, 15000), + (2020, 20, 8000); +-- +ok +== +SET old_implicit_casting={casting}; +-- +error: Parser Error: syntax error at or near "}" +== +SELECT MAX_BY(employee_id, salary) as employee_with_biggest_salary +FROM employees; +-- +ok +== +SELECT MIN_BY(employee_id, salary) as employee_with_least_salary +FROM employees; +-- +ok +== +SELECT max_by(c0, c1) FROM (values (1, null)) t(c0,c1); +-- +ok +== +create table names (first_name string, last_name string) +-- +ok +== +insert into names values ('PedroPedroPedroPedroPedro','HolandaHolandaHolandaHolandaHolanda'), ('HannesHannesHannesHannesHannesHannes','MuhleisenMuhleisenMuhleisenMuhleisenMuhleisenMuhleisen'), ('MarkMarkMark','RaasveldtRaasveldtRaasveldtRaasveldtRaasveldtRaasveldt'), ('Hubert-BlaineHubert-BlaineHubert-BlaineHubert-Blaine','WolfeschlegelsteinhausenbergerdorffWolfeschlegelsteinhausenbergerdorffWolfeschlegelsteinhausenbergerdorff') +-- +ok +== +select arg_min(first_name,last_name),arg_max(first_name,last_name) from names; +-- +ok +== diff --git a/parser/testdata/corpus/sql/aggregate/aggregates/test_arg_min_max_null.test b/parser/testdata/corpus/sql/aggregate/aggregates/test_arg_min_max_null.test new file mode 100644 index 0000000..b8b6ebe --- /dev/null +++ b/parser/testdata/corpus/sql/aggregate/aggregates/test_arg_min_max_null.test @@ -0,0 +1,89 @@ +# source: test/sql/aggregate/aggregates/test_arg_min_max_null.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +select arg_min_null() +-- +ok +== +select arg_min_null(NULL,NULL) +-- +ok +== +select arg_min_null(1,1) +-- +ok +== +select arg_min_null(*) +-- +ok +== +select arg_min_null(i,i) from range (100) tbl(i); +-- +ok +== +select arg_min_null(i,i) from range (100) tbl(i) where 1 = 0; +-- +ok +== +select arg_max_null() +-- +ok +== +select arg_max_null(NULL,NULL) +-- +ok +== +select arg_max_null(1,1) +-- +ok +== +select arg_max_null(*) +-- +ok +== +select arg_max_null(i,i) from range (100) tbl(i); +-- +ok +== +select arg_max_null(i,i) from range (100) tbl(i) where 1 = 0; +-- +ok +== +select arg_min_null(a,b), arg_max_null(a,b) from args; +-- +ok +== +select arg_min_null(a,b), arg_max_null(a,b) from args group by a%2 ORDER BY arg_min_null(a,b); +-- +ok +== +insert into args values (NULL, 0), (NULL, 12) +-- +ok +== +select arg_min_null(b,a), arg_max_null(b,a) from blobs ; +-- +ok +== +select arg_min_null(a,b), arg_max_null(a,b) from blobs; +-- +ok +== +select arg_min_null(a,b) over ( partition by a%2) from args; +-- +ok +== +select arg_max_null(a,b) over ( partition by a%2) from args; +-- +ok +== +select arg_min_null(name,salary),arg_max_null(name,salary) from names; +-- +ok +== +select arg_min_null(salary,name),arg_max_null(salary,name) from names; +-- +ok +== diff --git a/parser/testdata/corpus/sql/aggregate/aggregates/test_avg.test b/parser/testdata/corpus/sql/aggregate/aggregates/test_avg.test new file mode 100644 index 0000000..8ba7ebb --- /dev/null +++ b/parser/testdata/corpus/sql/aggregate/aggregates/test_avg.test @@ -0,0 +1,153 @@ +# source: test/sql/aggregate/aggregates/test_avg.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +SELECT AVG(3), AVG(NULL) +-- +ok +== +SELECT AVG(3::SMALLINT), AVG(NULL::SMALLINT) +-- +ok +== +SELECT AVG(3::DOUBLE), AVG(NULL::DOUBLE) +-- +ok +== +SELECT AVG(nextval('seq')) +-- +ok +== +CREATE TABLE integers(i INTEGER); +-- +ok +== +INSERT INTO integers VALUES (1), (2), (3) +-- +ok +== +SELECT AVG(i), AVG(1), AVG(DISTINCT i), AVG(NULL) FROM integers +-- +ok +== +SELECT AVG(i) FROM integers WHERE i > 100 +-- +ok +== +CREATE TABLE intervals(itvl INTERVAL) +-- +ok +== +INSERT INTO intervals VALUES + ('1 day'), + ('30 days'), + ('30 days'), + ('30 days'), + ('30 days') +-- +ok +== +SELECT AVG(itvl), AVG(DISTINCT itvl) FROM intervals +-- +ok +== +CREATE TABLE interval_tbl (f1 interval); +-- +ok +== +INSERT INTO interval_tbl (f1) VALUES + ('@ 1 minute'), + ('@ 5 hour'), + ('@ 10 day'), + ('@ 34 year'), + ('@ 3 months'), + ('@ 14 seconds ago'), + ('1 day 2 hours 3 minutes 4 seconds'), + ('6 years'), + ('5 months'), + ('5 months 12 hours'); +-- +ok +== +select avg(f1) from interval_tbl; +-- +ok +== +SELECT AVG(1, 2, 3) +-- +ok +== +SELECT AVG(AVG(1)) +-- +ok +== +CREATE TABLE vals(i INTEGER, j DOUBLE, k HUGEINT); +-- +ok +== +INSERT INTO vals VALUES (NULL, NULL, NULL) +-- +ok +== +SELECT AVG(i), AVG(j), AVG(k) FROM vals; +-- +ok +== +CREATE OR REPLACE TABLE timestamps AS + SELECT range AS ts + FROM range('2024-11-01'::DATE, '2024-12-01'::DATE, INTERVAL 1 DAY) +-- +ok +== +SELECT AVG(ts::DATE) +FROM timestamps +-- +ok +== +SELECT AVG(ts) +FROM timestamps +-- +ok +== +SELECT AVG(ts::TIMESTAMPTZ) +FROM timestamps +-- +ok +== +CREATE OR REPLACE TABLE times AS + SELECT range AS ts + FROM range('2024-11-01'::DATE, '2024-11-02'::DATE, INTERVAL 7 MINUTES) +-- +ok +== +SELECT AVG(ts::TIME) +FROM times +-- +ok +== +CREATE TABLE timetzs (ttz TIMETZ); +-- +ok +== +INSERT INTO timetzs VALUES + (NULL), + ('00:00:00+1559'), + ('00:00:00+1558'), + ('02:30:00'), + ('02:30:00+04'), + ('02:30:00+04:30'), + ('02:30:00+04:30:45'), + ('16:15:03.123456'), + ('02:30:00+1200'), + ('02:30:00-1200'), + ('24:00:00-1558'), + ('24:00:00-1559'), +; +-- +ok +== +SELECT AVG(ttz) FROM timetzs; +-- +ok +== diff --git a/parser/testdata/corpus/sql/aggregate/aggregates/test_bigint_avg.test b/parser/testdata/corpus/sql/aggregate/aggregates/test_bigint_avg.test new file mode 100644 index 0000000..3ecbbc2 --- /dev/null +++ b/parser/testdata/corpus/sql/aggregate/aggregates/test_bigint_avg.test @@ -0,0 +1,17 @@ +# source: test/sql/aggregate/aggregates/test_bigint_avg.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +CREATE TABLE bigints(n HUGEINT); +-- +ok +== +INSERT INTO bigints (n) VALUES ('9007199254740992'::HUGEINT), (1::HUGEINT), (0::HUGEINT); +-- +ok +== +SELECT AVG(n)::DOUBLE - '3002399751580331'::DOUBLE FROM bigints; +-- +ok +== diff --git a/parser/testdata/corpus/sql/aggregate/aggregates/test_binned_histogram.test b/parser/testdata/corpus/sql/aggregate/aggregates/test_binned_histogram.test new file mode 100644 index 0000000..3ab6fd4 --- /dev/null +++ b/parser/testdata/corpus/sql/aggregate/aggregates/test_binned_histogram.test @@ -0,0 +1,86 @@ +# source: test/sql/aggregate/aggregates/test_binned_histogram.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +SELECT histogram(n, [10, 20, 30, 40, 50]) FROM obs +-- +ok +== +SELECT histogram(n, [10, 20, 30, 40]) FROM obs +-- +ok +== +SELECT histogram(n::double, [10, 20, 30, 40]) FROM obs +-- +ok +== +SELECT histogram(n, []) FROM obs +-- +ok +== +SELECT histogram(n, [10, 40, 50, 30, 20]) FROM obs +-- +ok +== +SELECT n%2=0 is_even, histogram(n, [10, 20, 30, 40, 50]) FROM obs GROUP BY is_even ORDER BY is_even +-- +ok +== +SELECT n%2=0 is_even, histogram(n, case when n%2=0 then [10, 20, 30, 40, 50] else [11, 21, 31, 41, 51] end) FROM obs GROUP BY is_even ORDER BY is_even +-- +ok +== +SELECT histogram(i, range(999, 10000, 1000)) FROM range(10000) t(i) +-- +ok +== +SELECT histogram(v, [-9223372036854775808, -9223372036854775807, 9223372036854775807]) FROM +(VALUES (-9223372036854775808), (-9223372036854775807), (0), (9223372036854775807)) t(v) +-- +ok +== +SELECT histogram(v, ['-infinity'::double, -10, 0, 10, 'infinity']) FROM +(VALUES (-1e308), (-0.5), (0), ('inf'), ('-inf'), (0.5)) t(v) +-- +ok +== +SELECT histogram(v, range(timestamp '2000-01-01', timestamp '2005-01-01', interval '1 year')) FROM +(VALUES (timestamp '2000-01-01'), (timestamp '2003-01-01')) t(v) +-- +ok +== +SELECT histogram(v, ['a', 'b', 'c', 'z']) FROM +(VALUES ('a'), ('aaaa'), ('b'), ('c'), ('d')) t(v) +-- +ok +== +SELECT histogram(concat('thisisalongprefix_', v), ['thisisalongprefix_'||x for x in ['a', 'b', 'c', 'z']]) FROM +(VALUES ('a'), ('aaaa'), ('b'), ('c'), ('d')) t(v) +-- +ok +== +SELECT histogram({'i': n}, [{'i': x} for x in [10, 20, 30, 40, 50]]) FROM obs +-- +ok +== +SELECT histogram([n], [[x] for x in [10, 20, 30, 40, 50]]) FROM obs +-- +ok +== +SELECT histogram(n, [10, 10, 10, 10]) FROM obs +-- +ok +== +SELECT list_aggregate(map_values(histogram(n, [10, 10, 10, 10])), 'sum') FROM obs +-- +ok +== +SELECT histogram(n, [10, 20, NULL]) FROM obs +-- +ok +== +SELECT histogram(n, NULL::BIGINT[]) FROM obs +-- +ok +== diff --git a/parser/testdata/corpus/sql/aggregate/aggregates/test_bit_and.test b/parser/testdata/corpus/sql/aggregate/aggregates/test_bit_and.test new file mode 100644 index 0000000..8882495 --- /dev/null +++ b/parser/testdata/corpus/sql/aggregate/aggregates/test_bit_and.test @@ -0,0 +1,57 @@ +# source: test/sql/aggregate/aggregates/test_bit_and.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +SELECT BIT_AND(3), BIT_AND(NULL) +-- +ok +== +SELECT BIT_AND(nextval('seq')) +-- +ok +== +INSERT INTO integers VALUES (3), (7), (15), (31), (3), (15) +-- +ok +== +SELECT BIT_AND(i), BIT_AND(1), BIT_AND(DISTINCT i), BIT_AND(NULL) FROM integers +-- +ok +== +SELECT BIT_AND(i) FROM integers WHERE i > 100 +-- +ok +== +SELECT BIT_AND() +-- +ok +== +SELECT BIT_AND(1, 2, 3) +-- +ok +== +SELECT BIT_AND(BIT_AND(1)) +-- +ok +== +CREATE TABLE bits(b BIT); +-- +ok +== +INSERT INTO bits VALUES ('1110101011'), ('0111010101'), ('0101011101'), ('1111111111'), ('0100010011'), ('1100110011') +-- +ok +== +SELECT BIT_AND(b) FROM bits +-- +ok +== +SELECT BIT_AND(b) FROM bits WHERE get_bit(b, 2) = 1; +-- +ok +== +SELECT BIT_AND('010110'::BIT) +-- +ok +== diff --git a/parser/testdata/corpus/sql/aggregate/aggregates/test_bit_or.test b/parser/testdata/corpus/sql/aggregate/aggregates/test_bit_or.test new file mode 100644 index 0000000..7d8ceae --- /dev/null +++ b/parser/testdata/corpus/sql/aggregate/aggregates/test_bit_or.test @@ -0,0 +1,49 @@ +# source: test/sql/aggregate/aggregates/test_bit_or.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +SELECT BIT_OR(3), BIT_OR(NULL) +-- +ok +== +SELECT BIT_OR(nextval('seq')) +-- +ok +== +SELECT BIT_OR(i), BIT_OR(1), BIT_OR(DISTINCT i), BIT_OR(NULL) FROM integers +-- +ok +== +SELECT BIT_OR(i) FROM integers WHERE i > 100 +-- +ok +== +SELECT BIT_OR() +-- +ok +== +SELECT BIT_OR(1, 2, 3) +-- +ok +== +SELECT BIT_OR(BIT_AND(1)) +-- +ok +== +INSERT INTO bits VALUES ('1010101001'), ('0011010101'), ('0001011101'), ('1011111101'), ('0000010001'), ('1000110001') +-- +ok +== +SELECT BIT_OR(b) FROM bits +-- +ok +== +SELECT BIT_OR(b) FROM bits WHERE get_bit(b, 3) = 0; +-- +ok +== +SELECT BIT_OR('111010'::BIT) +-- +ok +== diff --git a/parser/testdata/corpus/sql/aggregate/aggregates/test_bit_xor.test b/parser/testdata/corpus/sql/aggregate/aggregates/test_bit_xor.test new file mode 100644 index 0000000..0ee3084 --- /dev/null +++ b/parser/testdata/corpus/sql/aggregate/aggregates/test_bit_xor.test @@ -0,0 +1,49 @@ +# source: test/sql/aggregate/aggregates/test_bit_xor.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +SELECT BIT_XOR(3), BIT_XOR(NULL) +-- +ok +== +SELECT BIT_XOR(nextval('seq')) +-- +ok +== +SELECT BIT_XOR(i), BIT_XOR(1), BIT_XOR(DISTINCT i), BIT_XOR(NULL) FROM integers +-- +ok +== +SELECT BIT_XOR(i) FROM integers WHERE i > 100 +-- +ok +== +SELECT BIT_XOR() +-- +ok +== +SELECT BIT_XOR(1, 2, 3) +-- +ok +== +SELECT BIT_XOR(BIT_XOR(1)) +-- +ok +== +SELECT BIT_XOR(b) FROM bits +-- +ok +== +SELECT BIT_XOR(b) FROM bits WHERE get_bit(b, 3) = 1; +-- +ok +== +SELECT BIT_XOR('101011'::BIT) +-- +ok +== +SELECT BIT_XOR('0010101010101010101101011'::BIT) from bits +-- +ok +== diff --git a/parser/testdata/corpus/sql/aggregate/aggregates/test_bitstring_agg.test b/parser/testdata/corpus/sql/aggregate/aggregates/test_bitstring_agg.test new file mode 100644 index 0000000..7c37830 --- /dev/null +++ b/parser/testdata/corpus/sql/aggregate/aggregates/test_bitstring_agg.test @@ -0,0 +1,209 @@ +# source: test/sql/aggregate/aggregates/test_bitstring_agg.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +CREATE TABLE tinyints(i TINYINT) +-- +ok +== +INSERT INTO tinyints VALUES(1), (8), (3), (12), (7), (1), (2), (8) +-- +ok +== +SELECT BITSTRING_AGG(i) FROM tinyints +-- +ok +== +SELECT bit_count(BITSTRING_AGG(i)) FROM tinyints WHERE i <= 7 +-- +ok +== +CREATE TABLE smallints(i SMALLINT) +-- +ok +== +INSERT INTO smallints VALUES(1), (8), (-3), (12), (7), (1), (-1), (-9), (NULL), (-2), (8) +-- +ok +== +SELECT BITSTRING_AGG(i) FROM smallints +-- +ok +== +SELECT bit_count(BITSTRING_AGG(i)) FROM smallints WHERE i = 8 +-- +ok +== +CREATE TABLE ints(i INTEGER); +-- +ok +== +INSERT INTO ints VALUES(10), (-5), (11), (NULL), (30), (11), (23), (17), (27), (15), (5), (14) +-- +ok +== +SELECT BITSTRING_AGG(i) FROM ints +-- +ok +== +SELECT bit_count(BITSTRING_AGG(i)) FROM ints WHERE i > 20 AND i < 28 +-- +ok +== +CREATE TABLE bigints(i BIGINT); +-- +ok +== +INSERT INTO bigints VALUES(2378097), (2378100), (2378095), (2378104), (NULL), (2378113), (2378100), (2378095), (2378105), (2378097) +-- +ok +== +SELECT BITSTRING_AGG(i) FROM bigints +-- +ok +== +SELECT bit_count(BITSTRING_AGG(i)) FROM bigints WHERE i = 100 +-- +ok +== +CREATE TABLE hugeints(i HUGEINT); +-- +ok +== +INSERT INTO hugeints VALUES(12243372036854775807), (12243372036854778191), (12243372036854730332), (12243372036854773737), (12243372036854737711), (12243372036854722124), (12243372036854778191) +-- +ok +== +SELECT bit_length(BITSTRING_AGG(i)) FROM hugeints +-- +ok +== +CREATE TABLE uhugeints(i UHUGEINT); +-- +ok +== +INSERT INTO uhugeints VALUES(12243372036854775807), (12243372036854778191), (12243372036854730332), (12243372036854773737), (12243372036854737711), (12243372036854722124), (12243372036854778191) +-- +ok +== +SELECT bit_length(BITSTRING_AGG(i)) FROM uhugeints +-- +ok +== +SELECT bit_count(BITSTRING_AGG(i)) FROM smallints +-- +ok +== +SELECT COUNT(DISTINCT i) FROM smallints +-- +ok +== +SELECT bit_count(BITSTRING_AGG(i)) FROM ints +-- +ok +== +SELECT COUNT(DISTINCT i) FROM ints +-- +ok +== +SELECT bit_count(BITSTRING_AGG(i)) FROM bigints +-- +ok +== +SELECT COUNT(DISTINCT i) FROM bigints +-- +ok +== +SELECT bit_count(BITSTRING_AGG(i)) FROM hugeints +-- +ok +== +SELECT COUNT(DISTINCT i) FROM hugeints +-- +ok +== +SELECT BITSTRING_AGG(i, -5, 30) FROM ints +-- +ok +== +SELECT BITSTRING_AGG(i, -10, 40) FROM ints +-- +ok +== +SELECT BITSTRING_AGG(i, -10, 20) FROM ints +-- +ok +== +SELECT BITSTRING_AGG(i, 0, 15) FROM tinyints +-- +ok +== +SELECT BITSTRING_AGG(i, 2, 15) FROM tinyints +-- +ok +== +SELECT BITSTRING_AGG(i, 2378080, 2378150) FROM bigints +-- +ok +== +SELECT BITSTRING_AGG(3) +-- +ok +== +SELECT BITSTRING_AGG(2, 0, 5) +-- +ok +== +CREATE TABLE null_table(i INT); +-- +ok +== +INSERT INTO null_table VALUES(NULL) +-- +ok +== +SELECT BITSTRING_AGG(i) FROM null_table +-- +ok +== +INSERT INTO null_table VALUES(6), (NULL), (NULL), (NULL), (NULL) +-- +ok +== +COPY (SELECT i FROM ints) TO '{TEST_DIR}/bitstring_agg.csv' (HEADER 0); +-- +ok +== +SELECT BITSTRING_AGG(column0) FROM '{TEST_DIR}/bitstring_agg.csv'; +-- +ok +== +SELECT BITSTRING_AGG(column0, -10, 40) FROM '{TEST_DIR}/bitstring_agg.csv'; +-- +ok +== +SELECT BITSTRING_AGG() +-- +ok +== +SELECT BITSTRING_AGG(1, 3, 4, 8, 0) +-- +ok +== +CREATE TABLE groups(i INT, g VARCHAR); +-- +ok +== +INSERT INTO groups VALUES(10, 'a'), (13, 'b'), (9, 'a'), (16, 'c'), (NULL, 'd'), (2, 'a'), (6, 'c'), (9, 'b') +-- +ok +== +SELECT g, BITSTRING_AGG(i) FROM groups GROUP BY g ORDER BY g +-- +ok +== +SELECT BITSTRING_AGG(i, -5, 32) FROM ints +-- +ok +== diff --git a/parser/testdata/corpus/sql/aggregate/aggregates/test_bool.test b/parser/testdata/corpus/sql/aggregate/aggregates/test_bool.test new file mode 100644 index 0000000..5ccdf35 --- /dev/null +++ b/parser/testdata/corpus/sql/aggregate/aggregates/test_bool.test @@ -0,0 +1,85 @@ +# source: test/sql/aggregate/aggregates/test_bool.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +select bool_or(0) +-- +ok +== +select bool_and(0) +-- +ok +== +select bool_or(NULL) +-- +ok +== +select bool_and(NULL) +-- +ok +== +select bool_or() +-- +ok +== +select bool_and() +-- +ok +== +select bool_or(*) +-- +ok +== +select bool_and(*) +-- +ok +== +SELECT bool_or(True) FROM range(100); +-- +ok +== +SELECT bool_and(True) FROM range(100); +-- +ok +== +SELECT bool_or(True) FROM range(100) tbl(i) WHERE 1=0; +-- +ok +== +SELECT bool_and(True) FROM range(100) tbl(i) WHERE 1=0; +-- +ok +== +create table t (d date) +-- +ok +== +insert into t values (DATE'2021-02-09'-1),(DATE'2021-02-09'+1),(NULL) +-- +ok +== +select bool_or(d > '2021-02-09') AS or_result, + bool_and(d > '2021-02-09') AS and_result +from t; +-- +ok +== +select d,bool_or(d > '2021-02-09') AS or_result, + bool_and(d > '2021-02-09') AS and_result +from t +group by d +order by d; +-- +ok +== +select bool_or(d > '2021-02-09') over (partition by d) + from t order by d; +-- +ok +== +select bool_and(d > '2021-02-09') over (partition by d) + from t order by d; +-- +ok +== diff --git a/parser/testdata/corpus/sql/aggregate/aggregates/test_corr.test b/parser/testdata/corpus/sql/aggregate/aggregates/test_corr.test new file mode 100644 index 0000000..ee08f63 --- /dev/null +++ b/parser/testdata/corpus/sql/aggregate/aggregates/test_corr.test @@ -0,0 +1,50 @@ +# source: test/sql/aggregate/aggregates/test_corr.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +select corr() +-- +ok +== +select corr(NULL,NULL) +-- +ok +== +select corr(1,1) +-- +ok +== +select corr(*) +-- +ok +== +create table aggr(k int, v decimal(10,2), v2 decimal(10, 2)); +-- +ok +== +insert into aggr values(1, 10, null),(2, 10, 11), (2, 20, 22), (2, 25, null), (2, 30, 35); +-- +ok +== +select k, corr(v, v2) from aggr group by k ORDER BY ALL; +-- +ok +== +select corr(v, v2) from aggr +-- +ok +== +select corr(v, v2) over (partition by k) + from aggr; +-- +ok +== +SELECT corr(a,b) FROM (values (1e301, 0), (-1e301, 0)) tbl(a,b); +-- +ok +== +SELECT corr(b,a) FROM (values (1e301, 0), (-1e301, 0)) tbl(a,b); +-- +ok +== diff --git a/parser/testdata/corpus/sql/aggregate/aggregates/test_count.test b/parser/testdata/corpus/sql/aggregate/aggregates/test_count.test new file mode 100644 index 0000000..2be7a05 --- /dev/null +++ b/parser/testdata/corpus/sql/aggregate/aggregates/test_count.test @@ -0,0 +1,25 @@ +# source: test/sql/aggregate/aggregates/test_count.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +SELECT COUNT(*), COUNT(1), COUNT(100), COUNT(NULL), COUNT(DISTINCT 1) +-- +ok +== +INSERT INTO integers VALUES (1), (2), (NULL) +-- +ok +== +SELECT COUNT(*), COUNT(1), COUNT(i), COUNT(COALESCE(i, 1)), COUNT(DISTINCT i), COUNT(DISTINCT 1) FROM integers +-- +ok +== +SELECT COUNT(1 ORDER BY 1) +-- +ok +== +SELECT COUNT(DISTINCT *) FROM integers +-- +ok +== diff --git a/parser/testdata/corpus/sql/aggregate/aggregates/test_count_all_types.test b/parser/testdata/corpus/sql/aggregate/aggregates/test_count_all_types.test new file mode 100644 index 0000000..f4e94d0 --- /dev/null +++ b/parser/testdata/corpus/sql/aggregate/aggregates/test_count_all_types.test @@ -0,0 +1,54 @@ +# source: test/sql/aggregate/aggregates/test_count_all_types.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +SELECT COUNT(n) FROM test_vector_types(NULL::INT, all_flat={flatten}) t(n); +-- +error: Parser Error: syntax error at or near "}" +== +SELECT list_aggr(n, 'count') FROM test_vector_types(NULL::INT[], all_flat={flatten}) t(n); +-- +error: Parser Error: syntax error at or near "}" +== +SELECT COUNT(n) FROM test_vector_types(NULL::VARCHAR, all_flat={flatten}) t(n); +-- +error: Parser Error: syntax error at or near "}" +== +SELECT COUNT(DISTINCT n) FROM test_vector_types(NULL::INT, all_flat={flatten}) t(n); +-- +error: Parser Error: syntax error at or near "}" +== +SELECT COUNT(DISTINCT n) FROM test_vector_types(NULL::VARCHAR, all_flat={flatten}) t(n); +-- +error: Parser Error: syntax error at or near "}" +== +SELECT n, COUNT(n) FROM test_vector_types(NULL::INT, all_flat={flatten}) t(n) GROUP BY n ORDER BY ALL; +-- +error: Parser Error: syntax error at or near "}" +== +CREATE TABLE int(i INT); +-- +ok +== +INSERT INTO int FROM range(128); +INSERT INTO int SELECT NULL FROM range(128); +INSERT INTO int FROM range(77); +INSERT INTO int SELECT NULL FROM range(61); +INSERT INTO int FROM range(88); +INSERT INTO int SELECT NULL FROM range(33); +INSERT INTO int FROM range(44); +INSERT INTO int SELECT NULL FROM range(11); +INSERT INTO int FROM range(13); +INSERT INTO int SELECT NULL FROM range(27); +-- +ok +== +SELECT COUNT(i), COUNT(rowid) FROM int +-- +ok +== +SELECT rowid // 200 AS g, COUNT(i), COUNT(rowid) FROM int GROUP BY g +-- +ok +== diff --git a/parser/testdata/corpus/sql/aggregate/aggregates/test_count_star.test b/parser/testdata/corpus/sql/aggregate/aggregates/test_count_star.test new file mode 100644 index 0000000..3f652e4 --- /dev/null +++ b/parser/testdata/corpus/sql/aggregate/aggregates/test_count_star.test @@ -0,0 +1,21 @@ +# source: test/sql/aggregate/aggregates/test_count_star.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +CREATE TABLE integers(i INTEGER, j INTEGER); +-- +ok +== +INSERT INTO integers VALUES (3, 4), (3, 4), (2, 4); +-- +ok +== +SELECT i, COUNT(*) FROM integers GROUP BY i ORDER BY i +-- +ok +== +SELECT i, COUNT() FROM integers GROUP BY i ORDER BY i +-- +ok +== diff --git a/parser/testdata/corpus/sql/aggregate/aggregates/test_covar.test b/parser/testdata/corpus/sql/aggregate/aggregates/test_covar.test new file mode 100644 index 0000000..1d6da03 --- /dev/null +++ b/parser/testdata/corpus/sql/aggregate/aggregates/test_covar.test @@ -0,0 +1,65 @@ +# source: test/sql/aggregate/aggregates/test_covar.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +SELECT COVAR_POP() +-- +ok +== +SELECT COVAR_POP(1, 2, 3) +-- +ok +== +SELECT COVAR_POP(COVAR_POP(1)) +-- +ok +== +SELECT COVAR_SAMP() +-- +ok +== +SELECT COVAR_SAMP(1, 2, 3) +-- +ok +== +SELECT COVAR_SAMP(COVAR_SAMP(1)) +-- +ok +== +SELECT COVAR_POP(3,3), COVAR_POP(NULL,3), COVAR_POP(3,NULL), COVAR_POP(NULL,NULL) +-- +ok +== +SELECT COVAR_SAMP(3,3), COVAR_SAMP(NULL,3), COVAR_SAMP(3,NULL), COVAR_SAMP(NULL,NULL) +-- +ok +== +CREATE SEQUENCE seqx; +-- +ok +== +CREATE SEQUENCE seqy; +-- +ok +== +SELECT COVAR_POP(nextval('seqx'),nextval('seqy')) +-- +ok +== +SELECT COVAR_POP(x,y), COVAR_POP(x,1), COVAR_POP(1,y), COVAR_POP(x,NULL), COVAR_POP(NULL,y) FROM integers +-- +ok +== +SELECT COVAR_SAMP(x,y), COVAR_SAMP(x,1), COVAR_SAMP(1,y), COVAR_SAMP(x,NULL), COVAR_SAMP(NULL,y) FROM integers +-- +ok +== +SELECT COVAR_POP(x,y), COVAR_SAMP(x,y) FROM integers WHERE x > 100 +-- +ok +== +SELECT COVAR_POP(NULL, NULL), COVAR_SAMP(NULL, NULL) FROM integers +-- +ok +== diff --git a/parser/testdata/corpus/sql/aggregate/aggregates/test_empty_aggregate.test b/parser/testdata/corpus/sql/aggregate/aggregates/test_empty_aggregate.test new file mode 100644 index 0000000..fd21f80 --- /dev/null +++ b/parser/testdata/corpus/sql/aggregate/aggregates/test_empty_aggregate.test @@ -0,0 +1,21 @@ +# source: test/sql/aggregate/aggregates/test_empty_aggregate.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +SELECT COUNT(*), COUNT(i), STDDEV_SAMP(i), SUM(i), SUM(DISTINCT i), FIRST(i), LAST(i), MAX(i), MIN(i) FROM integers WHERE i > 100 +-- +ok +== +CREATE TABLE emptyaggr(i INTEGER); +-- +ok +== +SELECT COUNT(*) FROM emptyaggr +-- +ok +== +SELECT SUM(i), COUNT(i), COUNT(DISTINCT i), COUNT(*), AVG(i), COUNT(*)+1, COUNT(i)+1, MIN(i), MIN(i+1), MIN(i)+1 FROM emptyaggr +-- +ok +== diff --git a/parser/testdata/corpus/sql/aggregate/aggregates/test_entropy.test b/parser/testdata/corpus/sql/aggregate/aggregates/test_entropy.test new file mode 100644 index 0000000..51ff5d4 --- /dev/null +++ b/parser/testdata/corpus/sql/aggregate/aggregates/test_entropy.test @@ -0,0 +1,78 @@ +# source: test/sql/aggregate/aggregates/test_entropy.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +select entropy() +-- +ok +== +select entropy(NULL) +-- +ok +== +select entropy(1) +-- +ok +== +select entropy(*) +-- +ok +== +create table aggr(k int); +-- +ok +== +insert into aggr values (0),(1),(1),(1),(4),(0),(3),(3),(2),(2),(4),(4),(2),(4),(0),(0),(0),(1),(2),(3),(4),(2),(3),(3),(1); +-- +ok +== +select entropy(k) from aggr ; +-- +ok +== +SELECT entropy(2) FROM range(100); +-- +ok +== +select entropy(k) from aggr group by k%2 order by all +-- +ok +== +create table names (name string) +-- +ok +== +insert into names values ('pedro'), ('pedro'), ('pedro'),('hannes'),('hannes'),('mark'),(null); +-- +ok +== +select entropy(name) from names; +-- +ok +== +create table array_names as select case when name is null then null else [name] end l from names +-- +ok +== +select entropy(l) from array_names; +-- +ok +== +create table array_of_structs as select case when name is null then null else [{'name': name}] end l from names +-- +ok +== +select entropy(l) from array_of_structs; +-- +ok +== +select entropy(k) over (partition by k%2) + from aggr; +-- +ok +== +SELECT entropy(i) FROM range(100) tbl(i) WHERE 1=0; +-- +ok +== diff --git a/parser/testdata/corpus/sql/aggregate/aggregates/test_first_last_any_ordered.test b/parser/testdata/corpus/sql/aggregate/aggregates/test_first_last_any_ordered.test new file mode 100644 index 0000000..218e75d --- /dev/null +++ b/parser/testdata/corpus/sql/aggregate/aggregates/test_first_last_any_ordered.test @@ -0,0 +1,57 @@ +# source: test/sql/aggregate/aggregates/test_first_last_any_ordered.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +CREATE TABLE integers(i INTEGER, grp INTEGER); +-- +ok +== +INSERT INTO integers VALUES (1, NULL), (2, 3), (3, 2), (NULL, 1); +-- +ok +== +SELECT FIRST(i ORDER BY grp NULLS LAST) FROM integers +-- +ok +== +SELECT FIRST(i ORDER BY grp NULLS FIRST) FROM integers +-- +ok +== +SELECT ANY_VALUE(i ORDER BY grp NULLS FIRST) FROM integers +-- +ok +== +SELECT ANY_VALUE(i ORDER BY grp NULLS LAST) FROM integers +-- +ok +== +SELECT ARG_MIN(i, grp) FROM integers +-- +ok +== +SELECT FIRST(i ORDER BY grp DESC NULLS LAST) FROM integers +-- +ok +== +SELECT ANY_VALUE(i ORDER BY grp DESC NULLS FIRST) FROM integers +-- +ok +== +SELECT ANY_VALUE(i ORDER BY grp DESC NULLS LAST) FROM integers +-- +ok +== +SELECT ARG_MAX(i, grp) FROM integers +-- +ok +== +SELECT LAST(i ORDER BY grp NULLS FIRST) FROM integers +-- +ok +== +SELECT LAST(i ORDER BY grp DESC NULLS FIRST) FROM integers +-- +ok +== diff --git a/parser/testdata/corpus/sql/aggregate/aggregates/test_first_noninlined.test b/parser/testdata/corpus/sql/aggregate/aggregates/test_first_noninlined.test new file mode 100644 index 0000000..206fb02 --- /dev/null +++ b/parser/testdata/corpus/sql/aggregate/aggregates/test_first_noninlined.test @@ -0,0 +1,37 @@ +# source: test/sql/aggregate/aggregates/test_first_noninlined.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +SELECT FIRST(b) FROM tbl WHERE a=2 +-- +ok +== +SELECT ARBITRARY(b) FROM tbl WHERE a=2 +-- +ok +== +SELECT FIRST(b) FROM tbl WHERE a=1 +-- +ok +== +SELECT FIRST(b) FROM tbl WHERE a=1 GROUP BY a +-- +ok +== +SELECT FIRST(b) FROM tbl WHERE a=0 +-- +ok +== +SELECT FIRST(b) FROM tbl WHERE a=0 GROUP BY b +-- +ok +== +SELECT a, FIRST(b) FROM tbl GROUP BY a ORDER BY a +-- +ok +== +SELECT FIRST(i) FROM (VALUES (NULL::INT32)) tbl(i) +-- +ok +== diff --git a/parser/testdata/corpus/sql/aggregate/aggregates/test_group_on_expression.test b/parser/testdata/corpus/sql/aggregate/aggregates/test_group_on_expression.test new file mode 100644 index 0000000..37c6da7 --- /dev/null +++ b/parser/testdata/corpus/sql/aggregate/aggregates/test_group_on_expression.test @@ -0,0 +1,49 @@ +# source: test/sql/aggregate/aggregates/test_group_on_expression.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +CREATE TABLE integer(i INTEGER, j INTEGER); +-- +ok +== +INSERT INTO integer VALUES (3, 4), (3, 5), (3, 7); +-- +ok +== +SELECT j * 2 FROM integer GROUP BY j * 2 ORDER BY j * 2; +-- +ok +== +SELECT integer.j * 2 FROM integer GROUP BY j * 2 ORDER BY j * 2; +-- +ok +== +SELECT j * 2 FROM integer GROUP BY integer.j * 2 ORDER BY j * 2; +-- +ok +== +SELECT j * 2 FROM integer GROUP BY j * 2 ORDER BY integer.j * 2; +-- +ok +== +SELECT integer.j * 2 FROM integer GROUP BY j * 2 ORDER BY integer.j * 2; +-- +ok +== +SELECT j * 2 FROM integer GROUP BY integer.j * 2 ORDER BY integer.j * 2; +-- +ok +== +SELECT integer.j * 2 FROM integer GROUP BY integer.j * 2 ORDER BY j * 2; +-- +ok +== +SELECT integer.j * 2 FROM integer GROUP BY integer.j * 2 ORDER BY integer.j * 2; +-- +ok +== +SELECT j * 2 AS i FROM integer GROUP BY j * 2 ORDER BY i; +-- +ok +== diff --git a/parser/testdata/corpus/sql/aggregate/aggregates/test_histogram.test b/parser/testdata/corpus/sql/aggregate/aggregates/test_histogram.test new file mode 100644 index 0000000..6805fbb --- /dev/null +++ b/parser/testdata/corpus/sql/aggregate/aggregates/test_histogram.test @@ -0,0 +1,145 @@ +# source: test/sql/aggregate/aggregates/test_histogram.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +select histogram(NULL) +-- +ok +== +SELECT histogram(i) FROM range(100) tbl(i) WHERE 1=0; +-- +ok +== +select histogram(1) +-- +ok +== +SELECT histogram('、') +-- +ok +== +SELECT histogram(2) FROM range(100); +-- +ok +== +WITH d(v) AS ( + VALUES (1.0), ('nan'::DOUBLE), ('nan'::DOUBLE), (1.0) +) +SELECT histogram(v)::VARCHAR FROM d; +-- +ok +== +WITH d(v) AS ( + VALUES (1.0), ('nan'::DOUBLE), ('nan'::DOUBLE), (1.0) +) +SELECT histogram(v) OVER ()::VARCHAR FROM d LIMIT 1; +-- +ok +== +CREATE TABLE hist_data (g INTEGER, e INTEGER) +-- +ok +== +INSERT INTO hist_data VALUES (1, 1), (1, 2), (2, 3), (2, 4), (2, 5), (3, 6), (5, NULL) +-- +ok +== +SELECT histogram(g) from hist_data +-- +ok +== +SELECT histogram(e) from hist_data +-- +ok +== +SELECT histogram(g)::VARCHAR, mode(g), round(entropy(g), 6) FROM hist_data; +-- +ok +== +select histogram(g) + from hist_data + group by g%2==0 ORDER BY g%2==0 +-- +ok +== +select histogram(g) + from hist_data + where g < 3 +-- +ok +== +insert into names values ('pedro'), ('pedro'), ('pedro'),('hannes'),('hannes'),('mark'),(null),('Hubert Blaine Wolfeschlegelsteinhausenbergerdorff Sr.'); +-- +ok +== +select histogram(name) from names; +-- +ok +== +SELECT histogram(CAST('2021-08-20' AS TIMESTAMP_S)); +-- +ok +== +SELECT histogram(CAST('2021-08-20' AS TIMESTAMP_MS)); +-- +ok +== +SELECT histogram(CAST('2021-08-20' AS TIMESTAMP_NS)); +-- +ok +== +SELECT histogram(CAST('15:05:42' AS TIME)); +-- +ok +== +SELECT histogram(CAST('15:05:42+00' AS TIME WITH TIME ZONE)); +-- +ok +== +SELECT histogram(CAST('2022-01-02' AS DATE)); +-- +ok +== +select g,histogram(g) over (partition by g%2) + from hist_data; +-- +ok +== +select histogram() +-- +ok +== +select histogram(*) +-- +ok +== +CREATE TYPE mood AS ENUM ('sad', 'ok', 'happy') +-- +ok +== +CREATE TABLE enums (e mood) +-- +ok +== +INSERT INTO enums VALUES ('happy'), ('ok') +-- +ok +== +SELECT histogram(e) FROM enums +-- +ok +== +SELECT histogram([g])::VARCHAR, histogram({'g': g})::VARCHAR FROM hist_data; +-- +ok +== +SELECT histogram(DISTINCT e) FILTER (WHERE g < 3)::VARCHAR FROM hist_data; +-- +ok +== +EXPLAIN (FORMAT JSON) +SELECT histogram(g), mode(g), entropy(g) FROM hist_data; +-- +ok +== diff --git a/parser/testdata/corpus/sql/aggregate/aggregates/test_histogram_3529.test b/parser/testdata/corpus/sql/aggregate/aggregates/test_histogram_3529.test new file mode 100644 index 0000000..c0c7a12 --- /dev/null +++ b/parser/testdata/corpus/sql/aggregate/aggregates/test_histogram_3529.test @@ -0,0 +1,27 @@ +# source: test/sql/aggregate/aggregates/test_histogram_3529.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +create table tmp (c0 integer, c1 integer); +-- +ok +== +insert into tmp values +(0, 0), +(1, 1), +(2, 0), +(0, 1), +(1, 0), +(2, 1), +(0, 0), +(1, 1), +(2, 0), +(0, 1); +-- +ok +== +SELECT c0, histogram(c1) FROM tmp GROUP BY c0 ORDER BY ALL +-- +ok +== diff --git a/parser/testdata/corpus/sql/aggregate/aggregates/test_incorrect_aggregate.test b/parser/testdata/corpus/sql/aggregate/aggregates/test_incorrect_aggregate.test new file mode 100644 index 0000000..8c58998 --- /dev/null +++ b/parser/testdata/corpus/sql/aggregate/aggregates/test_incorrect_aggregate.test @@ -0,0 +1,57 @@ +# source: test/sql/aggregate/aggregates/test_incorrect_aggregate.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +SELECT COUNT(1, 2, 3) +-- +ok +== +SELECT COUNT(COUNT(1)) +-- +ok +== +SELECT STDDEV_SAMP() +-- +ok +== +SELECT STDDEV_SAMP(1, 2, 3) +-- +ok +== +SELECT STDDEV_SAMP(STDDEV_SAMP(1)) +-- +ok +== +SELECT SUM(1, 2, 3) +-- +ok +== +SELECT SUM(SUM(1)) +-- +ok +== +SELECT FIRST(1, 2, 3) +-- +ok +== +SELECT FIRST(FIRST(1)) +-- +ok +== +SELECT MAX(1, 2, 3) +-- +ok +== +SELECT MAX(MAX(1)) +-- +ok +== +SELECT MIN(1, 2, 3) +-- +ok +== +SELECT MIN(MIN(1)) +-- +ok +== diff --git a/parser/testdata/corpus/sql/aggregate/aggregates/test_kahan_avg.test b/parser/testdata/corpus/sql/aggregate/aggregates/test_kahan_avg.test new file mode 100644 index 0000000..d392173 --- /dev/null +++ b/parser/testdata/corpus/sql/aggregate/aggregates/test_kahan_avg.test @@ -0,0 +1,17 @@ +# source: test/sql/aggregate/aggregates/test_kahan_avg.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +CREATE TABLE doubles(n DOUBLE); +-- +ok +== +INSERT INTO doubles (n) VALUES ('9007199254740992'::DOUBLE), (1::DOUBLE), (1::DOUBLE), (0::DOUBLE); +-- +ok +== +SELECT FAVG(n) - '2251799813685248.5'::DOUBLE FROM doubles; +-- +ok +== diff --git a/parser/testdata/corpus/sql/aggregate/aggregates/test_kahan_sum.test b/parser/testdata/corpus/sql/aggregate/aggregates/test_kahan_sum.test new file mode 100644 index 0000000..b034fd4 --- /dev/null +++ b/parser/testdata/corpus/sql/aggregate/aggregates/test_kahan_sum.test @@ -0,0 +1,17 @@ +# source: test/sql/aggregate/aggregates/test_kahan_sum.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +SELECT FSUM(n)::BIGINT FROM doubles; +-- +ok +== +SELECT sumKahan(n)::BIGINT FROM doubles; +-- +ok +== +SELECT kahan_sum(n)::BIGINT FROM doubles; +-- +ok +== diff --git a/parser/testdata/corpus/sql/aggregate/aggregates/test_kurtosis.test b/parser/testdata/corpus/sql/aggregate/aggregates/test_kurtosis.test new file mode 100644 index 0000000..a4f1f33 --- /dev/null +++ b/parser/testdata/corpus/sql/aggregate/aggregates/test_kurtosis.test @@ -0,0 +1,77 @@ +# source: test/sql/aggregate/aggregates/test_kurtosis.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +select kurtosis() +-- +ok +== +select kurtosis(NULL) +-- +ok +== +select kurtosis(1) +-- +ok +== +select kurtosis(*) +-- +ok +== +select kurtosis(i) from (values (0), (0), (0), (0), (0), (0)) tbl(i) +-- +ok +== +select kurtosis(i) from (values (2e304), (2e305), (2e306), (2e307)) tbl(i) +-- +ok +== +select kurtosis(10) from range (5) +-- +ok +== +select kurtosis(10) from range (5) where 1 == 0 +-- +ok +== +create table aggr(k int, v int, v2 int); +-- +ok +== +insert into aggr values + (1, 10, null), + (2, 10, 11), + (2, 10, 15), + (2, 10, 18), + (2, 20, 22), + (2, 20, 25), + (2, 25, null), + (2, 30, 35), + (2, 30, 40), + (2, 30, 50), + (2, 30, 51); +-- +ok +== +select kurtosis(k), kurtosis(v), kurtosis(v2) from aggr; +-- +ok +== +select kurtosis_pop(k), kurtosis_pop(v), kurtosis_pop(v2) from aggr; +-- +ok +== +with onetwo as (select range::float as v from range(1,3)) select kurtosis_pop(v) from onetwo; +-- +ok +== +select kurtosis(v2) from aggr group by v ORDER BY ALL; +-- +ok +== +select kurtosis(v2) over (partition by v) + from aggr; +-- +ok +== diff --git a/parser/testdata/corpus/sql/aggregate/aggregates/test_last.test b/parser/testdata/corpus/sql/aggregate/aggregates/test_last.test new file mode 100644 index 0000000..55b6ae3 --- /dev/null +++ b/parser/testdata/corpus/sql/aggregate/aggregates/test_last.test @@ -0,0 +1,114 @@ +# source: test/sql/aggregate/aggregates/test_last.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +SELECT LAST(i) FROM five +-- +ok +== +SELECT i % 3 AS g, LAST(i) FROM five GROUP BY 1 ORDER BY 1 +-- +ok +== +SELECT LAST(i ORDER BY 5-i) FROM five +-- +ok +== +SELECT i % 3 AS g, LAST(i ORDER BY 5-i) FROM five GROUP BY 1 ORDER BY 1 +-- +ok +== +SELECT i::INTEGER % 3 AS g, LAST(i ORDER BY 5-i) FROM five GROUP BY 1 ORDER BY 1 +-- +ok +== +CREATE TABLE five_dates AS + SELECT + i::integer AS i, + '2021-08-20'::DATE + i::INTEGER AS d, + '2021-08-20'::TIMESTAMP + INTERVAL (i) HOUR AS dt, + '14:59:37'::TIME + INTERVAL (i) MINUTE AS t, + INTERVAL (i) SECOND AS s + FROM range(1, 6, 1) t1(i) +-- +ok +== +SELECT LAST(d), LAST(dt), LAST(t), LAST(s) FROM five_dates +-- +ok +== +SELECT i % 3 AS g, LAST(d), LAST(dt), LAST(t), LAST(s) +FROM five_dates +GROUP BY 1 +ORDER BY 1 +-- +ok +== +SELECT LAST(d ORDER BY 5-i), LAST(dt ORDER BY 5-i), LAST(t ORDER BY 5-i), LAST(s ORDER BY 5-i) FROM five_dates +-- +ok +== +SELECT i % 3 AS g, LAST(d ORDER BY 5-i), LAST(dt ORDER BY 5-i), LAST(t ORDER BY 5-i), LAST(s ORDER BY 5-i) +FROM five_dates +GROUP BY 1 +ORDER BY 1 +-- +ok +== +SELECT LAST(dt::TIMESTAMPTZ), LAST(t::TIMETZ) FROM five_dates +-- +ok +== +SELECT i % 3 AS g, LAST(dt::TIMESTAMPTZ), LAST(t::TIMETZ) +FROM five_dates +GROUP BY 1 +ORDER BY 1 +-- +ok +== +SELECT LAST(dt::TIMESTAMPTZ ORDER BY 5-i), LAST(t::TIMETZ ORDER BY 5-i) FROM five_dates +-- +ok +== +SELECT i % 3 AS g, LAST(dt::TIMESTAMPTZ ORDER BY 5-i), LAST(t::TIMETZ ORDER BY 5-i) +FROM five_dates +GROUP BY 1 +ORDER BY 1 +-- +ok +== +CREATE TABLE five_complex AS + SELECT + i::integer AS i, + i::VARCHAR AS s, + [i] AS l, + {'a': i} AS r + FROM range(1, 6, 1) t1(i) +-- +ok +== +SELECT LAST(s), LAST(l), LAST(r) +FROM five_complex +-- +ok +== +SELECT i % 3 AS g, LAST(s), LAST(l), LAST(r) +FROM five_complex +GROUP BY 1 +ORDER BY 1 +-- +ok +== +SELECT LAST(s ORDER BY 5-i), LAST(l ORDER BY 5-i), LAST(r ORDER BY 5-i) +FROM five_complex +-- +ok +== +SELECT i % 3 AS g, LAST(s ORDER BY 5-i), LAST(l ORDER BY 5-i), LAST(r ORDER BY 5-i) +FROM five_complex +GROUP BY 1 +ORDER BY 1 +-- +ok +== diff --git a/parser/testdata/corpus/sql/aggregate/aggregates/test_last_noninlined.test b/parser/testdata/corpus/sql/aggregate/aggregates/test_last_noninlined.test new file mode 100644 index 0000000..5c41ecd --- /dev/null +++ b/parser/testdata/corpus/sql/aggregate/aggregates/test_last_noninlined.test @@ -0,0 +1,33 @@ +# source: test/sql/aggregate/aggregates/test_last_noninlined.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +SELECT LAST(b) FROM tbl WHERE a=2 +-- +ok +== +SELECT LAST(b) FROM tbl WHERE a=1 +-- +ok +== +SELECT LAST(b) FROM tbl WHERE a=1 GROUP BY a +-- +ok +== +SELECT LAST(b) FROM tbl WHERE a=0 +-- +ok +== +SELECT LAST(b) FROM tbl WHERE a=0 GROUP BY b +-- +ok +== +SELECT a, LAST(b) FROM tbl GROUP BY a ORDER BY a +-- +ok +== +SELECT LAST(i) FROM (VALUES (NULL::INT32)) tbl(i) +-- +ok +== diff --git a/parser/testdata/corpus/sql/aggregate/aggregates/test_mad.test b/parser/testdata/corpus/sql/aggregate/aggregates/test_mad.test new file mode 100644 index 0000000..b9dddbc --- /dev/null +++ b/parser/testdata/corpus/sql/aggregate/aggregates/test_mad.test @@ -0,0 +1,96 @@ +# source: test/sql/aggregate/aggregates/test_mad.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +SELECT mad(NULL), mad(1) +-- +ok +== +SELECT mad(NULL), mad(1) FROM range(2000) +-- +ok +== +create table tinys as + select range r, random() + from range(100) + union all values (NULL, 0.1), (NULL, 0.5), (NULL, 0.9) + order by 2; +-- +ok +== +SELECT mad(r::{type}) FROM tinys +-- +error: Parser Error: syntax error at or near "{" +== +SELECT mad(NULL::{type}) FROM tinys +-- +error: Parser Error: syntax error at or near "{" +== +SELECT mad(42::{type}) FROM tinys +-- +error: Parser Error: syntax error at or near "{" +== +create table numerics as + select range r, random() + from range(10000) + union all values (NULL, 0.1), (NULL, 0.5), (NULL, 0.9) + order by 2; +-- +ok +== +SELECT mad(r::{type}) FROM numerics +-- +error: Parser Error: syntax error at or near "{" +== +SELECT mad(NULL::{type}) FROM numerics +-- +error: Parser Error: syntax error at or near "{" +== +SELECT mad(42::{type}) FROM numerics +-- +error: Parser Error: syntax error at or near "{" +== +SELECT mad(('2018-01-01'::DATE + INTERVAL (r) DAY)::DATE) FROM numerics +-- +ok +== +SELECT mad('2018-01-01'::TIMESTAMP + INTERVAL (r) HOUR) FROM numerics +-- +ok +== +SELECT mad('00:00:00'::TIME + INTERVAL (r) SECOND) FROM numerics +-- +ok +== +select mad(x) from (values ('127'::DECIMAL(3,0)), ('-128'::DECIMAL(3,0))) tbl(x); +-- +ok +== +select mad(x) from (values ('32767'::DECIMAL(5,0)), ('-32768'::DECIMAL(5,0))) tbl(x); +-- +ok +== +select mad(x) from (values ('2147483647'::DECIMAL(10,0)), ('-2147483648'::DECIMAL(10,0))) tbl(x); +-- +ok +== +select mad(x) from (values (-1e308), (1e308)) tbl(x); +-- +ok +== +select mad(x) from (values ('294247-01-10'::date), ('290309-12-22 (BC)'::date)) tbl(x); +-- +ok +== +select mad(x) from (values + ('294247-01-10 04:00:54.775806'::timestamp), + ('290309-12-22 (BC) 00:00:00'::timestamp) + ) tbl(x); +-- +ok +== +select mad(x) from (values ('23:59:59.999999'::time), ('00:00:00'::time)) tbl(x); +-- +ok +== diff --git a/parser/testdata/corpus/sql/aggregate/aggregates/test_median.test b/parser/testdata/corpus/sql/aggregate/aggregates/test_median.test new file mode 100644 index 0000000..efd4d76 --- /dev/null +++ b/parser/testdata/corpus/sql/aggregate/aggregates/test_median.test @@ -0,0 +1,121 @@ +# source: test/sql/aggregate/aggregates/test_median.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +SELECT median(NULL), median(1) +-- +ok +== +SELECT median(NULL), median(1) FROM range(2000) +-- +ok +== +SELECT median(r)::VARCHAR FROM quantile +-- +ok +== +SELECT median(r::float)::VARCHAR FROM quantile +-- +ok +== +SELECT median(r::double)::VARCHAR FROM quantile +-- +ok +== +SELECT median(r::tinyint)::VARCHAR FROM quantile where r < 100 +-- +ok +== +SELECT median(r::smallint)::VARCHAR FROM quantile +-- +ok +== +SELECT median(r::integer)::VARCHAR FROM quantile +-- +ok +== +SELECT median(r::bigint)::VARCHAR FROM quantile +-- +ok +== +SELECT median(r::hugeint)::VARCHAR FROM quantile +-- +ok +== +SELECT median(r::decimal(10,2))::VARCHAR FROM quantile +-- +ok +== +SELECT median(case when r is null then null else [r] end)::VARCHAR FROM quantile +-- +ok +== +SELECT median(case when r is null then null else {'i': r} end)::VARCHAR FROM quantile +-- +ok +== +SELECT median(r::varchar) FROM quantile +-- +ok +== +SELECT median(case when r is null then null else concat('thishasalongprefix_', r::varchar) end) FROM quantile +-- +ok +== +SELECT median(NULL) FROM quantile +-- +ok +== +SELECT median(42) FROM quantile +-- +ok +== +SELECT MEDIAN(range::{type}) +FROM range(0,10); +-- +error: Parser Error: syntax error at or near "{" +== +SELECT MEDIAN(range::{type}) +FROM range('2024-01-01'::date, '2024-01-11'::date, INTERVAL 1 DAY); +-- +error: Parser Error: syntax error at or near "{" +== +SELECT MEDIAN(range::timestamptz) +FROM range('2024-01-01'::date, '2024-01-11'::date, INTERVAL 1 DAY); +-- +ok +== +SELECT MEDIAN('00:00:00'::TIME + INTERVAL (range) HOUR) +FROM range(0,10); +-- +ok +== +SELECT MEDIAN(ttz::TIMETZ) +FROM (VALUES + ('00:00:00-09'), + ('00:00:00-08'), + ('00:00:00-07'), + ('00:00:00-06'), + ('00:00:00-05'), + ('00:00:00-04'), + ('00:00:00-03'), + ('00:00:00-02'), + ('00:00:00-01'), + ('00:00:00+00'), +) tbl(ttz); +-- +ok +== +SELECT MEDIAN(x) +FROM (VALUES + (INTERVAL '1 day'), + (INTERVAL '10 days') +) v(x); +-- +ok +== +SELECT MEDIAN(range::{type}) FROM range(0,10); +-- +error: Parser Error: syntax error at or near "{" +== diff --git a/parser/testdata/corpus/sql/aggregate/aggregates/test_minmax.test b/parser/testdata/corpus/sql/aggregate/aggregates/test_minmax.test new file mode 100644 index 0000000..95fb3c0 --- /dev/null +++ b/parser/testdata/corpus/sql/aggregate/aggregates/test_minmax.test @@ -0,0 +1,17 @@ +# source: test/sql/aggregate/aggregates/test_minmax.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +create table lists as select array[i] l from generate_series(0,5,1) tbl(i); +-- +ok +== +select min(l) from lists where l[1]>2; +-- +ok +== +select min(l) from lists where l[0]>2; +-- +ok +== diff --git a/parser/testdata/corpus/sql/aggregate/aggregates/test_minmax_14145.test b/parser/testdata/corpus/sql/aggregate/aggregates/test_minmax_14145.test new file mode 100644 index 0000000..c072341 --- /dev/null +++ b/parser/testdata/corpus/sql/aggregate/aggregates/test_minmax_14145.test @@ -0,0 +1,9 @@ +# source: test/sql/aggregate/aggregates/test_minmax_14145.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +DESCRIBE SELECT max(l) from (select unnest( [{'a':1}::JSON, [2]::JSON ]) as l); +-- +ok +== diff --git a/parser/testdata/corpus/sql/aggregate/aggregates/test_mode.test b/parser/testdata/corpus/sql/aggregate/aggregates/test_mode.test new file mode 100644 index 0000000..af35547 --- /dev/null +++ b/parser/testdata/corpus/sql/aggregate/aggregates/test_mode.test @@ -0,0 +1,243 @@ +# source: test/sql/aggregate/aggregates/test_mode.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +select mode() +-- +ok +== +select mode(NULL) +-- +ok +== +select mode(1) +-- +ok +== +select mode(*) +-- +ok +== +create table aggr(k int, v decimal(10,2)); +-- +ok +== +insert into aggr (k, v) values (1, 10), (1, 10), (1, 20), (1, 21); +-- +ok +== +select mode(v) from aggr; +-- +ok +== +SELECT mode(2) FROM range(100); +-- +ok +== +insert into aggr (k, v) values (2, 20),(2, 20), (2, 25), (2, 30); +-- +ok +== +SELECT CASE + WHEN ( value = 10 or value = 20) + THEN TRUE + ELSE FALSE + END + FROM (select mode(v) as value from aggr) AS T +-- +ok +== +insert into aggr (k, v) values (3, null); +-- +ok +== +select k, mode(v) + from aggr + group by k + order by k; +-- +ok +== +select mode(name) from names; +-- +ok +== +select k, v, mode(v) over (partition by k) + from aggr + order by k, v; +-- +ok +== +SELECT mode(i) FROM range(100) tbl(i) WHERE 1=0; +-- +ok +== +create table dates (k int, v date) +-- +ok +== +insert into dates values + (1, '2021-05-02'), + (1, '2021-05-02'), + (2, '2021-05-02'), + (2, '2020-02-29'), + (2, '2020-02-29'), + (3, '2004-09-01'), + (1, null); +-- +ok +== +select mode(v) from dates; +-- +ok +== +select k, mode(v) from dates group by k ORDER BY ALL; +-- +ok +== +select k, v, mode(v) over (partition by k) + from dates + order by k, v; +-- +ok +== +create table times (k int, v time) +-- +ok +== +insert into times values + (1, '12:11:49.5'), + (1, '12:11:49.5'), + (2, '12:11:49.5'), + (2, '06:30:00'), + (2, '06:30:00'), + (3, '21:15:22'), + (1, null); +-- +ok +== +select mode(v) from times; +-- +ok +== +select k, mode(v) from times group by k ORDER BY ALL; +-- +ok +== +select k, v, mode(v) over (partition by k) + from times + order by k, v; +-- +ok +== +create table timestamps (k int, v timestamp) +-- +ok +== +insert into timestamps values + (1, '2021-05-02 12:11:49.5'), + (1, '2021-05-02 12:11:49.5'), + (2, '2021-05-02 12:11:49.5'), + (2,'2020-02-29 06:30:00'), + (2,'2020-02-29 06:30:00'), + (3,'2004-09-01 21:15:22'), + (1, null); +-- +ok +== +select mode(v) from timestamps; +-- +ok +== +select k, mode(v) from timestamps group by k ORDER BY ALL; +-- +ok +== +select k, v, mode(v) over (partition by k) + from timestamps + order by k, v; +-- +ok +== +create table intervals (k int, v interval) +-- +ok +== +insert into intervals values + (1, INTERVAL '5 months 2 days 12 hours 11 minutes 49 seconds'), + (1, INTERVAL '5 months 2 days 12 hours 11 minutes 49 seconds'), + (2, INTERVAL '5 months 2 days 12 hours 11 minutes 49 seconds'), + (2, INTERVAL '2 months 29 days 6 hours 30 minutes'), + (2, INTERVAL '2 months 29 days 6 hours 30 minutes'), + (3, INTERVAL '9 months 1 day 21 hours 15 minutes 22 seconds'), + (1, null); +-- +ok +== +select mode(v) from intervals; +-- +ok +== +select k, mode(v) from intervals group by k ORDER BY ALL; +-- +ok +== +select k, v, mode(v) over (partition by k) + from intervals + order by k, v; +-- +ok +== +create table hugeints (k int, v hugeint) +-- +ok +== +insert into hugeints values (1, 5), (1, 5), (2, 5), (2, 2), (2, 2), (3, 1), (1, null); +-- +ok +== +select mode(v) from hugeints; +-- +ok +== +select k, mode(v) from hugeints group by k ORDER BY ALL; +-- +ok +== +select k, v, mode(v) over (partition by k) + from hugeints + order by k, v; +-- +ok +== +SELECT MODE(order_occurrences ORDER BY order_occurrences DESC) FROM ( +VALUES + (500, 1), + (1000, 2), + (800, 3), + (1000, 4), + (500, 5), + (550, 6), + (400, 7), + (200, 8), + (10, 9) +)items_per_order(order_occurrences, item_count); +-- +ok +== +PRAGMA threads=4; +-- +ok +== +CREATE TABLE mode_utf8 AS +SELECT g, (['চৌদ্দগ্রাম', 'São Paulo', '東京都', 'Região Geográfica'])[1 + (g+s) % 4] AS v +FROM generate_series(0,100000) _(g), generate_series(0,2) __(s); +-- +ok +== +SELECT count(*) FROM (SELECT g, mode(v) AS m FROM mode_utf8 GROUP BY g) +WHERE m IN ('চৌদ্দগ্রাম', 'São Paulo', '東京都', 'Região Geográfica'); +-- +ok +== diff --git a/parser/testdata/corpus/sql/aggregate/aggregates/test_null_aggregates.test b/parser/testdata/corpus/sql/aggregate/aggregates/test_null_aggregates.test new file mode 100644 index 0000000..c4669a1 --- /dev/null +++ b/parser/testdata/corpus/sql/aggregate/aggregates/test_null_aggregates.test @@ -0,0 +1,385 @@ +# source: test/sql/aggregate/aggregates/test_null_aggregates.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +CREATE TABLE t1(c0 BIGINT, c1 SMALLINT); +-- +ok +== +INSERT INTO t1 VALUES(NULL,NULL); +-- +ok +== +INSERT INTO t1 VALUES(-9121942514766415310,NULL); +-- +ok +== +INSERT INTO t1 VALUES(-9113483941634330359,NULL); +-- +ok +== +INSERT INTO t1 VALUES(-8718457747090493475,NULL); +-- +ok +== +INSERT INTO t1 VALUES(-7650527153348320600,NULL); +-- +ok +== +INSERT INTO t1 VALUES(-7511073704802549520,NULL); +-- +ok +== +INSERT INTO t1 VALUES(-7342137292157212364,NULL); +-- +ok +== +INSERT INTO t1 VALUES(-7003121677824953185,NULL); +-- +ok +== +INSERT INTO t1 VALUES(-6971852266038069200,NULL); +-- +ok +== +INSERT INTO t1 VALUES(-6873545755554765972,NULL); +-- +ok +== +INSERT INTO t1 VALUES(-6355311124878824053,NULL); +-- +ok +== +INSERT INTO t1 VALUES(-6350463272352412486,NULL); +-- +ok +== +INSERT INTO t1 VALUES(-5908442705000090253,NULL); +-- +ok +== +INSERT INTO t1 VALUES(-5897662788702027960,NULL); +-- +ok +== +INSERT INTO t1 VALUES(-5877879044803815845,NULL); +-- +ok +== +INSERT INTO t1 VALUES(-5732980609151508408,NULL); +-- +ok +== +INSERT INTO t1 VALUES(-5361272612100082873,NULL); +-- +ok +== +INSERT INTO t1 VALUES(-5336571579832669145,NULL); +-- +ok +== +INSERT INTO t1 VALUES(-4928993529687100359,NULL); +-- +ok +== +INSERT INTO t1 VALUES(-4468905900574568755,NULL); +-- +ok +== +INSERT INTO t1 VALUES(-4170492860397664351,NULL); +-- +ok +== +INSERT INTO t1 VALUES(-3684174996218175685,NULL); +-- +ok +== +INSERT INTO t1 VALUES(-3550425917959859111,NULL); +-- +ok +== +INSERT INTO t1 VALUES(-3538537641982313134,NULL); +-- +ok +== +INSERT INTO t1 VALUES(-3509778083052175642,NULL); +-- +ok +== +INSERT INTO t1 VALUES(-3297429447844697659,NULL); +-- +ok +== +INSERT INTO t1 VALUES(-3285304895013369375,NULL); +-- +ok +== +INSERT INTO t1 VALUES(-2783073089603195828,NULL); +-- +ok +== +INSERT INTO t1 VALUES(-2422155131602272083,NULL); +-- +ok +== +INSERT INTO t1 VALUES(-2411133157184452856,NULL); +-- +ok +== +INSERT INTO t1 VALUES(-2353272908390735004,NULL); +-- +ok +== +INSERT INTO t1 VALUES(-2242558770815087701,NULL); +-- +ok +== +INSERT INTO t1 VALUES(-1554405226393925625,NULL); +-- +ok +== +INSERT INTO t1 VALUES(-1337520990873830579,NULL); +-- +ok +== +INSERT INTO t1 VALUES(-1217288122333132479,NULL); +-- +ok +== +INSERT INTO t1 VALUES(-829779308050048379,NULL); +-- +ok +== +INSERT INTO t1 VALUES(-783860634233596188,NULL); +-- +ok +== +INSERT INTO t1 VALUES(-750940733896551510,NULL); +-- +ok +== +INSERT INTO t1 VALUES(-595923232719547231,NULL); +-- +ok +== +INSERT INTO t1 VALUES(-542467477806120649,NULL); +-- +ok +== +INSERT INTO t1 VALUES(-424237581585430344,NULL); +-- +ok +== +INSERT INTO t1 VALUES(-214362279664766533,NULL); +-- +ok +== +INSERT INTO t1 VALUES(-71301914094672848,NULL); +-- +ok +== +INSERT INTO t1 VALUES(85486376371946746,NULL); +-- +ok +== +INSERT INTO t1 VALUES(88239714065746993,NULL); +-- +ok +== +INSERT INTO t1 VALUES(587212336705139504,NULL); +-- +ok +== +INSERT INTO t1 VALUES(672222439154311688,NULL); +-- +ok +== +INSERT INTO t1 VALUES(831201880315087268,NULL); +-- +ok +== +INSERT INTO t1 VALUES(995204053540447006,NULL); +-- +ok +== +INSERT INTO t1 VALUES(1246914698489704287,NULL); +-- +ok +== +INSERT INTO t1 VALUES(1546231510864932275,NULL); +-- +ok +== +INSERT INTO t1 VALUES(1791765016181687769,NULL); +-- +ok +== +INSERT INTO t1 VALUES(1799302827895858725,NULL); +-- +ok +== +INSERT INTO t1 VALUES(2026591599286391832,NULL); +-- +ok +== +INSERT INTO t1 VALUES(2195119737828970803,NULL); +-- +ok +== +INSERT INTO t1 VALUES(2342493223442167775,NULL); +-- +ok +== +INSERT INTO t1 VALUES(2453343748991321803,NULL); +-- +ok +== +INSERT INTO t1 VALUES(2499109626526694126,NULL); +-- +ok +== +INSERT INTO t1 VALUES(2753988324592681474,NULL); +-- +ok +== +INSERT INTO t1 VALUES(2810878285747130284,NULL); +-- +ok +== +INSERT INTO t1 VALUES(2848885963459816804,NULL); +-- +ok +== +INSERT INTO t1 VALUES(2915647809434477614,NULL); +-- +ok +== +INSERT INTO t1 VALUES(3475034101394730335,NULL); +-- +ok +== +INSERT INTO t1 VALUES(3626542162137919338,NULL); +-- +ok +== +INSERT INTO t1 VALUES(3877673001272535186,NULL); +-- +ok +== +INSERT INTO t1 VALUES(4007330825134180665,NULL); +-- +ok +== +INSERT INTO t1 VALUES(4077358421272316858,NULL); +-- +ok +== +INSERT INTO t1 VALUES(4690678276679226532,NULL); +-- +ok +== +INSERT INTO t1 VALUES(4866304904348119643,NULL); +-- +ok +== +INSERT INTO t1 VALUES(5214401850561094529,NULL); +-- +ok +== +INSERT INTO t1 VALUES(5272799208960207736,NULL); +-- +ok +== +INSERT INTO t1 VALUES(5530918740051863299,NULL); +-- +ok +== +INSERT INTO t1 VALUES(5569314186296520615,NULL); +-- +ok +== +INSERT INTO t1 VALUES(5740904173463435848,NULL); +-- +ok +== +INSERT INTO t1 VALUES(5849452934504718062,NULL); +-- +ok +== +INSERT INTO t1 VALUES(6218815181136940951,NULL); +-- +ok +== +INSERT INTO t1 VALUES(6275945720557189700,NULL); +-- +ok +== +INSERT INTO t1 VALUES(6279008355318181000,NULL); +-- +ok +== +INSERT INTO t1 VALUES(7017987158241964732,NULL); +-- +ok +== +INSERT INTO t1 VALUES(7237035290160030660,NULL); +-- +ok +== +INSERT INTO t1 VALUES(7374688146326987272,NULL); +-- +ok +== +INSERT INTO t1 VALUES(7612353589185494102,NULL); +-- +ok +== +INSERT INTO t1 VALUES(7958180433948844465,NULL); +-- +ok +== +INSERT INTO t1 VALUES(8093404925372580611,NULL); +-- +ok +== +INSERT INTO t1 VALUES(8165972772169640480,NULL); +-- +ok +== +INSERT INTO t1 VALUES(8531143325322891078,NULL); +-- +ok +== +INSERT INTO t1 VALUES(8658728983219000078,NULL); +-- +ok +== +INSERT INTO t1 VALUES(8730638167239698291,NULL); +-- +ok +== +INSERT INTO t1 VALUES(8757751876611013998,NULL); +-- +ok +== +INSERT INTO t1 VALUES(8994059213096666367,NULL); +-- +ok +== +INSERT INTO t1 VALUES(9034558451786630908,NULL); +-- +ok +== +INSERT INTO t1 VALUES(9049770455330813268,NULL); +-- +ok +== +INSERT INTO t1 VALUES(9196517019233481682,NULL); +-- +ok +== +SELECT c0, sum(c1), min(c1), max(c1) FROM t1 GROUP BY c0 ORDER BY 1, 2, 3, 4 +-- +ok +== diff --git a/parser/testdata/corpus/sql/aggregate/aggregates/test_order_by_aggregate.test b/parser/testdata/corpus/sql/aggregate/aggregates/test_order_by_aggregate.test new file mode 100644 index 0000000..f0f580b --- /dev/null +++ b/parser/testdata/corpus/sql/aggregate/aggregates/test_order_by_aggregate.test @@ -0,0 +1,82 @@ +# source: test/sql/aggregate/aggregates/test_order_by_aggregate.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +CREATE TABLE integers(grp INTEGER, i INTEGER); +-- +ok +== +INSERT INTO integers VALUES (1, 10), (2, 15), (1, 30), (2, 20) +-- +ok +== +SELECT FIRST(i ORDER BY i) FROM integers +-- +ok +== +SELECT FIRST(i ORDER BY i, i, i) FROM integers +-- +ok +== +SELECT FIRST(i ORDER BY i, i DESC, i) FROM integers +-- +ok +== +SELECT FIRST(i ORDER BY i DESC) FROM integers +-- +ok +== +SELECT FIRST(i ORDER BY i DESC, i ASC) FROM integers +-- +ok +== +SELECT FIRST(i ORDER BY i), FIRST(i ORDER BY i DESC) FROM integers +-- +ok +== +SELECT grp, FIRST(i ORDER BY i) FROM integers GROUP BY grp ORDER BY ALL +-- +ok +== +SELECT grp, FIRST(i ORDER BY grp, i, grp DESC, i DESC) FROM integers GROUP BY grp ORDER BY ALL +-- +ok +== +SELECT grp, FIRST(i ORDER BY i DESC) FROM integers GROUP BY grp ORDER BY ALL +-- +ok +== +CREATE TABLE user_causes ( + user_id INT, + cause VARCHAR, + "date" DATE +); +-- +ok +== +INSERT INTO user_causes (user_id, cause, "date") VALUES +(1, 'Environmental', '2024-03-18'), +(1, 'Environmental', '2024-02-18'), +(1, 'Health', '2024-01-18'), +(1, 'Social', '2023-12-18'), +(1, NULL, '2023-11-19'); +-- +ok +== +SELECT + user_id, + list(DISTINCT cause ORDER BY "date" DESC) FILTER(cause IS NOT NULL) AS causes +FROM user_causes +GROUP BY user_id; +-- +ok +== +SELECT + user_id, + list(DISTINCT cause ORDER BY cause DESC) FILTER(cause IS NOT NULL) AS causes +FROM user_causes +GROUP BY user_id; +-- +ok +== diff --git a/parser/testdata/corpus/sql/aggregate/aggregates/test_ordered_aggregates.test b/parser/testdata/corpus/sql/aggregate/aggregates/test_ordered_aggregates.test new file mode 100644 index 0000000..dd4b899 --- /dev/null +++ b/parser/testdata/corpus/sql/aggregate/aggregates/test_ordered_aggregates.test @@ -0,0 +1,191 @@ +# source: test/sql/aggregate/aggregates/test_ordered_aggregates.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +CREATE TABLE flights( + "year" INTEGER, + "month" INTEGER, + "day" INTEGER, + dep_time INTEGER, + sched_dep_time INTEGER, + dep_delay DOUBLE, + arr_time INTEGER, + sched_arr_time INTEGER, + arr_delay DOUBLE, + carrier VARCHAR, + flight INTEGER, + tailnum VARCHAR, + origin VARCHAR, + dest VARCHAR, + air_time DOUBLE, + distance DOUBLE, + "hour" DOUBLE, + "minute" DOUBLE, + time_hour TIMESTAMP); +-- +ok +== +SELECT "dest", mode() WITHIN GROUP (ORDER BY "arr_delay") AS "median_delay" +FROM "flights" +GROUP BY "dest" +-- +ok +== +SELECT "dest", percentile_cont(0.5) WITHIN GROUP (ORDER BY "arr_delay") AS "median_delay" +FROM "flights" +GROUP BY "dest" +-- +ok +== +SELECT "dest", percentile_cont([0.25, 0.5, 0.75]) WITHIN GROUP (ORDER BY "arr_delay") AS "iqr_delay" +FROM "flights" +GROUP BY "dest" +-- +ok +== +SELECT "dest", percentile_disc(0.5) WITHIN GROUP (ORDER BY "arr_delay") AS "median_delay" +FROM "flights" +GROUP BY "dest" +-- +ok +== +SELECT "dest", percentile_disc([0.25, 0.5, 0.75]) WITHIN GROUP (ORDER BY "arr_delay") AS "iqr_delay" +FROM "flights" +GROUP BY "dest" +-- +ok +== +select percentile_disc(0.25) within group(order by i desc) from generate_series(0,100) tbl(i); +-- +ok +== +select percentile_disc([0.25, 0.5, 0.75]) within group(order by i desc) from generate_series(0,100) tbl(i); +-- +ok +== +select percentile_cont(0.25) within group(order by i desc) from generate_series(0,100) tbl(i); +-- +ok +== +select percentile_cont([0.25, 0.5, 0.75]) within group(order by i desc) from generate_series(0,100) tbl(i); +-- +ok +== +SELECT percentile_disc(.5) WITHIN GROUP (order by col desc) +FROM VALUES (11000), (3100), (2900), (2800), (2600), (2500) AS tab(col); +-- +ok +== +SELECT percentile_disc([.25, .5, .75]) WITHIN GROUP (order by col desc) +FROM VALUES (11000), (3100), (2900), (2800), (2600), (2500) AS tab(col); +-- +ok +== +SELECT MODE() WITHIN GROUP (ORDER BY order_occurrences DESC) FROM ( +VALUES + (500, 1), + (1000, 2), + (800, 3), + (1000, 4), + (500, 5), + (550, 6), + (400, 7), + (200, 8), + (10, 9) +) items_per_order(order_occurrences, item_count); +-- +ok +== +SELECT "dest", mode() WITHIN GROUP (ORDER BY "arr_delay", "arr_time") AS "median_delay" +FROM "flights" +GROUP BY "dest" +-- +error: Parser Error: Cannot use multiple ORDER BY clauses with WITHIN GROUP +== +SELECT "dest", duck(0.5) WITHIN GROUP (ORDER BY "arr_delay") AS "duck_delay" +FROM "flights" +GROUP BY "dest" +-- +error: Parser Error: Unknown ordered aggregate "duck". +== +select percentile_disc() within group(order by i) from generate_series(0,100) tbl(i); +-- +error: Parser Error: Wrong number of arguments for PERCENTILE_DISC +== +select percentile_disc(0.25, 0.5) within group(order by i) from generate_series(0,100) tbl(i); +-- +error: Parser Error: Wrong number of arguments for PERCENTILE_DISC +== +select percentile_cont() within group(order by i) from generate_series(0,100) tbl(i); +-- +error: Parser Error: Wrong number of arguments for PERCENTILE_CONT +== +select percentile_cont(0.25, 0.5) within group(order by i) from generate_series(0,100) tbl(i); +-- +error: Parser Error: Wrong number of arguments for PERCENTILE_CONT +== +SELECT percentile_disc(CAST('NaN' AS REAL)) WITHIN GROUP (ORDER BY 1); +-- +ok +== +SELECT percentile_disc([]) WITHIN GROUP (ORDER BY LAST); +-- +ok +== +select mode(0.25) within group(order by i) from generate_series(0,100) tbl(i); +-- +error: Parser Error: Wrong number of arguments for MODE +== +select percentile_disc('duck') within group(order by i) from generate_series(0,100) tbl(i); +-- +ok +== +select percentile_cont('duck') within group(order by i) from generate_series(0,100) tbl(i); +-- +ok +== +SELECT percentile_disc(sum(1)) WITHIN GROUP (ORDER BY 1 DESC); +-- +ok +== +SELECT percentile_disc(strftime(DATE '1-11-25',NULL)) WITHIN GROUP (ORDER BY 1 DESC); +-- +ok +== +SELECT percentile_cont(CASE 1 WHEN 2 THEN 3 END) WITHIN GROUP (ORDER BY 1 DESC); +-- +ok +== +SELECT percentile_disc(-.5) WITHIN GROUP (order by col {sense}) +FROM VALUES (11000), (3100), (2900), (2800), (2600), (2500) AS tab(col); +-- +error: Parser Error: syntax error at or near "{" +== +SELECT percentile_disc([-.25, .5, .75]) WITHIN GROUP (order by col {sense}) +FROM VALUES (11000), (3100), (2900), (2800), (2600), (2500) AS tab(col); +-- +error: Parser Error: syntax error at or near "{" +== +SELECT percentile_cont(quantile := 0.5) WITHIN GROUP (ORDER BY i) FROM generate_series(0,100) tbl(i); +-- +ok +== +SELECT percentile_disc(quantile := 0.25) WITHIN GROUP (ORDER BY i DESC) FROM generate_series(0,100) tbl(i); +-- +ok +== +SELECT percentile_cont(quantile := [0.25, 0.5, 0.75]) WITHIN GROUP (ORDER BY i) FROM generate_series(0,100) tbl(i); +-- +ok +== +SELECT percentile_cont(frac := 0.5) WITHIN GROUP (ORDER BY i) FROM generate_series(0,100) tbl(i); +-- +ok +== +EXPLAIN (FORMAT JSON) +SELECT first(i ORDER BY j), last(i ORDER BY j), any_value(i ORDER BY j) +FROM (VALUES (1, 2)) t(i, j); +-- +ok +== diff --git a/parser/testdata/corpus/sql/aggregate/aggregates/test_ordered_aggregates.test.metadata.json b/parser/testdata/corpus/sql/aggregate/aggregates/test_ordered_aggregates.test.metadata.json new file mode 100644 index 0000000..ad4a1dc --- /dev/null +++ b/parser/testdata/corpus/sql/aggregate/aggregates/test_ordered_aggregates.test.metadata.json @@ -0,0 +1,11 @@ +{ + "todo": { + "1cd3dc66ee1babf4": "transformer-raised parser error: upstream rejects in the transformer, not the grammar; expected to clear as transformers land (milestones 3-5)", + "587c503e21fcb4ef": "transformer-raised parser error: upstream rejects in the transformer, not the grammar; expected to clear as transformers land (milestones 3-5)", + "6e6328bcf7c20489": "transformer-raised parser error: upstream rejects in the transformer, not the grammar; expected to clear as transformers land (milestones 3-5)", + "7f59824aeae80576": "transformer-raised parser error: upstream rejects in the transformer, not the grammar; expected to clear as transformers land (milestones 3-5)", + "9360b7f8a9a72f05": "transformer-raised parser error: upstream rejects in the transformer, not the grammar; expected to clear as transformers land (milestones 3-5)", + "d20b324f2dfc9147": "transformer-raised parser error: upstream rejects in the transformer, not the grammar; expected to clear as transformers land (milestones 3-5)", + "eeb448437cd388cc": "transformer-raised parser error: upstream rejects in the transformer, not the grammar; expected to clear as transformers land (milestones 3-5)" + } +} diff --git a/parser/testdata/corpus/sql/aggregate/aggregates/test_perfect_ht.test b/parser/testdata/corpus/sql/aggregate/aggregates/test_perfect_ht.test new file mode 100644 index 0000000..f463ecc --- /dev/null +++ b/parser/testdata/corpus/sql/aggregate/aggregates/test_perfect_ht.test @@ -0,0 +1,61 @@ +# source: test/sql/aggregate/aggregates/test_perfect_ht.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +PRAGMA perfect_ht_threshold=20; +-- +ok +== +SET disabled_optimizers to {optimizer} +-- +error: Parser Error: syntax error at or near "}" +== +CREATE OR REPLACE TABLE timeseries(year {type}, val {type}); +-- +error: Parser Error: syntax error at or near "{" +== +INSERT INTO timeseries VALUES (1996, 10), (1997, 12), (1996, 20), (2001, 30), (NULL, 1), (1996, NULL); +-- +ok +== +SELECT year, SUM(val), COUNT(val), COUNT(*) FROM timeseries GROUP BY year ORDER BY year; +-- +ok +== +SELECT year, LIST(val), STRING_AGG(val::VARCHAR, ',') FROM timeseries GROUP BY year ORDER BY year; +-- +ok +== +create table manycolumns as select i a, i b, i c, i d, i e from range(0,2) tbl(i); +-- +ok +== +select a, b, c, d, e FROM manycolumns GROUP BY 1, 2, 3, 4, 5 +-- +ok +== +CREATE TABLE tinyints AS SELECT i::TINYINT::VARCHAR AS t FROM range(-127, 128) tbl(i); +-- +ok +== +SELECT COUNT(DISTINCT i), MIN(i), MAX(i), SUM(i) / COUNT(i) FROM (SELECT t::TINYINT t1 FROM tinyints GROUP BY t1) tbl(i) +-- +ok +== +CREATE TABLE smallints AS SELECT i::SMALLINT::VARCHAR AS t FROM range(-32767, 32768) tbl(i); +-- +ok +== +SELECT COUNT(DISTINCT i), MIN(i), MAX(i), SUM(i) / COUNT(i) FROM (SELECT t::SMALLINT t1 FROM smallints GROUP BY t1) tbl(i) +-- +ok +== +create table dates as select date '1992-01-01' + concat(i, ' months')::interval as d from range(100) tbl(i); +-- +ok +== +select extract(year from d), extract(month from d) from dates group by 1, 2 ORDER BY ALL; +-- +ok +== diff --git a/parser/testdata/corpus/sql/aggregate/aggregates/test_product.test b/parser/testdata/corpus/sql/aggregate/aggregates/test_product.test new file mode 100644 index 0000000..14541c3 --- /dev/null +++ b/parser/testdata/corpus/sql/aggregate/aggregates/test_product.test @@ -0,0 +1,50 @@ +# source: test/sql/aggregate/aggregates/test_product.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +select product() +-- +ok +== +select product(NULL) +-- +ok +== +select product(1) +-- +ok +== +select product(*) +-- +ok +== +INSERT INTO integers VALUES (1), (2),(4), (NULL) +-- +ok +== +SELECT product(i) FROM integers +-- +ok +== +SELECT PRODUCT(2) FROM range(100); +-- +ok +== +SELECT PRODUCT(2) FROM range(100) tbl(i) WHERE i % 2 != 0; +-- +ok +== +select product(i) from integers group by i%2 order by all +-- +ok +== +SELECT PRODUCT(i) FROM range(100) tbl(i) WHERE 1=0; +-- +ok +== +select product(i) over (partition by i%2) + from integers; +-- +ok +== diff --git a/parser/testdata/corpus/sql/aggregate/aggregates/test_quantile_cont.test b/parser/testdata/corpus/sql/aggregate/aggregates/test_quantile_cont.test new file mode 100644 index 0000000..b5f8f62 --- /dev/null +++ b/parser/testdata/corpus/sql/aggregate/aggregates/test_quantile_cont.test @@ -0,0 +1,222 @@ +# source: test/sql/aggregate/aggregates/test_quantile_cont.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +create table quantile as select range r, random() from range(0,1000000,100) union all values (NULL, 0.1), (NULL, 0.5), (NULL, 0.9) order by 2; +-- +ok +== +SELECT quantile_cont(r, NULL) FROM quantile +-- +ok +== +SELECT quantile_cont(r, 0.5) FROM quantile +-- +ok +== +SELECT quantile_cont(r::decimal(10,2), 0.5) FROM quantile +-- +ok +== +SELECT quantile_cont(r, 1.0) FROM quantile +-- +ok +== +SELECT quantile_cont(r, 0.0) FROM quantile +-- +ok +== +SELECT quantile_cont(NULL, 0.5) FROM quantile +-- +ok +== +SELECT quantile_cont(42, 0.5) FROM quantile +-- +ok +== +SELECT quantile_cont(NULL, 0.5) +-- +ok +== +SELECT quantile_cont(42, 0.5) +-- +ok +== +SELECT quantile_cont(r, 0.25), quantile_cont(r, 0.5), quantile_cont(r, 0.75) from quantile +-- +ok +== +SELECT quantile_cont(d::{type}, 0.25), quantile_cont(d::{type}, 0.5), quantile_cont(d::{type}, 0.75) +FROM range(0,100) tbl(d) +-- +error: Parser Error: syntax error at or near "{" +== +SELECT mod(r,1000) as g, quantile_cont(r, 0.25) FROM quantile GROUP BY 1 ORDER BY 1 +-- +ok +== +SELECT quantile_cont('2021-01-01'::TIMESTAMP + interval (r) second, 0.5) FROM quantile +-- +ok +== +SELECT quantile_cont(('1990-01-01'::DATE + interval (r/100) day)::DATE, 0.5) FROM quantile +-- +ok +== +SELECT quantile_cont('00:00:00'::TIME + interval (r/100) second, 0.5) FROM quantile +-- +ok +== +SELECT quantile_cont(interval (r/100) second, 0.5) FROM quantile +-- +ok +== +SELECT quantile_cont(('2021-01-01'::TIMESTAMP + interval (r) second)::TIMESTAMPTZ, 0.5) FROM quantile +-- +ok +== +SELECT quantile_cont(1, 0.1) FROM quantile +-- +ok +== +SELECT quantile_cont(r, -0.1) FROM quantile +-- +ok +== +SELECT + percentile_cont(0.8) WITHIN GROUP (ORDER BY x DESC), + quantile_cont(x, 0.8 ORDER BY x DESC), +FROM + (VALUES (2), (1)) _(x); +-- +ok +== +SELECT quantile_cont(r, 0.1) FROM quantile WHERE 1=0 +-- +ok +== +SELECT quantile_cont(r, -1.1) FROM quantile +-- +ok +== +SELECT quantile_cont(r, 1.1) FROM quantile +-- +ok +== +SELECT quantile_cont(r, "string") FROM quantile +-- +ok +== +SELECT quantile_cont(r::string, 0.5) FROM quantile +-- +ok +== +SELECT quantile_cont(r) FROM quantile +-- +ok +== +SELECT quantile_cont(r, 0.1, 50) FROM quantile +-- +ok +== +SELECT quantile_cont(t, 0.5) FROM (VALUES (120::TINYINT), (122::TINYINT)) tbl(t) +-- +ok +== +CREATE TABLE tinyints(t TINYINT); +-- +ok +== +INSERT INTO tinyints VALUES (-127), (-127); +-- +ok +== +SELECT quantile_cont(t, 0.5) FROM tinyints; +-- +ok +== +UPDATE tinyints SET t=-t; +-- +ok +== +SELECT quantile_cont(t, 0.5) FROM (VALUES (32764::SMALLINT), (32766::SMALLINT)) tbl(t) +-- +ok +== +CREATE TABLE smallints(t SMALLINT); +-- +ok +== +INSERT INTO smallints VALUES (-32767), (-32767); +-- +ok +== +SELECT quantile_cont(t, 0.5) FROM smallints; +-- +ok +== +UPDATE smallints SET t=-t; +-- +ok +== +SELECT quantile_cont(t, 0.5) FROM (VALUES (2147483642::INTEGER), (2147483644::INTEGER)) tbl(t) +-- +ok +== +CREATE TABLE integers(t INTEGER); +-- +ok +== +INSERT INTO integers VALUES (-2147483647), (-2147483647); +-- +ok +== +SELECT quantile_cont(t, 0.5) FROM integers; +-- +ok +== +UPDATE integers SET t=-t; +-- +ok +== +SELECT quantile_cont(t, 0.5) FROM (VALUES (9223372036854775794::BIGINT), (9223372036854775796::BIGINT)) tbl(t) +-- +ok +== +CREATE TABLE bigints(t BIGINT); +-- +ok +== +INSERT INTO bigints VALUES (-9223372036854775800), (-9223372036854775800); +-- +ok +== +SELECT quantile_cont(t, 0.5) FROM bigints; +-- +ok +== +UPDATE bigints SET t=-t; +-- +ok +== +SELECT quantile_cont(r, random()) FROM quantile +-- +ok +== +WITH t(v) AS ( + VALUES (9999999999999999999999999999::DECIMAL(38,0)), + (9999999999999999999999999997::DECIMAL(38,0)) +) +SELECT quantile_cont(v, 0.5), median(v) FROM t +-- +ok +== +WITH t(v) AS ( + VALUES (9999999999999999999999999999::DECIMAL(38,0)), + (9999999999999999999999999997::DECIMAL(38,0)) +) +SELECT quantile_cont(v, 0.3), median(v) FROM t +-- +ok +== diff --git a/parser/testdata/corpus/sql/aggregate/aggregates/test_quantile_cont_list.test b/parser/testdata/corpus/sql/aggregate/aggregates/test_quantile_cont_list.test new file mode 100644 index 0000000..91b6c97 --- /dev/null +++ b/parser/testdata/corpus/sql/aggregate/aggregates/test_quantile_cont_list.test @@ -0,0 +1,79 @@ +# source: test/sql/aggregate/aggregates/test_quantile_cont_list.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +create table quantiles as select range r, random() FROM range(0,1000000,100) union all values (NULL, 0.25), (NULL, 0.5), (NULL, 0.75) order by 2; +-- +ok +== +SELECT quantile_cont('2021-01-01'::TIMESTAMP + interval (r/100) hour, [0.25, 0.5, 0.75]) FROM quantiles +-- +ok +== +SELECT quantile_cont('1990-01-01'::DATE + interval (r/100) day, [0.25, 0.5, 0.75]) FROM quantiles +-- +ok +== +SELECT quantile_cont('00:00:00'::TIME + interval (r/100) second, [0.25, 0.5, 0.75]) FROM quantiles +-- +ok +== +SELECT quantile_cont(('2021-01-01'::TIMESTAMP + interval (r/100) hour)::TIMESTAMPTZ, [0.25, 0.5, 0.75]) +FROM quantiles +-- +ok +== +SELECT quantile_cont(interval (r/100) second, [0.25, 0.5, 0.75]) FROM quantiles +-- +ok +== +SELECT quantile_cont(r, [0.25, 0.5, 0.75]) FROM quantiles +-- +ok +== +SELECT quantile_cont(d::{type}, [0.25, 0.5, 0.75]) +FROM range(0,100) tbl(d) +-- +error: Parser Error: syntax error at or near "{" +== +SELECT mod(r,1000) as g, quantile_cont(r, [0.25, 0.5, 0.75]) FROM quantiles GROUP BY 1 ORDER BY 1 +-- +ok +== +SELECT quantile_cont(1, [0.25, 0.5, 0.75]) FROM quantiles +-- +ok +== +SELECT quantile_cont(r, [0.25, 0.5, 0.75]) FROM quantiles WHERE 1=0 +-- +ok +== +SELECT quantile_cont(r, []) FROM quantiles +-- +ok +== +SELECT quantile_cont(r, [-0.25, 0.5, 0.75]) FROM quantiles +-- +ok +== +SELECT quantile_cont(r, (0.25, 0.5, 1.1)) FROM quantiles +-- +ok +== +SELECT quantile_cont(r, [0.25, 0.5, NULL]) FROM quantiles +-- +ok +== +SELECT quantile_cont(r, ["0.25", "0.5", "0.75"]) FROM quantiles +-- +ok +== +SELECT quantile_cont(r::string, [0.25, 0.5, 0.75]) FROM quantiles +-- +ok +== +SELECT quantile_cont(r, [0.25, 0.5, 0.75], 50) FROM quantiles +-- +ok +== diff --git a/parser/testdata/corpus/sql/aggregate/aggregates/test_quantile_disc.test b/parser/testdata/corpus/sql/aggregate/aggregates/test_quantile_disc.test new file mode 100644 index 0000000..4d2ce25 --- /dev/null +++ b/parser/testdata/corpus/sql/aggregate/aggregates/test_quantile_disc.test @@ -0,0 +1,173 @@ +# source: test/sql/aggregate/aggregates/test_quantile_disc.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +CREATE TABLE quantile as +SELECT range r, random() AS q +FROM range(10000) +UNION ALL VALUES (NULL, 0.1), (NULL, 0.5), (NULL, 0.9) +ORDER BY 2; +-- +ok +== +SELECT quantile_disc(r, 0.5) FROM quantile +-- +ok +== +SELECT quantile_disc(r::decimal(10,2), 0.5) FROM quantile +-- +ok +== +SELECT quantile_disc(case when r is null then null else [r] end, 0.5) FROM quantile +-- +ok +== +SELECT quantile_disc(case when r is null then null else {'i': r} end, 0.5) FROM quantile +-- +ok +== +SELECT quantile_disc(r, 1.0) FROM quantile +-- +ok +== +SELECT quantile_disc(r, 0.0) FROM quantile +-- +ok +== +SELECT quantile_disc(NULL, 0.5) FROM quantile +-- +ok +== +SELECT quantile_disc(42, 0.5) FROM quantile +-- +ok +== +SELECT quantile_disc(NULL, 0.5) +-- +ok +== +SELECT quantile_disc(42, 0.5) +-- +ok +== +SELECT quantile_disc(r, 0.1), quantile_disc(r, 0.5), quantile_disc(r, 0.9) from quantile +-- +ok +== +SELECT quantile_disc(d::{type}, 0.1), quantile_disc(d::{type}, 0.5), quantile_disc(d::{type}, 0.9) +FROM range(0,100) tbl(d) +-- +error: Parser Error: syntax error at or near "{" +== +SELECT quantile_disc(col, -0.5) +FROM VALUES (11000), (3100), (2900), (2800), (2600), (2500) AS tab(col); +-- +ok +== +SELECT + percentile_disc(0.8) WITHIN GROUP (ORDER BY x DESC), + quantile_disc(x, 0.8 ORDER BY x DESC), +FROM + (VALUES (2), (1)) _(x); +-- +ok +== +SELECT quantile_disc(d::VARCHAR, 0.1), quantile_disc(d::VARCHAR, 0.5), quantile_disc(d::VARCHAR, 0.9) +FROM range(0,100) tbl(d) +-- +ok +== +SELECT quantile_disc(NULL::VARCHAR, 0.1) +FROM range(0,100) tbl(d) +-- +ok +== +SELECT quantile_disc('prefix-' || d::VARCHAR || '-suffix', 0.1) +FROM range(0,100) tbl(d) +-- +ok +== +SELECT median(d::VARCHAR) +FROM range(0,100) tbl(d) +-- +ok +== +SELECT median(d::VARCHAR) +FROM range(0,100) tbl(d) +WHERE d > 100 +-- +ok +== +SELECT mod(r,10) as g, quantile_disc(r, 0.1) FROM quantile GROUP BY 1 ORDER BY 1 +-- +ok +== +SELECT quantile_disc('2021-01-01'::TIMESTAMP + interval (r) hour, 0.5) FROM quantile +-- +ok +== +SELECT quantile_disc('1990-01-01'::DATE + interval (r) day, 0.5) FROM quantile +-- +ok +== +SELECT quantile_disc('00:00:00'::TIME + interval (r) second, 0.5) FROM quantile +-- +ok +== +SELECT quantile_disc(interval (r) second, 0.5) FROM quantile +-- +ok +== +SELECT quantile_disc(('2021-01-01'::TIMESTAMP + interval (r) hour)::TIMESTAMPTZ, 0.5) FROM quantile +-- +ok +== +SELECT quantile_disc(1, 0.1) FROM quantile +-- +ok +== +SELECT quantile_disc(r, 0.1) FROM quantile WHERE 1=0 +-- +ok +== +SELECT quantile_disc(r, -1.1) FROM quantile +-- +ok +== +SELECT quantile_disc(r, 1.1) FROM quantile +-- +ok +== +SELECT quantile_disc(r, "string") FROM quantile +-- +ok +== +SELECT quantile_disc(r, NULL) FROM quantile +-- +ok +== +SELECT quantile_disc(r) FROM quantile +-- +ok +== +SELECT quantile_disc(r, 0.1, 50) FROM quantile +-- +ok +== +SELECT quantile_cont(r, q) FROM quantile +-- +ok +== +with a as ( + select 'NaN'::{fp} as num + union all + select num::{fp} as num from generate_series(1,99) as tbl(num) + union all + select 'NaN'::{fp} as num +) +select quantile_disc(num, 0.9) c1 +from a; +-- +error: Parser Error: syntax error at or near "{" +== diff --git a/parser/testdata/corpus/sql/aggregate/aggregates/test_quantile_disc_list.test b/parser/testdata/corpus/sql/aggregate/aggregates/test_quantile_disc_list.test new file mode 100644 index 0000000..e4129c5 --- /dev/null +++ b/parser/testdata/corpus/sql/aggregate/aggregates/test_quantile_disc_list.test @@ -0,0 +1,106 @@ +# source: test/sql/aggregate/aggregates/test_quantile_disc_list.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +create table quantiles as select range r, random() FROM range(10000) union all values (NULL, 0.1), (NULL, 0.5), (NULL, 0.9) order by 2; +-- +ok +== +SELECT quantile_disc(r, [0.1, 0.5, 0.9]) FROM quantiles +-- +ok +== +SELECT quantile_disc(case when r is null then null else [r] end, [0.1, 0.5, 0.9]) FROM quantiles +-- +ok +== +SELECT quantile_disc(case when r is null then null else {'i': r} end, [0.1, 0.5, 0.9]) FROM quantiles +-- +ok +== +SELECT quantile_disc(d::{type}, [0.1, 0.5, 0.9]) +FROM range(0,100) tbl(d) +-- +error: Parser Error: syntax error at or near "{" +== +SELECT quantile_disc(col, [-.25, -.5, -.75]) +FROM VALUES (11000), (3100), (2900), (2800), (2600), (2500) AS tab(col); +-- +ok +== +SELECT quantile_disc(d::VARCHAR, [0.1, 0.5, 0.9]) +FROM range(0,100) tbl(d) +-- +ok +== +SELECT mod(r,10) as g, quantile_disc(r, [0.1, 0.5, 0.9]) FROM quantiles GROUP BY 1 ORDER BY 1 +-- +ok +== +SELECT quantile_disc(1, [0.1, 0.5, 0.9]) FROM quantiles +-- +ok +== +SELECT quantile_disc(r, [0.1, 0.5, 0.9]) FROM quantiles WHERE 1=0 +-- +ok +== +SELECT quantile_disc(r, []) FROM quantiles +-- +ok +== +SELECT quantile_disc('2021-01-01'::TIMESTAMP + interval (r) hour, [0.1, 0.5, 0.9]) FROM quantiles +-- +ok +== +SELECT quantile_disc('1990-01-01'::DATE + interval (r) day, [0.1, 0.5, 0.9]) FROM quantiles +-- +ok +== +SELECT quantile_disc('00:00:00'::TIME + interval (r) second, [0.1, 0.5, 0.9]) FROM quantiles +-- +ok +== +SELECT quantile_disc(interval (r) second, [0.1, 0.5, 0.9]) FROM quantiles +-- +ok +== +SELECT quantile_disc(('2021-01-01'::TIMESTAMP + interval (r) hour)::TIMESTAMPTZ, [0.1, 0.5, 0.9]) FROM quantiles +-- +ok +== +SELECT quantile_disc(col, [0.1, 0.32, 0.33, 0.34, 0.49, .5, .51, 0.75, 0.9, 0.999, 1]) +FROM VALUES (0), (1), (2), (10) AS tab(col); +-- +ok +== +SELECT quantile_disc(42::UTINYINT, 0.5); +-- +ok +== +SELECT quantile_disc(col, ARRAY_VALUE(0.5, 0.4, 0.1)) AS percentile +FROM VALUES (0), (1), (2), (10) AS tab(col); +-- +ok +== +SELECT quantile_disc(r, [-0.1, 0.5, 0.9]) FROM quantiles +-- +ok +== +SELECT quantile_disc(r, (0.1, 0.5, 1.1)) FROM quantiles +-- +ok +== +SELECT quantile_disc(r, [0.1, 0.5, NULL]) FROM quantiles +-- +ok +== +SELECT quantile_disc(r, ["0.1", "0.5", "0.9"]) FROM quantiles +-- +ok +== +SELECT quantile_disc(r, [0.1, 0.5, 0.9], 50) FROM quantiles +-- +ok +== diff --git a/parser/testdata/corpus/sql/aggregate/aggregates/test_regression.test b/parser/testdata/corpus/sql/aggregate/aggregates/test_regression.test new file mode 100644 index 0000000..b393c60 --- /dev/null +++ b/parser/testdata/corpus/sql/aggregate/aggregates/test_regression.test @@ -0,0 +1,294 @@ +# source: test/sql/aggregate/aggregates/test_regression.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +select regr_avgx(NULL,NULL) +-- +ok +== +select regr_avgx(1,1) +-- +ok +== +select regr_avgx() +-- +ok +== +select regr_avgx(*) +-- +ok +== +select regr_avgy() +-- +ok +== +select regr_avgy(NULL,NULL) +-- +ok +== +select regr_avgy(1,1) +-- +ok +== +select regr_avgy(*) +-- +ok +== +select regr_count() +-- +ok +== +select regr_count(NULL,NULL) +-- +ok +== +select regr_count(1,1) +-- +ok +== +select regr_count(*) +-- +ok +== +select regr_slope() +-- +ok +== +select regr_slope(NULL,NULL) +-- +ok +== +select regr_slope(1,1) +-- +ok +== +select regr_slope(*) +-- +ok +== +select regr_r2() +-- +ok +== +select regr_r2(NULL,NULL) +-- +ok +== +select regr_r2(1,1) +-- +ok +== +select regr_r2(0, 1e230*i) from range(5) tbl(i); +-- +ok +== +select regr_r2(1e230*i, i) from range(5) tbl(i); +-- +ok +== +select regr_r2(1e230*i, 0) from range(5) tbl(i); +-- +ok +== +select regr_r2(0, i) from range(5) tbl(i); +-- +ok +== +select regr_r2(*) +-- +ok +== +select regr_sxx() +-- +ok +== +select regr_sxx(0, 2e230*i) from range(5) tbl(i) +-- +ok +== +select regr_sxx(2e230*i, 0) from range(5) tbl(i) +-- +ok +== +select regr_sxx(NULL,NULL) +-- +ok +== +select regr_sxx(1,1) +-- +ok +== +select regr_syy() +-- +ok +== +select regr_syy(NULL,NULL) +-- +ok +== +select regr_syy(1,1) +-- +ok +== +select regr_sxy(*) +-- +ok +== +select regr_sxy() +-- +ok +== +select regr_sxy(NULL,NULL) +-- +ok +== +select regr_sxy(1,1) +-- +ok +== +select regr_syy(*) +-- +ok +== +select regr_intercept() +-- +ok +== +select regr_intercept(NULL,NULL) +-- +ok +== +select regr_intercept(1,1) +-- +ok +== +select regr_intercept(*) +-- +ok +== +create table aggr(k int, v decimal(10,2), v2 decimal(10, 2)); +-- +ok +== +insert into aggr values(1, 10, null), (2, 10, 11), (2, 20, 22), (2, 25, null), (2, 30, 35); +-- +ok +== +select k, regr_avgx(v, v2) from aggr group by k ORDER BY ALL; +-- +ok +== +select k, regr_avgy(v, v2) from aggr group by k ORDER BY ALL; +-- +ok +== +select k, count(*), regr_count(v, v2) from aggr group by k ORDER BY ALL; +-- +ok +== +select k, regr_slope(v, v2) from aggr group by k ORDER BY ALL; +-- +ok +== +select k, regr_r2(v, v2) from aggr group by k ORDER BY ALL; +-- +ok +== +select k, regr_sxx(v, v2) from aggr group by k ORDER BY ALL; +-- +ok +== +select k, regr_syy(v, v2) from aggr group by k ORDER BY ALL; +-- +ok +== +select k, regr_sxy(v, v2) from aggr group by k ORDER BY ALL; +-- +ok +== +select k, regr_intercept(v, v2) from aggr group by k ORDER BY ALL; +-- +ok +== +select regr_avgx(v, v2) from aggr ; +-- +ok +== +select regr_avgy(v, v2) from aggr ; +-- +ok +== +select regr_count(v, v2) from aggr ; +-- +ok +== +select regr_slope(v, v2) from aggr ; +-- +ok +== +select regr_r2(v, v2) from aggr ; +-- +ok +== +select regr_sxx(v, v2) from aggr ; +-- +ok +== +select regr_syy(v, v2) from aggr ; +-- +ok +== +select regr_sxy(v, v2) from aggr; +-- +ok +== +select regr_intercept(v, v2) from aggr; +-- +ok +== +select regr_avgx(v, v2) over (partition by k) + from aggr; +-- +ok +== +select regr_avgy(v, v2) over (partition by k) + from aggr; +-- +ok +== +select regr_count(v, v2) over (partition by k) + from aggr; +-- +ok +== +select regr_slope(v, v2) over (partition by k) + from aggr; +-- +ok +== +select regr_r2(v, v2) over (partition by k) + from aggr; +-- +ok +== +select regr_sxx(v, v2) over (partition by k) + from aggr; +-- +ok +== +select regr_syy(v, v2) over (partition by k) + from aggr; +-- +ok +== +select regr_sxy(v, v2) over (partition by k) + from aggr; +-- +ok +== +select regr_intercept(v, v2) over (partition by k) + from aggr; +-- +ok +== diff --git a/parser/testdata/corpus/sql/aggregate/aggregates/test_scalar_aggr.test b/parser/testdata/corpus/sql/aggregate/aggregates/test_scalar_aggr.test new file mode 100644 index 0000000..afb5ca2 --- /dev/null +++ b/parser/testdata/corpus/sql/aggregate/aggregates/test_scalar_aggr.test @@ -0,0 +1,33 @@ +# source: test/sql/aggregate/aggregates/test_scalar_aggr.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +SELECT COUNT(1), MIN(1), FIRST(1), LAST(1),MAX(1), SUM(1), STRING_AGG('hello', ',') +-- +ok +== +SELECT COUNT(NULL), MIN(NULL), FIRST(NULL), LAST(NULL), MAX(NULL), SUM(NULL), STRING_AGG(NULL, NULL) +-- +ok +== +SELECT FIRST(NULL) +-- +ok +== +SELECT LAST(NULL) +-- +ok +== +SELECT NULL as a, NULL as b, 1 as id UNION SELECT CAST('00:00:00' AS TIME) as a, CAST('12:34:56' AS TIME) as b, 2 as id ORDER BY 1 +-- +ok +== +SELECT COUNT(1), MIN(1), FIRST(1), LAST(1), MAX(1), SUM(1), STRING_AGG('hello', ',') FROM integers +-- +ok +== +SELECT COUNT(NULL), MIN(NULL), FIRST(NULL), LAST(NULL), MAX(NULL), SUM(NULL), STRING_AGG(NULL, NULL) FROM integers +-- +ok +== diff --git a/parser/testdata/corpus/sql/aggregate/aggregates/test_sem.test b/parser/testdata/corpus/sql/aggregate/aggregates/test_sem.test new file mode 100644 index 0000000..c3f17e0 --- /dev/null +++ b/parser/testdata/corpus/sql/aggregate/aggregates/test_sem.test @@ -0,0 +1,35 @@ +# source: test/sql/aggregate/aggregates/test_sem.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +select sem() +-- +ok +== +select sem(NULL) +-- +ok +== +select sem(1) +-- +ok +== +select sem(*) +-- +ok +== +select k, sem(v),sem(v2) from aggr group by k ORDER BY ALL; +-- +ok +== +select sem(v),sem(v2) from aggr +-- +ok +== +select k, sem(v) over (partition by k) +from aggr +order by all +-- +ok +== diff --git a/parser/testdata/corpus/sql/aggregate/aggregates/test_simple_filter.test b/parser/testdata/corpus/sql/aggregate/aggregates/test_simple_filter.test new file mode 100644 index 0000000..181f062 --- /dev/null +++ b/parser/testdata/corpus/sql/aggregate/aggregates/test_simple_filter.test @@ -0,0 +1,74 @@ +# source: test/sql/aggregate/aggregates/test_simple_filter.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +SELECT + count(*) as total_rows, + count(*) FILTER (WHERE i <= 5) as lte_five, + count(*) FILTER (WHERE i % 2 = 1) as odds +FROM generate_series(1,11) tbl(i) +-- +ok +== +SELECT + count(*) FILTER (WHERE i % 2 = 1) as odds, + count(*) FILTER (WHERE i <= 5) as lte_five, + count(*) as total_rows +FROM generate_series(1,11) tbl(i) +-- +ok +== +SELECT + count(*) FILTER (WHERE i <= 5) as lte_five, + count(*) FILTER (WHERE i % 2 = 1) as odds, + count(*) as total_rows +FROM generate_series(1,11) tbl(i) +-- +ok +== +CREATE TABLE issue3105(gender VARCHAR, pay FLOAT); +-- +ok +== +INSERT INTO issue3105 VALUES + ('male', 100), + ('male', 200), + ('male', 300), + ('female', 150), + ('female', 250); +-- +ok +== +SELECT + SUM(pay) FILTER (WHERE gender = 'male'), + SUM(pay) FILTER (WHERE gender = 'female'), + SUM(pay) +FROM issue3105; +-- +ok +== +SELECT + SUM(pay), + SUM(pay) FILTER (WHERE gender = 'male'), + SUM(pay) FILTER (WHERE gender = 'female') +FROM issue3105; +-- +ok +== +SELECT + SUM(pay) FILTER (WHERE gender = 'male'), + SUM(pay), + SUM(pay) FILTER (WHERE gender = 'female') +FROM issue3105; +-- +ok +== +SELECT + SUM(pay) FILTER (gender = 'male'), + SUM(pay), + SUM(pay) FILTER (gender = 'female') +FROM issue3105; +-- +ok +== diff --git a/parser/testdata/corpus/sql/aggregate/aggregates/test_skewness.test b/parser/testdata/corpus/sql/aggregate/aggregates/test_skewness.test new file mode 100644 index 0000000..cab66bf --- /dev/null +++ b/parser/testdata/corpus/sql/aggregate/aggregates/test_skewness.test @@ -0,0 +1,46 @@ +# source: test/sql/aggregate/aggregates/test_skewness.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +select skewness() +-- +ok +== +select skewness(NULL) +-- +ok +== +select skewness(1) +-- +ok +== +select skewness(*) +-- +ok +== +select skewness (10) from range (5) +-- +ok +== +select skewness (10) from range (5) where 1 == 0 +-- +ok +== +select skewness(i) from (values (-2e307), (0), (2e307)) tbl(i) +-- +ok +== +select skewness(k), skewness(v), skewness(v2) from aggr +-- +ok +== +select skewness(v2) from aggr group by v ORDER BY ALL +-- +ok +== +select skewness(v2) over (partition by v) + from aggr order by v; +-- +ok +== diff --git a/parser/testdata/corpus/sql/aggregate/aggregates/test_stddev.test b/parser/testdata/corpus/sql/aggregate/aggregates/test_stddev.test new file mode 100644 index 0000000..2b940c5 --- /dev/null +++ b/parser/testdata/corpus/sql/aggregate/aggregates/test_stddev.test @@ -0,0 +1,133 @@ +# source: test/sql/aggregate/aggregates/test_stddev.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +SELECT stddev_samp(1) +-- +ok +== +SELECT var_samp(1) +-- +ok +== +select round(stddev_samp(val), 1) from stddev_test +-- +ok +== +select round(stddev_samp(val), 1) from stddev_test where val is not null +-- +ok +== +select grp, sum(val), round(stddev_samp(val), 1), min(val) from stddev_test group by grp order by grp +-- +ok +== +select grp, sum(val), round(stddev_samp(val), 1), min(val) from stddev_test where val is not null group by grp order by grp +-- +ok +== +select round(stddev_pop(val), 1) from stddev_test +-- +ok +== +select round(stddev_pop(val), 1) from stddev_test where val is not null +-- +ok +== +select grp, sum(val), round(stddev_pop(val), 1), min(val) from stddev_test group by grp order by grp +-- +ok +== +select grp, sum(val), round(stddev_pop(val), 1), min(val) from stddev_test where val is not null group by grp order by grp +-- +ok +== +select round(var_samp(val), 1) from stddev_test +-- +ok +== +select round(variance(val), 1) from stddev_test +-- +ok +== +select round(var_samp(val), 1) from stddev_test where val is not null +-- +ok +== +select grp, sum(val), round(var_samp(val), 1), min(val) from stddev_test group by grp order by grp +-- +ok +== +select grp, sum(val), round(var_samp(val), 1), min(val) from stddev_test where val is not null group by grp order by grp +-- +ok +== +select round(var_pop(val), 1) from stddev_test +-- +ok +== +select round(var_pop(val), 1) from stddev_test where val is not null +-- +ok +== +select grp, sum(val), round(var_pop(val), 2), min(val) from stddev_test group by grp order by grp +-- +ok +== +select grp, sum(val), round(var_pop(val), 2), min(val) from stddev_test where val is not null group by grp order by grp +-- +ok +== +create table stddev_test_alias(val integer, grp integer) +-- +ok +== +insert into stddev_test_alias values (42, 1), (43, 1), (42, 2), (1000, 2), (NULL, 1), (NULL, 3) +-- +ok +== +select round(stddev(val), 1) from stddev_test_alias +-- +ok +== +select stddev(0) from range(10) +-- +ok +== +select stddev(a) from (values (1e301), (-1e301)) tbl(a) +-- +ok +== +select var_samp(a) from (values (1e301), (-1e301)) tbl(a) +-- +ok +== +select var_pop(a) from (values (1e301), (-1e301)) tbl(a) +-- +ok +== +select stddev(a) from (values (1.0/0.0), (2.0)) tbl(a) +-- +ok +== +select var_samp(a) from (values (1.0/0.0), (2.0)) tbl(a) +-- +ok +== +select var_pop(a) from (values (1.0/0.0), (2.0)) tbl(a) +-- +ok +== +select stddev(a) from (values (-1.0/0.0), (2.0)) tbl(a) +-- +ok +== +CREATE TABLE inf_test AS SELECT 1.0/0.0 AS inf_col, 2.0 AS normal_col UNION ALL SELECT 2.0, 3.0; +-- +ok +== +SUMMARIZE inf_test; +-- +ok +== diff --git a/parser/testdata/corpus/sql/aggregate/aggregates/test_string_agg.test b/parser/testdata/corpus/sql/aggregate/aggregates/test_string_agg.test new file mode 100644 index 0000000..7ef615c --- /dev/null +++ b/parser/testdata/corpus/sql/aggregate/aggregates/test_string_agg.test @@ -0,0 +1,150 @@ +# source: test/sql/aggregate/aggregates/test_string_agg.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +SELECT STRING_AGG('a', 'b', 'c') +-- +ok +== +SELECT STRING_AGG(STRING_AGG('a',',')) +-- +ok +== +SELECT STRING_AGG('a',',') +-- +ok +== +SELECT STRING_AGG('a',','), STRING_AGG(NULL,','), STRING_AGG('a', NULL), STRING_AGG(NULL,NULL) +-- +ok +== +CREATE TABLE strings(g INTEGER, x VARCHAR, y VARCHAR); +-- +ok +== +INSERT INTO strings VALUES (1,'a','/'), (1,'b','-'), (2,'i','/'), (2,NULL,'-'), (2,'j','+'), (3,'p','/'), (4,'x','/'), (4,'y','-'), (4,'z','+') +-- +ok +== +SELECT STRING_AGG(x,','), STRING_AGG(x,y) FROM strings +-- +ok +== +SELECT g, STRING_AGG(x,'|') FROM strings GROUP BY g ORDER BY g +-- +ok +== +SELECT STRING_AGG(x,',') FROM strings WHERE g > 100 +-- +ok +== +SELECT STRING_AGG(1, 2) +-- +ok +== +SELECT GROUP_CONCAT('a', ',') +-- +ok +== +SELECT GROUP_CONCAT('a') +-- +ok +== +SELECT g, GROUP_CONCAT(x) FROM strings GROUP BY g ORDER BY g +-- +ok +== +SELECT STRING_AGG(x ORDER BY x ASC), STRING_AGG(x, '|' ORDER BY x ASC) FROM strings +-- +ok +== +SELECT STRING_AGG(x ORDER BY x DESC), STRING_AGG(x,'|' ORDER BY x DESC) FROM strings +-- +ok +== +SELECT g, STRING_AGG(x ORDER BY x ASC), STRING_AGG(x, '|' ORDER BY x ASC) FROM strings GROUP BY g ORDER BY 1 +-- +ok +== +SELECT g, STRING_AGG(x ORDER BY x DESC), STRING_AGG(x, '|' ORDER BY x DESC) FROM strings GROUP BY g ORDER BY 1 +-- +ok +== +SELECT g, STRING_AGG(x, y ORDER BY x ASC) FROM strings GROUP BY g ORDER BY 1 +-- +ok +== +SELECT g, STRING_AGG(x, y ORDER BY x DESC) FROM strings GROUP BY g ORDER BY 1 +-- +ok +== +SELECT STRING_AGG(g::VARCHAR, ',' ORDER BY CONCAT(x, y) ASC) FROM strings ORDER BY 1 +-- +ok +== +SELECT STRING_AGG(g::VARCHAR, ',' ORDER BY x, y) FROM strings ORDER BY 1 +-- +ok +== +SELECT STRING_AGG(x, ',' ORDER BY x DESC), STRING_AGG(x, ',' ORDER BY x ASC) FROM strings; +-- +ok +== +SELECT y, STRING_AGG(x, ',' ORDER BY x DESC) FILTER (WHERE g < 3) +FROM strings +GROUP BY y +ORDER BY 1 +-- +ok +== +SELECT g, STRING_AGG(DISTINCT y, ',' ORDER BY x DESC) FILTER (WHERE g < 4) +FROM strings +GROUP BY g +ORDER BY 1 +-- +ok +== +INSERT INTO integers (VALUES (1), (2), (3), (NULL)); +-- +ok +== +SELECT i1.i, (SELECT STRING_AGG(i::VARCHAR, ',' ORDER BY i1.i+i) FROM integers WHERE i<=i1.i) c1 +FROM integers i1 +ORDER BY 1 NULLS LAST +-- +ok +== +SELECT string_agg(DISTINCT CellType, '&' ORDER BY list_position(['L900','L1800','L2100','L2600'], CellType)) +FROM (VALUES + ('L900'), + ('L2600'), + ('L2100'), + ('L2100'), + ('L1800') + ) AS t(CellType); +-- +ok +== +SELECT first(DISTINCT i ORDER BY random() * i) +FROM (VALUES + (900), + (2600), + (2100), + (2100), + (1800) + ) AS t(i); +-- +ok +== +SELECT first(DISTINCT random() * i ORDER BY i) +FROM (VALUES + (900), + (2600), + (2100), + (2100), + (1800) + ) AS t(i); +-- +ok +== diff --git a/parser/testdata/corpus/sql/aggregate/aggregates/test_string_agg_big.test b/parser/testdata/corpus/sql/aggregate/aggregates/test_string_agg_big.test new file mode 100644 index 0000000..16fb25f --- /dev/null +++ b/parser/testdata/corpus/sql/aggregate/aggregates/test_string_agg_big.test @@ -0,0 +1,21 @@ +# source: test/sql/aggregate/aggregates/test_string_agg_big.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +CREATE TABLE strings AS SELECT c::VARCHAR g, (c*10+e)::VARCHAR x FROM range(0, 100, 1) t1(c), range(0, 100, 1) t2(e); +-- +ok +== +SELECT COUNT(*) FROM (SELECT g, STRING_AGG(x,',') FROM strings GROUP BY g) t1 +-- +ok +== +SELECT g, STRING_AGG(x ORDER BY x DESC) FROM strings GROUP BY g ORDER BY 1, 2 +-- +ok +== +SELECT g, STRING_AGG(x,',' ORDER BY x DESC) FROM strings GROUP BY g ORDER BY 1, 2 +-- +ok +== diff --git a/parser/testdata/corpus/sql/aggregate/aggregates/test_sum.test b/parser/testdata/corpus/sql/aggregate/aggregates/test_sum.test new file mode 100644 index 0000000..a4380c6 --- /dev/null +++ b/parser/testdata/corpus/sql/aggregate/aggregates/test_sum.test @@ -0,0 +1,57 @@ +# source: test/sql/aggregate/aggregates/test_sum.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +INSERT INTO integers SELECT * FROM range(0, 1000, 1); +-- +ok +== +SELECT SUM(i) FROM integers; +-- +ok +== +INSERT INTO integers SELECT * FROM range(0, -1000, -1); +-- +ok +== +SELECT SUM(1) FROM integers; +-- +ok +== +SELECT SUM(-1) FROM integers; +-- +ok +== +SELECT SUM(-1) FROM integers WHERE i=-1; +-- +ok +== +SELECT SUM(-1) FROM integers WHERE i>10000; +-- +ok +== +CREATE TABLE bigints(b BIGINT); +-- +ok +== +INSERT INTO bigints SELECT * FROM range(4611686018427387904, 4611686018427388904, 1); +-- +ok +== +SELECT SUM(b) FROM bigints +-- +ok +== +SELECT SUM(b)::BIGINT FROM bigints +-- +ok +== +SELECT sum(n ORDER BY ABS(n))::BIGINT FROM doubles; +-- +ok +== +SELECT (sum(n) WITHIN GROUP(ORDER BY ABS(n)))::BIGINT FROM doubles; +-- +error: Parser Error: Unknown ordered aggregate "sum". +== diff --git a/parser/testdata/corpus/sql/aggregate/aggregates/test_sum.test.metadata.json b/parser/testdata/corpus/sql/aggregate/aggregates/test_sum.test.metadata.json new file mode 100644 index 0000000..e96cb89 --- /dev/null +++ b/parser/testdata/corpus/sql/aggregate/aggregates/test_sum.test.metadata.json @@ -0,0 +1,5 @@ +{ + "todo": { + "55e359377905e882": "transformer-raised parser error: upstream rejects in the transformer, not the grammar; expected to clear as transformers land (milestones 3-5)" + } +} diff --git a/parser/testdata/corpus/sql/aggregate/aggregates/test_weighted_avg.test b/parser/testdata/corpus/sql/aggregate/aggregates/test_weighted_avg.test new file mode 100644 index 0000000..d00a420 --- /dev/null +++ b/parser/testdata/corpus/sql/aggregate/aggregates/test_weighted_avg.test @@ -0,0 +1,41 @@ +# source: test/sql/aggregate/aggregates/test_weighted_avg.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +SELECT weighted_avg(3, 3), weighted_avg(3, NULL), weighted_avg(NULL, 3), weighted_avg(NULL, NULL) +-- +ok +== +SELECT weighted_avg(3, 0), weighted_avg(3, 0.0), weighted_avg(0, 3), weighted_avg(0.0, 3) +-- +ok +== +SELECT wavg(3, 3) +-- +ok +== +CREATE TABLE students(name TEXT, grade INTEGER, etcs INTEGER); +-- +ok +== +INSERT INTO students VALUES ('Alice', 8, 6), ('Alice', 6, 2), ('Bob', 6, 3), ('Bob', 8, 3), ('Bob', 6, 6); +-- +ok +== +SELECT name, weighted_avg(grade, etcs) FROM students GROUP BY name ORDER BY name +-- +ok +== +INSERT INTO students VALUES ('Alice', 42, 0); +-- +ok +== +INSERT INTO students VALUES ('Alice', 42, NULL); +-- +ok +== +INSERT INTO students VALUES ('Alice', NULL, 42); +-- +ok +== diff --git a/parser/testdata/corpus/sql/aggregate/distinct/distinct_limit.test b/parser/testdata/corpus/sql/aggregate/distinct/distinct_limit.test new file mode 100644 index 0000000..838709e --- /dev/null +++ b/parser/testdata/corpus/sql/aggregate/distinct/distinct_limit.test @@ -0,0 +1,113 @@ +# source: test/sql/aggregate/distinct/distinct_limit.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +SET profiling_renderer_settings = MAP {'operator_casing': 'upper'}; +-- +ok +== +PRAGMA threads=4 +-- +ok +== +SELECT COUNT(*) FROM (SELECT DISTINCT i % 100 FROM range(1000000) t(i) LIMIT 10) +-- +ok +== +SELECT COUNT(*) FROM (SELECT DISTINCT i % 100 FROM range(1000000) t(i) LIMIT 5 OFFSET 3) +-- +ok +== +EXPLAIN SELECT DISTINCT i % 100 FROM range(1000000) t(i) LIMIT 5 OFFSET 3 +-- +ok +== +SELECT COUNT(*) FROM (SELECT DISTINCT i % 10 FROM range(1000000) t(i) LIMIT 100) +-- +ok +== +SELECT COUNT(*) FROM (SELECT DISTINCT i FROM range(1000000) t(i) LIMIT 0) +-- +ok +== +CREATE TABLE t1 AS SELECT i, i % 10 AS j FROM range(100000) t(i) +-- +ok +== +SELECT COUNT(*) FROM (SELECT DISTINCT i, j FROM t1 LIMIT 15) +-- +ok +== +SELECT COUNT(*) FROM (SELECT i % 100 FROM range(1000000) t(i) GROUP BY 1 LIMIT 10) +-- +ok +== +SELECT COUNT(*) FROM (SELECT i % 100, COUNT(*) FROM range(1000000) t(i) GROUP BY 1 LIMIT 10) +-- +ok +== +CREATE TABLE rollup_limit_t AS SELECT i % 3 AS a FROM range(6) t(i) +-- +ok +== +SELECT COUNT(*) FROM (SELECT grouping(a), a FROM rollup_limit_t GROUP BY ROLLUP (a) LIMIT 10) +-- +ok +== +SELECT DISTINCT i % 10 AS v FROM range(1000000) t(i) ORDER BY v LIMIT 5 +-- +ok +== +CREATE TABLE empty_table (i INTEGER) +-- +ok +== +SELECT COUNT(*) FROM (SELECT DISTINCT i FROM empty_table LIMIT 10) +-- +ok +== +CREATE TABLE t2 AS SELECT i, i % 5 AS grp, i * 10 AS val FROM range(1000) t(i) +-- +ok +== +SELECT COUNT(*) FROM (SELECT DISTINCT ON (grp) grp, val FROM t2 LIMIT 3) +-- +ok +== +EXPLAIN SELECT DISTINCT ON (grp) grp, val FROM t2 LIMIT 3 +-- +ok +== +SELECT DISTINCT ON (grp) grp, val FROM t2 ORDER BY grp, val DESC LIMIT 3 +-- +ok +== +EXPLAIN SELECT DISTINCT ON (grp) grp, val FROM t2 ORDER BY grp, val DESC LIMIT 3 +-- +ok +== +EXPLAIN SELECT DISTINCT i % 100 FROM range(1000000) t(i) LIMIT 10 +-- +ok +== +EXPLAIN SELECT DISTINCT i FROM range(100000) t(i) LIMIT 100000 +-- +ok +== +EXPLAIN SELECT i % 100 FROM range(1000000) t(i) GROUP BY 1 LIMIT 10 +-- +ok +== +EXPLAIN SELECT i % 100, COUNT(*) FROM range(1000000) t(i) GROUP BY 1 LIMIT 10 +-- +ok +== +EXPLAIN SELECT i % 100, first(i) FROM range(1000000) t(i) GROUP BY 1 LIMIT 10 +-- +ok +== +EXPLAIN SELECT DISTINCT i % 100 AS v FROM range(1000000) t(i) ORDER BY v LIMIT 10 +-- +ok +== diff --git a/parser/testdata/corpus/sql/aggregate/distinct/distinct_on_nulls.test b/parser/testdata/corpus/sql/aggregate/distinct/distinct_on_nulls.test new file mode 100644 index 0000000..0e87caf --- /dev/null +++ b/parser/testdata/corpus/sql/aggregate/distinct/distinct_on_nulls.test @@ -0,0 +1,59 @@ +# source: test/sql/aggregate/distinct/distinct_on_nulls.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +INSERT INTO integers VALUES (2, 3), (4, 5), (2, NULL), (NULL, NULL); +-- +ok +== +SELECT DISTINCT ON (i) i, j FROM integers ORDER BY j +-- +ok +== +SELECT DISTINCT ON (i) i, j FROM integers ORDER BY i, j +-- +ok +== +SELECT DISTINCT ON (i) i, j FROM integers ORDER BY i NULLS FIRST, j NULLS FIRST +-- +ok +== +SELECT DISTINCT ON (i) i, j FROM integers ORDER BY i, j NULLS FIRST +-- +ok +== +CREATE TABLE distinct_on_test(key INTEGER, v1 VARCHAR, v2 INTEGER[], v3 INTEGER); +-- +ok +== +INSERT INTO distinct_on_test VALUES + (1, 'hello', ARRAY[1], 42), -- ASC + (1, 'hello', ARRAY[1], 42), + (1, 'hello', ARRAY[1], 43), -- DESC + (2, NULL, NULL, 0), -- ASC + (2, NULL, NULL, 1), + (2, NULL, NULL, NULL), -- DESC + (3, 'thisisalongstring', NULL, 0), -- ASC + (3, 'thisisalongstringbutlonger', NULL, 1), + (3, 'thisisalongstringbutevenlonger', ARRAY[1, 2, 3, 4, 5, 6, 7, 8, 9], 2) -- DESC +; +-- +ok +== +SELECT DISTINCT ON (key) * FROM distinct_on_test ORDER BY key, v1, v2, v3 +-- +ok +== +SELECT DISTINCT ON (key) * FROM distinct_on_test WHERE key <> 2 ORDER BY key, v1, v2, v3 +-- +ok +== +SELECT DISTINCT ON (key) * FROM distinct_on_test ORDER BY key, v1 DESC NULLS FIRST, v2 DESC NULLS FIRST, v3 DESC NULLS FIRST +-- +ok +== +SELECT DISTINCT ON (key) * FROM distinct_on_test WHERE key <> 2 ORDER BY key, v1 DESC NULLS FIRST, v2 DESC NULLS FIRST, v3 DESC NULLS FIRST +-- +ok +== diff --git a/parser/testdata/corpus/sql/aggregate/distinct/distinct_on_order_by.test b/parser/testdata/corpus/sql/aggregate/distinct/distinct_on_order_by.test new file mode 100644 index 0000000..83aaebc --- /dev/null +++ b/parser/testdata/corpus/sql/aggregate/distinct/distinct_on_order_by.test @@ -0,0 +1,128 @@ +# source: test/sql/aggregate/distinct/distinct_on_order_by.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +CREATE TABLE integers(i INTEGER, j INTEGER, k INTEGER); +-- +ok +== +INSERT INTO integers VALUES (2, 3, 5), (4, 5, 6), (2, 7, 6); +-- +ok +== +SELECT DISTINCT ON (i) i, j FROM integers ORDER BY i, j DESC; +-- +ok +== +SELECT DISTINCT ON (i) i, j FROM integers ORDER BY i, j; +-- +ok +== +SELECT DISTINCT ON (i) i, j FROM integers ORDER BY j DESC; +-- +ok +== +SELECT DISTINCT ON (i) i, j FROM integers ORDER BY j; +-- +ok +== +SELECT i, j, (SELECT DISTINCT ON(i) j) AS k FROM integers ORDER BY i, j; +-- +ok +== +SELECT i, j, (SELECT DISTINCT ON(i) j ORDER BY i, j DESC) AS k FROM integers ORDER BY i, j; +-- +ok +== +SELECT i, j, (SELECT DISTINCT ON(i) j ORDER BY i, k) AS k FROM integers ORDER BY i, j; +-- +ok +== +INSERT INTO integers VALUES (2, 3, 7), (4, 5, 11); +-- +ok +== +SELECT DISTINCT ON(i) i, j, k FROM integers ORDER BY i, j ASC, k ASC +-- +ok +== +SELECT DISTINCT ON(i) i, j, k FROM integers ORDER BY i, j ASC, k DESC +-- +ok +== +INSERT INTO integers VALUES (2, NULL, 27), (4, 88, NULL); +-- +ok +== +SELECT DISTINCT ON(i) i, j, k FROM integers ORDER BY i, j NULLS FIRST, k DESC NULLS LAST; +-- +ok +== +SELECT DISTINCT ON(i) i, j, k FROM integers ORDER BY i, j NULLS FIRST, k NULLS FIRST; +-- +ok +== +SELECT DISTINCT ON(i) i, j, k FROM integers ORDER BY i, k NULLS FIRST, j NULLS FIRST; +-- +ok +== +create table foo(a real, b real); +-- +ok +== +insert into foo values (1, 69), (1, 420), (2, 69), (2, 420); +-- +ok +== +select distinct on(a) a, b from foo order by b asc; +-- +ok +== +select distinct on(a) a, b from foo order by b desc; +-- +ok +== +CREATE TABLE example ( + id INT, + person_id INT, + address_id INT, + effective_date DATE +); +-- +ok +== +INSERT INTO + example (id, person_id, address_id, effective_date) +VALUES + (1, 2, 1, '2000-01-01'), -- Moved to first house + (5, 2, 2, '2004-08-19'), -- Went to uni + (9, 2, 1, '2007-06-12'), -- Moved back home + (2, 4, 3, '2007-05-18'), -- Moved to first house + (3, 4, 4, '2016-02-09') -- Moved to new house +; +-- +ok +== +SELECT DISTINCT ON (person_id) + * +FROM + example +ORDER BY + person_id, + effective_date ASC +; +-- +ok +== +SELECT DISTINCT ON (person_id) + * +FROM + example +ORDER BY + person_id, + effective_date DESC +; +-- +ok +== diff --git a/parser/testdata/corpus/sql/aggregate/distinct/grouped/combined_with_grouping.test b/parser/testdata/corpus/sql/aggregate/distinct/grouped/combined_with_grouping.test new file mode 100644 index 0000000..355efff --- /dev/null +++ b/parser/testdata/corpus/sql/aggregate/distinct/grouped/combined_with_grouping.test @@ -0,0 +1,75 @@ +# source: test/sql/aggregate/distinct/grouped/combined_with_grouping.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +create table students ( + course VARCHAR, + type VARCHAR, + value BIGINT +); +-- +ok +== +insert into students + (course, type, value) + values + ('CS', 'Bachelor', 34), + ('CS', 'Bachelor', 34), + ('CS', 'PhD', 12), + ('Math', 'Masters', 12), + ('CS', NULL, 10), + ('CS', NULL, 12), + ('Math', NULL, 12), + ('Math', NULL, NULL); +-- +ok +== +SELECT GROUPING(course), course, sum(distinct value), COUNT(*) FROM students GROUP BY course ORDER BY all; +-- +ok +== +SELECT sum(distinct value), GROUPING_ID(course), course, COUNT(*) FROM students GROUP BY course ORDER BY all; +-- +ok +== +SELECT GROUPING(course), GROUPING(type), course, type, sum(distinct value), COUNT(*), sum(distinct value), FROM students GROUP BY course, type ORDER BY all; +-- +ok +== +SELECT GROUPING(course), GROUPING(type), avg(distinct value), course, type, COUNT(*), sum(distinct value), FROM students GROUP BY CUBE(course, type) ORDER BY all; +-- +ok +== +SELECT sum(distinct value), GROUPING(course, type), course, type, COUNT(*), sum(distinct value), FROM students GROUP BY CUBE(course, type) ORDER BY all; +-- +ok +== +SELECT GROUPING(course), GROUPING(type), sum(distinct value), GROUPING(course)+GROUPING(type), course, type, count(distinct value), COUNT(*) FROM students GROUP BY CUBE(course, type) ORDER BY all; +-- +ok +== +SELECT GROUPING(course, type, course, course, type, value, type, course), avg(distinct value), avg(value), avg(distinct value), course, type, COUNT(*) FROM students GROUP BY CUBE(course, type, value) ORDER BY all; +-- +ok +== +SELECT GROUPING(students.course), GROUPING(students.type), sum(distinct value), GROUPING(course)+GROUPING(type), course, avg(distinct value), type, COUNT(*) FROM students GROUP BY CUBE(course, type, value) ORDER BY all; +-- +ok +== +SELECT GROUPING(course), GROUPING(type), avg(value), GROUPING(course)+GROUPING(type), avg(distinct value), course, type, COUNT(*) FROM students GROUP BY CUBE(students.course, students.type) ORDER BY all; +-- +ok +== +SELECT GROUPING(course), GROUPING(value), course, sum(distinct value), COUNT(*) FROM students GROUP BY CUBE(course, value) HAVING GROUPING(course)=0 ORDER BY all; +-- +ok +== +SELECT GROUPING(course), GROUPING(type), sum(distinct value), course, type, sum(distinct value), avg(distinct value), COUNT(*) FROM students GROUP BY CUBE(course, value, type, value) HAVING GROUPING(students.course)=0 ORDER BY all; +-- +ok +== +SELECT type, COUNT(*), avg(value), sum(distinct value), avg(distinct value), FROM students GROUP BY CUBE(value, type) ORDER BY GROUPING(value), GROUPING(type), 1, 2, 3, 4, 5; +-- +ok +== diff --git a/parser/testdata/corpus/sql/aggregate/distinct/grouped/identical_inputs.test b/parser/testdata/corpus/sql/aggregate/distinct/grouped/identical_inputs.test new file mode 100644 index 0000000..c0281ac --- /dev/null +++ b/parser/testdata/corpus/sql/aggregate/distinct/grouped/identical_inputs.test @@ -0,0 +1,13 @@ +# source: test/sql/aggregate/distinct/grouped/identical_inputs.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +create table tbl as select i%50::BIGINT as i, i%5::BIGINT as j from range(1000000) tbl(i); +-- +ok +== +select count(distinct i), min(distinct i), max(distinct i), sum(distinct i), product(distinct i) from tbl group by j order by all; +-- +ok +== diff --git a/parser/testdata/corpus/sql/aggregate/distinct/grouped/issue_5070.test b/parser/testdata/corpus/sql/aggregate/distinct/grouped/issue_5070.test new file mode 100644 index 0000000..9ecd34f --- /dev/null +++ b/parser/testdata/corpus/sql/aggregate/distinct/grouped/issue_5070.test @@ -0,0 +1,22 @@ +# source: test/sql/aggregate/distinct/grouped/issue_5070.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +pragma verify_parallelism +-- +ok +== +WITH evs AS ( + SELECT * FROM (VALUES + ('1','123','7'), + ('1','456','7') + ) AS t("id", "type", "value" ) +) +SELECT "id" +, COUNT(DISTINCT "value") FILTER (WHERE "type" = '456') AS type_456_count +FROM evs +GROUP BY "id" +-- +ok +== diff --git a/parser/testdata/corpus/sql/aggregate/distinct/grouped/multiple_grouping_sets.test b/parser/testdata/corpus/sql/aggregate/distinct/grouped/multiple_grouping_sets.test new file mode 100644 index 0000000..7645e1f --- /dev/null +++ b/parser/testdata/corpus/sql/aggregate/distinct/grouped/multiple_grouping_sets.test @@ -0,0 +1,132 @@ +# source: test/sql/aggregate/distinct/grouped/multiple_grouping_sets.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +insert into students + (course, type, value) + values + ('CS', 'Bachelor', 20), + ('CS', 'Bachelor', 10), + ('CS', 'PhD', -20), + ('Math', 'Masters', 10), + ('CS', NULL, -15), + ('CS', NULL, 10), + ('Math', NULL, 15); +-- +ok +== +select course, type, count(*), sum(distinct value) from students group by course, type order by all; +-- +ok +== +select course, type, count(*), sum(distinct value) from students group by (course, type) order by all; +-- +ok +== +select course, count(*), sum(distinct value) from students group by (), course, () order by all; +-- +ok +== +select count(*), course, type, sum(distinct value) + from students + group by grouping sets ((course), (type)) + order by all; +-- +ok +== +select sum(distinct value), count(*), course, avg(distinct value), type + from students + group by grouping sets (course), grouping sets(type) + order by all; +-- +ok +== +select sum(distinct value), count(*), count(distinct value), course, type + from students + group by course, grouping sets(type) + order by all; +-- +ok +== +select count(*), ARG_MIN(distinct value%5, value), course, sum(distinct value), type + from students + group by course, grouping sets(type, ()) + order by all; +-- +ok +== +select sum(distinct value), count(*), course, type + from students + group by grouping sets((course, type), (course)) + order by all; +-- +ok +== +select count(*), count(distinct value), count(value), course, sum(distinct value), type + from students + group by grouping sets (grouping sets(course), grouping sets(type)) + order by all; +-- +ok +== +select count(*), avg(distinct value) FILTER (where value < 5), avg(distinct value), course, avg(value), type + from students + group by grouping sets (grouping sets(course, ()), grouping sets(type)) + order by all; +-- +ok +== +select count(*), sum(distinct value), course, type + from students + group by grouping sets ((course), (), (type)) + order by all; +-- +ok +== +select count(*), count(distinct value), sum(distinct value), course, type + from students + group by grouping sets(course, ()), grouping sets(type) + order by all; +-- +ok +== +select sum(distinct value), count(*), course, type, sum(distinct value) + from students + group by grouping sets(course, ()), type + order by all; +-- +ok +== +select sum(distinct value) FILTER (where value % 10 != 0), count(*), course, type, sum(distinct value) + from students + group by grouping sets((course, type), (type)) + order by all; +-- +ok +== +select count(*), sum(distinct value), course, type + from students + group by grouping sets((3, 4), (4)) + order by all; +-- +ok +== +select count(*), course AS crs, sum(distinct value), type AS tp + from students + group by grouping sets((crs, tp), (tp)) + order by all; +-- +ok +== +select sum(distinct value), count(*), course, type + from students + group by grouping sets (grouping sets(course, ()), grouping sets(type, ())) + order by all; +-- +ok +== +set threads=1 +-- +ok +== diff --git a/parser/testdata/corpus/sql/aggregate/distinct/grouped/string_agg.test b/parser/testdata/corpus/sql/aggregate/distinct/grouped/string_agg.test new file mode 100644 index 0000000..8da6dfa --- /dev/null +++ b/parser/testdata/corpus/sql/aggregate/distinct/grouped/string_agg.test @@ -0,0 +1,51 @@ +# source: test/sql/aggregate/distinct/grouped/string_agg.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +CREATE TABLE strings( + g INTEGER, + x VARCHAR, + y VARCHAR +); +-- +ok +== +INSERT INTO strings VALUES + (1,'a','/'), + (1,'b','-'), + (2,'i','/'), + (2,NULL,'-'), + (2,'j','+'), + (3,'p','/'), + (4,'x','/'), + (4,'y','-'), + (4,'z','+'); +-- +ok +== +SELECT g, STRING_AGG(DISTINCT y, ',' ORDER BY y DESC) FILTER (WHERE g < 4) +FROM strings +GROUP BY g +ORDER BY 1 +-- +ok +== +SELECT g, count(y), STRING_AGG(DISTINCT y, ',' ORDER BY y DESC) FILTER (WHERE g < 4), sum(1) +FROM strings +GROUP BY g +ORDER BY 1 +-- +ok +== +SELECT g, STRING_AGG(DISTINCT y ORDER BY y, '_' ) FILTER (WHERE g < 4) +FROM strings +GROUP BY g +ORDER BY 1 +-- +ok +== +SET order_by_non_integer_literal=true +-- +ok +== diff --git a/parser/testdata/corpus/sql/aggregate/distinct/issue19616.test b/parser/testdata/corpus/sql/aggregate/distinct/issue19616.test new file mode 100644 index 0000000..04e51da --- /dev/null +++ b/parser/testdata/corpus/sql/aggregate/distinct/issue19616.test @@ -0,0 +1,34 @@ +# source: test/sql/aggregate/distinct/issue19616.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +CREATE TABLE test ( + col1 int, + col2 int, + col3 int +); +-- +ok +== +INSERT INTO test +VALUES (22, 6, 8), + (28, 57, 45), + (82, 44, 71); +-- +ok +== +SET threads = 4; +-- +ok +== +SELECT * +FROM ( + SELECT DISTINCT col2 + FROM test + GROUP BY ROLLUP (col1, col2, col3) +) +ORDER BY col2; +-- +ok +== diff --git a/parser/testdata/corpus/sql/aggregate/distinct/issue2656.test b/parser/testdata/corpus/sql/aggregate/distinct/issue2656.test new file mode 100644 index 0000000..40899e7 --- /dev/null +++ b/parser/testdata/corpus/sql/aggregate/distinct/issue2656.test @@ -0,0 +1,39 @@ +# source: test/sql/aggregate/distinct/issue2656.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +CREATE TABLE T (t1 int, t2 int); +-- +ok +== +INSERT INTO t VALUES (1, 1), (1, 2); +-- +ok +== +SELECT DISTINCT t1 +FROM T +ORDER BY t1, t2; +-- +ok +== +SELECT DISTINCT ON (1) t1, t2 +FROM T +ORDER BY t1, t2; +-- +ok +== +SELECT DISTINCT t1 FROM T +UNION +SELECT DISTINCT t1 FROM T +ORDER BY t1; +-- +ok +== +SELECT DISTINCT t1 FROM T +UNION ALL +SELECT DISTINCT t1 FROM T +ORDER BY t1; +-- +ok +== diff --git a/parser/testdata/corpus/sql/aggregate/distinct/issue8505.test b/parser/testdata/corpus/sql/aggregate/distinct/issue8505.test new file mode 100644 index 0000000..db80728 --- /dev/null +++ b/parser/testdata/corpus/sql/aggregate/distinct/issue8505.test @@ -0,0 +1,19 @@ +# source: test/sql/aggregate/distinct/issue8505.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +create table test (id int, provider int, record_key int, record_rank int, record_date int) +-- +ok +== +explain select record_key from ( + select distinct on (id, provider) id, provider, record_key from test order by id, provider, record_rank desc, record_date +) +-- +ok +== +explain select distinct on (id, provider) record_key from test order by id, provider, record_rank desc, record_date +-- +ok +== diff --git a/parser/testdata/corpus/sql/aggregate/distinct/issue9241.test b/parser/testdata/corpus/sql/aggregate/distinct/issue9241.test new file mode 100644 index 0000000..8465477 --- /dev/null +++ b/parser/testdata/corpus/sql/aggregate/distinct/issue9241.test @@ -0,0 +1,21 @@ +# source: test/sql/aggregate/distinct/issue9241.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +create table foo (a int, b int); +-- +ok +== +insert into foo values (1, 1), (2, 1), (2, 2); +-- +ok +== +select * from (select distinct on (a) a, b from foo order by a, b desc) sub; +-- +ok +== +select * from (select distinct on (a) a, b from foo order by a, b desc) sub where b <> 2; +-- +ok +== diff --git a/parser/testdata/corpus/sql/aggregate/distinct/rewrite/distinct_aggregate_rewrite.test b/parser/testdata/corpus/sql/aggregate/distinct/rewrite/distinct_aggregate_rewrite.test new file mode 100644 index 0000000..0d7d544 --- /dev/null +++ b/parser/testdata/corpus/sql/aggregate/distinct/rewrite/distinct_aggregate_rewrite.test @@ -0,0 +1,346 @@ +# source: test/sql/aggregate/distinct/rewrite/distinct_aggregate_rewrite.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +CREATE TABLE distinct_rewrite AS + SELECT i % 4 AS g, CASE WHEN i % 5 = 0 THEN NULL ELSE i % 7 END AS x, i % 11 AS y + FROM range(100) tbl(i); +-- +ok +== +SELECT count(DISTINCT x), sum(DISTINCT x), avg(DISTINCT x) FROM distinct_rewrite; +-- +ok +== +SELECT g, count(DISTINCT x), sum(DISTINCT x) +FROM distinct_rewrite +GROUP BY g +ORDER BY g; +-- +ok +== +SELECT count(DISTINCT x), count(DISTINCT y), sum(DISTINCT x), sum(y) +FROM distinct_rewrite; +-- +ok +== +EXPLAIN ANALYZE +SELECT count(DISTINCT x), count(DISTINCT y) +FROM distinct_rewrite; +-- +ok +== +SELECT g, count(DISTINCT x), sum(y) +FROM distinct_rewrite +GROUP BY g +ORDER BY g; +-- +ok +== +CREATE TABLE distinct_rewrite_nulls(g INTEGER, x INTEGER, y INTEGER); +-- +ok +== +INSERT INTO distinct_rewrite_nulls VALUES + (NULL, NULL, 1), + (NULL, NULL, 2), + (1, NULL, 3), + (1, 4, 4), + (1, 4, 5), + (2, 5, 6), + (2, NULL, 7); +-- +ok +== +SELECT g, count(DISTINCT x), count(DISTINCT y), sum(DISTINCT x), sum(y) +FROM distinct_rewrite_nulls +GROUP BY g +ORDER BY g NULLS FIRST; +-- +ok +== +SELECT count(DISTINCT x), sum(DISTINCT x), avg(DISTINCT x) +FROM distinct_rewrite_nulls +WHERE false; +-- +ok +== +CREATE TABLE distinct_rewrite_order(g INTEGER, s VARCHAR, y INTEGER, keep BOOLEAN); +-- +ok +== +INSERT INTO distinct_rewrite_order VALUES + (1, 'a', 2, true), + (1, 'b', 1, false), + (1, 'b', 4, true), + (1, 'c', 3, true), + (2, 'a', 5, false), + (2, 'd', 1, true), + (2, 'd', 2, true), + (3, NULL, 3, true); +-- +ok +== +SELECT count(DISTINCT s), string_agg(DISTINCT s, ',' ORDER BY s DESC) +FROM distinct_rewrite_order; +-- +ok +== +SELECT string_agg(DISTINCT s, ',' ORDER BY unicode(s) DESC) +FROM distinct_rewrite_order; +-- +ok +== +SELECT g, string_agg(DISTINCT s, ',' ORDER BY s DESC) +FROM distinct_rewrite_order +GROUP BY g +ORDER BY g; +-- +ok +== +SELECT g, count(DISTINCT s), sum(y) FILTER (WHERE keep) +FROM distinct_rewrite_order +GROUP BY g +ORDER BY g; +-- +ok +== +SELECT g, count(DISTINCT s), string_agg(y::VARCHAR, ',' ORDER BY y DESC) +FROM distinct_rewrite_order +GROUP BY g +ORDER BY g; +-- +ok +== +SELECT count(DISTINCT s) FILTER (WHERE keep), + string_agg(DISTINCT s, ',' ORDER BY s DESC) FILTER (WHERE keep) +FROM distinct_rewrite_order; +-- +ok +== +SELECT g, count(DISTINCT x) FILTER (WHERE y > 3) +FROM distinct_rewrite_nulls +GROUP BY g +ORDER BY g NULLS FIRST; +-- +ok +== +SELECT g, + count(DISTINCT s) FILTER (WHERE keep), + string_agg(DISTINCT s, ',' ORDER BY s DESC) FILTER (WHERE keep) +FROM distinct_rewrite_order +GROUP BY g +ORDER BY g; +-- +ok +== +SELECT g, + count(DISTINCT s) FILTER (WHERE keep), + count(DISTINCT s) FILTER (WHERE NOT keep) +FROM distinct_rewrite_order +GROUP BY g +ORDER BY g; +-- +ok +== +SELECT g, list(DISTINCT s ORDER BY s) FILTER (WHERE keep AND y < 0) +FROM distinct_rewrite_order +GROUP BY g +ORDER BY g; +-- +ok +== +CREATE TABLE distinct_rewrite_filter_errors(g INTEGER, value VARCHAR, keep BOOLEAN); +-- +ok +== +INSERT INTO distinct_rewrite_filter_errors VALUES (1, 'bad', false), (1, '1', true); +-- +ok +== +SELECT count(DISTINCT value::INTEGER) FILTER (WHERE keep) +FROM distinct_rewrite_filter_errors; +-- +ok +== +SELECT g, count(DISTINCT value::INTEGER) FILTER (WHERE keep) +FROM distinct_rewrite_filter_errors +GROUP BY g; +-- +ok +== +SELECT string_agg(DISTINCT value, ',' ORDER BY value::INTEGER) FILTER (WHERE keep) +FROM distinct_rewrite_filter_errors; +-- +ok +== +SELECT GROUPING(g), g, count(DISTINCT x) +FROM distinct_rewrite_nulls +GROUP BY g +ORDER BY g NULLS FIRST; +-- +ok +== +SELECT finalize(sum(DISTINCT x) EXPORT_STATE), + finalize(count(DISTINCT x) EXPORT_STATE) +FROM distinct_rewrite_nulls; +-- +ok +== +CREATE TABLE part(p_partkey BIGINT NOT NULL, p_brand VARCHAR NOT NULL, p_type VARCHAR NOT NULL, + p_size INTEGER NOT NULL); +-- +ok +== +CREATE TABLE partsupp(ps_partkey BIGINT NOT NULL, ps_suppkey BIGINT NOT NULL); +-- +ok +== +CREATE TABLE supplier(s_suppkey BIGINT NOT NULL, s_comment VARCHAR NOT NULL); +-- +ok +== +INSERT INTO part VALUES + (1, 'Brand#11', 'SMALL BRUSHED', 49), + (2, 'Brand#11', 'SMALL BRUSHED', 49), + (3, 'Brand#45', 'SMALL BRUSHED', 49), + (4, 'Brand#22', 'MEDIUM POLISHED STEEL', 14), + (5, 'Brand#22', 'LARGE BRUSHED', 3), + (6, 'Brand#33', 'LARGE BRUSHED', 2); +-- +ok +== +INSERT INTO partsupp VALUES + (1, 10), (1, 20), (2, 10), (2, 30), + (3, 60), (4, 70), (5, 40), (5, 50), (6, 80); +-- +ok +== +INSERT INTO supplier VALUES + (10, 'regular supplier'), + (20, 'Customer service Complaints pending'), + (30, 'regular supplier'), + (40, 'regular supplier'), + (50, 'regular supplier'), + (60, 'regular supplier'), + (70, 'regular supplier'), + (80, 'regular supplier'); +-- +ok +== +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; +-- +ok +== +CREATE TABLE distinct_rewrite_grouping_sets(course VARCHAR, type VARCHAR, value INTEGER); +-- +ok +== +INSERT INTO distinct_rewrite_grouping_sets VALUES + ('CS', 'B', 1), + ('CS', 'P', 1), + ('CS', 'P', 2), + ('Math', 'M', 2), + ('Math', 'M', 2), + ('Math', NULL, 3); +-- +ok +== +SELECT course, type, sum(DISTINCT value), count(DISTINCT value), GROUPING(course), GROUPING(type) +FROM distinct_rewrite_grouping_sets +GROUP BY CUBE(course, type) +ORDER BY GROUPING(course), GROUPING(type), course, type NULLS FIRST; +-- +ok +== +SELECT course, type, finalize(sum(DISTINCT value) EXPORT_STATE), GROUPING(course), GROUPING(type) +FROM distinct_rewrite_grouping_sets +GROUP BY CUBE(course, type) +ORDER BY GROUPING(course), GROUPING(type), course, type NULLS FIRST; +-- +ok +== +CREATE SEQUENCE distinct_rewrite_seq_count START 1; +-- +ok +== +CREATE SEQUENCE distinct_rewrite_seq_sum START 1; +-- +ok +== +SELECT count(DISTINCT nextval('distinct_rewrite_seq_count')), + sum(DISTINCT nextval('distinct_rewrite_seq_sum')) +FROM range(4); +-- +ok +== +SELECT currval('distinct_rewrite_seq_count'), currval('distinct_rewrite_seq_sum'); +-- +ok +== +CREATE SEQUENCE distinct_rewrite_seq_filter START 1; +-- +ok +== +SELECT count(DISTINCT i) FILTER (WHERE nextval('distinct_rewrite_seq_filter') % 2 = 0), + sum(i) +FROM range(5) tbl(i); +-- +ok +== +SELECT currval('distinct_rewrite_seq_filter'); +-- +ok +== +CREATE SEQUENCE distinct_rewrite_seq_filtered_arg START 1; +-- +ok +== +SELECT count(DISTINCT nextval('distinct_rewrite_seq_filtered_arg')) FILTER (WHERE false) +FROM range(4); +-- +ok +== +SELECT currval('distinct_rewrite_seq_filtered_arg'); +-- +ok +== +CREATE SEQUENCE distinct_rewrite_seq_grouping_sets START 1; +-- +ok +== +SELECT g, count(DISTINCT nextval('distinct_rewrite_seq_grouping_sets')), GROUPING(g) +FROM (VALUES (1), (2), (1)) tbl(g) +GROUP BY CUBE(g) +ORDER BY GROUPING(g), g; +-- +ok +== +SELECT currval('distinct_rewrite_seq_grouping_sets'); +-- +ok +== +EXPLAIN (FORMAT JSON) +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; +-- +ok +== diff --git a/parser/testdata/corpus/sql/aggregate/distinct/test_distinct.test b/parser/testdata/corpus/sql/aggregate/distinct/test_distinct.test new file mode 100644 index 0000000..db82424 --- /dev/null +++ b/parser/testdata/corpus/sql/aggregate/distinct/test_distinct.test @@ -0,0 +1,56 @@ +# source: test/sql/aggregate/distinct/test_distinct.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +CREATE TABLE test (a INTEGER, b INTEGER); +-- +ok +== +INSERT INTO test VALUES (11, 22), (13, 22), (11, 21), (11, 22) +-- +ok +== +SELECT DISTINCT a, b FROM test ORDER BY a, b +-- +ok +== +SELECT DISTINCT test.a, b FROM test ORDER BY a, b +-- +ok +== +SELECT DISTINCT a FROM test ORDER BY a +-- +ok +== +SELECT DISTINCT b FROM test ORDER BY b +-- +ok +== +SELECT DISTINCT a, SUM(B) FROM test GROUP BY a ORDER BY a +-- +ok +== +SELECT DISTINCT MAX(b) FROM test GROUP BY a +-- +ok +== +SELECT DISTINCT CASE WHEN a > 11 THEN 11 ELSE a END FROM test +-- +ok +== +CREATE TABLE issue3056 AS (SELECT * FROM (VALUES + (['TGTA']), + (['CGGT']), + (['CCTC']), + (['TCTA']), + (['AGGG']), + (NULL)) +tbl(genes)); +-- +ok +== +SELECT DISTINCT genes FROM issue3056; +-- +ok +== diff --git a/parser/testdata/corpus/sql/aggregate/distinct/test_distinct_on.test b/parser/testdata/corpus/sql/aggregate/distinct/test_distinct_on.test new file mode 100644 index 0000000..7f6c5d7 --- /dev/null +++ b/parser/testdata/corpus/sql/aggregate/distinct/test_distinct_on.test @@ -0,0 +1,101 @@ +# source: test/sql/aggregate/distinct/test_distinct_on.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +INSERT INTO integers VALUES (2, 3, 5), (4, 5, 6), (2, 7, 6) +-- +ok +== +SELECT DISTINCT ON (i) i, j FROM integers WHERE i <> 2 +-- +ok +== +SELECT DISTINCT ON (j) i, j FROM integers WHERE i <> 2 +-- +ok +== +SELECT DISTINCT ON (j, i) i, j FROM integers WHERE i <> 2 +-- +ok +== +SELECT DISTINCT ON (j + 1, i * 3) i, j FROM integers WHERE i <> 2 +-- +ok +== +SELECT DISTINCT ON (1) i, j FROM integers ORDER BY i +-- +ok +== +SELECT DISTINCT ON (1) i, j FROM integers ORDER BY i LIMIT 1 +-- +ok +== +SELECT DISTINCT ON (1) i, j FROM integers ORDER BY i LIMIT 1 OFFSET 1 +-- +ok +== +SELECT DISTINCT ON (2) i, j FROM integers ORDER BY 2 +-- +ok +== +SELECT DISTINCT ON (2) j, k FROM integers ORDER BY 2 +-- +ok +== +SELECT DISTINCT ON (3) i, j, k FROM integers ORDER BY 2 +-- +ok +== +SELECT DISTINCT ON (3) i, j, k FROM integers ORDER BY 3 +-- +ok +== +SELECT DISTINCT ON (2) j, (SELECT i FROM integers WHERE i=2 LIMIT 1) FROM integers ORDER BY 2 +-- +ok +== +SELECT DISTINCT ON (2) j, (SELECT DISTINCT ON (i) i FROM integers ORDER BY 1 LIMIT 1) FROM integers ORDER BY 2 +-- +ok +== +SELECT * FROM (SELECT DISTINCT ON (i) i, j FROM integers) tbl1 WHERE i <> 2 +-- +ok +== +SELECT DISTINCT ON (i) i, j FROM integers ORDER BY k +-- +ok +== +SELECT DISTINCT ON (i) i, j, k FROM integers ORDER BY k +-- +ok +== +SELECT DISTINCT ON (integers.i) i, j FROM integers ORDER BY 1, 2 +-- +ok +== +SELECT DISTINCT ON (i) integers.i, integers.j FROM integers ORDER BY 1, 2 +-- +ok +== +SELECT DISTINCT ON (integers.i) integers.i, integers.j FROM integers ORDER BY i, j +-- +ok +== +SELECT DISTINCT ON (2) i FROM integers +-- +ok +== +SELECT DISTINCT ON(i, 'literal') i FROM integers +-- +ok +== +SELECT DISTINCT ON(i, 'literal') i FROM integers ORDER BY ALL +-- +ok +== +PREPARE v1 AS select distinct on (?) 42; +-- +ok +== diff --git a/parser/testdata/corpus/sql/aggregate/distinct/test_distinct_on_columns.test b/parser/testdata/corpus/sql/aggregate/distinct/test_distinct_on_columns.test new file mode 100644 index 0000000..c096af4 --- /dev/null +++ b/parser/testdata/corpus/sql/aggregate/distinct/test_distinct_on_columns.test @@ -0,0 +1,116 @@ +# source: test/sql/aggregate/distinct/test_distinct_on_columns.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +FROM (VALUES (1,1,2),(1,1,3)) AS t(key1,key2,v) +SELECT DISTINCT ON (COLUMNS('key')) * +-- +ok +== +CREATE TABLE grouped_table AS SELECT 1 id, 42 index1, 84 index2 UNION ALL SELECT 2, 42, 84 UNION ALL SELECT 3, 13, 14 +-- +ok +== +SELECT DISTINCT ON (COLUMNS('index[0-9]')) * FROM grouped_table ORDER BY index1, index2, id +-- +ok +== +FROM (VALUES (1,1,2),(1,1,3),(2,1,4)) AS t(key1,key2,v) +SELECT DISTINCT ON (COLUMNS('key'), v) key1, key2, v ORDER BY key1, v +-- +ok +== +FROM (VALUES (1,1,2),(1,1,3)) AS t(k1,k2,v) +SELECT DISTINCT ON (COLUMNS('k')) * ORDER BY k1, k2 +-- +ok +== +CREATE TABLE a AS SELECT * FROM (VALUES (1,1),(2,2)) AS ta(ak, av) +-- +ok +== +CREATE TABLE b AS SELECT * FROM (VALUES (1,9),(2,8)) AS tb(bk, bv) +-- +ok +== +SELECT DISTINCT ON (a.ak, b.bk) * FROM a JOIN b ON a.ak = b.bk ORDER BY a.ak, b.bk +-- +ok +== +FROM (VALUES (1,1,2),(1,1,3)) AS t(key1,key2,v) +SELECT DISTINCT ON (COLUMNS('key'), key1) * ORDER BY key1, key2 +-- +ok +== +FROM (VALUES (1,1,2),(1,1,3)) AS t(key1,key2,v) +SELECT DISTINCT ON (COLUMNS(* EXCLUDE (v))) * ORDER BY key1, key2 +-- +ok +== +SELECT DISTINCT ON (COLUMNS('[0-9]')) * FROM grouped_table ORDER BY index1, index2, id +-- +ok +== +SELECT DISTINCT ON (COLUMNS('nonexistent')) * FROM grouped_table +-- +ok +== +FROM (VALUES (1,1,2),(1,1,3),(2,2,4)) AS t(key1,key2,v) +SELECT DISTINCT ON (COLUMNS('key')) * ORDER BY key1, key2, v +-- +ok +== +FROM (VALUES (1,1,2),(1,1,3)) AS t(key1,key2,v) +SELECT DISTINCT ON (COLUMNS('key1'), COLUMNS('key2')) * ORDER BY key1, key2 +-- +ok +== +FROM (VALUES (1,1,2),(1,1,3)) AS t(key1,key2,v) +SELECT DISTINCT ON (COLUMNS(* EXCLUDE (v) REPLACE (key1+1 AS key1))) * ORDER BY key1, key2 +-- +ok +== +SELECT DISTINCT ON (key1, key2) * FROM (VALUES(1,1,2),(1,1,3)) AS t(key1,key2,v) ORDER BY key1, key2 +-- +ok +== +SELECT DISTINCT COLUMNS('key') FROM (VALUES(1,1,2),(1,1,3)) AS t(key1,key2,v) +-- +ok +== +FROM (VALUES (1,1,2),(1,1,3)) AS t(key1,key2,v) +SELECT DISTINCT ON (COLUMNS(['key1', 'key2'])) * ORDER BY key1, key2 +-- +ok +== +CREATE TABLE complex_table AS SELECT 1 a, 2 b, 3 c UNION ALL SELECT 1, 2, 4 UNION ALL SELECT 1, 3, 5 +-- +ok +== +SELECT DISTINCT ON (COLUMNS('a'), COLUMNS('b')) * FROM complex_table ORDER BY a, b, c +-- +ok +== +SELECT DISTINCT ON (COLUMNS('key')) * FROM ( + SELECT * FROM (VALUES (1,1,2),(1,1,3)) AS t(key1,key2,v) +) subq ORDER BY key1, key2 +-- +ok +== +DROP TABLE IF EXISTS grouped_table +-- +ok +== +DROP TABLE IF EXISTS a +-- +ok +== +DROP TABLE IF EXISTS b +-- +ok +== +DROP TABLE IF EXISTS complex_table +-- +ok +== diff --git a/parser/testdata/corpus/sql/aggregate/distinct/test_distinct_order_by.test b/parser/testdata/corpus/sql/aggregate/distinct/test_distinct_order_by.test new file mode 100644 index 0000000..094057e --- /dev/null +++ b/parser/testdata/corpus/sql/aggregate/distinct/test_distinct_order_by.test @@ -0,0 +1,29 @@ +# source: test/sql/aggregate/distinct/test_distinct_order_by.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +SELECT DISTINCT i%2 FROM integers ORDER BY 1 +-- +ok +== +SELECT DISTINCT i % 2 FROM integers WHERE i<3 ORDER BY i +-- +ok +== +SELECT DISTINCT ON (1) i % 2, i FROM integers WHERE i<3 ORDER BY i +-- +ok +== +SELECT DISTINCT integers.i FROM integers ORDER BY i DESC +-- +ok +== +SELECT DISTINCT i FROM integers ORDER BY integers.i DESC +-- +ok +== +SELECT DISTINCT integers.i FROM integers ORDER BY integers.i DESC +-- +ok +== diff --git a/parser/testdata/corpus/sql/aggregate/distinct/ungrouped/test_distinct_ungrouped.test b/parser/testdata/corpus/sql/aggregate/distinct/ungrouped/test_distinct_ungrouped.test new file mode 100644 index 0000000..f9b927f --- /dev/null +++ b/parser/testdata/corpus/sql/aggregate/distinct/ungrouped/test_distinct_ungrouped.test @@ -0,0 +1,132 @@ +# source: test/sql/aggregate/distinct/ungrouped/test_distinct_ungrouped.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +create table tbl as + (select i%50 as i, i%100 as j from range(50000) tbl(i)) +; +-- +ok +== +select + count(distinct i) +from tbl; +-- +ok +== +select + sum(distinct i), + sum(i), + sum(j) +from tbl; +-- +ok +== +select + sum(i), + sum(j), + sum(distinct i) +from tbl; +-- +ok +== +select + sum(i), + sum(distinct i), + sum(j) +from tbl; +-- +ok +== +select + sum(distinct i), + count(j), + sum(distinct j) +from tbl; +-- +ok +== +select + sum(j), + sum(distinct i), + count(j), + sum(distinct j) +from tbl; +-- +ok +== +select + sum(distinct i), + count(j), + sum(distinct j), + sum(j) +from tbl; +-- +ok +== +select + count(distinct i) FILTER (WHERE i >= 20) +from tbl; +-- +ok +== +select + sum(distinct i), + sum(i) FILTER (WHERE j < 20), + sum(j) FILTER (WHERE i >= 20) +from tbl; +-- +ok +== +select + sum(i), + sum(j) FILTER (WHERE j == 0), + sum(distinct i) FILTER (WHERE i == 0) +from tbl; +-- +ok +== +select + sum(i) FILTER (WHERE j == 5), + sum(distinct i), + sum(j) FILTER (WHERE i == 5) +from tbl; +-- +ok +== +select + sum(distinct i) FILTER (WHERE i == 5), + count(j), + sum(distinct j) FILTER (WHERE i == 5) +from tbl; +-- +ok +== +select + sum(j) FILTER (WHERE j == 5), + sum(distinct i) FILTER (WHERE j == 5), + count(j), + sum(distinct j) +from tbl; +-- +ok +== +select + sum(j) FILTER (WHERE i == 5), + sum(distinct i), + count(j), + sum(distinct j) FILTER (WHERE j == 5) +from tbl; +-- +ok +== +select + sum(distinct i), + count(j), + sum(distinct j) FILTER (WHERE j == 5), + sum(j) FILTER (WHERE j == 5) +from tbl; +-- +ok +== diff --git a/parser/testdata/corpus/sql/aggregate/distinct/ungrouped/test_distinct_ungrouped_shared_input.test b/parser/testdata/corpus/sql/aggregate/distinct/ungrouped/test_distinct_ungrouped_shared_input.test new file mode 100644 index 0000000..5490fee --- /dev/null +++ b/parser/testdata/corpus/sql/aggregate/distinct/ungrouped/test_distinct_ungrouped_shared_input.test @@ -0,0 +1,13 @@ +# source: test/sql/aggregate/distinct/ungrouped/test_distinct_ungrouped_shared_input.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +create table tbl as select i%50 as i from range(1000000) tbl(i); +-- +ok +== +select count(distinct i), min(distinct i), max(distinct i), sum(distinct i), product(distinct i) from tbl; +-- +ok +== diff --git a/parser/testdata/corpus/sql/aggregate/group/group_by_all.test b/parser/testdata/corpus/sql/aggregate/group/group_by_all.test new file mode 100644 index 0000000..e1373c8 --- /dev/null +++ b/parser/testdata/corpus/sql/aggregate/group/group_by_all.test @@ -0,0 +1,73 @@ +# source: test/sql/aggregate/group/group_by_all.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +CREATE TABLE integers(g integer, i integer); +-- +ok +== +INSERT INTO integers values (0, 1), (0, 2), (1, 3), (1, NULL); +-- +ok +== +SELECT g, SUM(i) FROM integers GROUP BY ALL ORDER BY 1 +-- +ok +== +SELECT SUM(i), g FROM integers GROUP BY ALL ORDER BY 2 +-- +ok +== +SELECT g, SUM(i) FROM integers GROUP BY * ORDER BY 1 +-- +ok +== +SELECT g, SUM(i) FROM integers GROUP BY 1 ORDER BY ALL +-- +ok +== +SELECT g, SUM(i) FROM integers GROUP BY 1 ORDER BY * +-- +ok +== +SELECT g, SUM(i), COUNT(*), COUNT(i), SUM(g) FROM integers GROUP BY ALL ORDER BY 1 +-- +ok +== +SELECT i%2, SUM(i), SUM(g) FROM integers GROUP BY ALL ORDER BY 1 +-- +ok +== +SELECT i%2, SUM(i), SUM(g) FROM integers GROUP BY 1 ORDER BY 1 +-- +ok +== +SELECT i%2, SUM(i), SUM(g) FROM integers GROUP BY i ORDER BY 1 NULLS FIRST, 2 +-- +ok +== +SELECT (g+i)%2, SUM(i), SUM(g) FROM integers GROUP BY ALL ORDER BY 1 NULLS FIRST +-- +ok +== +SELECT (g+i)%2, SUM(i), SUM(g) FROM integers GROUP BY 1 ORDER BY 1 NULLS FIRST +-- +ok +== +SELECT (g+i)%2, SUM(i), SUM(g) FROM integers GROUP BY g, i ORDER BY 1 NULLS FIRST, 2 +-- +ok +== +SELECT (g+i)%2 + SUM(i), SUM(i), SUM(g) FROM integers GROUP BY ALL ORDER BY 1 +-- +ok +== +SELECT g, i, g%2, SUM(i), SUM(g) FROM integers GROUP BY 1, 2, 3 ORDER BY 1, 2, 3, 4 +-- +ok +== +SELECT g, i, g%2, SUM(i), SUM(g) FROM integers GROUP BY ALL ORDER BY 1, 2 NULLS FIRST, 3, 4 +-- +ok +== diff --git a/parser/testdata/corpus/sql/aggregate/group/group_by_all_having.test b/parser/testdata/corpus/sql/aggregate/group/group_by_all_having.test new file mode 100644 index 0000000..134dc49 --- /dev/null +++ b/parser/testdata/corpus/sql/aggregate/group/group_by_all_having.test @@ -0,0 +1,21 @@ +# source: test/sql/aggregate/group/group_by_all_having.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +SELECT * FROM (SELECT 1) t0(c0) GROUP BY c0 HAVING c0>0 +-- +ok +== +SELECT c0 FROM (SELECT 1) t0(c0) GROUP BY ALL HAVING c0>0 +-- +ok +== +SELECT c0 FROM (SELECT 1, 1 UNION ALL SELECT 1, 2) t0(c0, c1) GROUP BY ALL ORDER BY c0 +-- +ok +== +SELECT c0 FROM (SELECT 1, 1 UNION ALL SELECT 1, 2) t0(c0, c1) GROUP BY ALL HAVING c1>0 ORDER BY c0 +-- +ok +== diff --git a/parser/testdata/corpus/sql/aggregate/group/group_by_all_order.test b/parser/testdata/corpus/sql/aggregate/group/group_by_all_order.test new file mode 100644 index 0000000..d2cf439 --- /dev/null +++ b/parser/testdata/corpus/sql/aggregate/group/group_by_all_order.test @@ -0,0 +1,25 @@ +# source: test/sql/aggregate/group/group_by_all_order.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +SELECT SUM(i) FROM integers +-- +ok +== +SELECT SUM(i) FROM integers GROUP BY ALL +-- +ok +== +SELECT SUM(i) FROM integers GROUP BY ALL ORDER BY ALL +-- +ok +== +SELECT SUM(i) FROM integers GROUP BY ALL ORDER BY g +-- +ok +== +SELECT g, SUM(i) FROM integers GROUP BY ALL ORDER BY g +-- +ok +== diff --git a/parser/testdata/corpus/sql/aggregate/group/group_by_limits.test b/parser/testdata/corpus/sql/aggregate/group/group_by_limits.test new file mode 100644 index 0000000..557dc4c --- /dev/null +++ b/parser/testdata/corpus/sql/aggregate/group/group_by_limits.test @@ -0,0 +1,93 @@ +# source: test/sql/aggregate/group/group_by_limits.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +CREATE TABLE t(t_k0 TINYINT); +-- +ok +== +INSERT INTO t VALUES (-128), (127); +-- +ok +== +SELECT t_k0, COUNT(*) FROM t GROUP BY t_k0 ORDER BY 1; +-- +ok +== +DROP TABLE t; +-- +ok +== +CREATE TABLE t(t_k0 SMALLINT); +-- +ok +== +INSERT INTO t VALUES (-32768), (32767); +-- +ok +== +CREATE TABLE t(t_k0 INTEGER); +-- +ok +== +INSERT INTO t VALUES (-2147483648), (2147483647); +-- +ok +== +CREATE TABLE t(t_k0 BIGINT); +-- +ok +== +INSERT INTO t VALUES (-9223372036854775808), (9223372036854775807); +-- +ok +== +CREATE TABLE t(t_k0 HUGEINT); +-- +ok +== +INSERT INTO t VALUES (-170141183460469231731687303715884105728), (170141183460469231731687303715884105727); +-- +ok +== +CREATE TABLE t(t_k0 UTINYINT); +-- +ok +== +INSERT INTO t VALUES (0), (255); +-- +ok +== +CREATE TABLE t(t_k0 USMALLINT); +-- +ok +== +INSERT INTO t VALUES (0), (65535); +-- +ok +== +CREATE TABLE t(t_k0 UINTEGER); +-- +ok +== +INSERT INTO t VALUES (0), (4294967295); +-- +ok +== +CREATE TABLE t(t_k0 UBIGINT); +-- +ok +== +INSERT INTO t VALUES (0), (18446744073709551615); +-- +ok +== +CREATE TABLE t(t_k0 UHUGEINT); +-- +ok +== +INSERT INTO t VALUES (0), ('340282366920938463463374607431768211455'::UHUGEINT); +-- +ok +== diff --git a/parser/testdata/corpus/sql/aggregate/group/test_group_by.test b/parser/testdata/corpus/sql/aggregate/group/test_group_by.test new file mode 100644 index 0000000..ab7e5e3 --- /dev/null +++ b/parser/testdata/corpus/sql/aggregate/group/test_group_by.test @@ -0,0 +1,117 @@ +# source: test/sql/aggregate/group/test_group_by.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +INSERT INTO test VALUES (11, 22), (13, 22), (12, 21) +-- +ok +== +SELECT SUM(SUM(41)), COUNT(*); +-- +ok +== +SELECT SUM(a), COUNT(*), AVG(a) FROM test; +-- +ok +== +SELECT COUNT(*) FROM test; +-- +ok +== +SELECT SUM(a), COUNT(*) FROM test WHERE a = 11; +-- +ok +== +SELECT SUM(a), SUM(b), SUM(a) + SUM (b) FROM test; +-- +ok +== +SELECT SUM(a+2), SUM(a) + 2 * COUNT(*) FROM test; +-- +ok +== +SELECT b, SUM(a), SUM(a+2), AVG(a) FROM test GROUP BY b ORDER BY b; +-- +ok +== +SELECT b, SUM(a) FROM test GROUP BY b ORDER BY COUNT(a); +-- +ok +== +SELECT b, SUM(a) FROM test GROUP BY b ORDER BY COUNT(a) DESC; +-- +ok +== +SELECT b, SUM(a), COUNT(*), SUM(a+2) FROM test GROUP BY b ORDER BY b; +-- +ok +== +SELECT b % 2 AS f, SUM(a) FROM test GROUP BY f ORDER BY f; +-- +ok +== +SELECT b, SUM(a), COUNT(*), SUM(a+2) FROM test WHERE a <= 12 GROUP BY b ORDER BY b; +-- +ok +== +SELECT b % 2 AS f, COUNT(SUM(a)) FROM test GROUP BY f; +-- +ok +== +INSERT INTO test VALUES (12, 21), (12, 21), (12, 21) +-- +ok +== +SELECT i, i + 10 FROM integers GROUP BY i ORDER BY i +-- +ok +== +SELECT i, SUM(j), j FROM integers GROUP BY i ORDER BY i +-- +ok +== +SELECT i, SUM(j), FIRST(j) FROM integers GROUP BY i ORDER BY i +-- +ok +== +SELECT i, SUM(j), LAST(j) FROM integers GROUP BY i ORDER BY i +-- +ok +== +SELECT 1 AS k, SUM(i) FROM integers GROUP BY k ORDER BY 2; +-- +ok +== +SELECT 1 AS i, SUM(i) FROM integers GROUP BY i ORDER BY 2; +-- +ok +== +SELECT i % 2 AS k, SUM(i) FROM integers GROUP BY k, k ORDER BY 1; +-- +ok +== +DROP TABLE integers; +-- +ok +== +INSERT INTO integers VALUES (1), (2), (3), (NULL); +-- +ok +== +SELECT i, SUM(i) FROM integers GROUP BY i ORDER BY 1; +-- +ok +== +SELECT i, i % 2 AS i, SUM(i) FROM integers GROUP BY i ORDER BY 1; +-- +ok +== +SELECT 1 AS k, SUM(i) FROM integers GROUP BY k+1 ORDER BY 2; +-- +ok +== +SELECT test.b, SUM(a) FROM test GROUP BY b ORDER BY COUNT(a) DESC; +-- +ok +== diff --git a/parser/testdata/corpus/sql/aggregate/group/test_group_by_alias.test b/parser/testdata/corpus/sql/aggregate/group/test_group_by_alias.test new file mode 100644 index 0000000..e383175 --- /dev/null +++ b/parser/testdata/corpus/sql/aggregate/group/test_group_by_alias.test @@ -0,0 +1,57 @@ +# source: test/sql/aggregate/group/test_group_by_alias.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +CREATE TABLE integers(i INTEGER) +-- +ok +== +INSERT INTO integers VALUES (1), (2), (3), (NULL) +-- +ok +== +SELECT i % 2 AS k, SUM(i) FROM integers WHERE i IS NOT NULL GROUP BY k HAVING k>0; +-- +ok +== +SELECT i % 2 AS k, SUM(i) FROM integers WHERE i IS NOT NULL GROUP BY k HAVING i%2>0; +-- +ok +== +SELECT i % 2 AS k, SUM(i) FROM integers WHERE i IS NOT NULL GROUP BY 1 HAVING i%2>0; +-- +ok +== +SELECT i % 2 AS k, SUM(i) FROM integers WHERE i IS NOT NULL GROUP BY 42 HAVING i%2>0; +-- +ok +== +SELECT i, i % 2 AS i, SUM(i) FROM integers GROUP BY i ORDER BY i, 3; +-- +ok +== +SELECT i, i % 2 AS k, SUM(i) FROM integers GROUP BY i ORDER BY k, 3; +-- +ok +== +SELECT i, i % 2 AS k, SUM(i) FROM integers GROUP BY i ORDER BY i; +-- +ok +== +SELECT i % 2 AS k, SUM(k) FROM integers GROUP BY k ORDER BY ALL +-- +ok +== +SELECT i, SUM(i) FROM integers GROUP BY i ORDER BY i +-- +ok +== +SELECT (10-i) AS k, SUM(i) FROM integers GROUP BY k ORDER BY i; +-- +ok +== +SELECT (10-i) AS k, SUM(i) FROM integers GROUP BY k ORDER BY FIRST(i); +-- +ok +== diff --git a/parser/testdata/corpus/sql/aggregate/group/test_group_by_error.test b/parser/testdata/corpus/sql/aggregate/group/test_group_by_error.test new file mode 100644 index 0000000..9c6f1bd --- /dev/null +++ b/parser/testdata/corpus/sql/aggregate/group/test_group_by_error.test @@ -0,0 +1,34 @@ +# source: test/sql/aggregate/group/test_group_by_error.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +CREATE TABLE tbl(i INT) +-- +ok +== +SELECT * FROM tbl GROUP BY DEFAULT +-- +ok +== +SELECT * FROM tbl GROUP BY SUM(41) +-- +ok +== +CREATE TABLE v3 (v4 DOUBLE, v5 INTEGER); +-- +ok +== +SELECT + v4, + TRY(v5 / v5) AS result +FROM v3 +GROUP BY v4 +HAVING ( + SELECT SUM(v5) + FROM v3 + WHERE v5 IS NOT NULL +) +-- +ok +== diff --git a/parser/testdata/corpus/sql/aggregate/group/test_group_by_large_string.test b/parser/testdata/corpus/sql/aggregate/group/test_group_by_large_string.test new file mode 100644 index 0000000..a92f332 --- /dev/null +++ b/parser/testdata/corpus/sql/aggregate/group/test_group_by_large_string.test @@ -0,0 +1,17 @@ +# source: test/sql/aggregate/group/test_group_by_large_string.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +CREATE TABLE test (a VARCHAR, b INTEGER); +-- +ok +== +INSERT INTO test VALUES ('helloworld', 22), ('thisisalongstring', 22), ('helloworld', 21) +-- +ok +== +SELECT a, SUM(b) FROM test GROUP BY a ORDER BY a +-- +ok +== diff --git a/parser/testdata/corpus/sql/aggregate/group/test_group_by_multi_column.test b/parser/testdata/corpus/sql/aggregate/group/test_group_by_multi_column.test new file mode 100644 index 0000000..ad5844f --- /dev/null +++ b/parser/testdata/corpus/sql/aggregate/group/test_group_by_multi_column.test @@ -0,0 +1,13 @@ +# source: test/sql/aggregate/group/test_group_by_multi_column.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +INSERT INTO integers VALUES (1, 1, 2), (1, 2, 2), (1, 1, 2), (2, 1, 2), (1, 2, 4), (1, 2, NULL); +-- +ok +== +SELECT i, j, SUM(k), COUNT(*), COUNT(k) FROM integers GROUP BY i, j ORDER BY 1, 2 +-- +ok +== diff --git a/parser/testdata/corpus/sql/aggregate/group/test_group_by_nested.test b/parser/testdata/corpus/sql/aggregate/group/test_group_by_nested.test new file mode 100644 index 0000000..be63930 --- /dev/null +++ b/parser/testdata/corpus/sql/aggregate/group/test_group_by_nested.test @@ -0,0 +1,178 @@ +# source: test/sql/aggregate/group/test_group_by_nested.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +CREATE {storage_type} intlists AS SELECT * FROM (VALUES + (21, [1]), + (22, [NULL]), + (23, []), + (24, [2, 3]), + (NULL::INTEGER, [13]), + (32, [NULL]), + (34, [2, 3]) + ) lv(v, k); +-- +error: Parser Error: syntax error at or near "{" +== +SELECT k, SUM(v) FROM intlists GROUP BY k ORDER BY 2 +-- +ok +== +SELECT k, LEAST(v, 21) as c, SUM(v) FROM intlists GROUP BY k, c ORDER BY 2, 3 +-- +ok +== +CREATE {storage_type} strlists AS SELECT * FROM (VALUES + (21, ['a']), + (22, [NULL]), + (23, []), + (24, ['Branta Canadensis', 'c']), + (NULL::INTEGER, ['Somateria mollissima']), + (32, [NULL]), + (34, ['Branta Canadensis', 'c']) + ) lv(v, k); +-- +error: Parser Error: syntax error at or near "{" +== +SELECT k, SUM(v) FROM strlists GROUP BY k ORDER BY 2 +-- +ok +== +SELECT k, LEAST(v, 21) as c, SUM(v) FROM strlists GROUP BY k, c ORDER BY 2, 3 +-- +ok +== +CREATE {storage_type} structs AS SELECT * FROM (VALUES + (21, {'x': 1, 'y': 'a'}), + (22, {'x': NULL, 'y': NULL}), + (23, {'x': 0, 'y': ''}), + (24, {'x': 2, 'y': 'c'}), + (NULL::INTEGER, {'x': 13, 'y': 'Somateria mollissima'}), + (32, {'x': NULL, 'y': NULL}), + (34, {'x': 2, 'y': 'c'}) + ) sv(v, k); +-- +error: Parser Error: syntax error at or near "{" +== +SELECT k, SUM(v) FROM structs GROUP BY k ORDER BY 2 +-- +ok +== +SELECT k, LEAST(v, 21) as c, SUM(v) FROM structs GROUP BY k, c ORDER BY 2, 3 +-- +ok +== +CREATE {storage_type} struct_lint_lstr AS SELECT * FROM (VALUES + (21, {'x': [1], 'y': ['a']}), + (22, {'x': [NULL], 'y': [NULL]}), + (23, {'x': [], 'y': []}), + (24, {'x': [2, 3], 'y': ['Branta Canadensis', 'c']}), + (NULL::INTEGER, {'x': [13], 'y': ['Somateria mollissima']}), + (32, {'x': [NULL], 'y': [NULL]}), + (34, {'x': [2, 3], 'y': ['Branta Canadensis', 'c']}) + ) sv(v, k); +-- +error: Parser Error: syntax error at or near "{" +== +SELECT k, SUM(v) FROM struct_lint_lstr +GROUP BY k +ORDER BY 2 +-- +ok +== +SELECT k, LEAST(v, 21) as c, SUM(v) FROM struct_lint_lstr +GROUP BY k, c +ORDER BY 2, 3 +-- +ok +== +CREATE {storage_type} r2l3r4l5i4i2l3v AS SELECT * FROM (VALUES + (21, {'x': [{'l4': [51], 'i4': 41}], 'y': ['a']}), + (22, {'x': [NULL], 'y': [NULL]}), + (23, {'x': [], 'y': []}), + (24, {'x': [{'l4': [52, 53], 'i4': 42}, {'l4': [54, 55], 'i4': 43}], 'y': ['Branta Canadensis', 'c']}), + (NULL::INTEGER, {'x': [{'l4': [62], 'i4': 47}], 'y': ['Somateria mollissima']}), + (32, {'x': [NULL], 'y': [NULL]}), + (34, {'x': [{'l4': [52, 53], 'i4': 42}, {'l4': [54, 55], 'i4': 43}], 'y': ['Branta Canadensis', 'c']}) + ) sv(v, k); +-- +error: Parser Error: syntax error at or near "{" +== +SELECT k, SUM(v) FROM r2l3r4l5i4i2l3v +GROUP BY k +ORDER BY 2 +-- +ok +== +SELECT k, LEAST(v, 21) as c, SUM(v) FROM r2l3r4l5i4i2l3v +GROUP BY k, c +ORDER BY 2, 3 +-- +ok +== +CREATE {storage_type} longlists AS +SELECT * +FROM ((VALUES + (21, [1]), + (22, [NULL]), + (23, []), + (NULL::INTEGER, [13]), + (32, [NULL]) + ) +UNION ALL + select 24 as i, list(r) as pk from range(2000) tbl(r) +UNION ALL + select 34 as i, list(r) as pk from range(2000) tbl(r) +) sv(v, k); +-- +error: Parser Error: syntax error at or near "{" +== +SELECT k, SUM(v) FROM longlists +GROUP BY k +ORDER BY 2 +-- +ok +== +SELECT k, LEAST(v, 21) as c, SUM(v) FROM longlists +GROUP BY k, c +ORDER BY 2, 3 +-- +ok +== +select [1,2,3] a, count(*) +from range(5) tbl(b) +group by a; +-- +ok +== +select {'x': 1, 'y': 2, 'z': 3} a, count(*) +from range(5) tbl(b) +group by a; +-- +ok +== +DROP {storage_type} intlists; +-- +error: Parser Error: syntax error at or near "{" +== +DROP {storage_type} strlists; +-- +error: Parser Error: syntax error at or near "{" +== +DROP {storage_type} structs; +-- +error: Parser Error: syntax error at or near "{" +== +DROP {storage_type} struct_lint_lstr; +-- +error: Parser Error: syntax error at or near "{" +== +DROP {storage_type} r2l3r4l5i4i2l3v; +-- +error: Parser Error: syntax error at or near "{" +== +DROP {storage_type} longlists; +-- +error: Parser Error: syntax error at or near "{" +== diff --git a/parser/testdata/corpus/sql/aggregate/group/test_group_by_null_length.test b/parser/testdata/corpus/sql/aggregate/group/test_group_by_null_length.test new file mode 100644 index 0000000..9fa6ae6 --- /dev/null +++ b/parser/testdata/corpus/sql/aggregate/group/test_group_by_null_length.test @@ -0,0 +1,49 @@ +# source: test/sql/aggregate/group/test_group_by_null_length.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +CREATE TABLE t0(c0 INTEGER); +-- +ok +== +SELECT LENGTH(NULL) FROM t0 GROUP BY NULL; +-- +ok +== +SELECT c0, LENGTH(NULL) FROM t0 GROUP BY c0; +-- +ok +== +SELECT NULL, LENGTH(NULL) FROM t0 GROUP BY NULL; +-- +ok +== +INSERT INTO t0(c0) VALUES (2), (3); +-- +ok +== +SELECT c0, LENGTH(NULL) FROM t0 GROUP BY c0 ORDER BY c0; +-- +ok +== +SELECT NULL FROM t0 GROUP BY NULL; +-- +ok +== +SELECT UPPER(NULL) FROM t0 GROUP BY NULL; +-- +ok +== +SELECT LOWER(NULL) FROM t0 GROUP BY NULL; +-- +ok +== +SELECT LENGTH(NULL::VARCHAR) FROM t0 GROUP BY NULL::VARCHAR; +-- +ok +== +SELECT LENGTH(NULL) + 0 FROM t0 GROUP BY NULL; +-- +ok +== diff --git a/parser/testdata/corpus/sql/aggregate/group/test_group_null.test b/parser/testdata/corpus/sql/aggregate/group/test_group_null.test new file mode 100644 index 0000000..62e9b7c --- /dev/null +++ b/parser/testdata/corpus/sql/aggregate/group/test_group_null.test @@ -0,0 +1,13 @@ +# source: test/sql/aggregate/group/test_group_null.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +INSERT INTO integers VALUES (3, 4), (NULL, 4), (2, 4); +-- +ok +== +SELECT i, SUM(j) FROM integers GROUP BY i ORDER BY i +-- +ok +== diff --git a/parser/testdata/corpus/sql/aggregate/grouping_sets/cube.test b/parser/testdata/corpus/sql/aggregate/grouping_sets/cube.test new file mode 100644 index 0000000..6dac597 --- /dev/null +++ b/parser/testdata/corpus/sql/aggregate/grouping_sets/cube.test @@ -0,0 +1,74 @@ +# source: test/sql/aggregate/grouping_sets/cube.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +create table students (course VARCHAR, type VARCHAR, highest_grade INTEGER); +-- +ok +== +insert into students + (course, type, highest_grade) + values + ('CS', 'Bachelor', 8), + ('CS', 'Bachelor', 8), + ('CS', 'PhD', 10), + ('Math', 'Masters', NULL), + ('CS', NULL, 7), + ('CS', NULL, 7), + ('Math', NULL, 8); +-- +ok +== +select course, count(*) from students group by cube (course) order by 1, 2; +-- +ok +== +select course, type, count(*) from students group by cube (course, type) order by 1, 2, 3; +-- +ok +== +select course, type, count(*) from students group by cube ((course, type)) order by 1, 2, 3; +-- +ok +== +select course, type, count(*) from students group by cube (course, type, course) order by 1, 2, 3; +-- +ok +== +select course, type, highest_grade, count(*) from students group by cube (course, type, highest_grade) order by 1, 2, 3, 4; +-- +ok +== +select course, type, count(*) from students group by cube (course), cube (type) order by 1, 2, 3; +-- +ok +== +select course as crs, type, count(*) from students group by cube (crs), (), type order by 1, 2, 3; +-- +ok +== +select course as crs, type as tp, count(*) from students group by grouping sets (cube (crs)), (), tp order by 1, 2, 3; +-- +ok +== +select course, count(*) from students group by cube () order by 1, 2; +-- +error: Parser Error: CUBE or ROLLUP column list cannot be empty +== +select course, count(*) from students group by cube (cube (course)) order by 1, 2; +-- +ok +== +select course, count(*) from students group by cube (grouping_sets (course)) order by 1, 2; +-- +ok +== +select course, type, count(*) from students group by cube (course, type, course, type, course, type, course, type, course, type, course, type, (course, type), (course, type), course, type) order by 1, 2, 3; +-- +error: Parser Error: Maximum grouping set count of 65535 exceeded +== +select course, type, count(*) from students group by cube (course, type, course, type, course), cube(type, course, type, course), cube(type, course, type, (course, type), (course, type), course, type) order by 1, 2, 3; +-- +error: Parser Error: Maximum grouping set count of 65535 exceeded +== diff --git a/parser/testdata/corpus/sql/aggregate/grouping_sets/cube.test.metadata.json b/parser/testdata/corpus/sql/aggregate/grouping_sets/cube.test.metadata.json new file mode 100644 index 0000000..4aa0228 --- /dev/null +++ b/parser/testdata/corpus/sql/aggregate/grouping_sets/cube.test.metadata.json @@ -0,0 +1,7 @@ +{ + "todo": { + "67783085c99e617e": "transformer-raised parser error: upstream rejects in the transformer, not the grammar; expected to clear as transformers land (milestones 3-5)", + "6ec4e705eca4140d": "transformer-raised parser error: upstream rejects in the transformer, not the grammar; expected to clear as transformers land (milestones 3-5)", + "dccfdc31b78ecfda": "transformer-raised parser error: upstream rejects in the transformer, not the grammar; expected to clear as transformers land (milestones 3-5)" + } +} diff --git a/parser/testdata/corpus/sql/aggregate/grouping_sets/grouping.test b/parser/testdata/corpus/sql/aggregate/grouping_sets/grouping.test new file mode 100644 index 0000000..de86e87 --- /dev/null +++ b/parser/testdata/corpus/sql/aggregate/grouping_sets/grouping.test @@ -0,0 +1,106 @@ +# source: test/sql/aggregate/grouping_sets/grouping.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +create table students (course VARCHAR, type VARCHAR); +-- +ok +== +insert into students + (course, type) + values + ('CS', 'Bachelor'), + ('CS', 'Bachelor'), + ('CS', 'PhD'), + ('Math', 'Masters'), + ('CS', NULL), + ('CS', NULL), + ('Math', NULL); +-- +ok +== +SELECT GROUPING(course), course, COUNT(*) FROM students GROUP BY course ORDER BY 1, 2, 3; +-- +ok +== +SELECT GROUPING_ID(course), course, COUNT(*) FROM students GROUP BY course ORDER BY 1, 2, 3; +-- +ok +== +SELECT GROUPING(course), GROUPING(type), course, type, COUNT(*) FROM students GROUP BY course, type ORDER BY 1, 2, 3, 4, 5; +-- +ok +== +SELECT GROUPING(course), GROUPING(type), course, type, COUNT(*) FROM students GROUP BY CUBE(course, type) ORDER BY 1, 2, 3, 4, 5; +-- +ok +== +SELECT GROUPING(course, type), course, type, COUNT(*) FROM students GROUP BY CUBE(course, type) ORDER BY 1, 2, 3, 4; +-- +ok +== +SELECT GROUPING(), course, type, COUNT(*) FROM students GROUP BY CUBE(course, type) ORDER BY 1, 2, 3, 4; +-- +ok +== +SELECT GROUPING(course), GROUPING(type), GROUPING(course)+GROUPING(type), course, type, COUNT(*) FROM students GROUP BY CUBE(course, type) ORDER BY 1, 2, 3, 4, 5; +-- +ok +== +SELECT GROUPING(course, type, course, course, type, type, course), course, type, COUNT(*) FROM students GROUP BY CUBE(course, type) ORDER BY 1, 2, 3, 4; +-- +ok +== +SELECT GROUPING(students.course), GROUPING(students.type), GROUPING(course)+GROUPING(type), course, type, COUNT(*) FROM students GROUP BY CUBE(course, type) ORDER BY 1, 2, 3, 4, 5; +-- +ok +== +SELECT GROUPING(course), GROUPING(type), GROUPING(course)+GROUPING(type), course, type, COUNT(*) FROM students GROUP BY CUBE(students.course, students.type) ORDER BY 1, 2, 3, 4, 5; +-- +ok +== +SELECT GROUPING(course), GROUPING(type), course, type, COUNT(*) FROM students GROUP BY CUBE(course, type) HAVING GROUPING(course)=0 ORDER BY 1, 2, 3, 4, 5; +-- +ok +== +SELECT GROUPING(course), GROUPING(type), course, type, COUNT(*) FROM students GROUP BY CUBE(course, type) HAVING GROUPING(students.course)=0 ORDER BY 1, 2, 3, 4, 5; +-- +ok +== +SELECT course, type, COUNT(*) FROM students GROUP BY CUBE(course, type) ORDER BY GROUPING(course), GROUPING(type), 1, 2, 3; +-- +ok +== +SELECT GROUPING(); +-- +ok +== +SELECT GROUPING() FROM students; +-- +ok +== +SELECT GROUPING(NULL) FROM students; +-- +ok +== +SELECT GROUPING(course) FROM students; +-- +ok +== +SELECT GROUPING(course) FROM students GROUP BY (); +-- +ok +== +SELECT GROUPING(type) FROM students GROUP BY course; +-- +ok +== +SELECT GROUPING(course) FROM students WHERE GROUPING(course)=0 GROUP BY course; +-- +ok +== +SELECT GROUPING(course, course, course, course, course, course, course, course, course, course, course, course, course, course, course, course, course, course, course, course, course, course, course, course, course, course, course, course, course, course, course, course, course, course, course, course, course, course, course, course, course, course, course, course, course, course, course, course, course, course, course, course, course, course, course, course, course, course, course, course, course, course, course, course, course, course, course, course, course, course, course, course, course, course, course, course, course, course, course, course), course, type, COUNT(*) FROM students GROUP BY CUBE(course, type) ORDER BY 1, 2, 3, 4; +-- +ok +== diff --git a/parser/testdata/corpus/sql/aggregate/grouping_sets/grouping_sets.test b/parser/testdata/corpus/sql/aggregate/grouping_sets/grouping_sets.test new file mode 100644 index 0000000..c60804a --- /dev/null +++ b/parser/testdata/corpus/sql/aggregate/grouping_sets/grouping_sets.test @@ -0,0 +1,127 @@ +# source: test/sql/aggregate/grouping_sets/grouping_sets.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +select 1 from students group by (); +-- +ok +== +select count(*) from students group by (); +-- +ok +== +select course, type, count(*) from students group by course, type order by 1, 2, 3; +-- +ok +== +select course, type, count(*) from students group by (course, type) order by 1, 2, 3; +-- +ok +== +select course, count(*) from students group by (), course, () ORDER BY 1; +-- +ok +== +select count(*), course, type + from students + group by grouping sets ((course), (type)) + order by 1, 2, 3; +-- +ok +== +select count(*), course, type + from students + group by grouping sets (course), grouping sets(type) + order by 1, 2, 3; +-- +ok +== +select count(*), course, type + from students + group by course, grouping sets(type) + order by 1, 2, 3; +-- +ok +== +select count(*), course, type + from students + group by course, grouping sets(type, ()) + order by 1, 2, 3; +-- +ok +== +select count(*), course, type + from students + group by grouping sets((course, type), (course)) + order by 1, 2, 3; +-- +ok +== +select count(*), course, type + from students + group by grouping sets (grouping sets(course), grouping sets(type)) + order by 1, 2, 3; +-- +ok +== +select count(*), course, type + from students + group by grouping sets (grouping sets(course, ()), grouping sets(type)) + order by 1, 2, 3; +-- +ok +== +select count(*), course, type + from students + group by grouping sets ((course), (), (type)) + order by 1, 2, 3; +-- +ok +== +select count(*), course, type + from students + group by grouping sets(course, ()), grouping sets(type) + order by 1, 2, 3; +-- +ok +== +select count(*), course, type + from students + group by grouping sets(course, ()), type + order by 1, 2, 3; +-- +ok +== +select count(*), course, type + from students + group by grouping sets((course, type), (type)) + order by 1, 2, 3; +-- +ok +== +select count(*), course, type + from students + group by grouping sets((2, 3), (3)) + order by 1, 2, 3; +-- +ok +== +select count(*), course AS crs, type AS tp + from students + group by grouping sets((crs, tp), (tp)) + order by 1, 2, 3; +-- +ok +== +select count(*), course, type + from students + group by grouping sets (grouping sets(course, ()), grouping sets(type, ())) + order by 1, 2, 3; +-- +ok +== +select course from students group by (); +-- +ok +== diff --git a/parser/testdata/corpus/sql/aggregate/grouping_sets/grouping_sets_filter.test b/parser/testdata/corpus/sql/aggregate/grouping_sets/grouping_sets_filter.test new file mode 100644 index 0000000..b2a7cda --- /dev/null +++ b/parser/testdata/corpus/sql/aggregate/grouping_sets/grouping_sets_filter.test @@ -0,0 +1,21 @@ +# source: test/sql/aggregate/grouping_sets/grouping_sets_filter.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +SELECT course, COUNT(*) FROM students GROUP BY GROUPING SETS ((), (course)) HAVING course LIKE 'C%' ORDER BY 1, 2; +-- +ok +== +SELECT course, COUNT(*) FROM students GROUP BY GROUPING SETS ((), (course)) HAVING course LIKE 'C%' OR course NOT LIKE 'C%' OR course IS NULL ORDER BY 1, 2; +-- +ok +== +SELECT course, COUNT(*) FROM students GROUP BY GROUPING SETS ((), (course)) HAVING random()<1000 ORDER BY ALL; +-- +ok +== +SELECT course, COUNT(*) FROM students GROUP BY GROUPING SETS ((), (course)) HAVING random()>1000; +-- +ok +== diff --git a/parser/testdata/corpus/sql/aggregate/grouping_sets/issue_3730.test b/parser/testdata/corpus/sql/aggregate/grouping_sets/issue_3730.test new file mode 100644 index 0000000..22e16f2 --- /dev/null +++ b/parser/testdata/corpus/sql/aggregate/grouping_sets/issue_3730.test @@ -0,0 +1,42 @@ +# source: test/sql/aggregate/grouping_sets/issue_3730.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +CREATE TABLE response( + id BIGINT, + response VARCHAR +); +-- +ok +== +INSERT INTO response VALUES + (1,'yes'), + (1,'no'), + (1,'yes'), + (2,'no'), + (2,'no'); +-- +ok +== +CREATE TABLE user_pq( + id BIGINT, + "name" VARCHAR +); +-- +ok +== +INSERT INTO user_pq VALUES + (1,'alice'), + (2,'bob'); +-- +ok +== +SELECT id, response, COUNT(DISTINCT id) +FROM user_pq +JOIN response USING (id) +GROUP BY CUBE (id, response) +ORDER BY 1 NULLS LAST, 2 NULLS LAST, 3 NULLS LAST +-- +ok +== diff --git a/parser/testdata/corpus/sql/aggregate/grouping_sets/multiple_empty_grouping_sets.test b/parser/testdata/corpus/sql/aggregate/grouping_sets/multiple_empty_grouping_sets.test new file mode 100644 index 0000000..b14ed31 --- /dev/null +++ b/parser/testdata/corpus/sql/aggregate/grouping_sets/multiple_empty_grouping_sets.test @@ -0,0 +1,10 @@ +# source: test/sql/aggregate/grouping_sets/multiple_empty_grouping_sets.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +select count(*) +group by grouping sets ((), ()) +-- +ok +== diff --git a/parser/testdata/corpus/sql/aggregate/grouping_sets/rollup.test b/parser/testdata/corpus/sql/aggregate/grouping_sets/rollup.test new file mode 100644 index 0000000..a7427e4 --- /dev/null +++ b/parser/testdata/corpus/sql/aggregate/grouping_sets/rollup.test @@ -0,0 +1,49 @@ +# source: test/sql/aggregate/grouping_sets/rollup.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +select course, count(*) from students group by rollup (course) order by 1, 2; +-- +ok +== +select course, type, count(*) from students group by rollup (course, type) order by 1, 2, 3; +-- +ok +== +select course, type, count(*) from students group by rollup ((course, type)) order by 1, 2, 3; +-- +ok +== +select course, type, count(*) from students group by rollup (course, type, course) order by 1, 2, 3; +-- +ok +== +select course, type, count(*) from students group by grouping sets ((course, type), (course), ()) order by 1, 2, 3; +-- +ok +== +select course, type, count(*) from students group by rollup (course), rollup (type) order by 1, 2, 3; +-- +ok +== +select course as crs, type, count(*) from students group by rollup (crs), (), type order by 1, 2, 3; +-- +ok +== +select course as crs, type as tp, count(*) from students group by grouping sets (rollup (crs)), (), tp order by 1, 2, 3; +-- +ok +== +select course, count(*) from students group by rollup () order by 1, 2; +-- +error: Parser Error: CUBE or ROLLUP column list cannot be empty +== +select course, count(*) from students group by rollup (rollup (course)) order by 1, 2; +-- +ok +== +select course, count(*) from students group by rollup (grouping_sets (course)) order by 1, 2; +-- +ok +== diff --git a/parser/testdata/corpus/sql/aggregate/grouping_sets/rollup.test.metadata.json b/parser/testdata/corpus/sql/aggregate/grouping_sets/rollup.test.metadata.json new file mode 100644 index 0000000..a994bb0 --- /dev/null +++ b/parser/testdata/corpus/sql/aggregate/grouping_sets/rollup.test.metadata.json @@ -0,0 +1,5 @@ +{ + "todo": { + "8dce076071091b7a": "transformer-raised parser error: upstream rejects in the transformer, not the grammar; expected to clear as transformers land (milestones 3-5)" + } +} diff --git a/parser/testdata/corpus/sql/aggregate/having/having_alias.test b/parser/testdata/corpus/sql/aggregate/having/having_alias.test new file mode 100644 index 0000000..4a28f4c --- /dev/null +++ b/parser/testdata/corpus/sql/aggregate/having/having_alias.test @@ -0,0 +1,37 @@ +# source: test/sql/aggregate/having/having_alias.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +SELECT b, sum(a) AS a +FROM (VALUES (1, 0), (1, 1)) t(a, b) +GROUP BY b +HAVING a > 0 +ORDER BY ALL +-- +ok +== +create table t1(a int); +-- +ok +== +insert into t1 values (42), (84); +-- +ok +== +select a+1 as a from t1 group by a having a=42; +-- +ok +== +create table t2(a int); +-- +ok +== +insert into t2 values (42), (84), (42); +-- +ok +== +select a as b, sum(a) as a from t2 group by b having a=42; +-- +ok +== diff --git a/parser/testdata/corpus/sql/aggregate/having/having_without_groupby.test b/parser/testdata/corpus/sql/aggregate/having/having_without_groupby.test new file mode 100644 index 0000000..207657d --- /dev/null +++ b/parser/testdata/corpus/sql/aggregate/having/having_without_groupby.test @@ -0,0 +1,41 @@ +# source: test/sql/aggregate/having/having_without_groupby.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +SELECT 1 AS one FROM ( + values + (1,2), + (3,2) +) t(a, b) +HAVING 1 < 2; +-- +ok +== +SELECT 1 AS one FROM ( + values + (1,2), + (3,2) +) t(a, b) +HAVING false; +-- +ok +== +select a FROM ( + values + (1,2), + (3,2) +) t(a, b) +HAVING true +-- +ok +== +select sum(a) FROM ( + values + (1,2), + (3,2) +) t(a, b) +HAVING true +-- +ok +== diff --git a/parser/testdata/corpus/sql/aggregate/having/test_having.test b/parser/testdata/corpus/sql/aggregate/having/test_having.test new file mode 100644 index 0000000..ee7ea46 --- /dev/null +++ b/parser/testdata/corpus/sql/aggregate/having/test_having.test @@ -0,0 +1,49 @@ +# source: test/sql/aggregate/having/test_having.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +SELECT b, SUM(a) AS sum FROM test GROUP BY b HAVING b=21 ORDER BY b; +-- +ok +== +SELECT b, SUM(a) FROM test GROUP BY b HAVING SUM(a) < 20 ORDER BY b; +-- +ok +== +SELECT b, SUM(a) AS sum FROM test GROUP BY b HAVING sum < 20 ORDER BY b; +-- +ok +== +SELECT b, SUM(a) AS sum FROM test GROUP BY b HAVING SUM(a) < 20 ORDER BY b; +-- +ok +== +SELECT b, SUM(a) AS sum FROM test GROUP BY b HAVING COUNT(*) = 1 ORDER BY b; +-- +ok +== +SELECT b, SUM(a) FROM test GROUP BY b HAVING SUM(a)+10>28; +-- +ok +== +SELECT b, SUM(a) FROM test GROUP BY b HAVING SUM(a)>(SELECT SUM(t.a)*0.5 FROM test t); +-- +ok +== +SELECT test.b, SUM(a) FROM test GROUP BY test.b HAVING SUM(a)=(SELECT SUM(a) FROM test t WHERE test.b=t.b) ORDER BY test.b; +-- +ok +== +SELECT test.b, SUM(a) FROM test GROUP BY test.b HAVING SUM(a)*2=(SELECT SUM(a)+SUM(t.a) FROM test t WHERE test.b=t.b) ORDER BY test.b +-- +ok +== +SELECT test.b, SUM(a) FROM test GROUP BY test.b HAVING SUM(a)*2+2=(SELECT SUM(a)+SUM(t.a)+COUNT(t.a) FROM test t WHERE test.b=t.b) ORDER BY test.b +-- +ok +== +SELECT test.b, SUM(a) FROM test GROUP BY test.b ORDER BY (SELECT SUM(a) FROM test t WHERE test.b=t.b) DESC; +-- +ok +== diff --git a/parser/testdata/corpus/sql/aggregate/having/test_scalar_having.test b/parser/testdata/corpus/sql/aggregate/having/test_scalar_having.test new file mode 100644 index 0000000..721345a --- /dev/null +++ b/parser/testdata/corpus/sql/aggregate/having/test_scalar_having.test @@ -0,0 +1,61 @@ +# source: test/sql/aggregate/having/test_scalar_having.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +SELECT 42 HAVING 42 > 20 +-- +ok +== +SELECT 42 HAVING 42 > 80 +-- +ok +== +SELECT SUM(42) HAVING AVG(42) > MIN(20) +-- +ok +== +SELECT SUM(42) HAVING SUM(42) > SUM(80) +-- +ok +== +SELECT SUM(42)+COUNT(*)+COUNT(1), 3 HAVING SUM(42)+MAX(20)+AVG(30) > SUM(120)-MIN(100) +-- +ok +== +SELECT SUM(42) HAVING (SELECT SUM(42)) > SUM(80) +-- +ok +== +SELECT a FROM test WHERE a=13 HAVING a > 11 +-- +ok +== +SELECT a FROM test WHERE a=13 HAVING SUM(a) > 11 +-- +ok +== +SELECT SUM(a) FROM test WHERE a=13 HAVING SUM(a) > 11 +-- +ok +== +SELECT SUM(a) FROM test WHERE a=13 HAVING SUM(a) > 20 +-- +ok +== +SELECT SUM(a) FROM test HAVING SUM(a)>10; +-- +ok +== +SELECT SUM(a) FROM test HAVING SUM(a)<10; +-- +ok +== +SELECT SUM(a) FROM test HAVING COUNT(*)>1; +-- +ok +== +SELECT SUM(a) FROM test HAVING COUNT(*)>10; +-- +ok +== diff --git a/parser/testdata/corpus/sql/aggregate/qualify/test_qualify.test b/parser/testdata/corpus/sql/aggregate/qualify/test_qualify.test new file mode 100644 index 0000000..8cac183 --- /dev/null +++ b/parser/testdata/corpus/sql/aggregate/qualify/test_qualify.test @@ -0,0 +1,166 @@ +# source: test/sql/aggregate/qualify/test_qualify.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +CREATE TABLE qt (a INTEGER, b CHAR(1), c INTEGER); +-- +ok +== +INSERT INTO qt VALUES (1, 'A', 1), (2, 'A', 2), (3, 'B', 1), (4, 'B', 2) +-- +ok +== +SELECT * from qt QUALIFY row_number() over (PARTITION BY b ORDER BY c) = 1 ORDER BY b +-- +ok +== +SELECT a, b, c, row_number() over (PARTITION BY b ORDER BY c) as row_num FROM qt QUALIFY row_num = 1 ORDER BY b +-- +ok +== +CREATE TABLE exam (student TEXT, subject TEXT, mark INTEGER); +-- +ok +== +INSERT INTO exam VALUES +('Lily', 'Maths', 65), +('Lily', 'Science', 80), +('Lily', 'english', 70), +('Isabella', 'Maths', 50), +('Isabella', 'Science', 70), +('Isabella', 'english', 90), +('Olivia', 'Maths', 55), +('Olivia', 'Science', 60), +('Olivia', 'english', 89); +-- +ok +== +SELECT * FROM exam QUALIFY rank() OVER (ORDER BY mark desc) = 4 +-- +ok +== +SELECT * FROM exam QUALIFY rank() OVER (PARTITION BY student ORDER BY mark DESC) = 2 ORDER BY student +-- +ok +== +SELECT * FROM exam WINDOW w AS (ORDER BY mark) QUALIFY row_number() OVER w >= 1 AND (rank() OVER w) <= 2 ORDER BY student +-- +ok +== +SELECT * FROM exam QUALIFY first_value(mark) OVER (PARTITION BY student ORDER BY mark) >= 60 order by mark +-- +ok +== +SELECT * FROM exam QUALIFY last_value(mark) OVER (PARTITION BY student ORDER BY mark) >= 85 order by mark +-- +ok +== +CREATE TABLE power (plant TEXT, date DATE, mwh INTEGER); +-- +ok +== +INSERT INTO power VALUES +('Boston', '2019-01-02', 564337), +('Boston', '2019-01-03', 507405), +('Boston', '2019-01-04', 528523), +('Boston', '2019-01-05', 469538), +('Boston', '2019-01-06', 474163), +('Boston', '2019-01-07', 507213), +('Boston', '2019-01-08', 613040), +('Boston', '2019-01-09', 582588), +('Boston', '2019-01-10', 499506), +('Boston', '2019-01-11', 482014), +('Boston', '2019-01-12', 486134), +('Boston', '2019-01-13', 531518), +('Worcester', '2019-01-02', 118860), +('Worcester', '2019-01-03', 101977), +('Worcester', '2019-01-04', 106054), +('Worcester', '2019-01-05', 92182), +('Worcester', '2019-01-06', 94492), +('Worcester', '2019-01-07', 99932), +('Worcester', '2019-01-08', 118854), +('Worcester', '2019-01-09', 113506), +('Worcester', '2019-01-10', 96644), +('Worcester', '2019-01-11', 93806), +('Worcester', '2019-01-12', 98963), +('Worcester', '2019-01-13', 107170); +-- +ok +== +SELECT * FROM power QUALIFY rank() OVER (PARTITION BY plant ORDER BY date DESC) = 2 ORDER BY plant +-- +ok +== +SELECT * FROM (SELECT plant, date, avg(mwh) OVER (PARTITION BY plant ORDER BY date ASC RANGE BETWEEN INTERVAL 3 DAYS PRECEDING AND INTERVAL 3 DAYS FOLLOWING) AS avgmwh FROM power +ORDER BY plant, avgmwh DESC) QUALIFY row_number() OVER (PARTITION BY plant ORDER BY avgmwh DESC) = 1 ORDER BY plant +-- +ok +== +SELECT b, SUM(a) AS sum FROM test GROUP BY b QUALIFY row_number() OVER (PARTITION BY b) >= 1 AND sum < 20 ORDER BY b; +-- +ok +== +SELECT b, SUM(a) AS sum FROM test GROUP BY b QUALIFY row_number() OVER (PARTITION BY b) > sum * 10; +-- +ok +== +SELECT * FROM qt QUALIFY row_number() OVER (PARTITION BY b ORDER BY c) = (SELECT max(c) FROM qt) ORDER BY b; +-- +ok +== +CREATE TABLE tenk1 (unique1 int4, unique2 int4, two int4, four int4, ten int4, twenty int4, hundred int4, thousand int4, twothousand int4, fivethous int4, tenthous int4, odd int4, even int4, stringu1 varchar, stringu2 varchar, string4 varchar) +-- +ok +== +insert into tenk1 values (8800,0,0,0,0,0,0,800,800,3800,8800,0,1,'MAAAAA','AAAAAA','AAAAxx'), (1891,1,1,3,1,11,91,891,1891,1891,1891,182,183,'TUAAAA','BAAAAA','HHHHxx'), (3420,2,0,0,0,0,20,420,1420,3420,3420,40,41,'OBAAAA','CAAAAA','OOOOxx'), (9850,3,0,2,0,10,50,850,1850,4850,9850,100,101,'WOAAAA','DAAAAA','VVVVxx'), (7164,4,0,0,4,4,64,164,1164,2164,7164,128,129,'OPAAAA','EAAAAA','AAAAxx'), (8009,5,1,1,9,9,9,9,9,3009,8009,18,19,'BWAAAA','FAAAAA','HHHHxx'), (5057,6,1,1,7,17,57,57,1057,57,5057,114,115,'NMAAAA','GAAAAA','OOOOxx'), (6701,7,1,1,1,1,1,701,701,1701,6701,2,3,'TXAAAA','HAAAAA','VVVVxx'), (4321,8,1,1,1,1,21,321,321,4321,4321,42,43,'FKAAAA','IAAAAA','AAAAxx'), (3043,9,1,3,3,3,43,43,1043,3043,3043,86,87,'BNAAAA','JAAAAA','HHHHxx') +-- +ok +== +SELECT unique1 FROM tenk1 QUALIFY cast(cume_dist() OVER (PARTITION BY four ORDER BY ten)*10 as integer) = 5 order by four, ten +-- +ok +== +SELECT unique1 FROM tenk1 QUALIFY first_value(ten) OVER (PARTITION BY four ORDER BY ten) = 1 order by four, ten +-- +ok +== +SELECT unique1 FROM tenk1 qualify lead(ten * 2, 1, -1) OVER (PARTITION BY four ORDER BY ten) = -1 order by four, ten +-- +ok +== +SELECT * +FROM ( + SELECT b FROM test as t + GROUP BY b + QUALIFY rank() OVER (PARTITION BY t.b) = 1 +) +QUALIFY row_number() OVER (PARTITION BY b) = 1 +ORDER BY 1 +-- +ok +== +SELECT * FROM test QUALIFY row_number() OVER (PARTITION BY test.b) = (SELECT max(a) FROM qt GROUP BY qt.b QUALIFY rank() OVER (PARTITION BY qt.b) = 1 order by qt.b limit 1) +-- +ok +== +SELECT * FROM exam WINDOW w AS (ORDER BY mark) QUALIFY row_number() OVER w = 1 +-- +ok +== +SELECT * FROM exam QUALIFY row_number() OVER w = 1 WINDOW w AS (ORDER BY mark) +-- +error: Parser Error: syntax error at or near "WINDOW" +== +SELECT b, avg(a) AS avga FROM test GROUP BY b QUALIFY avga > 10 +-- +ok +== +SELECT b FROM test QUALIFY avga() > 10 +-- +ok +== +SELECT b, SUM(a) FROM test GROUP BY b QUALIFY row_number() OVER (PARTITION BY b) > sum; +-- +ok +== diff --git a/parser/testdata/corpus/sql/aggregate/qualify/test_qualify_macro.test b/parser/testdata/corpus/sql/aggregate/qualify/test_qualify_macro.test new file mode 100644 index 0000000..e119770 --- /dev/null +++ b/parser/testdata/corpus/sql/aggregate/qualify/test_qualify_macro.test @@ -0,0 +1,29 @@ +# source: test/sql/aggregate/qualify/test_qualify_macro.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +PRAGMA disable_checkpoint_on_shutdown +-- +ok +== +CREATE MACRO plus1(x) AS (x + (SELECT COUNT(*) FROM (SELECT b, SUM(test.a) FROM test GROUP BY b QUALIFY row_number() OVER (PARTITION BY b) = 1))) +-- +ok +== +SELECT plus1(3) +-- +ok +== +SELECT plus1(5) +-- +ok +== +DROP MACRO plus1 +-- +ok +== +SELECT plus1(2) +-- +ok +== diff --git a/parser/testdata/corpus/sql/aggregate/qualify/test_qualify_view.test b/parser/testdata/corpus/sql/aggregate/qualify/test_qualify_view.test new file mode 100644 index 0000000..66058fd --- /dev/null +++ b/parser/testdata/corpus/sql/aggregate/qualify/test_qualify_view.test @@ -0,0 +1,41 @@ +# source: test/sql/aggregate/qualify/test_qualify_view.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +CREATE SCHEMA test; +-- +ok +== +CREATE TABLE test.t (a INTEGER, b INTEGER); +-- +ok +== +INSERT INTO test.t VALUES (11, 22), (13, 22), (12, 21) +-- +ok +== +CREATE VIEW test.v AS SELECT * FROM test.t QUALIFY row_number() OVER (PARTITION BY b) = 1; +-- +ok +== +SELECT b, SUM(a) +FROM test.v +GROUP BY b +QUALIFY row_number() OVER (PARTITION BY b) = 1 +ORDER BY ALL +-- +ok +== +DROP TABLE test.t +-- +ok +== +DROP TABLE test.t CASCADE; +-- +ok +== +SELECT * FROM test.v +-- +ok +== diff --git a/parser/testdata/corpus/sql/aggregate/quantile_fun.test b/parser/testdata/corpus/sql/aggregate/quantile_fun.test new file mode 100644 index 0000000..5c5b31c --- /dev/null +++ b/parser/testdata/corpus/sql/aggregate/quantile_fun.test @@ -0,0 +1,37 @@ +# source: test/sql/aggregate/quantile_fun.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +create table quantiles as select range r, random() FROM range(100) union all values (NULL, 0.1), (NULL, 0.5), (NULL, 0.9) order by 2; +-- +ok +== +SELECT quantile_disc(0.1::decimal(4,1), [0.1, 0.5, 0.9]); +-- +ok +== +SELECT PERCENTILE_CONT(0.5) WITHIN GROUP (ORDER BY "l_extendedprice") FROM lineitem; +-- +ok +== +SELECT quantile_disc(r::{type}, 0.1) FROM quantiles +-- +error: Parser Error: syntax error at or near "{" +== +SELECT quantile_disc(r::{type}, [0.1, 0.5, 0.9]) FROM quantiles +-- +error: Parser Error: syntax error at or near "{" +== +SELECT quantile_cont(r::{type}, 0.15) FROM quantiles +-- +error: Parser Error: syntax error at or near "{" +== +SELECT quantile_cont(r::{type}, [0.15, 0.5, 0.9]) FROM quantiles +-- +error: Parser Error: syntax error at or near "{" +== +SELECT quantile_cont(NULL, CAST(NULL AS DOUBLE[])) +-- +ok +== diff --git a/parser/testdata/corpus/sql/alter/add_col/test_add_col.test b/parser/testdata/corpus/sql/alter/add_col/test_add_col.test new file mode 100644 index 0000000..75c96d1 --- /dev/null +++ b/parser/testdata/corpus/sql/alter/add_col/test_add_col.test @@ -0,0 +1,21 @@ +# source: test/sql/alter/add_col/test_add_col.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +CREATE TABLE test(i INTEGER, j INTEGER) +-- +ok +== +INSERT INTO test VALUES (1, 1), (2, 2) +-- +ok +== +ALTER TABLE test ADD COLUMN k INTEGER +-- +ok +== +SELECT * FROM test +-- +ok +== diff --git a/parser/testdata/corpus/sql/alter/add_col/test_add_col_chain.test b/parser/testdata/corpus/sql/alter/add_col/test_add_col_chain.test new file mode 100644 index 0000000..f5bd039 --- /dev/null +++ b/parser/testdata/corpus/sql/alter/add_col/test_add_col_chain.test @@ -0,0 +1,17 @@ +# source: test/sql/alter/add_col/test_add_col_chain.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +INSERT INTO test VALUES (3, 3) +-- +ok +== +ALTER TABLE test ADD COLUMN l INTEGER +-- +ok +== +ALTER TABLE test ADD COLUMN m INTEGER DEFAULT 3 +-- +ok +== diff --git a/parser/testdata/corpus/sql/alter/add_col/test_add_col_default.test b/parser/testdata/corpus/sql/alter/add_col/test_add_col_default.test new file mode 100644 index 0000000..27b4d74 --- /dev/null +++ b/parser/testdata/corpus/sql/alter/add_col/test_add_col_default.test @@ -0,0 +1,13 @@ +# source: test/sql/alter/add_col/test_add_col_default.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +ALTER TABLE test ADD COLUMN l INTEGER DEFAULT 3 +-- +ok +== +SELECT i, j, l FROM test +-- +ok +== diff --git a/parser/testdata/corpus/sql/alter/add_col/test_add_col_default_seq.test b/parser/testdata/corpus/sql/alter/add_col/test_add_col_default_seq.test new file mode 100644 index 0000000..cfad151 --- /dev/null +++ b/parser/testdata/corpus/sql/alter/add_col/test_add_col_default_seq.test @@ -0,0 +1,13 @@ +# source: test/sql/alter/add_col/test_add_col_default_seq.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +ALTER TABLE test ADD COLUMN m INTEGER DEFAULT nextval('seq') +-- +ok +== +ALTER TABLE test ADD COLUMN n INTEGER DEFAULT currval('seq') +-- +ok +== diff --git a/parser/testdata/corpus/sql/alter/add_col/test_add_col_if_not_exists_default.test b/parser/testdata/corpus/sql/alter/add_col/test_add_col_if_not_exists_default.test new file mode 100644 index 0000000..0629e9b --- /dev/null +++ b/parser/testdata/corpus/sql/alter/add_col/test_add_col_if_not_exists_default.test @@ -0,0 +1,25 @@ +# source: test/sql/alter/add_col/test_add_col_if_not_exists_default.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +CREATE TABLE t (i INTEGER) +-- +ok +== +INSERT INTO t VALUES (1), (2) +-- +ok +== +ALTER TABLE t ADD COLUMN IF NOT EXISTS b BOOLEAN DEFAULT false +-- +ok +== +UPDATE t SET b = true +-- +ok +== +SELECT b FROM t +-- +ok +== diff --git a/parser/testdata/corpus/sql/alter/add_col/test_add_col_incorrect.test b/parser/testdata/corpus/sql/alter/add_col/test_add_col_incorrect.test new file mode 100644 index 0000000..e39850d --- /dev/null +++ b/parser/testdata/corpus/sql/alter/add_col/test_add_col_incorrect.test @@ -0,0 +1,21 @@ +# source: test/sql/alter/add_col/test_add_col_incorrect.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +ALTER TABLE test ADD COLUMN i INTEGER +-- +ok +== +CREATE VIEW x(x) AS (SELECT 1) +-- +ok +== +ALTER VIEW x ADD COLUMN i INTEGER +-- +error: Parser Error: syntax error at or near "ADD" +== +ALTER TABLE i ADD COLUMN j INT, ADD COLUMN k INT +-- +error: Parser Error: Only one ALTER command per statement is supported +== diff --git a/parser/testdata/corpus/sql/alter/add_col/test_add_col_incorrect.test.metadata.json b/parser/testdata/corpus/sql/alter/add_col/test_add_col_incorrect.test.metadata.json new file mode 100644 index 0000000..4e94fcf --- /dev/null +++ b/parser/testdata/corpus/sql/alter/add_col/test_add_col_incorrect.test.metadata.json @@ -0,0 +1,5 @@ +{ + "todo": { + "12b6cadced0b435f": "transformer-raised parser error: upstream rejects in the transformer, not the grammar; expected to clear as transformers land (milestones 3-5)" + } +} diff --git a/parser/testdata/corpus/sql/alter/add_col/test_add_col_index.test b/parser/testdata/corpus/sql/alter/add_col/test_add_col_index.test new file mode 100644 index 0000000..abecefc --- /dev/null +++ b/parser/testdata/corpus/sql/alter/add_col/test_add_col_index.test @@ -0,0 +1,25 @@ +# source: test/sql/alter/add_col/test_add_col_index.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +ALTER TABLE test ADD COLUMN k INTEGER DEFAULT 2 +-- +ok +== +CREATE INDEX i_index ON test(k) +-- +ok +== +INSERT INTO test VALUES (3, 3, 3) +-- +ok +== +SELECT * FROM test WHERE k=2 +-- +ok +== +SELECT * FROM test WHERE k=3 +-- +ok +== diff --git a/parser/testdata/corpus/sql/alter/add_col/test_add_col_stats.test b/parser/testdata/corpus/sql/alter/add_col/test_add_col_stats.test new file mode 100644 index 0000000..54bcfbe --- /dev/null +++ b/parser/testdata/corpus/sql/alter/add_col/test_add_col_stats.test @@ -0,0 +1,13 @@ +# source: test/sql/alter/add_col/test_add_col_stats.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +SELECT * FROM test WHERE m=2 +-- +ok +== +SELECT s.min, s.max FROM (SELECT stats(m) s FROM test LIMIT 1) +-- +ok +== diff --git a/parser/testdata/corpus/sql/alter/add_col/test_add_col_transactions.test b/parser/testdata/corpus/sql/alter/add_col/test_add_col_transactions.test new file mode 100644 index 0000000..d1917eb --- /dev/null +++ b/parser/testdata/corpus/sql/alter/add_col/test_add_col_transactions.test @@ -0,0 +1,21 @@ +# source: test/sql/alter/add_col/test_add_col_transactions.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +DROP TABLE test +-- +ok +== +INSERT INTO test (i, j) VALUES (3, 3) +-- +ok +== +DELETE FROM test WHERE i=1 +-- +ok +== +UPDATE test SET j=100 +-- +ok +== diff --git a/parser/testdata/corpus/sql/alter/add_col/test_add_col_user_type.test b/parser/testdata/corpus/sql/alter/add_col/test_add_col_user_type.test new file mode 100644 index 0000000..83a131d --- /dev/null +++ b/parser/testdata/corpus/sql/alter/add_col/test_add_col_user_type.test @@ -0,0 +1,37 @@ +# source: test/sql/alter/add_col/test_add_col_user_type.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +CREATE SCHEMA test_schema; +-- +ok +== +CREATE TYPE main_int AS int32; +-- +ok +== +CREATE TYPE test_schema.test_int AS int32; +-- +ok +== +CREATE TABLE test_schema.test_t1 (i INT); +-- +ok +== +CREATE TABLE main_t1 (i INT); +-- +ok +== +ALTER TABLE main_t1 ADD COLUMN j test_int; +-- +ok +== +ALTER TABLE test_schema.test_t1 ADD COLUMN not_found main_int; +-- +ok +== +ALTER TABLE test_schema.test_t1 ADD COLUMN l test_int; +-- +ok +== diff --git a/parser/testdata/corpus/sql/alter/add_pk/test_add_multi_column_pk.test b/parser/testdata/corpus/sql/alter/add_pk/test_add_multi_column_pk.test new file mode 100644 index 0000000..5348476 --- /dev/null +++ b/parser/testdata/corpus/sql/alter/add_pk/test_add_multi_column_pk.test @@ -0,0 +1,29 @@ +# source: test/sql/alter/add_pk/test_add_multi_column_pk.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +CREATE TABLE test (i INTEGER, j INTEGER, d TEXT); +-- +ok +== +INSERT INTO test VALUES (3, 4, 'hello'), (44, 45, '56'); +-- +ok +== +ALTER TABLE test ADD PRIMARY KEY (i, j); +-- +ok +== +INSERT INTO test VALUES (1, 1, 'foo'), (1, 2, 'bar'); +-- +ok +== +INSERT INTO test VALUES (1, 2, 'oops'); +-- +ok +== +INSERT INTO test VALUES (NULL, 2, 'nada'); +-- +ok +== diff --git a/parser/testdata/corpus/sql/alter/add_pk/test_add_pk.test b/parser/testdata/corpus/sql/alter/add_pk/test_add_pk.test new file mode 100644 index 0000000..2216a73 --- /dev/null +++ b/parser/testdata/corpus/sql/alter/add_pk/test_add_pk.test @@ -0,0 +1,89 @@ +# source: test/sql/alter/add_pk/test_add_pk.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +CREATE TABLE test (i INTEGER, j INTEGER) +-- +ok +== +INSERT INTO test VALUES (1, 1) +-- +ok +== +ALTER TABLE test ADD PRIMARY KEY (j) +-- +ok +== +INSERT INTO test VALUES (1, 2) +-- +ok +== +INSERT INTO test VALUES (2, 1) +-- +ok +== +INSERT INTO test VALUES (2, NULL) +-- +ok +== +ALTER TABLE test ADD PRIMARY KEY (i) +-- +ok +== +CREATE TABLE reverse (i INTEGER, j INTEGER) +-- +ok +== +INSERT INTO reverse VALUES (1, 2) +-- +ok +== +ALTER TABLE reverse ADD PRIMARY KEY (j, i) +-- +ok +== +INSERT INTO reverse (j, i) VALUES (2, 1) +-- +ok +== +CREATE TABLE scan (i INTEGER, j INTEGER) +-- +ok +== +INSERT INTO scan SELECT range, range + 1 FROM range(30000); +-- +ok +== +ALTER TABLE scan ADD PRIMARY KEY (i) +-- +ok +== +SELECT * FROM scan WHERE i = 2 +-- +ok +== +CREATE TEMPORARY TABLE temp_pk_test(x INTEGER) +-- +ok +== +SELECT table_name, database_name, temporary FROM duckdb_tables() WHERE table_name='temp_pk_test' +-- +ok +== +ALTER TABLE temp_pk_test ADD PRIMARY KEY (x) +-- +ok +== +CREATE VIEW view_test AS SELECT 'hello' AS name, 42 AS value +-- +ok +== +ALTER TABLE view_test ADD PRIMARY KEY (name) +-- +ok +== +DROP VIEW view_test +-- +ok +== diff --git a/parser/testdata/corpus/sql/alter/add_pk/test_add_pk_alter_in_tx.test b/parser/testdata/corpus/sql/alter/add_pk/test_add_pk_alter_in_tx.test new file mode 100644 index 0000000..bf974c2 --- /dev/null +++ b/parser/testdata/corpus/sql/alter/add_pk/test_add_pk_alter_in_tx.test @@ -0,0 +1,13 @@ +# source: test/sql/alter/add_pk/test_add_pk_alter_in_tx.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +ALTER TABLE test ADD PRIMARY KEY (j); +-- +ok +== +ALTER TABLE test ALTER COLUMN j SET NOT NULL; +-- +ok +== diff --git a/parser/testdata/corpus/sql/alter/add_pk/test_add_pk_attach.test b/parser/testdata/corpus/sql/alter/add_pk/test_add_pk_attach.test new file mode 100644 index 0000000..2929173 --- /dev/null +++ b/parser/testdata/corpus/sql/alter/add_pk/test_add_pk_attach.test @@ -0,0 +1,25 @@ +# source: test/sql/alter/add_pk/test_add_pk_attach.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +ATTACH ':memory:' as memory +-- +ok +== +USE memory +-- +ok +== +DETACH test_add_pk_attach +-- +ok +== +ATTACH '{TEST_DIR}/test_add_pk_attach.db' as test_add_pk_attach +-- +ok +== +USE test_add_pk_attach +-- +ok +== diff --git a/parser/testdata/corpus/sql/alter/add_pk/test_add_pk_catalog_error.test b/parser/testdata/corpus/sql/alter/add_pk/test_add_pk_catalog_error.test new file mode 100644 index 0000000..34f2b26 --- /dev/null +++ b/parser/testdata/corpus/sql/alter/add_pk/test_add_pk_catalog_error.test @@ -0,0 +1,37 @@ +# source: test/sql/alter/add_pk/test_add_pk_catalog_error.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +ALTER TABLE test ADD PRIMARY KEY (i_do_not_exist) +-- +ok +== +ALTER TABLE i_do_not_exist ADD PRIMARY KEY (i, j) +-- +ok +== +CREATE TABLE uniq (i INTEGER UNIQUE, j INTEGER) +-- +ok +== +INSERT INTO uniq VALUES (1, 10), (2, 20), (3, 30) +-- +ok +== +INSERT INTO uniq VALUES (1, 100) +-- +ok +== +ALTER TABLE uniq ADD PRIMARY KEY (i) +-- +ok +== +INSERT INTO uniq VALUES (1, 101) +-- +ok +== +INSERT INTO uniq VALUES (NULL, 100) +-- +ok +== diff --git a/parser/testdata/corpus/sql/alter/add_pk/test_add_pk_gaps_in_rowids.test b/parser/testdata/corpus/sql/alter/add_pk/test_add_pk_gaps_in_rowids.test new file mode 100644 index 0000000..1d94359 --- /dev/null +++ b/parser/testdata/corpus/sql/alter/add_pk/test_add_pk_gaps_in_rowids.test @@ -0,0 +1,25 @@ +# source: test/sql/alter/add_pk/test_add_pk_gaps_in_rowids.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +CREATE TABLE integers(i integer) +-- +ok +== +INSERT INTO integers SELECT * FROM range(50000); +-- +ok +== +SELECT i FROM integers WHERE i = 100 +-- +ok +== +DELETE FROM integers WHERE i = 42; +-- +ok +== +ALTER TABLE integers ADD PRIMARY KEY (i); +-- +ok +== diff --git a/parser/testdata/corpus/sql/alter/add_pk/test_add_pk_invalid_data.test b/parser/testdata/corpus/sql/alter/add_pk/test_add_pk_invalid_data.test new file mode 100644 index 0000000..6bd9824 --- /dev/null +++ b/parser/testdata/corpus/sql/alter/add_pk/test_add_pk_invalid_data.test @@ -0,0 +1,53 @@ +# source: test/sql/alter/add_pk/test_add_pk_invalid_data.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +CREATE TABLE duplicates (i INTEGER, j INTEGER) +-- +ok +== +INSERT INTO duplicates VALUES (1, 10), (2, 20), (3, 30), (1, 100) +-- +ok +== +ALTER TABLE duplicates ADD PRIMARY KEY (i) +-- +ok +== +CREATE TABLE nulls (i INTEGER, j INTEGER); +-- +ok +== +INSERT INTO nulls VALUES (1, 10), (2, NULL), (3, 30), (4, 40); +-- +ok +== +ALTER TABLE nulls ADD PRIMARY KEY (i, j); +-- +ok +== +DROP TABLE nulls; +-- +ok +== +INSERT INTO nulls VALUES (5, 10), (NULL, 20), (7, 30), (8, 100); +-- +ok +== +ALTER TABLE nulls ADD PRIMARY KEY (i) +-- +ok +== +CREATE TABLE nulls_compound (i INTEGER, j INTEGER, k VARCHAR) +-- +ok +== +INSERT INTO nulls_compound VALUES (1, 10, 'hello'), (2, 20, 'world'), (NULL, NULL, NULL), (3, 100, 'yay'); +-- +ok +== +ALTER TABLE nulls_compound ADD PRIMARY KEY (k, i) +-- +ok +== diff --git a/parser/testdata/corpus/sql/alter/add_pk/test_add_pk_invalid_type.test b/parser/testdata/corpus/sql/alter/add_pk/test_add_pk_invalid_type.test new file mode 100644 index 0000000..ce25d5e --- /dev/null +++ b/parser/testdata/corpus/sql/alter/add_pk/test_add_pk_invalid_type.test @@ -0,0 +1,17 @@ +# source: test/sql/alter/add_pk/test_add_pk_invalid_type.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +CREATE TABLE test (a INTEGER[], b INTEGER) +-- +ok +== +ALTER TABLE test ADD PRIMARY KEY (a) +-- +ok +== +ALTER TABLE test ADD PRIMARY KEY (a, b) +-- +ok +== diff --git a/parser/testdata/corpus/sql/alter/add_pk/test_add_pk_naming_conflict.test b/parser/testdata/corpus/sql/alter/add_pk/test_add_pk_naming_conflict.test new file mode 100644 index 0000000..311465d --- /dev/null +++ b/parser/testdata/corpus/sql/alter/add_pk/test_add_pk_naming_conflict.test @@ -0,0 +1,37 @@ +# source: test/sql/alter/add_pk/test_add_pk_naming_conflict.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +CREATE TABLE tbl (i INTEGER); +-- +ok +== +INSERT INTO tbl VALUES (1); +-- +ok +== +CREATE INDEX PRIMARY_tbl_i ON tbl(i); +-- +ok +== +ALTER TABLE tbl ADD PRIMARY KEY (i); +-- +ok +== +CREATE TABLE test (i INTEGER) +-- +ok +== +INSERT INTO test VALUES (1); +-- +ok +== +ALTER TABLE test ADD PRIMARY KEY (i); +-- +ok +== +CREATE INDEX PRIMARY_test_i ON test(i); +-- +ok +== diff --git a/parser/testdata/corpus/sql/alter/add_pk/test_add_pk_rollback.test b/parser/testdata/corpus/sql/alter/add_pk/test_add_pk_rollback.test new file mode 100644 index 0000000..cafbcef --- /dev/null +++ b/parser/testdata/corpus/sql/alter/add_pk/test_add_pk_rollback.test @@ -0,0 +1,33 @@ +# source: test/sql/alter/add_pk/test_add_pk_rollback.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +CREATE TABLE test (i INTEGER, j INTEGER); +-- +ok +== +INSERT INTO test VALUES (1, 1); +-- +ok +== +INSERT INTO test VALUES (2, 1); +-- +ok +== +INSERT INTO test VALUES (1, 1), (2, 1), (2, NULL); +-- +ok +== +CREATE TABLE other (i INTEGER, j INTEGER); +-- +ok +== +INSERT INTO other VALUES (1, 1), (2, 1); +-- +ok +== +ALTER TABLE other ADD PRIMARY KEY (j); +-- +ok +== diff --git a/parser/testdata/corpus/sql/alter/add_pk/test_add_pk_wal.test b/parser/testdata/corpus/sql/alter/add_pk/test_add_pk_wal.test new file mode 100644 index 0000000..fb3edcd --- /dev/null +++ b/parser/testdata/corpus/sql/alter/add_pk/test_add_pk_wal.test @@ -0,0 +1,13 @@ +# source: test/sql/alter/add_pk/test_add_pk_wal.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +INSERT INTO test VALUES (1, 2), (3, 4); +-- +ok +== +INSERT INTO test VALUES (2, 2) +-- +ok +== diff --git a/parser/testdata/corpus/sql/alter/add_pk/test_add_pk_with_generated_column.test b/parser/testdata/corpus/sql/alter/add_pk/test_add_pk_with_generated_column.test new file mode 100644 index 0000000..c197f59 --- /dev/null +++ b/parser/testdata/corpus/sql/alter/add_pk/test_add_pk_with_generated_column.test @@ -0,0 +1,33 @@ +# source: test/sql/alter/add_pk/test_add_pk_with_generated_column.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +CREATE TABLE test ( + a INT NOT NULL, + b INT GENERATED ALWAYS AS (a) VIRTUAL, + c INT, +); +-- +ok +== +INSERT INTO test VALUES (5, 4); +-- +ok +== +ALTER TABLE test ADD PRIMARY KEY (b); +-- +ok +== +ALTER TABLE test ADD PRIMARY KEY (b, c); +-- +ok +== +ALTER TABLE test ADD PRIMARY KEY (c); +-- +ok +== +INSERT INTO test VALUES (1, 4); +-- +ok +== diff --git a/parser/testdata/corpus/sql/alter/add_pk/test_add_same_pk_simultaneously.test b/parser/testdata/corpus/sql/alter/add_pk/test_add_same_pk_simultaneously.test new file mode 100644 index 0000000..82d88e8 --- /dev/null +++ b/parser/testdata/corpus/sql/alter/add_pk/test_add_same_pk_simultaneously.test @@ -0,0 +1,9 @@ +# source: test/sql/alter/add_pk/test_add_same_pk_simultaneously.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +INSERT INTO test VALUES (1, 1), (1, 1) +-- +ok +== diff --git a/parser/testdata/corpus/sql/alter/add_pk/test_add_same_pk_twice.test b/parser/testdata/corpus/sql/alter/add_pk/test_add_same_pk_twice.test new file mode 100644 index 0000000..6508c7b --- /dev/null +++ b/parser/testdata/corpus/sql/alter/add_pk/test_add_same_pk_twice.test @@ -0,0 +1,21 @@ +# source: test/sql/alter/add_pk/test_add_same_pk_twice.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +CREATE TABLE other (i INTEGER PRIMARY KEY, j INTEGER) +-- +ok +== +ALTER TABLE other ADD PRIMARY KEY (i, j) +-- +ok +== +ALTER TABLE other ADD PRIMARY KEY (i) +-- +ok +== +ALTER TABLE other ADD PRIMARY KEY (j) +-- +ok +== diff --git a/parser/testdata/corpus/sql/alter/alter_col/test_drop_not_null.test b/parser/testdata/corpus/sql/alter/alter_col/test_drop_not_null.test new file mode 100644 index 0000000..7868fda --- /dev/null +++ b/parser/testdata/corpus/sql/alter/alter_col/test_drop_not_null.test @@ -0,0 +1,61 @@ +# source: test/sql/alter/alter_col/test_drop_not_null.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +CREATE TABLE test(i INTEGER, j INTEGER NOT NULL) +-- +ok +== +INSERT INTO test VALUES (3, NULL) +-- +ok +== +ALTER TABLE test ALTER COLUMN j DROP NOT NULL +-- +ok +== +CREATE TABLE test2(i INTEGER, j INTEGER) +-- +ok +== +INSERT INTO test2 VALUES (1, 1), (2, 2) +-- +ok +== +ALTER TABLE test2 ALTER COLUMN j DROP NOT NULL +-- +ok +== +DROP TABLE IF EXISTS test +-- +ok +== +CREATE TABLE test(i AS (1), j INTEGER NOT NULL) +-- +ok +== +INSERT INTO test VALUES (1), (2) +-- +ok +== +INSERT INTO test VALUES (NULL) +-- +ok +== +ALTER TABLE test ALTER COLUMN i DROP NOT NULL +-- +ok +== +CREATE TEMPORARY TABLE temp_drop_not_null_test(x INTEGER NOT NULL) +-- +ok +== +SELECT table_name, database_name, temporary FROM duckdb_tables() WHERE table_name='temp_drop_not_null_test' +-- +ok +== +ALTER TABLE temp_drop_not_null_test ALTER COLUMN x DROP NOT NULL +-- +ok +== diff --git a/parser/testdata/corpus/sql/alter/alter_col/test_not_null_in_tran.test b/parser/testdata/corpus/sql/alter/alter_col/test_not_null_in_tran.test new file mode 100644 index 0000000..5449934 --- /dev/null +++ b/parser/testdata/corpus/sql/alter/alter_col/test_not_null_in_tran.test @@ -0,0 +1,121 @@ +# source: test/sql/alter/alter_col/test_not_null_in_tran.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +CREATE TABLE t(i INTEGER, j INTEGER) +-- +ok +== +INSERT INTO t SELECT i, i FROM RANGE(2048) tbl(i) +-- +ok +== +INSERT INTO t VALUES(9999, NULL) +-- +ok +== +ALTER TABLE t ALTER COLUMN j SET NOT NULL +-- +ok +== +SELECT i FROM t WHERE j IS NULL +-- +ok +== +DROP TABLE IF EXISTS t +-- +ok +== +INSERT INTO t values(8888, 8888) +-- +ok +== +SELECT * FROM t WHERE j = 8888 +-- +ok +== +CREATE TABLE t(i int, j int) +-- +ok +== +INSERT INTO T SELECT 1,1 FROM RANGE(2048) +-- +ok +== +INSERT INTO t VALUES(2, 2) +-- +ok +== +ALTER TABLE t ALTER COLUMN j DROP NOT NULL +-- +ok +== +INSERT INTO t values(3, NULL) +-- +ok +== +INSERT INTO t VALUES(4, NULL) +-- +ok +== +SELECT * FROM t WHERE j IS NULL +-- +ok +== +INSERT INTO T VALUES(8888, 8888) +-- +ok +== +INSERT INTO T VALUES(7777, NULL) +-- +ok +== +INSERT INTO t VALUES(8888, NULL) +-- +ok +== +SELECT COUNT(*) FROM t WHERE j IS NULL +-- +ok +== +CREATE TABLE t(i INTEGER) +-- +ok +== +ALTER TABLE t ALTER COLUMN i SET NOT NULL +-- +ok +== +INSERT INTO t SELECT 1 FROM RANGE(1024) +-- +ok +== +INSERT INTO t VALUES(NULL) +-- +ok +== +CREATE TABLE t(i INTEGER NOT NULL) +-- +ok +== +ALTER TABLE t ALTER COLUMN i DROP NOT NULL +-- +ok +== +INSERT INTO t SELECT 1,1 FROM RANGE(1024) +-- +ok +== +INSERT INTO t VALUES(2,NULL) +-- +ok +== +DELETE FROM t WHERE i = 2 +-- +ok +== +INSERT INTO t VALUES(3, NULL) +-- +ok +== diff --git a/parser/testdata/corpus/sql/alter/alter_col/test_not_null_multi_tran.test b/parser/testdata/corpus/sql/alter/alter_col/test_not_null_multi_tran.test new file mode 100644 index 0000000..c97e6ae --- /dev/null +++ b/parser/testdata/corpus/sql/alter/alter_col/test_not_null_multi_tran.test @@ -0,0 +1,37 @@ +# source: test/sql/alter/alter_col/test_not_null_multi_tran.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +INSERT INTO t VALUES(7777, NULL) +-- +ok +== +INSERT INTO t VALUES(7, 7) +-- +ok +== +SELECT i FROM t +-- +ok +== +SELECT COUNT(*) FROM t +-- +ok +== +INSERT INTO t VALUES(1, 1) +-- +ok +== +SELECT count(*) from t +-- +ok +== +INSERT INTO t VALUES(1, NULL) +-- +ok +== +INSERT INTO t VALUES(2, NULL) +-- +ok +== diff --git a/parser/testdata/corpus/sql/alter/alter_col/test_set_not_null.test b/parser/testdata/corpus/sql/alter/alter_col/test_set_not_null.test new file mode 100644 index 0000000..f2bff4b --- /dev/null +++ b/parser/testdata/corpus/sql/alter/alter_col/test_set_not_null.test @@ -0,0 +1,73 @@ +# source: test/sql/alter/alter_col/test_set_not_null.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +INSERT INTO t VALUES (1, 1), (2, 2) +-- +ok +== +INSERT INTO t VALUES (3, NULL) +-- +ok +== +SELECT * FROM t +-- +ok +== +INSERT INTO t SELECT 5,5 from range(65534) +-- +ok +== +INSERT INTO t VALUES (6, NULL) +-- +ok +== +INSERT INTO t VALUES (1, 1), (2, 2), (3, null) +-- +ok +== +INSERT INTO t SELECT 4,4 FROM RANGE(65536) +-- +ok +== +INSERT INTO t VALUES (5, null) +-- +ok +== +INSERT INTO t SELECT 1,1 FROM RANGE(65536) +-- +ok +== +INSERT INTO t VALUES (2, null) +-- +ok +== +INSERT INTO t VALUES (3, null) +-- +ok +== +CREATE TABLE t(i AS (1), j INTEGER) +-- +ok +== +INSERT INTO t SELECT 1 FROM RANGE(65536) +-- +ok +== +INSERT INTO t VALUES (null) +-- +ok +== +CREATE TEMPORARY TABLE temp_not_null_test(x INTEGER) +-- +ok +== +SELECT table_name, database_name, temporary FROM duckdb_tables() WHERE table_name='temp_not_null_test' +-- +ok +== +ALTER TABLE temp_not_null_test ALTER COLUMN x SET NOT NULL +-- +ok +== diff --git a/parser/testdata/corpus/sql/alter/alter_table_set_partitioned_by.test b/parser/testdata/corpus/sql/alter/alter_table_set_partitioned_by.test new file mode 100644 index 0000000..6c91e72 --- /dev/null +++ b/parser/testdata/corpus/sql/alter/alter_table_set_partitioned_by.test @@ -0,0 +1,17 @@ +# source: test/sql/alter/alter_table_set_partitioned_by.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +CREATE TABLE tbl(i INTEGER); +-- +ok +== +ALTER TABLE tbl SET PARTITIONED BY (i) +-- +ok +== +ALTER TABLE tbl RESET PARTITIONED BY; +-- +ok +== diff --git a/parser/testdata/corpus/sql/alter/alter_table_set_sorted_by.test b/parser/testdata/corpus/sql/alter/alter_table_set_sorted_by.test new file mode 100644 index 0000000..6943552 --- /dev/null +++ b/parser/testdata/corpus/sql/alter/alter_table_set_sorted_by.test @@ -0,0 +1,13 @@ +# source: test/sql/alter/alter_table_set_sorted_by.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +ALTER TABLE tbl SET SORTED BY (i DESC NULLS FIRST) +-- +ok +== +ALTER TABLE tbl RESET SORTED BY; +-- +ok +== diff --git a/parser/testdata/corpus/sql/alter/alter_table_set_table_options.test b/parser/testdata/corpus/sql/alter/alter_table_set_table_options.test new file mode 100644 index 0000000..e5f53c8 --- /dev/null +++ b/parser/testdata/corpus/sql/alter/alter_table_set_table_options.test @@ -0,0 +1,49 @@ +# source: test/sql/alter/alter_table_set_table_options.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +CREATE TABLE tbl1(i INTEGER); +-- +ok +== +set variable location='my/location/path'; +-- +ok +== +ALTER TABLE tbl1 SET ('foo'='baz', 'buzz'='wizz'); +-- +ok +== +ALTER TABLE tbl1 SET (foo='baz', buzz='wizz'); +-- +ok +== +ALTER TABLE tbl1 SET (foo=getvariable('location')); +-- +ok +== +ALTER TABLE tbl1 RESET ('foo', 'buzz'); +-- +ok +== +ALTER TABLE tbl1 RESET (foo, buzz); +-- +ok +== +ALTER TABLE tbl1 RESET ('foo'='baz', 'buzz'='wizz'); +-- +error: Parser Error: Reset option "buzz" cannot set any value. Did you mean to use SET? +== +ALTER TABLE tbl1 RESET (foo='baz', buzz='wizz'); +-- +error: Parser Error: Reset option "buzz" cannot set any value. Did you mean to use SET? +== +ALTER TABLE tbl1 RESET (); +-- +error: Parser Error: syntax error at or near ")" +== +ALTER TABLE tbl1 SET (); +-- +error: Parser Error: syntax error at or near ")" +== diff --git a/parser/testdata/corpus/sql/alter/alter_table_set_table_options.test.metadata.json b/parser/testdata/corpus/sql/alter/alter_table_set_table_options.test.metadata.json new file mode 100644 index 0000000..cb7a9c1 --- /dev/null +++ b/parser/testdata/corpus/sql/alter/alter_table_set_table_options.test.metadata.json @@ -0,0 +1,6 @@ +{ + "todo": { + "2131189ef0747278": "transformer-raised parser error: upstream rejects in the transformer, not the grammar; expected to clear as transformers land (milestones 3-5)", + "3a4a1eb80e178aac": "transformer-raised parser error: upstream rejects in the transformer, not the grammar; expected to clear as transformers land (milestones 3-5)" + } +} diff --git a/parser/testdata/corpus/sql/alter/alter_type/alter_type_struct.test b/parser/testdata/corpus/sql/alter/alter_type/alter_type_struct.test new file mode 100644 index 0000000..edc67d5 --- /dev/null +++ b/parser/testdata/corpus/sql/alter/alter_type/alter_type_struct.test @@ -0,0 +1,21 @@ +# source: test/sql/alter/alter_type/alter_type_struct.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +CREATE TABLE test AS SELECT {'t': 42} t +-- +ok +== +ALTER TABLE test ALTER t TYPE ROW(t VARCHAR) USING {'t': concat('hello', (test.t.t + 42)::varchar)} +-- +ok +== +DROP TABLE test; +-- +ok +== +ALTER TABLE test ALTER t TYPE ROW(t VARCHAR) USING {'t': concat('hello', (t.t + 42)::varchar)} +-- +ok +== diff --git a/parser/testdata/corpus/sql/alter/alter_type/test_alter_type.test b/parser/testdata/corpus/sql/alter/alter_type/test_alter_type.test new file mode 100644 index 0000000..dd664ce --- /dev/null +++ b/parser/testdata/corpus/sql/alter/alter_type/test_alter_type.test @@ -0,0 +1,57 @@ +# source: test/sql/alter/alter_type/test_alter_type.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +ALTER TABLE test ALTER i SET DATA TYPE VARCHAR +-- +ok +== +SELECT * FROM test ORDER BY ALL +-- +ok +== +SELECT * FROM test WHERE i = '1' +-- +ok +== +ALTER TABLE test ALTER i SET DATA TYPE INTEGER +-- +ok +== +SELECT * FROM test WHERE i = 1 +-- +ok +== +SELECT s.min, s.max FROM (SELECT stats(i) s FROM test LIMIT 1) +-- +ok +== +ALTER TABLE test ALTER not_a_column SET DATA TYPE INTEGER +-- +ok +== +CREATE TABLE tbl (col STRUCT(i INT)); +-- +ok +== +INSERT INTO tbl SELECT {'i': range} FROM range(5000); +-- +ok +== +ALTER TABLE tbl ALTER col TYPE USING struct_insert(col, a := 42, b := NULL::VARCHAR); +-- +ok +== +INSERT INTO tbl VALUES ({'i': 10000, 'a': NULL, 'b': 'hello'}); +-- +ok +== +SELECT col FROM tbl ORDER BY col DESC LIMIT 3; +-- +ok +== +ALTER TABLE tbl ALTER col TYPE; +-- +error: Parser Error: Omitting the type is only possible in combination with USING +== diff --git a/parser/testdata/corpus/sql/alter/alter_type/test_alter_type.test.metadata.json b/parser/testdata/corpus/sql/alter/alter_type/test_alter_type.test.metadata.json new file mode 100644 index 0000000..80b996e --- /dev/null +++ b/parser/testdata/corpus/sql/alter/alter_type/test_alter_type.test.metadata.json @@ -0,0 +1,5 @@ +{ + "todo": { + "635891b97530349f": "transformer-raised parser error: upstream rejects in the transformer, not the grammar; expected to clear as transformers land (milestones 3-5)" + } +} diff --git a/parser/testdata/corpus/sql/alter/alter_type/test_alter_type_active_transaction_visibility.test b/parser/testdata/corpus/sql/alter/alter_type/test_alter_type_active_transaction_visibility.test new file mode 100644 index 0000000..f3ce9ef --- /dev/null +++ b/parser/testdata/corpus/sql/alter/alter_type/test_alter_type_active_transaction_visibility.test @@ -0,0 +1,25 @@ +# source: test/sql/alter/alter_type/test_alter_type_active_transaction_visibility.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +CREATE TABLE test(i INTEGER) +-- +ok +== +INSERT INTO test VALUES (1) +-- +ok +== +SELECT i FROM test +-- +ok +== +UPDATE test SET i = 2 +-- +ok +== +ALTER TABLE test ALTER COLUMN i SET DATA TYPE BIGINT +-- +ok +== diff --git a/parser/testdata/corpus/sql/alter/alter_type/test_alter_type_check.test b/parser/testdata/corpus/sql/alter/alter_type/test_alter_type_check.test new file mode 100644 index 0000000..8021f11 --- /dev/null +++ b/parser/testdata/corpus/sql/alter/alter_type/test_alter_type_check.test @@ -0,0 +1,13 @@ +# source: test/sql/alter/alter_type/test_alter_type_check.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +CREATE TABLE test(i INTEGER CHECK(i < 10), j INTEGER) +-- +ok +== +ALTER TABLE test ALTER j SET DATA TYPE VARCHAR +-- +ok +== diff --git a/parser/testdata/corpus/sql/alter/alter_type/test_alter_type_dependencies.test b/parser/testdata/corpus/sql/alter/alter_type/test_alter_type_dependencies.test new file mode 100644 index 0000000..097a1be --- /dev/null +++ b/parser/testdata/corpus/sql/alter/alter_type/test_alter_type_dependencies.test @@ -0,0 +1,29 @@ +# source: test/sql/alter/alter_type/test_alter_type_dependencies.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +PREPARE v1 AS SELECT * FROM test +-- +ok +== +EXECUTE v1 +-- +ok +== +ALTER TABLE test ALTER i TYPE VARCHAR USING i::VARCHAR +-- +ok +== +ALTER TABLE test ALTER i TYPE INTEGER USING i::INTEGER +-- +ok +== +PREPARE v2 AS SELECT i+$1 FROM test +-- +ok +== +EXECUTE v2 +-- +ok +== diff --git a/parser/testdata/corpus/sql/alter/alter_type/test_alter_type_expression.test b/parser/testdata/corpus/sql/alter/alter_type/test_alter_type_expression.test new file mode 100644 index 0000000..92d2185 --- /dev/null +++ b/parser/testdata/corpus/sql/alter/alter_type/test_alter_type_expression.test @@ -0,0 +1,9 @@ +# source: test/sql/alter/alter_type/test_alter_type_expression.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +ALTER TABLE test ALTER i TYPE BIGINT USING i+100 +-- +ok +== diff --git a/parser/testdata/corpus/sql/alter/alter_type/test_alter_type_incorrect.test b/parser/testdata/corpus/sql/alter/alter_type/test_alter_type_incorrect.test new file mode 100644 index 0000000..08a48d0 --- /dev/null +++ b/parser/testdata/corpus/sql/alter/alter_type/test_alter_type_incorrect.test @@ -0,0 +1,25 @@ +# source: test/sql/alter/alter_type/test_alter_type_incorrect.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +ALTER TABLE test ALTER blabla SET TYPE VARCHAR +-- +ok +== +ALTER TABLE test ALTER i SET TYPE VARCHAR USING blabla +-- +ok +== +ALTER TABLE test ALTER i SET TYPE VARCHAR USING SUM(i) +-- +ok +== +ALTER TABLE test ALTER i SET TYPE VARCHAR USING row_id() OVER () +-- +ok +== +ALTER TABLE test ALTER i SET TYPE VARCHAR USING othertable.j +-- +ok +== diff --git a/parser/testdata/corpus/sql/alter/alter_type/test_alter_type_index.test b/parser/testdata/corpus/sql/alter/alter_type/test_alter_type_index.test new file mode 100644 index 0000000..4745cd7 --- /dev/null +++ b/parser/testdata/corpus/sql/alter/alter_type/test_alter_type_index.test @@ -0,0 +1,13 @@ +# source: test/sql/alter/alter_type/test_alter_type_index.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +CREATE INDEX i_index ON test(i) +-- +ok +== +DROP INDEX i_index +-- +ok +== diff --git a/parser/testdata/corpus/sql/alter/alter_type/test_alter_type_local.test b/parser/testdata/corpus/sql/alter/alter_type/test_alter_type_local.test new file mode 100644 index 0000000..4c554c4 --- /dev/null +++ b/parser/testdata/corpus/sql/alter/alter_type/test_alter_type_local.test @@ -0,0 +1,9 @@ +# source: test/sql/alter/alter_type/test_alter_type_local.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +ALTER TABLE test ALTER i SET DATA TYPE BIGINT +-- +ok +== diff --git a/parser/testdata/corpus/sql/alter/alter_type/test_alter_type_multi_column.test b/parser/testdata/corpus/sql/alter/alter_type/test_alter_type_multi_column.test new file mode 100644 index 0000000..68de6c0 --- /dev/null +++ b/parser/testdata/corpus/sql/alter/alter_type/test_alter_type_multi_column.test @@ -0,0 +1,9 @@ +# source: test/sql/alter/alter_type/test_alter_type_multi_column.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +ALTER TABLE test ALTER i TYPE INTEGER USING 2*(i+j) +-- +ok +== diff --git a/parser/testdata/corpus/sql/alter/alter_type/test_alter_type_not_null.test b/parser/testdata/corpus/sql/alter/alter_type/test_alter_type_not_null.test new file mode 100644 index 0000000..3edff8c --- /dev/null +++ b/parser/testdata/corpus/sql/alter/alter_type/test_alter_type_not_null.test @@ -0,0 +1,17 @@ +# source: test/sql/alter/alter_type/test_alter_type_not_null.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +CREATE TABLE test(i INTEGER NOT NULL, j INTEGER) +-- +ok +== +INSERT INTO test VALUES (NULL, 4) +-- +ok +== +INSERT INTO test VALUES ('hello', 3) +-- +ok +== diff --git a/parser/testdata/corpus/sql/alter/alter_type/test_alter_type_rollback.test b/parser/testdata/corpus/sql/alter/alter_type/test_alter_type_rollback.test new file mode 100644 index 0000000..0ba41e8 --- /dev/null +++ b/parser/testdata/corpus/sql/alter/alter_type/test_alter_type_rollback.test @@ -0,0 +1,9 @@ +# source: test/sql/alter/alter_type/test_alter_type_rollback.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +UPDATE test SET i='hello' +-- +ok +== diff --git a/parser/testdata/corpus/sql/alter/alter_type/test_alter_type_transactions.test b/parser/testdata/corpus/sql/alter/alter_type/test_alter_type_transactions.test new file mode 100644 index 0000000..d0b7f3a --- /dev/null +++ b/parser/testdata/corpus/sql/alter/alter_type/test_alter_type_transactions.test @@ -0,0 +1,21 @@ +# source: test/sql/alter/alter_type/test_alter_type_transactions.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +ALTER TABLE test ALTER j TYPE VARCHAR +-- +ok +== +ALTER TABLE test ALTER i TYPE VARCHAR +-- +ok +== +UPDATE test SET i=1000 +-- +ok +== +CREATE INDEX i_index ON test(j) +-- +ok +== diff --git a/parser/testdata/corpus/sql/alter/alter_type/test_alter_type_unique.test b/parser/testdata/corpus/sql/alter/alter_type/test_alter_type_unique.test new file mode 100644 index 0000000..6d1391f --- /dev/null +++ b/parser/testdata/corpus/sql/alter/alter_type/test_alter_type_unique.test @@ -0,0 +1,9 @@ +# source: test/sql/alter/alter_type/test_alter_type_unique.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +CREATE TABLE test(i INTEGER UNIQUE, j INTEGER) +-- +ok +== diff --git a/parser/testdata/corpus/sql/alter/alter_type/test_alter_type_with_generated_column.test b/parser/testdata/corpus/sql/alter/alter_type/test_alter_type_with_generated_column.test new file mode 100644 index 0000000..96bcef5 --- /dev/null +++ b/parser/testdata/corpus/sql/alter/alter_type/test_alter_type_with_generated_column.test @@ -0,0 +1,9 @@ +# source: test/sql/alter/alter_type/test_alter_type_with_generated_column.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +CREATE TABLE test(i AS (1), j INTEGER) +-- +ok +== diff --git a/parser/testdata/corpus/sql/alter/default/drop_default.test b/parser/testdata/corpus/sql/alter/default/drop_default.test new file mode 100644 index 0000000..a501792 --- /dev/null +++ b/parser/testdata/corpus/sql/alter/default/drop_default.test @@ -0,0 +1,25 @@ +# source: test/sql/alter/default/drop_default.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +CREATE TABLE data(id INTEGER, x INTEGER); +-- +ok +== +ALTER TABLE data ALTER COLUMN id DROP DEFAULT; +-- +ok +== +INSERT INTO data VALUES (1, 0), (2, 1); +-- +ok +== +ALTER TABLE data ALTER COLUMN x DROP DEFAULT; +-- +ok +== +ALTER TABLE data ALTER COLUMN j DROP DEFAULT; +-- +ok +== diff --git a/parser/testdata/corpus/sql/alter/default/test_set_default.test b/parser/testdata/corpus/sql/alter/default/test_set_default.test new file mode 100644 index 0000000..f29dab1 --- /dev/null +++ b/parser/testdata/corpus/sql/alter/default/test_set_default.test @@ -0,0 +1,65 @@ +# source: test/sql/alter/default/test_set_default.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +ALTER TABLE test ALTER j SET DEFAULT 3 +-- +ok +== +INSERT INTO test (i) VALUES (3) +-- +ok +== +ALTER TABLE test ALTER COLUMN j DROP DEFAULT +-- +ok +== +INSERT INTO test (i) VALUES (4) +-- +ok +== +ALTER TABLE test ALTER j SET DEFAULT nextval('seq') +-- +ok +== +INSERT INTO test (i) VALUES (5), (6) +-- +ok +== +CREATE TABLE constrainty(i INTEGER PRIMARY KEY, j INTEGER); +-- +ok +== +ALTER TABLE constrainty ALTER j SET DEFAULT 3 +-- +ok +== +INSERT INTO constrainty (i) VALUES (2) +-- +ok +== +SELECT * FROM constrainty +-- +ok +== +ALTER TABLE test ALTER blabla SET DEFAULT 3 +-- +ok +== +ALTER TABLE test ALTER blabla DROP DEFAULT +-- +ok +== +CREATE TEMPORARY TABLE temp_default_test(x INTEGER DEFAULT 1) +-- +ok +== +SELECT table_name, database_name, temporary FROM duckdb_tables() WHERE table_name='temp_default_test' +-- +ok +== +ALTER TABLE temp_default_test ALTER x SET DEFAULT 5 +-- +ok +== diff --git a/parser/testdata/corpus/sql/alter/drop_col/test_drop_col.test b/parser/testdata/corpus/sql/alter/drop_col/test_drop_col.test new file mode 100644 index 0000000..5c5b58e --- /dev/null +++ b/parser/testdata/corpus/sql/alter/drop_col/test_drop_col.test @@ -0,0 +1,9 @@ +# source: test/sql/alter/drop_col/test_drop_col.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +ALTER TABLE test DROP COLUMN j +-- +ok +== diff --git a/parser/testdata/corpus/sql/alter/drop_col/test_drop_col_check.test b/parser/testdata/corpus/sql/alter/drop_col/test_drop_col_check.test new file mode 100644 index 0000000..3a709a2 --- /dev/null +++ b/parser/testdata/corpus/sql/alter/drop_col/test_drop_col_check.test @@ -0,0 +1,25 @@ +# source: test/sql/alter/drop_col/test_drop_col_check.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +CREATE TABLE test(i INTEGER, j INTEGER CHECK(j < 10)) +-- +ok +== +INSERT INTO test VALUES (3) +-- +ok +== +CREATE TABLE test2(i INTEGER, j INTEGER CHECK(i+j < 10)) +-- +ok +== +SELECT * FROM test2 +-- +ok +== +ALTER TABLE test2 DROP COLUMN j +-- +ok +== diff --git a/parser/testdata/corpus/sql/alter/drop_col/test_drop_col_check_next.test b/parser/testdata/corpus/sql/alter/drop_col/test_drop_col_check_next.test new file mode 100644 index 0000000..10b3f81 --- /dev/null +++ b/parser/testdata/corpus/sql/alter/drop_col/test_drop_col_check_next.test @@ -0,0 +1,13 @@ +# source: test/sql/alter/drop_col/test_drop_col_check_next.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +ALTER TABLE test DROP COLUMN i +-- +ok +== +INSERT INTO test VALUES (20) +-- +ok +== diff --git a/parser/testdata/corpus/sql/alter/drop_col/test_drop_col_concurrent_dml_conflict.test b/parser/testdata/corpus/sql/alter/drop_col/test_drop_col_concurrent_dml_conflict.test new file mode 100644 index 0000000..4cc1f3d --- /dev/null +++ b/parser/testdata/corpus/sql/alter/drop_col/test_drop_col_concurrent_dml_conflict.test @@ -0,0 +1,41 @@ +# source: test/sql/alter/drop_col/test_drop_col_concurrent_dml_conflict.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +SET immediate_transaction_mode=true +-- +ok +== +CREATE TABLE t1 (id INTEGER PRIMARY KEY, val INTEGER, extra INTEGER) +-- +ok +== +INSERT INTO t1 SELECT i, i * 10, i FROM range(1000) tbl(i) +-- +ok +== +DELETE FROM t1 WHERE id < 500 +-- +ok +== +ALTER TABLE t1 DROP COLUMN extra +-- +ok +== +EXPLAIN ANALYZE SELECT val FROM t1 WHERE id = 5 +-- +ok +== +SELECT val FROM t1 WHERE id = 499 +-- +ok +== +EXPLAIN ANALYZE SELECT val FROM t1 WHERE id = 500 +-- +ok +== +SELECT val FROM t1 WHERE id = 500 +-- +ok +== diff --git a/parser/testdata/corpus/sql/alter/drop_col/test_drop_col_failure.test b/parser/testdata/corpus/sql/alter/drop_col/test_drop_col_failure.test new file mode 100644 index 0000000..c17c0fa --- /dev/null +++ b/parser/testdata/corpus/sql/alter/drop_col/test_drop_col_failure.test @@ -0,0 +1,25 @@ +# source: test/sql/alter/drop_col/test_drop_col_failure.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +ALTER TABLE test DROP COLUMN blabla +-- +ok +== +ALTER TABLE test DROP COLUMN IF EXISTS blabla +-- +ok +== +CREATE TABLE test2 (id INT PRIMARY KEY, name TEXT, surname TEXT, age INT, UNIQUE(surname, age)) +-- +ok +== +ALTER TABLE test2 DROP COLUMN surname +-- +ok +== +ALTER TABLE test2 DROP COLUMN age +-- +ok +== diff --git a/parser/testdata/corpus/sql/alter/drop_col/test_drop_col_not_null_next.test b/parser/testdata/corpus/sql/alter/drop_col/test_drop_col_not_null_next.test new file mode 100644 index 0000000..7a05c0d --- /dev/null +++ b/parser/testdata/corpus/sql/alter/drop_col/test_drop_col_not_null_next.test @@ -0,0 +1,17 @@ +# source: test/sql/alter/drop_col/test_drop_col_not_null_next.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +CREATE TABLE test(i INTEGER, j INTEGER, k INTEGER NOT NULL) +-- +ok +== +INSERT INTO test VALUES (1, 1, 11), (2, 2, 12) +-- +ok +== +INSERT INTO test VALUES (3, 13) +-- +ok +== diff --git a/parser/testdata/corpus/sql/alter/drop_col/test_drop_col_operations.test b/parser/testdata/corpus/sql/alter/drop_col/test_drop_col_operations.test new file mode 100644 index 0000000..c70cc82 --- /dev/null +++ b/parser/testdata/corpus/sql/alter/drop_col/test_drop_col_operations.test @@ -0,0 +1,21 @@ +# source: test/sql/alter/drop_col/test_drop_col_operations.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +INSERT INTO test SELECT i, i FROM range(100) tbl(i); +-- +ok +== +DELETE FROM test WHERE j%2=0 +-- +ok +== +SELECT COUNT(j), SUM(j) FROM test +-- +ok +== +UPDATE test SET j=j+100 +-- +ok +== diff --git a/parser/testdata/corpus/sql/alter/drop_col/test_drop_col_pk.test b/parser/testdata/corpus/sql/alter/drop_col/test_drop_col_pk.test new file mode 100644 index 0000000..40de29a --- /dev/null +++ b/parser/testdata/corpus/sql/alter/drop_col/test_drop_col_pk.test @@ -0,0 +1,9 @@ +# source: test/sql/alter/drop_col/test_drop_col_pk.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +CREATE TABLE test(i INTEGER PRIMARY KEY, j INTEGER) +-- +ok +== diff --git a/parser/testdata/corpus/sql/alter/drop_col/test_drop_col_with_generated_cols.test b/parser/testdata/corpus/sql/alter/drop_col/test_drop_col_with_generated_cols.test new file mode 100644 index 0000000..4f43e74 --- /dev/null +++ b/parser/testdata/corpus/sql/alter/drop_col/test_drop_col_with_generated_cols.test @@ -0,0 +1,25 @@ +# source: test/sql/alter/drop_col/test_drop_col_with_generated_cols.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +create table t(i int, j as (2), k int, m as (3), n int); +-- +ok +== +alter table t drop column n; +-- +ok +== +alter table t drop column m; +-- +ok +== +alter table t drop column k; +-- +ok +== +alter table t drop column j; +-- +ok +== diff --git a/parser/testdata/corpus/sql/alter/list/add_column_in_struct.test b/parser/testdata/corpus/sql/alter/list/add_column_in_struct.test new file mode 100644 index 0000000..8bad536 --- /dev/null +++ b/parser/testdata/corpus/sql/alter/list/add_column_in_struct.test @@ -0,0 +1,54 @@ +# source: test/sql/alter/list/add_column_in_struct.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +WITH cte AS ( + SELECT a::STRUCT(i INTEGER, j INTEGER)[] a FROM + VALUES ([ROW(1, 1)]), ([ROW(2, 2)]) t(a) +) +SELECT remap_struct( + a, + NULL::STRUCT(i INTEGER, j INTEGER, k INTEGER)[], + {'list': ('list', {'i': 'i', 'j': 'j'})}, + {'list': {'k': NULL::INTEGER}} +) FROM cte; +-- +ok +== +CREATE TABLE test(s STRUCT(i INTEGER, j INTEGER)[]) +-- +ok +== +INSERT INTO test VALUES ([ROW(1, 1)]), ([ROW(2, 2)]) +-- +ok +== +ALTER TABLE test ADD COLUMN s.element.k INTEGER +-- +ok +== +SELECT * FROM test; +-- +ok +== +CREATE TABLE test( + s STRUCT( + a STRUCT(i INTEGER, j INTEGER)[] + ) +) +-- +ok +== +INSERT INTO test VALUES (ROW([ROW(1, 1)])), (ROW([ROW(2, 2)])) +-- +ok +== +ALTER TABLE test ADD COLUMN s.a.element.k INTEGER +-- +ok +== +ALTER TABLE test ADD COLUMN s.a.not_element INTEGER +-- +ok +== diff --git a/parser/testdata/corpus/sql/alter/list/drop_column_in_struct.test b/parser/testdata/corpus/sql/alter/list/drop_column_in_struct.test new file mode 100644 index 0000000..c0633e6 --- /dev/null +++ b/parser/testdata/corpus/sql/alter/list/drop_column_in_struct.test @@ -0,0 +1,17 @@ +# source: test/sql/alter/list/drop_column_in_struct.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +ALTER TABLE test DROP COLUMN s.element +-- +ok +== +ALTER TABLE test DROP COLUMN s.element.j +-- +ok +== +ALTER TABLE test DROP COLUMN s.a.element.i +-- +ok +== diff --git a/parser/testdata/corpus/sql/alter/list/rename_column_in_struct.test b/parser/testdata/corpus/sql/alter/list/rename_column_in_struct.test new file mode 100644 index 0000000..d81fe8d --- /dev/null +++ b/parser/testdata/corpus/sql/alter/list/rename_column_in_struct.test @@ -0,0 +1,57 @@ +# source: test/sql/alter/list/rename_column_in_struct.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +CREATE TABLE test( + s STRUCT( + i INTEGER, + j INTEGER + )[] +) +-- +ok +== +INSERT INTO test VALUES + ([ROW(1, 1)]), + ([ROW(2, 2)]) +-- +ok +== +ALTER TABLE test RENAME COLUMN s.element TO not_element +-- +ok +== +ALTER TABLE test RENAME COLUMN s.element.j TO k +-- +ok +== +select * from test +-- +ok +== +drop table test; +-- +ok +== +CREATE TABLE test( + s STRUCT( + a STRUCT( + i INTEGER, + j INTEGER + )[] + ) +) +-- +ok +== +INSERT INTO test VALUES + (ROW([ROW(1, 1)])), + (ROW([ROW(2, 2)])) +-- +ok +== +ALTER TABLE test RENAME COLUMN s.a.element.i TO k +-- +ok +== diff --git a/parser/testdata/corpus/sql/alter/map/add_column_in_struct.test b/parser/testdata/corpus/sql/alter/map/add_column_in_struct.test new file mode 100644 index 0000000..36e012e --- /dev/null +++ b/parser/testdata/corpus/sql/alter/map/add_column_in_struct.test @@ -0,0 +1,105 @@ +# source: test/sql/alter/map/add_column_in_struct.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +WITH cte as ( + select a::MAP(STRUCT(n INTEGER, m INTEGER), STRUCT(i INTEGER, j INTEGER)) a from + VALUES + (MAP {ROW(3,3): ROW(1, 1)}), + (MAP {ROW(4,4): ROW(2, 2)}) + t(a) +) +SELECT remap_struct( + a, + NULL::MAP(STRUCT(n INTEGER, m INTEGER), STRUCT(i INTEGER, j INTEGER, k INTEGER)), + { + 'key': 'key', + 'value': ( + 'value', { + 'i': 'i', + 'j': 'j' + } + ) + }, + { + 'value': { + 'k': NULL::INTEGER + } + } +) from cte; +-- +ok +== +CREATE TABLE test( + s MAP( + STRUCT( + n INTEGER, + m INTEGER + ), + STRUCT( + i INTEGER, + j INTEGER + ) + ) +) +-- +ok +== +INSERT INTO test VALUES + (MAP {ROW(3,3): ROW(1, 1)}), + (MAP {ROW(4,4): ROW(2, 2)}) +-- +ok +== +ALTER TABLE test ADD COLUMN s.key.k INTEGER +-- +ok +== +select * from test; +-- +ok +== +ALTER TABLE test ADD COLUMN s.value.b VARCHAR +-- +ok +== +CREATE TABLE test( + s STRUCT( + a MAP( + STRUCT( + n INTEGER, + m INTEGER + ), + STRUCT( + i INTEGER, + j INTEGER + ) + ) + ) +) +-- +ok +== +INSERT INTO test VALUES + (ROW(MAP {ROW(3,3): ROW(1, 1)})), + (ROW(MAP {ROW(4,4): ROW(2, 2)})) +-- +ok +== +ALTER TABLE test ADD COLUMN s.a.key.k INTEGER +-- +ok +== +ALTER TABLE test ADD COLUMN s.a.value.b VARCHAR +-- +ok +== +ALTER TABLE test ADD COLUMN s.a.not_key INTEGER +-- +ok +== +ALTER TABLE test ADD COLUMN s.a.key INTEGER +-- +ok +== diff --git a/parser/testdata/corpus/sql/alter/map/drop_column_in_struct.test b/parser/testdata/corpus/sql/alter/map/drop_column_in_struct.test new file mode 100644 index 0000000..bfaeb91 --- /dev/null +++ b/parser/testdata/corpus/sql/alter/map/drop_column_in_struct.test @@ -0,0 +1,29 @@ +# source: test/sql/alter/map/drop_column_in_struct.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +ALTER TABLE test DROP COLUMN s.key +-- +ok +== +ALTER TABLE test DROP COLUMN s.value +-- +ok +== +ALTER TABLE test DROP COLUMN s.value.j +-- +ok +== +ALTER TABLE test DROP COLUMN s.key.n +-- +ok +== +ALTER TABLE test DROP COLUMN s.a.key.m +-- +ok +== +ALTER TABLE test DROP COLUMN s.a.value.j +-- +ok +== diff --git a/parser/testdata/corpus/sql/alter/map/rename_column_in_struct.test b/parser/testdata/corpus/sql/alter/map/rename_column_in_struct.test new file mode 100644 index 0000000..f102499 --- /dev/null +++ b/parser/testdata/corpus/sql/alter/map/rename_column_in_struct.test @@ -0,0 +1,29 @@ +# source: test/sql/alter/map/rename_column_in_struct.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +ALTER TABLE test RENAME COLUMN s.key to anything +-- +ok +== +ALTER TABLE test RENAME COLUMN s.value to anything +-- +ok +== +ALTER TABLE test RENAME COLUMN s.value.j TO abc +-- +ok +== +ALTER TABLE test RENAME COLUMN s.key.n TO def +-- +ok +== +ALTER TABLE test RENAME COLUMN s.a.key.m TO abc +-- +ok +== +ALTER TABLE test RENAME COLUMN s.a.value.j TO def +-- +ok +== diff --git a/parser/testdata/corpus/sql/alter/rename_col/test_rename_col.test b/parser/testdata/corpus/sql/alter/rename_col/test_rename_col.test new file mode 100644 index 0000000..367b531 --- /dev/null +++ b/parser/testdata/corpus/sql/alter/rename_col/test_rename_col.test @@ -0,0 +1,9 @@ +# source: test/sql/alter/rename_col/test_rename_col.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +ALTER TABLE test RENAME COLUMN i TO k +-- +ok +== diff --git a/parser/testdata/corpus/sql/alter/rename_col/test_rename_col_check.test b/parser/testdata/corpus/sql/alter/rename_col/test_rename_col_check.test new file mode 100644 index 0000000..25e2f81 --- /dev/null +++ b/parser/testdata/corpus/sql/alter/rename_col/test_rename_col_check.test @@ -0,0 +1,21 @@ +# source: test/sql/alter/rename_col/test_rename_col_check.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +INSERT INTO test (i, j) VALUES (1, 2), (2, 3) +-- +ok +== +INSERT INTO test (i, j) VALUES (100, 2) +-- +ok +== +INSERT INTO test (k, j) VALUES (1, 2), (2, 3) +-- +ok +== +INSERT INTO test (k, j) VALUES (100, 2) +-- +ok +== diff --git a/parser/testdata/corpus/sql/alter/rename_col/test_rename_col_dependencies.test b/parser/testdata/corpus/sql/alter/rename_col/test_rename_col_dependencies.test new file mode 100644 index 0000000..92bd91b --- /dev/null +++ b/parser/testdata/corpus/sql/alter/rename_col/test_rename_col_dependencies.test @@ -0,0 +1,13 @@ +# source: test/sql/alter/rename_col/test_rename_col_dependencies.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +PREPARE v1 AS SELECT i, j FROM test +-- +ok +== +PREPARE v2 AS SELECT * FROM test +-- +ok +== diff --git a/parser/testdata/corpus/sql/alter/rename_col/test_rename_col_failure.test b/parser/testdata/corpus/sql/alter/rename_col/test_rename_col_failure.test new file mode 100644 index 0000000..1079af6 --- /dev/null +++ b/parser/testdata/corpus/sql/alter/rename_col/test_rename_col_failure.test @@ -0,0 +1,17 @@ +# source: test/sql/alter/rename_col/test_rename_col_failure.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +ALTER TABLE test RENAME COLUMN blablabla TO k +-- +ok +== +ALTER TABLE test RENAME COLUMN i TO j +-- +ok +== +SELECT i, j FROM test +-- +ok +== diff --git a/parser/testdata/corpus/sql/alter/rename_col/test_rename_col_not_null.test b/parser/testdata/corpus/sql/alter/rename_col/test_rename_col_not_null.test new file mode 100644 index 0000000..a9f43b7 --- /dev/null +++ b/parser/testdata/corpus/sql/alter/rename_col/test_rename_col_not_null.test @@ -0,0 +1,13 @@ +# source: test/sql/alter/rename_col/test_rename_col_not_null.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +INSERT INTO test (i, j) VALUES (NULL, 2) +-- +ok +== +INSERT INTO test (k, j) VALUES (NULL, 2) +-- +ok +== diff --git a/parser/testdata/corpus/sql/alter/rename_col/test_rename_col_rollback.test b/parser/testdata/corpus/sql/alter/rename_col/test_rename_col_rollback.test new file mode 100644 index 0000000..4a23958 --- /dev/null +++ b/parser/testdata/corpus/sql/alter/rename_col/test_rename_col_rollback.test @@ -0,0 +1,17 @@ +# source: test/sql/alter/rename_col/test_rename_col_rollback.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +SET default_transaction_invalidation_policy='SYNTACTIC_ERRORS_DO_NOT_INVALIDATE'; +-- +ok +== +START TRANSACTION +-- +ok +== +SELECT k FROM test +-- +ok +== diff --git a/parser/testdata/corpus/sql/alter/rename_col/test_rename_col_transactions.test b/parser/testdata/corpus/sql/alter/rename_col/test_rename_col_transactions.test new file mode 100644 index 0000000..bb6b060 --- /dev/null +++ b/parser/testdata/corpus/sql/alter/rename_col/test_rename_col_transactions.test @@ -0,0 +1,12 @@ +# source: test/sql/alter/rename_col/test_rename_col_transactions.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +CREATE TABLE test( + i INTEGER, + j INTEGER +) +-- +ok +== diff --git a/parser/testdata/corpus/sql/alter/rename_col/test_rename_col_unique.test b/parser/testdata/corpus/sql/alter/rename_col/test_rename_col_unique.test new file mode 100644 index 0000000..9da80c6 --- /dev/null +++ b/parser/testdata/corpus/sql/alter/rename_col/test_rename_col_unique.test @@ -0,0 +1,25 @@ +# source: test/sql/alter/rename_col/test_rename_col_unique.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +CREATE TABLE test(i INTEGER, j INTEGER, PRIMARY KEY(i, j)) +-- +ok +== +INSERT INTO test (i, j) VALUES (1, 1), (2, 2) +-- +ok +== +INSERT INTO test (i, j) VALUES (1, 1) +-- +ok +== +INSERT INTO test (k, j) VALUES (3, 3), (4, 4) +-- +ok +== +INSERT INTO test (k, j) VALUES (1, 1) +-- +ok +== diff --git a/parser/testdata/corpus/sql/alter/rename_schema/rename_schema.test b/parser/testdata/corpus/sql/alter/rename_schema/rename_schema.test new file mode 100644 index 0000000..858bd1f --- /dev/null +++ b/parser/testdata/corpus/sql/alter/rename_schema/rename_schema.test @@ -0,0 +1,9 @@ +# source: test/sql/alter/rename_schema/rename_schema.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +ALTER SCHEMA a RENAME TO b; +-- +ok +== diff --git a/parser/testdata/corpus/sql/alter/rename_table/test_rename_bug4455_schema.test b/parser/testdata/corpus/sql/alter/rename_table/test_rename_bug4455_schema.test new file mode 100644 index 0000000..e58f3ed --- /dev/null +++ b/parser/testdata/corpus/sql/alter/rename_table/test_rename_bug4455_schema.test @@ -0,0 +1,37 @@ +# source: test/sql/alter/rename_table/test_rename_bug4455_schema.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +create schema public; +-- +ok +== +set schema=public; +-- +ok +== +create table a1 (c int); +-- +ok +== +alter table public.a1 rename to a2; +-- +ok +== +alter table a2 rename to a3; +-- +ok +== +create view v1 as select 42; +-- +ok +== +alter view public.v1 rename to v2; +-- +ok +== +alter view v2 rename to v3; +-- +ok +== diff --git a/parser/testdata/corpus/sql/alter/rename_table/test_rename_table.test b/parser/testdata/corpus/sql/alter/rename_table/test_rename_table.test new file mode 100644 index 0000000..a73d2e9 --- /dev/null +++ b/parser/testdata/corpus/sql/alter/rename_table/test_rename_table.test @@ -0,0 +1,81 @@ +# source: test/sql/alter/rename_table/test_rename_table.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +INSERT INTO tbl VALUES (999), (100); +-- +ok +== +ALTER TABLE tbl RENAME TO tbl2 +-- +ok +== +SELECT * FROM tbl2 +-- +ok +== +SELECT * FROM tbl +-- +ok +== +SELECT * FROM tbl; +-- +ok +== +BEGIN TRANSACTION; +-- +ok +== +ALTER TABLE tbl2 RENAME TO tbl3 +-- +ok +== +ALTER TABLE tbl3 RENAME TO tbl4 +-- +ok +== +ALTER TABLE tbl4 RENAME TO tbl5 +-- +ok +== +SELECT * FROM tbl5 +-- +ok +== +CREATE TABLE tbl2(i INTEGER); +-- +ok +== +CREATE TABLE tbl3(i INTEGER); +-- +ok +== +CREATE TABLE tbl4(i INTEGER); +-- +ok +== +CREATE TEMPORARY TABLE temp_tbl(i INTEGER); +-- +ok +== +INSERT INTO temp_tbl VALUES (42); +-- +ok +== +SELECT table_name, database_name, temporary FROM duckdb_tables() WHERE table_name='temp_tbl' +-- +ok +== +ALTER TABLE temp.temp_tbl RENAME TO temp_tbl_renamed +-- +ok +== +SELECT * FROM temp_tbl_renamed +-- +ok +== +SELECT table_name, database_name, temporary FROM duckdb_tables() WHERE table_name='temp_tbl_renamed' +-- +ok +== diff --git a/parser/testdata/corpus/sql/alter/rename_table/test_rename_table_case.test b/parser/testdata/corpus/sql/alter/rename_table/test_rename_table_case.test new file mode 100644 index 0000000..bd1ebfa --- /dev/null +++ b/parser/testdata/corpus/sql/alter/rename_table/test_rename_table_case.test @@ -0,0 +1,25 @@ +# source: test/sql/alter/rename_table/test_rename_table_case.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +create table MY_TABLE (i integer); +-- +ok +== +insert into MY_TABLE values(42); +-- +ok +== +alter table MY_TABLE rename to my_table; +-- +ok +== +select * from my_table; +-- +ok +== +select * from MY_TABLE; +-- +ok +== diff --git a/parser/testdata/corpus/sql/alter/rename_table/test_rename_table_chain_commit.test b/parser/testdata/corpus/sql/alter/rename_table/test_rename_table_chain_commit.test new file mode 100644 index 0000000..1e30fe8 --- /dev/null +++ b/parser/testdata/corpus/sql/alter/rename_table/test_rename_table_chain_commit.test @@ -0,0 +1,53 @@ +# source: test/sql/alter/rename_table/test_rename_table_chain_commit.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +CREATE TABLE entry(i INTEGER); +-- +ok +== +INSERT INTO entry VALUES (1) +-- +ok +== +SELECT * FROM entry +-- +ok +== +ALTER TABLE entry RENAME TO entry2; +-- +ok +== +CREATE TABLE entry(j INTEGER); +-- +ok +== +INSERT INTO entry VALUES (2) +-- +ok +== +ALTER TABLE entry2 RENAME TO entry3; +-- +ok +== +CREATE TABLE entry(k INTEGER); +-- +ok +== +ALTER TABLE entry3 RENAME TO entry4; +-- +ok +== +SELECT * FROM entry2 +-- +ok +== +SELECT * FROM entry3 +-- +ok +== +SELECT * FROM entry4 +-- +ok +== diff --git a/parser/testdata/corpus/sql/alter/rename_table/test_rename_table_collision.test b/parser/testdata/corpus/sql/alter/rename_table/test_rename_table_collision.test new file mode 100644 index 0000000..1155e05 --- /dev/null +++ b/parser/testdata/corpus/sql/alter/rename_table/test_rename_table_collision.test @@ -0,0 +1,97 @@ +# source: test/sql/alter/rename_table/test_rename_table_collision.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +CREATE TABLE t1(i INTEGER); +-- +ok +== +INSERT INTO t1 VALUES (1), (2), (3); +-- +ok +== +CREATE TABLE t2(i VARCHAR); +-- +ok +== +INSERT INTO t2 VALUES (4), (5), (6); +-- +ok +== +DROP TABLE t2; +-- +ok +== +ALTER TABLE t1 RENAME TO t2; +-- +ok +== +SELECT i FROM t2 ORDER BY i; +-- +ok +== +SELECT i FROM t1 ORDER BY i; +-- +ok +== +ALTER TABLE t2 RENAME TO t3; +-- +ok +== +SELECT i FROM t3 ORDER BY i +-- +ok +== +SELECT i FROM t2 ORDER BY i +-- +ok +== +DROP TABLE t3; +-- +ok +== +CREATE TABLE t2 (i integer) +-- +ok +== +INSERT INTO t2 VALUES (7), (8), (9) +-- +ok +== +ALTER TABLE t2 RENAME TO t3 +-- +ok +== +CREATE TABLE t3 (i INTEGER) +-- +ok +== +ALTER TABLE t2 RENAME TO t4 +-- +ok +== +CREATE TABLE e1 (i INTEGER) +-- +ok +== +CREATE TABLE e2 (i INTEGER) +-- +ok +== +DROP TABLE e2 +-- +ok +== +DROP TABLE e1 +-- +ok +== +ALTER TABLE e1 RENAME TO e2 +-- +ok +== +ALTER TABLE e2 RENAME TO e1 +-- +ok +== diff --git a/parser/testdata/corpus/sql/alter/rename_table/test_rename_table_constraints.test b/parser/testdata/corpus/sql/alter/rename_table/test_rename_table_constraints.test new file mode 100644 index 0000000..fb706a2 --- /dev/null +++ b/parser/testdata/corpus/sql/alter/rename_table/test_rename_table_constraints.test @@ -0,0 +1,41 @@ +# source: test/sql/alter/rename_table/test_rename_table_constraints.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +CREATE TABLE tbl(i INTEGER PRIMARY KEY, j INTEGER CHECK(j < 10)) +-- +ok +== +INSERT INTO tbl VALUES (999, 4), (1000, 5) +-- +ok +== +INSERT INTO tbl VALUES (9999, 0), (10000, 1) +-- +ok +== +INSERT INTO tbl VALUES (777, 10), (888, 10) +-- +ok +== +ALTER TABLE tbl RENAME TO new_tbl +-- +ok +== +INSERT INTO new_tbl VALUES (999, 0), (1000, 1) +-- +ok +== +INSERT INTO new_tbl VALUES (9999, 0), (10000, 1) +-- +ok +== +INSERT INTO new_tbl VALUES (1, 10), (2, 999) +-- +ok +== +INSERT INTO new_tbl VALUES (66, 6), (55, 5) +-- +ok +== diff --git a/parser/testdata/corpus/sql/alter/rename_table/test_rename_table_incorrect.test b/parser/testdata/corpus/sql/alter/rename_table/test_rename_table_incorrect.test new file mode 100644 index 0000000..f15a135 --- /dev/null +++ b/parser/testdata/corpus/sql/alter/rename_table/test_rename_table_incorrect.test @@ -0,0 +1,17 @@ +# source: test/sql/alter/rename_table/test_rename_table_incorrect.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +CREATE TABLE tbl2(i INTEGER) +-- +ok +== +ALTER TABLE non_table RENAME TO tbl +-- +ok +== +ALTER TABLE tbl2 RENAME TO tbl +-- +ok +== diff --git a/parser/testdata/corpus/sql/alter/rename_table/test_rename_table_many_transactions.test b/parser/testdata/corpus/sql/alter/rename_table/test_rename_table_many_transactions.test new file mode 100644 index 0000000..153b56f --- /dev/null +++ b/parser/testdata/corpus/sql/alter/rename_table/test_rename_table_many_transactions.test @@ -0,0 +1,29 @@ +# source: test/sql/alter/rename_table/test_rename_table_many_transactions.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +CREATE TABLE tbl1(i INTEGER) +-- +ok +== +INSERT INTO tbl1 VALUES (999), (100) +-- +ok +== +ALTER TABLE tbl1 RENAME TO tbl2 +-- +ok +== +SELECT * FROM tbl1 +-- +ok +== +SELECT * FROM tbl3 +-- +ok +== +SELECT * FROM tbl4 +-- +ok +== diff --git a/parser/testdata/corpus/sql/alter/rename_table/test_rename_table_transactions.test b/parser/testdata/corpus/sql/alter/rename_table/test_rename_table_transactions.test new file mode 100644 index 0000000..712439c --- /dev/null +++ b/parser/testdata/corpus/sql/alter/rename_table/test_rename_table_transactions.test @@ -0,0 +1,13 @@ +# source: test/sql/alter/rename_table/test_rename_table_transactions.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +INSERT INTO tbl VALUES (999), (100) +-- +ok +== +DROP TABLE tbl2; +-- +ok +== diff --git a/parser/testdata/corpus/sql/alter/rename_table/test_rename_table_view.test b/parser/testdata/corpus/sql/alter/rename_table/test_rename_table_view.test new file mode 100644 index 0000000..793b146 --- /dev/null +++ b/parser/testdata/corpus/sql/alter/rename_table/test_rename_table_view.test @@ -0,0 +1,21 @@ +# source: test/sql/alter/rename_table/test_rename_table_view.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +CREATE VIEW v1 AS SELECT * FROM tbl +-- +ok +== +ALTER TABLE v1 RENAME TO v2 +-- +ok +== +SELECT * FROM v1 +-- +ok +== +SELECT * FROM v2 +-- +ok +== diff --git a/parser/testdata/corpus/sql/alter/rename_table/test_rename_table_with_dependency_check.test b/parser/testdata/corpus/sql/alter/rename_table/test_rename_table_with_dependency_check.test new file mode 100644 index 0000000..3092ca4 --- /dev/null +++ b/parser/testdata/corpus/sql/alter/rename_table/test_rename_table_with_dependency_check.test @@ -0,0 +1,25 @@ +# source: test/sql/alter/rename_table/test_rename_table_with_dependency_check.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +CREATE UNIQUE INDEX i1 ON t0 (c0); +-- +ok +== +ALTER TABLE t0 RENAME TO t3; +-- +ok +== +CREATE TABLE t3 (c0 INT); +-- +ok +== +ALTER TABLE t0 RENAME TO t4; +-- +ok +== +ANALYZE t4; +-- +ok +== diff --git a/parser/testdata/corpus/sql/alter/rename_table/test_rename_table_with_insert_transaction.test b/parser/testdata/corpus/sql/alter/rename_table/test_rename_table_with_insert_transaction.test new file mode 100644 index 0000000..49a9f3a --- /dev/null +++ b/parser/testdata/corpus/sql/alter/rename_table/test_rename_table_with_insert_transaction.test @@ -0,0 +1,17 @@ +# source: test/sql/alter/rename_table/test_rename_table_with_insert_transaction.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +CREATE TABLE t1 (i INTEGER) +-- +ok +== +INSERT INTO t1 VALUES (2) +-- +ok +== +ALTER TABLE t1 RENAME TO t2 +-- +ok +== diff --git a/parser/testdata/corpus/sql/alter/rename_view/test_rename_view.test b/parser/testdata/corpus/sql/alter/rename_view/test_rename_view.test new file mode 100644 index 0000000..5ce63a8 --- /dev/null +++ b/parser/testdata/corpus/sql/alter/rename_view/test_rename_view.test @@ -0,0 +1,39 @@ +# source: test/sql/alter/rename_view/test_rename_view.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +CREATE TABLE tbl(i INTEGER); +INSERT INTO tbl VALUES (999), (100); +CREATE VIEW vw AS SELECT * FROM tbl; +-- +ok +== +ALTER VIEW vw RENAME TO vw2 +-- +ok +== +SELECT * FROM vw2 +-- +ok +== +SELECT * FROM vw +-- +ok +== +SELECT * FROM vw; +-- +ok +== +CREATE VIEW vw AS SELECT i+1 AS i FROM tbl +-- +ok +== +ALTER VIEW sqlite_master RENAME TO my_sqlite_master +-- +ok +== +ALTER VIEW nonexistingview RENAME TO my_new_view +-- +ok +== diff --git a/parser/testdata/corpus/sql/alter/rename_view/test_rename_view_incorrect.test b/parser/testdata/corpus/sql/alter/rename_view/test_rename_view_incorrect.test new file mode 100644 index 0000000..6846b79 --- /dev/null +++ b/parser/testdata/corpus/sql/alter/rename_view/test_rename_view_incorrect.test @@ -0,0 +1,21 @@ +# source: test/sql/alter/rename_view/test_rename_view_incorrect.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +CREATE VIEW vw AS SELECT * FROM tbl +-- +ok +== +CREATE VIEW vw2 AS SELECT 1729 AS i +-- +ok +== +ALTER VIEW non_view RENAME TO vw +-- +ok +== +ALTER VIEW vw2 RENAME TO vw +-- +ok +== diff --git a/parser/testdata/corpus/sql/alter/rename_view/test_rename_view_many_transactions.test b/parser/testdata/corpus/sql/alter/rename_view/test_rename_view_many_transactions.test new file mode 100644 index 0000000..3c6d8dd --- /dev/null +++ b/parser/testdata/corpus/sql/alter/rename_view/test_rename_view_many_transactions.test @@ -0,0 +1,33 @@ +# source: test/sql/alter/rename_view/test_rename_view_many_transactions.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +CREATE VIEW vw1 AS SELECT * FROM tbl1 +-- +ok +== +ALTER VIEW vw1 RENAME TO vw2 +-- +ok +== +ALTER VIEW vw2 RENAME TO vw3 +-- +ok +== +ALTER VIEW vw3 RENAME TO vw4 +-- +ok +== +SELECT * FROM vw1 +-- +ok +== +SELECT * FROM vw3 +-- +ok +== +SELECT * FROM vw4 +-- +ok +== diff --git a/parser/testdata/corpus/sql/alter/rename_view/test_rename_view_table.test b/parser/testdata/corpus/sql/alter/rename_view/test_rename_view_table.test new file mode 100644 index 0000000..55c5798 --- /dev/null +++ b/parser/testdata/corpus/sql/alter/rename_view/test_rename_view_table.test @@ -0,0 +1,9 @@ +# source: test/sql/alter/rename_view/test_rename_view_table.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +ALTER VIEW tbl RENAME TO tbl2 +-- +ok +== diff --git a/parser/testdata/corpus/sql/alter/struct/add_col_nested_struct.test b/parser/testdata/corpus/sql/alter/struct/add_col_nested_struct.test new file mode 100644 index 0000000..589f807 --- /dev/null +++ b/parser/testdata/corpus/sql/alter/struct/add_col_nested_struct.test @@ -0,0 +1,33 @@ +# source: test/sql/alter/struct/add_col_nested_struct.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +CREATE TABLE test(s STRUCT(s2 STRUCT(v1 INT, v2 INT))) +-- +ok +== +INSERT INTO test VALUES (ROW(ROW(1, 1))), (ROW(ROW(2, 2))) +-- +ok +== +ALTER TABLE test ADD COLUMN s.s2.k INTEGER +-- +ok +== +ALTER TABLE test ADD COLUMN s.s2.v1 VARCHAR +-- +ok +== +ALTER TABLE test ADD COLUMN IF NOT EXISTS s.s2.v1 VARCHAR +-- +ok +== +ALTER TABLE test ADD COLUMN s.i INTEGER DEFAULT 100 +-- +ok +== +ALTER TABLE test ADD COLUMN s.s2.v1.x INTEGER +-- +ok +== diff --git a/parser/testdata/corpus/sql/alter/struct/add_col_struct.test b/parser/testdata/corpus/sql/alter/struct/add_col_struct.test new file mode 100644 index 0000000..6e61766 --- /dev/null +++ b/parser/testdata/corpus/sql/alter/struct/add_col_struct.test @@ -0,0 +1,41 @@ +# source: test/sql/alter/struct/add_col_struct.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +CREATE TABLE test(s STRUCT(i INTEGER, j INTEGER)) +-- +ok +== +INSERT INTO test VALUES (ROW(1, 1)), (ROW(2, 2)) +-- +ok +== +ALTER TABLE test ADD COLUMN s.k INTEGER +-- +ok +== +ALTER TABLE test ADD COLUMN s.l INTEGER DEFAULT 42 +-- +ok +== +ALTER TABLE test ADD COLUMN s.m INTEGER DEFAULT 42 +-- +ok +== +ALTER TABLE test ADD COLUMN s.i VARCHAR +-- +ok +== +ALTER TABLE test ADD COLUMN IF NOT EXISTS s.i VARCHAR +-- +ok +== +ALTER TABLE test ADD COLUMN s.i.a INTEGER +-- +ok +== +ALTER TABLE test ADD COLUMN s.x.a INTEGER +-- +ok +== diff --git a/parser/testdata/corpus/sql/alter/struct/drop_col_nested_struct.test b/parser/testdata/corpus/sql/alter/struct/drop_col_nested_struct.test new file mode 100644 index 0000000..af128e0 --- /dev/null +++ b/parser/testdata/corpus/sql/alter/struct/drop_col_nested_struct.test @@ -0,0 +1,29 @@ +# source: test/sql/alter/struct/drop_col_nested_struct.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +CREATE TABLE test(s STRUCT(i INT, s2 STRUCT(v1 INT, v2 INT))) +-- +ok +== +INSERT INTO test VALUES (ROW(42, ROW(1, 1))), (ROW(84, ROW(2, 2))) +-- +ok +== +ALTER TABLE test DROP s.s2.v1 +-- +ok +== +ALTER TABLE test DROP COLUMN s.s2.v1 +-- +ok +== +ALTER TABLE test DROP COLUMN IF EXISTS s.s2.v1 +-- +ok +== +ALTER TABLE test DROP COLUMN s.s2 +-- +ok +== diff --git a/parser/testdata/corpus/sql/alter/struct/drop_col_struct.test b/parser/testdata/corpus/sql/alter/struct/drop_col_struct.test new file mode 100644 index 0000000..81b4fb6 --- /dev/null +++ b/parser/testdata/corpus/sql/alter/struct/drop_col_struct.test @@ -0,0 +1,33 @@ +# source: test/sql/alter/struct/drop_col_struct.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +ALTER TABLE test DROP COLUMN s.i +-- +ok +== +ALTER TABLE test DROP COLUMN s.j +-- +ok +== +ALTER TABLE test DROP COLUMN s.v +-- +ok +== +ALTER TABLE test DROP COLUMN IF EXISTS s.v +-- +ok +== +ALTER TABLE test DROP COLUMN s.j.a +-- +ok +== +ALTER TABLE test DROP COLUMN z.j +-- +ok +== +ALTER TABLE test DROP COLUMN s.v1.a +-- +ok +== diff --git a/parser/testdata/corpus/sql/alter/struct/rename_col_nested_struct.test b/parser/testdata/corpus/sql/alter/struct/rename_col_nested_struct.test new file mode 100644 index 0000000..5c95937 --- /dev/null +++ b/parser/testdata/corpus/sql/alter/struct/rename_col_nested_struct.test @@ -0,0 +1,49 @@ +# source: test/sql/alter/struct/rename_col_nested_struct.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +ALTER TABLE test RENAME s.s2.v1 TO i +-- +ok +== +ALTER TABLE test RENAME COLUMN s.s2.v2 TO i +-- +ok +== +ALTER TABLE test RENAME COLUMN s.s2 TO x +-- +ok +== +CREATE TABLE test_default(s STRUCT(s2 STRUCT(a INTEGER, b INTEGER)) DEFAULT {'s2': {'a': 1, 'b': 2}}) +-- +ok +== +INSERT INTO test_default DEFAULT VALUES +-- +ok +== +ALTER TABLE test_default RENAME s.s2.a TO c +-- +ok +== +SELECT s FROM test_default +-- +ok +== +CREATE TABLE test_default_parent(s STRUCT(s2 STRUCT(a INTEGER, b INTEGER)) DEFAULT {'s2': {'a': 1, 'b': 2}}) +-- +ok +== +INSERT INTO test_default_parent DEFAULT VALUES +-- +ok +== +ALTER TABLE test_default_parent RENAME s.s2 TO x +-- +ok +== +SELECT s FROM test_default_parent +-- +ok +== diff --git a/parser/testdata/corpus/sql/alter/struct/rename_col_struct.test b/parser/testdata/corpus/sql/alter/struct/rename_col_struct.test new file mode 100644 index 0000000..20dc395 --- /dev/null +++ b/parser/testdata/corpus/sql/alter/struct/rename_col_struct.test @@ -0,0 +1,56 @@ +# source: test/sql/alter/struct/rename_col_struct.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +ALTER TABLE test RENAME s.i TO v1 +-- +ok +== +ALTER TABLE test RENAME s.j TO v2 +-- +ok +== +ALTER TABLE test RENAME s.j TO v1 +-- +ok +== +ALTER TABLE test RENAME s.j.x TO v2 +-- +ok +== +ALTER TABLE test RENAME s.i TO v2 +-- +ok +== +ALTER TABLE test RENAME x.i TO v2 +-- +ok +== +CREATE TABLE test_default(s STRUCT(a INTEGER, b INTEGER) DEFAULT {'a': 1, 'b': 2}) +-- +ok +== +ALTER TABLE test_default RENAME s.a TO c +-- +ok +== +CREATE TABLE test_cast_default( + s STRUCT(a INTEGER, b INTEGER) + DEFAULT (struct_pack(a := 1, b := 2)::STRUCT(a INTEGER, b INTEGER)) +) +-- +ok +== +ALTER TABLE test_cast_default RENAME s.a TO c +-- +ok +== +INSERT INTO test_cast_default DEFAULT VALUES +-- +ok +== +SELECT s FROM test_cast_default +-- +ok +== diff --git a/parser/testdata/corpus/sql/alter/struct/rename_col_struct_case_insensitive.test b/parser/testdata/corpus/sql/alter/struct/rename_col_struct_case_insensitive.test new file mode 100644 index 0000000..f7331d7 --- /dev/null +++ b/parser/testdata/corpus/sql/alter/struct/rename_col_struct_case_insensitive.test @@ -0,0 +1,9 @@ +# source: test/sql/alter/struct/rename_col_struct_case_insensitive.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +CREATE TABLE test(S STRUCT(i INTEGER, j INTEGER)) +-- +ok +== diff --git a/parser/testdata/corpus/sql/alter/test_alter_database_rename.test b/parser/testdata/corpus/sql/alter/test_alter_database_rename.test new file mode 100644 index 0000000..ff90c5c --- /dev/null +++ b/parser/testdata/corpus/sql/alter/test_alter_database_rename.test @@ -0,0 +1,49 @@ +# source: test/sql/alter/test_alter_database_rename.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +ATTACH ':memory:' AS test_db; +-- +ok +== +CREATE TABLE test_db.sample AS SELECT i FROM range(100) t(i); +-- +ok +== +SELECT COUNT(*) FROM test_db.sample +-- +ok +== +ALTER DATABASE test_db SET ALIAS TO renamed_db; +-- +ok +== +SELECT COUNT(*) FROM renamed_db.sample +-- +ok +== +ALTER DATABASE non_existent SET ALIAS TO something_else; +-- +ok +== +ALTER DATABASE IF EXISTS non_existent SET ALIAS TO something_else; +-- +ok +== +ATTACH ':memory:' AS another_db; +-- +ok +== +ALTER DATABASE another_db SET ALIAS TO renamed_db; +-- +ok +== +ALTER DATABSE renamed_db RENAME TO system; +-- +error: Parser Error: syntax error at or near "DATABSE" +== +ALTER DATABSE renamed_db RENAME TO temp; +-- +error: Parser Error: syntax error at or near "DATABSE" +== diff --git a/parser/testdata/corpus/sql/alter/test_alter_if_exists.test b/parser/testdata/corpus/sql/alter/test_alter_if_exists.test new file mode 100644 index 0000000..a5d3fc3 --- /dev/null +++ b/parser/testdata/corpus/sql/alter/test_alter_if_exists.test @@ -0,0 +1,137 @@ +# source: test/sql/alter/test_alter_if_exists.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +ALTER SEQUENCE IF EXISTS seq OWNED BY x; +-- +ok +== +ALTER TABLE IF EXISTS t0 ADD COLUMN c0 INT; +-- +ok +== +ALTER TABLE IF EXISTS t0 ADD COLUMN IF NOT EXISTS c0 int; +-- +ok +== +ALTER TABLE t0 ADD COLUMN IF NOT EXISTS c0 int; +-- +ok +== +ALTER TABLE t0 ADD COLUMN c0 int; +-- +ok +== +ALTER TABLE t0 ADD COLUMN c1 int; +-- +ok +== +INSERT INTO t0 VALUES (42, 43); +-- +ok +== +ALTER TABLE t0 ADD COLUMN IF NOT EXISTS c2 int; +-- +ok +== +INSERT INTO t0 VALUES (42, 43, 44); +-- +ok +== +ALTER TABLE IF EXISTS t1 DROP COLUMN IF EXISTS c3; +-- +ok +== +ALTER TABLE IF EXISTS t0 DROP COLUMN if EXISTS c3; +-- +ok +== +ALTER TABLE t1 DROP COLUMN IF EXISTS c3; +-- +ok +== +ALTER TABLE t1 DROP COLUMN c3; +-- +ok +== +ALTER TABLE t0 DROP COLUMN c3; +-- +ok +== +ALTER TABLE t0 DROP COLUMN IF EXISTS c3 +-- +ok +== +ALTER TABLE IF EXISTS t0 DROP COLUMN c3 +-- +ok +== +ALTER TABLE IF EXISTS t1 ALTER COLUMN c0 TYPE varchar; +-- +ok +== +ALTER TABLE IF EXISTS t1 ALTER COLUMN IF EXISTS c0 TYPE varchar; +-- +error: Parser Error: syntax error at or near "EXISTS" +== +CREATE TABLE t_default (c0 INT, c1 BOOLEAN); +-- +ok +== +ALTER TABLE t_default ADD COLUMN IF NOT EXISTS c1 BOOLEAN DEFAULT false; +-- +ok +== +ALTER TABLE t_default ADD COLUMN IF NOT EXISTS c2 BOOLEAN DEFAULT false; +-- +ok +== +INSERT INTO t_default VALUES (1, true, true); +-- +ok +== +SELECT * FROM t_default; +-- +ok +== +CREATE TABLE unit (price INTEGER, amount_sold INTEGER); +-- +ok +== +ALTER TABLE unit DROP COLUMN IF EXISTS rowid; +-- +ok +== +SELECT rowid FROM unit; +-- +ok +== +INSERT INTO unit VALUES (10, 5); +-- +ok +== +ALTER TABLE unit ADD COLUMN rowid INTEGER; +-- +ok +== +INSERT INTO unit VALUES (20, 10, 1337); +-- +ok +== +INSERT INTO unit VALUES (30, 20); +-- +ok +== +ALTER TABLE unit ADD COLUMN IF NOT EXISTS rowid INTEGER; +-- +ok +== +INSERT INTO unit VALUES (40, 30, 1337); +-- +ok +== +ALTER TABLE unit DROP COLUMN rowid; +-- +ok +== diff --git a/parser/testdata/corpus/sql/attach/attach_all_types.test b/parser/testdata/corpus/sql/attach/attach_all_types.test new file mode 100644 index 0000000..5eae63e --- /dev/null +++ b/parser/testdata/corpus/sql/attach/attach_all_types.test @@ -0,0 +1,25 @@ +# source: test/sql/attach/attach_all_types.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +ATTACH '{TEST_DIR}/attach_all_types.db' AS db1 (STORAGE_VERSION 'v2.0.0') +-- +ok +== +CREATE TABLE db1.all_types AS SELECT * FROM test_all_types(); +-- +ok +== +SELECT * FROM test_all_types() +-- +ok +== +SELECT * FROM db1.all_types +-- +ok +== +ATTACH '{TEST_DIR}/attach_all_types.db' AS db1 +-- +ok +== diff --git a/parser/testdata/corpus/sql/attach/attach_catalog_error_early_out.test b/parser/testdata/corpus/sql/attach/attach_catalog_error_early_out.test new file mode 100644 index 0000000..760470b --- /dev/null +++ b/parser/testdata/corpus/sql/attach/attach_catalog_error_early_out.test @@ -0,0 +1,17 @@ +# source: test/sql/attach/attach_catalog_error_early_out.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +SET catalog_error_max_schemas = 0; +-- +ok +== +ATTACH '{TEST_DIR}/did_you_mean_db_{i}.db'; +-- +ok +== +FROM tbl; +-- +ok +== diff --git a/parser/testdata/corpus/sql/attach/attach_checkpoint_on_detach.test b/parser/testdata/corpus/sql/attach/attach_checkpoint_on_detach.test new file mode 100644 index 0000000..37cb88b --- /dev/null +++ b/parser/testdata/corpus/sql/attach/attach_checkpoint_on_detach.test @@ -0,0 +1,141 @@ +# source: test/sql/attach/attach_checkpoint_on_detach.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +SET wal_autocheckpoint = '1TB'; +-- +ok +== +ATTACH '{TEST_DIR}/test1.db' AS test1; +-- +ok +== +CREATE TABLE test1.tbl AS SELECT range AS id FROM range(100); +-- +ok +== +DETACH test1; +-- +ok +== +SELECT COUNT(*) FROM glob('{TEST_DIR}/test1.db.wal') +-- +ok +== +ATTACH '{TEST_DIR}/test2.db' AS test2; +-- +ok +== +CREATE TABLE test2.tbl AS SELECT range AS id FROM range(100); +-- +ok +== +DETACH test2; +-- +ok +== +SELECT COUNT(*) FROM glob('{TEST_DIR}/test2.db.wal') +-- +ok +== +PRAGMA enable_checkpoint_on_shutdown; +-- +ok +== +SET checkpoint_on_detach = 'ENABLED'; +-- +ok +== +ATTACH '{TEST_DIR}/test3.db' AS test3; +-- +ok +== +CREATE TABLE test3.tbl AS SELECT range AS id FROM range(100); +-- +ok +== +DETACH test3; +-- +ok +== +SELECT COUNT(*) FROM glob('{TEST_DIR}/test3.db.wal') +-- +ok +== +ATTACH '{TEST_DIR}/test4.db' AS test4; +-- +ok +== +CREATE TABLE test4.tbl AS SELECT range AS id FROM range(100); +-- +ok +== +DETACH test4; +-- +ok +== +SELECT COUNT(*) FROM glob('{TEST_DIR}/test4.db.wal') +-- +ok +== +SET checkpoint_on_detach = 'DISABLED'; +-- +ok +== +ATTACH '{TEST_DIR}/test5.db' AS test5; +-- +ok +== +CREATE TABLE test5.tbl AS SELECT range AS id FROM range(100); +-- +ok +== +DETACH test5; +-- +ok +== +SELECT COUNT(*) FROM glob('{TEST_DIR}/test5.db.wal') +-- +ok +== +ATTACH '{TEST_DIR}/test6.db' AS test6; +-- +ok +== +CREATE TABLE test6.tbl AS SELECT range AS id FROM range(100); +-- +ok +== +DETACH test6; +-- +ok +== +SELECT COUNT(*) FROM glob('{TEST_DIR}/test6.db.wal') +-- +ok +== +RESET checkpoint_on_detach; +-- +ok +== +ATTACH '{TEST_DIR}/test7.db' AS test7; +-- +ok +== +CREATE TABLE test7.tbl AS SELECT range AS id FROM range(100); +-- +ok +== +DETACH test7; +-- +ok +== +SELECT COUNT(*) FROM glob('{TEST_DIR}/test7.db.wal') +-- +ok +== +SET checkpoint_on_detach = 'blah blah blah'; +-- +ok +== diff --git a/parser/testdata/corpus/sql/attach/attach_checkpoint_vacuum.test b/parser/testdata/corpus/sql/attach/attach_checkpoint_vacuum.test new file mode 100644 index 0000000..82480e4 --- /dev/null +++ b/parser/testdata/corpus/sql/attach/attach_checkpoint_vacuum.test @@ -0,0 +1,21 @@ +# source: test/sql/attach/attach_checkpoint_vacuum.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +ATTACH '{TEST_DIR}/attach_vacuum.db' AS db1 +-- +ok +== +CREATE TABLE db1.integers(i INTEGER); +-- +ok +== +CHECKPOINT db1 +-- +ok +== +VACUUM db1.integers +-- +ok +== diff --git a/parser/testdata/corpus/sql/attach/attach_copy.test b/parser/testdata/corpus/sql/attach/attach_copy.test new file mode 100644 index 0000000..955d7cf --- /dev/null +++ b/parser/testdata/corpus/sql/attach/attach_copy.test @@ -0,0 +1,33 @@ +# source: test/sql/attach/attach_copy.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +ATTACH DATABASE ':memory:' AS db1; +-- +ok +== +CREATE TABLE db1.test(a INTEGER, b INTEGER, c VARCHAR(10)); +-- +ok +== +COPY db1.test FROM '{DATA_DIR}/csv/test/test.csv'; +-- +ok +== +COPY db1.main.test FROM '{DATA_DIR}/csv/test/test.csv'; +-- +ok +== +COPY db1.main.test TO '{TEMP_DIR}/test.csv'; +-- +ok +== +USE db1 +-- +ok +== +COPY test FROM '{DATA_DIR}/csv/test/test.csv'; +-- +ok +== diff --git a/parser/testdata/corpus/sql/attach/attach_create_index.test b/parser/testdata/corpus/sql/attach/attach_create_index.test new file mode 100644 index 0000000..ce962f0 --- /dev/null +++ b/parser/testdata/corpus/sql/attach/attach_create_index.test @@ -0,0 +1,17 @@ +# source: test/sql/attach/attach_create_index.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +ATTACH '' AS tmp; +-- +ok +== +CREATE TABLE tmp.t1(id int); +-- +ok +== +CREATE INDEX idx ON tmp.t1(id); +-- +ok +== diff --git a/parser/testdata/corpus/sql/attach/attach_cross_catalog.test b/parser/testdata/corpus/sql/attach/attach_cross_catalog.test new file mode 100644 index 0000000..42439ed --- /dev/null +++ b/parser/testdata/corpus/sql/attach/attach_cross_catalog.test @@ -0,0 +1,33 @@ +# source: test/sql/attach/attach_cross_catalog.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +CREATE TABLE test(a INTEGER); +-- +ok +== +CREATE INDEX index ON test(a) +-- +ok +== +CREATE INDEX db1.index ON test(a) +-- +error: Parser Error: syntax error at or near "." +== +CREATE TYPE db1.mood AS ENUM('ok', 'sad', 'happy'); +-- +ok +== +CREATE TABLE db1.integers(i mood) +-- +ok +== +CREATE TABLE integers(i mood) +-- +ok +== +SELECT 'happy'::mood +-- +ok +== diff --git a/parser/testdata/corpus/sql/attach/attach_custom_block_size.test b/parser/testdata/corpus/sql/attach/attach_custom_block_size.test new file mode 100644 index 0000000..ebc8029 --- /dev/null +++ b/parser/testdata/corpus/sql/attach/attach_custom_block_size.test @@ -0,0 +1,65 @@ +# source: test/sql/attach/attach_custom_block_size.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +ATTACH '{TEST_DIR}/not_pow_of_two.db' (BLOCK_SIZE 123456); +-- +ok +== +ATTACH '{TEST_DIR}/exceeds_maximum.db' (BLOCK_SIZE 2147483648); +-- +ok +== +ATTACH '{TEST_DIR}/not_default.db' (BLOCK_SIZE 16384); +-- +ok +== +ATTACH '{TEST_DIR}/too_small.db' (BLOCK_SIZE 128); +-- +ok +== +ATTACH '{TEST_DIR}/default_size.db' (BLOCK_SIZE 262144); +-- +ok +== +DETACH default_size; +-- +ok +== +ATTACH '{TEST_DIR}/default_size.db' (BLOCK_SIZE 16384); +-- +ok +== +ATTACH '{TEST_DIR}/default_size.db'; +-- +ok +== +ATTACH '{TEST_DIR}/dbname.db' (BLOCK_SIZE 16384); +-- +ok +== +DETACH dbname; +-- +ok +== +ATTACH '{TEST_DIR}/dbname.db'; +-- +ok +== +SET default_block_size = '123456'; +-- +ok +== +SET default_block_size = '16384'; +-- +ok +== +SET default_block_size = '128'; +-- +ok +== +SET default_block_size = '262144'; +-- +ok +== diff --git a/parser/testdata/corpus/sql/attach/attach_database_options.test b/parser/testdata/corpus/sql/attach/attach_database_options.test new file mode 100644 index 0000000..b3dddff --- /dev/null +++ b/parser/testdata/corpus/sql/attach/attach_database_options.test @@ -0,0 +1,17 @@ +# source: test/sql/attach/attach_database_options.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +ATTACH DATABASE ':memory:' AS new_database (BLOCK_SIZE 262144, ROW_GROUP_SIZE 2048); +-- +ok +== +SELECT options['block_size'] from duckdb_databases() where database_name = 'new_database'; +-- +ok +== +SELECT options['row_group_size'] from duckdb_databases() where database_name = 'new_database'; +-- +ok +== diff --git a/parser/testdata/corpus/sql/attach/attach_database_size.test b/parser/testdata/corpus/sql/attach/attach_database_size.test new file mode 100644 index 0000000..60617d3 --- /dev/null +++ b/parser/testdata/corpus/sql/attach/attach_database_size.test @@ -0,0 +1,21 @@ +# source: test/sql/attach/attach_database_size.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +ATTACH '{TEST_DIR}/attach_database_size.db' AS db1 +-- +ok +== +SELECT database_name FROM pragma_database_size() WHERE database_name = 'db1'; +-- +ok +== +ATTACH ':memory:' AS db2 +-- +ok +== +SELECT database_name FROM pragma_database_size() WHERE database_name = 'db1' OR database_name = 'db2' ORDER BY ALL; +-- +ok +== diff --git a/parser/testdata/corpus/sql/attach/attach_dbname_quotes.test b/parser/testdata/corpus/sql/attach/attach_dbname_quotes.test new file mode 100644 index 0000000..56bc5dd --- /dev/null +++ b/parser/testdata/corpus/sql/attach/attach_dbname_quotes.test @@ -0,0 +1,57 @@ +# source: test/sql/attach/attach_dbname_quotes.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +ATTACH ':memory:' as "my""db"; +-- +ok +== +CREATE TABLE "my""db".tbl(i int); +-- +ok +== +INSERT INTO "my""db".tbl VALUES (42) +-- +ok +== +USE "my""db"; +-- +ok +== +SET search_path=current_setting('search_path') +-- +ok +== +ATTACH '{TEST_DIR}/attach_quoated_base.db' +-- +ok +== +USE attach_quoated_base +-- +ok +== +CREATE SCHEMA "my""db"."my""schema" +-- +ok +== +CREATE TABLE "my""db"."my""schema".tbl(i int); +-- +ok +== +INSERT INTO "my""db"."my""schema".tbl VALUES (84) +-- +ok +== +USE "my""db"."my""schema" +-- +ok +== +CREATE SCHEMA """" +-- +ok +== +USE """" +-- +ok +== diff --git a/parser/testdata/corpus/sql/attach/attach_default_database_case.test b/parser/testdata/corpus/sql/attach/attach_default_database_case.test new file mode 100644 index 0000000..c279853 --- /dev/null +++ b/parser/testdata/corpus/sql/attach/attach_default_database_case.test @@ -0,0 +1,29 @@ +# source: test/sql/attach/attach_default_database_case.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +ATTACH ':memory:' AS MyDB; +-- +ok +== +USE MyDB; +-- +ok +== +SELECT current_database() +-- +ok +== +DETACH mydb; +-- +ok +== +DETACH MyDB; +-- +ok +== +USE memory; +-- +ok +== diff --git a/parser/testdata/corpus/sql/attach/attach_default_table.test b/parser/testdata/corpus/sql/attach/attach_default_table.test new file mode 100644 index 0000000..13da0d9 --- /dev/null +++ b/parser/testdata/corpus/sql/attach/attach_default_table.test @@ -0,0 +1,77 @@ +# source: test/sql/attach/attach_default_table.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +attach '{TEST_DIR}/test.db' as ddb (default_table 'my_table') +-- +ok +== +FROM ddb +-- +ok +== +CREATE OR REPLACE TABLE ddb.my_table AS (SELECT 1337 as value); +-- +ok +== +from ddb +-- +ok +== +from ddb.my_table +-- +ok +== +from ddb.main.my_table +-- +ok +== +create table ddb as select 42 as value +-- +ok +== +from memory.main.ddb +-- +ok +== +SELECT + t1.value, + t2.value +FROM + memory.main.ddb as t1 +JOIN + ddb.main.my_table as t2 +ON + t1.value != t2.value +-- +ok +== +use ddb +-- +ok +== +from my_table +-- +ok +== +from main.my_table +-- +ok +== +use memory +-- +ok +== +DROP TABLE memory.main.ddb +-- +ok +== +CREATE VIEW ddb as SELECT 1 +-- +ok +== +DROP VIEW ddb; +-- +ok +== diff --git a/parser/testdata/corpus/sql/attach/attach_defaults.test b/parser/testdata/corpus/sql/attach/attach_defaults.test new file mode 100644 index 0000000..7b131e6 --- /dev/null +++ b/parser/testdata/corpus/sql/attach/attach_defaults.test @@ -0,0 +1,17 @@ +# source: test/sql/attach/attach_defaults.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +ATTACH DATABASE ':memory:' AS new_database; +-- +ok +== +ATTACH ':memory:' AS new_database; +-- +ok +== +ATTACH ':memory:' +-- +ok +== diff --git a/parser/testdata/corpus/sql/attach/attach_dependencies.test b/parser/testdata/corpus/sql/attach/attach_dependencies.test new file mode 100644 index 0000000..5c31226 --- /dev/null +++ b/parser/testdata/corpus/sql/attach/attach_dependencies.test @@ -0,0 +1,57 @@ +# source: test/sql/attach/attach_dependencies.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +CREATE TABLE pk_tbl (id INTEGER PRIMARY KEY, name VARCHAR UNIQUE); +-- +ok +== +CREATE TABLE fk_tbl (id INTEGER REFERENCES pk_tbl(id)); +-- +ok +== +CREATE TABLE tbl_alter_column (id INT, other INT, nn_col INT NOT NULL, rm INT, rename_c INT, my_def INT, drop_def INT DEFAULT 10, new_null_col INT); +-- +ok +== +ALTER TABLE tbl_alter_column ADD COLUMN k INTEGER; +-- +ok +== +ALTER TABLE tbl_alter_column ALTER other SET DATA TYPE VARCHAR USING concat(other, '_', 'yay'); +-- +ok +== +ALTER TABLE tbl_alter_column ALTER COLUMN nn_col DROP NOT NULL; +-- +ok +== +ALTER TABLE tbl_alter_column DROP rm; +-- +ok +== +ALTER TABLE tbl_alter_column RENAME rename_c TO my_new_col; +-- +ok +== +ALTER TABLE tbl_alter_column ALTER COLUMN my_def SET DEFAULT 10; +-- +ok +== +ALTER TABLE tbl_alter_column ALTER COLUMN drop_def DROP DEFAULT; +-- +ok +== +ALTER TABLE tbl_alter_column ALTER COLUMN new_null_col SET NOT NULL; +-- +ok +== +ATTACH '{TEST_DIR}/fk.db'; +-- +ok +== +ATTACH '{TEST_DIR}/alter_column.db'; +-- +ok +== diff --git a/parser/testdata/corpus/sql/attach/attach_did_you_mean.test b/parser/testdata/corpus/sql/attach/attach_did_you_mean.test new file mode 100644 index 0000000..aa4bd99 --- /dev/null +++ b/parser/testdata/corpus/sql/attach/attach_did_you_mean.test @@ -0,0 +1,57 @@ +# source: test/sql/attach/attach_did_you_mean.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +CREATE TABLE hello(i INTEGER); +-- +ok +== +CREATE TABLE db1.test(a INTEGER); +-- +ok +== +CREATE SCHEMA db1.myschema +-- +ok +== +CREATE TABLE db1.myschema.blablabla(i INTEGER) +-- +ok +== +SELECT * FROM blablabla; +-- +ok +== +SET catalog_error_max_schemas=0 +-- +ok +== +RESET catalog_error_max_schemas +-- +ok +== +SELECT * FROM blablabla +-- +ok +== +SELECT * FROM myschema.blablabla +-- +ok +== +SELECT * FROM hello; +-- +ok +== +SELECT * FROM memory.hello +-- +ok +== +USE db1.myschema +-- +ok +== +SELECT * FROM db1.main.test +-- +ok +== diff --git a/parser/testdata/corpus/sql/attach/attach_different_alias.test b/parser/testdata/corpus/sql/attach/attach_different_alias.test new file mode 100644 index 0000000..e6644a5 --- /dev/null +++ b/parser/testdata/corpus/sql/attach/attach_different_alias.test @@ -0,0 +1,29 @@ +# source: test/sql/attach/attach_different_alias.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +ATTACH '{TEST_DIR}/attach_alias.db' AS alias1 +-- +ok +== +create table alias1.tbl1 as select 1 as a; +-- +ok +== +FROM alias1.tbl1 +-- +ok +== +DETACH alias1 +-- +ok +== +ATTACH '{TEST_DIR}/attach_alias.db' AS alias2 +-- +ok +== +FROM alias2.tbl1 +-- +ok +== diff --git a/parser/testdata/corpus/sql/attach/attach_duckdb_type.test b/parser/testdata/corpus/sql/attach/attach_duckdb_type.test new file mode 100644 index 0000000..d0f2f68 --- /dev/null +++ b/parser/testdata/corpus/sql/attach/attach_duckdb_type.test @@ -0,0 +1,21 @@ +# source: test/sql/attach/attach_duckdb_type.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +ATTACH '{TEST_DIR}/first.db' (TYPE DUCKDB); +-- +ok +== +SELECT database_name FROM duckdb_databases() WHERE database_name = 'first'; +-- +ok +== +ATTACH '{TEST_DIR}/error.db' (TYPE DUCKDB, HELLO, OPTION 2); +-- +ok +== +ATTACH '{TEST_DIR}/error.db' (HELLO, OPTION 2); +-- +ok +== diff --git a/parser/testdata/corpus/sql/attach/attach_enable_external_access.test b/parser/testdata/corpus/sql/attach/attach_enable_external_access.test new file mode 100644 index 0000000..db0cabd --- /dev/null +++ b/parser/testdata/corpus/sql/attach/attach_enable_external_access.test @@ -0,0 +1,37 @@ +# source: test/sql/attach/attach_enable_external_access.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +ATTACH '{TEST_DIR}/attach_access1.db' AS a1 +-- +ok +== +ATTACH '{TEST_DIR}/attach_access2.db' AS a2 +-- +ok +== +SET enable_external_access=false +-- +ok +== +CREATE TABLE a1.test (a INTEGER PRIMARY KEY, b INTEGER); +-- +ok +== +CHECKPOINT a1 +-- +ok +== +CREATE TABLE a2.test (a INTEGER PRIMARY KEY, b INTEGER); +-- +ok +== +CHECKPOINT a2 +-- +ok +== +ATTACH '{TEST_DIR}/attach_access3.db' AS a2 +-- +ok +== diff --git a/parser/testdata/corpus/sql/attach/attach_encrypted_db_key_test.test b/parser/testdata/corpus/sql/attach/attach_encrypted_db_key_test.test new file mode 100644 index 0000000..f32def6 --- /dev/null +++ b/parser/testdata/corpus/sql/attach/attach_encrypted_db_key_test.test @@ -0,0 +1,53 @@ +# source: test/sql/attach/attach_encrypted_db_key_test.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +ATTACH '{TEST_DIR}/encrypted.duckdb' AS encrypted (ENCRYPTION_KEY); +-- +ok +== +ATTACH '{TEST_DIR}/base64_encrypted.duckdb' AS base64 (ENCRYPTION_KEY 'sYfVG1ZZN1mdtMP7Hd+2KLoU1iqglOMQQmhMm7ZnB8o='); +-- +ok +== +ATTACH '{TEST_DIR}/nobase64_encrypted.duckdb' AS nobase64 (ENCRYPTION_KEY 'gH8@#v$k1!!9=+=rYZ^32x==0plm*'); +-- +ok +== +ATTACH '{TEST_DIR}/encrypted.duckdb' AS encrypted (ENCRYPTION_KEY ''); +-- +ok +== +ATTACH '{TEST_DIR}/encrypted.duckdb' AS encrypted (ENCRYPTION_KEY 'asdf'); +-- +ok +== +ATTACH '{TEST_DIR}/encrypted_aws_key.duckdb' AS encrypted_aws (ENCRYPTION_KEY 'wJalrXUtnFEMI/K7MDENG/bPxRfiCY0000EXAMPLEKEY'); +-- +ok +== +DETACH encrypted +-- +ok +== +DETACH encrypted_aws +-- +ok +== +ATTACH '{TEST_DIR}/encrypted.duckdb' AS encrypted (ENCRYPTION_KEY 'xxxx'); +-- +ok +== +ATTACH '{TEST_DIR}/encrypted.duckdb' AS encrypted; +-- +ok +== +ATTACH '{TEST_DIR}/encrypted.duckdb' AS encrypted (ENCRYPTION_KEY 'asdfx'); +-- +ok +== +ATTACH '{TEST_DIR}/encrypted_aws_key.duckdb' AS encrypted_aws (ENCRYPTION_KEY 'wJalrXUtnFEMI/K7MDENG/bPxRfiCYEXAMPLEKEX'); +-- +ok +== diff --git a/parser/testdata/corpus/sql/attach/attach_encryption_block_header.test b/parser/testdata/corpus/sql/attach/attach_encryption_block_header.test new file mode 100644 index 0000000..4ed636b --- /dev/null +++ b/parser/testdata/corpus/sql/attach/attach_encryption_block_header.test @@ -0,0 +1,57 @@ +# source: test/sql/attach/attach_encryption_block_header.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +ATTACH '{TEST_DIR}/encrypted.duckdb' AS encrypted (ENCRYPTION_KEY 42); +-- +ok +== +ATTACH '{TEST_DIR}/unencrypted.duckdb' (STORAGE_VERSION 'v1.0.0'); +-- +ok +== +CREATE OR REPLACE TABLE encrypted.tbl AS SELECT * FROM range(10) t(i); +-- +ok +== +CREATE OR REPLACE TABLE unencrypted.tbl AS SELECT * FROM range(10) t(i); +-- +ok +== +SELECT SUM(i) FROM encrypted.tbl +-- +ok +== +SELECT SUM(i) FROM unencrypted.tbl +-- +ok +== +DETACH unencrypted +-- +ok +== +ATTACH '{TEST_DIR}/encrypted.duckdb' AS encrypted +-- +ok +== +ATTACH '{TEST_DIR}/unencrypted.duckdb' AS unencrypted (ENCRYPTION_KEY 'asdf'); +-- +ok +== +ATTACH '{TEST_DIR}/unencrypted.duckdb'; +-- +ok +== +SELECT tags FROM duckdb_databases() WHERE database_name LIKE '%encrypted%' ORDER BY database_name; +-- +ok +== +ATTACH '{TEST_DIR}/incompatible_parameters.duckdb' (ENCRYPTION_KEY 'asdf', STORAGE_VERSION 'v1.2.0'); +-- +ok +== +ATTACH '{TEST_DIR}/compatible_parameters.duckdb' (ENCRYPTION_KEY 'asdf', STORAGE_VERSION 'v1.4.0'); +-- +ok +== diff --git a/parser/testdata/corpus/sql/attach/attach_encryption_downgrade_prevention.test b/parser/testdata/corpus/sql/attach/attach_encryption_downgrade_prevention.test new file mode 100644 index 0000000..c5a3142 --- /dev/null +++ b/parser/testdata/corpus/sql/attach/attach_encryption_downgrade_prevention.test @@ -0,0 +1,17 @@ +# source: test/sql/attach/attach_encryption_downgrade_prevention.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +ATTACH 'data/attach_test/encrypted_ctr_key=abcde.db' as enc (ENCRYPTION_KEY 'abcde'); +-- +ok +== +ATTACH 'data/attach_test/encrypted_ctr_key=abcde.db' as enc1 (ENCRYPTION_KEY 'abcde', ENCRYPTION_CIPHER 'CTR'); +-- +ok +== +ATTACH 'data/attach_test/encrypted_gcm_key=abcde.db' as enc2 (ENCRYPTION_KEY 'abcde'); +-- +ok +== diff --git a/parser/testdata/corpus/sql/attach/attach_encryption_fallback_readonly.test b/parser/testdata/corpus/sql/attach/attach_encryption_fallback_readonly.test new file mode 100644 index 0000000..aba9302 --- /dev/null +++ b/parser/testdata/corpus/sql/attach/attach_encryption_fallback_readonly.test @@ -0,0 +1,49 @@ +# source: test/sql/attach/attach_encryption_fallback_readonly.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +set autoinstall_known_extensions=false +-- +ok +== +set autoload_known_extensions=false +-- +ok +== +ATTACH 'data/attach_test/encrypted_gcm_key=abcde.db' as enc (ENCRYPTION_KEY 'abcde', ENCRYPTION_CIPHER 'GCM'); +-- +ok +== +ATTACH 'data/attach_test/encrypted_gcm_key=abcde.db' as enc (ENCRYPTION_KEY 'abcde', ENCRYPTION_CIPHER 'GCM', READ_ONLY); +-- +ok +== +FROM enc.test ORDER BY value +-- +ok +== +DETACH enc +-- +ok +== +ATTACH '{TEST_DIR}/test_write_only.db' as enc (ENCRYPTION_KEY 'abcde', ENCRYPTION_CIPHER 'GCM'); +-- +ok +== +SET force_mbedtls_unsafe = 'true' +-- +ok +== +SET force_mbedtls_unsafe = 'false' +-- +ok +== +CREATE TABLE enc.test AS SELECT 1 as a; +-- +ok +== +FROM enc.test +-- +ok +== diff --git a/parser/testdata/corpus/sql/attach/attach_enums.test b/parser/testdata/corpus/sql/attach/attach_enums.test new file mode 100644 index 0000000..21a29a4 --- /dev/null +++ b/parser/testdata/corpus/sql/attach/attach_enums.test @@ -0,0 +1,75 @@ +# source: test/sql/attach/attach_enums.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +ATTACH '{TEST_DIR}/attach_enums.db' AS db1 +-- +ok +== +CREATE TYPE db1.mood AS ENUM ('sad', 'ok', 'happy'); +-- +ok +== +SELECT enum_range(NULL::db1.mood) AS my_enum_range; +-- +ok +== +SELECT enum_range(NULL::db1.main.mood) AS my_enum_range; +-- +ok +== +SELECT enum_range(NULL::xx.db1.main.mood) AS my_enum_range; +-- +ok +== +DROP TYPE db1.mood +-- +ok +== +DROP TYPE IF EXISTS db1.main.mood +-- +ok +== +CREATE TABLE db1.person ( + name text, + current_mood mood +); +-- +ok +== +INSERT INTO db1.person VALUES ('Moe', 'happy'); +-- +ok +== +select * from db1.person +-- +ok +== +ATTACH '{TEST_DIR}/attach_enums.db' AS db1 (READ_ONLY) +-- +ok +== +ATTACH '{TEST_DIR}/attach_enums_2.db' AS db2 +-- +ok +== +CREATE TYPE db2.mood AS ENUM ('ble','grr','kkcry'); +-- +ok +== +CREATE TABLE db2.person ( + name text, + current_mood mood +); +-- +ok +== +INSERT INTO db2.person VALUES ('Moe', 'kkcry'); +-- +ok +== +select * from db2.person +-- +ok +== diff --git a/parser/testdata/corpus/sql/attach/attach_export_import.test b/parser/testdata/corpus/sql/attach/attach_export_import.test new file mode 100644 index 0000000..558fa93 --- /dev/null +++ b/parser/testdata/corpus/sql/attach/attach_export_import.test @@ -0,0 +1,65 @@ +# source: test/sql/attach/attach_export_import.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +ATTACH ':memory:' AS db1 +-- +ok +== +ATTACH ':memory:' as other +-- +ok +== +USE db1; +-- +ok +== +INSERT INTO db1.integers VALUES (1), (2), (3), (NULL); +-- +ok +== +CREATE VIEW db1.integers_view AS SELECT * FROM integers; +-- +ok +== +CREATE TABLE other.dont_export_me (i integer); +-- +ok +== +EXPORT DATABASE db1 TO '{TEST_DIR}/export_test' (FORMAT CSV) +-- +ok +== +rollback; +-- +ok +== +drop table db1.integers CASCADE; +-- +ok +== +SELECT * FROM integers +-- +ok +== +drop view integers_view; +-- +ok +== +IMPORT DATABASE '{TEST_DIR}/export_test' +-- +ok +== +SELECT * FROM integers ORDER BY i NULLS LAST +-- +ok +== +SELECT * FROM integers_view order by i NULLS LAST; +-- +ok +== +SELECT * FROM other.dont_export_me; +-- +ok +== diff --git a/parser/testdata/corpus/sql/attach/attach_expr.test b/parser/testdata/corpus/sql/attach/attach_expr.test new file mode 100644 index 0000000..8abaa81 --- /dev/null +++ b/parser/testdata/corpus/sql/attach/attach_expr.test @@ -0,0 +1,21 @@ +# source: test/sql/attach/attach_expr.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +SET VARIABLE db_type='DUCKDB' +-- +ok +== +ATTACH ':memory:' AS db1 (TYPE getvariable('db_type')) +-- +ok +== +SET VARIABLE db_type='UNKNOWN_TYPE' +-- +ok +== +ATTACH ':memory:' AS db2 (TYPE getvariable('db_type')) +-- +ok +== diff --git a/parser/testdata/corpus/sql/attach/attach_external_access.test b/parser/testdata/corpus/sql/attach/attach_external_access.test new file mode 100644 index 0000000..2b5e989 --- /dev/null +++ b/parser/testdata/corpus/sql/attach/attach_external_access.test @@ -0,0 +1,9 @@ +# source: test/sql/attach/attach_external_access.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +ATTACH 'mydb.db' AS db2 +-- +ok +== diff --git a/parser/testdata/corpus/sql/attach/attach_filepath_roundtrip.test b/parser/testdata/corpus/sql/attach/attach_filepath_roundtrip.test new file mode 100644 index 0000000..1ea789c --- /dev/null +++ b/parser/testdata/corpus/sql/attach/attach_filepath_roundtrip.test @@ -0,0 +1,49 @@ +# source: test/sql/attach/attach_filepath_roundtrip.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +ATTACH '{TEST_DIR}/concurrent.db'; +-- +ok +== +SELECT database_name FROM duckdb_databases() WHERE database_name = 'concurrent'; +-- +ok +== +DETACH concurrent; +-- +ok +== +ATTACH '{TEST_DIR}/db1.db'; +-- +ok +== +DETACH db1; +-- +ok +== +ATTACH '{TEST_DIR}/con2_rollback_detach.db'; +-- +ok +== +ATTACH '{TEST_DIR}/con1.db'; +-- +ok +== +ATTACH '{TEST_DIR}/con1_commit.db'; +-- +ok +== +DETACH con2_rollback_detach; +-- +ok +== +DETACH con2_rollback_detach +-- +ok +== +DETACH con1; +-- +ok +== diff --git a/parser/testdata/corpus/sql/attach/attach_foreign_key.test b/parser/testdata/corpus/sql/attach/attach_foreign_key.test new file mode 100644 index 0000000..be4094b --- /dev/null +++ b/parser/testdata/corpus/sql/attach/attach_foreign_key.test @@ -0,0 +1,33 @@ +# source: test/sql/attach/attach_foreign_key.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +CREATE TABLE album(artistid INTEGER, albumname TEXT, albumcover TEXT, UNIQUE (artistid, albumname)); +-- +ok +== +CREATE TABLE db1.song(songid INTEGER, songartist INTEGER, songalbum TEXT, songname TEXT, FOREIGN KEY(songartist, songalbum) REFERENCES album(artistid, albumname)); +-- +ok +== +INSERT INTO album VALUES (1, 'A', 'A_cover'), (2, 'B', 'B_cover'), (3, 'C', 'C_cover'), (4, 'D', 'D_cover'); +-- +ok +== +CREATE TABLE song(songid INTEGER, songartist INTEGER, songalbum TEXT, songname TEXT, FOREIGN KEY(songartist, songalbum) REFERENCES album(artistid, albumname)); +-- +ok +== +ATTACH DATABASE ':memory:' AS db2; +-- +ok +== +USE db2; +-- +ok +== +INSERT INTO db1.song VALUES (11, 1, 'A', 'A_song'), (12, 2, 'B', 'B_song'), (13, 3, 'C', 'C_song'); +-- +ok +== diff --git a/parser/testdata/corpus/sql/attach/attach_foreign_key_external_catalog.test b/parser/testdata/corpus/sql/attach/attach_foreign_key_external_catalog.test new file mode 100644 index 0000000..cdeb2c7 --- /dev/null +++ b/parser/testdata/corpus/sql/attach/attach_foreign_key_external_catalog.test @@ -0,0 +1,69 @@ +# source: test/sql/attach/attach_foreign_key_external_catalog.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +ATTACH '{TEST_DIR}/fk_external.duckdb' AS ext; +-- +ok +== +CREATE TABLE ext.artist(id INTEGER PRIMARY KEY, name TEXT); +-- +ok +== +CREATE TABLE ext.album(id INTEGER PRIMARY KEY, artist_id INTEGER, title TEXT, FOREIGN KEY(artist_id) REFERENCES artist(id)); +-- +ok +== +INSERT INTO ext.artist VALUES (1, 'Alice'), (2, 'Bob'); +-- +ok +== +INSERT INTO ext.album VALUES (100, 1, 'First Album'), (101, 2, 'Second Album'); +-- +ok +== +INSERT INTO ext.album VALUES (102, 999, 'Bad Album'); +-- +ok +== +DELETE FROM ext.artist WHERE id = 1; +-- +ok +== +CREATE TABLE ext.track(id INTEGER PRIMARY KEY, album_id INTEGER, artist_id INTEGER, title TEXT, FOREIGN KEY(album_id) REFERENCES album(id), FOREIGN KEY(artist_id) REFERENCES artist(id)); +-- +ok +== +INSERT INTO ext.track VALUES (1000, 100, 1, 'Track One'), (1001, 101, 2, 'Track Two'); +-- +ok +== +INSERT INTO ext.track VALUES (1002, 999, 1, 'Bad Track'); +-- +ok +== +CREATE TABLE main_table(id INTEGER PRIMARY KEY); +-- +ok +== +CREATE TABLE ext.cross_ref(id INTEGER, ref_id INTEGER, FOREIGN KEY(ref_id) REFERENCES main_table(id)); +-- +ok +== +DROP TABLE ext.track; +-- +ok +== +DROP TABLE ext.album; +-- +ok +== +DROP TABLE ext.artist; +-- +ok +== +DETACH ext; +-- +ok +== diff --git a/parser/testdata/corpus/sql/attach/attach_fsspec.test b/parser/testdata/corpus/sql/attach/attach_fsspec.test new file mode 100644 index 0000000..784c5f8 --- /dev/null +++ b/parser/testdata/corpus/sql/attach/attach_fsspec.test @@ -0,0 +1,25 @@ +# source: test/sql/attach/attach_fsspec.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +ATTACH 'dummy_extension:/hello.world'; +-- +ok +== +ATTACH 'file://{TEMP_DIR_ABSOLUTE}/dummy.csv' +-- +ok +== +CREATE TABLE dummy.tbl(i INTEGER); +-- +ok +== +DETACH dummy +-- +ok +== +FROM dummy.tbl +-- +ok +== diff --git a/parser/testdata/corpus/sql/attach/attach_hidden.test b/parser/testdata/corpus/sql/attach/attach_hidden.test new file mode 100644 index 0000000..53ec331 --- /dev/null +++ b/parser/testdata/corpus/sql/attach/attach_hidden.test @@ -0,0 +1,29 @@ +# source: test/sql/attach/attach_hidden.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +ATTACH ':memory:' AS hidden_db (HIDDEN true); +-- +ok +== +SELECT database_name FROM duckdb_databases() WHERE database_name = 'hidden_db' +-- +ok +== +SELECT database_name FROM duckdb_tables() WHERE database_name = 'hidden_db' +-- +ok +== +CREATE TABLE hidden_db.main.tbl AS SELECT 42 AS i; +-- +ok +== +SELECT * FROM hidden_db.main.tbl +-- +ok +== +DETACH hidden_db; +-- +ok +== diff --git a/parser/testdata/corpus/sql/attach/attach_home_directory.test b/parser/testdata/corpus/sql/attach/attach_home_directory.test new file mode 100644 index 0000000..c41d557 --- /dev/null +++ b/parser/testdata/corpus/sql/attach/attach_home_directory.test @@ -0,0 +1,33 @@ +# source: test/sql/attach/attach_home_directory.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +ATTACH '{TEST_DIR}/home_dir.db' AS s1 +-- +ok +== +CREATE TABLE s1.integers AS FROM range(10) t(i); +-- +ok +== +SELECT SUM(i) FROM s1.integers +-- +ok +== +SET home_directory='{TEST_DIR}' +-- +ok +== +ATTACH '~/home_dir.db' AS s2 +-- +ok +== +DETACH s1 +-- +ok +== +ATTACH '~/home_dir.db' AS s1 +-- +ok +== diff --git a/parser/testdata/corpus/sql/attach/attach_huggingface_index.test b/parser/testdata/corpus/sql/attach/attach_huggingface_index.test new file mode 100644 index 0000000..65aff21 --- /dev/null +++ b/parser/testdata/corpus/sql/attach/attach_huggingface_index.test @@ -0,0 +1,9 @@ +# source: test/sql/attach/attach_huggingface_index.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +ATTACH '{TEST_DIR}/huggingface_index.db' +-- +ok +== diff --git a/parser/testdata/corpus/sql/attach/attach_icu_collation.test b/parser/testdata/corpus/sql/attach/attach_icu_collation.test new file mode 100644 index 0000000..e3e2f3e --- /dev/null +++ b/parser/testdata/corpus/sql/attach/attach_icu_collation.test @@ -0,0 +1,17 @@ +# source: test/sql/attach/attach_icu_collation.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +ATTACH '{TEST_DIR}/german_collation.db' AS db +-- +ok +== +SELECT * FROM db.strings +-- +ok +== +SELECT * FROM db.strings ORDER BY 1 +-- +ok +== diff --git a/parser/testdata/corpus/sql/attach/attach_if_not_exists.test b/parser/testdata/corpus/sql/attach/attach_if_not_exists.test new file mode 100644 index 0000000..0ead967 --- /dev/null +++ b/parser/testdata/corpus/sql/attach/attach_if_not_exists.test @@ -0,0 +1,37 @@ +# source: test/sql/attach/attach_if_not_exists.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +ATTACH '{TEST_DIR}/attach_if_not_exists.db' AS db1 +-- +ok +== +ATTACH IF NOT EXISTS '{TEST_DIR}/attach_if_not_exists.db' AS db1 +-- +ok +== +ATTACH IF NOT EXISTS ':memory:' AS db1 +-- +ok +== +ATTACH IF NOT EXISTS '{TEST_DIR}/attach_if_not_exists.db' AS db2 +-- +ok +== +ATTACH '{TEST_DIR}/attach_if_not_exists.db' AS db1 (READ_WRITE); +-- +ok +== +ATTACH IF NOT EXISTS '{TEST_DIR}/attach_if_not_exists.db' AS db1 (READ_ONLY); +-- +ok +== +ATTACH '{TEST_DIR}/attach_if_not_exists.db' AS db1 (READ_ONLY) +-- +ok +== +ATTACH IF NOT EXISTS '{TEST_DIR}/attach_if_not_exists.db' AS db1 (READ_WRITE); +-- +ok +== diff --git a/parser/testdata/corpus/sql/attach/attach_if_not_exists_detach.test b/parser/testdata/corpus/sql/attach/attach_if_not_exists_detach.test new file mode 100644 index 0000000..66f3524 --- /dev/null +++ b/parser/testdata/corpus/sql/attach/attach_if_not_exists_detach.test @@ -0,0 +1,17 @@ +# source: test/sql/attach/attach_if_not_exists_detach.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +ATTACH '{TEST_DIR}/attach_if_not_exists_detach.db' AS db1 +-- +ok +== +CREATE TABLE db1.tbl(i INTEGER); +-- +ok +== +ATTACH IF NOT EXISTS '{TEST_DIR}/attach_if_not_exists_detach.db' AS db1 +-- +ok +== diff --git a/parser/testdata/corpus/sql/attach/attach_index.test b/parser/testdata/corpus/sql/attach/attach_index.test new file mode 100644 index 0000000..03bab70 --- /dev/null +++ b/parser/testdata/corpus/sql/attach/attach_index.test @@ -0,0 +1,52 @@ +# source: test/sql/attach/attach_index.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +ATTACH '{TEST_DIR}/attach_index_db.db' +-- +ok +== +USE attach_index_db +-- +ok +== +CREATE TABLE tbl_a ( + a_id INTEGER PRIMARY KEY, + value VARCHAR NOT NULL +) +-- +ok +== +CREATE INDEX idx_tbl_a ON tbl_a (value) +-- +ok +== +INSERT INTO tbl_a VALUES (1, 'x') +-- +ok +== +INSERT INTO tbl_a VALUES (2, 'y') +-- +ok +== +SELECT * FROM tbl_a WHERE a_id = 2 +-- +ok +== +ATTACH '{TEST_DIR}/other_attach_index.db' +-- +ok +== +USE other_attach_index +-- +ok +== +DETACH attach_index_db +-- +ok +== +SELECT * FROM attach_index_db.tbl_a WHERE a_id = 2 +-- +ok +== diff --git a/parser/testdata/corpus/sql/attach/attach_issue16122.test b/parser/testdata/corpus/sql/attach/attach_issue16122.test new file mode 100644 index 0000000..4f68418 --- /dev/null +++ b/parser/testdata/corpus/sql/attach/attach_issue16122.test @@ -0,0 +1,29 @@ +# source: test/sql/attach/attach_issue16122.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +create table mytable (C1 VARCHAR(10)); +-- +ok +== +insert into mytable values ('a'); +-- +ok +== +attach '{TEST_DIR}/issue16122_new.db' as TOMERGE; +-- +ok +== +create table TOMERGE.mytable (C1 VARCHAR(10)); +-- +ok +== +insert into TOMERGE.mytable SELECT * FROM mytable; +-- +ok +== +select * from TOMERGE.mytable; +-- +ok +== diff --git a/parser/testdata/corpus/sql/attach/attach_issue7567.test b/parser/testdata/corpus/sql/attach/attach_issue7567.test new file mode 100644 index 0000000..18dd390 --- /dev/null +++ b/parser/testdata/corpus/sql/attach/attach_issue7567.test @@ -0,0 +1,33 @@ +# source: test/sql/attach/attach_issue7567.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +attach ':memory:' as test; +-- +ok +== +use test; +-- +ok +== +create schema schema1; +-- +ok +== +create table schema1.table1 as select 1 as a; +-- +ok +== +set schema='schema2'; +-- +ok +== +set schema='schema1'; +-- +ok +== +select * from table1; +-- +ok +== diff --git a/parser/testdata/corpus/sql/attach/attach_issue7711.test b/parser/testdata/corpus/sql/attach/attach_issue7711.test new file mode 100644 index 0000000..d78472c --- /dev/null +++ b/parser/testdata/corpus/sql/attach/attach_issue7711.test @@ -0,0 +1,13 @@ +# source: test/sql/attach/attach_issue7711.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +detach test; +-- +ok +== +detach test +-- +ok +== diff --git a/parser/testdata/corpus/sql/attach/attach_issue_21491.test b/parser/testdata/corpus/sql/attach/attach_issue_21491.test new file mode 100644 index 0000000..a853419 --- /dev/null +++ b/parser/testdata/corpus/sql/attach/attach_issue_21491.test @@ -0,0 +1,21 @@ +# source: test/sql/attach/attach_issue_21491.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +ATTACH unknown_scalar('test.db') AS db; +-- +ok +== +ATTACH ':memory:' AS memdb +-- +ok +== +DETACH memdb +-- +ok +== +ATTACH lower(':MEMORY:') AS memdb +-- +ok +== diff --git a/parser/testdata/corpus/sql/attach/attach_issue_7660.test b/parser/testdata/corpus/sql/attach/attach_issue_7660.test new file mode 100644 index 0000000..5125bcf --- /dev/null +++ b/parser/testdata/corpus/sql/attach/attach_issue_7660.test @@ -0,0 +1,29 @@ +# source: test/sql/attach/attach_issue_7660.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +create table tbl1 as select 1 as a; +-- +ok +== +FROM test.tbl1 +-- +ok +== +export database '{TEST_DIR}/test_issue_7660'; +-- +ok +== +DETACH test +-- +ok +== +import database '{TEST_DIR}/test_issue_7660' +-- +ok +== +FROM tbl1 +-- +ok +== diff --git a/parser/testdata/corpus/sql/attach/attach_lambda_view.test b/parser/testdata/corpus/sql/attach/attach_lambda_view.test new file mode 100644 index 0000000..1aadbff --- /dev/null +++ b/parser/testdata/corpus/sql/attach/attach_lambda_view.test @@ -0,0 +1,34 @@ +# source: test/sql/attach/attach_lambda_view.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +ATTACH '{TEST_DIR}/version_1_{i}_0.db' (STORAGE_VERSION 'v1.{i}.0'); +-- +ok +== +CREATE TABLE version_1_{i}_0.lists(l integer[], initial integer); +-- +error: Parser Error: syntax error at or near "{" +== +INSERT INTO version_1_{i}_0.lists VALUES ([1], -1), ([1, 2, 3], -2), (NULL, -3), ([-1, NULL, 2], -3); +-- +error: Parser Error: syntax error at or near "{" +== +CREATE VIEW version_1_{i}_0.reduced_lists AS + SELECT list_reduce(l, LAMBDA x, y : x + y, initial) AS r FROM version_1_{i}_0.lists; +-- +error: Parser Error: syntax error at or near "{" +== +FROM version_1_{i}_0.reduced_lists; +-- +error: Parser Error: syntax error at or near "{" +== +DETACH version_1_{i}_0 +-- +error: Parser Error: syntax error at or near "{" +== +ATTACH '{TEST_DIR}/version_1_{i}_0.db' +-- +ok +== diff --git a/parser/testdata/corpus/sql/attach/attach_macros.test b/parser/testdata/corpus/sql/attach/attach_macros.test new file mode 100644 index 0000000..a86fdcb --- /dev/null +++ b/parser/testdata/corpus/sql/attach/attach_macros.test @@ -0,0 +1,29 @@ +# source: test/sql/attach/attach_macros.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +ATTACH ':memory:' AS db1; +-- +ok +== +CREATE TABLE db1.tbl AS SELECT 42 AS x, 3 AS y; +-- +ok +== +CREATE MACRO db1.two_x_plus_y(x, y) AS 2 * x + y; +-- +ok +== +SELECT db1.two_x_plus_y(x, y) FROM db1.tbl; +-- +ok +== +SELECT db1.main.two_x_plus_y(x, y) FROM db1.tbl; +-- +ok +== +SELECT two_x_plus_y(x, y) FROM db1.tbl; +-- +ok +== diff --git a/parser/testdata/corpus/sql/attach/attach_modify_multiple_databases.test b/parser/testdata/corpus/sql/attach/attach_modify_multiple_databases.test new file mode 100644 index 0000000..3ea4ec9 --- /dev/null +++ b/parser/testdata/corpus/sql/attach/attach_modify_multiple_databases.test @@ -0,0 +1,21 @@ +# source: test/sql/attach/attach_modify_multiple_databases.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +ATTACH DATABASE ':memory:' AS database; +-- +ok +== +CREATE TABLE database.integers(i INTEGER); +-- +ok +== +INSERT INTO database.integers SELECT * FROM range(10); +-- +ok +== +INSERT INTO integers SELECT * FROM range(10); +-- +ok +== diff --git a/parser/testdata/corpus/sql/attach/attach_multi_identifiers.test b/parser/testdata/corpus/sql/attach/attach_multi_identifiers.test new file mode 100644 index 0000000..8c694fe --- /dev/null +++ b/parser/testdata/corpus/sql/attach/attach_multi_identifiers.test @@ -0,0 +1,100 @@ +# source: test/sql/attach/attach_multi_identifiers.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +ATTACH ':memory:' AS db2; +-- +ok +== +CREATE SCHEMA db1.s1; +-- +ok +== +CREATE SCHEMA db2.s1; +-- +ok +== +CREATE TABLE db1.s1.t(c INT); +-- +ok +== +CREATE TABLE db2.s1.t(c INT); +-- +ok +== +INSERT INTO db1.s1.t VALUES (42); +-- +ok +== +INSERT INTO db2.s1.t SELECT c * 2 FROM db1.s1.t +-- +ok +== +SELECT * FROM db1.s1.t, db2.s1.t +-- +ok +== +SELECT db1.t.c, db2.t.c FROM db1.s1.t, db2.s1.t +-- +ok +== +SELECT db1.s1.t.c, db2.s1.t.c FROM db1.s1.t, db2.s1.t +-- +ok +== +SELECT * EXCLUDE (db1.s1.t.c) FROM db1.s1.t, db2.s1.t +-- +ok +== +SELECT * EXCLUDE (DB1.S1.T.C) FROM db1.s1.t, db2.s1.t +-- +ok +== +SELECT * EXCLUDE (s1.t.c) FROM db1.s1.t, (SELECT 42) t +-- +ok +== +SELECT * EXCLUDE (new_col) FROM (SELECT * RENAME (db1.s1.t.c AS new_col) FROM db1.s1.t, db2.s1.t) +-- +ok +== +SELECT * EXCLUDE (new_col) FROM (SELECT * RENAME (DB1.S1.T.C AS new_col) FROM db1.s1.t, db2.s1.t) +-- +ok +== +SELECT * EXCLUDE (new_col) FROM (SELECT * RENAME (s1.t.c AS new_col) FROM db1.s1.t, (SELECT 42) t) +-- +ok +== +SELECT db1.s1.t, db2.s1.t FROM db1.s1.t, db2.s1.t +-- +ok +== +SELECT db1.t, db2.t FROM db1.s1.t, db2.s1.t +-- +ok +== +SELECT c FROM db1.s1.t, db2.s1.t +-- +ok +== +SELECT t.c FROM db1.s1.t, db2.s1.t +-- +ok +== +SELECT s1.t.c FROM db1.s1.t, db2.s1.t +-- +ok +== +SELECT db1.s1.t.c FROM db1.s1.t, db2.s1.t +-- +ok +== +CREATE OR REPLACE TABLE db1.s1.t ( + c INT, + c_squared AS (c * c), +); +-- +ok +== diff --git a/parser/testdata/corpus/sql/attach/attach_nested_types.test b/parser/testdata/corpus/sql/attach/attach_nested_types.test new file mode 100644 index 0000000..3676edb --- /dev/null +++ b/parser/testdata/corpus/sql/attach/attach_nested_types.test @@ -0,0 +1,61 @@ +# source: test/sql/attach/attach_nested_types.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +CREATE SCHEMA database.schema; +-- +ok +== +CREATE TABLE database.schema.table(col ROW(field INTEGER)); +-- +ok +== +INSERT INTO database.schema.table VALUES ({'field': 42}); +-- +ok +== +SELECT database.schema.table.col.field FROM database.schema.table +-- +ok +== +SELECT database.schema.table.col FROM database.schema.table +-- +ok +== +SELECT database.schema.table FROM database.schema.table +-- +ok +== +USE database +-- +ok +== +SELECT schema.table FROM database.schema.table +-- +ok +== +SELECT "table" FROM database.schema.table +-- +ok +== +USE database.schema +-- +ok +== +SELECT "table" FROM "table" +-- +ok +== +SELECT schema.table FROM "table" +-- +ok +== +SELECT database.table FROM "table" +-- +ok +== +SELECT database.schema.table FROM "table" +-- +ok +== diff --git a/parser/testdata/corpus/sql/attach/attach_new_compression.test b/parser/testdata/corpus/sql/attach/attach_new_compression.test new file mode 100644 index 0000000..c027254 --- /dev/null +++ b/parser/testdata/corpus/sql/attach/attach_new_compression.test @@ -0,0 +1,53 @@ +# source: test/sql/attach/attach_new_compression.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +ATTACH '{TEST_DIR}/test_new_compression.db' AS db1 (STORAGE_VERSION 'v1.0.0'); +-- +ok +== +SET force_compression='roaring' +-- +ok +== +CREATE TABLE db1.tbl AS SELECT CASE WHEN i%2=0 THEN NULL ELSE i END i FROM range(10000) t(i); +-- +ok +== +SET force_compression='zstd'; +-- +ok +== +CREATE TABLE db1.str_tbl AS SELECT STRING_AGG('long_string_' || i, '-') FROM range(1000) t(i); +-- +ok +== +SELECT COUNT(*)>0 FROM pragma_storage_info('db1.tbl') WHERE compression='Roaring' +-- +ok +== +SELECT COUNT(*)>0 FROM pragma_storage_info('db1.str_tbl') WHERE compression='ZSTD' +-- +ok +== +ATTACH '{TEST_DIR}/test_new_compression.db' AS db1 (STORAGE_VERSION 'v1.2.0'); +-- +ok +== +CREATE TABLE db1.tbl2 AS FROM db1.tbl +-- +ok +== +CREATE TABLE db1.str_tbl2 AS FROM db1.str_tbl +-- +ok +== +SELECT COUNT(*)>0 FROM pragma_storage_info('db1.tbl2') WHERE compression='Roaring' +-- +ok +== +SELECT COUNT(*)>0 FROM pragma_storage_info('db1.str_tbl2') WHERE compression='ZSTD' +-- +ok +== diff --git a/parser/testdata/corpus/sql/attach/attach_no_wal_writes_mode.test b/parser/testdata/corpus/sql/attach/attach_no_wal_writes_mode.test new file mode 100644 index 0000000..ec814c4 --- /dev/null +++ b/parser/testdata/corpus/sql/attach/attach_no_wal_writes_mode.test @@ -0,0 +1,45 @@ +# source: test/sql/attach/attach_no_wal_writes_mode.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +SET threads = 1; +-- +ok +== +ATTACH '{TEST_DIR}/no_wal_writes.db' AS no_wal_writes (RECOVERY_MODE NO_WAL_WRITES); +-- +ok +== +CREATE TABLE no_wal_writes.tbl AS SELECT range AS id, 0 AS v FROM range(5_000); +-- +ok +== +UPDATE no_wal_writes.tbl SET v = id; +-- +ok +== +DETACH no_wal_writes; +-- +ok +== +SELECT COUNT(*) FROM glob('{TEST_DIR}/no_wal_writes.db.wal') +-- +ok +== +SELECT COUNT(*) FROM no_wal_writes.tbl WHERE v = 0; +-- +ok +== +ATTACH '{TEST_DIR}/other_no_wal_writes.db' AS no_wal_writes (RECOVERY_MODE NO_WAL_WRITES); +-- +ok +== +CHECKPOINT no_wal_writes; +-- +ok +== +SELECT COUNT(*) FROM glob('{TEST_DIR}/other_no_wal_writes.db.wal') +-- +ok +== diff --git a/parser/testdata/corpus/sql/attach/attach_null.test b/parser/testdata/corpus/sql/attach/attach_null.test new file mode 100644 index 0000000..5b58481 --- /dev/null +++ b/parser/testdata/corpus/sql/attach/attach_null.test @@ -0,0 +1,9 @@ +# source: test/sql/attach/attach_null.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +ATTACH '{TEST_DIR}/test_new_compression.db' AS db1 (TYPE NULL); +-- +ok +== diff --git a/parser/testdata/corpus/sql/attach/attach_or_replace.test b/parser/testdata/corpus/sql/attach/attach_or_replace.test new file mode 100644 index 0000000..ed41c4d --- /dev/null +++ b/parser/testdata/corpus/sql/attach/attach_or_replace.test @@ -0,0 +1,61 @@ +# source: test/sql/attach/attach_or_replace.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +ATTACH '{TEST_DIR}/attach_or_replace.db' AS db1 (STORAGE_VERSION 'v2.0.0'); +-- +ok +== +ATTACH '{TEST_DIR}/attach_or_replace_new.db' AS db2 (STORAGE_VERSION 'v2.0.0'); +-- +ok +== +CREATE TABLE db2.all_types_new AS SELECT * FROM test_all_types(); +-- +ok +== +DETACH db2; +-- +ok +== +ATTACH OR REPLACE '{TEST_DIR}/attach_or_replace.db' AS db1; +-- +ok +== +SELECT * FROM db1.all_types; +-- +ok +== +ATTACH OR REPLACE '{TEST_DIR}/attach_or_replace.db' AS db2; +-- +ok +== +ATTACH OR REPLACE '{TEST_DIR}/attach_or_replace_new.db' AS db1; +-- +ok +== +SELECT * FROM db1.all_types_new; +-- +ok +== +ATTACH '{TEST_DIR}/attach_or_replace.db' AS db2; +-- +ok +== +SELECT * FROM db2.all_types; +-- +ok +== +ATTACH '{TEST_DIR}/attach_or_replace_txn.db' AS db3; +-- +ok +== +ATTACH OR REPLACE '{TEST_DIR}/attach_or_replace_txn_new.db' AS db3; +-- +ok +== +SELECT count(*) FROM duckdb_databases() WHERE database_name = 'db3'; +-- +ok +== diff --git a/parser/testdata/corpus/sql/attach/attach_persistent.test b/parser/testdata/corpus/sql/attach/attach_persistent.test new file mode 100644 index 0000000..bad89cf --- /dev/null +++ b/parser/testdata/corpus/sql/attach/attach_persistent.test @@ -0,0 +1,25 @@ +# source: test/sql/attach/attach_persistent.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +ATTACH '{TEST_DIR}/persistent_attach.db' +-- +ok +== +CREATE TABLE persistent_attach.integers(i INTEGER) +-- +ok +== +INSERT INTO persistent_attach.integers VALUES (42) +-- +ok +== +SELECT SUM(i) FROM persistent_attach.integers +-- +ok +== +DETACH persistent_attach +-- +ok +== diff --git a/parser/testdata/corpus/sql/attach/attach_pragma_storage_info.test b/parser/testdata/corpus/sql/attach/attach_pragma_storage_info.test new file mode 100644 index 0000000..b5da5e5 --- /dev/null +++ b/parser/testdata/corpus/sql/attach/attach_pragma_storage_info.test @@ -0,0 +1,21 @@ +# source: test/sql/attach/attach_pragma_storage_info.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +ATTACH '{TEST_DIR}/database.db' as persistent; +-- +ok +== +CREATE OR REPLACE TABLE persistent.T1 (A0 int); +-- +ok +== +insert into persistent.T1 values (5); +-- +ok +== +SELECT column_name from pragma_storage_info('persistent.T1'); +-- +ok +== diff --git a/parser/testdata/corpus/sql/attach/attach_prefetch_header.test b/parser/testdata/corpus/sql/attach/attach_prefetch_header.test new file mode 100644 index 0000000..1054f2f --- /dev/null +++ b/parser/testdata/corpus/sql/attach/attach_prefetch_header.test @@ -0,0 +1,53 @@ +# source: test/sql/attach/attach_prefetch_header.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +ATTACH '{TEST_DIR}/attach_prefetch_header.db' AS db1 +-- +ok +== +CREATE TABLE db1.integers AS SELECT range AS i FROM range(10000); +-- +ok +== +CREATE TABLE db1.strings AS SELECT 'v' || range::VARCHAR AS s FROM range(1000); +-- +ok +== +ATTACH '{TEST_DIR}/attach_prefetch_header.db' AS db1 (READ_ONLY) +-- +ok +== +SELECT COUNT(*) FROM db1.integers +-- +ok +== +SELECT SUM(i) FROM db1.integers +-- +ok +== +SELECT COUNT(*) FROM db1.strings +-- +ok +== +ATTACH '{TEST_DIR}/attach_prefetch_header.db' AS db1 (READ_WRITE) +-- +ok +== +INSERT INTO db1.integers VALUES (10000) +-- +ok +== +COPY (SELECT 42 AS a) TO '{TEST_DIR}/attach_prefetch_header.csv' (FORMAT CSV, HEADER) +-- +ok +== +ATTACH '{TEST_DIR}/attach_prefetch_header.csv' AS c +-- +ok +== +SELECT a FROM c.file +-- +ok +== diff --git a/parser/testdata/corpus/sql/attach/attach_read_only.test b/parser/testdata/corpus/sql/attach/attach_read_only.test new file mode 100644 index 0000000..e6f5ba0 --- /dev/null +++ b/parser/testdata/corpus/sql/attach/attach_read_only.test @@ -0,0 +1,53 @@ +# source: test/sql/attach/attach_read_only.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +ATTACH ':memory:' AS db1 (READONLY 1) +-- +ok +== +ATTACH ':memory:' AS db1 (BLABLABLA 1) +-- +ok +== +ATTACH '{TEST_DIR}/attach_read_only.db' AS db1 (READONLY 1) +-- +ok +== +ATTACH '{TEST_DIR}/attach_read_only.db' AS db1 +-- +ok +== +CREATE TABLE db1.integers AS SELECT * FROM range(10) t(i); +-- +ok +== +CREATE TABLE db1.test AS SELECT * FROM range(10) t(i); +-- +ok +== +CREATE TABLE db2.integers AS SELECT * FROM db1.integers +-- +ok +== +SELECT SUM(i) FROM db2.integers +-- +ok +== +CREATE TABLE test AS SELECT * FROM range(10) t(i); +-- +ok +== +ATTACH ':memory:' AS db1 (READ_WRITE); +-- +ok +== +CREATE TABLE db1.test AS SELECT * FROM integers +-- +ok +== +CREATE TABLE test AS SELECT * FROM db1.test +-- +ok +== diff --git a/parser/testdata/corpus/sql/attach/attach_read_only_transaction.test b/parser/testdata/corpus/sql/attach/attach_read_only_transaction.test new file mode 100644 index 0000000..6e412e5 --- /dev/null +++ b/parser/testdata/corpus/sql/attach/attach_read_only_transaction.test @@ -0,0 +1,21 @@ +# source: test/sql/attach/attach_read_only_transaction.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +INSERT INTO db1.integers VALUES (42); +-- +ok +== +BEGIN TRANSACTION READ ONLY +-- +ok +== +FROM db1.integers +-- +ok +== +INSERT INTO db1.integers VALUES (48) +-- +ok +== diff --git a/parser/testdata/corpus/sql/attach/attach_replay_with_no_wal_writes.test b/parser/testdata/corpus/sql/attach/attach_replay_with_no_wal_writes.test new file mode 100644 index 0000000..2aa1ac9 --- /dev/null +++ b/parser/testdata/corpus/sql/attach/attach_replay_with_no_wal_writes.test @@ -0,0 +1,37 @@ +# source: test/sql/attach/attach_replay_with_no_wal_writes.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +ATTACH '{TEST_DIR}/wal_writes.db' AS wal_writes; +-- +ok +== +CREATE TABLE wal_writes.tbl AS SELECT range AS id, 0 AS v FROM range(5_000); +-- +ok +== +DETACH wal_writes; +-- +ok +== +SELECT COUNT(*) FROM glob('{TEST_DIR}/wal_writes.db.wal') +-- +ok +== +ATTACH '{TEST_DIR}/wal_writes.db' AS wal_writes (RECOVERY_MODE NO_WAL_WRITES); +-- +ok +== +INSERT INTO wal_writes.tbl VALUES (42, 42); +-- +ok +== +CHECKPOINT wal_writes; +-- +ok +== +UPDATE wal_writes.tbl SET v = id; +-- +ok +== diff --git a/parser/testdata/corpus/sql/attach/attach_reserved.test b/parser/testdata/corpus/sql/attach/attach_reserved.test new file mode 100644 index 0000000..5d7ce2f --- /dev/null +++ b/parser/testdata/corpus/sql/attach/attach_reserved.test @@ -0,0 +1,41 @@ +# source: test/sql/attach/attach_reserved.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +ATTACH DATABASE '{TEST_DIR}/temp.db'; +-- +ok +== +CREATE TABLE temp_db.integers(i INTEGER); +-- +ok +== +DETACH temp_db; +-- +ok +== +ATTACH DATABASE '{TEST_DIR}/system.db'; +-- +ok +== +CREATE TABLE system_db.integers(i INTEGER); +-- +ok +== +DETACH system_db; +-- +ok +== +ATTACH DATABASE ':memory:' AS temp; +-- +ok +== +ATTACH DATABASE ':memory:' AS main; +-- +ok +== +ATTACH DATABASE ':memory:' AS system; +-- +ok +== diff --git a/parser/testdata/corpus/sql/attach/attach_row_group_size.test b/parser/testdata/corpus/sql/attach/attach_row_group_size.test new file mode 100644 index 0000000..4585675 --- /dev/null +++ b/parser/testdata/corpus/sql/attach/attach_row_group_size.test @@ -0,0 +1,25 @@ +# source: test/sql/attach/attach_row_group_size.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +ATTACH '{TEST_DIR}/attach_row_group_size.db' AS db1 (STORAGE_VERSION 'v1.0.0', ROW_GROUP_SIZE 245760); +-- +ok +== +ATTACH '{TEST_DIR}/attach_row_group_size.db' AS db1 (STORAGE_VERSION 'v1.0.0'); +-- +ok +== +CREATE TABLE db1.tbl AS FROM range(10000) t(i) +-- +ok +== +ATTACH '{TEST_DIR}/attach_row_group_size.db' AS db1 (STORAGE_VERSION 'v1.2.0', ROW_GROUP_SIZE 245760); +-- +ok +== +INSERT INTO db1.tbl FROM range(10000) +-- +ok +== diff --git a/parser/testdata/corpus/sql/attach/attach_row_group_size_decreasing.test b/parser/testdata/corpus/sql/attach/attach_row_group_size_decreasing.test new file mode 100644 index 0000000..e961a04 --- /dev/null +++ b/parser/testdata/corpus/sql/attach/attach_row_group_size_decreasing.test @@ -0,0 +1,37 @@ +# source: test/sql/attach/attach_row_group_size_decreasing.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +ATTACH '{TEST_DIR}/attach_row_group_size_decreasing.db' as test (ROW_GROUP_SIZE 4096); +-- +ok +== +CREATE TABLE test.data (key BIGINT PRIMARY KEY); +-- +ok +== +INSERT INTO test.data SELECT * FROM range(8190); +-- +ok +== +SELECT COUNT(DISTINCT row_group_id) FROM pragma_storage_info('test.data'); +-- +ok +== +DETACH test; +-- +ok +== +ATTACH '{TEST_DIR}/attach_row_group_size_decreasing.db' as test (ROW_GROUP_SIZE 2048); +-- +ok +== +INSERT INTO test.data VALUES(8190), (8191); +-- +ok +== +SELECT row_group_id, SUM(count) FROM pragma_storage_info('test.data') where segment_type != 'VALIDITY' GROUP BY (row_group_id) ORDER BY row_group_id; +-- +ok +== diff --git a/parser/testdata/corpus/sql/attach/attach_same_db.test b/parser/testdata/corpus/sql/attach/attach_same_db.test new file mode 100644 index 0000000..c45c3a7 --- /dev/null +++ b/parser/testdata/corpus/sql/attach/attach_same_db.test @@ -0,0 +1,13 @@ +# source: test/sql/attach/attach_same_db.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +ATTACH '{TEST_DIR}/attach_same_db.db' AS db1 +-- +ok +== +ATTACH '{TEST_DIR}/attach_same_db.db' AS db2 +-- +ok +== diff --git a/parser/testdata/corpus/sql/attach/attach_schema.test b/parser/testdata/corpus/sql/attach/attach_schema.test new file mode 100644 index 0000000..5d07a0a --- /dev/null +++ b/parser/testdata/corpus/sql/attach/attach_schema.test @@ -0,0 +1,17 @@ +# source: test/sql/attach/attach_schema.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +CREATE SCHEMA new_database.s1.xxx; +-- +ok +== +CREATE SCHEMA IF NOT EXISTS new_database.s1.xxx; +-- +ok +== +CREATE SCHEMA new_database.s1; +-- +ok +== diff --git a/parser/testdata/corpus/sql/attach/attach_sequence.test b/parser/testdata/corpus/sql/attach/attach_sequence.test new file mode 100644 index 0000000..2c585ec --- /dev/null +++ b/parser/testdata/corpus/sql/attach/attach_sequence.test @@ -0,0 +1,37 @@ +# source: test/sql/attach/attach_sequence.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +ATTACH DATABASE '{TEST_DIR}/attach_seq.db' AS db1; +-- +ok +== +CREATE TABLE db1.integers(i INTEGER DEFAULT nextval('seq')) +-- +ok +== +CREATE SEQUENCE db1.seq +-- +ok +== +CREATE TABLE db1.integers(i INTEGER DEFAULT nextval('db1.seq')) +-- +ok +== +SELECT nextval('db1.seq') +-- +ok +== +SELECT nextval('seq') +-- +ok +== +CREATE TABLE integers(i INTEGER DEFAULT nextval('db1.seq')) +-- +ok +== +detach db1; +-- +ok +== diff --git a/parser/testdata/corpus/sql/attach/attach_serialize_dependency.test b/parser/testdata/corpus/sql/attach/attach_serialize_dependency.test new file mode 100644 index 0000000..e99b34e --- /dev/null +++ b/parser/testdata/corpus/sql/attach/attach_serialize_dependency.test @@ -0,0 +1,57 @@ +# source: test/sql/attach/attach_serialize_dependency.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +set storage_compatibility_version='latest'; +-- +ok +== +attach '{TEST_DIR}/db1.db'; +-- +ok +== +use db1; +-- +ok +== +CREATE TABLE A (A1 INTEGER PRIMARY KEY,A2 VARCHAR, A3 INTEGER); +-- +ok +== +CREATE INDEX A_index ON A (A2); +-- +ok +== +CREATE TABLE B(B1 INTEGER REFERENCES A(A1)); +-- +ok +== +attach '{TEST_DIR}/db1_other.db'; +-- +ok +== +USE db1_other; +-- +ok +== +attach '{TEST_DIR}/db1.db' as other_db; +-- +ok +== +attach '{TEST_DIR}/db2.db'; +-- +ok +== +use db2; +-- +ok +== +detach db2; +-- +ok +== +attach '{TEST_DIR}/db2.db' as other_db2; +-- +ok +== diff --git a/parser/testdata/corpus/sql/attach/attach_show_all_tables.test b/parser/testdata/corpus/sql/attach/attach_show_all_tables.test new file mode 100644 index 0000000..916544a --- /dev/null +++ b/parser/testdata/corpus/sql/attach/attach_show_all_tables.test @@ -0,0 +1,37 @@ +# source: test/sql/attach/attach_show_all_tables.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +CREATE TABLE tbl(a INTEGER); +-- +ok +== +CREATE TABLE new_database.tbl(b INTEGER); +-- +ok +== +CREATE TABLE new_database.s1.tbl(c INTEGER); +-- +ok +== +SHOW ALL TABLES +-- +ok +== +SHOW ALL +-- +ok +== +DESCRIBE ALL +-- +ok +== +DESC ALL +-- +ok +== +DESCRIBE ALL TABLES +-- +ok +== diff --git a/parser/testdata/corpus/sql/attach/attach_show_table.test b/parser/testdata/corpus/sql/attach/attach_show_table.test new file mode 100644 index 0000000..23e2c62 --- /dev/null +++ b/parser/testdata/corpus/sql/attach/attach_show_table.test @@ -0,0 +1,49 @@ +# source: test/sql/attach/attach_show_table.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +CREATE TABLE db1.table_in_db1(i int); +-- +ok +== +CREATE TABLE db2.table_in_db2(i int); +-- +ok +== +CREATE SCHEMA db2.test_schema; +-- +ok +== +CREATE TABLE db2.test_schema.table_in_db2_test_schema(i int); +-- +ok +== +SHOW TABLES +-- +ok +== +USE DB1 +-- +ok +== +USE db2 +-- +ok +== +USE db2.test_schema; +-- +ok +== +USE DB2.TEST_sChEmA; +-- +ok +== +FROM table_in_db2 +-- +ok +== +FROM table_in_db2_test_schema +-- +ok +== diff --git a/parser/testdata/corpus/sql/attach/attach_storage_version.test b/parser/testdata/corpus/sql/attach/attach_storage_version.test new file mode 100644 index 0000000..3e2a987 --- /dev/null +++ b/parser/testdata/corpus/sql/attach/attach_storage_version.test @@ -0,0 +1,93 @@ +# source: test/sql/attach/attach_storage_version.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +ATTACH '{TEST_DIR}/version_1_2_0.db' (STORAGE_VERSION 'v1.2.0'); +-- +ok +== +SELECT tags['storage_version'] FROM duckdb_databases() WHERE database_name='version_1_2_0' +-- +ok +== +DETACH version_1_2_0 +-- +ok +== +ATTACH '{TEST_DIR}/version_1_2_0.db' (STORAGE_VERSION 'v1.0.0'); +-- +ok +== +ATTACH '{TEST_DIR}/version_1_2_0.db' (STORAGE_VERSION 'non_existant'); +-- +ok +== +ATTACH '{TEST_DIR}/version_1_2_0.db'; +-- +ok +== +set storage_compatibility_version='v0.10.2' +-- +ok +== +ATTACH '{TEST_DIR}/default_version.db'; +-- +ok +== +CREATE TABLE default_version.tbl(i VARCHAR); +-- +ok +== +SELECT tags['storage_version'] FROM duckdb_databases() WHERE database_name='default_version' +-- +ok +== +DETACH default_version +-- +ok +== +ATTACH '{TEST_DIR}/default_version.db' (STORAGE_VERSION 'v1.2.0'); +-- +ok +== +SET force_compression = 'zstd'; +-- +ok +== +INSERT INTO default_version.tbl VALUES ('abcd'), ('efgh'), ('hello'), ('world'), (NULL); +-- +ok +== +CHECKPOINT default_version +-- +ok +== +ATTACH '{TEST_DIR}/default_version.db' +-- +ok +== +FROM default_version.tbl +-- +ok +== +ATTACH '{TEST_DIR}/default_version.db' (STORAGE_VERSION 'v1.2.0') +-- +ok +== +ATTACH '{TEST_DIR}/default_version.db' (STORAGE_VERSION 'v1.0.0') +-- +ok +== +SET storage_compatibility_version = 'v1.2.0' +-- +ok +== +ATTACH '{TEST_DIR}/modified_default_setting.db'; +-- +ok +== +SELECT tags['storage_version'] FROM duckdb_databases() WHERE database_name='modified_default_setting' +-- +ok +== diff --git a/parser/testdata/corpus/sql/attach/attach_table_constraints.test b/parser/testdata/corpus/sql/attach/attach_table_constraints.test new file mode 100644 index 0000000..e561ca7 --- /dev/null +++ b/parser/testdata/corpus/sql/attach/attach_table_constraints.test @@ -0,0 +1,17 @@ +# source: test/sql/attach/attach_table_constraints.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +ATTACH '{TEST_DIR}/constraint_test.db' as test +-- +ok +== +CREATE TABLE test.tbl(i INTEGER PRIMARY KEY); +-- +ok +== +select constraint_catalog, table_catalog, table_name from information_schema.table_constraints limit 1 +-- +ok +== diff --git a/parser/testdata/corpus/sql/attach/attach_table_ddl.test b/parser/testdata/corpus/sql/attach/attach_table_ddl.test new file mode 100644 index 0000000..e2b8b97 --- /dev/null +++ b/parser/testdata/corpus/sql/attach/attach_table_ddl.test @@ -0,0 +1,73 @@ +# source: test/sql/attach/attach_table_ddl.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +CREATE TABLE {prefix}.integers(i INTEGER) +-- +error: Parser Error: syntax error at or near "{" +== +INSERT INTO {prefix}.integers VALUES (42); +-- +error: Parser Error: syntax error at or near "{" +== +SELECT * FROM {prefix}.integers +-- +error: Parser Error: syntax error at or near "{" +== +UPDATE {prefix}.integers SET i=i+1 +-- +error: Parser Error: syntax error at or near "{" +== +DELETE FROM {prefix}.integers WHERE i=43 +-- +error: Parser Error: syntax error at or near "{" +== +SELECT COUNT(*) FROM {prefix}.integers +-- +error: Parser Error: syntax error at or near "{" +== +ALTER TABLE {prefix}.integers ADD COLUMN j VARCHAR +-- +error: Parser Error: syntax error at or near "{" +== +INSERT INTO {prefix}.integers VALUES (1, 'T100'); +-- +error: Parser Error: syntax error at or near "{" +== +ALTER TABLE {prefix}.integers ALTER j TYPE INT USING REPLACE(j, 'T', '')::INT +-- +error: Parser Error: syntax error at or near "{" +== +ALTER TABLE {prefix}.integers DROP COLUMN j +-- +error: Parser Error: syntax error at or near "{" +== +ALTER TABLE {prefix}.integers RENAME COLUMN i TO k +-- +error: Parser Error: syntax error at or near "{" +== +SELECT k FROM {prefix}.integers +-- +error: Parser Error: syntax error at or near "{" +== +DROP TABLE {prefix}.integers +-- +error: Parser Error: syntax error at or near "{" +== +CREATE TABLE {prefix}.t1(i INTEGER) +-- +error: Parser Error: syntax error at or near "{" +== +ALTER TABLE {prefix}.t1 RENAME TO t2 +-- +error: Parser Error: syntax error at or near "{" +== +SELECT * FROM {prefix}.t2 +-- +error: Parser Error: syntax error at or near "{" +== +DROP TABLE {prefix}.t2 +-- +error: Parser Error: syntax error at or near "{" +== diff --git a/parser/testdata/corpus/sql/attach/attach_table_info.test b/parser/testdata/corpus/sql/attach/attach_table_info.test new file mode 100644 index 0000000..05de953 --- /dev/null +++ b/parser/testdata/corpus/sql/attach/attach_table_info.test @@ -0,0 +1,33 @@ +# source: test/sql/attach/attach_table_info.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +CREATE TABLE new_database.integers(i INTEGER) +-- +ok +== +PRAGMA table_info('new_database.integers'); +-- +ok +== +CREATE SCHEMA new_database.new_schema +-- +ok +== +CREATE TABLE new_database.new_schema.integers(i INTEGER) +-- +ok +== +PRAGMA table_info('new_database.new_schema.integers'); +-- +ok +== +USE new_database.new_schema +-- +ok +== +PRAGMA table_info('integers'); +-- +ok +== diff --git a/parser/testdata/corpus/sql/attach/attach_transactionality.test b/parser/testdata/corpus/sql/attach/attach_transactionality.test new file mode 100644 index 0000000..759f92c --- /dev/null +++ b/parser/testdata/corpus/sql/attach/attach_transactionality.test @@ -0,0 +1,33 @@ +# source: test/sql/attach/attach_transactionality.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +ATTACH '{TEST_DIR}/attach_transaction.db' +-- +ok +== +CREATE TABLE attach_transaction.integers(i INTEGER) +-- +ok +== +INSERT INTO attach_transaction.integers VALUES (42) +-- +ok +== +DETACH attach_transaction +-- +ok +== +INSERT INTO attach_transaction.integers VALUES (84) +-- +ok +== +SELECT * FROM attach_transaction.integers +-- +ok +== +SELECT * FROM attach_transaction.integers ORDER BY 1 +-- +ok +== diff --git a/parser/testdata/corpus/sql/attach/attach_use_rollback.test b/parser/testdata/corpus/sql/attach/attach_use_rollback.test new file mode 100644 index 0000000..2ad03ec --- /dev/null +++ b/parser/testdata/corpus/sql/attach/attach_use_rollback.test @@ -0,0 +1,21 @@ +# source: test/sql/attach/attach_use_rollback.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +begin; +-- +ok +== +attach ':memory:' as mem; +-- +ok +== +use mem; +-- +ok +== +create table tbl(i int); +-- +ok +== diff --git a/parser/testdata/corpus/sql/attach/attach_view_search_path.test b/parser/testdata/corpus/sql/attach/attach_view_search_path.test new file mode 100644 index 0000000..371f1af --- /dev/null +++ b/parser/testdata/corpus/sql/attach/attach_view_search_path.test @@ -0,0 +1,61 @@ +# source: test/sql/attach/attach_view_search_path.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +ATTACH DATABASE '{TEST_DIR}/view_search_path.db' AS view_search_path; +-- +ok +== +USE view_search_path +-- +ok +== +CREATE TABLE my_tbl(i INTEGER) +-- +ok +== +INSERT INTO my_tbl VALUES (42) +-- +ok +== +CREATE VIEW my_view AS FROM my_tbl +-- +ok +== +FROM my_view +-- +ok +== +CREATE SCHEMA my_schema +-- +ok +== +USE my_schema +-- +ok +== +INSERT INTO my_tbl VALUES (84) +-- +ok +== +ATTACH DATABASE '{TEST_DIR}/view_search_path_other.db'; +-- +ok +== +USE view_search_path_other; +-- +ok +== +FROM view_search_path.my_view +-- +ok +== +FROM view_search_path.my_schema.my_view +-- +ok +== +DETACH view_search_path +-- +ok +== diff --git a/parser/testdata/corpus/sql/attach/attach_views.test b/parser/testdata/corpus/sql/attach/attach_views.test new file mode 100644 index 0000000..ce1220e --- /dev/null +++ b/parser/testdata/corpus/sql/attach/attach_views.test @@ -0,0 +1,49 @@ +# source: test/sql/attach/attach_views.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +CREATE TABLE t1 AS SELECT 42 i +-- +ok +== +CREATE VIEW {prefix}.v1 AS SELECT * FROM t1 +-- +error: Parser Error: syntax error at or near "{" +== +SELECT * FROM {prefix}.v1 +-- +error: Parser Error: syntax error at or near "{" +== +CREATE TABLE {prefix}.t1 AS SELECT 84 i +-- +error: Parser Error: syntax error at or near "{" +== +CREATE OR REPLACE VIEW {prefix}.v1 AS SELECT * FROM {prefix}.t1 +-- +error: Parser Error: syntax error at or near "{" +== +SELECT * FROM {prefix}.t1 +-- +error: Parser Error: syntax error at or near "{" +== +CREATE OR REPLACE VIEW {prefix}.v1 AS SELECT * FROM {prefix}.t1 UNION ALL FROM memory.t1 ORDER BY ALL +-- +error: Parser Error: syntax error at or near "{" +== +ALTER VIEW {prefix}.v1 RENAME TO v2 +-- +error: Parser Error: syntax error at or near "{" +== +SELECT * FROM {prefix}.v2 +-- +error: Parser Error: syntax error at or near "{" +== +DROP VIEW {prefix}.v2 +-- +error: Parser Error: syntax error at or near "{" +== +DROP TABLE {prefix}.t1 +-- +error: Parser Error: syntax error at or near "{" +== diff --git a/parser/testdata/corpus/sql/attach/attach_wal_alter.test b/parser/testdata/corpus/sql/attach/attach_wal_alter.test new file mode 100644 index 0000000..16e93b1 --- /dev/null +++ b/parser/testdata/corpus/sql/attach/attach_wal_alter.test @@ -0,0 +1,21 @@ +# source: test/sql/attach/attach_wal_alter.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +ATTACH DATABASE '{TEST_DIR}/wal_crash.db' as db1; +-- +ok +== +ATTACH DATABASE ':memory:' as db2; +-- +ok +== +INSERT INTO db1.t2 DEFAULT VALUES +-- +ok +== +SELECT * FROM db1.t2 +-- +ok +== diff --git a/parser/testdata/corpus/sql/attach/attach_wal_alter_sequence.test b/parser/testdata/corpus/sql/attach/attach_wal_alter_sequence.test new file mode 100644 index 0000000..496f64f --- /dev/null +++ b/parser/testdata/corpus/sql/attach/attach_wal_alter_sequence.test @@ -0,0 +1,45 @@ +# source: test/sql/attach/attach_wal_alter_sequence.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +attach '{TEST_DIR}/attach_wal_with_sequence.db' as db1; +-- +ok +== +CREATE SEQUENCE db1.seq; +-- +ok +== +CREATE TABLE db1.test (a INTEGER DEFAULT nextval('seq'), b INTEGER, c INTEGER DEFAULT currval('seq')); +-- +ok +== +INSERT INTO db1.test (b) VALUES (1); +-- +ok +== +alter table db1.test RENAME TO blubb; +-- +ok +== +INSERT INTO db1.blubb (b) VALUES (10); +-- +ok +== +SELECT * FROM db1.blubb +-- +ok +== +attach '{TEST_DIR}/attach_wal_with_sequence.db' as db2; +-- +ok +== +INSERT INTO db2.blubb (b) VALUES (100); +-- +ok +== +SELECT * FROM db2.blubb +-- +ok +== diff --git a/parser/testdata/corpus/sql/attach/detach_keyword.test b/parser/testdata/corpus/sql/attach/detach_keyword.test new file mode 100644 index 0000000..f5da9ae --- /dev/null +++ b/parser/testdata/corpus/sql/attach/detach_keyword.test @@ -0,0 +1,13 @@ +# source: test/sql/attach/detach_keyword.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +ATTACH DATABASE ':memory:' AS varchar; +-- +ok +== +DETACH varchar +-- +ok +== diff --git a/parser/testdata/corpus/sql/attach/detach_manager_default_database.test b/parser/testdata/corpus/sql/attach/detach_manager_default_database.test new file mode 100644 index 0000000..709874d --- /dev/null +++ b/parser/testdata/corpus/sql/attach/detach_manager_default_database.test @@ -0,0 +1,25 @@ +# source: test/sql/attach/detach_manager_default_database.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +ATTACH ':memory:' AS other; +-- +ok +== +USE other; +-- +ok +== +DETACH memory; +-- +ok +== +RESET search_path; +-- +ok +== +SELECT database_name FROM duckdb_databases() WHERE database_name = 'other'; +-- +ok +== diff --git a/parser/testdata/corpus/sql/attach/external_resource_discovery.test b/parser/testdata/corpus/sql/attach/external_resource_discovery.test new file mode 100644 index 0000000..4454790 --- /dev/null +++ b/parser/testdata/corpus/sql/attach/external_resource_discovery.test @@ -0,0 +1,47 @@ +# source: test/sql/attach/external_resource_discovery.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +CREATE MACRO qk_create(p) AS TABLE SELECT MAP {'id': 'q1'} AS handle; +-- +ok +== +CREATE MACRO qk_status(h) AS TABLE + SELECT 'ready' AS state, MAP {'uri': 'localhost', 'attached_db_type': 'quack'} AS result; +-- +ok +== +CREATE MACRO qk_list(p) AS TABLE + SELECT * FROM (VALUES + (MAP {'id': 'q1'}, 'ref-q1', 'running'), + (MAP {'id': 'q2'}, 'ref-q2', 'running') + ) t(handle, reference, state); +-- +ok +== +CALL register_external_resource_type('quack@disco', kind := 'catalog', create_function := 'qk_create', + status_function := 'qk_status', list_function := 'qk_list'); +-- +ok +== +SELECT name, list_function FROM duckdb_external_resource_types() WHERE name = 'quack@disco'; +-- +ok +== +CREATE EXTERNAL RESOURCE 'quack@disco' AS mine; +-- +ok +== +SELECT name, type, managed FROM duckdb_external_resources() ORDER BY name; +-- +ok +== +SELECT name, type, managed, state FROM duckdb_external_resources(discover := true) ORDER BY managed DESC, reference; +-- +ok +== +SELECT reference, state FROM duckdb_external_resources(discover := true) WHERE managed = false; +-- +ok +== diff --git a/parser/testdata/corpus/sql/attach/external_resource_statements.test b/parser/testdata/corpus/sql/attach/external_resource_statements.test new file mode 100644 index 0000000..6591436 --- /dev/null +++ b/parser/testdata/corpus/sql/attach/external_resource_statements.test @@ -0,0 +1,41 @@ +# source: test/sql/attach/external_resource_statements.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +CREATE EXTERNAL RESOURCE 'aws:ec2:quack' AS x (SPOT, REGION 'eu-west-1'); +-- +ok +== +REGISTER EXTERNAL RESOURCE 'aws:ec2:quack' AS x FROM {'id': 'i-123'}; +-- +ok +== +DESTROY EXTERNAL RESOURCE nope; +-- +ok +== +SHOW EXTERNAL RESOURCES; +-- +ok +== +SHOW ALL EXTERNAL RESOURCES; +-- +ok +== +DESTROY EXTERNAL RESOURCE; +-- +error: Parser Error: syntax error at or near ";" +== +REGISTER EXTERNAL RESOURCE 'aws:ec2:quack' AS x; +-- +error: Parser Error: syntax error at or near ";" +== +CREATE TABLE t(i INTEGER); +-- +ok +== +SHOW ALL TABLES; +-- +ok +== diff --git a/parser/testdata/corpus/sql/attach/in_memory_attach.test b/parser/testdata/corpus/sql/attach/in_memory_attach.test new file mode 100644 index 0000000..0e6dee6 --- /dev/null +++ b/parser/testdata/corpus/sql/attach/in_memory_attach.test @@ -0,0 +1,33 @@ +# source: test/sql/attach/in_memory_attach.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +INSERT INTO new_database.integers VALUES (42); +-- +ok +== +INSERT INTO new_database.main.integers VALUES (84); +-- +ok +== +SELECT * FROM new_database.integers ORDER BY i +-- +ok +== +SELECT * FROM new_database.main.integers ORDER BY i +-- +ok +== +SELECT * FROM new_database.integers ORDER BY new_database.i +-- +ok +== +SELECT * FROM new_database.integers ORDER BY new_database.integers.i +-- +ok +== +SELECT * FROM new_database.main.integers ORDER BY new_database.main.integers.i +-- +ok +== diff --git a/parser/testdata/corpus/sql/attach/reattach_schema.test b/parser/testdata/corpus/sql/attach/reattach_schema.test new file mode 100644 index 0000000..7b68302 --- /dev/null +++ b/parser/testdata/corpus/sql/attach/reattach_schema.test @@ -0,0 +1,101 @@ +# source: test/sql/attach/reattach_schema.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +ATTACH '{TEST_DIR}/reattach_schema.db' AS new_db; +-- +ok +== +CREATE SCHEMA new_db.my_schema; +-- +ok +== +CREATE TABLE new_db.my_schema.my_table(col INTEGER); +-- +ok +== +INSERT INTO new_db.my_schema.my_table VALUES (42); +-- +ok +== +CREATE VIEW new_db.my_schema.my_view AS SELECT 84 +-- +ok +== +CREATE SEQUENCE new_db.my_schema.my_sequence; +-- +ok +== +CREATE MACRO new_db.my_schema.one() AS (SELECT 1); +-- +ok +== +CREATE MACRO new_db.my_schema.range(a) as TABLE SELECT * FROM range(a) +-- +ok +== +SELECT new_db.my_schema.one() +-- +ok +== +SELECT * FROM new_db.my_schema.range(3) +-- +ok +== +DETACH new_db +-- +ok +== +ATTACH '{TEST_DIR}/reattach_schema.db' AS new_name; +-- +ok +== +SELECT * FROM new_name.my_schema.my_table +-- +ok +== +SELECT * FROM new_name.my_schema.my_view +-- +ok +== +SELECT nextval('new_name.my_schema.my_sequence') +-- +ok +== +SELECT new_name.my_schema.one() +-- +ok +== +SELECT * FROM new_name.my_schema.range(3) +-- +ok +== +USE new_name.my_schema +-- +ok +== +USE new_name.my_schema.my_table +-- +error: Parser Error: Expected "USE database" or "USE database.schema" +== +SELECT * FROM my_table +-- +ok +== +SELECT * FROM my_view +-- +ok +== +SELECT nextval('my_sequence') +-- +ok +== +SELECT one() +-- +ok +== +SELECT * FROM range(3) +-- +ok +== diff --git a/parser/testdata/corpus/sql/attach/reattach_schema.test.metadata.json b/parser/testdata/corpus/sql/attach/reattach_schema.test.metadata.json new file mode 100644 index 0000000..f82090c --- /dev/null +++ b/parser/testdata/corpus/sql/attach/reattach_schema.test.metadata.json @@ -0,0 +1,5 @@ +{ + "todo": { + "b11ee77530666b1a": "transformer-raised parser error: upstream rejects in the transformer, not the grammar; expected to clear as transformers land (milestones 3-5)" + } +} diff --git a/parser/testdata/corpus/sql/attach/remote_file_concurrently.test b/parser/testdata/corpus/sql/attach/remote_file_concurrently.test new file mode 100644 index 0000000..e30fc8d --- /dev/null +++ b/parser/testdata/corpus/sql/attach/remote_file_concurrently.test @@ -0,0 +1,13 @@ +# source: test/sql/attach/remote_file_concurrently.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +ATTACH 'https://raw.githubusercontent.com/duckdb/duckdb/main/data/attach_test/attach.db' AS db; +-- +ok +== +ATTACH 'https://raw.githubusercontent.com/duckdb/duckdb/main/data/attach_test/attach.db' AS db2; +-- +ok +== diff --git a/parser/testdata/corpus/sql/attach/searchpath_fallback.test b/parser/testdata/corpus/sql/attach/searchpath_fallback.test new file mode 100644 index 0000000..f790dca --- /dev/null +++ b/parser/testdata/corpus/sql/attach/searchpath_fallback.test @@ -0,0 +1,158 @@ +# source: test/sql/attach/searchpath_fallback.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +ATTACH ':memory:' AS view_path_c1; +-- +ok +== +CREATE SCHEMA view_path_c1.s1; +-- +ok +== +CREATE MACRO view_path_c1.main.fn() AS 1; +-- +ok +== +ATTACH ':memory:' AS view_path_c2; +-- +ok +== +CREATE MACRO view_path_c2.main.fn() AS 'caller'; +-- +ok +== +SET search_path = 'view_path_c2.main'; +-- +ok +== +CREATE VIEW view_path_c1.s1.v AS SELECT fn() AS result; +-- +ok +== +SELECT data_type +FROM duckdb_columns() +WHERE database_name = 'view_path_c1' + AND schema_name = 's1' + AND table_name = 'v' + AND column_name = 'result'; +-- +ok +== +FROM view_path_c1.s1.v; +-- +ok +== +DETACH view_path_c2; +-- +ok +== +DETACH view_path_c1; +-- +ok +== +CREATE MACRO view_path_c2.main.fn() AS 2; +-- +ok +== +ATTACH ':memory:' AS dt (DEFAULT_TABLE 'real_t'); +-- +ok +== +CREATE TABLE dt.main.real_t(i INT); +-- +ok +== +INSERT INTO dt.main.real_t values (1); +-- +ok +== +ATTACH ':memory:' AS c1; +-- +ok +== +CREATE SCHEMA c1.s1; +-- +ok +== +CREATE TABLE c1.main.dt(i INT); +-- +ok +== +CREATE VIEW c1.s1.vv AS SELECT * FROM dt; +-- +ok +== +FROM c1.s1.vv; +-- +ok +== +DETACH dt; +-- +ok +== +CREATE TYPE my_enum AS ENUM ('x'); +-- +ok +== +ATTACH ':memory:' AS c2; +-- +ok +== +CREATE SCHEMA c2.s1; +-- +ok +== +CREATE TYPE c2.my_enum AS ENUM ('y'); +-- +ok +== +CREATE TABLE c2.s1.t(a VARCHAR); +-- +ok +== +INSERT INTO c2.s1.t VALUES ('x'); +-- +ok +== +ALTER TABLE c2.s1.t ALTER COLUMN a SET DATA TYPE my_enum; +-- +ok +== +FROM c2.s1.t; +-- +ok +== +DETACH c2; +-- +ok +== +ATTACH ':memory:' as test; +-- +ok +== +ATTACH ':memory:' as test2; +-- +ok +== +CREATE OR REPLACE MACRO fn(a) as a+1; +-- +ok +== +CREATE SCHEMA other_schema; +-- +ok +== +CREATE VIEW other_schema.some_view AS SELECT fn(1) AS t; +-- +ok +== +use test2; +-- +ok +== +from test.other_schema.some_view; +-- +ok +== diff --git a/parser/testdata/corpus/sql/attach/show_databases.test b/parser/testdata/corpus/sql/attach/show_databases.test new file mode 100644 index 0000000..46673a2 --- /dev/null +++ b/parser/testdata/corpus/sql/attach/show_databases.test @@ -0,0 +1,29 @@ +# source: test/sql/attach/show_databases.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +SHOW DATABASES +-- +ok +== +SELECT name FROM pragma_database_list ORDER BY name +-- +ok +== +USE new_database +-- +ok +== +CREATE TABLE tbl AS SELECT 42 i +-- +ok +== +SELECT * FROM new_database.tbl +-- +ok +== +USE blablabla +-- +ok +== diff --git a/parser/testdata/corpus/sql/attach/show_schemas.test b/parser/testdata/corpus/sql/attach/show_schemas.test new file mode 100644 index 0000000..430a291 --- /dev/null +++ b/parser/testdata/corpus/sql/attach/show_schemas.test @@ -0,0 +1,31 @@ +# source: test/sql/attach/show_schemas.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +SHOW SCHEMAS +-- +ok +== +USE new_database; +-- +ok +== +CREATE SCHEMA new_s1; +CREATE SCHEMA new_s2; +CREATE SCHEMA memory.mem_s1; +-- +ok +== +USE new_database.new_s2; +-- +ok +== +DROP SCHEMA new_database.new_s2; +-- +ok +== +DESCRIBE SCHEMAS +-- +ok +== diff --git a/parser/testdata/corpus/sql/attach/system_catalog.test b/parser/testdata/corpus/sql/attach/system_catalog.test new file mode 100644 index 0000000..e7d1b25 --- /dev/null +++ b/parser/testdata/corpus/sql/attach/system_catalog.test @@ -0,0 +1,37 @@ +# source: test/sql/attach/system_catalog.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +DETACH DATABASE system +-- +ok +== +DETACH DATABASE temp +-- +ok +== +CREATE SCHEMA system.eek +-- +ok +== +CREATE TABLE system.main.integers(i INTEGER) +-- +ok +== +CREATE VIEW system.main.integers AS SELECT 42 +-- +ok +== +CREATE SEQUENCE system.main.seq +-- +ok +== +CREATE MACRO system.main.my_macro(a,b) AS a+b +-- +ok +== +CREATE TYPE system.main.rainbow AS ENUM ('red', 'orange', 'yellow', 'green', 'blue', 'purple'); +-- +ok +== diff --git a/parser/testdata/corpus/sql/binder/alias_error_10057.test b/parser/testdata/corpus/sql/binder/alias_error_10057.test new file mode 100644 index 0000000..fcdb59b --- /dev/null +++ b/parser/testdata/corpus/sql/binder/alias_error_10057.test @@ -0,0 +1,12 @@ +# source: test/sql/binder/alias_error_10057.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +with test_data as ( + select 'foo' as a +) +select test_data.foobar as new_column from test_data where new_column is not null; +-- +ok +== diff --git a/parser/testdata/corpus/sql/binder/alias_qualification_errors.test b/parser/testdata/corpus/sql/binder/alias_qualification_errors.test new file mode 100644 index 0000000..9156e2f --- /dev/null +++ b/parser/testdata/corpus/sql/binder/alias_qualification_errors.test @@ -0,0 +1,21 @@ +# source: test/sql/binder/alias_qualification_errors.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +SELECT alias.x + 1 AS y, 1 AS x +-- +ok +== +SELECT alias.nope; +-- +ok +== +SELECT (SELECT 1) AS x, alias.x +-- +ok +== +SELECT 5 as x, alias.123; +-- +error: Parser Error: syntax error at or near ".123" +== diff --git a/parser/testdata/corpus/sql/binder/alias_qualification_group_by.test b/parser/testdata/corpus/sql/binder/alias_qualification_group_by.test new file mode 100644 index 0000000..a363d9a --- /dev/null +++ b/parser/testdata/corpus/sql/binder/alias_qualification_group_by.test @@ -0,0 +1,46 @@ +# source: test/sql/binder/alias_qualification_group_by.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +SELECT a % 2 AS x, COUNT(*) AS cnt +FROM (VALUES (1),(2),(3),(4)) t(a) +GROUP BY alias.x +ORDER BY x; +-- +ok +== +SELECT (a/2)::INT AS "Half", COUNT(*) AS c +FROM (VALUES (1),(2),(3),(4)) t(a) +GROUP BY alias."Half" +ORDER BY "Half"; +-- +ok +== +CREATE TABLE alias (g INT); +-- +ok +== +INSERT INTO alias VALUES (1), (1), (2); +-- +ok +== +SELECT g AS x, COUNT(*) c FROM alias +GROUP BY alias.g +ORDER BY x; +-- +ok +== +SELECT a + 1 AS x, alias.x % 2 AS y, SUM(a) AS s +FROM (VALUES (1),(2),(3)) t(a) +GROUP BY alias.y +ORDER BY y; +-- +ok +== +SELECT a as x FROM (VALUES (1),(2),(3)) t(a) +GROUP BY alias.x + 1 +ORDER BY alias.x; +-- +ok +== diff --git a/parser/testdata/corpus/sql/binder/alias_qualification_having.test b/parser/testdata/corpus/sql/binder/alias_qualification_having.test new file mode 100644 index 0000000..81e3c5a --- /dev/null +++ b/parser/testdata/corpus/sql/binder/alias_qualification_having.test @@ -0,0 +1,54 @@ +# source: test/sql/binder/alias_qualification_having.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +SELECT a % 2 AS x, SUM(a) AS s +FROM (VALUES (1),(2),(3),(4)) t(a) +GROUP BY alias.x +HAVING alias.s >= 6 +ORDER BY x; +-- +ok +== +SELECT a + 1 AS x, alias.x % 2 AS y, SUM(a) AS s +FROM (VALUES (1),(2),(3),(4)) t(a) +GROUP BY a +HAVING alias.s > 2 +ORDER BY y; +-- +ok +== +SELECT (a/2)::INT AS "Half", COUNT(*) AS c +FROM (VALUES (1),(2),(3),(4)) t(a) +GROUP BY alias."Half" +HAVING alias.c >= 1 +ORDER BY "Half"; +-- +ok +== +SELECT g AS x, COUNT(*) c FROM alias +GROUP BY alias.g +HAVING alias.c = 2 +ORDER BY x; +-- +ok +== +SELECT c1, sum(c2) as c3 FROM VALUES ('a', 1), ('b', 2), ('b', 3), ('c', 4), ('d', null) AS t(c1, c2) group by c1 having c3.add(1) > 2 order by c1; +-- +ok +== +FROM VALUES ('CS', 'Bachelor'), ('CS', 'Bachelor'), ('CS', 'PhD'), ('Math', 'Masters') AS t(c1, c2) +SELECT c1, STRING_AGG(c2, ',' order by c2) as c3 +GROUP BY c1 +HAVING len(c3) > 7 +-- +ok +== +FROM VALUES ('CS', 'Bachelor'), ('CS', 'Bachelor'), ('CS', 'PhD'), ('Math', 'Masters') AS t(c1, c2) +SELECT c1, STRING_AGG(c2, ',' order by c2) as c3 +GROUP BY c1 +HAVING c3.len() > 7 +-- +ok +== diff --git a/parser/testdata/corpus/sql/binder/alias_qualification_order_by.test b/parser/testdata/corpus/sql/binder/alias_qualification_order_by.test new file mode 100644 index 0000000..aba1382 --- /dev/null +++ b/parser/testdata/corpus/sql/binder/alias_qualification_order_by.test @@ -0,0 +1,33 @@ +# source: test/sql/binder/alias_qualification_order_by.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +SELECT a AS x FROM (VALUES (3),(1),(2)) t(a) +ORDER BY alias.x; +-- +ok +== +SELECT a + 1 AS x, alias.x * 10 AS y FROM (VALUES (1),(3),(2)) t(a) +ORDER BY alias.y DESC; +-- +ok +== +SELECT a AS "MiXeD" FROM (VALUES (2),(1)) t(a) +ORDER BY alias."MiXeD"; +-- +ok +== +CREATE TABLE alias (v INT); +-- +ok +== +INSERT INTO alias VALUES (20), (10); +-- +ok +== +SELECT v AS x FROM alias +ORDER BY alias.v; +-- +ok +== diff --git a/parser/testdata/corpus/sql/binder/alias_qualification_qualify.test b/parser/testdata/corpus/sql/binder/alias_qualification_qualify.test new file mode 100644 index 0000000..0b55587 --- /dev/null +++ b/parser/testdata/corpus/sql/binder/alias_qualification_qualify.test @@ -0,0 +1,46 @@ +# source: test/sql/binder/alias_qualification_qualify.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +SELECT a, row_number() OVER (ORDER BY a) AS rn +FROM (VALUES (3),(1),(2)) t(a) +QUALIFY alias.rn <= 2 +ORDER BY a; +-- +ok +== +SELECT a + 1 AS x, row_number() OVER (ORDER BY alias.x) AS rx +FROM (VALUES (10),(20),(30)) t(a) +QUALIFY alias.rx = 2 +ORDER BY a; +-- +ok +== +SELECT a AS "MiXeD", row_number() OVER (ORDER BY a) AS r +FROM (VALUES (2),(1)) t(a) +QUALIFY alias.r = 1 +ORDER BY a; +-- +ok +== +INSERT INTO alias VALUES (2), (1), (3); +-- +ok +== +SELECT v AS x, row_number() OVER (ORDER BY v) r FROM alias +QUALIFY alias.r <= 2 +ORDER BY v; +-- +ok +== +SELECT c1, row_number() over(partition BY c1 order by c2) as rk FROM VALUES ('a', 1), ('b', 2), ('b', 3), ('c', 4) AS t(c1, c2) qualify rk.add(1) > 2 +-- +ok +== +FROM VALUES ('CS', 'Bachelor'), ('CS', 'Bachelor'), ('CS', 'PhD'), ('Math', 'Masters') AS t(c1, c2) +SELECT list(c2) over(partition BY c1) AS "c3" +QUALIFY "c3".len() = 1; +-- +ok +== diff --git a/parser/testdata/corpus/sql/binder/alias_qualification_select_projection.test b/parser/testdata/corpus/sql/binder/alias_qualification_select_projection.test new file mode 100644 index 0000000..6556244 --- /dev/null +++ b/parser/testdata/corpus/sql/binder/alias_qualification_select_projection.test @@ -0,0 +1,88 @@ +# source: test/sql/binder/alias_qualification_select_projection.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +SELECT + a + 1 AS x, + alias.x + 2 AS y +FROM (VALUES (42)) t(a); +-- +ok +== +SELECT + a AS a, + a + 1 AS x, + alias.x + 2 AS y, + alias.y * 2 AS z +FROM (VALUES (10)) t(a); +-- +ok +== +SELECT + a + 1 AS x, + alias.x AS x2, + alias.x + alias.x AS xsum +FROM (VALUES (5)) t(a); +-- +ok +== +SELECT + a + 1 AS "MiXeD", + alias."MiXeD" + 1 AS y +FROM (VALUES (1)) t(a); +-- +ok +== +SELECT + a, + row_number() OVER (ORDER BY a) AS rn, + alias.rn + 1 AS rn2 +FROM (VALUES (3),(1),(2)) t(a) +ORDER BY a; +-- +ok +== +SELECT DISTINCT + a AS x, + alias.x + 0 AS y +FROM (VALUES (1),(1),(2)) t(a) +ORDER BY x; +-- +ok +== +SELECT + a AS x, + CASE WHEN alias.x % 2 = 0 THEN 'even' ELSE 'odd' END AS parity +FROM (VALUES (1),(2),(3)) t(a) +ORDER BY a; +-- +ok +== +SELECT + 'hi' AS s, + alias.s || '!' AS ex +FROM (VALUES (1)) t(a); +-- +ok +== +CREATE TABLE alias (col1 INT, col2 INT); +-- +ok +== +INSERT INTO alias VALUES (11, 22); +-- +ok +== +SELECT alias.col1, alias.col2 FROM alias; +-- +ok +== +SELECT col1 * 10 AS col2, alias.col2 AS projected_col2 FROM alias; +-- +ok +== +SELECT 'AbC' AS s, alias.s.lower(); +-- +ok +== diff --git a/parser/testdata/corpus/sql/binder/alias_qualification_where.test b/parser/testdata/corpus/sql/binder/alias_qualification_where.test new file mode 100644 index 0000000..953758f --- /dev/null +++ b/parser/testdata/corpus/sql/binder/alias_qualification_where.test @@ -0,0 +1,32 @@ +# source: test/sql/binder/alias_qualification_where.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +SELECT a AS x FROM (VALUES (1),(2),(3)) t(a) +WHERE alias.x > 1 +ORDER BY a; +-- +ok +== +SELECT a + 1 AS x, alias.x * 2 AS y FROM (VALUES (1),(2)) t(a) +WHERE alias.y >= 6 +ORDER BY a; +-- +ok +== +SELECT a AS "MiXeD" FROM (VALUES (0),(1)) t(a) +WHERE alias."MiXeD" = 1; +-- +ok +== +INSERT INTO alias VALUES (10), (20); +-- +ok +== +SELECT v AS x FROM alias +WHERE alias.v > 10 +ORDER BY v; +-- +ok +== diff --git a/parser/testdata/corpus/sql/binder/alias_where_side_effects.test b/parser/testdata/corpus/sql/binder/alias_where_side_effects.test new file mode 100644 index 0000000..0722ed4 --- /dev/null +++ b/parser/testdata/corpus/sql/binder/alias_where_side_effects.test @@ -0,0 +1,9 @@ +# source: test/sql/binder/alias_where_side_effects.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +select count(*) from (select random() as num from range(20) where num > 0.9) where num <= 0.9 +-- +ok +== diff --git a/parser/testdata/corpus/sql/binder/column_ref_as_alias.test b/parser/testdata/corpus/sql/binder/column_ref_as_alias.test new file mode 100644 index 0000000..aef20e9 --- /dev/null +++ b/parser/testdata/corpus/sql/binder/column_ref_as_alias.test @@ -0,0 +1,47 @@ +# source: test/sql/binder/column_ref_as_alias.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +create table ss_items as select 1 item_id, 10 ss_item_rev; +-- +ok +== +create table cs_items as select 1 item_id, 100 cs_item_rev; +-- +ok +== +select ss_items.item_id +from ss_items,cs_items +where ss_items.item_id = cs_items.item_id +order by item_id; +-- +ok +== +select ss_items.item_id, cs_items.item_id +from ss_items,cs_items +where ss_items.item_id = cs_items.item_id +order by item_id; +-- +ok +== +select ss_items.item_id +from ss_items,cs_items +where ss_items.item_id = cs_items.item_id +group by item_id; +-- +ok +== +select item_id +from ss_items,cs_items +where ss_items.item_id = cs_items.item_id; +-- +ok +== +select ss_items.item_id, cs_items.item_id +from ss_items,cs_items +where ss_items.item_id = cs_items.item_id +order by item_id +-- +ok +== diff --git a/parser/testdata/corpus/sql/binder/column_value_alias_group.test b/parser/testdata/corpus/sql/binder/column_value_alias_group.test new file mode 100644 index 0000000..c7b37a4 --- /dev/null +++ b/parser/testdata/corpus/sql/binder/column_value_alias_group.test @@ -0,0 +1,29 @@ +# source: test/sql/binder/column_value_alias_group.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +create table test(a int); +-- +ok +== +insert into test values (2), (1), (3); +-- +ok +== +select a as "user" from test group by "user"; +-- +ok +== +select a as "user" from test group by "user" having "user"=1; +-- +ok +== +select a as "user" from test order by "user"; +-- +ok +== +select a as "user" from test group by "user" order by "user"; +-- +ok +== diff --git a/parser/testdata/corpus/sql/binder/duplicate_alias.test b/parser/testdata/corpus/sql/binder/duplicate_alias.test new file mode 100644 index 0000000..8b53832 --- /dev/null +++ b/parser/testdata/corpus/sql/binder/duplicate_alias.test @@ -0,0 +1,33 @@ +# source: test/sql/binder/duplicate_alias.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +create table t(i int); +-- +ok +== +INSERT INTO t VALUES (42); +-- +ok +== +SELECT COUNT(*) FROM t, t +-- +ok +== +SELECT * FROM (SELECT 42 x) t, (SELECT 84 y) t +-- +ok +== +SELECT t.x, t.y FROM (SELECT 42 x) t, (SELECT 84 y) t +-- +ok +== +SELECT t.z FROM (SELECT 42 x) t, (SELECT 84 y) t +-- +ok +== +SELECT t.i FROM t, t +-- +ok +== diff --git a/parser/testdata/corpus/sql/binder/function_chaining_19035.test b/parser/testdata/corpus/sql/binder/function_chaining_19035.test new file mode 100644 index 0000000..1848487 --- /dev/null +++ b/parser/testdata/corpus/sql/binder/function_chaining_19035.test @@ -0,0 +1,64 @@ +# source: test/sql/binder/function_chaining_19035.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +with stage as ( + select + [1,2,3] as c1, + [4,5,6] as c2 +) +select + list_transform( + c1, + lambda x: list_bool_or( + list_transform( + c2, + lambda y: y == x + ) + ) + ) as c3 +from stage; +-- +ok +== +select list_transform( + [1,2,3], + lambda x: list_max( + list_transform([4,5,6], lambda y: y + x) + )) as result; +-- +ok +== +CREATE MACRO list_contains_macro(x, y) AS (SELECT list_contains(x, y)) +-- +ok +== +SELECT list_filter([[1, 2, 1], [1, 2, 3], [1, 1, 1]], lambda x: list_contains_macro(x, 3)) +-- +ok +== +CREATE TABLE tbl(a int[]); +-- +ok +== +INSERT INTO tbl VALUES ([5, 4, 3]), ([1, 2, 3]), (NULL), ([NULL, 101, 12]); +-- +ok +== +SELECT list_transform(a, lambda x, i: x + i + list_any_value(a)) FROM tbl; +-- +ok +== +select ['a a ', ' b ', ' cc'].list_transform(lambda x: nullif(trim(x), '')) as trimmed_and_nulled +-- +ok +== +select ['a a ', ' b ', ' cc'].list_transform(lambda x: x.trim().nullif('')) as trimmed_and_nulled; +-- +ok +== +select ['a a ', ' b ', ' cd'].list_transform(lambda x: x.trim().nullif('').reverse()) as trimmed_and_nulled; +-- +ok +== diff --git a/parser/testdata/corpus/sql/binder/group_by_incremental_alias.test b/parser/testdata/corpus/sql/binder/group_by_incremental_alias.test new file mode 100644 index 0000000..ed7aa5a --- /dev/null +++ b/parser/testdata/corpus/sql/binder/group_by_incremental_alias.test @@ -0,0 +1,17 @@ +# source: test/sql/binder/group_by_incremental_alias.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +create table my_functions as select 'my_name' as function_name; +-- +ok +== +select + function_name as raw, + replace(raw, '_', ' ') as prettier +from my_functions +group by all; +-- +ok +== diff --git a/parser/testdata/corpus/sql/binder/group_by_qualification.test b/parser/testdata/corpus/sql/binder/group_by_qualification.test new file mode 100644 index 0000000..1da64f3 --- /dev/null +++ b/parser/testdata/corpus/sql/binder/group_by_qualification.test @@ -0,0 +1,33 @@ +# source: test/sql/binder/group_by_qualification.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +CREATE SCHEMA IF NOT EXISTS prd; +-- +ok +== +CREATE TABLE prd.ad_stats_v(event_date DATE, app VARCHAR, country VARCHAR, platform VARCHAR); +-- +ok +== +select event_date, country +FROM prd.ad_stats_v +GROUP by event_date, prd.ad_stats_v.country +order by country +-- +ok +== +select event_date, ad_stats_v.country +FROM prd.ad_stats_v +GROUP by event_date, prd.ad_stats_v.country +order by ad_stats_v.country +-- +ok +== +select event_date, prd.ad_stats_v.country +FROM prd.ad_stats_v +GROUP by event_date, prd.ad_stats_v.country; +-- +ok +== diff --git a/parser/testdata/corpus/sql/binder/integer_literal_binding.test b/parser/testdata/corpus/sql/binder/integer_literal_binding.test new file mode 100644 index 0000000..c843257 --- /dev/null +++ b/parser/testdata/corpus/sql/binder/integer_literal_binding.test @@ -0,0 +1,29 @@ +# source: test/sql/binder/integer_literal_binding.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +SELECT typeof(100::{type} + 1) == '{type}'; +-- +error: Parser Error: syntax error at or near "{" +== +SELECT typeof(100 + 1::{type}) == '{type}'; +-- +error: Parser Error: syntax error at or near "{" +== +SELECT typeof(1::TINYINT + 100); +-- +ok +== +SELECT typeof(1::TINYINT + 10000); +-- +ok +== +SELECT typeof(1.05 + 1) +-- +ok +== +SELECT typeof(1 + 1); +-- +ok +== diff --git a/parser/testdata/corpus/sql/binder/legacy_null_type.test b/parser/testdata/corpus/sql/binder/legacy_null_type.test new file mode 100644 index 0000000..1c6f917 --- /dev/null +++ b/parser/testdata/corpus/sql/binder/legacy_null_type.test @@ -0,0 +1,17 @@ +# source: test/sql/binder/legacy_null_type.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +SET legacy_disable_null_type=true; +-- +ok +== +CREATE TABLE t AS SELECT NULL c +-- +ok +== +SELECT TYPEOF(c) FROM t +-- +ok +== diff --git a/parser/testdata/corpus/sql/binder/missing_column_error.test b/parser/testdata/corpus/sql/binder/missing_column_error.test new file mode 100644 index 0000000..f22097a --- /dev/null +++ b/parser/testdata/corpus/sql/binder/missing_column_error.test @@ -0,0 +1,26 @@ +# source: test/sql/binder/missing_column_error.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +create table customers (name varchar, age integer, something_easy_to_type_wrong integer, city varchar); +-- +ok +== +create table zipcodes (city varchar, zipcode varchar); +-- +ok +== +with cte as ( + select *, + rank() over (order by something_easy_to_typo_wrong) as rk + from customers + where age <= 42 +) +select * +from zipcodes +join cte +using (city); +-- +ok +== diff --git a/parser/testdata/corpus/sql/binder/not_similar_to.test b/parser/testdata/corpus/sql/binder/not_similar_to.test new file mode 100644 index 0000000..50c33bf --- /dev/null +++ b/parser/testdata/corpus/sql/binder/not_similar_to.test @@ -0,0 +1,53 @@ +# source: test/sql/binder/not_similar_to.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +create or replace table foo as select 'd' as a, 'e' as b, 'f' as c; +-- +ok +== +select * similar to '(a|c)' from foo; +-- +ok +== +select * not similar to '(a|c)' from foo; +-- +ok +== +SELECT * similar to 'b' FROM (select * not similar to '(a|c)' from foo); +-- +ok +== +SELECT * similar to 'a' FROM (select * not similar to '(a|c)' from foo); +-- +ok +== +INSERT INTO t0(c0) VALUES (0.1); +-- +ok +== +SELECT * FROM t0 WHERE REGEXP_MATCHES(t0.c0, '1'); +-- +ok +== +SELECT * FROM t0 WHERE NOT REGEXP_MATCHES(t0.c0, '1'); +-- +ok +== +SELECT 'aaa' NOT SIMILAR TO '[b-z]{3}'; +-- +ok +== +CREATE TABLE integers(col1 INTEGER, col2 INTEGER, k INTEGER) +-- +ok +== +INSERT INTO integers VALUES (1, 2, 3) +-- +ok +== +SELECT * LIKE 'col%' FROM integers +-- +ok +== diff --git a/parser/testdata/corpus/sql/binder/old_implicit_cast.test b/parser/testdata/corpus/sql/binder/old_implicit_cast.test new file mode 100644 index 0000000..a429b1f --- /dev/null +++ b/parser/testdata/corpus/sql/binder/old_implicit_cast.test @@ -0,0 +1,25 @@ +# source: test/sql/binder/old_implicit_cast.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +CREATE TABLE integers AS SELECT 42 AS i, '5' AS v; +-- +ok +== +SELECT i >= v FROM integers +-- +ok +== +SELECT i[1] FROM integers +-- +ok +== +SELECT [i, v] FROM integers +-- +ok +== +SET old_implicit_casting=true +-- +ok +== diff --git a/parser/testdata/corpus/sql/binder/old_implicit_cast_template.test b/parser/testdata/corpus/sql/binder/old_implicit_cast_template.test new file mode 100644 index 0000000..bf71903 --- /dev/null +++ b/parser/testdata/corpus/sql/binder/old_implicit_cast_template.test @@ -0,0 +1,17 @@ +# source: test/sql/binder/old_implicit_cast_template.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +create table t1 as select * from values ('1-2', '3-4', 'a-z', NULL) as r(v); +-- +ok +== +SELECT list_extract(string_split(v, '-'), 1) FROM t1; +-- +ok +== +SET old_implicit_casting = true; +-- +ok +== diff --git a/parser/testdata/corpus/sql/binder/order_by_view.test b/parser/testdata/corpus/sql/binder/order_by_view.test new file mode 100644 index 0000000..efe7411 --- /dev/null +++ b/parser/testdata/corpus/sql/binder/order_by_view.test @@ -0,0 +1,46 @@ +# source: test/sql/binder/order_by_view.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +CREATE TABLE src("Name" VARCHAR, CreatedAt TIMESTAMP, userID VARCHAR, "Version" VARCHAR, Clients BIGINT, HasDocumentation BOOLEAN, HasCustomAddress BOOLEAN, HasHostname BOOLEAN, RunningContainers BIGINT, HasActions BOOLEAN); +-- +ok +== +CREATE VIEW model AS + SELECT DISTINCT on(userID, CreatedAt::DATE) + CreatedAt::DATE AS CreatedAt, + "Version", + Clients, + HasCustomAddress, + HasHostname, + RunningContainers, + HasDocumentation, + HasActions +FROM src +WHERE name = 'events' +ORDER BY userID, CreatedAt DESC; +-- +ok +== +SELECT HasCustomAddress, count(*) AS total_records +FROM model +WHERE +1 = 1 AND +CreatedAt >= '2023-12-01' AND +CreatedAt < '2023-12-13' +GROUP BY HasCustomAddress ; +-- +ok +== +SELECT HasCustomAddress, count(*) AS total_records +FROM model +WHERE 1 = 1 AND +CreatedAt >= '2023-12-01' AND +CreatedAt < '2023-12-13' +GROUP BY HasCustomAddress +ORDER BY true, total_records DESC NULLS LAST +LIMIT 250 OFFSET 0; +-- +ok +== diff --git a/parser/testdata/corpus/sql/binder/qualified_alias_method_call.test b/parser/testdata/corpus/sql/binder/qualified_alias_method_call.test new file mode 100644 index 0000000..f4b7b1e --- /dev/null +++ b/parser/testdata/corpus/sql/binder/qualified_alias_method_call.test @@ -0,0 +1,45 @@ +# source: test/sql/binder/qualified_alias_method_call.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +CREATE TABLE test_alias(a INT, b VARCHAR); +-- +ok +== +INSERT INTO test_alias VALUES (1, 'hello'), (2, 'world'), (3, 'foo'); +-- +ok +== +SELECT a, b || '!' AS greeting FROM test_alias GROUP BY a, b HAVING greeting.lower() != 'foo!' ORDER BY a; +-- +ok +== +SELECT a, b || '!' AS greeting FROM test_alias GROUP BY a, b HAVING alias.greeting.lower() != 'foo!' ORDER BY a; +-- +ok +== +SELECT a, (a*10)::VARCHAR AS big FROM test_alias WHERE big.length() > 1 ORDER BY a; +-- +ok +== +SELECT a, (a*10)::VARCHAR AS big FROM test_alias WHERE alias.big.length() > 1 ORDER BY a; +-- +ok +== +SELECT a, b, row_number() OVER (ORDER BY a)::VARCHAR AS rn FROM test_alias QUALIFY rn.length() > 0 ORDER BY a; +-- +ok +== +SELECT a, b, row_number() OVER (ORDER BY a)::VARCHAR AS rn FROM test_alias QUALIFY alias.rn.length() > 0 ORDER BY a; +-- +ok +== +SELECT a, b AS x, alias.x.upper() AS y FROM test_alias ORDER BY a; +-- +ok +== +SELECT a, sum(a) AS total FROM test_alias GROUP BY a HAVING alias.total > 1 ORDER BY a; +-- +ok +== diff --git a/parser/testdata/corpus/sql/binder/separate_schema_tables.test b/parser/testdata/corpus/sql/binder/separate_schema_tables.test new file mode 100644 index 0000000..33206c1 --- /dev/null +++ b/parser/testdata/corpus/sql/binder/separate_schema_tables.test @@ -0,0 +1,127 @@ +# source: test/sql/binder/separate_schema_tables.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +CREATE SCHEMA IF NOT EXISTS s1; +-- +ok +== +CREATE SCHEMA IF NOT EXISTS s2; +-- +ok +== +CREATE SCHEMA IF NOT EXISTS s3; +-- +ok +== +CREATE TABLE s1.tbl(i INT); +-- +ok +== +CREATE TABLE s2.tbl(i INT); +-- +ok +== +CREATE TABLE s3.tbl(i INT); +-- +ok +== +CREATE TABLE tbl(i INT); +-- +ok +== +INSERT INTO s1.tbl VALUES (10); +-- +ok +== +INSERT INTO s2.tbl VALUES (100); +-- +ok +== +INSERT INTO s3.tbl VALUES (1000); +-- +ok +== +SELECT * FROM tbl, s1.tbl, s2.tbl +-- +ok +== +SELECT * FROM tbl, s1.tbl, s2.tbl, s3.tbl +-- +ok +== +SELECT tbl.i FROM s1.tbl, s2.tbl +-- +ok +== +SELECT tbl.i FROM s1.tbl, s2.tbl, s3.tbl +-- +ok +== +SELECT s1.tbl, s2.tbl, s3.tbl FROM s1.tbl, s2.tbl, s3.tbl +-- +ok +== +CREATE TABLE s1.t AS SELECT 1 id, 's1.t' payload UNION ALL SELECT 10 id, 'AAA' payload +-- +ok +== +CREATE TABLE s2.t AS SELECT 1 id, 's2.t' payload2 UNION ALL SELECT 100 id, 'BBB' payload2 +-- +ok +== +CREATE TABLE s3.t AS SELECT 1 id, 's3.t' payload3 UNION ALL SELECT 1000 id, 'CCC' payload3 +-- +ok +== +SELECT * FROM s1.t JOIN s2.t USING (id) JOIN s3.t USING (id) +-- +ok +== +SELECT id FROM s1.t JOIN s2.t USING (id) JOIN s3.t USING (id) +-- +ok +== +SELECT * FROM s1.t NATURAL JOIN s2.t NATURAL JOIN s3.t +-- +ok +== +SELECT id, s1.t.id, s2.t.id, s3.t.id, s1.t.payload, s2.t.payload2, s3.t.payload3 +FROM s1.t LEFT JOIN s2.t USING (id) LEFT JOIN s3.t USING (id) +ORDER BY ALL +-- +ok +== +SELECT id, s1.t.id, s2.t.id, s3.t.id, s1.t.payload, s2.t.payload2, s3.t.payload3 +FROM s1.t RIGHT JOIN s2.t USING (id) RIGHT JOIN s3.t USING (id) +ORDER BY ALL +-- +ok +== +SELECT id, s1.t.id, s2.t.id, s3.t.id, s1.t.payload, s2.t.payload2, s3.t.payload3 +FROM s1.t FULL OUTER JOIN s2.t USING (id) FULL OUTER JOIN s3.t USING (id) +ORDER BY ALL +-- +ok +== +CREATE OR REPLACE TABLE s1.tbl(col INT); +-- +ok +== +CREATE OR REPLACE TABLE s2.TBL(COL INT); +-- +ok +== +CREATE OR REPLACE TABLE s3.Tbl(Col INT); +-- +ok +== +SELECT tbl.col FROM s1.tbl, s2.tbl +-- +ok +== +SELECT tbl.col FROM s1.tbl, s2.tbl, s3.tbl +-- +ok +== diff --git a/parser/testdata/corpus/sql/binder/similar_to.test b/parser/testdata/corpus/sql/binder/similar_to.test new file mode 100644 index 0000000..dc7c695 --- /dev/null +++ b/parser/testdata/corpus/sql/binder/similar_to.test @@ -0,0 +1,57 @@ +# source: test/sql/binder/similar_to.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +CREATE TABLE depdelay_minutes(depdelay_minutes INTEGER); +-- +ok +== +SELECT * FROM depdelay +-- +ok +== +SELECT depdelay FROM depdelay_minutes +-- +ok +== +CREATE TABLE lineitem(i INTEGER); +-- +ok +== +SELECT * FROM li +-- +ok +== +SELECT * FROM lineitem_long +-- +ok +== +select jaro_winkler_('x', 'y'); +-- +ok +== +create schema s1; +-- +ok +== +create table s1.my_lineitem(i int); +-- +ok +== +select * from my_lineitem; +-- +ok +== +select * from m_lineitem; +-- +ok +== +create table s1.orders(i int) +-- +ok +== +select * from ord +-- +ok +== diff --git a/parser/testdata/corpus/sql/binder/string_literal_binding.test b/parser/testdata/corpus/sql/binder/string_literal_binding.test new file mode 100644 index 0000000..1ae178f --- /dev/null +++ b/parser/testdata/corpus/sql/binder/string_literal_binding.test @@ -0,0 +1,82 @@ +# source: test/sql/binder/string_literal_binding.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +select '01'=1; +-- +ok +== +SELECT cos('0') +-- +ok +== +select date '1992-01-01'>'1991-01-01'; +-- +ok +== +select date '2023-12-11' < '2023-12-11 15:54:45.119'; +-- +ok +== +CREATE TABLE test ( + "date" DATE, + value VARCHAR +); +-- +ok +== +INSERT INTO test VALUES ('2023-08-01', 1), ('2023-08-02', 2), ('2023-08-03', 3), ('2023-08-04', 4), ('2023-08-05', 5), ('2023-08-06', 6), ('2023-08-07', 7); +-- +ok +== +SELECT * FROM test WHERE date >= '2023-08-05 00:00:00' AND date < '2023-08-06 00:00:00'; +-- +ok +== +SELECT '[hello]'[1]; +-- +ok +== +SELECT list('hello world') +-- +ok +== +select 1 IN ('1', '2'); +-- +ok +== +SELECT COALESCE(1, '1'); +-- +ok +== +select i=1 from (values ('01')) t(i); +-- +ok +== +select i IN (1) from (values ('01')) t(i); +-- +ok +== +WITH cte AS (SELECT '01' AS s) +SELECT 1=s AS in_res FROM cte; +-- +ok +== +WITH cte AS (SELECT '01' AS s) +SELECT 1 IN (s) AS in_res FROM cte; +-- +ok +== +select i>1 from (values ('01')) t(i); +-- +ok +== +select date '1992-01-01'>i from (values ('1991-01-01')) t(i); +-- +ok +== +select d[1] from (values (date '1992-01-01')) t(d); +-- +ok +== diff --git a/parser/testdata/corpus/sql/binder/table_alias_single_quotes.test b/parser/testdata/corpus/sql/binder/table_alias_single_quotes.test new file mode 100644 index 0000000..89dfe86 --- /dev/null +++ b/parser/testdata/corpus/sql/binder/table_alias_single_quotes.test @@ -0,0 +1,13 @@ +# source: test/sql/binder/table_alias_single_quotes.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +SELECT t.k FROM integers AS 't'('k') ORDER BY ALL +-- +ok +== +SELECT t.k FROM integers t('k') ORDER BY ALL +-- +ok +== diff --git a/parser/testdata/corpus/sql/binder/table_view_alias.test b/parser/testdata/corpus/sql/binder/table_view_alias.test new file mode 100644 index 0000000..0bb1252 --- /dev/null +++ b/parser/testdata/corpus/sql/binder/table_view_alias.test @@ -0,0 +1,37 @@ +# source: test/sql/binder/table_view_alias.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +CREATE VIEW s1.v AS SELECT 42 c; +-- +ok +== +CREATE TABLE s1.t AS SELECT 42 c +-- +ok +== +SELECT s1.v.c, v.c, c FROM s1.v +-- +ok +== +SELECT s1.t.c, t.c, c FROM s1.t +-- +ok +== +SELECT s1.t.c, t.c, c FROM s1.t AS t +-- +ok +== +SELECT s1.x.c FROM s1.v AS x +-- +ok +== +SELECT s1.v.c FROM s1.v AS x +-- +ok +== +SELECT s1.v.c FROM s1.v AS v +-- +ok +== diff --git a/parser/testdata/corpus/sql/binder/test_alias.test b/parser/testdata/corpus/sql/binder/test_alias.test new file mode 100644 index 0000000..bd6ed53 --- /dev/null +++ b/parser/testdata/corpus/sql/binder/test_alias.test @@ -0,0 +1,49 @@ +# source: test/sql/binder/test_alias.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +SELECT i % 2 AS p, SUM(i) AS sum_i FROM integers GROUP BY p ORDER BY 1 +-- +ok +== +SELECT alias(i % 2) AS p, alias(SUM(i)) AS sum_i FROM integers GROUP BY p ORDER BY 1 +-- +ok +== +SELECT i + 1 + 1 + 1 AS k, abs(i) AS l FROM integers WHERE i=1 ORDER BY 1 +-- +ok +== +SELECT alias(i + 1 + 1 + 1) AS k, alias(abs(i)) AS l FROM integers WHERE i=1 ORDER BY 1 +-- +ok +== +SELECT alias(i) AS k, alias(i IN (1)) AS l, alias(i >= 10) AS m, alias(1=0) AS n FROM integers WHERE i=1 ORDER BY 1 +-- +ok +== +SELECT alias(CASE WHEN i=1 THEN 19 ELSE 0 END) AS k, alias(i::VARCHAR) AS l FROM integers WHERE i=1 ORDER BY 1 +-- +ok +== +CREATE TABLE test (a INTEGER, b INTEGER) +-- +ok +== +INSERT INTO test VALUES (42, 10), (43, 100); +-- +ok +== +SELECT a, b, a * 2 AS c, b * (a * 2) AS d FROM test ORDER BY a +-- +ok +== +SELECT alias(a), alias(b), alias(a * 2) AS c, alias(b * (a * 2)) AS d FROM test ORDER BY a +-- +ok +== +select i as b, b as c, c as d, d as e from integers where e = 3; +-- +ok +== diff --git a/parser/testdata/corpus/sql/binder/test_alias_map_in_subquery.test b/parser/testdata/corpus/sql/binder/test_alias_map_in_subquery.test new file mode 100644 index 0000000..2d43b3b --- /dev/null +++ b/parser/testdata/corpus/sql/binder/test_alias_map_in_subquery.test @@ -0,0 +1,80 @@ +# source: test/sql/binder/test_alias_map_in_subquery.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +CREATE OR REPLACE TABLE tbl (example VARCHAR); +-- +ok +== +INSERT INTO tbl VALUES ('hello'); +-- +ok +== +SELECT (WITH keys AS ( + SELECT example AS k + ), nonNull AS ( + SELECT keys.k, example AS v + FROM keys + WHERE v IS NOT NULL + ) + SELECT nonNull.v + FROM nonNull +) +FROM tbl; +-- +ok +== +CREATE OR REPLACE TABLE testjson (example JSON); +-- +ok +== +INSERT INTO testjson VALUES ('{ "location" : { "address" : "123 Main St" }, "sampleField" : null, "anotherField" : 123, "yetAnotherField" : "abc" }'); +-- +ok +== +SELECT (WITH keys AS (SELECT unnest(json_keys(example)) AS k), nonNull AS ( + SELECT keys.k, example->keys.k AS v + FROM keys WHERE nullif(v, 'null') IS NOT NULL + ) + SELECT json_group_object(nonNull.k, nonNull.v) + FROM nonNull +) +FROM testjson; +-- +ok +== +CREATE OR REPLACE MACRO strip_null_value(jsonValue) AS ( + WITH keys AS (SELECT UNNEST(json_keys(jsonValue)) AS k), + nonNull AS ( + SELECT keys.k, jsonValue->keys.k AS v + FROM keys WHERE nullif(v, 'null') IS NOT NULL + ) + SELECT json_group_object(nonNull.k, nonNull.v) + FROM nonNull +); +-- +ok +== +SELECT strip_null_value('{ "location" : { "address" : "123 Main St" }, "sampleField" : null, "anotherField" : 123, "yetAnotherField" : "abc" }') +AS example; +-- +ok +== +INSERT INTO testjson +VALUES ('{ "location" : { "address" : "123 Main St" }, "sampleField" : null, "anotherField" : 123, "yetAnotherField" : "abc" }'); +-- +ok +== +SELECT strip_null_value(example) FROM testjson; +-- +ok +== +WITH x AS ( + SELECT '{ "location" : { "address" : "123 Main St" }, "sampleField" : null, "anotherField" : 123, "yetAnotherField" : "abc" }' + AS example) +SELECT strip_null_value(x.example) AS test +FROM x; +-- +ok +== diff --git a/parser/testdata/corpus/sql/binder/test_case_insensitive_binding.test b/parser/testdata/corpus/sql/binder/test_case_insensitive_binding.test new file mode 100644 index 0000000..f4750d0 --- /dev/null +++ b/parser/testdata/corpus/sql/binder/test_case_insensitive_binding.test @@ -0,0 +1,177 @@ +# source: test/sql/binder/test_case_insensitive_binding.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +CREATE TABLE test ("HeLlO" INTEGER) +-- +ok +== +SELECT HeLlO FROM test +-- +ok +== +SELECT hello FROM test +-- +ok +== +SELECT "HeLlO" FROM test +-- +ok +== +SELECT "HELLO" FROM test +-- +ok +== +SELECT "HELLo" FROM test +-- +ok +== +SELECT alias(HeLlO) FROM test +-- +ok +== +SELECT alias(hello) FROM test +-- +ok +== +SELECT alias(x) FROM (SELECT HeLlO as x FROM test) tbl; +-- +ok +== +SELECT test.HeLlO FROM test +-- +ok +== +SELECT test.hello FROM test +-- +ok +== +SELECT test."HeLlO" FROM test +-- +ok +== +SELECT test."HELLO" FROM test +-- +ok +== +SELECT test."HELLo" FROM test +-- +ok +== +UPDATE test SET hello=3 +-- +ok +== +UPDATE test SET HeLlO=3 +-- +ok +== +CREATE TABLE test("HeLlO" INTEGER, "HELLO" INTEGER) +-- +ok +== +CREATE TABLE test1("HeLlO" INTEGER) +-- +ok +== +CREATE TABLE test2("HELLO" INTEGER) +-- +ok +== +SELECT HeLlO FROM test1, test2 +-- +ok +== +SELECT hello FROM test1, test2 +-- +ok +== +SELECT "HeLlO" FROM test1, test2 +-- +ok +== +SELECT "HELLO" FROM test1, test2 +-- +ok +== +SELECT "HELLo" FROM test1, test2 +-- +ok +== +SELECT test1.HeLlO FROM test1, test2 +-- +ok +== +SELECT test1.hello FROM test1, test2 +-- +ok +== +SELECT test1."HeLlO" FROM test1, test2 +-- +ok +== +SELECT test1."HELLO" FROM test1, test2 +-- +ok +== +SELECT test1."HELLo" FROM test1, test2 +-- +ok +== +SELECT test2.HeLlO FROM test1, test2 +-- +ok +== +SELECT test2.hello FROM test1, test2 +-- +ok +== +SELECT test2."HeLlO" FROM test1, test2 +-- +ok +== +SELECT test2."HELLO" FROM test1, test2 +-- +ok +== +SELECT test2."HELLo" FROM test1, test2 +-- +ok +== +SELECT * FROM test1 JOIN test2 USING (hello) +-- +ok +== +SELECT hello FROM (SELECT 42) tbl("HeLlO") +-- +ok +== +CREATE TABLE case_test(MixedCase INTEGER); +-- +ok +== +CREATE TABLE case_output AS +SELECT mixedcase +FROM case_test; +-- +ok +== +SELECT column_name +FROM duckdb_columns() +WHERE table_name = 'case_output'; +-- +ok +== +CREATE TABLE case_alias_output AS +SELECT mixedcase AS custom_name +FROM case_test; +-- +ok +== +SELECT column_name +FROM duckdb_columns() +WHERE table_name = 'case_alias_output'; +-- +ok +== diff --git a/parser/testdata/corpus/sql/binder/test_duplicate_in_set_operation.test b/parser/testdata/corpus/sql/binder/test_duplicate_in_set_operation.test new file mode 100644 index 0000000..2961a20 --- /dev/null +++ b/parser/testdata/corpus/sql/binder/test_duplicate_in_set_operation.test @@ -0,0 +1,47 @@ +# source: test/sql/binder/test_duplicate_in_set_operation.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +create table t1(col1 varchar collate nocase); +-- +ok +== +create table t2(col1 varchar collate nocase); +-- +ok +== +insert into t1 values ('a'); +-- +ok +== +insert into t2 values ('A'); +-- +ok +== +select upper(col1) +from ( + select * + from t1 + union + select * + from t2 +) d; +-- +ok +== +pragma explain_output='physical_only'; +-- +ok +== +explain select upper(col1) +from ( + select * + from t1 + union + select * + from t2 +) d; +-- +ok +== diff --git a/parser/testdata/corpus/sql/binder/test_function_chaining_alias.test b/parser/testdata/corpus/sql/binder/test_function_chaining_alias.test new file mode 100644 index 0000000..69f4e0c --- /dev/null +++ b/parser/testdata/corpus/sql/binder/test_function_chaining_alias.test @@ -0,0 +1,118 @@ +# source: test/sql/binder/test_function_chaining_alias.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +SELECT 'test' || ' more testing' AS added, added.substr(5) AS my_substr +-- +ok +== +CREATE TABLE varchars(v VARCHAR); +-- +ok +== +INSERT INTO varchars VALUES ('>>%Test<<'), ('%FUNCTION%'), ('Chaining') +-- +ok +== +SELECT v.lower() FROM varchars +-- +ok +== +SELECT + v.trim('><') AS trim_inequality, + only_alphabet.lower() AS lower, + trim_inequality.replace('%', '') AS only_alphabet, +FROM varchars +-- +ok +== +SELECT + v.trim('><') AS trim_inequality, + trim_inequality.replace('%', '') AS only_alphabet, + only_alphabet.lower() AS lower +FROM varchars +-- +ok +== +SELECT + varchars.v.trim('><') AS trim_inequality, + trim_inequality.replace('%', '') AS only_alphabet, + only_alphabet.lower() AS lower +FROM varchars +-- +ok +== +DELETE FROM varchars +-- +ok +== +INSERT INTO varchars VALUES ('Test Function Chaining Alias'); +-- +ok +== +SELECT + v.split(' ')::VARCHAR strings, + strings.lower() lower, + lower.upper() upper +FROM varchars +-- +ok +== +SELECT + v.split(' ') strings, + strings.apply(lambda x: x.lower()).filter(lambda x: x[1] == 't') lower, + strings.apply(lambda x: x.upper()).filter(lambda x: x[1] == 'T') upper, + lower + upper AS mix_case_srings +FROM varchars +-- +ok +== +PREPARE v1 AS +SELECT + (?.split(' ')::VARCHAR).lower() lstrings, + (?.split(' ')::VARCHAR).upper() ustrings, + list_concat(lstrings::VARCHAR[], ustrings::VARCHAR[]) AS mix_case_srings +-- +ok +== +EXECUTE v1('Hello World', 'test function chaining') +-- +ok +== +INSERT INTO varchars VALUES ('Another longggggg String'); +-- +ok +== +SELECT + v.split(' ') strings, + strings.apply(lambda x: x.lower()).filter(lambda x: x[1] == 't' OR x[1] == 'a') lower, + strings.apply(lambda x: x.upper()).filter(lambda x: x[1] == 'T' OR x[1] == 'A') upper, + lower + upper AS mix_case_srings +FROM varchars +WHERE mix_case_srings[1] = 'test' +-- +ok +== +SELECT + v.split(' ') strings, + strings.apply(lambda x: x.lower()).filter(lambda x: x[1] == 't' OR x[1] == 'a') lower, + strings.apply(lambda x: x.upper()).filter(lambda x: x[1] == 'T' OR x[1] == 'A') upper, + lower + upper AS mix_case_srings +FROM varchars +WHERE mix_case_srings[1] = 'another' +-- +ok +== +WITH test AS ( + SELECT 'woot' AS my_column +) +FROM test +SELECT + my_column.substr(2) AS partial_woot, + partial_woot.substr(2) AS more_partially_woot +WHERE + more_partially_woot = 'ot'; +-- +ok +== diff --git a/parser/testdata/corpus/sql/binder/test_having_alias.test b/parser/testdata/corpus/sql/binder/test_having_alias.test new file mode 100644 index 0000000..35ee99f --- /dev/null +++ b/parser/testdata/corpus/sql/binder/test_having_alias.test @@ -0,0 +1,61 @@ +# source: test/sql/binder/test_having_alias.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +CREATE TABLE integers AS SELECT * FROM range(5) tbl(i); +-- +ok +== +SELECT i, COUNT(*) AS k FROM integers GROUP BY i HAVING k=1 ORDER BY i; +-- +ok +== +SELECT i, COUNT(*) AS k FROM integers GROUP BY i HAVING integers.k=1 ORDER BY i; +-- +ok +== +SELECT 1 AS i, COUNT(*) FROM integers GROUP BY i HAVING i=2; +-- +ok +== +SELECT i AS j, COUNT(*) AS i FROM integers GROUP BY j HAVING integers.i=1 ORDER BY i; +-- +ok +== +SELECT i AS j, COUNT(*) AS i FROM integers GROUP BY j HAVING j=1 ORDER BY i; +-- +ok +== +SELECT COUNT(i) AS j FROM integers HAVING j=5; +-- +ok +== +SELECT COUNT(i) AS i FROM integers HAVING i=5; +-- +ok +== +SELECT COUNT(i) AS i FROM integers GROUP BY i HAVING i=5; +-- +ok +== +SELECT COUNT(i) AS i FROM integers HAVING i=5 ORDER BY i; +-- +ok +== +SELECT COUNT(i) AS j FROM integers HAVING j=j; +-- +ok +== +SELECT COUNT(*) FROM (SELECT i, SUM(RANDOM()) AS k FROM integers GROUP BY i HAVING k=k) tbl(i, k); +-- +ok +== +SELECT COUNT(i) AS i FROM integers HAVING integers.i=5 ORDER BY i; +-- +ok +== +SELECT i + i AS i FROM integers HAVING i=5 ORDER BY i; +-- +ok +== diff --git a/parser/testdata/corpus/sql/binder/test_implicit_struct_pack.test b/parser/testdata/corpus/sql/binder/test_implicit_struct_pack.test new file mode 100644 index 0000000..9315537 --- /dev/null +++ b/parser/testdata/corpus/sql/binder/test_implicit_struct_pack.test @@ -0,0 +1,64 @@ +# source: test/sql/binder/test_implicit_struct_pack.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +create table test as select range i from range(3) +-- +ok +== +select test from test +-- +ok +== +select test from main.test +-- +ok +== +select main.test from main.test +-- +ok +== +SELECT t FROM test AS t +-- +ok +== +select t from (SELECT * FROM test) AS t +-- +ok +== +select main.test from main.test t +-- +ok +== +select main.t from main.test t +-- +ok +== +WITH data AS ( + SELECT 1 as a, 2 as b, 3 as c +) +SELECT d FROM data d +-- +ok +== +create table main as select 3 test +-- +ok +== +select main.test from main, test +-- +ok +== +select test from main, test +-- +ok +== +create table structs as select {test: 4} main +-- +ok +== +select main.test from structs, test +-- +ok +== diff --git a/parser/testdata/corpus/sql/binder/test_in_with_collate.test b/parser/testdata/corpus/sql/binder/test_in_with_collate.test new file mode 100644 index 0000000..0fb54a7 --- /dev/null +++ b/parser/testdata/corpus/sql/binder/test_in_with_collate.test @@ -0,0 +1,53 @@ +# source: test/sql/binder/test_in_with_collate.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +create table tbl (str varchar); +-- +ok +== +insert into tbl values ('ABCDE'), ('aBcDe'); +-- +ok +== +insert into tbl values ('àbcdë'); +-- +ok +== +insert into tbl values ('ÀbCdÈ'); +-- +ok +== +select * from tbl where str in ('AbCdE'); +-- +ok +== +select * from tbl where str collate nocase in ('abcde'); +-- +ok +== +select * from tbl where str collate noaccent in ('abcde'); +-- +ok +== +select * from tbl where str collate nocase.noaccent in ('abcde'); +-- +ok +== +select * from tbl where str not in ('abcde'); +-- +ok +== +select * from tbl where str collate nocase not in ('abcde'); +-- +ok +== +select * from tbl where str collate noaccent not in ('abcde'); +-- +ok +== +select * from tbl where str collate nocase.noaccent not in ('abcde'); +-- +ok +== diff --git a/parser/testdata/corpus/sql/binder/test_null_type_propagation.test b/parser/testdata/corpus/sql/binder/test_null_type_propagation.test new file mode 100644 index 0000000..8e7c532 --- /dev/null +++ b/parser/testdata/corpus/sql/binder/test_null_type_propagation.test @@ -0,0 +1,126 @@ +# source: test/sql/binder/test_null_type_propagation.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +SELECT NULL +-- +ok +== +SELECT NULL UNION ALL SELECT CAST(1 AS BOOLEAN) +-- +ok +== +SELECT NULL UNION ALL SELECT NULL +-- +ok +== +SELECT NULL UNION ALL SELECT NULL UNION ALL SELECT NULL UNION ALL SELECT NULL UNION ALL SELECT CAST(1 AS BOOLEAN) +-- +ok +== +SELECT (SELECT NULL) UNION ALL SELECT CAST(1 AS BOOLEAN) +-- +ok +== +SELECT * FROM (SELECT NULL) tbl(i) UNION ALL SELECT CAST(1 AS BOOLEAN) +-- +ok +== +SELECT * FROM (SELECT (SELECT NULL) UNION ALL SELECT CAST(1 AS BOOLEAN)) tbl(i) +-- +ok +== +SELECT * FROM (SELECT NULL) tbl(i) UNION ALL SELECT NULL +-- +ok +== +SELECT bool_and(i) FROM (SELECT * FROM (SELECT NULL) tbl(i) UNION ALL SELECT CAST(1 as BOOLEAN)) tbl(i) +-- +ok +== +SELECT bool_and(i) FROM (SELECT * FROM (SELECT NULL::INTEGER) tbl(i) UNION ALL SELECT CAST(1 as BOOLEAN)) tbl(i) +-- +ok +== +SELECT * FROM (SELECT NULL) tbl(i), (SELECT NULL) tbl2(j) +-- +ok +== +SELECT bool_and(i), bool_and(j) FROM (SELECT NULL) tbl(i), (SELECT NULL) tbl2(j) +-- +ok +== +SELECT NULL as a, NULL as b, 1 as id UNION SELECT CAST(1 AS BOOLEAN) as a, CAST(0 AS BOOLEAN) as b, 2 as id +-- +ok +== +SELECT CAST(1 AS BOOLEAN) as a, CAST(0 AS BOOLEAN) as b, 1 as id UNION SELECT NULL as a, NULL as b, 2 as id +-- +ok +== +SELECT NULL::INTEGER as a, NULL::INTEGER as b, 1 as id UNION SELECT CAST(1 AS BOOLEAN) as a, CAST(0 AS BOOLEAN) as b, 2 as id +-- +ok +== +SELECT CAST(1 AS BOOLEAN) as a, CAST(0 AS BOOLEAN) as b, 1 as id UNION SELECT NULL::INTEGER as a, NULL::INTEGER as b, 2 as id +-- +ok +== +CREATE TABLE tbl AS SELECT NULL UNION ALL SELECT NULL +-- +ok +== +SELECT typeof(#1) FROM tbl LIMIT 1 +-- +ok +== +INSERT INTO tbl VALUES (NULL); +-- +ok +== +CREATE VIEW v1 AS SELECT NULL +-- +ok +== +SELECT * FROM v1 UNION ALL SELECT CAST(1 AS BOOLEAN) +-- +ok +== +SELECT typeof(#1) FROM v1 +-- +ok +== +CREATE VIEW v2 AS SELECT NULL UNION ALL SELECT NULL +-- +ok +== +SELECT * FROM v2 UNION ALL SELECT CAST(1 AS BOOLEAN) +-- +ok +== +SELECT typeof(#1) FROM v2 LIMIT 1 +-- +ok +== +SELECT [NULL] +-- +ok +== +SELECT [NULL] UNION ALL SELECT [True] +-- +ok +== +SELECT {'x': NULL} +-- +ok +== +SELECT {'x': NULL} UNION ALL SELECT {'x': True} +-- +ok +== +WITH cte AS (SELECT NULL) +SELECT * FROM cte +-- +ok +== diff --git a/parser/testdata/corpus/sql/binder/test_postitional_ref_order_binding.test b/parser/testdata/corpus/sql/binder/test_postitional_ref_order_binding.test new file mode 100644 index 0000000..c648f5f --- /dev/null +++ b/parser/testdata/corpus/sql/binder/test_postitional_ref_order_binding.test @@ -0,0 +1,13 @@ +# source: test/sql/binder/test_postitional_ref_order_binding.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +create table test as select * from (values (42, 43), (44, 45)) v(i, j); +-- +ok +== +select i, sum(j) as s from test group by i order by #1; +-- +ok +== diff --git a/parser/testdata/corpus/sql/binder/test_select_clause_alias.test b/parser/testdata/corpus/sql/binder/test_select_clause_alias.test new file mode 100644 index 0000000..1e43d5e --- /dev/null +++ b/parser/testdata/corpus/sql/binder/test_select_clause_alias.test @@ -0,0 +1,72 @@ +# source: test/sql/binder/test_select_clause_alias.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +INSERT INTO integers VALUES (1), (2), (3); +-- +ok +== +SELECT i + 1 AS a, a + 1 AS b FROM integers ORDER BY b +-- +ok +== +SELECT i + 1 AS a, a + a AS b, b + b AS c, c + c AS d FROM integers ORDER BY b +-- +ok +== +SELECT i + 1 AS i, i + 1 AS b FROM integers ORDER BY b +-- +ok +== +SELECT a + 1 AS b, i + 1 AS a FROM integers +-- +ok +== +SELECT RANDOM() AS a, a + 1 AS b FROM integers +-- +ok +== +create table orders as +select + cast(random()*100 as integer) + 1 as customer_id, + date '2020-01-01' + interval (cast(random()*365*10 as integer)) days as order_date, + cast(random()*1000 as integer) as order_amount, +from range(0, 1000) +order by order_date; +-- +ok +== +select + (select distinct date_trunc('month', order_date) from orders) as month, + (select sum(order_amount) from orders where date_trunc('month', order_date) = month) as revenue; +-- +ok +== +select + split(from0, ' ') as expr_parts, + case + try(expr_parts[6][1]::int) + when 1 + then 'NOT' + end as dayname, +from (select '1 2 3 1 2 3 4 5 6' as from0); +-- +ok +== +select + split('1 2 3', ' ') as expr_parts, + try(expr_parts[1]::int) as try_val; +-- +ok +== +select + split('1 2 x', ' ') as expr_parts, + case + when try(expr_parts[3]::int) is null + then 'invalid' + else 'valid' + end as check_val; +-- +ok +== diff --git a/parser/testdata/corpus/sql/binder/test_string_alias.test b/parser/testdata/corpus/sql/binder/test_string_alias.test new file mode 100644 index 0000000..ac73ba3 --- /dev/null +++ b/parser/testdata/corpus/sql/binder/test_string_alias.test @@ -0,0 +1,29 @@ +# source: test/sql/binder/test_string_alias.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +SELECT i AS 'hello world' FROM integers +-- +ok +== +SELECT i 'hello world' FROM integers +-- +ok +== +SELECT i "hello world" FROM integers +-- +ok +== +SELECT i AS "hello world" FROM integers +-- +ok +== +SELECT "hello world".i FROM integers AS 'hello world' +-- +ok +== +SELECT "hello world".i FROM integers 'hello world' +-- +error: Parser Error: syntax error at or near "'hello world'" +== diff --git a/parser/testdata/corpus/sql/cast/boolean_autocast.test b/parser/testdata/corpus/sql/cast/boolean_autocast.test new file mode 100644 index 0000000..c23bfc2 --- /dev/null +++ b/parser/testdata/corpus/sql/cast/boolean_autocast.test @@ -0,0 +1,97 @@ +# source: test/sql/cast/boolean_autocast.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +SELECT true=1; +-- +ok +== +SELECT true=0; +-- +ok +== +SELECT false=0; +-- +ok +== +SELECT false=1; +-- +ok +== +SELECT 1=true; +-- +ok +== +SELECT 0=true; +-- +ok +== +SELECT 0=false; +-- +ok +== +SELECT 1=false; +-- +ok +== +SELECT true='1'; +-- +ok +== +SELECT true='1'::VARCHAR; +-- +ok +== +SELECT true='0'; +-- +ok +== +SELECT false='0'; +-- +ok +== +SELECT false='1'; +-- +ok +== +SELECT true='true'; +-- +ok +== +SELECT true='false'; +-- +ok +== +SELECT false='false'; +-- +ok +== +SELECT false='true'; +-- +ok +== +SELECT '1'=true; +-- +ok +== +SELECT '0'=true; +-- +ok +== +SELECT '0'=false; +-- +ok +== +SELECT '1'=false; +-- +ok +== +SELECT false='unknownbool'; +-- +ok +== +SELECT 'unknownbool'=false; +-- +ok +== diff --git a/parser/testdata/corpus/sql/cast/cast_error_location.test b/parser/testdata/corpus/sql/cast/cast_error_location.test new file mode 100644 index 0000000..da57acb --- /dev/null +++ b/parser/testdata/corpus/sql/cast/cast_error_location.test @@ -0,0 +1,149 @@ +# source: test/sql/cast/cast_error_location.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +SELECT 1::STRUCT(i INTEGER) +-- +ok +== +SELECT 1000::utinyint +-- +ok +== +SELECT 'hello'::int +-- +ok +== +SELECT 1000::decimal(2,1) +-- +ok +== +SELECT 1000.0::decimal(5,1)::decimal(2,1) +-- +ok +== +SELECT [1000]::utinyint[] +-- +ok +== +SELECT {'x': 1000}::row(x tinyint) +-- +ok +== +select 1e308::float +-- +ok +== +select 1e308::hugeint +-- +ok +== +select 1000000000000000000000000000000::hugeint::int +-- +ok +== +select nth_value(42, 'hello') over () +-- +ok +== +select '1900'::date +-- +ok +== +select 42::utinyint + 'hello' +-- +ok +== +SELECT bitstring('1', 9)::BOOL; +-- +ok +== +SELECT [1,2,3]::INT[2] +-- +ok +== +SELECT '\x'::BYTEA +-- +ok +== +CREATE TABLE cast_table(i INTEGER, s VARCHAR, d DECIMAL(5,1), l INT[], int_struct ROW(i INTEGER), dbl DOUBLE, hge HUGEINT, invalid_blob_str VARCHAR); +-- +ok +== +INSERT INTO cast_table VALUES (1000, 'hello', 1000.0, [1000], {'i': 1000}, 1e308, 1000000000000000000000000000000, '\x') +-- +ok +== +SELECT i::utinyint from cast_table +-- +ok +== +SELECT s::int FROM cast_table +-- +ok +== +SELECT i::decimal(2,1) FROM cast_table +-- +ok +== +SELECT d::decimal(2,1) FROM cast_table +-- +ok +== +SELECT l::utinyint[] FROM cast_table +-- +ok +== +SELECT int_struct::ROW(x TINYINT) FROM cast_table +-- +ok +== +select dbl::float FROM cast_table +-- +ok +== +select dbl::hugeint FROM cast_table +-- +ok +== +select hge::hugeint::int FROM cast_table +-- +ok +== +SELECT l::INT[3] FROM cast_table +-- +ok +== +SELECT invalid_blob_str::BYTEA FROM cast_table +-- +ok +== +CREATE TABLE int_tbl AS SELECT 42 my_integer +-- +ok +== +CREATE TABLE str_tbl AS SELECT 'hello' my_str +-- +ok +== +CREATE TABLE ts_tbl(ts TIMESTAMP) +-- +ok +== +INSERT INTO ts_tbl SELECT my_integer FROM int_tbl +-- +ok +== +INSERT INTO ts_tbl SELECT my_integer * 2 FROM int_tbl +-- +ok +== +INSERT INTO ts_tbl FROM int_tbl +-- +ok +== +INSERT INTO ts_tbl FROM str_tbl +-- +ok +== diff --git a/parser/testdata/corpus/sql/cast/decimal_cast.test b/parser/testdata/corpus/sql/cast/decimal_cast.test new file mode 100644 index 0000000..4019b37 --- /dev/null +++ b/parser/testdata/corpus/sql/cast/decimal_cast.test @@ -0,0 +1,33 @@ +# source: test/sql/cast/decimal_cast.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +SELECT '9.90'::DECIMAL(4,3)::DECIMAL(3,2); +-- +ok +== +SELECT '1.10'::DECIMAL(4,3)::DECIMAL(3,2); +-- +ok +== +SELECT '9.90000000'::DECIMAL(9,8)::DECIMAL(8,7); +-- +ok +== +SELECT '9.90000000000000000'::DECIMAL(18,17)::DECIMAL(17,16); +-- +ok +== +SELECT '9.9000000000000000000000000000000000000'::DECIMAL(38,37)::DECIMAL(37,36); +-- +ok +== +SELECT '9.995'::DECIMAL(4,3)::DECIMAL(3,2); +-- +ok +== +SELECT '9.99999995'::DECIMAL(9,8)::DECIMAL(8,7); +-- +ok +== diff --git a/parser/testdata/corpus/sql/cast/decimal_float_cast.test b/parser/testdata/corpus/sql/cast/decimal_float_cast.test new file mode 100644 index 0000000..7834605 --- /dev/null +++ b/parser/testdata/corpus/sql/cast/decimal_float_cast.test @@ -0,0 +1,49 @@ +# source: test/sql/cast/decimal_float_cast.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +select cast(100000000000000000000 as double) < cast(99999999999999999999.99999 as double); +-- +ok +== +select 100000000000000000000 > 99999999999999999999.99999; +-- +ok +== +select cast(999999999999999.9999 as double) <= cast(999999999999999.99999999 as double); +-- +ok +== +SELECT printf('%.17g', 0.41000000000000003), printf('%.17g', CAST('0.41000000000000003' AS DOUBLE)) +-- +ok +== +SELECT printf('%.17g', 0.9999999999999999), printf('%.17g', CAST('0.9999999999999999' AS DOUBLE)) +-- +ok +== +WITH p(v) AS (VALUES (CAST('0.41000000000000003' AS DECIMAL(18,17)))) +SELECT printf('%.17g', v::DOUBLE), printf('%.17g', CAST(v::VARCHAR AS DOUBLE)) FROM p +-- +ok +== +SELECT printf('%.9g', CAST(0.99999997 AS FLOAT)), printf('%.9g', CAST('0.99999997' AS FLOAT)) +-- +ok +== +SELECT printf('%.17g', CAST(CAST('0.000000000000000000000001' AS DECIMAL(38,38)) AS DOUBLE)), + printf('%.17g', CAST('0.000000000000000000000001' AS DOUBLE)) +-- +ok +== +SELECT printf('%.17g', CAST(CAST('0.00000000000000000000000000001' AS DECIMAL(38,38)) AS DOUBLE)), + printf('%.17g', CAST('0.00000000000000000000000000001' AS DOUBLE)) +-- +ok +== +SELECT printf('%.9g', CAST(CAST('0.0000000000000001' AS DECIMAL(20,20)) AS FLOAT)), + printf('%.9g', CAST('0.0000000000000001' AS FLOAT)) +-- +ok +== diff --git a/parser/testdata/corpus/sql/cast/decimal_integer_cast.test b/parser/testdata/corpus/sql/cast/decimal_integer_cast.test new file mode 100644 index 0000000..1c0ac49 --- /dev/null +++ b/parser/testdata/corpus/sql/cast/decimal_integer_cast.test @@ -0,0 +1,13 @@ +# source: test/sql/cast/decimal_integer_cast.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +SELECT CAST(0.55 AS {datatype}) as x; +-- +error: Parser Error: syntax error at or near "{" +== +SELECT CAST(-0.55 AS {datatype}) as x; +-- +error: Parser Error: syntax error at or near "{" +== diff --git a/parser/testdata/corpus/sql/cast/dot_function_missing_error.test b/parser/testdata/corpus/sql/cast/dot_function_missing_error.test new file mode 100644 index 0000000..a5d44c3 --- /dev/null +++ b/parser/testdata/corpus/sql/cast/dot_function_missing_error.test @@ -0,0 +1,17 @@ +# source: test/sql/cast/dot_function_missing_error.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +select file.replace('a', 'b') from (values ('xxxx')) t("filename"); +-- +ok +== +select filename.replacezxcv('a', 'b') from (values ('xxxx')) t("filename"); +-- +ok +== +select replacezxcv('a', 'b') from (values ('xxxx')) t("filename"); +-- +ok +== diff --git a/parser/testdata/corpus/sql/cast/double_float_cast.test b/parser/testdata/corpus/sql/cast/double_float_cast.test new file mode 100644 index 0000000..0b0811c --- /dev/null +++ b/parser/testdata/corpus/sql/cast/double_float_cast.test @@ -0,0 +1,25 @@ +# source: test/sql/cast/double_float_cast.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +select 1e308::float; +-- +ok +== +select '1e308'::float; +-- +ok +== +select '1e310'::double; +-- +ok +== +select '-1e308'::float; +-- +ok +== +select '-1e310'::double; +-- +ok +== diff --git a/parser/testdata/corpus/sql/cast/float_decimal_cast.test b/parser/testdata/corpus/sql/cast/float_decimal_cast.test new file mode 100644 index 0000000..55a9213 --- /dev/null +++ b/parser/testdata/corpus/sql/cast/float_decimal_cast.test @@ -0,0 +1,9 @@ +# source: test/sql/cast/float_decimal_cast.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +select 1.35::{src}::decimal(3, 1), 1.45::{src}::decimal(3, 1) +-- +error: Parser Error: syntax error at or near "{" +== diff --git a/parser/testdata/corpus/sql/cast/float_integer_cast.test b/parser/testdata/corpus/sql/cast/float_integer_cast.test new file mode 100644 index 0000000..2156717 --- /dev/null +++ b/parser/testdata/corpus/sql/cast/float_integer_cast.test @@ -0,0 +1,89 @@ +# source: test/sql/cast/float_integer_cast.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +select cast(0.5::{src} as {dst}) as x; +-- +error: Parser Error: syntax error at or near "{" +== +select cast(0.55::{src} as {dst}) as x; +-- +error: Parser Error: syntax error at or near "{" +== +select cast(1.5::{src} as {dst}) as x; +-- +error: Parser Error: syntax error at or near "{" +== +select cast(-0.5::{src} as {dst}) as x; +-- +error: Parser Error: syntax error at or near "{" +== +select cast(-0.55::{src} as {dst}) as x; +-- +error: Parser Error: syntax error at or near "{" +== +select cast(-1.5::{src} as {dst}) as x; +-- +error: Parser Error: syntax error at or near "{" +== +select cast(127.5::{src} as TINYINT) +-- +error: Parser Error: syntax error at or near "{" +== +select cast(127.6::{src} as TINYINT) +-- +error: Parser Error: syntax error at or near "{" +== +select cast(255.5::{src} as UTINYINT) +-- +error: Parser Error: syntax error at or near "{" +== +select cast(32767.5::{src} as SMALLINT) +-- +error: Parser Error: syntax error at or near "{" +== +select cast(65535.5::{src} as USMALLINT) +-- +error: Parser Error: syntax error at or near "{" +== +select cast(127.4::{src} as TINYINT), cast(126.5::{src} as TINYINT), + cast(255.4::{src} as UTINYINT), cast(32766.5::{src} as SMALLINT) +-- +error: Parser Error: syntax error at or near "{" +== +select cast(-128.4::{src} as TINYINT), cast(-128.5::{src} as TINYINT), + cast(-0.4::{src} as UTINYINT), cast(-0.5::{src} as UTINYINT) +-- +error: Parser Error: syntax error at or near "{" +== +select cast(-128.6::{src} as TINYINT) +-- +error: Parser Error: syntax error at or near "{" +== +select cast(-0.6::{src} as UTINYINT) +-- +error: Parser Error: syntax error at or near "{" +== +select try_cast(127.6::{src} as TINYINT), try_cast(-128.6::{src} as TINYINT), + try_cast(-128.5::{src} as TINYINT), try_cast(-0.6::{src} as UTINYINT) +-- +error: Parser Error: syntax error at or near "{" +== +select cast(2147483647.5::DOUBLE as INTEGER) +-- +ok +== +select cast(-2147483648.6::DOUBLE as INTEGER) +-- +ok +== +select cast(2147483647.4::DOUBLE as INTEGER), cast(-2147483648.4::DOUBLE as INTEGER), + cast(4294967295.4::DOUBLE as UINTEGER) +-- +ok +== +select cast(4294967295.5::DOUBLE as UINTEGER) +-- +ok +== diff --git a/parser/testdata/corpus/sql/cast/signed_cast_repro.test b/parser/testdata/corpus/sql/cast/signed_cast_repro.test new file mode 100644 index 0000000..178889c --- /dev/null +++ b/parser/testdata/corpus/sql/cast/signed_cast_repro.test @@ -0,0 +1,25 @@ +# source: test/sql/cast/signed_cast_repro.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +CREATE TABLE tab2(col0 INTEGER, col1 INTEGER, col2 INTEGER) +-- +ok +== +INSERT INTO tab2 VALUES(64,77,40) +-- +ok +== +INSERT INTO tab2 VALUES(75,67,58) +-- +ok +== +INSERT INTO tab2 VALUES(46,51,23) +-- +ok +== +SELECT 43 - MAX( ALL - 87 + col1 ) FROM tab2 WHERE col1 * col1 * - CAST( - col2 AS SIGNED ) * + - col0 * + - 77 * - col0 IS NOT NULL AND NOT + col0 BETWEEN 35 * - col2 AND NULL +-- +ok +== diff --git a/parser/testdata/corpus/sql/cast/string_to_integer_decimal_cast.test b/parser/testdata/corpus/sql/cast/string_to_integer_decimal_cast.test new file mode 100644 index 0000000..0ef29f4 --- /dev/null +++ b/parser/testdata/corpus/sql/cast/string_to_integer_decimal_cast.test @@ -0,0 +1,133 @@ +# source: test/sql/cast/string_to_integer_decimal_cast.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +select '0.000005'::{type}; +-- +error: Parser Error: syntax error at or near "{" +== +select '1.100004'::{type}; +-- +error: Parser Error: syntax error at or near "{" +== +select '0.5'::{type}; +-- +error: Parser Error: syntax error at or near "{" +== +select '1.50004'::{type}; +-- +error: Parser Error: syntax error at or near "{" +== +select '-0.000005'::{type}; +-- +error: Parser Error: syntax error at or near "{" +== +select '-1.100004'::{type}; +-- +error: Parser Error: syntax error at or near "{" +== +select '-0.5'::{type}; +-- +error: Parser Error: syntax error at or near "{" +== +select '-1.50004'::{type}; +-- +error: Parser Error: syntax error at or near "{" +== +select '127.1'::TINYINT, '-128.1'::TINYINT; +-- +ok +== +select '32767.1'::SMALLINT, '-32768.1'::SMALLINT; +-- +ok +== +select '2147483647.1'::INTEGER, '-2147483648.1'::INTEGER; +-- +ok +== +select '9223372036854775807.1'::BIGINT, '-9223372036854775808.1'::BIGINT; +-- +ok +== +select '170141183460469231731687303715884105727.1'::HUGEINT, '-170141183460469231731687303715884105728.1'::HUGEINT; +-- +ok +== +select '255.1'::UTINYINT; +-- +ok +== +select '65535.1'::USMALLINT; +-- +ok +== +select '4294967295.1'::UINTEGER; +-- +ok +== +select '18446744073709551615.1'::UBIGINT; +-- +ok +== +select '340282366920938463463374607431768211455.1'::UHUGEINT; +-- +ok +== +select '127.5'::TINYINT; +-- +ok +== +select '32767.5'::SMALLINT; +-- +ok +== +select '2147483647.5'::INTEGER; +-- +ok +== +select '9223372036854775807.5'::BIGINT; +-- +ok +== +select '170141183460469231731687303715884105727.5'::HUGEINT; +-- +ok +== +select '-128.5'::TINYINT; +-- +ok +== +select '-32768.5'::SMALLINT; +-- +ok +== +select '-2147483648.5'::INTEGER; +-- +ok +== +select '-9223372036854775808.5'::BIGINT; +-- +ok +== +select '-170141183460469231731687303715884105728.5'::HUGEINT; +-- +ok +== +select '255.5'::UTINYINT; +-- +ok +== +select '65535.5'::USMALLINT; +-- +ok +== +select '4294967295.5'::UINTEGER; +-- +ok +== +select '18446744073709551615.5'::UBIGINT; +-- +ok +== diff --git a/parser/testdata/corpus/sql/cast/string_to_integer_exponent_cast.test b/parser/testdata/corpus/sql/cast/string_to_integer_exponent_cast.test new file mode 100644 index 0000000..9fe62a3 --- /dev/null +++ b/parser/testdata/corpus/sql/cast/string_to_integer_exponent_cast.test @@ -0,0 +1,213 @@ +# source: test/sql/cast/string_to_integer_exponent_cast.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +select '1e2'::{type}; +-- +error: Parser Error: syntax error at or near "{" +== +select '1.23e2'::{type}; +-- +error: Parser Error: syntax error at or near "{" +== +select '1.234e2'::{type}; +-- +error: Parser Error: syntax error at or near "{" +== +select '1.235e2'::{type}; +-- +error: Parser Error: syntax error at or near "{" +== +select '1e-2'::{type}; +-- +error: Parser Error: syntax error at or near "{" +== +select '123.456e-2'::{type}; +-- +error: Parser Error: syntax error at or near "{" +== +select '1584.92e-2'::{type}; +-- +error: Parser Error: syntax error at or near "{" +== +select '1214.235e-2'::{type}; +-- +error: Parser Error: syntax error at or near "{" +== +select '10e40'::{type}; +-- +error: Parser Error: syntax error at or near "{" +== +select '-1e2'::{type}; +-- +error: Parser Error: syntax error at or near "{" +== +select '-1.23456e2'::{type}; +-- +error: Parser Error: syntax error at or near "{" +== +select '-0.158492e2'::{type}; +-- +error: Parser Error: syntax error at or near "{" +== +select '-1.235e2'::{type}; +-- +error: Parser Error: syntax error at or near "{" +== +select '-100e-2'::{type}; +-- +error: Parser Error: syntax error at or near "{" +== +select '-50.23456e-2'::{type}; +-- +error: Parser Error: syntax error at or near "{" +== +select '-1584.92e-2'::{type}; +-- +error: Parser Error: syntax error at or near "{" +== +select '-1.235e-2'::{type}; +-- +error: Parser Error: syntax error at or near "{" +== +select '5.5e-1'::bigint; +-- +ok +== +select '9.5e-5'::{type}; +-- +error: Parser Error: syntax error at or near "{" +== +select '-10e40'::{type}; +-- +error: Parser Error: syntax error at or near "{" +== +select '12.7e1'::TINYINT, '-12.8e1'::TINYINT; +-- +ok +== +select '3276.7e1'::SMALLINT, '-3276.8e1'::SMALLINT; +-- +ok +== +select '214748364.7e1'::INTEGER, '-214748364.8e1'::INTEGER; +-- +ok +== +select '922337203685477580.7e1'::BIGINT, '-922337203685477580.8e1'::BIGINT; +-- +ok +== +select '17014118346046923173168730371588410572.7e1'::HUGEINT, '-17014118346046923173168730371588410572.8e1'::HUGEINT; +-- +ok +== +select '25.5e1'::UTINYINT; +-- +ok +== +select '6553.5e1'::USMALLINT; +-- +ok +== +select '429496729.5e1'::UINTEGER; +-- +ok +== +select '1844674407370955161.5e1'::UBIGINT; +-- +ok +== +select '34028236692093846346337460743176821145.5e1'::UHUGEINT; +-- +ok +== +select '12.8e1'::TINYINT; +-- +ok +== +select '3276.8e1'::SMALLINT; +-- +ok +== +select '214748364.8e1'::INTEGER; +-- +ok +== +select '922337203685477580.8e1'::BIGINT; +-- +ok +== +select '17014118346046923173168730371588410572.8e1'::HUGEINT; +-- +ok +== +select '-12.9e1'::TINYINT; +-- +ok +== +select '-3276.9e1'::SMALLINT; +-- +ok +== +select '-214748364.9e1'::INTEGER; +-- +ok +== +select '-922337203685477580.9e1'::BIGINT; +-- +ok +== +select '-17014118346046923173168730371588410572.9e1'::HUGEINT; +-- +ok +== +select '25.6e1'::UTINYINT; +-- +ok +== +select '6553.6e1'::USMALLINT; +-- +ok +== +select '429496729.6e1'::UINTEGER; +-- +ok +== +select '1844674407370955161.6e1'::UBIGINT; +-- +ok +== +select '1e100000'::int; +-- +ok +== +select '1e-100000'::int; +-- +ok +== +select '0.00000000000000000000000000000009223372036854775807e50'::BIGINT; +-- +ok +== +select '-0.00000000000000000000000000000009223372036854775807e50'::BIGINT; +-- +ok +== +select '0.00000000000170141183460469231731687303715884105727e50'::HUGEINT; +-- +ok +== +select '-0.00000000000170141183460469231731687303715884105727e50'::HUGEINT; +-- +ok +== +select '15123456789e-32768'::int; +-- +ok +== +select '0e32767'::int; +-- +ok +== diff --git a/parser/testdata/corpus/sql/cast/string_to_list_cast.test b/parser/testdata/corpus/sql/cast/string_to_list_cast.test new file mode 100644 index 0000000..ec1df87 --- /dev/null +++ b/parser/testdata/corpus/sql/cast/string_to_list_cast.test @@ -0,0 +1,427 @@ +# source: test/sql/cast/string_to_list_cast.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +SELECT '[12,13,14]'::INT[]; +-- +ok +== +SELECT '["hello", "world", "!"]'::VARCHAR[]; +-- +ok +== +SELECT CAST('[Hello World!]' AS VARCHAR[]); +-- +ok +== +SELECT CAST('[[Hello World!], hello, universe]' AS VARCHAR[]); +-- +ok +== +SELECT '[Cast like this]':: VARCHAR[]; +-- +ok +== +select UNNEST('[NULL, , NULL]'::varchar[]); +-- +ok +== +select UNNEST('[NULL,, NULL]'::varchar[]); +-- +ok +== +select UNNEST('[NULL, , NULL]'::varchar[]); +-- +ok +== +SELECT UNNEST('[NULL, NULL , ]'::varchar[]); +-- +ok +== +SELECT UNNEST('[NULL, NULL ,]'::varchar[]); +-- +ok +== +SELECT UNNEST('[NULL, NULL,]'::varchar[]); +-- +ok +== +SELECT CAST('[ [12,13,14], [8, 9], [4], [2, 1, 0] ]' AS INT[][]) a, a::VARCHAR::INT[][] b, a == b; +-- +ok +== +SELECT CAST('[ [[12,13,14], [8, 9]], [[4]], [[2, 1, 0], [99]] ]' AS INT[][][]); +-- +ok +== +SELECT CAST('[ [12,13,14], [8, 9], [4], [2, 1, 0] ]' AS VARCHAR[]); +-- +ok +== +SELECT CAST('[[ [🦆, 🦆, 🦆]], [[duck, db, 🦆], [🦆]], [[🦆, duck, db]]]' AS VARCHAR[][][]); +-- +ok +== +CREATE TABLE stringList (col1 VARCHAR) +-- +ok +== +INSERT INTO stringList VALUES ('["hello","world","!"]'), ('["Amazing","text"]'), ('[Hello World!]'); +-- +ok +== +SELECT col1::VARCHAR[] FROM stringList; +-- +ok +== +CREATE TABLE nestedStrings (col1 VARCHAR) +-- +ok +== +INSERT INTO nestedStrings VALUES ('[["hello"], ["world"],["!"]]'), ('[["Amazing"],["text"]]'), ('[[Hello World!]]'); +-- +ok +== +SELECT col1::VARCHAR[][] FROM nestedStrings; +-- +ok +== +CREATE TABLE superNestedStrings (col1 VARCHAR) +-- +ok +== +INSERT INTO superNestedStrings VALUES ('[[[[["hello"]]], [[["world"],["!"]]]]]'), ('[[[[["Amazing"]],[["text"]]]]]'), ('[[[[[Hello World!]]]]]'); +-- +ok +== +SELECT col1::VARCHAR[][][][][] FROM superNestedStrings; +-- +ok +== +CREATE TABLE tbl (col1 VARCHAR); +-- +ok +== +INSERT INTO tbl VALUES ('[1,2,2]'), ('[345,67865,44,4]'), ('[5,6,7]'); +-- +ok +== +SELECT col1::INT[] FROM tbl; +-- +ok +== +CREATE TABLE doubleNested (col1 VARCHAR); +-- +ok +== +INSERT INTO doubleNested VALUES ('[[1,2],[2]]'), ('[[345],[67865,44,4]]'), ('[[5],[6,7]]'); +-- +ok +== +SELECT col1::INT[][] FROM doubleNested; +-- +ok +== +CREATE TABLE tripleNested (col1 VARCHAR) +-- +ok +== +INSERT INTO tripleNested VALUES ('[[[1,2],[3]]]'), ('[[[4]]]'); +-- +ok +== +SELECT col1::INT[][][] FROM tripleNested; +-- +ok +== +CREATE TABLE crazyNested (col1 VARCHAR) +-- +ok +== +INSERT INTO crazyNested VALUES ('[[[[[[1]],[[3,4,9]]],[[[0,1]]]]]]'), ('[[[[[[4]]]]]]'); +-- +ok +== +SELECT col1::INT[][][][][][] FROM crazyNested; +-- +ok +== +SELECT CAST($$['hello','world', '!']$$ AS VARCHAR[]); +-- +ok +== +SELECT CAST($$[\'hello\',\'world\', \'!\']$$ AS VARCHAR[]); +-- +ok +== +SELECT CAST($$[[ ['🦆, 🦆, 🦆']], [[duck, db, '🦆'] ]]$$ AS VARCHAR[][][]); +-- +ok +== +SELECT CAST($$[can\'t, you\'re, i\'m]$$ AS VARCHAR[]); +-- +ok +== +SELECT CAST($$["]", "hello", "world"]$$ AS VARCHAR[]); +-- +ok +== +SELECT CAST($$[']', "hello", "world"]$$ AS VARCHAR[]); +-- +ok +== +SELECT CAST('[ [12, 13,14], [8, 9 ], [ 4 ], [ 2, 1, 0] ] ' AS INT[][]); +-- +ok +== +SELECT CAST('[ [ [12, 13,14], [8, 9 ] ],[[ 4 ] ], [[ 2, 1, 0 ] ] ] ' AS INT[][][]); +-- +ok +== +SELECT CAST($$[" hello"," \"' world", "! "]$$ AS VARCHAR[]); +-- +ok +== +SELECT CAST('[ hello , world , ! ]' AS VARCHAR[]); +-- +ok +== +SELECT CAST($$[ [ " hello"] ,[" world" ],[ "! " ] ]$$ AS VARCHAR[][]); +-- +ok +== +SELECT '[]'::VARCHAR[]; +-- +ok +== +SELECT '[]'::INT[]; +-- +ok +== +SELECT '[]'::INT[][][][]; +-- +ok +== +SELECT '[[1, 2, 3], [], [ ], [ ]]'::INT[][]; +-- +ok +== +SELECT '[[1, 2, 3], [], NULL, [NULL], [4, NULL]]'::INT[][]; +-- +ok +== +CREATE TABLE null_tbl(col1 VARCHAR); +-- +ok +== +INSERT INTO null_tbl VALUES(NULL), (NULL), ('[NULL]'); +-- +ok +== +SELECT col1::INT[] FROM null_tbl; +-- +ok +== +SELECT CAST(NULL AS INT[]); +-- +ok +== +SELECT CAST('[NULL]' AS INT[]); +-- +ok +== +SELECT CAST('[NULL]' AS INT[][]); +-- +ok +== +SELECT CAST('[[12,13,14], [8, 9], NULL, [2, 1]]' AS INT[][]); +-- +ok +== +SELECT CAST('[[12,13,14], [8, 9], [2, NULL, 1]]' AS INT[][]); +-- +ok +== +SELECT CAST('[ [[12,13,14], NULL], [[4]], NULL, [[2, NULL, 1, 0], [99]] ]' AS INT[][][]); +-- +ok +== +SELECT TRY_CAST('Hello World' AS INT[]); +-- +ok +== +CREATE TABLE try_cast_tbl (col1 VARCHAR); +-- +ok +== +INSERT INTO try_cast_tbl VALUES ('[1,2,X,2]'), ('[hello DuckDB]'), ('[345,oops,44,4.0]'), ('[12345678901]'), ('[5,6,7]'), ('[3 0, 1]'); +-- +ok +== +SELECT TRY_CAST(col1 AS INT[]) FROM try_cast_tbl; +-- +ok +== +SELECT CAST('{[3]}' AS INT[]); +-- +ok +== +SELECT CAST('Hello World' AS INT[]); +-- +ok +== +SELECT CAST('[3]]' AS INT[]); +-- +ok +== +SELECT CAST('[3],[[]' AS INT[][]); +-- +ok +== +SELECT CAST('[3], [[1]]' AS INT[][]); +-- +ok +== +SELECT CAST('[[3 1]]' AS INT[][]); +-- +ok +== +SELECT CAST('[[3,, 1]]' AS INT[][]); +-- +ok +== +SELECT CAST('[[3], [[5], [4]]' AS INT[][]); +-- +ok +== +SELECT CAST('][3]' AS INT[]); +-- +ok +== +SELECT CAST('[[[[[]][3][[]][][[[][]]]]]' AS INT[][][][]); +-- +ok +== +SELECT * FROM tbl WHERE cast(col1 as int[]) = [1, 2, 2]; +-- +ok +== +SELECT col1 FROM tbl WHERE LEN(cast(col1 as int[])) < 4; +-- +ok +== +SELECT cast(col1 as int[]) FROM tbl WHERE LEN(cast(col1 as int[])) < 4; +-- +ok +== +CREATE TABLE struct_tbl1(col VARCHAR); +-- +ok +== +INSERT INTO struct_tbl1 VALUES('[{a: "hii"}, {a: "hellooo"}]'); +-- +ok +== +SELECT col::STRUCT(a VARCHAR)[] FROM struct_tbl1; +-- +ok +== +SELECT CAST('[ [{a:[12,13,14], b:"🦆"}], [{a:[12,13,14], b:"🦆", c:100}] ]' AS STRUCT(a INT[], b VARCHAR, c FLOAT)[][]); +-- +ok +== +SELECT CAST('[{a:[12,13,14], b:"🦆", c:{a:[[a], [b, c]], b:[123]}}]' AS STRUCT(a INT[], b VARCHAR, c STRUCT(a VARCHAR[][], b INT[]))[]); +-- +ok +== +SELECT '[{a: hii}, {a: "{" }]'::STRUCT(a VARCHAR)[] FROM struct_tbl1; +-- +ok +== +CREATE TABLE struct_tbl2(col VARCHAR); +-- +ok +== +INSERT INTO struct_tbl2 VALUES('[{a: 7, b:"Duck"}, {a: 7000, b: "🦆🦆🦆🦆🦆🦆"}]'); +-- +ok +== +SELECT col::STRUCT(a INT, b VARCHAR)[] FROM struct_tbl2; +-- +ok +== +CREATE TABLE int_list(col INT[]); +-- +ok +== +COPY (SELECT [1,2,3]) TO '{TEST_DIR}/int_list.csv'; +-- +ok +== +COPY int_list FROM '{TEST_DIR}/int_list.csv'; +-- +ok +== +SELECT col FROM int_list; +-- +ok +== +CREATE TABLE assorted_lists(col1 INT[], col2 VARCHAR[], col3 DATE[]); +-- +ok +== +COPY (SELECT [8,7,6], $$[hello, Duck\\'DB]$$, '[2022-12-2, 1929-01-25]') TO '{TEST_DIR}/assorted_lists.csv' (Header 0); +-- +ok +== +COPY assorted_lists FROM '{TEST_DIR}/assorted_lists.csv' (ESCAPE '\'); +-- +ok +== +SELECT * FROM assorted_lists; +-- +ok +== +COPY ( + SELECT * + FROM (VALUES + (1, '[["a0974028-d682-4796-b142-b96580b1c103","2afb4b62-0eeb-4f1a-b351-1464a79d6db2"],["205ffd21-db5c-463d-9575-f7cbf6d73746","2b6705fd-2154-4815-a418-d86cb381efa9"]]'), + (2, NULL) + ) tbl(id, v) +) TO '{TEST_DIR}/issue_23373_uuid_list.csv' (HEADER true, NULLSTR '\N'); +-- +ok +== +SELECT id, v FROM read_csv('{TEST_DIR}/issue_23373_uuid_list.csv', columns={'id':'BIGINT','v':'UUID[]'}, header=true, delim=',', quote='"', escape='"', nullstr='\N'); +-- +ok +== +select '[{"bar":"\""}]'::VARCHAR[]; +-- +ok +== +select '[{"bar":"\\""}]'::VARCHAR[]; +-- +ok +== +select '[{"bar":"\\""}]'::STRUCT(bar VARCHAR)[]; +-- +ok +== +select '[{"bar":"\\\""}]'::STRUCT(bar VARCHAR)[]; +-- +ok +== +select '[{"bar":"\"\"\\\"\"\"\\"}]'::STRUCT(bar VARCHAR)[] a, CAST(a::VARCHAR AS STRUCT(bar VARCHAR)[]) b, a == b; +-- +ok +== +select $$[\ \\abc\\ \ , def, ghi]$$::VARCHAR[] a, a[1], len(a[1]) +-- +ok +== +select $$["\ \\abc\\ \ ", def, ghi]$$::VARCHAR[] a, a[1], len(a[1]) +-- +ok +== diff --git a/parser/testdata/corpus/sql/cast/string_to_list_escapes.test b/parser/testdata/corpus/sql/cast/string_to_list_escapes.test new file mode 100644 index 0000000..4179a29 --- /dev/null +++ b/parser/testdata/corpus/sql/cast/string_to_list_escapes.test @@ -0,0 +1,209 @@ +# source: test/sql/cast/string_to_list_escapes.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +SELECT $$[hello, world]$$::VARCHAR[]; +-- +ok +== +SELECT $$["hello\ world", world]$$::VARCHAR[]; +-- +ok +== +SELECT $$[hello\ world, world]$$::VARCHAR[]; +-- +ok +== +SELECT $$[hello\,world, test]$$::VARCHAR[]; +-- +ok +== +SELECT $$["hello\,world", test]$$::VARCHAR[]; +-- +ok +== +SELECT $$["hello\,", test]$$::VARCHAR[]; +-- +ok +== +SELECT $$[hello\,, test]$$::VARCHAR[]; +-- +ok +== +SELECT $$['']$$::VARCHAR[] a, a::VARCHAR::VARCHAR[] b, a == b; +-- +ok +== +SELECT $$[hello\"quoted\"text, more]$$::VARCHAR[]; +-- +ok +== +SELECT $$[escaped\\backslash, test]$$::VARCHAR[]; +-- +ok +== +SELECT $$["escaped\\backslash", test]$$::VARCHAR[]; +-- +ok +== +SELECT $$[nested[brackets], test]$$::VARCHAR[]; +-- +ok +== +SELECT $$[nested[bracket, test]$$::VARCHAR[]; +-- +ok +== +SELECT $$[nested"["bracket, test]$$::VARCHAR[]; +-- +ok +== +SELECT $$[quote\'in\'string, test]$$::VARCHAR[]; +-- +ok +== +SELECT $$[mix\ of\ special\,chars]$$::VARCHAR[]; +-- +ok +== +SELECT $$["mix\ of\ special\,chars"]$$::VARCHAR[]; +-- +ok +== +SELECT $$["mix\ of\ special\,"chars]$$::VARCHAR[]; +-- +ok +== +SELECT $$["ends with space ", "trailing space "]$$::VARCHAR[]; +-- +ok +== +SELECT $$["ends with comma,", "another,"]$$::VARCHAR[]; +-- +ok +== +SELECT $$["quote at end\"", "\""]$$::VARCHAR[]; +-- +ok +== +SELECT $$["ends with bracket]", "[bracket"]$$::VARCHAR[]; +-- +ok +== +SELECT $$["backslash at end\\", "\\"]$$::VARCHAR[]; +-- +ok +== +SELECT $$[" space at start", " leading space"]$$::VARCHAR[]; +-- +ok +== +SELECT $$[",comma at start", ",leading comma"]$$::VARCHAR[]; +-- +ok +== +SELECT $$["\"quote at start", "\"leading quote"]$$::VARCHAR[]; +-- +ok +== +SELECT $$["[bracket at start", "[leading bracket"]$$::VARCHAR[]; +-- +ok +== +SELECT $$["\\backslash at start", "\\leading backslash"]$$::VARCHAR[]; +-- +ok +== +SELECT $$[" space at start and end ", " leading and trailing space "]$$::VARCHAR[]; +-- +ok +== +SELECT $$[",comma at start and end,", ",leading and trailing comma,"]$$::VARCHAR[]; +-- +ok +== +SELECT $$["\"quote at start and end\"", "\"leading and trailing quote\""]$$::VARCHAR[]; +-- +ok +== +SELECT $$["[bracket at start and end]", "[leading and trailing bracket]"]$$::VARCHAR[]; +-- +ok +== +SELECT $$["\\backslash at start and end\\", "\\leading and trailing backslash\\"]$$::VARCHAR[]; +-- +ok +== +SELECT $$[" mix, of special\ characters " , "[various] \"combinations\" "]$$::VARCHAR[]; +-- +ok +== +SELECT $$[", starts and ends with ,", "[brackets] and ,commas,"]$$::VARCHAR[]; +-- +ok +== +SELECT $$["\"quotes\" and \ spaces ", "\ leading and trailing \ "]$$::VARCHAR[]; +-- +ok +== +SELECT $$["[complex\ combination, of\" special]", "\\all cases covered\\"]$$::VARCHAR[]; +-- +ok +== +SELECT $$["hello, world"]$$::VARCHAR[]; +-- +ok +== +SELECT $$["missing quote]]$$::VARCHAR[]; -- Mismatched quotes +-- +ok +== +SELECT $$["backslash at end\"]$$::VARCHAR[]; -- Improper escaping +-- +ok +== +SELECT $$[unescaped[bracket]$$::VARCHAR[]; -- Unescaped bracket +-- +ok +== +SELECT $$[unterminated string]"]$$::VARCHAR[]; +-- +ok +== +SELECT $$[]$$::VARCHAR[]; -- Empty list +-- +ok +== +SELECT $$[""]$$::VARCHAR[]; -- List with empty string +-- +ok +== +SELECT $$[" "]$$::VARCHAR[]; -- List with whitespace string +-- +ok +== +SELECT $$["\\"]$$::VARCHAR[]; -- List with only a backslash +-- +ok +== +SELECT $$["\""]$$::VARCHAR[]; -- List with only a quote +-- +ok +== +SELECT $$[\,]$$::VARCHAR[]; -- List with only a comma (not quoted) +-- +ok +== +SELECT $$["\,"]$$::VARCHAR[]; -- List with only a comma +-- +ok +== +SELECT $$[","]$$::VARCHAR[]; -- List with only a comma +-- +ok +== +select $$[NULL, 'null', 'nUlL', NuLl, "NULLz", "NULL"]$$::VARCHAR[] a, a::VARCHAR::VARCHAR[] b, a IS NOT DISTINCT FROM b +-- +ok +== diff --git a/parser/testdata/corpus/sql/cast/string_to_list_roundtrip.test b/parser/testdata/corpus/sql/cast/string_to_list_roundtrip.test new file mode 100644 index 0000000..e201372 --- /dev/null +++ b/parser/testdata/corpus/sql/cast/string_to_list_roundtrip.test @@ -0,0 +1,33 @@ +# source: test/sql/cast/string_to_list_roundtrip.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +select $$[\"abc\", def, ghi]$$::VARCHAR[] a, a::VARCHAR::VARCHAR[] b, a == b +-- +ok +== +COPY (select $$[\"abc\", def, ghi]$$::VARCHAR[] a) TO '{TEST_DIR}/copy_test.csv' (FORMAT CSV); +-- +ok +== +select a, a::VARCHAR[] from read_csv('{TEST_DIR}/copy_test.csv') t(a); +-- +ok +== +select $$[" \"abc\" ", def, ghi]$$::VARCHAR[] a, a::VARCHAR::VARCHAR[] b, a == b +-- +ok +== +select $$[\ \\abc\\ \ , def, ghi]$$::VARCHAR[] a, a::VARCHAR::VARCHAR[] b, a == b +-- +ok +== +select $$["\ \\abc\\ \ ", def, ghi]$$::VARCHAR[] a, a::VARCHAR::VARCHAR[] b, a == b +-- +ok +== +select $$[{}]$$::VARCHAR[] a, a::VARCHAR::VARCHAR[] b, a == b +-- +ok +== diff --git a/parser/testdata/corpus/sql/cast/string_to_struct_cast.test b/parser/testdata/corpus/sql/cast/string_to_struct_cast.test new file mode 100644 index 0000000..9c2302a --- /dev/null +++ b/parser/testdata/corpus/sql/cast/string_to_struct_cast.test @@ -0,0 +1,375 @@ +# source: test/sql/cast/string_to_struct_cast.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +SELECT '{key_A:0}'::STRUCT(key_A INT); +-- +ok +== +SELECT '{key_A: 2, key_B: 46, key_C: -3000}'::STRUCT(key_A INT, key_B INT, key_C INT); +-- +ok +== +SELECT '{key_A: 2, key_B: 3, key_C: 8}'::STRUCT(key_A INT, key_B DOUBLE, key_C FLOAT); +-- +ok +== +SELECT '{"key_A": 2, "key_B": hello world}'::STRUCT(key_A INT, key_B VARCHAR); +-- +ok +== +select (struct_pack(key_A=>'42'::double, key_B=>'DuckDB'::string)::VARCHAR)::STRUCT(key_A INT, key_B VARCHAR); +-- +ok +== +SELECT '{🦆: Quack, 🦤: ....}'::STRUCT(🦆 VARCHAR, 🦤 VARCHAR); +-- +ok +== +SELECT '{a:{c:1}, b:900}'::STRUCT(a STRUCT(c INT), b INT); +-- +ok +== +SELECT '{a:{b:DuckDB, c:12}, b:900, c:{a:"DuckParty"}}'::STRUCT(a STRUCT(b VARCHAR, c INT), b INT, c STRUCT(a VARCHAR)); +-- +ok +== +SELECT '{a:{b:DuckDB, c:{a:{a:0.9, b:{a:"DuckieDuck"}, c:{a:9000}, d:{a:5881580-07-10}}, b:"🦆"}}, b:900, c:{a:"DuckParty"}}'::STRUCT(a STRUCT(b VARCHAR, c STRUCT(a STRUCT(a FLOAT, b STRUCT(a VARCHAR), c STRUCT(a INT), d STRUCT(a DATE)), b VARCHAR)), b INT, c STRUCT(a VARCHAR)); +-- +ok +== +SELECT CAST('{a:{b:{c:{d:{e:{f:"Hello World"}}}}}}' AS STRUCT(a STRUCT(b STRUCT(c STRUCT(d STRUCT(e STRUCT(f VARCHAR))))))); +-- +ok +== +CREATE TABLE tbl1(col VARCHAR); +-- +ok +== +INSERT INTO tbl1 (VALUES ('{a:1, b:3}')); +-- +ok +== +SELECT col::STRUCT(a INT, b INT) FROM tbl1; +-- +ok +== +CREATE TABLE tbl2(col VARCHAR); +-- +ok +== +INSERT INTO tbl2 (VALUES ('{a:1, b:"hello, world"}')); +-- +ok +== +SELECT col::STRUCT(a INT, b VARCHAR) a, a::VARCHAR::STRUCT(a INT, b VARCHAR) b, a == b FROM tbl2; +-- +ok +== +CREATE TABLE tbl3(col VARCHAR); +-- +ok +== +INSERT INTO tbl3 (VALUES ('{a:DUCK, b:9.999, c:12}'), ('{a:"DB", b:1.111, c:21}')); +-- +ok +== +SELECT col::STRUCT(a VARCHAR, b FLOAT, c INT) FROM tbl3; +-- +ok +== +CREATE TABLE tbl4(col VARCHAR); +-- +ok +== +INSERT INTO tbl4 (VALUES ('{a:{b:1}}')); +-- +ok +== +SELECT col::STRUCT(a STRUCT(b INT)) FROM tbl4; +-- +ok +== +SELECT '{key_A: [2, 3, 4], key_B: [Hello, World]}'::STRUCT(key_A INT[], key_B VARCHAR[]); +-- +ok +== +SELECT '{key_A: [[2, 3], [4]], key_B: [Hello, World]}'::STRUCT(key_A INT[][], key_B VARCHAR[]); +-- +ok +== +SELECT '{key_A: [[{a: 5, b: 900}, {a:3, b:34}], [{a:2, b: 0}]], key_B: [Hello, World]}'::STRUCT(key_A STRUCT(a INT, b INT)[][], key_B VARCHAR[]); +-- +ok +== +SELECT '{key_B: 2, key_A: 46}'::STRUCT(key_A INT, key_B INT); +-- +ok +== +SELECT '{c:{a:"DuckParty"}, b:900, a:{b:DuckDB, c:{a:{a:0.9, b:{a:"DuckieDuck"}, c:{a:9000}, d:{a:5881580-07-10}}, b:"🦆"}}}'::STRUCT(a STRUCT(b VARCHAR, c STRUCT(a STRUCT(a FLOAT, b STRUCT(a VARCHAR), c STRUCT(a INT), d STRUCT(a DATE)), b VARCHAR)), b INT, c STRUCT(a VARCHAR)); +-- +ok +== +SELECT '{key_D: "World Hello", key_B: [Hello, World], key_C : 5000, key_A: [[{a: 5, b: 900}, {a:3, b:34}], [{a:2, b: 0}]]}'::STRUCT(key_A STRUCT(a INT, b INT)[][], key_B VARCHAR[], key_C INT, key_D VARCHAR); +-- +ok +== +SELECT ('{a:"}", b: hello universe}'::STRUCT(a VARCHAR, b VARCHAR)); +-- +ok +== +SELECT '{ key_A: 2, key_B: hello world }'::STRUCT(key_A INT, key_B VARCHAR); +-- +ok +== +SELECT ' {a: {b: DuckDB, c:12 }, b: 900, c :{a + : "DuckParty "} } '::STRUCT(a STRUCT(b VARCHAR, c INT), b INT, c STRUCT(a VARCHAR)); +-- +ok +== +SELECT '{key_A : [ [{ a: 5 , b : 900 }, { a: 3, b: 34}], [ {a: + 2, b: 0 } ] ], key_B: [Hello , World] }'::STRUCT(key_A STRUCT(a INT, b INT)[][], key_B VARCHAR[]); +-- +ok +== +SELECT '{a : {c : 9000}, b : NULL + , c:{ d: "Ducky", e: NULL } } '::STRUCT(a STRUCT(c INT), b VARCHAR, c STRUCT(d VARCHAR, e DOUBLE)); +-- +ok +== +SELECT ' { } '::STRUCT(a INT, b DATE); +-- +ok +== +SELECT '{ key_A: 2, key_B: {key_C: hello world } X }'::STRUCT(key_A INT, key_B STRUCT(key_C VARCHAR)); +-- +ok +== +SELECT CAST(NULL AS STRUCT(a INT)); +-- +ok +== +SELECT '{a: NULL}'::STRUCT(a VARCHAR); +-- +ok +== +SELECT '{a:12, b:NULL}'::STRUCT(a INT, b INT); +-- +ok +== +SELECT '{a:{c: NULL}, b: NULL, c:{d: "Ducky", e: NULL}}'::STRUCT(a STRUCT(c INT), b VARCHAR, c STRUCT(d VARCHAR, e DOUBLE)); +-- +ok +== +SELECT '{key_A: 2, key_C: 8}'::STRUCT(key_A INT, key_B INT, key_C FLOAT); +-- +ok +== +SELECT '{key_C: 8, key_A: 2}'::STRUCT(key_A INT, key_B DOUBLE, key_C FLOAT); +-- +ok +== +SELECT '{key_C: Quack}'::STRUCT(key_A INT, key_B VARCHAR, key_C VARCHAR); +-- +ok +== +SELECT {'key_C': 2, 'key_A': 4}::VARCHAR::STRUCT(key_A INT, key_B VARCHAR, key_C VARCHAR); +-- +ok +== +SELECT '{key_A:0}'::STRUCT(key_A INT, key_B VARCHAR); +-- +ok +== +SELECT '{key_C: {key_B: 3, key_E: 🦆}, key_A: 2}'::STRUCT(key_A INT, key_C STRUCT(key_B INT, key_D INT, key_E VARCHAR)); +-- +ok +== +SELECT '{a:{b:{b:300}, c:12}, c:{a:"DuckParty"}}'::STRUCT(a STRUCT(b STRUCT(a INT, b VARCHAR), c INT), b INT, c STRUCT(a VARCHAR, b STRUCT(a INT))); +-- +ok +== +SELECT '{}'::STRUCT(a INT, b VARCHAR); +-- +ok +== +SELECT TRY_CAST('{key_B: "hello", key_Z: 2, key_A: 46}' AS STRUCT(key_A INT, key_B VARCHAR)); +-- +ok +== +SELECT TRY_CAST('{key_B: "hello", key_Z: 2, key_A: 46}' AS STRUCT(key_A INT, key_B VARCHAR, key_C INT)); +-- +ok +== +SELECT TRY_CAST('{key_B: "hello", key_A: 46}' AS STRUCT(key_A INT, key_B INT)); +-- +ok +== +SELECT TRY_CAST('{a:4, b:''Ducky'', c:''🦆''}' AS STRUCT(a INT, b DOUBLE, c VARCHAR)); +-- +ok +== +CREATE TABLE try_cast_tbl(col VARCHAR); +-- +ok +== +INSERT INTO try_cast_tbl (VALUES ('{a:{d:1}, b:100, c:"🦆"}'), ('{a:{X:1}, b:100, c:"🦆"}'), ('{a:{d:1}, b:100, X:"🦆"}'), ('{a:"oh oh", b:100, c:"🦆"}'), ('{a:{d:"oops"}, b:100, c:"🦆"}'), ('{a:{d:"oops"}, b:100, Z: "undercover", c:"🦆"}')); +-- +ok +== +SELECT TRY_CAST(col AS STRUCT(a STRUCT(d INT), b DOUBLE, c VARCHAR)) FROM try_cast_tbl; +-- +ok +== +SELECT CAST('[{a:3}]' AS STRUCT(a INT)); +-- +ok +== +SELECT CAST('Hello World' AS STRUCT(a VARCHAR)); +-- +ok +== +SELECT CAST('{a: 3}}' AS STRUCT(a INT)); +-- +ok +== +SELECT CAST('{a: 3, b:{c: 8}}}' AS STRUCT(a INT, b STRUCT(c INT))); +-- +ok +== +SELECT CAST('{{a: 3}' AS STRUCT(a INT)); +-- +ok +== +SELECT CAST('{a:3}, {b:1}' AS STRUCT(a INT, b INT)); +-- +ok +== +SELECT CAST('{a:{a:3}, b:{{b:1}}}' AS STRUCT(a STRUCT(a INT), b STRUCT(b INT))); +-- +ok +== +SELECT CAST('{a: 3 1}' AS STRUCT(a INT)); +-- +ok +== +SELECT CAST('{a:3,, b:1}' AS STRUCT(a INT, b INT)); +-- +ok +== +SELECT CAST('}{a:5}' AS STRUCT(a INT)); +-- +ok +== +SELECT CAST('{a:{b:{d: 800}, {c: "Duck"}}}' AS STRUCT(a STRUCT(b STRUCT(d INT), c STRUCT(c VARCHAR)))); +-- +ok +== +SELECT CAST('{[{]}}' AS STRUCT(a VARCHAR[])); +-- +ok +== +SELECT CAST('{ ' AS STRUCT(a INTEGER)); +-- +ok +== +SELECT CAST('( ' AS STRUCT(a INTEGER)); +-- +ok +== +CREATE TABLE tbl(col VARCHAR); +-- +ok +== +INSERT INTO tbl (VALUES ('{a:DUCK, b:12}'), ('{a:"DB", b:21}'), ('{a:"Quack", b:2}')); +-- +ok +== +SELECT cast(col as STRUCT(a VARCHAR, b INT)).a FROM tbl WHERE cast(col as STRUCT(a VARCHAR, b INT)).b=12; +-- +ok +== +CREATE TABLE assorted_structs(col1 STRUCT(a INT, b VARCHAR)); +-- +ok +== +COPY (SELECT '{a: 8, b: "hello, DuckDB"}') TO '{TEST_DIR}/assorted_structs.csv'; +-- +ok +== +COPY assorted_structs FROM '{TEST_DIR}/assorted_structs.csv'; +-- +ok +== +SELECT * FROM assorted_structs; +-- +ok +== +CREATE TABLE json_tbl(col1 VARCHAR); +-- +ok +== +INSERT INTO json_tbl (VALUES ('{ + "id": "0001", + "type": "donut", + "name": "Cake", + "ppu": 0.55, + "batters": + { + "batter": + [ + { "id": "1001", "type": "Regular" }, + { "id": "1002", "type": "Chocolate" }, + { "id": "1003", "type": "Blueberry" }, + { "id": "1004", "type": "Devil''s Food" } + ] + }, + "topping": + [ + { "id": "5001", "type": "None" }, + { "id": "5002", "type": "Glazed" }, + { "id": "5005", "type": "Sugar" }, + { "id": "5007", "type": "Powdered Sugar" }, + { "id": "5006", "type": "Chocolate with Sprinkles" }, + { "id": "5003", "type": "Chocolate" }, + { "id": "5004", "type": "Maple" } + ] +}')); +-- +ok +== +SELECT col1::STRUCT( + id VARCHAR, + type VARCHAR, + name VARCHAR, + ppu FLOAT, + batters STRUCT( + batter STRUCT( + id VARCHAR, + type VARCHAR + )[] + ), + topping STRUCT( + id VARCHAR, + type VARCHAR + )[] +) FROM json_tbl; +-- +ok +== +CREATE TABLE json_tbl2(col1 JSON); +-- +ok +== +INSERT INTO json_tbl2 (VALUES ('{"A": "Ducky", "B": [3, 50, 8, 43], "C":{"A": "TEST", "B": 0.9, "C": [0.0, 9, 30.2]} }' ), + ('{"A": "TESTY", "B": [4], "C":{"A": "🦆", "B": 6.12, "C": [0.099, 1.6]} }' ), + ('{"A": "Hello World", "B": [0, 0, 2, 500, 0, 8], "C":{"A": "DuckieDuck !", "B": 3000, "C": [0]} }' ), + ('{"A": "", "B": [], "C":{"A": "", "B": 0, "C": []} }' )); +-- +ok +== +SELECT col1::VARCHAR::STRUCT(A VARCHAR, B INT[], C STRUCT(A VARCHAR, B FLOAT, C DOUBLE[])) FROM json_tbl2; +-- +ok +== diff --git a/parser/testdata/corpus/sql/cast/string_to_struct_escapes.test b/parser/testdata/corpus/sql/cast/string_to_struct_escapes.test new file mode 100644 index 0000000..4603387 --- /dev/null +++ b/parser/testdata/corpus/sql/cast/string_to_struct_escapes.test @@ -0,0 +1,9 @@ +# source: test/sql/cast/string_to_struct_escapes.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +select $$[{'a': test}, {'a': NULL}, {'a': 'null'}, {'a': 'nUlL'}, {'a': NULL}, {'a': NULLz}, {'a': 'NULL'}]$$::STRUCT(a VARCHAR)[] a, a::VARCHAR::STRUCT(a VARCHAR)[] b, a IS NOT DISTINCT FROM b +-- +ok +== diff --git a/parser/testdata/corpus/sql/cast/string_to_unnamed_struct.test b/parser/testdata/corpus/sql/cast/string_to_unnamed_struct.test new file mode 100644 index 0000000..d79e262 --- /dev/null +++ b/parser/testdata/corpus/sql/cast/string_to_unnamed_struct.test @@ -0,0 +1,75 @@ +# source: test/sql/cast/string_to_unnamed_struct.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +select [row('a'), $$(abc)$$] +-- +ok +== +select [row('a', 'b', 'c'), $$(abc, def, ghi)$$] +-- +ok +== +select [row('a'),$$()$$] +-- +ok +== +select [row('a'),$$('')$$] +-- +ok +== +select [row({'amount': 21}), $$({'amount': 42})$$] +-- +ok +== +select [row(row(21)), $$((42))$$] +-- +ok +== +select [row(row(21), {'amount': 42}), $$((42), {amount: 21})$$] +-- +ok +== +select [row([7,8,9], [10,11,12]), $$([1,2,3], [4,5,6])$$] +-- +ok +== +select [row([4,5,6]), $$([1,2,3],)$$] +-- +ok +== +select [row([4,5,6], 'abc'), $$([1,2,3],)$$] +-- +ok +== +select [ + [ + row( + row( + ' test ' + ) + ), + {'a': { + 'inner': + '\ test \' + } + } + ], + $$[((" test ")), {'a': (\\ test \\)}]$$ +] +-- +ok +== +select [ + row('test'), + $$(NULL)$$, + $$('null')$$, + $$('nUlL')$$, + $$(NuLl)$$, + $$("NULLz")$$, + $$("NULL")$$ +] a, a::VARCHAR::STRUCT(a VARCHAR)[] b, a IS NOT DISTINCT FROM b +-- +ok +== diff --git a/parser/testdata/corpus/sql/cast/struct_to_map.test b/parser/testdata/corpus/sql/cast/struct_to_map.test new file mode 100644 index 0000000..1d815c0 --- /dev/null +++ b/parser/testdata/corpus/sql/cast/struct_to_map.test @@ -0,0 +1,222 @@ +# source: test/sql/cast/struct_to_map.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +SELECT {"name": 'Alice', "city": 'NYC'}::MAP(VARCHAR, VARCHAR); +-- +ok +== +SELECT {"age": 25, "score": 100}::MAP(VARCHAR, INT); +-- +ok +== +SELECT col::MAP(VARCHAR, INT) +FROM VALUES ({"duck": 1}),({"duck": 2}),({"duck": 3}),({"duck": 4}),({"duck": 5}) +AS tab(col); +-- +ok +== +SELECT {"name": 'Alice', "age": 25, "score": 95}::MAP(VARCHAR, VARCHAR); +-- +ok +== +SELECT col::MAP(INT, INT) +FROM VALUES ({"1": 1}),({"2": 2}),({"3": 3}),({"4": 4}),({"5": 5}) +AS tab(col); +-- +ok +== +SELECT {"123456789": 42}::MAP(BIGINT, INT); +-- +ok +== +SELECT {"3.14": 100}::MAP(DOUBLE, INT); +-- +ok +== +SELECT {"age": 25, "score": 100}::MAP(VARCHAR, VARCHAR); +-- +ok +== +SELECT {"small": 1, "big": 999999999}::MAP(VARCHAR, BIGINT); +-- +ok +== +SELECT {"pi": 3, "e": 2}::MAP(VARCHAR, DOUBLE); +-- +ok +== +SELECT {"1": 100, "2": 200}::MAP(INT, BIGINT); +-- +ok +== +SELECT (NULL::STRUCT(name VARCHAR, age INT))::MAP(VARCHAR, VARCHAR); +-- +ok +== +SELECT {"name": 'Alice', "age": NULL}::MAP(VARCHAR, VARCHAR); +-- +ok +== +SELECT {"a": NULL, "b": NULL, "c": 'value'}::MAP(VARCHAR, VARCHAR); +-- +ok +== +SELECT x::MAP(VARCHAR, INT) FROM (SELECT {"constant": 42} as x FROM range(5)); +-- +ok +== +SELECT {"person": {"name": 'Alice', "age": 25}}::MAP(VARCHAR, STRUCT(name VARCHAR, age INT)); +-- +ok +== +SELECT {"numbers": [1,2,3], "letters": ['a','b']}::MAP(VARCHAR, VARCHAR[]); +-- +ok +== +SELECT {meta: MAP{'key': 'value'}}::MAP(VARCHAR, MAP(VARCHAR, VARCHAR)); +-- +ok +== +SELECT col::MAP(VARCHAR, MAP(VARCHAR, INT)) +FROM VALUES ({ data: MAP{'count': 10, 'total': 100} }) +AS tab(col); +-- +ok +== +SELECT {"value": 42}::MAP(VARCHAR, INT) +FROM range(1, 1001) +LIMIT 5; +-- +ok +== +pragma debug_verify_vector='dictionary_expression' +-- +ok +== +SELECT TRY_CAST(col AS MAP(VARCHAR, integer)) +FROM ( + SELECT CASE WHEN (i % 5 == 0) THEN NULL else {'a': i::varchar} END as col + FROM range(1, 1001) t(i) +) +LIMIT 5; +-- +ok +== +pragma debug_verify_vector='none' +-- +ok +== +SELECT {"single": 'value'}::MAP(VARCHAR, VARCHAR); +-- +ok +== +SELECT { + "f1": 1, "f2": 2, "f3": 3, "f4": 4, "f5": 5, + "f6": 6, "f7": 7, "f8": 8, "f9": 9, "f10": 10 +}::MAP(VARCHAR, INT); +-- +ok +== +SELECT (1, 2, 3)::MAP(INT, INT); +-- +ok +== +SELECT col::MAP(INT, INT) +FROM VALUES ({"duck": 1}),({"goose": 2}) +AS tab(col); +-- +ok +== +SELECT {"number": 'not_a_number'}::MAP(VARCHAR, INT); +-- +ok +== +SELECT {"first name": 'Alice', "last name": 'Smith'}::MAP(VARCHAR, VARCHAR); +-- +ok +== +SELECT {"key-with-dashes": 1, "key_with_underscores": 2, "key.with.dots": 3}::MAP(VARCHAR, INT); +-- +ok +== +SELECT {"测试": 'test', "🦆": 'duck'}::MAP(VARCHAR, VARCHAR); +-- +ok +== +SELECT {"CamelCase": 1, "lowercase": 2, "UPPERCASE": 3}::MAP(VARCHAR, INT); +-- +ok +== +SELECT col::MAP(VARCHAR, INT) +FROM ( + SELECT {"value": i} as col + FROM range(1, 1001) t(i) +) +LIMIT 5; +-- +ok +== +SELECT col::MAP(VARCHAR, VARCHAR) +FROM VALUES + ({"a": '1'}), + ({"A": '1', "b": '2'}), + ({"a": '1', "B": '2', "c": '3'}), + ({"x": 'single'}), + ({"many": '1', "fields": '2', "here": '3', "total": '4', "five": '5'}) +AS tab(col); +-- +ok +== +SELECT { + "tinyint": 1::TINYINT, + "smallint": 2::SMALLINT, + "int": 3::INT, + "bigint": 4::BIGINT +}::MAP(VARCHAR, BIGINT); +-- +ok +== +SELECT { + "varchar": 'hello'::VARCHAR, + "text": 'world'::TEXT +}::MAP(VARCHAR, VARCHAR); +-- +ok +== +SELECT { + "date": '2023-01-01'::DATE, + "time": '12:00:00'::TIME +}::MAP(VARCHAR, VARCHAR); +-- +ok +== +SELECT {"true_val": true, "false_val": false}::MAP(VARCHAR, VARCHAR); +-- +ok +== +SELECT {"price": 19.99::DECIMAL(10,2)}::MAP(VARCHAR, VARCHAR); +-- +ok +== +SELECT * +FROM VALUES ({"status": 'active'}), ({"status": 'inactive'}) +AS tab(col) +WHERE (col::MAP(VARCHAR, VARCHAR))['status'] = 'active'; +-- +ok +== +SELECT COUNT(*) +FROM VALUES ({"type": 'A'}), ({"type": 'B'}), ({"type": 'A'}) +AS tab(col) +WHERE (col::MAP(VARCHAR, VARCHAR))['type'] = 'A'; +-- +ok +== +SELECT col::MAP(VARCHAR, MAP(VARCHAR, INT)) +FROM VALUES ({ nested: MAP { 'inner_key': 707 } }) +AS tab(col); +-- +ok +== diff --git a/parser/testdata/corpus/sql/cast/test_bit_cast.test b/parser/testdata/corpus/sql/cast/test_bit_cast.test new file mode 100644 index 0000000..22ad7dd --- /dev/null +++ b/parser/testdata/corpus/sql/cast/test_bit_cast.test @@ -0,0 +1,329 @@ +# source: test/sql/cast/test_bit_cast.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +CREATE TABLE bits (b bit); +-- +ok +== +INSERT INTO bits VALUES('00001111'); +-- +ok +== +SELECT b::BOOLEAN FROM bits; +-- +ok +== +SELECT '1'::BIT::BOOL; +-- +ok +== +SELECT '0'::BIT::BOOL; +-- +ok +== +SELECT b::TINYINT FROM bits; +-- +ok +== +SELECT b::SMALLINT FROM bits; +-- +ok +== +SELECT b::INTEGER FROM bits; +-- +ok +== +SELECT b::BIGINT FROM bits; +-- +ok +== +SELECT b::UTINYINT FROM bits; +-- +ok +== +SELECT b::USMALLINT FROM bits; +-- +ok +== +SELECT b::UINTEGER FROM bits; +-- +ok +== +SELECT b::UBIGINT FROM bits; +-- +ok +== +SELECT b::HUGEINT FROM bits; +-- +ok +== +SELECT b::UHUGEINT FROM bits; +-- +ok +== +SELECT b::FLOAT FROM bits; +-- +ok +== +SELECT b::DOUBLE FROM bits; +-- +ok +== +SELECT '100001111000011110000111100001111'::BIT::BIGINT; +-- +ok +== +SELECT 15::BOOLEAN::BIT; +-- +ok +== +SELECT 15::TINYINT::BIT; +-- +ok +== +SELECT 15::SMALLINT::BIT; +-- +ok +== +SELECT 15::BIT; +-- +ok +== +SELECT 15::BIGINT::BIT; +-- +ok +== +SELECT 15::HUGEINT::BIT; +-- +ok +== +SELECT 15::UHUGEINT::BIT; +-- +ok +== +SELECT 2.1e-44::FLOAT::BIT; +-- +ok +== +SELECT 7.4e-323::BIT; +-- +ok +== +SELECT ''::BIT; +-- +ok +== +SELECT bit_length(''::BIT); +-- +ok +== +SELECT TRY_CAST('' AS BIT); +-- +ok +== +SELECT bitstring('1', 9)::TINYINT; +-- +ok +== +SELECT bitstring('1', 17)::SMALLINT; +-- +ok +== +SELECT bitstring('1', 33)::INT; +-- +ok +== +SELECT bitstring('1', 65)::BIGINT; +-- +ok +== +SELECT bitstring('1', 33)::FLOAT; +-- +ok +== +SELECT bitstring('1', 65)::DOUBLE; +-- +ok +== +SELECT b::BLOB FROM bits; +-- +ok +== +SELECT bitstring('1111', 32)::BLOB; +-- +ok +== +SELECT '1111'::BIT::BLOB; +-- +ok +== +select 'ab'::BLOB::BIT::BLOB; +-- +ok +== +select 'a'::BLOB::BIT::BLOB; +-- +ok +== +SELECT bitstring('1111', 33)::BLOB; +-- +ok +== +SELECT 'AAAA'::BLOB::BIT; +-- +ok +== +SELECT ''::BLOB::BIT; +-- +ok +== +SELECT (-15)::TINYINT::BIT; +-- +ok +== +SELECT (-15)::HUGEINT::BIT; +-- +ok +== +SELECT (127)::TINYINT::BIT; +-- +ok +== +SELECT (-128)::TINYINT::BIT; +-- +ok +== +SELECT (32767)::SMALLINT::BIT; +-- +ok +== +SELECT (-32768)::SMALLINT::BIT; +-- +ok +== +SELECT (2147483647)::INT::BIT; +-- +ok +== +SELECT (-2147483648)::INT::BIT; +-- +ok +== +SELECT (9223372036854775807)::BIGINT::BIT; +-- +ok +== +SELECT (-9223372036854775808)::BIGINT::BIT; +-- +ok +== +SELECT (170141183460469231731687303715884105727)::HUGEINT::BIT; +-- +ok +== +SELECT (-170141183460469231731687303715884105728)::HUGEINT::BIT; +-- +ok +== +SELECT '01111111'::BIT::TINYINT; +-- +ok +== +SELECT '10000000'::BIT::TINYINT; +-- +ok +== +SELECT '0111111111111111'::BIT::SMALLINT; +-- +ok +== +SELECT '1000000000000000'::BIT::SMALLINT; +-- +ok +== +SELECT '01111111111111111111111111111111'::BIT::INT; +-- +ok +== +SELECT '10000000000000000000000000000000'::BIT::INT; +-- +ok +== +SELECT '0111111111111111111111111111111111111111111111111111111111111111'::BIT::BIGINT; +-- +ok +== +SELECT '1000000000000000000000000000000000000000000000000000000000000000'::BIT::BIGINT; +-- +ok +== +SELECT '01111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111'::BIT::HUGEINT; +-- +ok +== +SELECT '10000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000'::BIT::HUGEINT; +-- +ok +== +SELECT (255)::UTINYINT::BIT; +-- +ok +== +SELECT (65535)::USMALLINT::BIT; +-- +ok +== +SELECT (4294967295)::UINTEGER::BIT; +-- +ok +== +SELECT (18446744073709551615)::UBIGINT::BIT; +-- +ok +== +SELECT '340282366920938463463374607431768211455'::UHUGEINT::BIT; +-- +ok +== +SELECT '11111111'::BIT::UTINYINT; +-- +ok +== +SELECT '1111111111111111'::BIT::USMALLINT; +-- +ok +== +SELECT '11111111111111111111111111111111'::BIT::UINTEGER; +-- +ok +== +SELECT '1111111111111111111111111111111111111111111111111111111111111111'::BIT::UBIGINT; +-- +ok +== +SELECT (3.4028235e+38)::FLOAT::BIT; +-- +ok +== +SELECT (1.7976931348623157e+308)::DOUBLE::BIT; +-- +ok +== +SELECT '01111111011111111111111111111111'::BIT::FLOAT; +-- +ok +== +SELECT '0111111111101111111111111111111111111111111111111111111111111111'::BIT::DOUBLE; +-- +ok +== +SELECT NULL::BIT; +-- +ok +== +SELECT NULL::BIT::INT; +-- +ok +== diff --git a/parser/testdata/corpus/sql/cast/test_boolean_cast.test b/parser/testdata/corpus/sql/cast/test_boolean_cast.test new file mode 100644 index 0000000..4d9d4af --- /dev/null +++ b/parser/testdata/corpus/sql/cast/test_boolean_cast.test @@ -0,0 +1,185 @@ +# source: test/sql/cast/test_boolean_cast.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +SELECT CAST(1=1 AS VARCHAR) +-- +ok +== +SELECT CAST(1=0 AS VARCHAR) +-- +ok +== +SELECT CAST(12345 AS BOOLEAN) +-- +ok +== +SELECT CAST('true' AS BOOLEAN) +-- +ok +== +SELECT CAST('t' AS BOOLEAN) +-- +ok +== +SELECT CAST('TRUE' AS BOOLEAN) +-- +ok +== +SELECT CAST('yes' AS BOOLEAN) +-- +ok +== +SELECT CAST('YeS' AS BOOLEAN) +-- +ok +== +SELECT CAST('y' AS BOOLEAN) +-- +ok +== +SELECT CAST('false' AS BOOLEAN) +-- +ok +== +SELECT CAST('f' AS BOOLEAN) +-- +ok +== +SELECT CAST('FALSE' AS BOOLEAN) +-- +ok +== +SELECT CAST('no' AS BOOLEAN) +-- +ok +== +SELECT CAST('nO' AS BOOLEAN) +-- +ok +== +SELECT CAST('n' AS BOOLEAN) +-- +ok +== +SELECT CAST('12345' AS BOOLEAN) +-- +ok +== +CREATE TABLE tbl AS SELECT 0 AS yes +-- +ok +== +SELECT CAST(yes AS BOOLEAN) FROM tbl +-- +ok +== +SELECT CAST(yes AS BOOLEAN) +-- +ok +== +SELECT CAST(CAST('12345' AS INTEGER) AS BOOLEAN) +-- +ok +== +SELECT CAST(CAST('0' AS INTEGER) AS BOOLEAN) +-- +ok +== +SELECT CAST(CAST('1' AS tinyint) AS BOOLEAN) +-- +ok +== +SELECT CAST(CAST('0' AS tinyint) AS BOOLEAN) +-- +ok +== +SELECT CAST(CAST('1' AS smallint) AS BOOLEAN) +-- +ok +== +SELECT CAST(CAST('0' AS smallint) AS BOOLEAN) +-- +ok +== +SELECT CAST(CAST('1' AS integer) AS BOOLEAN) +-- +ok +== +SELECT CAST(CAST('0' AS integer) AS BOOLEAN) +-- +ok +== +SELECT CAST(CAST('1' AS bigint) AS BOOLEAN) +-- +ok +== +SELECT CAST(CAST('0' AS bigint) AS BOOLEAN) +-- +ok +== +SELECT CAST(CAST('1' AS decimal) AS BOOLEAN) +-- +ok +== +SELECT CAST(CAST('0' AS decimal) AS BOOLEAN) +-- +ok +== +SELECT CAST(CAST('1' AS decimal(1,0)) AS BOOLEAN) +-- +ok +== +SELECT CAST(CAST('0' AS decimal(1,0)) AS BOOLEAN) +-- +ok +== +SELECT CAST(CAST('1' AS decimal(9,0)) AS BOOLEAN) +-- +ok +== +SELECT CAST(CAST('0' AS decimal(9,0)) AS BOOLEAN) +-- +ok +== +SELECT CAST(CAST('1' AS decimal(38,0)) AS BOOLEAN) +-- +ok +== +SELECT CAST(CAST('0' AS decimal(38,0)) AS BOOLEAN) +-- +ok +== +SELECT CAST(CAST('1' AS float) AS BOOLEAN) +-- +ok +== +SELECT CAST(CAST('0' AS float) AS BOOLEAN) +-- +ok +== +SELECT CAST(CAST('1' AS double) AS BOOLEAN) +-- +ok +== +SELECT CAST(CAST('0' AS double) AS BOOLEAN) +-- +ok +== +SELECT CAST(CAST('1' AS HUGEINT) AS BOOLEAN) +-- +ok +== +SELECT CAST(CAST('0' AS HUGEINT) AS BOOLEAN) +-- +ok +== +SELECT CAST(CAST('1' AS UHUGEINT) AS BOOLEAN) +-- +ok +== +SELECT CAST(CAST('0' AS UHUGEINT) AS BOOLEAN) +-- +ok +== diff --git a/parser/testdata/corpus/sql/cast/test_exponent_in_cast.test b/parser/testdata/corpus/sql/cast/test_exponent_in_cast.test new file mode 100644 index 0000000..ba44244 --- /dev/null +++ b/parser/testdata/corpus/sql/cast/test_exponent_in_cast.test @@ -0,0 +1,45 @@ +# source: test/sql/cast/test_exponent_in_cast.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +SELECT CAST('e1' AS INTEGER); +-- +ok +== +SELECT CAST(' e1' AS INTEGER); +-- +ok +== +SELECT CAST(' E1' AS INTEGER); +-- +ok +== +SELECT CAST('e1' AS DOUBLE); +-- +ok +== +SELECT CAST(' e1' AS DOUBLE); +-- +ok +== +SELECT CAST(' E1' AS DOUBLE); +-- +ok +== +SELECT CAST('1e1' AS INTEGER); +-- +ok +== +SELECT CAST(' 1e1' AS INTEGER); +-- +ok +== +SELECT CAST('1e1' AS DOUBLE); +-- +ok +== +SELECT CAST(' 1e1' AS DOUBLE); +-- +ok +== diff --git a/parser/testdata/corpus/sql/cast/test_string_binary_cast.test b/parser/testdata/corpus/sql/cast/test_string_binary_cast.test new file mode 100644 index 0000000..77552d1 --- /dev/null +++ b/parser/testdata/corpus/sql/cast/test_string_binary_cast.test @@ -0,0 +1,122 @@ +# source: test/sql/cast/test_string_binary_cast.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +SELECT '{prefix}'::INT +-- +ok +== +SELECT '{prefix}2'::INT +-- +ok +== +SELECT '{prefix}10105'::INT +-- +ok +== +SELECT '{prefix}-1'::INT +-- +ok +== +SELECT '-{prefix}1'::INT +-- +ok +== +SELECT '{prefix}1'::INT +-- +ok +== +SELECT '{prefix}10'::INT +-- +ok +== +SELECT '{prefix}11'::INT +-- +ok +== +SELECT '{prefix}0000000'::INT +-- +ok +== +SELECT '{prefix}1_0'::INT +-- +ok +== +SELECT '{prefix}1_0_0'::INT +-- +ok +== +SELECT '{prefix}11110000_11110000'::INT +-- +ok +== +SELECT '{prefix}_1'::INT +-- +ok +== +SELECT '{prefix}1_'::INT +-- +ok +== +SELECT '{prefix}1_0_'::INT +-- +ok +== +SELECT '{prefix}_1_0'::INT +-- +ok +== +WITH binary_string as (select replace('{binary}', '_', '') as str) +SELECT + list_sum([ (CASE WHEN str[i+1] = '0' THEN 0 ELSE 1 END) * (2 ** (len(str)-(i+1))) for i in range(len(str))])::INT + == + '{prefix}{binary}'::INT +FROM binary_string +-- +ok +== +SELECT '{prefix}0000000000000000000000000000000001111111'::TINYINT +-- +ok +== +SELECT '{prefix}0000000000000000000000000000000011111111'::UINT8 +-- +ok +== +SELECT '{prefix}00000000000000000000000000000000111111111'::TINYINT +-- +ok +== +SELECT '{prefix}1111111111111111111111111111111'::INT +-- +ok +== +SELECT '{prefix}11111111111111111111111111111111'::INT +-- +ok +== +SELECT '{prefix}01111111111111111111111111111111'::UINT32 +-- +ok +== +SELECT '{prefix}11111111111111111111111111111111'::UINT32 +-- +ok +== +SELECT '{prefix}11111111111111111111111111111111'::BIGINT +-- +ok +== +SELECT '{prefix}111111111111111111111111111111111111111111111111111111111111111'::BIGINT +-- +ok +== +SELECT '{prefix}1111111111111111111111111111111111111111111111111111111111111111'::BIGINT +-- +ok +== +SELECT '{prefix}1111111111111111111111111111111111111111111111111111111111111111'::UINT64 +-- +ok +== diff --git a/parser/testdata/corpus/sql/cast/test_string_cast.test b/parser/testdata/corpus/sql/cast/test_string_cast.test new file mode 100644 index 0000000..616b11e --- /dev/null +++ b/parser/testdata/corpus/sql/cast/test_string_cast.test @@ -0,0 +1,165 @@ +# source: test/sql/cast/test_string_cast.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +SELECT (1=1)::VARCHAR, (1=0)::VARCHAR, NULL::BOOLEAN::VARCHAR +-- +ok +== +SELECT 1::TINYINT::VARCHAR, 12::TINYINT::VARCHAR, (-125)::TINYINT::VARCHAR +-- +ok +== +SELECT 1::SMALLINT::VARCHAR, 12442::SMALLINT::VARCHAR, (-32153)::SMALLINT::VARCHAR +-- +ok +== +SELECT 1::INTEGER::VARCHAR, 12442952::INTEGER::VARCHAR, (-2000000111)::INTEGER::VARCHAR +-- +ok +== +SELECT 1::BIGINT::VARCHAR, 1244295295289253::BIGINT::VARCHAR, (-2000000111551166)::BIGINT::VARCHAR +-- +ok +== +SELECT 2::FLOAT::VARCHAR, 0.5::FLOAT::VARCHAR, (-128.5)::FLOAT::VARCHAR +-- +ok +== +SELECT 2::DOUBLE::VARCHAR, 0.5::DOUBLE::VARCHAR, (-128.5)::DOUBLE::VARCHAR +-- +ok +== +SELECT '0xF'::INTEGER, '0x0'::INTEGER, '0xFEE'::INTEGER, '0xfee'::INTEGER, '0x00FEE'::INTEGER +-- +ok +== +SELECT '0x'::INT +-- +ok +== +SELECT '0X'::INT +-- +ok +== +SELECT '0xHELLO'::INT +-- +ok +== +SELECT '0xFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF'::INT +-- +ok +== +SELECT '0x7F'::TINYINT, '0x7FFF'::SMALLINT, '0x7FFFFFFF'::INT, '0x7FFFFFFFFFFFFFFF'::BIGINT +-- +ok +== +SELECT '0xFF'::UINT8, '0xFFFF'::UINT16, '0xFFFFFFFF'::UINT32, '0xFFFFFFFFFFFFFFFF'::UINT64 +-- +ok +== +SELECT '0x000000000000000000000000000000000000000000000000000000000000000000'::INT +-- +ok +== +SELECT '0x80'::TINYINT +-- +ok +== +SELECT '0x8000'::SMALLINT +-- +ok +== +SELECT '0x80000000'::INT +-- +ok +== +SELECT '0x8000000000000000'::BIGINT +-- +ok +== +SELECT '0x100'::UINT8 +-- +ok +== +SELECT '0x10000'::UINT16 +-- +ok +== +SELECT '0x100000000'::UINT32 +-- +ok +== +SELECT '0x10000000000000000'::UINT64 +-- +ok +== +SELECT TRY_CAST('0x80' AS TINYINT) +-- +ok +== +SELECT TRY_CAST('0x8000' AS SMALLINT) +-- +ok +== +SELECT TRY_CAST('0x80000000' AS INT) +-- +ok +== +SELECT TRY_CAST('0x8000000000000000' AS BIGINT) +-- +ok +== +SELECT TRY_CAST('0x100' AS UINT8) +-- +ok +== +SELECT TRY_CAST('0x10000' AS UINT16) +-- +ok +== +SELECT TRY_CAST('0x100000000' AS UINT32) +-- +ok +== +SELECT TRY_CAST('0x10000000000000000' AS UINT64) +-- +ok +== +SELECT '0.5'::{inttype}; +-- +error: Parser Error: syntax error at or near "{" +== +SELECT '-0.5'::{inttype}; +-- +error: Parser Error: syntax error at or near "{" +== +SELECT '0x1e'::{inttype}; +-- +error: Parser Error: syntax error at or near "{" +== +SELECT '{hex}'::INT; +-- +ok +== +SELECT '0'::{inttype}; +-- +error: Parser Error: syntax error at or near "{" +== +SELECT ('infinity'::{ts})::VARCHAR +-- +error: Parser Error: syntax error at or near "{" +== +SELECT ('-infinity'::{ts})::VARCHAR +-- +error: Parser Error: syntax error at or near "{" +== +SELECT TRY_CAST('infinity' AS {ts}) +-- +error: Parser Error: syntax error at or near "{" +== +SELECT TRY_CAST('-infinity' AS {ts}) +-- +error: Parser Error: syntax error at or near "{" +== diff --git a/parser/testdata/corpus/sql/cast/test_try_cast.test b/parser/testdata/corpus/sql/cast/test_try_cast.test new file mode 100644 index 0000000..3bc0f8a --- /dev/null +++ b/parser/testdata/corpus/sql/cast/test_try_cast.test @@ -0,0 +1,37 @@ +# source: test/sql/cast/test_try_cast.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +SELECT TRY_CAST('hello' as INTEGER) +-- +ok +== +SELECT CAST('hello' as INTEGER) +-- +ok +== +SELECT TRY_CAST(3 as BIGINT), CAST(3 AS BIGINT), TRY_CAST(2 as BIGINT), CAST(3 AS INTEGER) +-- +ok +== +CREATE TABLE try_cast(try_cast INTEGER); +-- +ok +== +INSERT INTO try_cast VALUES (3); +-- +ok +== +SELECT try_cast FROM try_cast; +-- +ok +== +SELECT try_cast(try_cast as bigint) FROM try_cast; +-- +ok +== +SELECT try_cast(try_cast(try_cast as integer) as integer) FROM try_cast; +-- +ok +== diff --git a/parser/testdata/corpus/sql/cast/timestamp_casts.test b/parser/testdata/corpus/sql/cast/timestamp_casts.test new file mode 100644 index 0000000..1f73a8a --- /dev/null +++ b/parser/testdata/corpus/sql/cast/timestamp_casts.test @@ -0,0 +1,119 @@ +# source: test/sql/cast/timestamp_casts.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +CREATE TABLE tss AS + FROM VALUES ('2026-04-09 11:48:07.123456'::TIMESTAMP) tbl(t); +-- +ok +== +select t::TIMESTAMP_NS from tss; +-- +ok +== +select t::TIMESTAMP from tss; +-- +ok +== +select t::TIMESTAMP_MS from tss; +-- +ok +== +select t::TIMESTAMP_S from tss; +-- +ok +== +select t::DATE from tss; +-- +ok +== +SELECT TRY_CAST(TIMESTAMP '2262-04-11 23:47:16.854776' AS TIMESTAMP_NS); +-- +ok +== +SELECT CAST(TIMESTAMP '2262-04-11 23:47:16.854776' AS TIMESTAMP_NS); +-- +ok +== +SELECT CAST(TIMESTAMP '2262-04-11 23:47:16.854776' AS TIMESTAMPTZ_NS); +-- +ok +== +SELECT CAST(TIMESTAMPTZ '2262-04-11 23:47:16.854776+00' AS TIMESTAMP_NS); +-- +ok +== +SELECT CAST(TIMESTAMP_MS '2262-04-11 23:47:16.855' AS TIMESTAMP_NS); +-- +ok +== +SELECT CAST(TIMESTAMP_MS '2262-04-11 23:47:16.855' AS TIMESTAMPTZ_NS); +-- +ok +== +SELECT CAST(TIMESTAMP_S '2262-04-12 00:00:00' AS TIMESTAMP_NS); +-- +ok +== +SELECT CAST(TIMESTAMP_S '2262-04-12 00:00:00' AS TIMESTAMPTZ_NS); +-- +ok +== +SELECT CAST(TIMESTAMP 'infinity' AS TIME); +-- +ok +== +SELECT CAST(TIMESTAMP 'infinity' AS TIMETZ); +-- +ok +== +SELECT CAST(TIMESTAMPTZ 'infinity' AS TIMETZ); +-- +ok +== +SELECT CAST('infinity'::TIMESTAMPTZ_NS AS TIMETZ); +-- +ok +== +SELECT CAST(TIMESTAMP_MS 'infinity' AS TIME); +-- +ok +== +SELECT CAST('infinity'::TIMESTAMP_NS AS TIME); +-- +ok +== +SELECT CAST(TIMESTAMP_S 'infinity' AS TIME); +-- +ok +== +SELECT CAST('infinity'::TIMESTAMP_NS AS TIME_NS); +-- +ok +== +SELECT + CAST('1970-01-01 23:59:59.999999999'::TIMESTAMP_NS AS DATE), + TRY_CAST('1970-01-01 23:59:59.999999999'::TIMESTAMP_NS AS DATE) +-- +ok +== +SELECT + TRY_CAST(TIMESTAMP 'infinity' AS TIME) IS NULL, + TRY_CAST(TIMESTAMP 'infinity' AS TIMETZ) IS NULL, + TRY_CAST(TIMESTAMPTZ 'infinity' AS TIMETZ) IS NULL, + TRY_CAST('infinity'::TIMESTAMP_NS AS TIME) IS NULL, + TRY_CAST('infinity'::TIMESTAMP_NS AS TIME_NS) IS NULL, + TRY_CAST('infinity'::TIMESTAMPTZ_NS AS TIMETZ) IS NULL, + TRY_CAST(TIMESTAMPTZ '2262-04-11 23:47:16.854776+00' AS TIMESTAMP_NS) IS NULL, + TRY_CAST(TIMESTAMP_MS '2262-04-11 23:47:16.855' AS TIMESTAMP_NS) IS NULL, + TRY_CAST(TIMESTAMP_S '2262-04-12 00:00:00' AS TIMESTAMP_NS) IS NULL +-- +ok +== +SELECT + CAST('1970-01-01 23:59:59.999999999+00'::TIMESTAMPTZ_NS AS TIMETZ), + TRY_CAST('1970-01-01 23:59:59.999999999+00'::TIMESTAMPTZ_NS AS TIMETZ) +-- +ok +== diff --git a/parser/testdata/corpus/sql/cast/timestamp_date_cast.test b/parser/testdata/corpus/sql/cast/timestamp_date_cast.test new file mode 100644 index 0000000..5187414 --- /dev/null +++ b/parser/testdata/corpus/sql/cast/timestamp_date_cast.test @@ -0,0 +1,32 @@ +# source: test/sql/cast/timestamp_date_cast.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +create table test as +select '2021-02-04 19:30:00'::timestamp t; +-- +ok +== +select * +from test +where (t::date) = '2021-02-04'::date; +-- +ok +== +select * +from test +where (t::date) = '2021-02-04'; +-- +ok +== +WITH t AS ( + SELECT + '2020-09-13 00:30:00'::{source} AS a, +) +SELECT + a::DATE = '2020-09-13'::DATE, +FROM t; +-- +error: Parser Error: syntax error at or near "{" +== diff --git a/parser/testdata/corpus/sql/cast/union_cast.test b/parser/testdata/corpus/sql/cast/union_cast.test new file mode 100644 index 0000000..d6eef38 --- /dev/null +++ b/parser/testdata/corpus/sql/cast/union_cast.test @@ -0,0 +1,21 @@ +# source: test/sql/cast/union_cast.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +CREATE TABLE t1 (i UNION(a INT)); +-- +ok +== +INSERT INTO t1 VALUES (1),(2),(3); +-- +ok +== +SELECT i::UNION(a UNION(a INT)) FROM t1; +-- +ok +== +SELECT (i::UNION(a INT, b UNION(a INT))).a FROM t1; +-- +ok +== diff --git a/parser/testdata/corpus/sql/catalog/case_insensitive_alter.test b/parser/testdata/corpus/sql/catalog/case_insensitive_alter.test new file mode 100644 index 0000000..45c3ad0 --- /dev/null +++ b/parser/testdata/corpus/sql/catalog/case_insensitive_alter.test @@ -0,0 +1,45 @@ +# source: test/sql/catalog/case_insensitive_alter.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +CREATE TABLE "MyTable"(i integer, "BigColumn" integer); +-- +ok +== +ALTER TABLE MyTable ALTER BIGCOLUMN SET DATA TYPE VARCHAR +-- +ok +== +ALTER TABLE MyTable DROP COLUMN BIGCOLUMN; +-- +ok +== +SELECT BIGCOLUMN FROM MyTable +-- +ok +== +ALTER TABLE MyTable ADD COLUMN "BIGCOLUMN" VARCHAR; +-- +ok +== +ALTER TABLE MyTable ALTER COLUMN BIGCOLUMN SET DEFAULT 3 +-- +ok +== +INSERT INTO MyTable(BIGCOLUMN) VALUES (DEFAULT) +-- +ok +== +ALTER TABLE MyTable ALTER COLUMN BIGCOLUMN DROP DEFAULT +-- +ok +== +ALTER TABLE MyTable RENAME BIGCOLUMN TO "SmallColumn" +-- +ok +== +SELECT SmallColumn FROM MyTable +-- +ok +== diff --git a/parser/testdata/corpus/sql/catalog/case_insensitive_binder.test b/parser/testdata/corpus/sql/catalog/case_insensitive_binder.test new file mode 100644 index 0000000..2b0de1f --- /dev/null +++ b/parser/testdata/corpus/sql/catalog/case_insensitive_binder.test @@ -0,0 +1,61 @@ +# source: test/sql/catalog/case_insensitive_binder.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +CREATE TABLE "MyTable"(i integer); +-- +ok +== +SELECT * FROM mytable; +-- +ok +== +SELECT * FROM MyTable; +-- +ok +== +SELECT * FROM "MyTable"; +-- +ok +== +ALTER TABLE MyTable ADD COLUMN j INTEGER; +-- +ok +== +ALTER TABLE MyTable RENAME TO "MyOtherTable" +-- +ok +== +DROP TABLE MyOtherTable; +-- +ok +== +CREATE TABLE "ABC"(i integer); +-- +ok +== +CREATE TABLE "AbC"(i integer); +-- +ok +== +SELECT * FROM "ABC"; +-- +ok +== +SELECT * FROM abc; -- error: which table did I mean? +-- +ok +== +ALTER TABLE abc ADD COLUMN j INTEGER; +-- +ok +== +ALTER TABLE "ABC" ADD COLUMN "J" INTEGER; +-- +ok +== +DROP TABLE abc +-- +ok +== diff --git a/parser/testdata/corpus/sql/catalog/case_insensitive_caps.test b/parser/testdata/corpus/sql/catalog/case_insensitive_caps.test new file mode 100644 index 0000000..1e715b5 --- /dev/null +++ b/parser/testdata/corpus/sql/catalog/case_insensitive_caps.test @@ -0,0 +1,29 @@ +# source: test/sql/catalog/case_insensitive_caps.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +CREATE TABLE mytable(mycolumn INTEGER, myothercolumn INTEGER); +-- +ok +== +SELECT "MYCOLUMN" FROM "MYTABLE"; +-- +ok +== +ALTER TABLE "MYTABLE" DROP COLUMN "MYCOLUMN"; +-- +ok +== +ALTER TABLE "MYTABLE" ADD COLUMN mycolumn INTEGER; +-- +ok +== +ALTER TABLE "MYTABLE" ALTER COLUMN "MYCOLUMN" SET DEFAULT 3 +-- +ok +== +DROP TABLE "MYTABLE" +-- +ok +== diff --git a/parser/testdata/corpus/sql/catalog/case_insensitive_cte.test b/parser/testdata/corpus/sql/catalog/case_insensitive_cte.test new file mode 100644 index 0000000..09b0884 --- /dev/null +++ b/parser/testdata/corpus/sql/catalog/case_insensitive_cte.test @@ -0,0 +1,15 @@ +# source: test/sql/catalog/case_insensitive_cte.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +with cte AS (SELECT 42 "A") +select a from cte +-- +ok +== +with "CTE" AS (SELECT 42) +select * from cte +-- +ok +== diff --git a/parser/testdata/corpus/sql/catalog/case_insensitive_operations.test b/parser/testdata/corpus/sql/catalog/case_insensitive_operations.test new file mode 100644 index 0000000..ba2187c --- /dev/null +++ b/parser/testdata/corpus/sql/catalog/case_insensitive_operations.test @@ -0,0 +1,103 @@ +# source: test/sql/catalog/case_insensitive_operations.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +CREATE TABLE INTEGERS(I INTEGER); +-- +ok +== +INSERT INTO integers (i) VALUES (1), (2), (3), (NULL); +-- +ok +== +SELECT integers.i FROM integers ORDER BY i; +-- +ok +== +SELECT integers.i AS i FROM integers GROUP BY I ORDER BY "integers"."I"; +-- +ok +== +SELECT integers.i AS "ZZZ" FROM integers GROUP BY "zzz" ORDER BY "INTEGERS"."i"; +-- +ok +== +WITH "CTE"("ZZZ") AS ( + SELECT integers.i AS "ZZZ" FROM integers GROUP BY "zzz" +) +SELECT * FROM cte ORDER BY zZz; +-- +ok +== +WITH "CTE"("ZZZ") AS ( + SELECT integers.i AS "ZZZ" FROM integers GROUP BY "zzz" +), + "cte" AS (SELECT 42) +-- +error: Parser Error: syntax error at or near ")" +== +UPDATE integers SET i=integers.i+1 +-- +ok +== +SELECT i FROM integers ORDER BY integers.i; +-- +ok +== +DELETE FROM integers WHERE i IS NULL; +-- +ok +== +ALTER TABLE integers ADD COLUMN J INTEGER; +-- +ok +== +SELECT i, j FROM integers ORDER BY integers.i; +-- +ok +== +UPDATE integers SET j=integers.i; +-- +ok +== +ALTER TABLE integers DROP COLUMN i; +-- +ok +== +SELECT j FROM integers ORDER BY integers.j; +-- +ok +== +SELECT tbl.k FROM (SELECT j FROM integers) TBL(K) ORDER BY K; +-- +ok +== +CREATE TABLE STRUCTS(S ROW(I ROW(K INTEGER))); +-- +ok +== +INSERT INTO structs VALUES ({'i': {'k': 42}}); +-- +ok +== +SELECT structs.S.i.K, "STRUCTS"."S"."I"."K", "structs"."s"."i"."k" FROM structs +-- +ok +== +SELECT "STRUCTS"."S"."I"."K" FROM structs GROUP BY "STRUCTS"."S"."I"."K" +-- +ok +== +SELECT structs.S.i.K FROM structs GROUP BY structs.S.i.K +-- +ok +== +DROP TABLE structs; +-- +ok +== +PRAGMA preserve_identifier_case=false; +-- +ok +== diff --git a/parser/testdata/corpus/sql/catalog/case_insensitive_using.test b/parser/testdata/corpus/sql/catalog/case_insensitive_using.test new file mode 100644 index 0000000..7fea62c --- /dev/null +++ b/parser/testdata/corpus/sql/catalog/case_insensitive_using.test @@ -0,0 +1,161 @@ +# source: test/sql/catalog/case_insensitive_using.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +create table A as select 1 as "X", 2 as "Y"; +-- +ok +== +create table B as select 1 as "X", 3 as "Z"; +-- +ok +== +select * from A join B using(X); +-- +ok +== +select * from A join B using("X"); +-- +ok +== +DROP TABLE "A" +-- +ok +== +DROP TABLE "B" +-- +ok +== +create table B as select 1 as X, 3 as "Z"; +-- +ok +== +create table A as select 1 as "hello", 2 as x; +-- +ok +== +create table B as select 1 as "HELLO", 3 as x2; +-- +ok +== +create table C as select 1 as "hEllO", 4 as x3; +-- +ok +== +create table D as select 1 as "HElLo", 5 as x4; +-- +ok +== +create table E as select 1 as "heLLo", 6 as x5; +-- +ok +== +SELECT * FROM a JOIN b USING (hello) +-- +ok +== +SELECT * FROM a JOIN b USING (hello, "HELLO"); +-- +ok +== +SELECT * FROM a JOIN b USING (hello) JOIN c USING (hello) +-- +ok +== +SELECT * FROM a JOIN b USING (hello) JOIN c USING ("HELLO") +-- +ok +== +SELECT * FROM a JOIN b USING (hello) JOIN c USING (hello) JOIN d USING (hello) +-- +ok +== +SELECT * FROM a JOIN b USING ("HELLO") JOIN c USING ("HeLLo") JOIN d USING (hello) +-- +ok +== +SELECT * FROM a JOIN b USING (hello) JOIN c USING (hello) JOIN d USING (hello) JOIN e USING (hello) +-- +ok +== +SELECT * FROM a FULL OUTER JOIN b USING (hello) +-- +ok +== +SELECT * FROM a FULL OUTER JOIN b USING (hello) FULL OUTER JOIN c USING (hello) +-- +ok +== +SELECT * FROM a FULL OUTER JOIN b USING (hello) FULL OUTER JOIN c USING (hello) FULL OUTER JOIN d USING (hello) +-- +ok +== +SELECT * FROM a FULL OUTER JOIN b USING (hello) FULL OUTER JOIN c USING (hello) FULL OUTER JOIN d USING (hello) FULL OUTER JOIN e USING (hello) +-- +ok +== +SELECT * FROM a NATURAL JOIN b +-- +ok +== +SELECT * FROM a NATURAL JOIN b NATURAL JOIN c +-- +ok +== +SELECT * FROM a NATURAL JOIN b NATURAL JOIN c NATURAL JOIN d +-- +ok +== +SELECT * FROM a NATURAL JOIN b NATURAL JOIN c NATURAL JOIN d NATURAL JOIN e +-- +ok +== +SELECT * FROM (a NATURAL JOIN b NATURAL JOIN c) NATURAL JOIN (d NATURAL JOIN e) +-- +ok +== +SELECT * FROM a NATURAL FULL OUTER JOIN b +-- +ok +== +SELECT * FROM a NATURAL FULL OUTER JOIN b NATURAL FULL OUTER JOIN c +-- +ok +== +SELECT * FROM a NATURAL FULL OUTER JOIN b NATURAL FULL OUTER JOIN c NATURAL FULL OUTER JOIN d +-- +ok +== +SELECT * FROM a NATURAL FULL OUTER JOIN b NATURAL FULL OUTER JOIN c NATURAL FULL OUTER JOIN d NATURAL FULL OUTER JOIN e +-- +ok +== +SELECT * FROM (a NATURAL FULL OUTER JOIN b NATURAL FULL OUTER JOIN c) NATURAL FULL OUTER JOIN (d NATURAL FULL OUTER JOIN e) +-- +ok +== +SELECT * FROM (SELECT 1 "hello", 2 "hello") NATURAL JOIN (SELECT 1 "hello", 2 "hello") +-- +ok +== +SELECT * FROM (SELECT 1 "hello", 2 "HeLlO") NATURAL JOIN (SELECT 1 "hello", 2 "HeLlO") +-- +ok +== +SELECT * FROM (SELECT 1 "hello", 2 "hello") t1, (SELECT 1 "hello", 2 "hello") t2 +-- +ok +== +SELECT * FROM (SELECT 1 "hello", 2 "hello") t1 JOIN (SELECT 1 "hello", 2 "hello") t2 USING (hello); +-- +ok +== +SELECT * FROM (SELECT 1 "hello", 2 "HeLlO") t1 JOIN (SELECT 1 "hello", 2 "HeLlO") t2 USING (hello); +-- +ok +== +SELECT hello FROM (a JOIN b USING (hello)), (d JOIN e USING (hello)) +-- +ok +== diff --git a/parser/testdata/corpus/sql/catalog/comment_on.test b/parser/testdata/corpus/sql/catalog/comment_on.test new file mode 100644 index 0000000..962a0f9 --- /dev/null +++ b/parser/testdata/corpus/sql/catalog/comment_on.test @@ -0,0 +1,245 @@ +# source: test/sql/catalog/comment_on.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +COMMENT ON TABLE test IS 1337 +-- +error: Parser Error: syntax error at or near "1337" +== +COMMENT ON TABLE hahahoehoe IS 'blablabloebloe' +-- +ok +== +COMMENT ON FUNCTION add IS 'foobar' +-- +ok +== +CREATE TABLE test_table as SELECT 1 as test_table_column +-- +ok +== +select comment from duckdb_tables() where table_name='test_table'; +-- +ok +== +COMMENT ON TABLE test_table IS 'very gezellige table' +-- +ok +== +ALTER TABLE test_table ADD COLUMN new_col INTEGER +-- +ok +== +ALTER TABLE test_table ALTER new_col SET DATA TYPE TINYINT +-- +ok +== +ALTER TABLE test_table ALTER COLUMN new_col SET DEFAULT 1 +-- +ok +== +ALTER TABLE test_table ALTER COLUMN new_col DROP DEFAULT +-- +ok +== +ALTER TABLE test_table RENAME COLUMN new_col TO new_col_2 +-- +ok +== +ALTER TABLE test_table DROP COLUMN new_col_2 +-- +ok +== +ALTER TABLE test_table RENAME TO test_table_2 +-- +ok +== +ALTER TABLE test_table_2 RENAME TO test_table +-- +ok +== +COMMENT ON TABLE test_table IS NULL +-- +ok +== +SELECT * FROM test_table +-- +ok +== +CREATE VIEW test_view as SELECT 1 as test_view_column +-- +ok +== +select comment from duckdb_views() where view_name='test_view'; +-- +ok +== +COMMENT ON VIEW test_view IS 'very gezellige view' +-- +ok +== +ALTER VIEW test_view RENAME TO test_view_2 +-- +ok +== +ALTER VIEW test_view_2 RENAME TO test_view +-- +ok +== +SELECT * FROM test_view +-- +ok +== +select comment from duckdb_columns() where column_name='test_view_column'; +-- +ok +== +COMMENT ON COLUMN test_view.test_view_column IS 'very gezellige viewcolumn' +-- +ok +== +DROP VIEW test_view +-- +ok +== +CREATE INDEX test_index ON test_table using art(test_table_column) +-- +ok +== +select comment from duckdb_indexes() where index_name='test_index'; +-- +ok +== +COMMENT ON INDEX test_index IS 'very gezellige index' +-- +ok +== +SELECT * FROM test_table WHERE test_table_column=1 +-- +ok +== +DROP INDEX test_index; +-- +ok +== +CREATE SEQUENCE test_sequence; +-- +ok +== +select comment from duckdb_sequences() where sequence_name='test_sequence'; +-- +ok +== +COMMENT ON SEQUENCE test_sequence IS 'very gezellige sequence' +-- +ok +== +SELECT nextval('test_sequence') +-- +ok +== +DROP SEQUENCE test_sequence +-- +ok +== +CREATE TYPE test_type AS int32; +-- +ok +== +select comment from duckdb_types() where type_name='test_type'; +-- +ok +== +COMMENT ON TYPE test_type IS 'very gezellige type' +-- +ok +== +SELECT 1::test_type as val; +-- +ok +== +DROP TYPE test_type +-- +ok +== +select comment from duckdb_columns() where column_name='test_table_column'; +-- +ok +== +COMMENT ON COLUMN test_table.test_table_column IS 'very gezellige column' +-- +ok +== +ALTER TABLE test_table RENAME COLUMN test_table_column TO test_table_column_renamed +-- +ok +== +select comment from duckdb_columns() where column_name='test_table_column_renamed'; +-- +ok +== +CREATE MACRO test_macro(a, b) AS a + b +-- +ok +== +select comment from duckdb_functions() where function_name='test_macro'; +-- +ok +== +COMMENT ON MACRO test_macro IS 'very gezellige macro' +-- +ok +== +SELECT test_macro(1,2); +-- +ok +== +DROP MACRO test_macro +-- +ok +== +CREATE FUNCTION test_function(a, b) AS a + b +-- +ok +== +select comment from duckdb_functions() where function_name='test_function'; +-- +ok +== +COMMENT ON FUNCTION test_function IS 'very gezellige function' +-- +ok +== +CREATE MACRO test_table_macro(a,b) as TABLE select a,b; +-- +ok +== +select comment from duckdb_functions() where function_name='test_table_macro'; +-- +ok +== +COMMENT ON MACRO TABLE test_table_macro IS 'very gezellige table macro' +-- +ok +== +from test_table_macro(1,2); +-- +ok +== +DROP MACRO TABLE test_table_macro +-- +ok +== +COMMENT ON DATABASE blabla IS 'bloebloe' +-- +ok +== +COMMENT ON SCHEMA blabla IS 'bloebloe' +-- +ok +== +DROP TABLE test_table +-- +ok +== diff --git a/parser/testdata/corpus/sql/catalog/comment_on_column.test b/parser/testdata/corpus/sql/catalog/comment_on_column.test new file mode 100644 index 0000000..2440225 --- /dev/null +++ b/parser/testdata/corpus/sql/catalog/comment_on_column.test @@ -0,0 +1,69 @@ +# source: test/sql/catalog/comment_on_column.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +CREATE VIEW test_view AS SELECT test_table_column as test_view_column FROM test_table; +-- +ok +== +COMMENT ON COLUMN test_view.test_view_column IS 'very gezellige view column' +-- +ok +== +SELECT database_name, table_name, column_name, comment FROM duckdb_columns() where internal is false +-- +ok +== +COMMENT ON COLUMN bla.bloe.blie.blo IS NULL +-- +ok +== +COMMENT ON COLUMN blie.blo IS NULL +-- +ok +== +COMMENT ON COLUMN test_view.test_table_column IS NULL +-- +ok +== +COMMENT ON COLUMN test_table.test_view_column IS NULL +-- +ok +== +CREATE TEMPORARY TABLE temp_comment_test(x INTEGER) +-- +ok +== +SELECT table_name, database_name, temporary FROM duckdb_tables() WHERE table_name='temp_comment_test' +-- +ok +== +COMMENT ON COLUMN temp_comment_test.x IS 'test comment' +-- +ok +== +CREATE VIEW aliased_view(c1, c2) AS SELECT 1, 2; +-- +ok +== +COMMENT ON COLUMN aliased_view.c1 IS 'comment on aliased column' +-- +ok +== +SELECT column_name, comment FROM duckdb_columns() WHERE table_name='aliased_view' AND column_name='c1'; +-- +ok +== +COMMENT ON COLUMN aliased_view.c2 IS 'second aliased column comment' +-- +ok +== +SELECT column_name, comment FROM duckdb_columns() WHERE table_name='aliased_view' ORDER BY column_index; +-- +ok +== +COMMENT ON COLUMN aliased_view.nonexistent IS 'bad' +-- +ok +== diff --git a/parser/testdata/corpus/sql/catalog/comment_on_dependencies.test b/parser/testdata/corpus/sql/catalog/comment_on_dependencies.test new file mode 100644 index 0000000..e06aed2 --- /dev/null +++ b/parser/testdata/corpus/sql/catalog/comment_on_dependencies.test @@ -0,0 +1,57 @@ +# source: test/sql/catalog/comment_on_dependencies.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +CREATE TABLE t1 AS SELECT 1 as c1 +-- +ok +== +CREATE INDEX test_index ON t1 using art(c1) +-- +ok +== +COMMENT ON TABLE t1 IS 'very niceee' +-- +ok +== +CREATE TABLE a (i INTEGER) +-- +ok +== +CREATE VIEW b AS SELECT i::STRING AS j FROM a +-- +ok +== +COMMENT ON TABLE a IS 'a table' +-- +ok +== +COMMENT ON COLUMN a.i IS 'a column' +-- +ok +== +COMMENT ON VIEW b IS 'a view' +-- +ok +== +COMMENT ON COLUMN b.j IS 'a column' +-- +ok +== +select comment from duckdb_columns() where column_name='i'; +-- +ok +== +select comment from duckdb_tables() where table_name='a'; +-- +ok +== +select comment from duckdb_views() where view_name='b'; +-- +ok +== +select comment from duckdb_columns() where column_name='j'; +-- +ok +== diff --git a/parser/testdata/corpus/sql/catalog/comment_on_extended.test b/parser/testdata/corpus/sql/catalog/comment_on_extended.test new file mode 100644 index 0000000..424af97 --- /dev/null +++ b/parser/testdata/corpus/sql/catalog/comment_on_extended.test @@ -0,0 +1,129 @@ +# source: test/sql/catalog/comment_on_extended.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +ATTACH '{TEST_DIR}/comment_on_extended_1.db' AS db1 +-- +ok +== +ATTACH '{TEST_DIR}/comment_on_extended_2.db' AS db2 +-- +ok +== +CREATE SCHEMA db2.s2; +-- +ok +== +CREATE TABLE db1.s1.t1 AS SELECT 1 as c1 +-- +ok +== +CREATE TABLE db2.s2.t2 AS SELECT 2 as c2 +-- +ok +== +CREATE TABLE db1.s1.t3 AS SELECT 3 as c3 +-- +ok +== +CREATE TABLE db2.s2.t4 AS SELECT 4 as c4 +-- +ok +== +CREATE INDEX test_index ON db1.s1.t3 using art(c3) +-- +ok +== +CREATE INDEX test_index ON db2.s2.t4 using art(c4) +-- +ok +== +SELECT count(*) from duckdb_tables() where comment IS NOT NULL; +-- +ok +== +SELECT count(*) from duckdb_columns() where comment IS NOT NULL; +-- +ok +== +COMMENT ON TABLE db1.s1.t1 IS 'very gezellige table 1' +-- +ok +== +select comment from duckdb_tables() where table_name='t1'; +-- +ok +== +USE db2.s2 +-- +ok +== +COMMENT ON TABLE t2 IS 'very gezellige table 2' +-- +ok +== +select comment from duckdb_tables() where table_name='t2'; +-- +ok +== +COMMENT ON TABLE db2.t2 IS 'another very gezellige table 2' +-- +ok +== +COMMENT ON TABLE s2.t2 IS 'yet another very gezellige table 2' +-- +ok +== +COMMENT ON INDEX db1.s1.test_index IS 'very gezellige index 1' +-- +ok +== +select comment from duckdb_indexes() where index_name='test_index' and database_name='db1'; +-- +ok +== +COMMENT ON INDEX db2.test_index IS 'very gezellige index 2' +-- +ok +== +select database_name, schema_name, comment from duckdb_indexes() where index_name='test_index' order by comment; +-- +ok +== +COMMENT ON COLUMN col1 IS 'no bueno' +-- +error: Parser Error: Invalid column reference: 'col1' +== +COMMENT ON COLUMN galaxy.db.schema.table.col1 IS 'no bueno' +-- +error: Parser Error: Too many qualifications found - expected [catalog.schema.name] or [schema.name] +== +COMMENT ON COLUMN table_blablabla.col1 IS 'bla' +-- +ok +== +COMMENT ON COLUMN db1.s1.t1.c1 IS 'very gezellige column 1' +-- +ok +== +select database_name, schema_name, table_name, comment from duckdb_columns() where column_name='c1' order by comment; +-- +ok +== +COMMENT ON COLUMN db2.t2.c2 IS 'very gezellige column 2' +-- +ok +== +select database_name, schema_name, table_name, comment from duckdb_columns() where column_name='c2' order by comment; +-- +ok +== +COMMENT ON COLUMN s2.t2.c2 IS 'another very gezellige column 2' +-- +ok +== +COMMENT ON COLUMN t2.c2 IS 'yet another very gezellige column 2' +-- +ok +== diff --git a/parser/testdata/corpus/sql/catalog/comment_on_extended.test.metadata.json b/parser/testdata/corpus/sql/catalog/comment_on_extended.test.metadata.json new file mode 100644 index 0000000..c12ea5f --- /dev/null +++ b/parser/testdata/corpus/sql/catalog/comment_on_extended.test.metadata.json @@ -0,0 +1,6 @@ +{ + "todo": { + "56b2cf63d0c96a20": "transformer-raised parser error: upstream rejects in the transformer, not the grammar; expected to clear as transformers land (milestones 3-5)", + "f1aa3d9bed842ca3": "transformer-raised parser error: upstream rejects in the transformer, not the grammar; expected to clear as transformers land (milestones 3-5)" + } +} diff --git a/parser/testdata/corpus/sql/catalog/comment_on_pg_description.test b/parser/testdata/corpus/sql/catalog/comment_on_pg_description.test new file mode 100644 index 0000000..e89005a --- /dev/null +++ b/parser/testdata/corpus/sql/catalog/comment_on_pg_description.test @@ -0,0 +1,125 @@ +# source: test/sql/catalog/comment_on_pg_description.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +CREATE TABLE test AS SELECT 1 as a; +-- +ok +== +COMMENT ON TABLE test IS 'comment-1' +-- +ok +== +COMMENT ON COLUMN test.a IS 'comment-2' +-- +ok +== +CREATE VIEW test_view AS FROM test; +-- +ok +== +COMMENT ON COLUMN test_view.a IS 'comment-2.5' +-- +ok +== +CREATE INDEX test_index ON test(a) +-- +ok +== +COMMENT ON VIEW test_view IS 'comment-3' +-- +ok +== +COMMENT ON INDEX test_index IS 'comment-4' +-- +ok +== +COMMENT ON SEQUENCE seq IS 'comment-5' +-- +ok +== +COMMENT ON TYPE test_type IS 'comment-6' +-- +ok +== +COMMENT ON MACRO TABLE test_table_macro IS 'comment-7' +-- +ok +== +COMMENT ON MACRO test_function IS 'comment-8' +-- +ok +== +SELECT ddb.comment, pg.description +FROM duckdb_tables AS ddb +LEFT JOIN pg_description AS pg + ON pg.classoid=ddb.database_oid AND pg.objoid=ddb.table_oid +WHERE pg.objsubid=0 AND ddb.table_name='test' +-- +ok +== +SELECT ddb.comment, pg.description +FROM duckdb_columns AS ddb +LEFT JOIN pg_description AS pg + ON pg.classoid=ddb.database_oid AND pg.objoid=ddb.table_oid +WHERE pg.objsubid=1 AND ddb.table_name='test' +-- +ok +== +SELECT ddb.comment, pg.description +FROM duckdb_columns AS ddb +LEFT JOIN pg_description AS pg + ON pg.classoid=ddb.database_oid AND pg.objoid=ddb.table_oid +WHERE pg.objsubid=1 AND ddb.table_name='test_view' +-- +ok +== +SELECT ddb.comment, pg.description +FROM duckdb_views AS ddb +LEFT JOIN pg_description AS pg + ON pg.classoid=ddb.database_oid AND pg.objoid=ddb.view_oid +WHERE pg.objsubid=0 AND ddb.view_name='test_view' +-- +ok +== +SELECT ddb.comment, pg.description +FROM duckdb_indexes AS ddb +LEFT JOIN pg_description AS pg + ON pg.classoid=ddb.database_oid AND pg.objoid=ddb.index_oid +WHERE ddb.index_name='test_index' +-- +ok +== +SELECT ddb.comment, pg.description +FROM duckdb_sequences() AS ddb +LEFT JOIN pg_description AS pg + ON pg.classoid=ddb.database_oid AND pg.objoid=ddb.sequence_oid +WHERE ddb.sequence_name='seq' +-- +ok +== +SELECT ddb.comment, pg.description +FROM duckdb_types() AS ddb +LEFT JOIN pg_description AS pg + ON pg.classoid=ddb.database_oid AND pg.objoid=ddb.type_oid +WHERE ddb.type_name='test_type' +-- +ok +== +SELECT ddb.comment, pg.description +FROM duckdb_functions() AS ddb +LEFT JOIN pg_description AS pg + ON pg.classoid=ddb.database_oid AND pg.objoid=ddb.function_oid +WHERE ddb.function_name='test_table_macro' +-- +ok +== +SELECT ddb.comment, pg.description +FROM duckdb_functions() AS ddb +LEFT JOIN pg_description AS pg + ON pg.classoid=ddb.database_oid AND pg.objoid=ddb.function_oid +WHERE ddb.function_name='test_function' +-- +ok +== diff --git a/parser/testdata/corpus/sql/catalog/comment_on_wal.test b/parser/testdata/corpus/sql/catalog/comment_on_wal.test new file mode 100644 index 0000000..3bf1254 --- /dev/null +++ b/parser/testdata/corpus/sql/catalog/comment_on_wal.test @@ -0,0 +1,9 @@ +# source: test/sql/catalog/comment_on_wal.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +SET checkpoint_threshold = '10.0 GB'; +-- +ok +== diff --git a/parser/testdata/corpus/sql/catalog/dependencies/add_column_to_table_referenced_by_fk.test b/parser/testdata/corpus/sql/catalog/dependencies/add_column_to_table_referenced_by_fk.test new file mode 100644 index 0000000..cf08706 --- /dev/null +++ b/parser/testdata/corpus/sql/catalog/dependencies/add_column_to_table_referenced_by_fk.test @@ -0,0 +1,36 @@ +# source: test/sql/catalog/dependencies/add_column_to_table_referenced_by_fk.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +create table tbl(a varchar primary key); +-- +ok +== +create table tbl2( + a varchar, + foreign key (a) references tbl(a) +) +-- +ok +== +insert into tbl values('abc'); +-- +ok +== +insert into tbl2 values ('abc'); +-- +ok +== +alter table tbl add column b integer default 5; +-- +ok +== +select * from tbl; +-- +ok +== +select * from tbl2; +-- +ok +== diff --git a/parser/testdata/corpus/sql/catalog/dependencies/add_column_to_table_referenced_by_macro.test b/parser/testdata/corpus/sql/catalog/dependencies/add_column_to_table_referenced_by_macro.test new file mode 100644 index 0000000..aa04a62 --- /dev/null +++ b/parser/testdata/corpus/sql/catalog/dependencies/add_column_to_table_referenced_by_macro.test @@ -0,0 +1,21 @@ +# source: test/sql/catalog/dependencies/add_column_to_table_referenced_by_macro.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +create table tbl(a varchar default 'abc'); +-- +ok +== +insert into tbl values(DEFAULT); +-- +ok +== +create macro mcr() as table select * from tbl; +-- +ok +== +select * from mcr(); +-- +ok +== diff --git a/parser/testdata/corpus/sql/catalog/dependencies/add_column_to_table_referenced_by_view.test b/parser/testdata/corpus/sql/catalog/dependencies/add_column_to_table_referenced_by_view.test new file mode 100644 index 0000000..b869380 --- /dev/null +++ b/parser/testdata/corpus/sql/catalog/dependencies/add_column_to_table_referenced_by_view.test @@ -0,0 +1,13 @@ +# source: test/sql/catalog/dependencies/add_column_to_table_referenced_by_view.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +create view vw as select * from tbl; +-- +ok +== +select * from vw; +-- +ok +== diff --git a/parser/testdata/corpus/sql/catalog/dependencies/change_type_of_table_column_referenced_by_index.test b/parser/testdata/corpus/sql/catalog/dependencies/change_type_of_table_column_referenced_by_index.test new file mode 100644 index 0000000..882096f --- /dev/null +++ b/parser/testdata/corpus/sql/catalog/dependencies/change_type_of_table_column_referenced_by_index.test @@ -0,0 +1,17 @@ +# source: test/sql/catalog/dependencies/change_type_of_table_column_referenced_by_index.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +create table tbl(a varchar, b integer); +-- +ok +== +create index idx on tbl(a); +-- +ok +== +alter table tbl alter a set type integer; +-- +ok +== diff --git a/parser/testdata/corpus/sql/catalog/dependencies/drop_recreate_schema_dependency.test b/parser/testdata/corpus/sql/catalog/dependencies/drop_recreate_schema_dependency.test new file mode 100644 index 0000000..23920ca --- /dev/null +++ b/parser/testdata/corpus/sql/catalog/dependencies/drop_recreate_schema_dependency.test @@ -0,0 +1,33 @@ +# source: test/sql/catalog/dependencies/drop_recreate_schema_dependency.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +CREATE TABLE documents(id VARCHAR, body VARCHAR); +-- +ok +== +INSERT INTO documents VALUES ('d1', 'hello world'); +-- +ok +== +DROP SCHEMA IF EXISTS idx CASCADE +-- +ok +== +CREATE SCHEMA idx +-- +ok +== +CREATE MACRO idx.tokenize(s) AS string_split(s, ' ') +-- +ok +== +CREATE TABLE idx.terms AS SELECT unnest(idx.tokenize(body)) AS term FROM documents +-- +ok +== +SELECT count(*) FROM idx.terms +-- +ok +== diff --git a/parser/testdata/corpus/sql/catalog/dependencies/remove_table_column_referenced_by_index.test b/parser/testdata/corpus/sql/catalog/dependencies/remove_table_column_referenced_by_index.test new file mode 100644 index 0000000..40fdf97 --- /dev/null +++ b/parser/testdata/corpus/sql/catalog/dependencies/remove_table_column_referenced_by_index.test @@ -0,0 +1,9 @@ +# source: test/sql/catalog/dependencies/remove_table_column_referenced_by_index.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +alter table tbl drop column a; +-- +ok +== diff --git a/parser/testdata/corpus/sql/catalog/dependencies/rename_table_column_referenced_by_index.test b/parser/testdata/corpus/sql/catalog/dependencies/rename_table_column_referenced_by_index.test new file mode 100644 index 0000000..538fad2 --- /dev/null +++ b/parser/testdata/corpus/sql/catalog/dependencies/rename_table_column_referenced_by_index.test @@ -0,0 +1,13 @@ +# source: test/sql/catalog/dependencies/rename_table_column_referenced_by_index.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +create table tbl(a varchar); +-- +ok +== +alter table tbl rename a to b; +-- +ok +== diff --git a/parser/testdata/corpus/sql/catalog/dependencies/rename_view_referenced_by_table_macro.test b/parser/testdata/corpus/sql/catalog/dependencies/rename_view_referenced_by_table_macro.test new file mode 100644 index 0000000..20a7abf --- /dev/null +++ b/parser/testdata/corpus/sql/catalog/dependencies/rename_view_referenced_by_table_macro.test @@ -0,0 +1,21 @@ +# source: test/sql/catalog/dependencies/rename_view_referenced_by_table_macro.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +create table tbl (a varchar); +-- +ok +== +create macro static_table() as table select * from vw; +-- +ok +== +alter view vw rename to vw2; +-- +ok +== +select * from static_table(); +-- +ok +== diff --git a/parser/testdata/corpus/sql/catalog/dependencies/set_default_of_table_column_referenced_by_index.test b/parser/testdata/corpus/sql/catalog/dependencies/set_default_of_table_column_referenced_by_index.test new file mode 100644 index 0000000..4153e50 --- /dev/null +++ b/parser/testdata/corpus/sql/catalog/dependencies/set_default_of_table_column_referenced_by_index.test @@ -0,0 +1,21 @@ +# source: test/sql/catalog/dependencies/set_default_of_table_column_referenced_by_index.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +alter table tbl alter a set default 'test'; +-- +ok +== +insert into tbl(b) values (1); +-- +ok +== +select a, b from tbl; +-- +ok +== +alter table tbl alter a drop default; +-- +ok +== diff --git a/parser/testdata/corpus/sql/catalog/dependencies/test_alter_dependency_ownership.test b/parser/testdata/corpus/sql/catalog/dependencies/test_alter_dependency_ownership.test new file mode 100644 index 0000000..cf6226d --- /dev/null +++ b/parser/testdata/corpus/sql/catalog/dependencies/test_alter_dependency_ownership.test @@ -0,0 +1,235 @@ +# source: test/sql/catalog/dependencies/test_alter_dependency_ownership.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +CREATE SEQUENCE sequence1; +-- +ok +== +CREATE TABLE tablename ( + colname integer +); +-- +ok +== +ALTER SEQUENCE sequence1 OWNED BY tablename; +-- +ok +== +DROP TABLE tablename; +-- +ok +== +SELECT nextval('sequence1'); +-- +ok +== +CREATE SEQUENCE main.sequence1; +-- +ok +== +CREATE TABLE main.tablename ( + colname integer +); +-- +ok +== +ALTER SEQUENCE main.sequence1 OWNED BY main.tablename; +-- +ok +== +DROP TABLE main.tablename; +-- +ok +== +SELECT nextval('main.sequence1'); +-- +ok +== +DROP SEQUENCE sequence1 CASCADE; +-- +ok +== +SELECT * FROM tablename; +-- +ok +== +DROP SEQUENCE sequence1; +-- +ok +== +CREATE TABLE tablename2 ( + colname integer +); +-- +ok +== +ALTER SEQUENCE sequence1 OWNED BY tablename OWNED BY tablename2; +-- +error: Parser Error: Owned by value should be passed at most once +== +ALTER SEQUENCE sequence1 OWNED BY tablename2; +-- +ok +== +DROP TABLE tablename2; +-- +ok +== +CREATE SEQUENCE sequence2; +-- +ok +== +CREATE SEQUENCE sequence3; +-- +ok +== +ALTER SEQUENCE sequence2 OWNED BY tablename; +-- +ok +== +ALTER SEQUENCE sequence3 OWNED BY tablename; +-- +ok +== +SELECT nextval('sequence2'); +-- +ok +== +SELECT nextval('sequence3'); +-- +ok +== +CREATE TABLE tablename ( + colname integer DEFAULT nextval('sequence1'), + colname2 integer DEFAULT nextval('sequence2'), + colname3 integer, + colname4 float, + colname5 string +); +-- +ok +== +INSERT INTO tablename VALUES(default, default, 10, 2.0, 'aaaa'); +-- +ok +== +INSERT INTO tablename VALUES(default, default, 20, 3.0, 'bbbb'); +-- +ok +== +SELECT colname, colname2, colname3, colname4, colname5 FROM tablename; +-- +ok +== +DROP SEQUENCE sequence2; +-- +ok +== +ALTER TABLE tablename RENAME TO new_tablename; +-- +ok +== +CREATE OR REPLACE SEQUENCE sequence1; +-- +ok +== +ALTER SEQUENCE sequence1 OWNED BY new_tablename; +-- +ok +== +DROP TABLE new_tablename; +-- +ok +== +ALTER TABLE tablename ADD COLUMN colname2 integer DEFAULT nextval('sequence1') +-- +ok +== +CREATE TABLE tablename ( + colname integer, + colname2 integer DEFAULT nextval('sequence1') +); +-- +ok +== +ALTER TABLE tablename DROP colname2; +-- +ok +== +CREATE TABLE tablename ( + colname integer DEFAULT nextval('sequence1') +); +-- +ok +== +ALTER TABLE tablename ALTER colname TYPE float; +-- +ok +== +CREATE TABLE tablename ( + colname integer DEFAULT nextval('sequence1'), + colname2 integer DEFAULT nextval('sequence1'), + colname3 integer DEFAULT nextval('sequence1'), + colname4 integer DEFAULT nextval('sequence1') +); +-- +ok +== +ALTER TABLE tablename DROP colname4; +-- +ok +== +ALTER TABLE tablename DROP colname3; +-- +ok +== +select nextval('sequence1'); +-- +ok +== +CREATE VIEW v1_sequence1(a) AS SELECT 42; +-- +ok +== +ALTER SEQUENCE sequence1 OWNED BY v1_sequence1; +-- +ok +== +DROP VIEW v1_sequence1; +-- +ok +== +ALTER SEQUENCE sequence1 OWNED BY sequence2; +-- +ok +== +ALTER SEQUENCE sequence2 OWNED BY sequence1; +-- +ok +== +CREATE SEQUENCE sequence4; +-- +ok +== +ALTER SEQUENCE sequence3 OWNED BY sequence2; +-- +ok +== +ALTER SEQUENCE sequence1 OWNED BY sequence3; +-- +ok +== +ALTER SEQUENCE sequence3 OWNED BY sequence4; +-- +ok +== +DROP SEQUENCE sequence4; +-- +ok +== +SELECT nextval('sequence4'); +-- +ok +== diff --git a/parser/testdata/corpus/sql/catalog/dependencies/test_alter_dependency_ownership.test.metadata.json b/parser/testdata/corpus/sql/catalog/dependencies/test_alter_dependency_ownership.test.metadata.json new file mode 100644 index 0000000..7639bbc --- /dev/null +++ b/parser/testdata/corpus/sql/catalog/dependencies/test_alter_dependency_ownership.test.metadata.json @@ -0,0 +1,5 @@ +{ + "todo": { + "65fba09c620dd863": "transformer-raised parser error: upstream rejects in the transformer, not the grammar; expected to clear as transformers land (milestones 3-5)" + } +} diff --git a/parser/testdata/corpus/sql/catalog/dependencies/test_alter_owned_by.test b/parser/testdata/corpus/sql/catalog/dependencies/test_alter_owned_by.test new file mode 100644 index 0000000..517e6da --- /dev/null +++ b/parser/testdata/corpus/sql/catalog/dependencies/test_alter_owned_by.test @@ -0,0 +1,37 @@ +# source: test/sql/catalog/dependencies/test_alter_owned_by.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +CREATE TABLE tbl1 ( + colname integer +); +-- +ok +== +CREATE TABLE tbl2 ( + colname integer +); +-- +ok +== +ALTER SEQUENCE sequence1 OWNED BY tbl1; +-- +ok +== +ALTER SEQUENCE sequence1 OWNED BY tbl2; +-- +ok +== +create sequence sequence3; +-- +ok +== +alter sequence sequence3 owned by sequence1 +-- +ok +== +DROP TABLE tbl1; +-- +ok +== diff --git a/parser/testdata/corpus/sql/catalog/dependencies/test_alter_owning_table.test b/parser/testdata/corpus/sql/catalog/dependencies/test_alter_owning_table.test new file mode 100644 index 0000000..1c71a7f --- /dev/null +++ b/parser/testdata/corpus/sql/catalog/dependencies/test_alter_owning_table.test @@ -0,0 +1,39 @@ +# source: test/sql/catalog/dependencies/test_alter_owning_table.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +create sequence seq; +-- +ok +== +create sequence other_seq; +-- +ok +== +create table tbl ( + a integer default nextval('other_seq') +); +-- +ok +== +alter sequence seq owned by tbl; +-- +ok +== +alter table tbl rename to tbl2; +-- +ok +== +drop sequence seq; +-- +ok +== +drop sequence other_seq; +-- +ok +== +drop table tbl2; +-- +ok +== diff --git a/parser/testdata/corpus/sql/catalog/dependencies/test_concurrent_alter.test b/parser/testdata/corpus/sql/catalog/dependencies/test_concurrent_alter.test new file mode 100644 index 0000000..efffad0 --- /dev/null +++ b/parser/testdata/corpus/sql/catalog/dependencies/test_concurrent_alter.test @@ -0,0 +1,17 @@ +# source: test/sql/catalog/dependencies/test_concurrent_alter.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +alter sequence seq owned by t2; +-- +ok +== +alter table t2 rename to t3; +-- +ok +== +alter table t3 rename to t2; +-- +ok +== diff --git a/parser/testdata/corpus/sql/catalog/dependencies/test_concurrent_drop.test b/parser/testdata/corpus/sql/catalog/dependencies/test_concurrent_drop.test new file mode 100644 index 0000000..4a9b45f --- /dev/null +++ b/parser/testdata/corpus/sql/catalog/dependencies/test_concurrent_drop.test @@ -0,0 +1,19 @@ +# source: test/sql/catalog/dependencies/test_concurrent_drop.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +create table tbl{i} ( + a integer default nextval('seq') +); +-- +error: Parser Error: syntax error at or near "{" +== +insert into tbl{i} VALUES(DEFAULT); +-- +error: Parser Error: syntax error at or near "{" +== +drop table tbl{i}; +-- +error: Parser Error: syntax error at or near "{" +== diff --git a/parser/testdata/corpus/sql/catalog/dependencies/test_concurrent_index_creation.test b/parser/testdata/corpus/sql/catalog/dependencies/test_concurrent_index_creation.test new file mode 100644 index 0000000..fc9b4df --- /dev/null +++ b/parser/testdata/corpus/sql/catalog/dependencies/test_concurrent_index_creation.test @@ -0,0 +1,25 @@ +# source: test/sql/catalog/dependencies/test_concurrent_index_creation.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +ATTACH '{TEST_DIR}/concurrent_index_creation.db' AS source; +-- +ok +== +CREATE TABLE IF NOT EXISTS source.tbl (i INT); +-- +ok +== +CREATE INDEX index{i} ON source.tbl (i); +-- +error: Parser Error: syntax error at or near "{" +== +DROP TABLE source.tbl; +-- +ok +== +DETACH source; +-- +ok +== diff --git a/parser/testdata/corpus/sql/catalog/dependencies/test_concurrent_schema_creation.test b/parser/testdata/corpus/sql/catalog/dependencies/test_concurrent_schema_creation.test new file mode 100644 index 0000000..2e5f8a0 --- /dev/null +++ b/parser/testdata/corpus/sql/catalog/dependencies/test_concurrent_schema_creation.test @@ -0,0 +1,25 @@ +# source: test/sql/catalog/dependencies/test_concurrent_schema_creation.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +create schema schema{i}; +-- +error: Parser Error: syntax error at or near "{" +== +create table schema{i}.tbl{i} (a integer); +-- +error: Parser Error: syntax error at or near "{" +== +drop schema schema{i}; +-- +error: Parser Error: syntax error at or near "{" +== +insert into schema{i}.tbl{i} VALUES(1); +-- +error: Parser Error: syntax error at or near "{" +== +drop table schema{i}.tbl{i}; +-- +error: Parser Error: syntax error at or near "{" +== diff --git a/parser/testdata/corpus/sql/catalog/dependencies/test_default_value_dependency.test b/parser/testdata/corpus/sql/catalog/dependencies/test_default_value_dependency.test new file mode 100644 index 0000000..06ccb2d --- /dev/null +++ b/parser/testdata/corpus/sql/catalog/dependencies/test_default_value_dependency.test @@ -0,0 +1,53 @@ +# source: test/sql/catalog/dependencies/test_default_value_dependency.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +CREATE TABLE integers(i INTEGER DEFAULT nextval('seq'), j INTEGER) +-- +ok +== +INSERT INTO integers (j) VALUES (1), (1), (1), (1), (1) +-- +ok +== +DROP SEQUENCE seq +-- +ok +== +DROP SEQUENCE seq CASCADE +-- +ok +== +CREATE SEQUENCE seq1 +-- +ok +== +CREATE SEQUENCE seq2 +-- +ok +== +CREATE TABLE integers(i INTEGER DEFAULT nextval('seq' || CAST(nextval('seq') AS VARCHAR)), j INTEGER) +-- +ok +== +CREATE TABLE integers(i INTEGER DEFAULT nextval('seq1') + nextval('seq2'), j INTEGER) +-- +ok +== +INSERT INTO integers (j) VALUES (1) +-- +ok +== +DROP SEQUENCE seq1 +-- +ok +== +DROP SEQUENCE seq2 +-- +ok +== +DROP SEQUENCE seq1 CASCADE +-- +ok +== diff --git a/parser/testdata/corpus/sql/catalog/dependencies/test_drop_column_sequence_dependency.test b/parser/testdata/corpus/sql/catalog/dependencies/test_drop_column_sequence_dependency.test new file mode 100644 index 0000000..340706b --- /dev/null +++ b/parser/testdata/corpus/sql/catalog/dependencies/test_drop_column_sequence_dependency.test @@ -0,0 +1,69 @@ +# source: test/sql/catalog/dependencies/test_drop_column_sequence_dependency.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +CREATE SEQUENCE seq2 START 1; +-- +ok +== +CREATE TABLE tbl3 (a INTEGER DEFAULT nextval('seq2'), b VARCHAR); +-- +ok +== +ALTER TABLE tbl3 DROP COLUMN a; +-- +ok +== +DROP SEQUENCE seq2; +-- +ok +== +DROP TABLE tbl3; +-- +ok +== +CREATE SEQUENCE seq3 START 1; +-- +ok +== +CREATE TABLE tbl4 (a INTEGER DEFAULT nextval('seq3'), b INTEGER DEFAULT nextval('seq3'), c VARCHAR); +-- +ok +== +ALTER TABLE tbl4 DROP COLUMN a; +-- +ok +== +DROP SEQUENCE seq3; +-- +ok +== +ALTER TABLE tbl4 DROP COLUMN b; +-- +ok +== +DROP TABLE tbl4; +-- +ok +== +CREATE SEQUENCE seq5 START 1; +-- +ok +== +CREATE TABLE tbl6 (a INTEGER DEFAULT nextval('seq5'), b VARCHAR); +-- +ok +== +ALTER TABLE tbl6 DROP COLUMN a; +-- +ok +== +DROP SEQUENCE seq5; +-- +ok +== +DROP TABLE tbl6; +-- +ok +== diff --git a/parser/testdata/corpus/sql/catalog/dependencies/test_drop_default_referencing_sequence.test b/parser/testdata/corpus/sql/catalog/dependencies/test_drop_default_referencing_sequence.test new file mode 100644 index 0000000..48d1ab4 --- /dev/null +++ b/parser/testdata/corpus/sql/catalog/dependencies/test_drop_default_referencing_sequence.test @@ -0,0 +1,51 @@ +# source: test/sql/catalog/dependencies/test_drop_default_referencing_sequence.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +set wal_autocheckpoint = '10gb'; +-- +ok +== +CREATE SEQUENCE seq_ledger_id START 1; +-- +ok +== +CREATE TABLE position_ledger( + id BIGINT DEFAULT nextval('seq_ledger_id'), + v VARCHAR +); +-- +ok +== +INSERT INTO position_ledger(v) VALUES + ('a'), + ('b'); +-- +ok +== +ALTER TABLE position_ledger ALTER COLUMN id DROP DEFAULT; +-- +ok +== +DROP SEQUENCE IF EXISTS seq_ledger_id; +-- +ok +== +checkpoint +-- +ok +== +ALTER TABLE position_ledger ALTER COLUMN id SET NOT NULL; +-- +ok +== +INSERT INTO position_ledger(id, v) VALUES + (99, 'c'); +-- +ok +== +checkpoint; +-- +ok +== diff --git a/parser/testdata/corpus/sql/catalog/dependencies/test_prepare_dependencies_transactions.test b/parser/testdata/corpus/sql/catalog/dependencies/test_prepare_dependencies_transactions.test new file mode 100644 index 0000000..9339dde --- /dev/null +++ b/parser/testdata/corpus/sql/catalog/dependencies/test_prepare_dependencies_transactions.test @@ -0,0 +1,25 @@ +# source: test/sql/catalog/dependencies/test_prepare_dependencies_transactions.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +INSERT INTO integers VALUES (1), (2), (3), (4), (5) +-- +ok +== +PREPARE v AS SELECT SUM(i) FROM integers +-- +ok +== +DROP TABLE integers CASCADE +-- +ok +== +EXECUTE v +-- +ok +== +DROP TABLE integers +-- +ok +== diff --git a/parser/testdata/corpus/sql/catalog/dependencies/test_prepared_dependency.test b/parser/testdata/corpus/sql/catalog/dependencies/test_prepared_dependency.test new file mode 100644 index 0000000..8641ae6 --- /dev/null +++ b/parser/testdata/corpus/sql/catalog/dependencies/test_prepared_dependency.test @@ -0,0 +1,13 @@ +# source: test/sql/catalog/dependencies/test_prepared_dependency.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +PREPARE v AS SELECT * FROM integers +-- +ok +== +PREPARE v AS SELECT nextval('seq') +-- +ok +== diff --git a/parser/testdata/corpus/sql/catalog/dependencies/test_schema_dependency.test b/parser/testdata/corpus/sql/catalog/dependencies/test_schema_dependency.test new file mode 100644 index 0000000..a75d205 --- /dev/null +++ b/parser/testdata/corpus/sql/catalog/dependencies/test_schema_dependency.test @@ -0,0 +1,33 @@ +# source: test/sql/catalog/dependencies/test_schema_dependency.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +CREATE SCHEMA s1 +-- +ok +== +CREATE TABLE s1.integers(i INTEGER) +-- +ok +== +SELECT * FROM s1.integers +-- +ok +== +DROP SCHEMA s1 +-- +ok +== +DROP SCHEMA s1 CASCADE +-- +ok +== +DROP TABLE s1.integers +-- +ok +== +CREATE TABLE s1.dummy(i INTEGER) +-- +ok +== diff --git a/parser/testdata/corpus/sql/catalog/dependencies/test_set_default_sequence_dependency.test b/parser/testdata/corpus/sql/catalog/dependencies/test_set_default_sequence_dependency.test new file mode 100644 index 0000000..fe7edbe --- /dev/null +++ b/parser/testdata/corpus/sql/catalog/dependencies/test_set_default_sequence_dependency.test @@ -0,0 +1,72 @@ +# source: test/sql/catalog/dependencies/test_set_default_sequence_dependency.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +CREATE SEQUENCE id_sequence START 1; +-- +ok +== +CREATE TABLE tbl (id INTEGER DEFAULT nextval('id_sequence'), s VARCHAR); +-- +ok +== +INSERT INTO tbl(s) VALUES ('default is sequence'); +-- +ok +== +ALTER TABLE tbl ALTER COLUMN id SET DEFAULT NULL; +-- +ok +== +INSERT INTO tbl(s) VALUES ('default is NULL'); +-- +ok +== +DROP SEQUENCE id_sequence; +-- +ok +== +CREATE SEQUENCE seq START 1; +-- +ok +== +CREATE TABLE tbl2 ( + a INTEGER DEFAULT nextval('seq'), + b INTEGER DEFAULT nextval('seq') +); +-- +ok +== +INSERT INTO tbl2 DEFAULT VALUES; +-- +ok +== +ALTER TABLE tbl2 ALTER COLUMN a SET DEFAULT NULL; +-- +ok +== +ALTER TABLE tbl2 ALTER COLUMN b SET DEFAULT 0; +-- +ok +== +CREATE SEQUENCE seq4 START 1; +-- +ok +== +CREATE TABLE tbl5 (a INTEGER DEFAULT nextval('seq4'), b VARCHAR); +-- +ok +== +ALTER TABLE tbl5 ALTER COLUMN a SET DEFAULT NULL; +-- +ok +== +DROP SEQUENCE seq4; +-- +ok +== +DROP TABLE tbl5; +-- +ok +== diff --git a/parser/testdata/corpus/sql/catalog/dependencies/test_write_after_rename.test b/parser/testdata/corpus/sql/catalog/dependencies/test_write_after_rename.test new file mode 100644 index 0000000..819f041 --- /dev/null +++ b/parser/testdata/corpus/sql/catalog/dependencies/test_write_after_rename.test @@ -0,0 +1,29 @@ +# source: test/sql/catalog/dependencies/test_write_after_rename.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +create table tbl (i integer); +-- +ok +== +insert into tbl VALUES (5); +-- +ok +== +begin transaction; +-- +ok +== +create table tbl (b varchar); +-- +ok +== +insert into tbl VALUES ('test') +-- +ok +== +commit; +-- +ok +== diff --git a/parser/testdata/corpus/sql/catalog/did_you_mean.test b/parser/testdata/corpus/sql/catalog/did_you_mean.test new file mode 100644 index 0000000..894bce9 --- /dev/null +++ b/parser/testdata/corpus/sql/catalog/did_you_mean.test @@ -0,0 +1,40 @@ +# source: test/sql/catalog/did_you_mean.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +CREATE TABLE test.bye(i INTEGER); +-- +ok +== +SELECT * FROM helloo; +-- +ok +== +SELECT * FROM bye; +-- +ok +== +CREATE SCHEMA a; +CREATE TABLE a.foo(name text); +-- +ok +== +SELECT * FROM foo; +-- +ok +== +CREATE SCHEMA b; +CREATE TABLE b.foo(name text); +-- +ok +== +CREATE SCHEMA c; +CREATE TABLE c.foo(name text); +-- +ok +== +SELECT * FROM a.fooo; +-- +ok +== diff --git a/parser/testdata/corpus/sql/catalog/drop_create_rollback.test b/parser/testdata/corpus/sql/catalog/drop_create_rollback.test new file mode 100644 index 0000000..ad696fb --- /dev/null +++ b/parser/testdata/corpus/sql/catalog/drop_create_rollback.test @@ -0,0 +1,21 @@ +# source: test/sql/catalog/drop_create_rollback.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +CREATE TABLE t1 (c1 CHAR(5)); +-- +ok +== +DROP TABLE IF EXISTS t1; +-- +ok +== +CREATE TABLE T1 (C2 CHAR(5)); +-- +ok +== +SELECT C2 FROM T1; +-- +ok +== diff --git a/parser/testdata/corpus/sql/catalog/function/attached_macro.test b/parser/testdata/corpus/sql/catalog/function/attached_macro.test new file mode 100644 index 0000000..588615d --- /dev/null +++ b/parser/testdata/corpus/sql/catalog/function/attached_macro.test @@ -0,0 +1,35 @@ +# source: test/sql/catalog/function/attached_macro.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +ATTACH ':memory:' AS checksum_macro; +-- +ok +== +CREATE MACRO checksum_macro.checksum(table_name) AS TABLE + SELECT bit_xor(md5_number(COLUMNS(*)::VARCHAR)) + FROM query_table(table_name); +-- +ok +== +CREATE TABLE tbl AS SELECT UNNEST([42, 43]) AS x; +-- +ok +== +USE checksum_macro; +-- +ok +== +SELECT * FROM checksum('memory.tbl'); +-- +ok +== +ABORT +-- +ok +== +SELECT * FROM checksum_macro.checksum('tbl'); +-- +ok +== diff --git a/parser/testdata/corpus/sql/catalog/function/information_schema_macro.test b/parser/testdata/corpus/sql/catalog/function/information_schema_macro.test new file mode 100644 index 0000000..f4b2240 --- /dev/null +++ b/parser/testdata/corpus/sql/catalog/function/information_schema_macro.test @@ -0,0 +1,9 @@ +# source: test/sql/catalog/function/information_schema_macro.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +create macro information_schema.foo(a) as a; +-- +ok +== diff --git a/parser/testdata/corpus/sql/catalog/function/macro_query_table.test b/parser/testdata/corpus/sql/catalog/function/macro_query_table.test new file mode 100644 index 0000000..1f19b80 --- /dev/null +++ b/parser/testdata/corpus/sql/catalog/function/macro_query_table.test @@ -0,0 +1,29 @@ +# source: test/sql/catalog/function/macro_query_table.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +create macro min_from_tbl(tbl, col) as (select min(col) from query_table(tbl::VARCHAR)); +-- +ok +== +create table integers as from range(100) t(i) +-- +ok +== +SELECT min_from_tbl(integers, i) +-- +ok +== +SELECT min_from_tbl(integers, k) +-- +ok +== +SELECT min_from_tbl(integers2, i) +-- +ok +== +SELECT min_from_tbl(tbl_name, i) from (values ('integers')) t(tbl_name); +-- +ok +== diff --git a/parser/testdata/corpus/sql/catalog/function/python_style_macro_parameters.test b/parser/testdata/corpus/sql/catalog/function/python_style_macro_parameters.test new file mode 100644 index 0000000..20b8dd6 --- /dev/null +++ b/parser/testdata/corpus/sql/catalog/function/python_style_macro_parameters.test @@ -0,0 +1,85 @@ +# source: test/sql/catalog/function/python_style_macro_parameters.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +create or replace macro m(a := 'a', b := 'b') as a || b +-- +ok +== +select m() +-- +ok +== +select m(b := 'a', a := 'b') +-- +ok +== +select m(a := 'b', b := 'a') +-- +ok +== +select m('c') +-- +ok +== +select m('c', 'd') +-- +ok +== +select m('c', b := 'd') +-- +ok +== +select m('c', a:= 'd') +-- +ok +== +select m('c', 'd', b := 'e') +-- +ok +== +create or replace macro m(a, b) as a || b +-- +ok +== +create or replace macro m(a := 'a', b := 'b') as table (select a || b) +-- +ok +== +select * from m() +-- +ok +== +select * from m(b := 'a', a := 'b') +-- +ok +== +select * from m(a := 'b', b := 'a') +-- +ok +== +select * from m('c') +-- +ok +== +select * from m('c', 'd') +-- +ok +== +select * from m('c', b := 'd') +-- +ok +== +select * from m('c', a:= 'd') +-- +ok +== +select * from m('c', 'd', b := 'e') +-- +ok +== +create or replace macro m(a, b) as table (select a || b) +-- +ok +== diff --git a/parser/testdata/corpus/sql/catalog/function/query_function.test b/parser/testdata/corpus/sql/catalog/function/query_function.test new file mode 100644 index 0000000..d00202d --- /dev/null +++ b/parser/testdata/corpus/sql/catalog/function/query_function.test @@ -0,0 +1,233 @@ +# source: test/sql/catalog/function/query_function.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +SELECT * FROM query('SELECT 42'); +-- +ok +== +FROM query('SELECT 42 AS a'); +-- +ok +== +FROM query('SELECT 10 + 32;'); +-- +ok +== +FROM query('SELECT abs(-42)'); +-- +ok +== +SELECT * FROM query('SELECT * FROM (SELECT 1 + 2)'); +-- +ok +== +FROM query('SELECT 1, 2, 3'); +-- +ok +== +FROM query('SELECT 42;;;--- hello;'); +-- +ok +== +SELECT * FROM query('SELECT ''hello'''); +-- +ok +== +CREATE TABLE tbl (a INT, b INT, c INT); +-- +ok +== +FROM query('SELECT *, 1 + 2 FROM tbl'); +-- +ok +== +INSERT INTO tbl VALUES (1, 2, 3), (4, 5, 6), (7, 8, 9); +-- +ok +== +SELECT * FROM query('FROM tbl'); +-- +ok +== +SELECT * FROM query('SELECT a + b + c FROM tbl'); +-- +ok +== +SELECT * FROM query('WITH a(i) AS (SELECT 1) SELECT a1.i AS i1, a2.i AS i2 FROM a AS a1, a AS a2'); +-- +ok +== +SELECT * FROM query(NULL); +-- +ok +== +SELECT * FROM query(' '); +-- +error: Parser Error: Expected a single SELECT statement +== +SELECT * FROM query(''); +-- +error: Parser Error: Expected a single SELECT statement +== +SELECT * FROM query('FROM query(FROM)'); +-- +error: Parser Error: syntax error at or near "FROM" +== +SELECT * FROM query('SELECT 1; SELECT 2'); +-- +error: Parser Error: Expected a single SELECT statement +== +SELECT query(SELECT 1); +-- +error: Parser Error: syntax error at or near "SELECT" +== +SELECT * FROM query('CREATE TABLE tbl (a INT)'); +-- +error: Parser Error: Expected a single SELECT statement +== +SELECT * FROM query('SELECT * FROM (PIVOT (SELECT 1 AS col) ON col IN (1) using first(col))'); +-- +ok +== +SELECT * FROM query('SELECT * FROM (PIVOT (SELECT 1 AS col) ON col using first(col))'); +-- +error: Parser Error: PIVOT statements without explicit IN clauses are not supported in query() function. Please specify the pivot values explicitly, e.g.: PIVOT ... ON col IN (val1, val2, ...) +== +CREATE TABLE tbl_int AS SELECT 42; +-- +ok +== +CREATE TABLE tbl_varchar AS SELECT 'duckdb'; +-- +ok +== +CREATE TABLE tbl2_varchar AS SELECT '1?ch@racter$'; +-- +ok +== +CREATE TABLE tbl_empty AS SELECT ''; +-- +ok +== +FROM query_table('tbl_int'); +-- +ok +== +FROM query_table(['tbl_int']); +-- +ok +== +FROM query_table(tbl); +-- +ok +== +CREATE TABLE tbl2 (a INT, b INT, c INT); +-- +ok +== +INSERT INTO tbl2 VALUES (9, 8, 7), (6, 5, 4), (3, 2, 1); +-- +ok +== +FROM query_table([tbl, tbl2]); +-- +ok +== +FROM query_table(); +-- +ok +== +FROM query_table(NULL); +-- +ok +== +FROM query_table([]); +-- +ok +== +FROM query_table(['']); +-- +error: Parser Error: syntax error at or near "FROM" +== +FROM query_table('tbl_int', 'tbl_varchar', tbl2_varchar); +-- +ok +== +FROM query_table([tbl_int, tbl2]); +-- +ok +== +FROM query_table(not_defined_tbl); +-- +ok +== +FROM query_table('FROM query(''select 1 + 2;'')'); +-- +ok +== +FROM query_table('FROM query("select 1 + 2;")'); +-- +error: Parser Error: Unexpected quote in the middle of a qualified name component! (input: FROM query("select 1 + 2;")) +== +FROM query_table('(SELECT 17 + 25)'); +-- +ok +== +CREATE TABLE "(SELECT 17 + 25)"(i int); +-- +ok +== +insert into "(SELECT 17 + 25)" values (100); +-- +ok +== +SELECT * FROM "(SELECT 17 + 25)"; +-- +ok +== +FROM query_table("(SELECT 17 + 25)"); +-- +ok +== +FROM query_table(SELECT 17 + 25); +-- +error: Parser Error: syntax error at or near "SELECT" +== +FROM query_table("SELECT 4 + 2"); +-- +ok +== +FROM query_table('SELECT 4 + 2'); +-- +ok +== +SELECT f.* FROM query_table('tbl_int') as f; +-- +ok +== +SELECT f.x FROM query_table('tbl_int') as f(x); +-- +ok +== +FROM query_table(['tbl_int', 'tbl_varchar', 'tbl_empty', 'tbl2_varchar'], false); +-- +ok +== +from query_table([tbl_int, tbl_varchar, tbl_empty, tbl2_varchar], true); +-- +ok +== +FROM query_table(true); +-- +ok +== +FROM query_table(tbl2, true); +-- +ok +== +FROM query_table(['tbl_int', 'tbl_varchar', 'tbl_empty', '(select ''I am a subquery'')'], false); +-- +ok +== diff --git a/parser/testdata/corpus/sql/catalog/function/query_function.test.metadata.json b/parser/testdata/corpus/sql/catalog/function/query_function.test.metadata.json new file mode 100644 index 0000000..f82f6c0 --- /dev/null +++ b/parser/testdata/corpus/sql/catalog/function/query_function.test.metadata.json @@ -0,0 +1,14 @@ +{ + "todo": { + "2dbe98fbfd26e976": "transformer-raised parser error: upstream rejects in the transformer, not the grammar; expected to clear as transformers land (milestones 3-5)", + "6849cf25332caa00": "transformer-raised parser error: upstream rejects in the transformer, not the grammar; expected to clear as transformers land (milestones 3-5)", + "aa55a1e51d55e50f": "transformer-raised parser error: upstream rejects in the transformer, not the grammar; expected to clear as transformers land (milestones 3-5)", + "b1a7071252780b40": "transformer-raised parser error: upstream rejects in the transformer, not the grammar; expected to clear as transformers land (milestones 3-5)", + "c0ff2e8320e39445": "transformer-raised parser error: upstream rejects in the transformer, not the grammar; expected to clear as transformers land (milestones 3-5)", + "c5d546a35986dc04": "transformer-raised parser error: upstream rejects in the transformer, not the grammar; expected to clear as transformers land (milestones 3-5)" + }, + "skip": { + "5f81be9e9bc42318": "nested parse at bind time: the inner SQL string is parsed by a function, the grammar never sees it", + "f84558899aa09cea": "nested parse at bind time: the inner SQL string is parsed by a function, the grammar never sees it" + } +} diff --git a/parser/testdata/corpus/sql/catalog/function/struct_extract_macro.test b/parser/testdata/corpus/sql/catalog/function/struct_extract_macro.test new file mode 100644 index 0000000..c1608ed --- /dev/null +++ b/parser/testdata/corpus/sql/catalog/function/struct_extract_macro.test @@ -0,0 +1,21 @@ +# source: test/sql/catalog/function/struct_extract_macro.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +CREATE MACRO my_extract(x) AS x.a.b +-- +ok +== +SELECT my_extract({'a': {'b': 42}}) +-- +ok +== +CREATE MACRO my_subquery_extract(x) AS (SELECT x.a.b); +-- +ok +== +SELECT my_subquery_extract({'a': {'b': 42}}) +-- +ok +== diff --git a/parser/testdata/corpus/sql/catalog/function/test_complex_macro.test b/parser/testdata/corpus/sql/catalog/function/test_complex_macro.test new file mode 100644 index 0000000..7c872cb --- /dev/null +++ b/parser/testdata/corpus/sql/catalog/function/test_complex_macro.test @@ -0,0 +1,324 @@ +# source: test/sql/catalog/function/test_complex_macro.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +CREATE TABLE integers (a INT) +-- +ok +== +INSERT INTO integers VALUES (1) +-- +ok +== +CREATE MACRO cte_sq(a,b) AS (WITH cte AS (SELECT a * 2 AS c) SELECT cte.c + sq.d FROM cte, (SELECT b * 3 AS d) AS sq) +-- +ok +== +SELECT cte_sq(3,4) +-- +ok +== +CREATE MACRO nested_cte(needle, haystack) AS needle IN ( + SELECT i FROM ( + WITH ints AS ( + SELECT CAST(UNNEST(string_split(haystack,',')) AS INT) AS i + ) + SELECT i FROM ints + ) AS sq +) +-- +ok +== +SELECT nested_cte(2, '2,2,2,2') +-- +ok +== +CREATE MACRO IFELSE(a,b,c) AS CASE WHEN a THEN b ELSE c END +-- +ok +== +SELECT IFELSE(1, IFELSE(1,'a','b'), 'c') +-- +ok +== +SELECT IFELSE(1, IFELSE(0,'a','b'), 'c') +-- +ok +== +SELECT IFELSE(0, IFELSE(1,'a','b'), 'c') +-- +ok +== +SELECT IFELSE(1, IFELSE(1,a,'b'), 'c') FROM integers +-- +ok +== +SELECT IFELSE(1,IFELSE(1,b,1),a) FROM integers +-- +ok +== +CREATE MACRO f1(x) AS (SELECT MIN(a) + x FROM integers) +-- +ok +== +select f1(42) from integers; +-- +ok +== +CREATE MACRO mod_two(k) AS k%2 +-- +ok +== +SELECT mod_two(a), SUM(a) FROM integers GROUP BY mod_two(a) +-- +ok +== +CREATE MACRO add_mac(a, b) AS a + b +-- +ok +== +CREATE MACRO double_add(a, b, c) AS add_mac(add_mac(a, b), c) +-- +ok +== +SELECT double_add(1, 2, 3) +-- +ok +== +CREATE MACRO triple_add1(a, b, c, d) AS add_mac(add_mac(a, b), add_mac(c, d)) +-- +ok +== +SELECT triple_add1(1, 2, 3, 4) +-- +ok +== +CREATE MACRO triple_add2(a, b, c, d) as add_mac(add_mac(add_mac(a, b), c), d) +-- +ok +== +SELECT triple_add2(1, 2, 3, 4) +-- +ok +== +INSERT INTO integers VALUES (41) +-- +ok +== +SELECT add((SELECT MIN(a) FROM integers), (SELECT MAX(a) FROM integers)) +-- +ok +== +SELECT (SELECT MAX(add(i1.a, a)) FROM integers) FROM integers i1 +-- +ok +== +CREATE MACRO prep(x) AS ?+1 +-- +ok +== +CREATE MACRO add_one(a) AS a + 1 +-- +ok +== +PREPARE v1 AS SELECT add_one(?::INTEGER) +-- +ok +== +CREATE MACRO my_square(a) AS a * a +-- +ok +== +PREPARE v2 AS SELECT my_square(?::INTEGER) +-- +ok +== +EXECUTE v2(3) +-- +ok +== +CREATE TABLE documents(id VARCHAR, body VARCHAR) +-- +ok +== +INSERT INTO documents VALUES ('doc1', ' QUÁCK+QUÁCK+QUÁCK'), ('doc2', ' BÁRK+BÁRK+BÁRK+BÁRK'), ('doc3', ' MÉOW+MÉOW+MÉOW+MÉOW+MÉOW') +-- +ok +== +CREATE SCHEMA fts_main_documents +-- +ok +== +CREATE TABLE fts_main_documents.docs AS ( + SELECT + row_number() OVER () AS docid, + id AS name + FROM + main.documents +) +-- +ok +== +CREATE TABLE fts_main_documents.terms AS ( + SELECT + term, + docid, + row_number() OVER (PARTITION BY docid) AS pos + FROM ( + SELECT + unnest(string_split_regex(regexp_replace(lower(strip_accents(body)), '[^a-z]', ' ', 'g'), '\s+')) AS term, + row_number() OVER () AS docid + FROM main.documents + ) AS sq + WHERE + term != '' +) +-- +ok +== +ALTER TABLE fts_main_documents.docs ADD len INT +-- +ok +== +UPDATE fts_main_documents.docs d +SET len = ( + SELECT count(term) + FROM fts_main_documents.terms t + WHERE t.docid = d.docid +) +-- +ok +== +CREATE TABLE fts_main_documents.dict AS +WITH distinct_terms AS ( + SELECT DISTINCT term, docid + FROM fts_main_documents.terms + ORDER BY docid +) +SELECT + row_number() OVER () AS termid, + term +FROM + distinct_terms +-- +ok +== +ALTER TABLE fts_main_documents.terms ADD termid INT +-- +ok +== +UPDATE fts_main_documents.terms t +SET termid = ( + SELECT termid + FROM fts_main_documents.dict d + WHERE t.term = d.term +) +-- +ok +== +ALTER TABLE fts_main_documents.terms DROP term +-- +ok +== +ALTER TABLE fts_main_documents.dict ADD df INT +-- +ok +== +UPDATE fts_main_documents.dict d +SET df = ( + SELECT count(distinct docid) + FROM fts_main_documents.terms t + WHERE d.termid = t.termid + GROUP BY termid +) +-- +ok +== +WITH ppterms AS ( + SELECT unnest(string_split_regex(regexp_replace(lower(strip_accents('QUÁCK BÁRK')), '[^a-z]', ' ', 'g'), '\s+')) AS term +), qtermids AS ( + SELECT termid + FROM fts_main_documents.dict AS dict + JOIN ppterms + USING (term) +), qterms AS ( + SELECT termid, + docid + FROM fts_main_documents.terms AS terms + WHERE termid IN ( + SELECT qtermids.termid FROM qtermids + ) +), subscores AS ( + SELECT docs.docid, + len, + term_tf.termid, + tf, + df, + (log((3 - df + 0.5) / (df + 0.5))* ((tf * (1.2 + 1)/(tf + 1.2 * (1 - 0.75 + 0.75 * (len / 4)))))) AS subscore + FROM ( + SELECT termid, + docid, + COUNT(*) AS tf + FROM qterms + GROUP BY docid, + termid + ) AS term_tf + JOIN ( + SELECT DISTINCT docid + FROM qterms + ) AS cdocs + ON term_tf.docid = cdocs.docid + JOIN fts_main_documents.docs AS docs + ON term_tf.docid = docs.docid + JOIN fts_main_documents.dict AS dict + ON term_tf.termid = dict.termid +) +SELECT name, + score +FROM ( + SELECT docid, + sum(subscore) AS score + FROM subscores + GROUP BY docid +) AS scores +JOIN fts_main_documents.docs AS docs +ON scores.docid = docs.docid +ORDER BY score DESC +LIMIT 1000 +-- +ok +== +CREATE MACRO fts_match(docname, query_string) AS docname IN ( +WITH ppterms AS (SELECT unnest(string_split_regex(regexp_replace(lower(strip_accents(query_string)), '[^a-z]', ' ', 'g'), '\s+')) AS term), +qtermids AS (SELECT termid FROM fts_main_documents.dict AS dict, ppterms WHERE dict.term = ppterms.term), +qterms AS (SELECT termid, docid FROM fts_main_documents.terms AS terms WHERE termid IN (SELECT qtermids.termid FROM qtermids)), +subscores AS ( +SELECT docs.docid, len, term_tf.termid, + tf, df, (log((3 - df + 0.5) / (df + 0.5))* ((tf * (1.2 + 1)/(tf + 1.2 * (1 - 0.75 + 0.75 * (len / 4)))))) AS subscore +FROM (SELECT termid, docid, COUNT(*) AS tf FROM qterms + GROUP BY docid, termid) AS term_tf + JOIN (SELECT docid FROM qterms + GROUP BY docid) -- HAVING COUNT(DISTINCT termid) = 3) + AS cdocs ON term_tf.docid = cdocs.docid + JOIN fts_main_documents.docs AS docs ON term_tf.docid = docs.docid + JOIN fts_main_documents.dict AS dict ON term_tf.termid = dict.termid) +SELECT name FROM (SELECT docid, sum(subscore) AS score + FROM subscores GROUP BY docid) AS scores JOIN fts_main_documents.docs AS docs ON + scores.docid = docs.docid ORDER BY score DESC LIMIT 1000) +-- +ok +== +SELECT * FROM documents WHERE fts_match(id, 'QUÁCK BÁRK') +-- +ok +== +CREATE MACRO mywindow(k,v) AS SUM(v) OVER (PARTITION BY k) +-- +ok +== +WITH grouped AS (SELECT mod(range, 3) AS grp, range AS val FROM RANGE(500)) +SELECT DISTINCT grp, mywindow(grp, val) FROM grouped ORDER BY grp +-- +ok +== diff --git a/parser/testdata/corpus/sql/catalog/function/test_cross_catalog_macros.test b/parser/testdata/corpus/sql/catalog/function/test_cross_catalog_macros.test new file mode 100644 index 0000000..ce39bae --- /dev/null +++ b/parser/testdata/corpus/sql/catalog/function/test_cross_catalog_macros.test @@ -0,0 +1,17 @@ +# source: test/sql/catalog/function/test_cross_catalog_macros.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +CREATE MACRO my_first_macro() AS (84) +-- +ok +== +CREATE TEMPORARY MACRO my_second_macro() AS my_first_macro() + 42; +-- +ok +== +SELECT my_second_macro() +-- +ok +== diff --git a/parser/testdata/corpus/sql/catalog/function/test_cte_macro.test b/parser/testdata/corpus/sql/catalog/function/test_cte_macro.test new file mode 100644 index 0000000..2ec8c72 --- /dev/null +++ b/parser/testdata/corpus/sql/catalog/function/test_cte_macro.test @@ -0,0 +1,75 @@ +# source: test/sql/catalog/function/test_cte_macro.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +CREATE MACRO parameterized_cte(a) AS (WITH cte AS (SELECT a AS answer) SELECT answer FROM cte) +-- +ok +== +SELECT parameterized_cte(42) +-- +ok +== +CREATE MACRO in_with_cte(i) AS i IN (WITH cte AS (SELECT a AS answer FROM integers) SELECT answer FROM cte) +-- +ok +== +SELECT in_with_cte(1) +-- +ok +== +SELECT in_with_cte(2) +-- +ok +== +CREATE MACRO plus42(a) AS (WITH cte AS (SELECT 42 AS answer) SELECT answer + a FROM cte) +-- +ok +== +SELECT plus42(42) +-- +ok +== +SELECT plus42(a) FROM integers +-- +ok +== +SELECT plus42(3) + a FROM integers +-- +ok +== +SELECT plus42(42) + answer FROM cte; +-- +ok +== +CREATE MACRO plus1(a) AS (WITH tbl AS (SELECT 1 AS one) SELECT one + a FROM tbl) +-- +ok +== +SELECT plus42(a) + plus1(a) FROM integers; +-- +ok +== +CREATE MACRO deep_cte(param) AS ( + WITH cte1 AS ( + WITH cte2 AS ( + WITH cte3 AS ( + WITH cte4 AS ( + SELECT param AS d + ) + SELECT d AS c FROM cte4 + ) + SELECT c AS b FROM cte3 + ) + SELECT b AS a FROM cte2 + ) + SELECT a FROM cte1 +) +-- +ok +== +SELECT deep_cte(42) +-- +ok +== diff --git a/parser/testdata/corpus/sql/catalog/function/test_drop_macro.test b/parser/testdata/corpus/sql/catalog/function/test_drop_macro.test new file mode 100644 index 0000000..0415679 --- /dev/null +++ b/parser/testdata/corpus/sql/catalog/function/test_drop_macro.test @@ -0,0 +1,25 @@ +# source: test/sql/catalog/function/test_drop_macro.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +create macro m() as 42; +-- +ok +== +create macro m() as table (select 42 i); +-- +ok +== +drop macro m; +-- +ok +== +select m(); +-- +ok +== +from m(); +-- +ok +== diff --git a/parser/testdata/corpus/sql/catalog/function/test_macro_correlated_cte.test b/parser/testdata/corpus/sql/catalog/function/test_macro_correlated_cte.test new file mode 100644 index 0000000..344d8df --- /dev/null +++ b/parser/testdata/corpus/sql/catalog/function/test_macro_correlated_cte.test @@ -0,0 +1,29 @@ +# source: test/sql/catalog/function/test_macro_correlated_cte.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +CREATE OR REPLACE MACRO test_21890_macro(q) AS TABLE +WITH sel AS ( + SELECT unnest(string_split(q, ',')) AS tag, + row_number() OVER () AS node_id +) +SELECT s.tag, s.node_id +FROM sel s +WHERE s.tag = 'a' + AND NOT EXISTS ( + SELECT 1 + FROM sel args + WHERE args.tag = 'b' + AND s.node_id > args.node_id + ); +-- +ok +== +WITH inputs(q) AS (VALUES ('b'), ('a,a')) +SELECT i.q, m.* +FROM inputs i, test_21890_macro(i.q) m +ORDER BY i.q, m.tag, m.node_id; +-- +ok +== diff --git a/parser/testdata/corpus/sql/catalog/function/test_macro_default_arg.test b/parser/testdata/corpus/sql/catalog/function/test_macro_default_arg.test new file mode 100644 index 0000000..ade3aec --- /dev/null +++ b/parser/testdata/corpus/sql/catalog/function/test_macro_default_arg.test @@ -0,0 +1,83 @@ +# source: test/sql/catalog/function/test_macro_default_arg.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +CREATE MACRO f(x := NULL) AS x+1; +-- +ok +== +SELECT f(); +-- +ok +== +SELECT f(x := 41) +-- +ok +== +SELECT f(x := (SELECT 41)); +-- +ok +== +select f(x:=(select 1 a)); +-- +ok +== +select f(x:=a) from (select 41) t(a); +-- +ok +== +create table t as select 41 a; +-- +ok +== +select f(x:=a) from t; +-- +ok +== +create macro my_macro1(a, b := a) as a + b; +-- +ok +== +create table integers (a integer); +-- +ok +== +create macro my_macro2(a := i) as ( + select min(a) from integers +) +-- +ok +== +drop table integers; +-- +ok +== +Create table t1 (a int, b int); +-- +ok +== +Create table t2 (c int, d int); +-- +ok +== +CREATE OR REPLACE MACRO eq(x := NULL, y := NULL) AS x = y +-- +ok +== +INSERT INTO t1 VALUES (1, 1), (1, 2), (2, 2), (3, 4); +-- +ok +== +INSERT INTO t2 VALUES (4, 1), (2, 10), (6, 2), (2, 6); +-- +ok +== +SELECT * FROM t1 as t1_alias inner join (select * from t2) as t2_alias ON (eq(x := t1_alias.a, y := t2_alias.c)) +-- +ok +== +SELECT * FROM t1 as t1_alias inner join (select * from t2) as t2_alias ON (eq(a := t1_alias.a, c := t2_alias.c)) +-- +ok +== diff --git a/parser/testdata/corpus/sql/catalog/function/test_macro_default_arg_with_dependencies.test b/parser/testdata/corpus/sql/catalog/function/test_macro_default_arg_with_dependencies.test new file mode 100644 index 0000000..f6d21da --- /dev/null +++ b/parser/testdata/corpus/sql/catalog/function/test_macro_default_arg_with_dependencies.test @@ -0,0 +1,45 @@ +# source: test/sql/catalog/function/test_macro_default_arg_with_dependencies.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +ATTACH '{TEST_DIR}/macro_default_arg.db' (STORAGE_VERSION 'v1.0.0'); +-- +ok +== +USE macro_default_arg +-- +ok +== +set enable_macro_dependencies=true +-- +ok +== +create macro my_macro2(a := i) as ( + select min(a) from integers +); +-- +ok +== +create macro my_macro2(i := 42) as ( + select min(a) + i from integers +); +-- +ok +== +insert into integers values (5), (10), (13) +-- +ok +== +select my_macro2(84) +-- +ok +== +drop table integers cascade; +-- +ok +== +select my_macro2(5); +-- +ok +== diff --git a/parser/testdata/corpus/sql/catalog/function/test_macro_issue_13104.test b/parser/testdata/corpus/sql/catalog/function/test_macro_issue_13104.test new file mode 100644 index 0000000..f51d6a7 --- /dev/null +++ b/parser/testdata/corpus/sql/catalog/function/test_macro_issue_13104.test @@ -0,0 +1,25 @@ +# source: test/sql/catalog/function/test_macro_issue_13104.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +create or replace macro my_macro(a:=true) as a; +-- +ok +== +select my_macro() +-- +ok +== +create or replace macro my_macro(a:=false) as a; +-- +ok +== +create or replace macro my_macro(a:={duck:42}) as a; +-- +ok +== +create or replace macro my_macro(a:=[42]) as a; +-- +ok +== diff --git a/parser/testdata/corpus/sql/catalog/function/test_macro_issue_14276.test b/parser/testdata/corpus/sql/catalog/function/test_macro_issue_14276.test new file mode 100644 index 0000000..c452990 --- /dev/null +++ b/parser/testdata/corpus/sql/catalog/function/test_macro_issue_14276.test @@ -0,0 +1,17 @@ +# source: test/sql/catalog/function/test_macro_issue_14276.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +CREATE OR REPLACE MACRO extract_many(x, y) AS (SELECT struct_pack(*COLUMNS(z -> z in y)) FROM (SELECT unnest(x))); +-- +ok +== +SELECT ['foo', 'baz'] AS k, extract_many(x, k) FROM (SELECT {'foo': 1, 'bar': 2, 'baz': 3} AS x); +-- +ok +== +CREATE OR REPLACE MACRO extract_many(x, y) AS (SELECT struct_pack(*COLUMNS(lambda z: z in y)) FROM (SELECT unnest(x))); +-- +ok +== diff --git a/parser/testdata/corpus/sql/catalog/function/test_macro_issue_18927.test b/parser/testdata/corpus/sql/catalog/function/test_macro_issue_18927.test new file mode 100644 index 0000000..1d02141 --- /dev/null +++ b/parser/testdata/corpus/sql/catalog/function/test_macro_issue_18927.test @@ -0,0 +1,13 @@ +# source: test/sql/catalog/function/test_macro_issue_18927.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +CREATE OR REPLACE MACRO my(s) AS s.lower().split('').aggregate('count'); +-- +ok +== +SELECT my('AA'); +-- +ok +== diff --git a/parser/testdata/corpus/sql/catalog/function/test_macro_issue_19119.test b/parser/testdata/corpus/sql/catalog/function/test_macro_issue_19119.test new file mode 100644 index 0000000..17fb4b4 --- /dev/null +++ b/parser/testdata/corpus/sql/catalog/function/test_macro_issue_19119.test @@ -0,0 +1,17 @@ +# source: test/sql/catalog/function/test_macro_issue_19119.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +CREATE TABLE t (x INT); +-- +ok +== +INSERT INTO t (x) VALUES (1), (2); +-- +ok +== +SELECT ROUND_EVEN(SUM(x) OVER (), 0) AS y FROM t; +-- +ok +== diff --git a/parser/testdata/corpus/sql/catalog/function/test_macro_overloads.test b/parser/testdata/corpus/sql/catalog/function/test_macro_overloads.test new file mode 100644 index 0000000..d1c09fa --- /dev/null +++ b/parser/testdata/corpus/sql/catalog/function/test_macro_overloads.test @@ -0,0 +1,72 @@ +# source: test/sql/catalog/function/test_macro_overloads.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +CREATE MACRO multi_add + () AS 0, + (a) AS a, + (a, b) AS a + b, + (a, b, c) AS a + b + c, + (a, b, c, d) AS a + b + c + d, + (a, b, c, d, e) AS a + b + c + d + e +-- +ok +== +SELECT multi_add(), + multi_add(42), + multi_add(42, 1), + multi_add(42, 1, 1), + multi_add(42, 1, 1, 1), + multi_add(42, 1, 1, 1, 1) +-- +ok +== +SELECT multi_add(1, 1, 1, 1, 1, 1, 1, 1, 1, 1); +-- +ok +== +CREATE MACRO arithmetic + (a, b, mult := 1) AS (a + b) * mult, + (a, b, c, division := 1) AS (a + b + c) / division +-- +ok +== +select arithmetic(100, 200, 300) +-- +ok +== +SELECT arithmetic(42, 84), arithmetic(42, 84, mult := 10), arithmetic(100, 200, c := 300), arithmetic(100, 200, 300, division := 10) +-- +ok +== +CREATE MACRO generate_numbers + (a, b) AS TABLE (SELECT * FROM range(a + b) t(i)), + (a, b, c, mult := 1) AS TABLE (SELECT * FROM range((a + b + c) * mult) t(i)) +-- +ok +== +SELECT COUNT(*) FROM generate_numbers(20, 10); +-- +ok +== +SELECT COUNT(*) FROM generate_numbers(1, 2, 2, mult := 5); +-- +ok +== +SELECT function_name, parameters FROM duckdb_functions() WHERE function_name IN ('arithmetic', 'multi_add', 'generate_numbers') ORDER BY function_name, len(parameters) +-- +ok +== +CREATE MACRO ambiguous_macro + (a) AS a, + (a) AS a + 1 +-- +ok +== +CREATE MACRO error_in_definition + (a) AS a, + (a, b) AS a + y +-- +ok +== diff --git a/parser/testdata/corpus/sql/catalog/function/test_macro_relpersistence_conflict.test b/parser/testdata/corpus/sql/catalog/function/test_macro_relpersistence_conflict.test new file mode 100644 index 0000000..23ee3b4 --- /dev/null +++ b/parser/testdata/corpus/sql/catalog/function/test_macro_relpersistence_conflict.test @@ -0,0 +1,37 @@ +# source: test/sql/catalog/function/test_macro_relpersistence_conflict.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +create macro test(a, b) as a + b +-- +ok +== +select test(4, 2) +-- +ok +== +create or replace macro test(a, b) as a + a +-- +ok +== +create macro if not exists test(a, b) as a + b +-- +ok +== +drop macro test +-- +ok +== +create temporary macro test(a, b) as a + b +-- +ok +== +create or replace temporary macro test(a, b) as a + a +-- +ok +== +create temporary macro if not exists test(a, b) as a + b +-- +ok +== diff --git a/parser/testdata/corpus/sql/catalog/function/test_macro_type_overloads.test b/parser/testdata/corpus/sql/catalog/function/test_macro_type_overloads.test new file mode 100644 index 0000000..f7f46bf --- /dev/null +++ b/parser/testdata/corpus/sql/catalog/function/test_macro_type_overloads.test @@ -0,0 +1,366 @@ +# source: test/sql/catalog/function/test_macro_type_overloads.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +attach ':memory:' AS inmemorydb +-- +ok +== +use inmemorydb +-- +ok +== +create or replace macro m(s varchar) as s || 'c' +-- +ok +== +attach '{TEST_DIR}/test_macro_type_overloads_olderdb.db' AS olderdb (storage_version 'v1.3.0') +-- +ok +== +use olderdb +-- +ok +== +create or replace temporary macro m(s varchar) as s || 'c' +-- +ok +== +attach '{TEST_DIR}/test_macro_type_overloads_newerdb.db' AS newerdb (storage_version 'v1.4.0') +-- +ok +== +use newerdb +-- +ok +== +create view v as select 42 +-- +ok +== +select m('ab') +-- +ok +== +select m(s := 'ab') +-- +ok +== +select m([42]) +-- +ok +== +select m(s := [42]) +-- +ok +== +create or replace macro m(s varchar := 'cc') as s || 'c' +-- +ok +== +create or replace macro m + (a tinyint) as a + 1, + (a smallint) as a + 2, + (a integer) as a + 3, + (a bigint) as a + 4, + (a hugeint) as a + 5, + (a) as a + 10 +-- +ok +== +select parameter_types[1] +from duckdb_functions() +where function_name = 'm' +and function_type = 'macro' +order by all +-- +ok +== +select + m(0::tinyint), + m(0::smallint), + m(0::integer), + m(0::bigint), + m(0::hugeint), + m(0::double) +-- +ok +== +select + m(0::utinyint), + m(0::usmallint), + m(0::uinteger), + m(0::ubigint), + m(0::uhugeint), + m(0::float) +-- +ok +== +create or replace macro m + (i int, j) as i + j, + (i, j int) as i - j; +-- +ok +== +select m(0, 42) +-- +ok +== +select m(0, 42::float) +-- +ok +== +select m(0::float, 42) +-- +ok +== +create or replace type cool_string as varchar; +-- +ok +== +create or replace macro m(s cool_string) as s; +-- +ok +== +select m('duck') +-- +ok +== +create or replace macro m(s varchar := 42) as s +-- +ok +== +create or replace macro m(s varchar := 42::varchar) as s +-- +ok +== +create or replace macro m(i bigint := 42::integer) as i +-- +ok +== +select typeof(m(42::integer)) +-- +ok +== +create or replace macro integral_defaults( + i tinyint := 1, + s smallint := 1, + ut utinyint := 1, + us usmallint := 1, + ui uinteger := 1, + ub ubigint := 1, + uh uhugeint := 1 +) as struct_pack(i := i, s := s, ut := ut, us := us, ui := ui, ub := ub, uh := uh) +-- +ok +== +select result.i, result.s, result.ut, result.us, result.ui, result.ub, result.uh +from (select integral_defaults() result) +-- +ok +== +select typeof(result.i), typeof(result.s), typeof(result.ut), typeof(result.us), + typeof(result.ui), typeof(result.ub), typeof(result.uh) +from (select integral_defaults() result) +-- +ok +== +create or replace macro bad_default(i tinyint := 128) as i +-- +ok +== +create or replace macro bad_default(i utinyint := -1) as i +-- +ok +== +create or replace macro typed_default(i tinyint := 1::integer) as i +-- +ok +== +create or replace macro folded_default(i tinyint := 64 + 63) as i +-- +ok +== +create or replace macro null_default(i tinyint := NULL) as i +-- +ok +== +select null_default() is null +-- +ok +== +create or replace macro typed_null_default(i tinyint := NULL::integer) as i +-- +ok +== +create or replace macro boundary_defaults( + min_i tinyint := -128, + max_ut utinyint := 255, + max_s smallint := 32767, + first_ui uinteger := 2147483648, + max_b bigint := 9223372036854775807, + first_ub ubigint := 9223372036854775808 +) as struct_pack(min_i := min_i, max_ut := max_ut, max_s := max_s, + first_ui := first_ui, max_b := max_b, first_ub := first_ub) +-- +ok +== +select result.min_i::varchar, result.max_ut::varchar, result.max_s::varchar, + result.first_ui::varchar, result.max_b::varchar, result.first_ub::varchar +from (select boundary_defaults() result) +-- +ok +== +create or replace macro bad_default(i tinyint := -129) as i +-- +ok +== +create or replace macro bad_default(i utinyint := 256) as i +-- +ok +== +create or replace macro table_integral_default(i tinyint := 1) as table select i +-- +ok +== +from table_integral_default() +-- +ok +== +attach ':memory:' as switch_db +-- +ok +== +use switch_db +-- +ok +== +detach newerdb +-- +ok +== +attach '{TEST_DIR}/test_macro_type_overloads_newerdb.db' AS newerdb +-- +ok +== +detach switch_db +-- +ok +== +select integral_defaults().i +-- +ok +== +create or replace macro m(s varchar) as table (select s || 'c') +-- +ok +== +from m('ab') +-- +ok +== +from m(s := 'ab') +-- +ok +== +from m([42]) +-- +ok +== +from m(s := [42]) +-- +ok +== +create or replace macro m(s varchar := 'cc') as table (select s || 'c') +-- +ok +== +create or replace macro m + (a tinyint) as table (select a + 1), + (a smallint) as table (select a + 2), + (a integer) as table (select a + 3), + (a bigint) as table (select a + 4), + (a hugeint) as table (select a + 5), + (a) as table (select a + 10) +-- +ok +== +select parameter_types[1] +from duckdb_functions() +where function_name = 'm' +and function_type = 'table_macro' +order by all +-- +ok +== +from m(0::tinyint) +union all +from m(0::smallint) +union all +from m(0::integer) +union all +from m(0::bigint) +union all +from m(0::hugeint) +union all +from m(0::double) +-- +ok +== +from m(0::utinyint) +union all +from m(0::usmallint) +union all +from m(0::uinteger) +union all +from m(0::ubigint) +union all +from m(0::uhugeint) +union all +from m(0::float) +-- +ok +== +create or replace macro m + (i int, j) as table (select i + j), + (i, j int) as table (select i - j); +-- +ok +== +from m(0, 42) +-- +ok +== +from m(0, 42::float) +-- +ok +== +from m(0::float, 42) +-- +ok +== +create or replace macro m(s cool_string) as table (select s); +-- +ok +== +from m('duck') +-- +ok +== +create or replace macro m(s varchar := 42) as table (select s) +-- +ok +== +create or replace macro m(s varchar := 42::varchar) as table (select s) +-- +ok +== +create or replace macro m(i bigint := 42::integer) as table (select i as i) +-- +ok +== +select typeof(i) from m(42::integer) +-- +ok +== diff --git a/parser/testdata/corpus/sql/catalog/function/test_macro_with_unknown_types.test b/parser/testdata/corpus/sql/catalog/function/test_macro_with_unknown_types.test new file mode 100644 index 0000000..fe30add --- /dev/null +++ b/parser/testdata/corpus/sql/catalog/function/test_macro_with_unknown_types.test @@ -0,0 +1,15 @@ +# source: test/sql/catalog/function/test_macro_with_unknown_types.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +CREATE TEMP MACRO m1(x, y) AS ( + SELECT list_has_all(x, y) AND list_has_all(y, x) +); +-- +ok +== +SELECT m1([1, 2], [1, 2]); +-- +ok +== diff --git a/parser/testdata/corpus/sql/catalog/function/test_recursive_macro.test b/parser/testdata/corpus/sql/catalog/function/test_recursive_macro.test new file mode 100644 index 0000000..9ef98d6 --- /dev/null +++ b/parser/testdata/corpus/sql/catalog/function/test_recursive_macro.test @@ -0,0 +1,49 @@ +# source: test/sql/catalog/function/test_recursive_macro.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +CREATE MACRO "sum"(x) AS (CASE WHEN sum(x) IS NULL THEN 0 ELSE sum(x) END); +-- +ok +== +SELECT sum(1); +-- +ok +== +SELECT sum(1) WHERE 42=0 +-- +ok +== +DROP MACRO sum +-- +ok +== +CREATE MACRO "sum"(x) AS (CASE WHEN system.main.sum(x) IS NULL THEN 0 ELSE system.main.sum(x) END); +-- +ok +== +create macro m1(a) as a+1; +-- +ok +== +create macro m2(a) as m1(a)+1; +-- +ok +== +create or replace macro m1(a) as m2(a)+1; +-- +ok +== +create macro m3(a) as a+1; +-- +ok +== +create macro m4(a) as table select m3(a); +-- +ok +== +create or replace macro m3(a) as (from m4(42)); +-- +ok +== diff --git a/parser/testdata/corpus/sql/catalog/function/test_sequence_macro.test b/parser/testdata/corpus/sql/catalog/function/test_sequence_macro.test new file mode 100644 index 0000000..0470b5c --- /dev/null +++ b/parser/testdata/corpus/sql/catalog/function/test_sequence_macro.test @@ -0,0 +1,73 @@ +# source: test/sql/catalog/function/test_sequence_macro.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +CREATE TABLE integers (i INT) +-- +ok +== +INSERT INTO integers VALUES (42), (42) +-- +ok +== +CREATE MACRO in_next_n(x, s, n) AS x IN ( + WITH RECURSIVE cte AS ( + SELECT nextval(s) AS nxt, 1 AS iter + UNION ALL + SELECT nextval(s), iter + 1 + FROM cte + WHERE iter < n + ) + SELECT nxt + FROM cte +) +-- +ok +== +SELECT in_next_n(3, 'seq', 5); +-- +ok +== +SELECT in_next_n(12, 'seq', 5); +-- +ok +== +CREATE MACRO in_next_n2(x, s, n) AS x IN ( + WITH RECURSIVE cte AS ( + SELECT nextval(s) AS nxt, n AS n + UNION ALL + SELECT nextval(s), cte.n - 1 + FROM cte + WHERE cte.n > 1 + ) + SELECT nxt + FROM cte +) +-- +ok +== +SELECT in_next_n2(17, 'seq', 5); +-- +ok +== +CREATE SEQUENCE seq2 INCREMENT BY 2 START WITH 2 +-- +ok +== +CREATE MACRO test(s1, s2, x) AS nextval(s1) + nextval(s2) + x +-- +ok +== +SELECT test('seq1', 'seq2', i) FROM integers +-- +ok +== +CREATE MACRO add_macro(a, b) AS a + b +-- +ok +== +CREATE SEQUENCE seqq +-- +ok +== diff --git a/parser/testdata/corpus/sql/catalog/function/test_simple_macro.test b/parser/testdata/corpus/sql/catalog/function/test_simple_macro.test new file mode 100644 index 0000000..5af8713 --- /dev/null +++ b/parser/testdata/corpus/sql/catalog/function/test_simple_macro.test @@ -0,0 +1,308 @@ +# source: test/sql/catalog/function/test_simple_macro.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +CREATE MACRO one() AS (SELECT 1); +-- +ok +== +SELECT one(1) +-- +ok +== +SELECT one(NULL) +-- +ok +== +DROP MACRO one; +-- +ok +== +CREATE MACRO having_macro(x) AS (SELECT * FROM integers GROUP BY a HAVING a = x) +-- +ok +== +SELECT having_macro(1) +-- +ok +== +SELECT having_macro(6) +-- +ok +== +CREATE MACRO union_macro(x, y, z) AS (SELECT x IN (SELECT y UNION ALL SELECT z)) +-- +ok +== +SELECT union_macro(1, 2, 3) +-- +ok +== +SELECT union_macro(1, 2, 1) +-- +ok +== +SELECT union_macro(1, 1, 2) +-- +ok +== +CREATE MACRO in_expression_list(x, y, z) AS (SELECT x IN (VALUES (y), (z))) +-- +ok +== +SELECT in_expression_list(1, 2, 3) +-- +ok +== +SELECT in_expression_list(1, 2, 1) +-- +ok +== +SELECT in_expression_list(1, 1, 2) +-- +ok +== +CREATE FUNCTION two() AS (SELECT 2); +-- +ok +== +SELECT two() +-- +ok +== +DROP FUNCTION two; +-- +ok +== +CREATE MACRO add_macro(a) AS a + b +-- +ok +== +SELECT add_macro(a,a) FROM integers +-- +ok +== +CREATE TABLE floats (b FLOAT) +-- +ok +== +INSERT INTO floats VALUES (0.5) +-- +ok +== +SELECT add_macro(a,2) + add_macro(3,b) FROM integers, floats +-- +ok +== +CREATE MACRO string_split(a,b) AS a + b +-- +ok +== +SELECT string_split(1, 2) +-- +ok +== +SELECT IFELSE(1,'true','false') +-- +ok +== +SELECT ifelse(1,'true','false') +-- +ok +== +SELECT IFELSE(0,'true','false') +-- +ok +== +SELECT IFELSE(a = 1, 'true', 'false') FROM integers +-- +ok +== +SELECT IFELSE(a = 0, 'true', 'false') FROM integers +-- +ok +== +SELECT IFELSE(); +-- +ok +== +SELECT IFELSE(1); +-- +ok +== +SELECT IFELSE(1, 2); +-- +ok +== +SELECT IFELSE(1, 2, 3, 4); +-- +ok +== +CREATE MACRO IFELSE(a,b) AS a+b +-- +ok +== +CREATE MACRO ifelse(a,b) AS a+b +-- +ok +== +SELECT IFELSE('1', 'random', RANDOM()::VARCHAR) +-- +ok +== +CREATE SCHEMA macros +-- +ok +== +CREATE MACRO macros.add_macro(a, b) AS a + b +-- +ok +== +SELECT macros.add_macro(40,2) +-- +ok +== +CREATE MACRO conflict(i, i) AS i + 1 +-- +error: Parser Error: Duplicate parameter 'i' in macro definition +== +CREATE MACRO myavg(x) AS SUM(x) / COUNT(x) +-- +ok +== +INSERT INTO integers VALUES (21), (41); +-- +ok +== +SELECT myavg(a) FROM integers +-- +ok +== +CREATE MACRO weird_avg(x) AS (MIN(x) + MAX(x)) / COUNT(x) +-- +ok +== +SELECT weird_avg(a) FROM integers +-- +ok +== +CREATE MACRO star() AS * +-- +ok +== +CREATE MACRO conflict(a, a := 1) AS a + a +-- +error: Parser Error: Duplicate parameter 'a' in macro definition +== +CREATE MACRO add_default5(a, b := 5) AS a + b +-- +ok +== +SELECT add_default5(3, 6) +-- +ok +== +SELECT add_default5(3) +-- +ok +== +SELECT add_default5(3, b := 6) +-- +ok +== +SELECT add_default5(b := 6, 3) +-- +ok +== +CREATE MACRO wrong_order(a, b := 3, c) AS a + b + c +-- +error: Parser Error: Parameter without a default follows parameter with a default +== +CREATE MACRO wrong_order(a := 3, b) AS a + b +-- +error: Parser Error: Parameter without a default follows parameter with a default +== +CREATE MACRO select_plus_floats(a, f := b) AS (SELECT a + f FROM floats) +-- +ok +== +CREATE MACRO wrong_type(s := 'not a float') AS (SELECT b + s FROM floats) +-- +ok +== +select wrong_type() +-- +ok +== +select wrong_type(42) +-- +ok +== +CREATE MACRO two_default_params(a := 4, a := 2) AS a + a +-- +error: Parser Error: Duplicate parameter 'a' in macro definition +== +CREATE MACRO two_default_params(a := 4, b := 2) AS a + b +-- +ok +== +SELECT two_default_params() +-- +ok +== +SELECT two_default_params(a := 5) +-- +ok +== +SELECT two_default_params(b := 3) +-- +ok +== +SELECT two_default_params(a := 5, a := 3) +-- +ok +== +SELECT two_default_params(b := 5, b := 3) +-- +ok +== +CREATE MACRO my_macro(a.b) AS 42; +-- +error: Parser Error: syntax error at or near "." +== +CREATE MACRO my_macro(a.b.c) AS 42; +-- +error: Parser Error: syntax error at or near "." +== +CREATE MACRO my_macro(a) AS 42; +-- +ok +== +SELECT my_macro(x := 42); +-- +ok +== +SELECT my_macro(a := 42, a := 42); +-- +ok +== +create macro zz1(x) as (select 10+x); +-- +ok +== +create macro zz2(x) as 20+x; +-- +ok +== +select zz1(1),zz2(2); +-- +ok +== +select function_name, parameters, macro_definition +from duckdb_functions() +where function_name like 'zz%' +and macro_definition like '%macro_parameters%'; +-- +ok +== diff --git a/parser/testdata/corpus/sql/catalog/function/test_simple_macro.test.metadata.json b/parser/testdata/corpus/sql/catalog/function/test_simple_macro.test.metadata.json new file mode 100644 index 0000000..277e1ef --- /dev/null +++ b/parser/testdata/corpus/sql/catalog/function/test_simple_macro.test.metadata.json @@ -0,0 +1,9 @@ +{ + "todo": { + "5c08f89028c1de02": "transformer-raised parser error: upstream rejects in the transformer, not the grammar; expected to clear as transformers land (milestones 3-5)", + "7dca7ca4eab6a6fb": "transformer-raised parser error: upstream rejects in the transformer, not the grammar; expected to clear as transformers land (milestones 3-5)", + "8c107818c0249ab5": "transformer-raised parser error: upstream rejects in the transformer, not the grammar; expected to clear as transformers land (milestones 3-5)", + "b6d9d3d217115c2b": "transformer-raised parser error: upstream rejects in the transformer, not the grammar; expected to clear as transformers land (milestones 3-5)", + "da128795699d6786": "transformer-raised parser error: upstream rejects in the transformer, not the grammar; expected to clear as transformers land (milestones 3-5)" + } +} diff --git a/parser/testdata/corpus/sql/catalog/function/test_subquery_macro.test b/parser/testdata/corpus/sql/catalog/function/test_subquery_macro.test new file mode 100644 index 0000000..3655e89 --- /dev/null +++ b/parser/testdata/corpus/sql/catalog/function/test_subquery_macro.test @@ -0,0 +1,53 @@ +# source: test/sql/catalog/function/test_subquery_macro.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +CREATE MACRO subquery(a) AS (SELECT a) +-- +ok +== +SELECT subquery(1) +-- +ok +== +SELECT subquery(NULL) +-- +ok +== +SELECT subquery(3) + a FROM integers +-- +ok +== +SELECT subquery(a) FROM integers +-- +ok +== +CREATE MACRO a1(a) AS (SELECT a + a FROM integers) +-- +ok +== +CREATE MACRO a1(b) AS (SELECT a + a FROM integers) +-- +ok +== +SELECT a1(3) +-- +ok +== +SELECT a1(3) + a FROM integers +-- +ok +== +CREATE MACRO a2(a) AS (SELECT i.a + a FROM integers i) +-- +ok +== +CREATE MACRO a2(b) AS (SELECT i.a + b FROM integers i) +-- +ok +== +SELECT a2(3) +-- +ok +== diff --git a/parser/testdata/corpus/sql/catalog/function/test_table_macro.test b/parser/testdata/corpus/sql/catalog/function/test_table_macro.test new file mode 100644 index 0000000..fff027e --- /dev/null +++ b/parser/testdata/corpus/sql/catalog/function/test_table_macro.test @@ -0,0 +1,118 @@ +# source: test/sql/catalog/function/test_table_macro.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +CREATE TABLE test_tbl (id INT, name string); +-- +ok +== +CREATE TABLE test2_tbl (id INT, name string); +-- +ok +== +CREATE TABLE greek_tbl (id INT, name string); +-- +ok +== +INSERT INTO test_tbl VALUES (1,'tom'), (2,'dick'),(3,'harry'), (4,'mary'), (5,'mungo'), (6,'midge'); +-- +ok +== +INSERT INTO test_tbl VALUES (20,'andrew'), (21,'boris'),(22,'Caleb'), (23,'david'), (24,'evan'); +-- +ok +== +INSERT INTO greek_tbl VALUES (1, 'alpha'), (2, 'beta'), (3, 'gamma'), (4, 'delta'), (5, 'epsilon'),(6, 'zeta'), (7, 'eta') , (8, 'theta'), (9, 'iota') , (10, 'kappa'); +-- +ok +== +CREATE MACRO xt(a,_name) as TABLE SELECT * FROM test_tbl WHERE(id>=a or name=_name); +-- +ok +== +CREATE MACRO xt2(a,_name) as TABLE SELECT * FROM test_tbl WHERE(id>=a or name like _name); +-- +ok +== +CREATE MACRO sgreek(a,b,c) as TABLE SELECT a,b FROM greek_tbl WHERE(id >= c); +-- +ok +== +( SELECT* FROM xt(1, 'tom') UNION SELECT* FROM xt2(1, '%%%') ) INTERSECT SELECT* FROM xt(100,'midge'); +-- +ok +== +(SELECT* FROM xt(1, 'tom') EXCEPT SELECT* FROM xt(20,'tom' )) INTERSECT SELECT* FROM xt(100,'harry'); +-- +ok +== +SELECT * FROM xt(200,'andrew'); +-- +ok +== +SELECT * FROM xt2(100,'m%'); +-- +ok +== +CREATE MACRO xtm(cmp_str) as TABLE SELECT id, name FROM test_tbl WHERE( name similar to cmp_str); +-- +ok +== +SELECT * FROM xtm('m.*'); +-- +ok +== +CREATE MACRO xt_reg(cmp) as TABLE SELECT * FROM test_tbl WHERE regexp_matches(name ,cmp ); +-- +ok +== +SELECT * FROM xt_reg('^m'); +-- +ok +== +CREATE MACRO cmp(a,m) as regexp_matches(a,m) or a similar to m; +-- +ok +== +CREATE MACRO gm(m) as TABLE SELECT * FROM greek_tbl WHERE cmp(name,m); +-- +ok +== +SELECT * FROM gm('^m'); +-- +ok +== +CREATE MACRO xt(a,b) as a+b; +-- +ok +== +DROP MACRO TABLE xt; +-- +ok +== +CREATE MACRO xt(id, imax) as TABLE SELECT id,name FROM test_tbl WHERE id<=imax; +-- +ok +== +SELECT * FROM xt(id,1); +-- +ok +== +CREATE MACRO range(a,b) as TABLE select a,b from test_tbl; +-- +ok +== +SELECT * FROM test_tbl where id>=(SELECT max(id) FROM xt(id,30)); +-- +ok +== +SELECT * FROM greek_tbl where id<=(SELECT min(id) FROM xt(id,30)); +-- +ok +== +SELECT schema_name, function_name, function_type, description, return_type, parameters, parameter_types, varargs, macro_definition FROM duckdb_functions() WHERE function_type = 'table_macro' AND + ( function_name = 'sgreek' or function_name = 'xt') order by function_name; +-- +ok +== diff --git a/parser/testdata/corpus/sql/catalog/function/test_table_macro_args.test b/parser/testdata/corpus/sql/catalog/function/test_table_macro_args.test new file mode 100644 index 0000000..a9e94d4 --- /dev/null +++ b/parser/testdata/corpus/sql/catalog/function/test_table_macro_args.test @@ -0,0 +1,116 @@ +# source: test/sql/catalog/function/test_table_macro_args.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +CREATE TABLE cards_tbl (val int, name string, suit string); +-- +ok +== +INSERT INTO cards_tbl values (1, 'ace', 'clubs'), (11,'jack', 'clubs' ), +(12, 'queen', 'clubs' ), (13, 'king', 'clubs'); +-- +ok +== +INSERT INTO cards_tbl values (1, 'ace', 'diamonds'), (11,'jack', 'diamonds' ), +(12, 'queen', 'diamonds' ), (13, 'king', 'diamonds'); +-- +ok +== +INSERT INTO cards_tbl values (1, 'ace', 'hearts'), (11,'jack', 'hearts' ), +(12, 'queen', 'hearts' ), (13, 'king', 'hearts'); +-- +ok +== +INSERT INTO cards_tbl values (1, 'ace', 'spades'), (11,'jack', 'spades' ), +(12, 'queen', 'spades' ), (13, 'king', 'spades'); +-- +ok +== +CREATE MACRO card_select(_val_min:=1, _val_max:=1, _name:='%', _suit:='%') +as TABLE SELECT * FROM cards_tbl WHERE val>=_val_min AND val<=_val_max AND name like _name AND suit like _suit; +-- +ok +== +SELECT DISTINCT val from card_select(); +-- +ok +== +SELECT * FROM card_select(_suit:='clubs'); +-- +ok +== +SELECT * FROM card_select(_name:='king', _val_max:=13) ORDER BY suit; +-- +ok +== +SELECT count(suit) FROM card_select() GROUP BY ALL; +-- +ok +== +SELECT * FROM card_select(_name:='king', _val_max:=13, _suit:='hearts', _val_min:=10); +-- +ok +== +CREATE MACRO card_select_args(_val_min, _val_max, _name:='%', _suit:='%') +as TABLE SELECT * FROM cards_tbl WHERE val>=_val_min AND val<=_val_max AND name like _name AND suit like _suit; +-- +ok +== +SELECT * FROM card_select_args(_name:='king',1, 13); +-- +ok +== +SELECT suit FROM card_select_args(1, 13, _name:='king' ) ORDER BY suit; +-- +ok +== +CREATE MACRO card_dfl() as TABLE SELECT DISTINCT suit FROM cards_tbl where suit='hearts'; +-- +ok +== +SELECT * FROM card_dfl(); +-- +ok +== +CREATE MACRO sc(aorder, border, nlimit) AS TABLE SELECT * FROM cards_tbl ORDER BY aorder,border LIMIT nlimit; +-- +ok +== +SELECT * FROM sc(name, suit, 4); +-- +ok +== +CREATE MACRO sc2(dlimit, noffset) AS TABLE SELECT DISTINCT suit from cards_tbl order by all limit dlimit% offset noffset; +-- +ok +== +SELECT * FROM sc2(50.0, 2); +-- +ok +== +CREATE MACRO sc3(col) AS TABLE SELECT DISTINCT ON (col) col FROM cards_tbl ORDER BY col; +-- +ok +== +SELECT * FROM sc3(name); +-- +ok +== +SELECT * FROM sc3(suit); +-- +ok +== +CREATE MACRO card_no_tbl() as TABLE SELECT * FROM suit_tbl; +-- +ok +== +CREATE MACRO card_select_args(_val_min, _name:='%', _suit:='%', _val_max) +as TABLE SELECT * FROM cards_tbl WHERE val>=_val_min AND val<=_val_max AND name like _name AND suit like _suit; +-- +error: Parser Error: Parameter without a default follows parameter with a default +== +CREATE MACRO card_select_val(_val_min, _val_min) as TABLE SELECT * FROM cards_tbl WHERE val>=_val_min AND val<=_val_max; +-- +error: Parser Error: Duplicate parameter '_val_min' in macro definition +== diff --git a/parser/testdata/corpus/sql/catalog/function/test_table_macro_args.test.metadata.json b/parser/testdata/corpus/sql/catalog/function/test_table_macro_args.test.metadata.json new file mode 100644 index 0000000..bae2b14 --- /dev/null +++ b/parser/testdata/corpus/sql/catalog/function/test_table_macro_args.test.metadata.json @@ -0,0 +1,6 @@ +{ + "todo": { + "9f3aa745137aa39f": "transformer-raised parser error: upstream rejects in the transformer, not the grammar; expected to clear as transformers land (milestones 3-5)", + "bee16037c4cea027": "transformer-raised parser error: upstream rejects in the transformer, not the grammar; expected to clear as transformers land (milestones 3-5)" + } +} diff --git a/parser/testdata/corpus/sql/catalog/function/test_table_macro_complex.test b/parser/testdata/corpus/sql/catalog/function/test_table_macro_complex.test new file mode 100644 index 0000000..9f9303f --- /dev/null +++ b/parser/testdata/corpus/sql/catalog/function/test_table_macro_complex.test @@ -0,0 +1,52 @@ +# source: test/sql/catalog/function/test_table_macro_complex.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +CREATE MACRO my_values(m,s) as TABLE select * from (values (1.0*m+s,'adam'), (2.0*m+s,'ben'), +(3.0*m+s,'cris'), (4.0*m+s,'desmond'),(5.0*m+s, 'eric')); +-- +ok +== +SELECT sum(col0) from my_values(10.0,5.0); +-- +ok +== +CREATE MACRO my_values_union(m1,s1,m2,s2) as TABLE select * from my_values(m1,s1) UNION select * from my_values(m2,s2); +-- +ok +== +select max(col0) from my_values_union(1.0,2.0,3.0,20.0); +-- +ok +== +CREATE MACRO dates_between(date_min, date_max, ilimit:=100) AS TABLE WITH dates(date) AS +(SELECT * FROM range(date '0000-01-01', date '3000-01-01', interval '1' month)) +SELECT * FROM dates WHERE date between date_min AND date_max; +-- +ok +== +select * from dates_between('2021-01-01', '2021-02-04'); +-- +ok +== +CREATE MACRO fibonacci(n0, n1, nlimit, noffset) AS TABLE +WITH RECURSIVE fib AS ( + SELECT 1 AS n, + n0::bigint AS "fibₙ", + n1::bigint AS "fibₙ₊₁" + UNION ALL + SELECT n+1, + "fibₙ₊₁", + "fibₙ" + "fibₙ₊₁" + FROM fib +) +SELECT n, "fibₙ" FROM fib +LIMIT nlimit OFFSET noffset; +-- +ok +== +SELECT * FROM fibonacci(1, 2, 5, 10); +-- +ok +== diff --git a/parser/testdata/corpus/sql/catalog/function/test_table_macro_copy.test b/parser/testdata/corpus/sql/catalog/function/test_table_macro_copy.test new file mode 100644 index 0000000..9d4f31f --- /dev/null +++ b/parser/testdata/corpus/sql/catalog/function/test_table_macro_copy.test @@ -0,0 +1,18 @@ +# source: test/sql/catalog/function/test_table_macro_copy.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +ATTACH '{TEST_DIR}/table_macro2.db' +-- +ok +== +COPY FROM DATABASE table_macro TO table_macro2 +-- +ok +== +SELECT database_name, schema_name, function_name, function_type, description, return_type, parameters, parameter_types, varargs, macro_definition FROM duckdb_functions() WHERE function_type = 'table_macro' AND + ( function_name = 'sgreek' or function_name = 'xt') order by database_name, function_name; +-- +ok +== diff --git a/parser/testdata/corpus/sql/catalog/function/test_table_macro_groups.test b/parser/testdata/corpus/sql/catalog/function/test_table_macro_groups.test new file mode 100644 index 0000000..4668ba8 --- /dev/null +++ b/parser/testdata/corpus/sql/catalog/function/test_table_macro_groups.test @@ -0,0 +1,69 @@ +# source: test/sql/catalog/function/test_table_macro_groups.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +CREATE TABLE car_pool ( + -- define columns (name / type / default value / nullable) + id DECIMAL , + producer VARCHAR(50) , + model VARCHAR(50) , + yyyy DECIMAL CHECK (yyyy BETWEEN 1970 AND 2020), + counter DECIMAL CHECK (counter >= 0), + CONSTRAINT car_pool_pk PRIMARY KEY (id) +); +-- +ok +== +INSERT INTO car_pool VALUES + ( 1, 'VW', 'Golf', 2005, 5), + ( 2, 'VW', 'Golf', 2006, 2), + ( 3, 'VW', 'Golf', 2007, 3), + ( 4, 'VW', 'Golf', 2008, 3), + ( 5, 'VW', 'Passat', 2005, 5), + ( 6, 'VW', 'Passat', 2006, 1), + ( 7, 'VW', 'Beetle', 2005, 1), + ( 8, 'VW', 'Beetle', 2006, 2), + ( 9, 'VW', 'Beetle', 2008, 4), + (10, 'Toyota', 'Corolla', 2005, 4), + (11, 'Toyota', 'Corolla', 2006, 3), + (12, 'Toyota', 'Corolla', 2007, 2), + (13, 'Toyota', 'Corolla', 2008, 4), + (14, 'Toyota', 'Prius', 2005, 1), + (15, 'Toyota', 'Prius', 2006, 1), + (16, 'Toyota', 'Hilux', 2005, 1), + (17, 'Toyota', 'Hilux', 2006, 1), + (18, 'Toyota', 'Hilux', 2008, 1); +-- +ok +== +CREATE MACRO car_pool_cube(g1, g2, hcnt:=1) AS +TABLE SELECT g1, g2, sum(counter) AS cnt FROM car_pool +GROUP BY CUBE(g1, g2) HAVING cnt >= hcnt order by g1 NULLS LAST, g2 NULLS LAST; +-- +ok +== +SELECT * FROM car_pool_cube(producer, model, hcnt:=4.0); +-- +ok +== +CREATE MACRO car_pool_rollup(g1, g2, hcnt:=1) AS +TABLE SELECT g1, g2, sum(counter) AS cnt FROM car_pool +GROUP BY ROLLUP(g1, g2) HAVING cnt >= hcnt order by g1, g2; +-- +ok +== +SELECT * FROM car_pool_rollup(model, yyyy, hcnt:=4); +-- +ok +== +CREATE MACRO car_pool_groups(g1, g2, hcnt:=1) AS +TABLE SELECT g1, g2, sum(counter) AS cnt FROM car_pool +GROUP BY (g1, g2) HAVING cnt >= hcnt order by g1, g2; +-- +ok +== +SELECT * FROM car_pool_groups(model, yyyy, hcnt:=2); +-- +ok +== diff --git a/parser/testdata/corpus/sql/catalog/function/test_window_macro.test b/parser/testdata/corpus/sql/catalog/function/test_window_macro.test new file mode 100644 index 0000000..db7a677 --- /dev/null +++ b/parser/testdata/corpus/sql/catalog/function/test_window_macro.test @@ -0,0 +1,103 @@ +# source: test/sql/catalog/function/test_window_macro.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +CREATE OR REPLACE MACRO my_agg(x) AS SUM(CASE WHEN x THEN 1 END); +-- +ok +== +select my_agg(range) +from range(2); +-- +ok +== +select my_agg(range) OVER () +from range(2); +-- +ok +== +CREATE OR REPLACE MACRO my_func(x) AS mod(x, 2); +-- +ok +== +select my_func(range) +from range(2); +-- +ok +== +select my_func(range) OVER () +from range(2); +-- +ok +== +CREATE OR REPLACE MACRO my_case(x) AS (CASE WHEN x THEN 1 END); +-- +ok +== +select my_case(range) +from range(2); +-- +ok +== +select my_case(range) OVER () +from range(2); +-- +ok +== +CREATE MACRO my_lag(x) AS LAG(x); +-- +ok +== +CREATE MACRO my_lead(x) AS LEAD(x); +-- +ok +== +CREATE MACRO my_rn() AS ROW_NUMBER(); +-- +ok +== +CREATE MACRO my_rank() AS RANK(); +-- +ok +== +CREATE MACRO my_dense_rank() AS DENSE_RANK(); +-- +ok +== +CREATE MACRO my_sum(x) AS SUM(x); +-- +ok +== +SELECT my_sum(i) FILTER (WHERE i > 3) OVER () FROM range(10) t(i) LIMIT 1; +-- +ok +== +CREATE MACRO my_count(x) AS COUNT(x); +-- +ok +== +SELECT my_count(DISTINCT i % 3) OVER () FROM range(10) t(i) LIMIT 1; +-- +ok +== +CREATE MACRO sum_positive(x) AS SUM(x) FILTER (WHERE x > 0); +-- +ok +== +SELECT sum_positive(i-5) FILTER (WHERE (i-5) < 3) OVER () FROM range(10) t(i) LIMIT 1; +-- +ok +== +SELECT LIST(i ORDER BY i DESC) OVER (PARTITION BY i % 2) FROM range(6) t(i) ORDER BY i; +-- +ok +== +CREATE MACRO my_list(x) AS LIST(x ORDER BY x DESC); +-- +ok +== +SELECT my_list(i) OVER (PARTITION BY i % 2) FROM range(6) t(i) ORDER BY i; +-- +ok +== diff --git a/parser/testdata/corpus/sql/catalog/information_schema_read_only.test b/parser/testdata/corpus/sql/catalog/information_schema_read_only.test new file mode 100644 index 0000000..18ae8e4 --- /dev/null +++ b/parser/testdata/corpus/sql/catalog/information_schema_read_only.test @@ -0,0 +1,17 @@ +# source: test/sql/catalog/information_schema_read_only.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +CREATE TABLE system.information_schema.tbl(i INT) +-- +ok +== +CREATE TABLE information_schema.tbl(i INT) +-- +ok +== +CREATE TABLE pg_catalog.tbl(i INT) +-- +ok +== diff --git a/parser/testdata/corpus/sql/catalog/issue_9459.test b/parser/testdata/corpus/sql/catalog/issue_9459.test new file mode 100644 index 0000000..725ca2c --- /dev/null +++ b/parser/testdata/corpus/sql/catalog/issue_9459.test @@ -0,0 +1,13 @@ +# source: test/sql/catalog/issue_9459.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +create schema """cursed_schema"; +-- +ok +== +drop schema """cursed_schema"; +-- +ok +== diff --git a/parser/testdata/corpus/sql/catalog/nested_schema/create_nested_schema.test b/parser/testdata/corpus/sql/catalog/nested_schema/create_nested_schema.test new file mode 100644 index 0000000..2964b46 --- /dev/null +++ b/parser/testdata/corpus/sql/catalog/nested_schema/create_nested_schema.test @@ -0,0 +1,54 @@ +# source: test/sql/catalog/nested_schema/create_nested_schema.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +CREATE SCHEMA memory.s2; +-- +ok +== +CREATE SCHEMA db2.s3; +-- +ok +== +CREATE SCHEMA s1.child; +-- +ok +== +CREATE SCHEMA memory.s1.child2; +-- +ok +== +CREATE SCHEMA s1.child.grandchild; +-- +ok +== +CREATE SCHEMA db2.s3.s3child; +-- +ok +== +SELECT database_name, schema_name, parent_schema, parent_schema_oid IS NULL +FROM duckdb_schemas() +WHERE schema_name IN ('s1','s2','s3','child','child2','grandchild','s3child') +ORDER BY database_name, schema_name; +-- +ok +== +SELECT p.oid = c.parent_schema_oid +FROM duckdb_schemas() c, duckdb_schemas() p +WHERE c.schema_name = 'child' AND p.schema_name = 's1' AND p.database_name = 'memory'; +-- +ok +== +CREATE SCHEMA IF NOT EXISTS s1.child; +-- +ok +== +CREATE SCHEMA does_not_exist.child; +-- +ok +== +CREATE SCHEMA s1.missing.grandchild; +-- +ok +== diff --git a/parser/testdata/corpus/sql/catalog/nested_schema/drop_nested_schema.test b/parser/testdata/corpus/sql/catalog/nested_schema/drop_nested_schema.test new file mode 100644 index 0000000..080c02d --- /dev/null +++ b/parser/testdata/corpus/sql/catalog/nested_schema/drop_nested_schema.test @@ -0,0 +1,142 @@ +# source: test/sql/catalog/nested_schema/drop_nested_schema.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +CREATE SCHEMA s1.sibling; +-- +ok +== +DROP SCHEMA s1.child.grandchild; +-- +ok +== +SELECT schema_name, parent_schema FROM duckdb_schemas() +WHERE database_name = 'memory' AND schema_name IN ('s1','child','grandchild','sibling') +ORDER BY schema_name; +-- +ok +== +CREATE SCHEMA s2; +-- +ok +== +CREATE SCHEMA s2.child; +-- +ok +== +DROP SCHEMA memory.s2.child; +-- +ok +== +SELECT count(*) FROM duckdb_schemas() WHERE database_name = 'memory' AND schema_name = 's2' AND parent_schema IS NULL; +-- +ok +== +SELECT count(*) FROM duckdb_schemas() WHERE database_name = 'memory' AND schema_name = 'child' AND parent_schema = 's2'; +-- +ok +== +DROP SCHEMA s1.child; +-- +ok +== +SELECT schema_name, parent_schema FROM duckdb_schemas() +WHERE database_name = 'memory' AND schema_name IN ('child','grandchild') +ORDER BY schema_name; +-- +ok +== +DROP SCHEMA s1.child CASCADE; +-- +ok +== +SELECT count(*) FROM duckdb_schemas() WHERE database_name = 'memory' AND schema_name IN ('child','grandchild'); +-- +ok +== +SELECT schema_name, parent_schema FROM duckdb_schemas() +WHERE database_name = 'memory' AND schema_name IN ('s1','sibling') +ORDER BY schema_name; +-- +ok +== +DROP SCHEMA s1 CASCADE; +-- +ok +== +SELECT count(*) FROM duckdb_schemas() +WHERE database_name = 'memory' AND schema_name IN ('s1','child','grandchild','sibling'); +-- +ok +== +CREATE SCHEMA db2.a; +-- +ok +== +CREATE SCHEMA db2.a.b; +-- +ok +== +DROP SCHEMA db2.a; +-- +ok +== +DROP SCHEMA db2.a CASCADE; +-- +ok +== +SELECT count(*) FROM duckdb_schemas() WHERE database_name = 'db2' AND schema_name IN ('a','b'); +-- +ok +== +DROP SCHEMA IF EXISTS s1.child; +-- +ok +== +DROP SCHEMA IF EXISTS s1.does_not_exist; +-- +ok +== +DROP SCHEMA s1.does_not_exist; +-- +ok +== +DROP SCHEMA s1.missing.child; +-- +ok +== +CREATE OR REPLACE SCHEMA s1.child; +-- +ok +== +SELECT schema_name, parent_schema FROM duckdb_schemas() +WHERE database_name = 'memory' AND schema_name = 'child'; +-- +ok +== +CREATE SCHEMA n1; +-- +ok +== +CREATE SCHEMA n2; +-- +ok +== +CREATE SCHEMA n1.dup; +-- +ok +== +CREATE SCHEMA n2.dup; +-- +ok +== +DROP SCHEMA n1.dup; +-- +ok +== +SELECT schema_name, parent_schema FROM duckdb_schemas() +WHERE database_name = 'memory' AND schema_name = 'dup'; +-- +ok +== diff --git a/parser/testdata/corpus/sql/catalog/nested_schema/drop_nested_schema_persist.test b/parser/testdata/corpus/sql/catalog/nested_schema/drop_nested_schema_persist.test new file mode 100644 index 0000000..d57646d --- /dev/null +++ b/parser/testdata/corpus/sql/catalog/nested_schema/drop_nested_schema_persist.test @@ -0,0 +1,68 @@ +# source: test/sql/catalog/nested_schema/drop_nested_schema_persist.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +CREATE SCHEMA parent; +-- +ok +== +CREATE SCHEMA parent.child; +-- +ok +== +CREATE SCHEMA parent.child.grandchild; +-- +ok +== +CREATE SCHEMA parent.sibling; +-- +ok +== +DROP SCHEMA parent.child.grandchild; +-- +ok +== +SELECT schema_name, parent_schema FROM duckdb_schemas() +WHERE schema_name IN ('parent','child','grandchild','sibling') ORDER BY schema_name; +-- +ok +== +CREATE SCHEMA parent.child.gc1; +-- +ok +== +CREATE SCHEMA parent.child.gc2; +-- +ok +== +DROP SCHEMA parent.child CASCADE; +-- +ok +== +SELECT schema_name, parent_schema FROM duckdb_schemas() +WHERE schema_name IN ('parent','child','grandchild','gc1','gc2','sibling') ORDER BY schema_name; +-- +ok +== +CREATE SCHEMA parent.child +-- +ok +== +CREATE SCHEMA parent.child.leaf +-- +ok +== +DROP SCHEMA parent.child; +-- +ok +== +DROP SCHEMA parent CASCADE; +-- +ok +== +SELECT count(*) FROM duckdb_schemas() +WHERE schema_name IN ('parent','child','grandchild','gc1','gc2','sibling','leaf'); +-- +ok +== diff --git a/parser/testdata/corpus/sql/catalog/nested_schema/nested_alter.test b/parser/testdata/corpus/sql/catalog/nested_schema/nested_alter.test new file mode 100644 index 0000000..9765b84 --- /dev/null +++ b/parser/testdata/corpus/sql/catalog/nested_schema/nested_alter.test @@ -0,0 +1,173 @@ +# source: test/sql/catalog/nested_schema/nested_alter.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +CREATE SCHEMA s1.s2; +-- +ok +== +CREATE TABLE s1.s2.t(i INTEGER, j INTEGER); +-- +ok +== +INSERT INTO s1.s2.t VALUES (1, 10); +-- +ok +== +ALTER TABLE s1.s2.t RENAME TO t2; +-- +ok +== +SELECT * FROM s1.s2.t2; +-- +ok +== +SELECT * FROM s1.s2.t; +-- +ok +== +ALTER TABLE s1.s2.t2 RENAME TO t; +-- +ok +== +ALTER TABLE s1.s2.t RENAME COLUMN j TO k; +-- +ok +== +SELECT k FROM s1.s2.t; +-- +ok +== +ALTER TABLE s1.s2.t ADD COLUMN l INTEGER DEFAULT 42; +-- +ok +== +SELECT i, k, l FROM s1.s2.t; +-- +ok +== +ALTER TABLE s1.s2.t DROP COLUMN l; +-- +ok +== +ALTER TABLE s1.s2.t ALTER COLUMN k TYPE VARCHAR; +-- +ok +== +SELECT name, type FROM pragma_table_info('s1.s2.t'); +-- +ok +== +ALTER TABLE s1.s2.t ALTER COLUMN k TYPE INTEGER; +-- +ok +== +ALTER TABLE s1.s2.t ALTER COLUMN k SET DEFAULT 7; +-- +ok +== +ALTER TABLE s1.s2.t ALTER COLUMN i SET NOT NULL; +-- +ok +== +INSERT INTO s1.s2.t (k) VALUES (1); +-- +ok +== +ALTER TABLE s1.s2.t ALTER COLUMN i DROP NOT NULL; +-- +ok +== +ALTER TABLE s1.s2.t ALTER COLUMN k DROP DEFAULT; +-- +ok +== +ALTER TABLE s1.s2.t ADD PRIMARY KEY (i); +-- +ok +== +INSERT INTO s1.s2.t VALUES (1, 99); +-- +ok +== +CREATE VIEW s1.s2.v AS SELECT * FROM s1.s2.t; +-- +ok +== +ALTER VIEW s1.s2.v RENAME TO v2; +-- +ok +== +SELECT * FROM s1.s2.v2; +-- +ok +== +COMMENT ON TABLE s1.s2.t IS 'nested table'; +-- +ok +== +SELECT comment FROM duckdb_tables() WHERE table_name = 't'; +-- +ok +== +COMMENT ON COLUMN s1.s2.t.i IS 'nested column'; +-- +ok +== +SELECT comment FROM duckdb_columns() WHERE table_name = 't' AND column_name = 'i'; +-- +ok +== +COMMENT ON VIEW s1.s2.v2 IS 'nested view'; +-- +ok +== +SELECT comment FROM duckdb_views() WHERE view_name = 'v2'; +-- +ok +== +CREATE SEQUENCE s1.s2.seq; +-- +ok +== +COMMENT ON SEQUENCE s1.s2.seq IS 'nested sequence'; +-- +ok +== +SELECT comment FROM duckdb_sequences() WHERE sequence_name = 'seq'; +-- +ok +== +ALTER TABLE s1.nope.t RENAME TO t3; +-- +ok +== +ALTER TABLE IF EXISTS s1.nope.t RENAME TO t3; +-- +ok +== +COMMENT ON TABLE s1.nope.t IS 'x'; +-- +ok +== +CREATE SCHEMA a; +-- +ok +== +CREATE SCHEMA a.b; +-- +ok +== +CREATE TABLE a.b.tt(x INTEGER); +-- +ok +== +ALTER TABLE a.b.tt RENAME TO tt2; +-- +ok +== +SELECT database_name, schema_name, table_name FROM duckdb_tables() WHERE table_name = 'tt2'; +-- +ok +== diff --git a/parser/testdata/corpus/sql/catalog/nested_schema/nested_constraints.test b/parser/testdata/corpus/sql/catalog/nested_schema/nested_constraints.test new file mode 100644 index 0000000..e656f6c --- /dev/null +++ b/parser/testdata/corpus/sql/catalog/nested_schema/nested_constraints.test @@ -0,0 +1,81 @@ +# source: test/sql/catalog/nested_schema/nested_constraints.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +CREATE TABLE s1.s2.pk(i INTEGER PRIMARY KEY, s VARCHAR UNIQUE); +-- +ok +== +INSERT INTO s1.s2.pk VALUES (1, 'a'), (2, 'b'); +-- +ok +== +INSERT INTO s1.s2.pk VALUES (1, 'c'); +-- +ok +== +INSERT INTO s1.s2.pk VALUES (3, 'a'); +-- +ok +== +CREATE TABLE s1.s2.fk(j INTEGER REFERENCES pk(i)); +-- +ok +== +INSERT INTO s1.s2.fk VALUES (1); +-- +ok +== +INSERT INTO s1.s2.fk VALUES (99); +-- +ok +== +DROP TABLE s1.s2.pk; +-- +ok +== +DROP TABLE s1.s2.fk; +-- +ok +== +CREATE TABLE s1.s2.fk2(j INTEGER, FOREIGN KEY (j) REFERENCES s1.s2.pk(i)); +-- +ok +== +INSERT INTO s1.s2.fk2 VALUES (2); +-- +ok +== +INSERT INTO s1.s2.fk2 VALUES (99); +-- +ok +== +DELETE FROM s1.s2.pk WHERE i = 2; +-- +ok +== +CREATE SCHEMA s1.s3; +-- +ok +== +CREATE TABLE s1.s3.fk3(j INTEGER REFERENCES s2.pk(i)); +-- +ok +== +CREATE TABLE s1.s2.chk(i INTEGER CHECK (i > 0)); +-- +ok +== +INSERT INTO s1.s2.chk VALUES (1); +-- +ok +== +INSERT INTO s1.s2.chk VALUES (-1); +-- +ok +== +SELECT count(*) FROM duckdb_tables() WHERE database_name = 'memory'; +-- +ok +== diff --git a/parser/testdata/corpus/sql/catalog/nested_schema/nested_entries.test b/parser/testdata/corpus/sql/catalog/nested_schema/nested_entries.test new file mode 100644 index 0000000..bb9b23b --- /dev/null +++ b/parser/testdata/corpus/sql/catalog/nested_schema/nested_entries.test @@ -0,0 +1,209 @@ +# source: test/sql/catalog/nested_schema/nested_entries.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +CREATE TABLE s1.s2.t(i INTEGER); +-- +ok +== +INSERT INTO s1.s2.t VALUES (1), (2); +-- +ok +== +CREATE VIEW s1.s2.v AS SELECT i * 10 AS x FROM s1.s2.t; +-- +ok +== +SELECT * FROM s1.s2.v ORDER BY x; +-- +ok +== +SELECT schema_name, view_name FROM duckdb_views() WHERE view_name = 'v'; +-- +ok +== +SELECT * FROM s2.v; +-- +ok +== +CREATE OR REPLACE VIEW s1.s2.v AS SELECT i * 100 AS x FROM s1.s2.t; +-- +ok +== +CREATE SEQUENCE s1.s2.seq START 5; +-- +ok +== +SELECT nextval('s1.s2.seq'); +-- +ok +== +SELECT nextval('memory.s1.s2.seq'); +-- +error: Parser Error: Expected catalog.entry, schema.entry or entry: too many entries found (input: memory.s1.s2.seq) +== +SELECT schema_name, sequence_name FROM duckdb_sequences() WHERE sequence_name = 'seq'; +-- +ok +== +CREATE TABLE s1.s2.defaults(i INTEGER DEFAULT nextval('s1.s2.seq')); +-- +ok +== +INSERT INTO s1.s2.defaults DEFAULT VALUES; +-- +ok +== +SELECT i FROM s1.s2.defaults; +-- +ok +== +CREATE MACRO s1.s2.double(a) AS a * 2; +-- +ok +== +SELECT s1.s2.double(21); +-- +ok +== +CREATE MACRO s1.s2.tbl_macro() AS TABLE SELECT 42 AS x; +-- +ok +== +SELECT * FROM s1.s2.tbl_macro(); +-- +ok +== +SELECT schema_name, function_name FROM duckdb_functions() WHERE function_name = 'double'; +-- +ok +== +CREATE TYPE s1.s2.mood AS ENUM ('happy', 'sad'); +-- +ok +== +SELECT 'happy'::s1.s2.mood; +-- +ok +== +CREATE TABLE s1.s2.moods(m s1.s2.mood); +-- +ok +== +INSERT INTO s1.s2.moods VALUES ('sad'); +-- +ok +== +SELECT * FROM s1.s2.moods; +-- +ok +== +SELECT 'angry'::s1.s2.mood; +-- +ok +== +SELECT schema_name, type_name FROM duckdb_types() WHERE type_name = 'mood'; +-- +ok +== +SELECT 'happy'::s1.nope.mood; +-- +ok +== +CREATE INDEX idx ON s1.s2.t(i); +-- +ok +== +SELECT database_name, schema_name, index_name, table_name FROM duckdb_indexes() WHERE index_name = 'idx'; +-- +ok +== +DROP INDEX s1.s2.idx; +-- +ok +== +SELECT count(*) FROM duckdb_indexes() WHERE index_name = 'idx'; +-- +ok +== +CREATE TABLE s1.s2.log(i INTEGER); +-- +ok +== +CREATE TRIGGER trg AFTER INSERT ON s1.s2.t FOR EACH STATEMENT INSERT INTO s1.s2.log SELECT 1; +-- +ok +== +INSERT INTO s1.s2.t VALUES (3); +-- +ok +== +SELECT count(*) FROM s1.s2.log; +-- +ok +== +SELECT database_name, schema_name, trigger_name FROM duckdb_triggers() WHERE trigger_name = 'trg'; +-- +ok +== +DROP TRIGGER trg ON s1.s2.t; +-- +ok +== +SELECT count(*) FROM duckdb_triggers() WHERE trigger_name = 'trg'; +-- +ok +== +CREATE TABLE a.b.t(i INTEGER); +-- +ok +== +CREATE VIEW a.b.v AS SELECT 1 AS x; +-- +ok +== +CREATE SEQUENCE a.b.seq; +-- +ok +== +SELECT * FROM a.b.v; +-- +ok +== +SELECT nextval('a.b.seq'); +-- +ok +== +DROP VIEW s1.s2.v; +-- +ok +== +DROP SEQUENCE s1.s2.seq CASCADE; +-- +ok +== +DROP MACRO s1.s2.double; +-- +ok +== +DROP MACRO s1.s2.tbl_macro; +-- +ok +== +SELECT count(*) FROM duckdb_views() WHERE view_name = 'v' AND database_name = 'memory'; +-- +ok +== +SELECT count(*) FROM duckdb_sequences() WHERE sequence_name = 'seq' AND database_name = 'memory'; +-- +ok +== +SELECT count(*) FROM duckdb_functions() WHERE function_name IN ('double', 'tbl_macro'); +-- +ok +== +SELECT count(*) FROM duckdb_types() WHERE type_name = 'mood'; +-- +ok +== diff --git a/parser/testdata/corpus/sql/catalog/nested_schema/nested_entries.test.metadata.json b/parser/testdata/corpus/sql/catalog/nested_schema/nested_entries.test.metadata.json new file mode 100644 index 0000000..63a1f5f --- /dev/null +++ b/parser/testdata/corpus/sql/catalog/nested_schema/nested_entries.test.metadata.json @@ -0,0 +1,5 @@ +{ + "todo": { + "c2d50285cb7509bb": "transformer-raised parser error: upstream rejects in the transformer, not the grammar; expected to clear as transformers land (milestones 3-5)" + } +} diff --git a/parser/testdata/corpus/sql/catalog/nested_schema/nested_entries_persist.test b/parser/testdata/corpus/sql/catalog/nested_schema/nested_entries_persist.test new file mode 100644 index 0000000..c01d061 --- /dev/null +++ b/parser/testdata/corpus/sql/catalog/nested_schema/nested_entries_persist.test @@ -0,0 +1,121 @@ +# source: test/sql/catalog/nested_schema/nested_entries_persist.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +CREATE TABLE parent.child.t(i INTEGER); +-- +ok +== +INSERT INTO parent.child.t VALUES (1), (2); +-- +ok +== +CREATE VIEW parent.child.v AS SELECT i * 10 AS x FROM parent.child.t; +-- +ok +== +CREATE SEQUENCE parent.child.seq START 5; +-- +ok +== +CREATE MACRO parent.child.double(a) AS a * 2; +-- +ok +== +CREATE TYPE parent.child.mood AS ENUM ('happy', 'sad'); +-- +ok +== +CREATE INDEX idx ON parent.child.t(i); +-- +ok +== +SELECT * FROM parent.child.v ORDER BY x; +-- +ok +== +SELECT nextval('parent.child.seq'); +-- +ok +== +SELECT parent.child.double(21); +-- +ok +== +SELECT 'sad'::parent.child.mood; +-- +ok +== +SELECT 'happy'::parent.child.mood; +-- +ok +== +CREATE TABLE parent.child.pk(i INTEGER PRIMARY KEY); +-- +ok +== +INSERT INTO parent.child.pk VALUES (1); +-- +ok +== +CREATE TABLE parent.child.fk(j INTEGER REFERENCES pk(i)); +-- +ok +== +INSERT INTO parent.child.fk VALUES (1); +-- +ok +== +INSERT INTO parent.child.fk VALUES (2); +-- +ok +== +CREATE TABLE parent.child.log(i INTEGER); +-- +ok +== +CREATE TRIGGER trg AFTER INSERT ON parent.child.t FOR EACH STATEMENT INSERT INTO parent.child.log SELECT 1; +-- +ok +== +INSERT INTO parent.child.t VALUES (3); +-- +ok +== +SELECT count(*) FROM parent.child.log; +-- +ok +== +INSERT INTO parent.child.t VALUES (4); +-- +ok +== +DROP TRIGGER trg ON parent.child.t; +-- +ok +== +DROP VIEW parent.child.v; +-- +ok +== +DROP SEQUENCE parent.child.seq; +-- +ok +== +SELECT * FROM parent.child.v; +-- +ok +== +SELECT count(*) FROM duckdb_sequences() WHERE sequence_name = 'seq'; +-- +ok +== +SELECT count(*) FROM duckdb_schemas() WHERE schema_name IN ('parent', 'child'); +-- +ok +== +SELECT count(*) FROM duckdb_indexes(); +-- +ok +== diff --git a/parser/testdata/corpus/sql/catalog/nested_schema/nested_export.test b/parser/testdata/corpus/sql/catalog/nested_schema/nested_export.test new file mode 100644 index 0000000..22664b8 --- /dev/null +++ b/parser/testdata/corpus/sql/catalog/nested_schema/nested_export.test @@ -0,0 +1,103 @@ +# source: test/sql/catalog/nested_schema/nested_export.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +CREATE SCHEMA s1.s2.s3; +-- +ok +== +CREATE TABLE s1.s2.t(i INTEGER PRIMARY KEY, s VARCHAR); +-- +ok +== +INSERT INTO s1.s2.t VALUES (1, 'a'), (2, 'b'); +-- +ok +== +CREATE SEQUENCE s1.s2.seq START 7; +-- +ok +== +CREATE TABLE top(i INTEGER); +-- +ok +== +INSERT INTO top VALUES (99); +-- +ok +== +EXPORT DATABASE '{TEST_DIR}/nested_export'; +-- +ok +== +SELECT count(*) FROM read_text('{TEST_DIR}/nested_export/schema.sql') WHERE content LIKE '%CREATE SCHEMA s1.s2;%'; +-- +ok +== +SELECT count(*) FROM read_text('{TEST_DIR}/nested_export/schema.sql') WHERE content LIKE '%CREATE SCHEMA s1.s2.s3;%'; +-- +ok +== +SELECT count(*) FROM read_text('{TEST_DIR}/nested_export/schema.sql') WHERE content LIKE '%CREATE TABLE s1.s2.t(%'; +-- +ok +== +SELECT count(*) FROM read_text('{TEST_DIR}/nested_export/load.sql') WHERE content LIKE '%COPY s1.s2.t FROM%'; +-- +ok +== +SELECT count(*) FROM read_text('{TEST_DIR}/nested_export/schema.sql') WHERE content LIKE '%CREATE TABLE top(%'; +-- +ok +== +ATTACH ':memory:' AS imported; +-- +ok +== +USE imported; +-- +ok +== +IMPORT DATABASE '{TEST_DIR}/nested_export'; +-- +ok +== +SELECT * FROM s1.s2.t ORDER BY i; +-- +ok +== +SELECT * FROM top; +-- +ok +== +SELECT schema_name, parent_schema FROM duckdb_schemas() +WHERE database_name = 'imported' AND schema_name IN ('s1','s2','s3') ORDER BY schema_name; +-- +ok +== +INSERT INTO s1.s2.t VALUES (1, 'c'); +-- +ok +== +ATTACH ':memory:' AS copied; +-- +ok +== +COPY FROM DATABASE memory TO copied; +-- +ok +== +SELECT schema_name, parent_schema FROM duckdb_schemas() +WHERE database_name = 'copied' AND schema_name IN ('s1','s2','s3') ORDER BY schema_name; +-- +ok +== +USE copied; +-- +ok +== +SELECT count(*) FROM top; +-- +ok +== diff --git a/parser/testdata/corpus/sql/catalog/nested_schema/nested_schema_limits.test b/parser/testdata/corpus/sql/catalog/nested_schema/nested_schema_limits.test new file mode 100644 index 0000000..45ae643 --- /dev/null +++ b/parser/testdata/corpus/sql/catalog/nested_schema/nested_schema_limits.test @@ -0,0 +1,114 @@ +# source: test/sql/catalog/nested_schema/nested_schema_limits.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +INSERT INTO s1.s2.t VALUES (1); +-- +ok +== +SELECT * FROM memory.s1.s2.t; +-- +error: Parser Error: syntax error at or near "." +== +CREATE TABLE memory.s1.s2.t2(i INTEGER); +-- +error: Parser Error: syntax error at or near "." +== +USE s1.s2; +-- +ok +== +SET search_path='s1.s2'; +-- +ok +== +USE s1.nope; +-- +ok +== +ATTACH ':memory:' AS shadow; +-- +ok +== +CREATE SCHEMA shadow.inner_schema; +-- +ok +== +CREATE TABLE shadow.inner_schema.tbl(i INTEGER); +-- +ok +== +SELECT database_name, schema_name, table_name FROM duckdb_tables() WHERE table_name = 'tbl'; +-- +ok +== +CREATE TYPE shadow.inner_schema.ty AS ENUM ('from_catalog'); +-- +ok +== +SELECT 'from_catalog'::shadow.inner_schema.ty; +-- +ok +== +SELECT database_name, schema_name FROM duckdb_types() WHERE type_name = 'ty'; +-- +ok +== +CREATE VIEW shadow.inner_schema.v AS SELECT 1 AS x; +-- +ok +== +SELECT database_name, schema_name FROM duckdb_views() WHERE view_name = 'v'; +-- +ok +== +CREATE SCHEMA shadow; +-- +ok +== +DETACH shadow; +-- +ok +== +CREATE TYPE fallback_ty AS ENUM ('q'); +-- +ok +== +SELECT 'q'::s1.fallback_ty; +-- +ok +== +SELECT 'q'::s1.s2.fallback_ty; +-- +ok +== +SELECT 'q'::fallback_ty; +-- +ok +== +SHOW TABLES FROM s1.s2; +-- +ok +== +SHOW TABLES FROM s1.nope; +-- +ok +== +SELECT schema_name, table_name FROM duckdb_tables() WHERE table_name = 't'; +-- +ok +== +SELECT s.parent_schema FROM duckdb_tables() t JOIN duckdb_schemas() s ON t.schema_oid = s.oid +WHERE t.table_name = 't'; +-- +ok +== +SELECT table_schema, table_name FROM information_schema.tables WHERE table_name = 't'; +-- +ok +== +SELECT nspname FROM pg_catalog.pg_namespace WHERE nspname = 's2'; +-- +ok +== diff --git a/parser/testdata/corpus/sql/catalog/nested_schema/nested_schema_storage_version.test b/parser/testdata/corpus/sql/catalog/nested_schema/nested_schema_storage_version.test new file mode 100644 index 0000000..d101be3 --- /dev/null +++ b/parser/testdata/corpus/sql/catalog/nested_schema/nested_schema_storage_version.test @@ -0,0 +1,17 @@ +# source: test/sql/catalog/nested_schema/nested_schema_storage_version.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +ATTACH ':memory:' AS mem; +-- +ok +== +CREATE SCHEMA mem.p; +-- +ok +== +CREATE SCHEMA mem.p.c; +-- +ok +== diff --git a/parser/testdata/corpus/sql/catalog/nested_schema/nested_table.test b/parser/testdata/corpus/sql/catalog/nested_schema/nested_table.test new file mode 100644 index 0000000..fe39b19 --- /dev/null +++ b/parser/testdata/corpus/sql/catalog/nested_schema/nested_table.test @@ -0,0 +1,71 @@ +# source: test/sql/catalog/nested_schema/nested_table.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +CREATE TABLE s1.child.t1(i INTEGER); +-- +ok +== +CREATE TABLE s1.child.t2(j INTEGER); +-- +ok +== +SELECT database_name, schema_name, table_name FROM duckdb_tables() +WHERE table_name IN ('t1','t2') ORDER BY table_name; +-- +ok +== +SELECT count(*) FROM duckdb_tables() t, duckdb_schemas() s +WHERE t.table_name = 't1' AND t.schema_oid = s.oid AND s.parent_schema = 's1'; +-- +ok +== +CREATE TABLE db2.a.tt(x INTEGER); +-- +ok +== +SELECT database_name, schema_name, table_name FROM duckdb_tables() WHERE table_name = 'tt'; +-- +ok +== +DROP TABLE s1.child.t1; +-- +ok +== +SELECT table_name FROM duckdb_tables() WHERE table_name IN ('t1','t2'); +-- +ok +== +DROP TABLE s1.child.nope; +-- +ok +== +DROP TABLE IF EXISTS s1.child.nope; +-- +ok +== +DROP TABLE IF EXISTS s1.missing.nope; +-- +ok +== +SELECT count(*) FROM duckdb_tables() WHERE table_name = 't2'; +-- +ok +== +SELECT count(*) FROM duckdb_schemas() WHERE database_name = 'memory' AND schema_name = 'child'; +-- +ok +== +CREATE TABLE s1.child.t3(i INTEGER); +-- +ok +== +SELECT count(*) FROM duckdb_tables() WHERE table_name = 't3'; +-- +ok +== +SELECT count(*) FROM duckdb_schemas() WHERE database_name = 'memory' AND schema_name IN ('s1','child'); +-- +ok +== diff --git a/parser/testdata/corpus/sql/catalog/nested_schema/nested_table_columnref.test b/parser/testdata/corpus/sql/catalog/nested_schema/nested_table_columnref.test new file mode 100644 index 0000000..00e325e --- /dev/null +++ b/parser/testdata/corpus/sql/catalog/nested_schema/nested_table_columnref.test @@ -0,0 +1,125 @@ +# source: test/sql/catalog/nested_schema/nested_table_columnref.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +CREATE TABLE s1.s2.tbl(i INTEGER, s STRUCT(a INTEGER, b INTEGER)); +-- +ok +== +INSERT INTO s1.s2.tbl VALUES (1, {'a': 10, 'b': 20}); +-- +ok +== +SELECT s1.s2.tbl.i FROM s1.s2.tbl; +-- +ok +== +SELECT memory.s1.s2.tbl.i FROM s1.s2.tbl; +-- +ok +== +SELECT tbl.i FROM s1.s2.tbl; +-- +ok +== +SELECT i FROM s1.s2.tbl; +-- +ok +== +SELECT s1.s2.tbl.s.a FROM s1.s2.tbl; +-- +ok +== +SELECT tbl.s.b FROM s1.s2.tbl; +-- +ok +== +SELECT memory.s1.s2.tbl.s.a FROM s1.s2.tbl; +-- +ok +== +SELECT s.a FROM s1.s2.tbl; +-- +ok +== +SELECT s1.s2.tbl FROM s1.s2.tbl; +-- +ok +== +SELECT s2.tbl FROM s1.s2.tbl; +-- +ok +== +SELECT s2.tbl.i FROM s1.s2.tbl; +-- +ok +== +SELECT s1.tbl.i FROM s1.s2.tbl; +-- +ok +== +SELECT nope.s2.tbl.i FROM s1.s2.tbl; +-- +ok +== +CREATE TABLE s1.s2.dup(a INTEGER); +-- +ok +== +CREATE TABLE s1.s3.dup(b INTEGER); +-- +ok +== +INSERT INTO s1.s2.dup VALUES (100); +-- +ok +== +INSERT INTO s1.s3.dup VALUES (200); +-- +ok +== +SELECT s2.dup.a, s3.dup.b FROM s1.s2.dup, s1.s3.dup; +-- +ok +== +SELECT s1.s2.dup.a, s1.s3.dup.b FROM s1.s2.dup, s1.s3.dup; +-- +ok +== +SELECT s1.dup.a FROM s1.s2.dup, s1.s3.dup; +-- +ok +== +CREATE SCHEMA s4; +-- +ok +== +CREATE SCHEMA s4.s2; +-- +ok +== +CREATE TABLE s4.s2.dup(a INTEGER); +-- +ok +== +INSERT INTO s4.s2.dup VALUES (300); +-- +ok +== +SELECT s2.dup.a FROM s1.s2.dup, s4.s2.dup; +-- +ok +== +SELECT s1.s2.dup.a AS x, s4.s2.dup.a AS y FROM s1.s2.dup, s4.s2.dup; +-- +ok +== +SELECT t.i FROM s1.s2.tbl AS t; +-- +ok +== +SELECT s1.s2.tbl.i FROM s1.s2.tbl AS t; +-- +ok +== diff --git a/parser/testdata/corpus/sql/catalog/nested_schema/nested_table_dml.test b/parser/testdata/corpus/sql/catalog/nested_schema/nested_table_dml.test new file mode 100644 index 0000000..6c11b9c --- /dev/null +++ b/parser/testdata/corpus/sql/catalog/nested_schema/nested_table_dml.test @@ -0,0 +1,109 @@ +# source: test/sql/catalog/nested_schema/nested_table_dml.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +CREATE TABLE s1.child.t1(i INTEGER, s VARCHAR); +-- +ok +== +INSERT INTO s1.child.t1 VALUES (1, 'a'), (2, 'b'); +-- +ok +== +SELECT * FROM s1.child.t1 ORDER BY i; +-- +ok +== +INSERT INTO s1.child.t1 (s, i) VALUES ('c', 3); +-- +ok +== +INSERT INTO s1.child.t1 SELECT i + 10, s FROM s1.child.t1; +-- +ok +== +SELECT count(*) FROM s1.child.t1; +-- +ok +== +INSERT INTO s1.child.t1 VALUES (99, 'z') RETURNING i, s; +-- +ok +== +UPDATE s1.child.t1 SET s = 'updated' WHERE i = 99; +-- +ok +== +SELECT s FROM s1.child.t1 WHERE i = 99; +-- +ok +== +DELETE FROM s1.child.t1 WHERE i > 10; +-- +ok +== +CREATE TABLE s1.child.t2(i INTEGER, v INTEGER); +-- +ok +== +INSERT INTO s1.child.t2 VALUES (1, 100), (2, 200); +-- +ok +== +SELECT l.i, l.s, r.v FROM s1.child.t1 l JOIN s1.child.t2 r USING (i) ORDER BY l.i; +-- +ok +== +COPY s1.child.t1 TO '{TEST_DIR}/nested_table_dml.csv'; +-- +ok +== +COPY s1.child.t1 FROM '{TEST_DIR}/nested_table_dml.csv'; +-- +ok +== +DELETE FROM s1.child.t1 WHERE rowid >= 3; +-- +ok +== +SELECT name, type FROM pragma_table_info('s1.child.t1'); +-- +ok +== +INSERT INTO a.b.tt VALUES (5), (6); +-- +ok +== +SELECT sum(x) FROM a.b.tt; +-- +ok +== +DELETE FROM a.b.tt WHERE x = 5; +-- +ok +== +SELECT * FROM child.t1; +-- +ok +== +INSERT INTO child.t1 VALUES (1, 'a'); +-- +ok +== +INSERT INTO s1.nope.t1 VALUES (1, 'a'); +-- +ok +== +SELECT * FROM s1.nope.t1; +-- +ok +== +INSERT INTO s1.child.t1 VALUES (42, 'tx'); +-- +ok +== +SELECT * FROM s1.child.t1; +-- +ok +== diff --git a/parser/testdata/corpus/sql/catalog/nested_schema/nested_table_dml_persist.test b/parser/testdata/corpus/sql/catalog/nested_schema/nested_table_dml_persist.test new file mode 100644 index 0000000..38a69a0 --- /dev/null +++ b/parser/testdata/corpus/sql/catalog/nested_schema/nested_table_dml_persist.test @@ -0,0 +1,65 @@ +# source: test/sql/catalog/nested_schema/nested_table_dml_persist.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +CREATE TABLE parent.child.t1(i INTEGER, s VARCHAR); +-- +ok +== +INSERT INTO parent.child.t1 VALUES (1, 'a'), (2, 'b'); +-- +ok +== +SELECT * FROM parent.child.t1 ORDER BY i; +-- +ok +== +UPDATE parent.child.t1 SET s = 'updated' WHERE i = 1; +-- +ok +== +DELETE FROM parent.child.t1 WHERE i = 2; +-- +ok +== +INSERT INTO parent.child.t1 VALUES (3, 'c'); +-- +ok +== +CREATE TABLE parent.child.big(i INTEGER); +-- +ok +== +INSERT INTO parent.child.big SELECT * FROM range(200000); +-- +ok +== +SELECT count(*), sum(i) FROM parent.child.big; +-- +ok +== +INSERT INTO parent.child.t1 VALUES (4, 'd'); +-- +ok +== +INSERT INTO parent.child.big VALUES (999999); +-- +ok +== +INSERT INTO parent.child.t1 VALUES (5, 'e'); +-- +ok +== +SELECT count(*) FROM parent.child.t1; +-- +ok +== +SELECT count(*) FROM parent.child.big; +-- +ok +== +SELECT * FROM parent.child.t1; +-- +ok +== diff --git a/parser/testdata/corpus/sql/catalog/nested_schema/nested_table_persist.test b/parser/testdata/corpus/sql/catalog/nested_schema/nested_table_persist.test new file mode 100644 index 0000000..4a41103 --- /dev/null +++ b/parser/testdata/corpus/sql/catalog/nested_schema/nested_table_persist.test @@ -0,0 +1,54 @@ +# source: test/sql/catalog/nested_schema/nested_table_persist.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +CREATE TABLE parent.child.t1(i INTEGER); +-- +ok +== +CREATE TABLE parent.child.t2(j INTEGER); +-- +ok +== +CREATE TABLE parent.child.wal_table(k INTEGER); +-- +ok +== +DROP TABLE parent.child.t1; +-- +ok +== +SELECT table_name FROM duckdb_tables() +WHERE table_name IN ('t1','t2','wal_table') ORDER BY table_name; +-- +ok +== +SELECT count(*) FROM duckdb_tables() WHERE table_name IN ('t2','wal_table'); +-- +ok +== +SELECT count(*) FROM duckdb_schemas() WHERE schema_name IN ('parent','child'); +-- +ok +== +CREATE SCHEMA p2 +-- +ok +== +CREATE SCHEMA p2.c2 +-- +ok +== +CREATE TABLE p2.c2.tbl(i INTEGER) +-- +ok +== +DROP SCHEMA p2 CASCADE +-- +ok +== +SELECT count(*) FROM duckdb_tables() WHERE table_name = 'tbl'; +-- +ok +== diff --git a/parser/testdata/corpus/sql/catalog/nested_schema/nested_wal_replay.test b/parser/testdata/corpus/sql/catalog/nested_schema/nested_wal_replay.test new file mode 100644 index 0000000..4707500 --- /dev/null +++ b/parser/testdata/corpus/sql/catalog/nested_schema/nested_wal_replay.test @@ -0,0 +1,133 @@ +# source: test/sql/catalog/nested_schema/nested_wal_replay.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +CREATE MACRO parent.child.tm() AS TABLE SELECT 42 AS x; +-- +ok +== +SELECT count(*), sum(i) FROM parent.child.t; +-- +ok +== +SELECT * FROM parent.child.tm(); +-- +ok +== +SELECT schema_name, index_name FROM duckdb_indexes() WHERE index_name = 'idx'; +-- +ok +== +SELECT count(*) FROM duckdb_schemas() WHERE schema_name IN ('parent', 'child', 'grandchild'); +-- +ok +== +CREATE TABLE parent.child.alt(i INTEGER); +-- +ok +== +INSERT INTO parent.child.alt VALUES (1), (2), (3); +-- +ok +== +ALTER TABLE parent.child.alt RENAME TO t2; +-- +ok +== +ALTER TABLE parent.child.t2 ADD COLUMN j INTEGER; +-- +ok +== +ALTER VIEW parent.child.v RENAME TO v2; +-- +ok +== +COMMENT ON TABLE parent.child.t2 IS 'nested table'; +-- +ok +== +COMMENT ON COLUMN parent.child.t2.i IS 'nested column'; +-- +ok +== +SELECT count(*) FROM parent.child.t2; +-- +ok +== +SELECT j FROM parent.child.t2 LIMIT 1; +-- +ok +== +SELECT * FROM parent.child.v2 ORDER BY x LIMIT 1; +-- +ok +== +SELECT comment FROM duckdb_tables() WHERE table_name = 't2'; +-- +ok +== +SELECT comment FROM duckdb_columns() WHERE table_name = 't2' AND column_name = 'i'; +-- +ok +== +CREATE TABLE parent.child.pk(i INTEGER); +-- +ok +== +ALTER TABLE parent.child.pk ADD PRIMARY KEY (i); +-- +ok +== +DROP VIEW parent.child.v2; +-- +ok +== +DROP MACRO parent.child.double; +-- +ok +== +DROP MACRO parent.child.tm; +-- +ok +== +DROP TYPE parent.child.mood; +-- +ok +== +DROP INDEX parent.child.idx; +-- +ok +== +DROP TABLE parent.child.pk; +-- +ok +== +SELECT count(*) FROM duckdb_triggers(); +-- +ok +== +SELECT count(*) FROM duckdb_views() WHERE NOT internal; +-- +ok +== +SELECT count(*) FROM duckdb_sequences(); +-- +ok +== +SELECT count(*) FROM duckdb_functions() WHERE function_name IN ('double', 'tm'); +-- +ok +== +SELECT count(*) FROM duckdb_tables() WHERE table_name = 'pk'; +-- +ok +== +SELECT count(*) FROM duckdb_schemas() WHERE schema_name = 'grandchild'; +-- +ok +== +SELECT count(*) FROM duckdb_tables(); +-- +ok +== diff --git a/parser/testdata/corpus/sql/catalog/nested_schema/persist.test b/parser/testdata/corpus/sql/catalog/nested_schema/persist.test new file mode 100644 index 0000000..c388312 --- /dev/null +++ b/parser/testdata/corpus/sql/catalog/nested_schema/persist.test @@ -0,0 +1,17 @@ +# source: test/sql/catalog/nested_schema/persist.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +SELECT schema_name, parent_schema FROM duckdb_schemas() WHERE schema_name IN ('parent','child','grandchild') ORDER BY schema_name; +-- +ok +== +CREATE SCHEMA parent.child.walschema; +-- +ok +== +SELECT schema_name, parent_schema FROM duckdb_schemas() WHERE schema_name IN ('walschema','grandchild') ORDER BY schema_name; +-- +ok +== diff --git a/parser/testdata/corpus/sql/catalog/sequence/sequence_currval_before_nextval_not_supported.test b/parser/testdata/corpus/sql/catalog/sequence/sequence_currval_before_nextval_not_supported.test new file mode 100644 index 0000000..bf1cb9e --- /dev/null +++ b/parser/testdata/corpus/sql/catalog/sequence/sequence_currval_before_nextval_not_supported.test @@ -0,0 +1,21 @@ +# source: test/sql/catalog/sequence/sequence_currval_before_nextval_not_supported.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +SET storage_compatibility_version = 'v1.5.2'; +-- +ok +== +CREATE SEQUENCE IF NOT EXISTS scenario_id START 1 INCREMENT BY 1; +-- +ok +== +SELECT currval('scenario_id'); +-- +ok +== +SELECT nextval('scenario_id'); +-- +ok +== diff --git a/parser/testdata/corpus/sql/catalog/sequence/sequence_currval_before_nextval_supported.test b/parser/testdata/corpus/sql/catalog/sequence/sequence_currval_before_nextval_supported.test new file mode 100644 index 0000000..7991565 --- /dev/null +++ b/parser/testdata/corpus/sql/catalog/sequence/sequence_currval_before_nextval_supported.test @@ -0,0 +1,9 @@ +# source: test/sql/catalog/sequence/sequence_currval_before_nextval_supported.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +SET storage_compatibility_version = 'v2.0.0'; +-- +ok +== diff --git a/parser/testdata/corpus/sql/catalog/sequence/sequence_cycle.test b/parser/testdata/corpus/sql/catalog/sequence/sequence_cycle.test new file mode 100644 index 0000000..42fff74 --- /dev/null +++ b/parser/testdata/corpus/sql/catalog/sequence/sequence_cycle.test @@ -0,0 +1,13 @@ +# source: test/sql/catalog/sequence/sequence_cycle.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +create sequence minseq INCREMENT BY -1 MINVALUE -5 MAXVALUE 5 CYCLE; +-- +ok +== +SELECT nextval('minseq') from generate_series(0,20); +-- +ok +== diff --git a/parser/testdata/corpus/sql/catalog/sequence/sequence_offset_increment.test b/parser/testdata/corpus/sql/catalog/sequence/sequence_offset_increment.test new file mode 100644 index 0000000..2b1a7d1 --- /dev/null +++ b/parser/testdata/corpus/sql/catalog/sequence/sequence_offset_increment.test @@ -0,0 +1,13 @@ +# source: test/sql/catalog/sequence/sequence_offset_increment.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +create sequence xx start 100 increment by 2; +-- +ok +== +SELECT nextval('xx') +-- +ok +== diff --git a/parser/testdata/corpus/sql/catalog/sequence/sequence_overflow.test b/parser/testdata/corpus/sql/catalog/sequence/sequence_overflow.test new file mode 100644 index 0000000..187db60 --- /dev/null +++ b/parser/testdata/corpus/sql/catalog/sequence/sequence_overflow.test @@ -0,0 +1,61 @@ +# source: test/sql/catalog/sequence/sequence_overflow.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +create sequence seq1 INCREMENT BY 1 MINVALUE 9223372036854775800 MAXVALUE 9223372036854775807 CYCLE; +-- +ok +== +SELECT nextval('seq1') from generate_series(0,20); +-- +ok +== +create sequence seq2 INCREMENT BY -1 MINVALUE -9223372036854775808 MAXVALUE -9223372036854775800 CYCLE; +-- +ok +== +SELECT nextval('seq2') from generate_series(0,20); +-- +ok +== +create sequence seq3 INCREMENT BY 1 MINVALUE 9223372036854775800 MAXVALUE 9223372036854775807; +-- +ok +== +SELECT nextval('seq3') from generate_series(0,20); +-- +ok +== +create sequence seq4 INCREMENT BY -1 MINVALUE -9223372036854775808 MAXVALUE -9223372036854775800; +-- +ok +== +SELECT nextval('seq4') from generate_series(0,20); +-- +ok +== +create sequence seq5 INCREMENT BY 9223372036854775807 MINVALUE 9223372036854775800 MAXVALUE 9223372036854775807 CYCLE; +-- +ok +== +SELECT nextval('seq5') from generate_series(0,20); +-- +ok +== +create sequence seq6 INCREMENT BY 9223372036854775807 MINVALUE 9223372036854775800 MAXVALUE 9223372036854775807; +-- +ok +== +SELECT nextval('seq6') from generate_series(0,20); +-- +ok +== +create sequence seq7 INCREMENT BY -9223372036854775808 MINVALUE -9223372036854775808 MAXVALUE -9223372036854775800; +-- +ok +== +SELECT nextval('seq7') from generate_series(0,20); +-- +ok +== diff --git a/parser/testdata/corpus/sql/catalog/sequence/setval.test b/parser/testdata/corpus/sql/catalog/sequence/setval.test new file mode 100644 index 0000000..117a0f2 --- /dev/null +++ b/parser/testdata/corpus/sql/catalog/sequence/setval.test @@ -0,0 +1,169 @@ +# source: test/sql/catalog/sequence/setval.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +CREATE SEQUENCE myseq; +-- +ok +== +SELECT setval('myseq', 42); +-- +ok +== +SELECT nextval('myseq'); +-- +ok +== +DROP SEQUENCE myseq; +-- +ok +== +SELECT setval('myseq', 42, true); +-- +ok +== +SELECT setval('myseq', 42, false); +-- +ok +== +SELECT currval('myseq'); +-- +ok +== +SELECT setval('myseq', 100, false); +-- +ok +== +CREATE SEQUENCE myseq MINVALUE 10 MAXVALUE 20; +-- +ok +== +SELECT setval('myseq', 10, false); +-- +ok +== +SELECT setval('myseq', 20, false); +-- +ok +== +SELECT setval('myseq', 9, false); +-- +ok +== +SELECT setval('myseq', 21, false); +-- +ok +== +SELECT setval('myseq'); +-- +ok +== +SELECT setval(); +-- +ok +== +SELECT setval('myseq', 1, true, true); +-- +ok +== +SELECT setval('nonexistent_seq', 1); +-- +ok +== +SELECT setval(NULL, 42); +-- +ok +== +SELECT setval(NULL, 42, true); +-- +ok +== +SELECT setval('myseq', NULL); +-- +ok +== +SELECT setval('myseq', NULL, true); +-- +ok +== +SELECT setval('myseq', 42, NULL); +-- +ok +== +SELECT setval(NULL, NULL); +-- +ok +== +SELECT setval(NULL, 42, NULL); +-- +ok +== +SELECT setval('myseq', NULL, NULL); +-- +ok +== +SELECT setval(NULL, NULL, NULL); +-- +ok +== +SELECT setval('myseq', 'abc'); +-- +ok +== +SELECT setval('myseq', 42, 'not_a_bool'); +-- +ok +== +SELECT setval('myseq', [1, 2, 3]); +-- +ok +== +CREATE SEQUENCE persisted_seq; +-- +ok +== +SELECT setval('persisted_seq', 42, true); +-- +ok +== +SELECT currval('persisted_seq'); +-- +ok +== +SELECT nextval('persisted_seq'); +-- +ok +== +DROP SEQUENCE persisted_seq; +-- +ok +== +CREATE SEQUENCE t_seq; +-- +ok +== +CREATE TABLE t (a BIGINT, b BOOLEAN); +-- +ok +== +INSERT INTO t VALUES (42, true), (100, false), (10, true); +-- +ok +== +INSERT INTO t VALUES (42, true), (NULL, true), (10, NULL); +-- +ok +== +SELECT setval('t_seq', a, b) FROM t; +-- +ok +== +SELECT nextval('t_seq'); +-- +ok +== +DROP SEQUENCE t_seq; +-- +ok +== diff --git a/parser/testdata/corpus/sql/catalog/sequence/test_duckdb_sequences.test b/parser/testdata/corpus/sql/catalog/sequence/test_duckdb_sequences.test new file mode 100644 index 0000000..a0530f7 --- /dev/null +++ b/parser/testdata/corpus/sql/catalog/sequence/test_duckdb_sequences.test @@ -0,0 +1,17 @@ +# source: test/sql/catalog/sequence/test_duckdb_sequences.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +create sequence my_seq; +-- +ok +== +select nextval('my_seq'); +-- +ok +== +select last_value from duckdb_sequences(); +-- +ok +== diff --git a/parser/testdata/corpus/sql/catalog/sequence/test_sequence.test b/parser/testdata/corpus/sql/catalog/sequence/test_sequence.test new file mode 100644 index 0000000..a72812f --- /dev/null +++ b/parser/testdata/corpus/sql/catalog/sequence/test_sequence.test @@ -0,0 +1,245 @@ +# source: test/sql/catalog/sequence/test_sequence.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +CREATE SEQUENCE IF NOT EXISTS seq; +-- +ok +== +CREATE OR REPLACE SEQUENCE seq +-- +ok +== +SELECT currval('seq') +-- +ok +== +SELECT nextval('seq'), nextval('seq'); +-- +ok +== +SELECT nextval(NULL) +-- +ok +== +SELECT currval(NULL) +-- +ok +== +SELECT nextval(a) FROM (VALUES ('seq'), (NULL), ('seq')) tbl1(a) +-- +ok +== +SELECT currval(a) FROM (VALUES ('seq'), (NULL), ('seq')) tbl1(a) +-- +ok +== +DROP SEQUENCE IF EXISTS seq; +-- +ok +== +CREATE SEQUENCE seq INCREMENT BY 2; +-- +ok +== +SELECT nextval('"seq"') +-- +ok +== +SELECT currval('"seq"') +-- +ok +== +CREATE SEQUENCE seq MINVALUE 3; +-- +ok +== +CREATE SEQUENCE seq MAXVALUE 2; +-- +ok +== +CREATE SEQUENCE seq MAXVALUE 2 CYCLE; +-- +ok +== +CREATE SEQUENCE seq MINVALUE 3 MAXVALUE 5 START WITH 4 CYCLE; +-- +ok +== +CREATE SEQUENCE seq INCREMENT BY -1 MINVALUE 0 MAXVALUE 2; +-- +ok +== +CREATE SEQUENCE seq INCREMENT BY 1 MINVALUE 0 MAXVALUE 2; +-- +ok +== +CREATE SEQUENCE seq INCREMENT 1 MAXVALUE 3 START 2 CYCLE; +-- +ok +== +CREATE SEQUENCE seq INCREMENT -1 CYCLE; +-- +ok +== +CREATE SEQUENCE seq INCREMENT -1 MINVALUE -2 CYCLE; +-- +ok +== +CREATE SEQUENCE seq INCREMENT 1 START -1 CYCLE; +-- +error: Parser Error: START value (-1) cannot be less than MINVALUE (1) +== +CREATE SEQUENCE seq INCREMENT -1 START 1 CYCLE; +-- +error: Parser Error: START value (1) cannot be greater than MAXVALUE (-1) +== +CREATE SCHEMA b; +-- +ok +== +CREATE SEQUENCE a.seq; +-- +ok +== +CREATE SEQUENCE b.seq; +-- +ok +== +SELECT nextval('a.seq'), nextval('b.seq'); +-- +ok +== +SELECT currval('a.seq'), currval('b.seq'); +-- +ok +== +SELECT nextval('"a"."seq"'), nextval('"b".seq'); +-- +ok +== +SELECT currval('"a"."seq"'), currval('"b".seq'); +-- +ok +== +SELECT nextval('"a"."seq'); +-- +error: Parser Error: Unterminated quote in qualified name! (input: "a"."seq) +== +SELECT nextval('a.b.c.d'); +-- +error: Parser Error: Expected catalog.entry, schema.entry or entry: too many entries found (input: a.b.c.d) +== +CREATE SEQUENCE seq MAXVALUE 5 START WITH 6; +-- +error: Parser Error: START value (6) cannot be greater than MAXVALUE (5) +== +CREATE SEQUENCE seq MINVALUE 5 START WITH 4; +-- +error: Parser Error: START value (4) cannot be less than MINVALUE (5) +== +CREATE SEQUENCE seq MINVALUE 7 MAXVALUE 5; +-- +error: Parser Error: MINVALUE (7) must be less than MAXVALUE (5) +== +CREATE SEQUENCE seq INCREMENT 0; +-- +error: Parser Error: Increment must not be zero +== +CREATE SEQUENCE seq2; +-- +ok +== +SELECT nextval('s'||'e'||'q') +-- +ok +== +CREATE TABLE strings(s VARCHAR); +-- +ok +== +INSERT INTO strings VALUES ('seq'), ('seq2') +-- +ok +== +SELECT s, nextval('seq') FROM strings +-- +ok +== +SELECT s, currval('seq') FROM strings +-- +ok +== +SELECT s, nextval(s) FROM strings +-- +ok +== +SELECT s, currval(s) FROM strings +-- +ok +== +INSERT INTO strings VALUES ('nonexistant_seq') +-- +ok +== +CREATE SEQUENCE fresh; +-- +ok +== +select currval('fresh'); +-- +ok +== +select nextval(1 + 1); +-- +ok +== +select currval(true); +-- +ok +== +CREATE SEQUENCE wrongseq NO MAXVALUE MAXVALUE 2; +-- +error: Parser Error: Maxvalue should be passed at most once +== +CREATE SEQUENCE wrongseq MINVALUE 10 MINVALUE 2; +-- +error: Parser Error: Minvalue should be passed at most once +== +CREATE SEQUENCE wrongseq START 13 START WITH 3; +-- +error: Parser Error: Start should be passed at most once +== +CREATE SEQUENCE wrongseq CYCLE MAXVALUE 2 MINVALUE 1 NO CYCLE; +-- +error: Parser Error: Cycle should be passed at most once +== +CREATE SEQUENCE wrongseq INCREMENT 2 INCREMENT BY -1; +-- +error: Parser Error: Increment should be passed at most once +== +CREATE SEQUENCE wrongseq START NULL; +-- +error: Parser Error: START value must not be NULL +== +CREATE SEQUENCE wrongseq START WITH NULL; +-- +error: Parser Error: START value must not be NULL +== +CREATE SEQUENCE wrongseq MINVALUE NULL; +-- +error: Parser Error: MINVALUE must not be NULL +== +CREATE SEQUENCE wrongseq MAXVALUE NULL; +-- +error: Parser Error: MAXVALUE must not be NULL +== +CREATE SEQUENCE wrongseq INCREMENT BY NULL; +-- +error: Parser Error: INCREMENT must not be NULL +== +CREATE SEQUENCE wrongseq CYCLE START NULL; +-- +error: Parser Error: START value must not be NULL +== diff --git a/parser/testdata/corpus/sql/catalog/sequence/test_sequence.test.metadata.json b/parser/testdata/corpus/sql/catalog/sequence/test_sequence.test.metadata.json new file mode 100644 index 0000000..b4f63a0 --- /dev/null +++ b/parser/testdata/corpus/sql/catalog/sequence/test_sequence.test.metadata.json @@ -0,0 +1,23 @@ +{ + "todo": { + "132d63d61772c3bf": "transformer-raised parser error: upstream rejects in the transformer, not the grammar; expected to clear as transformers land (milestones 3-5)", + "17ad559be3bc0bed": "transformer-raised parser error: upstream rejects in the transformer, not the grammar; expected to clear as transformers land (milestones 3-5)", + "2e1581541df8f2d4": "transformer-raised parser error: upstream rejects in the transformer, not the grammar; expected to clear as transformers land (milestones 3-5)", + "31e44341fd615e6e": "transformer-raised parser error: upstream rejects in the transformer, not the grammar; expected to clear as transformers land (milestones 3-5)", + "4824d3a8f34f1904": "transformer-raised parser error: upstream rejects in the transformer, not the grammar; expected to clear as transformers land (milestones 3-5)", + "49e80f12d8463a99": "transformer-raised parser error: upstream rejects in the transformer, not the grammar; expected to clear as transformers land (milestones 3-5)", + "4a727b414ee9e3aa": "transformer-raised parser error: upstream rejects in the transformer, not the grammar; expected to clear as transformers land (milestones 3-5)", + "4b6b034abfeec7e8": "transformer-raised parser error: upstream rejects in the transformer, not the grammar; expected to clear as transformers land (milestones 3-5)", + "5966969ec1140fad": "transformer-raised parser error: upstream rejects in the transformer, not the grammar; expected to clear as transformers land (milestones 3-5)", + "681dfde4704609ce": "transformer-raised parser error: upstream rejects in the transformer, not the grammar; expected to clear as transformers land (milestones 3-5)", + "6f8570edee9b3d74": "transformer-raised parser error: upstream rejects in the transformer, not the grammar; expected to clear as transformers land (milestones 3-5)", + "75fba905bb243877": "transformer-raised parser error: upstream rejects in the transformer, not the grammar; expected to clear as transformers land (milestones 3-5)", + "809350ad9fc71a21": "transformer-raised parser error: upstream rejects in the transformer, not the grammar; expected to clear as transformers land (milestones 3-5)", + "8f2945249abe5158": "transformer-raised parser error: upstream rejects in the transformer, not the grammar; expected to clear as transformers land (milestones 3-5)", + "9646d43ed9a210ab": "transformer-raised parser error: upstream rejects in the transformer, not the grammar; expected to clear as transformers land (milestones 3-5)", + "b5c2331745db52df": "transformer-raised parser error: upstream rejects in the transformer, not the grammar; expected to clear as transformers land (milestones 3-5)", + "cf44ff528cab7ec3": "transformer-raised parser error: upstream rejects in the transformer, not the grammar; expected to clear as transformers land (milestones 3-5)", + "dfda3a0ae8a0c287": "transformer-raised parser error: upstream rejects in the transformer, not the grammar; expected to clear as transformers land (milestones 3-5)", + "e4841867b271b34c": "transformer-raised parser error: upstream rejects in the transformer, not the grammar; expected to clear as transformers land (milestones 3-5)" + } +} diff --git a/parser/testdata/corpus/sql/catalog/sequence/test_sequence_dependency.test b/parser/testdata/corpus/sql/catalog/sequence/test_sequence_dependency.test new file mode 100644 index 0000000..808019a --- /dev/null +++ b/parser/testdata/corpus/sql/catalog/sequence/test_sequence_dependency.test @@ -0,0 +1,13 @@ +# source: test/sql/catalog/sequence/test_sequence_dependency.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +create table integers(i integer default nextval('seq')); +-- +ok +== +commit +-- +ok +== diff --git a/parser/testdata/corpus/sql/catalog/sequence/test_sequence_google_fuzz.test b/parser/testdata/corpus/sql/catalog/sequence/test_sequence_google_fuzz.test new file mode 100644 index 0000000..dd4d3e4 --- /dev/null +++ b/parser/testdata/corpus/sql/catalog/sequence/test_sequence_google_fuzz.test @@ -0,0 +1,17 @@ +# source: test/sql/catalog/sequence/test_sequence_google_fuzz.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +;creAte +sequence +uGeõó±õõõõ.õõõ.õ;creAte +sequence +uGeõõõõõ..õ;creAte +sequence +uGeõõõõõ..õ;creAte +sequence +uGeõõõõ +-- +ok +== diff --git a/parser/testdata/corpus/sql/catalog/table/create_table_as_abort.test b/parser/testdata/corpus/sql/catalog/table/create_table_as_abort.test new file mode 100644 index 0000000..482a1e7 --- /dev/null +++ b/parser/testdata/corpus/sql/catalog/table/create_table_as_abort.test @@ -0,0 +1,13 @@ +# source: test/sql/catalog/table/create_table_as_abort.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +CREATE TABLE IF NOT EXISTS integers AS SELECT i1.i FROM range(10000000000000000) i1(i); +-- +ok +== +CREATE TABLE integers AS SELECT i1.i FROM range(10000000000000000) i1(i); +-- +ok +== diff --git a/parser/testdata/corpus/sql/catalog/table/create_table_parameters.test b/parser/testdata/corpus/sql/catalog/table/create_table_parameters.test new file mode 100644 index 0000000..9af966c --- /dev/null +++ b/parser/testdata/corpus/sql/catalog/table/create_table_parameters.test @@ -0,0 +1,21 @@ +# source: test/sql/catalog/table/create_table_parameters.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +CREATE TABLE t0 ( c1 INT DEFAULT ? ); +-- +ok +== +CREATE TABLE t0 ( c1 INT CHECK (?) ); +-- +ok +== +set variable x = 5; +-- +ok +== +CREATE TABLE t0 (c1 BIGINT DEFAULT $x); +-- +ok +== diff --git a/parser/testdata/corpus/sql/catalog/table/long_identifier.test b/parser/testdata/corpus/sql/catalog/table/long_identifier.test new file mode 100644 index 0000000..3d1083f --- /dev/null +++ b/parser/testdata/corpus/sql/catalog/table/long_identifier.test @@ -0,0 +1,29 @@ +# source: test/sql/catalog/table/long_identifier.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +create table integers("AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" integer); +-- +ok +== +select "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" from integers +-- +ok +== +create table integers2("AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" integer); +-- +ok +== +select "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" from integers2 +-- +ok +== +create table integers3("Lorem ipsum dolor sit amet, consectetur adipiscing elit. Donec et laoreet lacus, sollicitudin cursus metus. Pellentesque quis magna magna. Ut viverra erat vulputate, euismod sapien id, mollis odio. Vestibulum accumsan orci ac diam accumsan efficitur. Sed vel maximus leo, vel tempus metus. Fusce urna dolor, lacinia ac scelerisque hendrerit, semper eu nisl. Vivamus pellentesque sapien id sapien finibus porttitor. Cras congue libero quis nunc pretium efficitur. Praesent vitae urna non elit luctus posuere mattis ac eros. Nunc tincidunt quam vel sem ullamcorper semper. Donec eget gravida justo. Duis vel mollis felis. +Duis scelerisque risus in sem molestie, nec egestas odio vestibulum. Nunc in dui eu dui fringilla dignissim vitae id felis. Pellentesque habitant morbi tristique senectus et netus et malesuada fames ac turpis egestas. Phasellus a tempus sapien. Cras vehicula maximus laoreet. In hac habitasse platea dictumst. In fermentum orci id libero congue dignissim. Aenean tristique porta arcu a varius. Cras vitae leo gravida, eleifend dolor et, porttitor arcu. +Pellentesque et fringilla tortor. Sed sodales nulla lacus, eget feugiat dolor mattis tincidunt. Morbi ut finibus odio. Mauris felis diam, ornare ac diam mattis, suscipit laoreet turpis. Duis vulputate mi in orci pretium, vitae varius turpis facilisis. Orci varius natoque penatibus et magnis dis parturient montes, nascetur ridiculus mus. Maecenas gravida libero at ligula pretium, quis gravida libero tempus. Aenean eu condimentum libero. Duis sagittis augue mi. Cras vel ante a ipsum consequat interdum. Aliquam venenatis metus sed ligula consequat congue. Fusce ut rutrum urna. Integer auctor purus nulla, eget lacinia dolor sollicitudin et. Vestibulum lacinia lectus nec mauris iaculis, eget cursus mauris semper. Donec ut lacinia felis. Quisque vitae risus sit amet erat semper suscipit. +Duis pulvinar ipsum purus, vitae placerat lectus commodo ut. Nullam viverra arcu vitae ipsum faucibus, at aliquet massa vehicula. Nunc eget felis sed quam sollicitudin tempus. Quisque lobortis id nisi id dictum. Phasellus id elementum purus. Duis diam purus, egestas ac quam et, porta fringilla velit. Nulla a turpis bibendum, eleifend eros eget, efficitur nibh. Pellentesque consectetur porttitor lacinia. Aliquam blandit eros eu metus ultrices, ut dignissim nunc lacinia. Mauris placerat volutpat odio, dictum dapibus dolor egestas sed. Nam consequat odio quis urna lobortis viverra. Phasellus facilisis elit nec neque rutrum laoreet. Etiam non maximus magna. Pellentesque pellentesque laoreet orci, vel sollicitudin urna sollicitudin a. Nunc id iaculis enim, quis pharetra mauris. Nullam sit amet diam eu massa dictum vehicula. +Vestibulum sed congue urna. Praesent iaculis massa viverra ex congue, nec euismod leo scelerisque. Lorem ipsum dolor sit amet, consectetur adipiscing elit. Duis aliquet ut augue non interdum. Quisque tempor blandit mi non dignissim. Integer hendrerit, elit id posuere facilisis, libero purus dignissim ipsum, nec tincidunt metus lectus elementum magna. Cras turpis dolor, gravida et ipsum non, vestibulum sagittis sapien. Maecenas varius lacus mi, at porta purus cursus eget. Nunc feugiat congue augue id mollis. Praesent sed erat non leo varius varius. Sed sodales justo sollicitudin ex faucibus euismod. Aenean gravida nec diam vel vestibulum. Donec feugiat risus velit, quis fringilla libero vulputate nec. Curabitur pulvinar, tellus in eleifend varius, orci ex hendrerit sem, at laoreet diam ante id nibh." integer); +-- +ok +== diff --git a/parser/testdata/corpus/sql/catalog/table/test_create_table_parallelism.test b/parser/testdata/corpus/sql/catalog/table/test_create_table_parallelism.test new file mode 100644 index 0000000..e8c0c57 --- /dev/null +++ b/parser/testdata/corpus/sql/catalog/table/test_create_table_parallelism.test @@ -0,0 +1,25 @@ +# source: test/sql/catalog/table/test_create_table_parallelism.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +CREATE TABLE test AS (SELECT string_agg(range::VARCHAR, '🦆 ') AS s, mod(range, 10000) xx FROM range(50000) GROUP BY xx) +-- +ok +== +CREATE TABLE test2 AS (SELECT unnest(string_split(s, ' ')) FROM test) +-- +ok +== +SELECT count(*) FROM test2 +-- +ok +== +CREATE TABLE test3 AS (SELECT * FROM test ORDER BY xx) +-- +ok +== +SELECT count(*) FROM test3 +-- +ok +== diff --git a/parser/testdata/corpus/sql/catalog/table/test_default.test b/parser/testdata/corpus/sql/catalog/table/test_default.test new file mode 100644 index 0000000..e81333d --- /dev/null +++ b/parser/testdata/corpus/sql/catalog/table/test_default.test @@ -0,0 +1,89 @@ +# source: test/sql/catalog/table/test_default.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +INSERT INTO test (b) VALUES (3); +-- +ok +== +INSERT INTO test VALUES (DEFAULT, DEFAULT); +-- +ok +== +CREATE TABLE test (a INTEGER NOT NULL, b INTEGER); +-- +ok +== +CREATE TABLE test (a INTEGER DEFAULT 1, b INTEGER); +-- +ok +== +CREATE TABLE test (a INTEGER DEFAULT 1+1, b INTEGER); +-- +ok +== +INSERT INTO test (b) SELECT 3 +-- +ok +== +CREATE TABLE test ( + a INTEGER DEFAULT nextval('seq'), + b INTEGER +); +-- +ok +== +INSERT INTO test (b) VALUES + (2), + (4), + (6), + (2), + (4); +-- +ok +== +SELECT * FROM test ORDER BY 1 +-- +ok +== +CREATE TABLE test (a INTEGER DEFAULT nextval('seq'), b INTEGER); +-- +ok +== +INSERT INTO test (b) VALUES (1); +-- +ok +== +UPDATE test SET a=DEFAULT +-- +ok +== +CREATE TABLE test (a INTEGER DEFAULT (SELECT 42), b INTEGER); +-- +ok +== +CREATE TABLE test (a INTEGER DEFAULT SUM(42), b INTEGER); +-- +ok +== +CREATE TABLE test (a INTEGER DEFAULT row_number() OVER (), b INTEGER); +-- +ok +== +CREATE TABLE test (a INTEGER DEFAULT b+1, b INTEGER); +-- +ok +== +CREATE TABLE test (a DOUBLE DEFAULT random(), b INTEGER); +-- +ok +== +INSERT INTO test (b) VALUES (2); +-- +ok +== +SELECT COUNT(DISTINCT a) FROM test; +-- +ok +== diff --git a/parser/testdata/corpus/sql/catalog/table/test_default_not_null.test b/parser/testdata/corpus/sql/catalog/table/test_default_not_null.test new file mode 100644 index 0000000..9c07ae2 --- /dev/null +++ b/parser/testdata/corpus/sql/catalog/table/test_default_not_null.test @@ -0,0 +1,65 @@ +# source: test/sql/catalog/table/test_default_not_null.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +CREATE TABLE uuids(u UUID DEFAULT gen_random_uuid() NOT NULL, a INTEGER); +-- +ok +== +INSERT INTO uuids (a) VALUES (42); +-- +ok +== +SELECT a FROM uuids; +-- +ok +== +SELECT u IS NOT NULL FROM uuids; +-- +ok +== +CREATE TABLE uuids2(u UUID DEFAULT (gen_random_uuid()) NOT NULL, a INTEGER); +-- +ok +== +INSERT INTO uuids2 (a) VALUES (1); +-- +ok +== +SELECT u IS NOT NULL FROM uuids2; +-- +ok +== +CREATE TABLE t(v INTEGER DEFAULT 42 NOT NULL, a INTEGER); +-- +ok +== +INSERT INTO t (a) VALUES (1); +-- +ok +== +SELECT v, a FROM t; +-- +ok +== +CREATE TABLE t3(v INTEGER DEFAULT 42 NOT NULL, a INTEGER); +-- +ok +== +INSERT INTO t3 VALUES (NULL, 1); +-- +ok +== +CREATE TABLE t2(v BOOLEAN DEFAULT (42 IS NOT NULL), a INTEGER); +-- +ok +== +INSERT INTO t2 (a) VALUES (1); +-- +ok +== +SELECT v, a FROM t2; +-- +ok +== diff --git a/parser/testdata/corpus/sql/catalog/table/test_default_values.test b/parser/testdata/corpus/sql/catalog/table/test_default_values.test new file mode 100644 index 0000000..7adbeae --- /dev/null +++ b/parser/testdata/corpus/sql/catalog/table/test_default_values.test @@ -0,0 +1,41 @@ +# source: test/sql/catalog/table/test_default_values.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +create table x (i int default 1, j int default 2) +-- +ok +== +insert into x default values; +-- +ok +== +SELECT * FROM x +-- +ok +== +insert into x default values returning (i); +-- +ok +== +insert into x default values returning (j); +-- +ok +== +insert into x(i) default values; +-- +error: Parser Error: You can not provide both a column list and DEFAULT VALUES, please remove one of the two +== +drop table x; +-- +ok +== +create table x (i int primary key default 1, j int default 2) +-- +ok +== +insert into x default values on conflict do nothing; +-- +ok +== diff --git a/parser/testdata/corpus/sql/catalog/table/test_default_values.test.metadata.json b/parser/testdata/corpus/sql/catalog/table/test_default_values.test.metadata.json new file mode 100644 index 0000000..f014efc --- /dev/null +++ b/parser/testdata/corpus/sql/catalog/table/test_default_values.test.metadata.json @@ -0,0 +1,5 @@ +{ + "todo": { + "ceb1e6f9f97931ac": "transformer-raised parser error: upstream rejects in the transformer, not the grammar; expected to clear as transformers land (milestones 3-5)" + } +} diff --git a/parser/testdata/corpus/sql/catalog/table/test_many_columns.test b/parser/testdata/corpus/sql/catalog/table/test_many_columns.test new file mode 100644 index 0000000..e95c431 --- /dev/null +++ b/parser/testdata/corpus/sql/catalog/table/test_many_columns.test @@ -0,0 +1,13 @@ +# source: test/sql/catalog/table/test_many_columns.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +INSERT INTO integers (i0, j) VALUES (2, 3), (3, 4), (5, 6) +-- +ok +== +SELECT i0, j, i1 FROM integers +-- +ok +== diff --git a/parser/testdata/corpus/sql/catalog/test_alter_oid_stability.test b/parser/testdata/corpus/sql/catalog/test_alter_oid_stability.test new file mode 100644 index 0000000..7daeddb --- /dev/null +++ b/parser/testdata/corpus/sql/catalog/test_alter_oid_stability.test @@ -0,0 +1,29 @@ +# source: test/sql/catalog/test_alter_oid_stability.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +CREATE TABLE oid_ref AS SELECT table_oid AS id FROM duckdb_tables() WHERE table_name='t'; +-- +ok +== +ALTER TABLE t ADD COLUMN j INTEGER; +-- +ok +== +SELECT (SELECT table_oid FROM duckdb_tables() WHERE table_name='t') = (SELECT id FROM oid_ref); +-- +ok +== +ALTER TABLE t RENAME TO t2; +-- +ok +== +SELECT (SELECT table_oid FROM duckdb_tables() WHERE table_name='t2') = (SELECT id FROM oid_ref); +-- +ok +== +CREATE TABLE t2(i INTEGER); +-- +ok +== diff --git a/parser/testdata/corpus/sql/catalog/test_catalog_errors.test b/parser/testdata/corpus/sql/catalog/test_catalog_errors.test new file mode 100644 index 0000000..51dda6e --- /dev/null +++ b/parser/testdata/corpus/sql/catalog/test_catalog_errors.test @@ -0,0 +1,57 @@ +# source: test/sql/catalog/test_catalog_errors.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +CREATE VIEW vintegers AS SELECT 42; +-- +ok +== +CREATE TABLE vintegers(i INTEGER); +-- +ok +== +CREATE VIEW integers AS SELECT 42; +-- +ok +== +CREATE OR REPLACE VIEW integers AS SELECT 42; +-- +ok +== +DROP VIEW integers +-- +ok +== +DROP TABLE blabla +-- +ok +== +ALTER TABLE blabla RENAME COLUMN i TO k +-- +ok +== +DROP TABLE IF EXISTS vintegers +-- +ok +== +CREATE INDEX i_index ON integers(i); +-- +ok +== +CREATE INDEX IF NOT EXISTS i_index ON integers(i); +-- +ok +== +DROP INDEX IF EXISTS i_index +-- +ok +== +CREATE UNIQUE INDEX i_index ON integers(i); +-- +ok +== +CREATE UNIQUE INDEX IF NOT EXISTS i_index ON integers(i); +-- +ok +== diff --git a/parser/testdata/corpus/sql/catalog/test_create_from_select.test b/parser/testdata/corpus/sql/catalog/test_create_from_select.test new file mode 100644 index 0000000..4704d1a --- /dev/null +++ b/parser/testdata/corpus/sql/catalog/test_create_from_select.test @@ -0,0 +1,29 @@ +# source: test/sql/catalog/test_create_from_select.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +INSERT INTO integers VALUES (3), (4), (5) +-- +ok +== +INSERT INTO integers SELECT i+3 FROM integers; +-- +ok +== +CREATE TABLE integers2 AS SELECT i, i+2 AS j FROM integers; +-- +ok +== +SELECT * FROM integers2 ORDER BY i +-- +ok +== +SELECT i FROM integers2 ORDER BY i +-- +ok +== +SELECT j FROM integers2 ORDER BY i +-- +ok +== diff --git a/parser/testdata/corpus/sql/catalog/test_extension_suggestion.test b/parser/testdata/corpus/sql/catalog/test_extension_suggestion.test new file mode 100644 index 0000000..ea36713 --- /dev/null +++ b/parser/testdata/corpus/sql/catalog/test_extension_suggestion.test @@ -0,0 +1,9 @@ +# source: test/sql/catalog/test_extension_suggestion.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +SELECT from_json('{DATA_DIR}/json/array_of_empty_arrays.json'); +-- +ok +== diff --git a/parser/testdata/corpus/sql/catalog/test_if_not_exists.test b/parser/testdata/corpus/sql/catalog/test_if_not_exists.test new file mode 100644 index 0000000..0f5ada5 --- /dev/null +++ b/parser/testdata/corpus/sql/catalog/test_if_not_exists.test @@ -0,0 +1,29 @@ +# source: test/sql/catalog/test_if_not_exists.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +CREATE TABLE IF NOT EXISTS integers(i INTEGER, j INTEGER) +-- +ok +== +CREATE TABLE IF NOT EXISTS integers2 AS SELECT 42 +-- +ok +== +CREATE VIEW IF NOT EXISTS integers2 AS SELECT 42 +-- +ok +== +DROP VIEW IF EXISTS integers +-- +ok +== +DROP TABLE IF EXISTS integers +-- +ok +== +DROP TABLE IF EXISTS no_such_scheme.integers +-- +ok +== diff --git a/parser/testdata/corpus/sql/catalog/test_incorrect_table_creation.test b/parser/testdata/corpus/sql/catalog/test_incorrect_table_creation.test new file mode 100644 index 0000000..8018a2e --- /dev/null +++ b/parser/testdata/corpus/sql/catalog/test_incorrect_table_creation.test @@ -0,0 +1,21 @@ +# source: test/sql/catalog/test_incorrect_table_creation.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +CREATE TABLE integers(i INTEGER, PRIMARY KEY(j)) +-- +ok +== +CREATE TABLE integers(i INTEGER, PRIMARY KEY(i, i)) +-- +error: Parser Error: column "i" appears twice in primary key constraint +== +CREATE TABLE integers(i INTEGER, PRIMARY KEY(i), PRIMARY KEY(i)) +-- +error: Parser Error: table "integers" has more than one primary key +== +CREATE TABLE integers(i INTEGER PRIMARY KEY, PRIMARY KEY(i)) +-- +error: Parser Error: table "integers" has more than one primary key +== diff --git a/parser/testdata/corpus/sql/catalog/test_incorrect_table_creation.test.metadata.json b/parser/testdata/corpus/sql/catalog/test_incorrect_table_creation.test.metadata.json new file mode 100644 index 0000000..c584a86 --- /dev/null +++ b/parser/testdata/corpus/sql/catalog/test_incorrect_table_creation.test.metadata.json @@ -0,0 +1,7 @@ +{ + "todo": { + "24a5d9123261c84d": "transformer-raised parser error: upstream rejects in the transformer, not the grammar; expected to clear as transformers land (milestones 3-5)", + "91b15dc29617d59c": "transformer-raised parser error: upstream rejects in the transformer, not the grammar; expected to clear as transformers land (milestones 3-5)", + "b542c6a3df03ddb8": "transformer-raised parser error: upstream rejects in the transformer, not the grammar; expected to clear as transformers land (milestones 3-5)" + } +} diff --git a/parser/testdata/corpus/sql/catalog/test_querying_from_detached_catalog.test b/parser/testdata/corpus/sql/catalog/test_querying_from_detached_catalog.test new file mode 100644 index 0000000..5838f95 --- /dev/null +++ b/parser/testdata/corpus/sql/catalog/test_querying_from_detached_catalog.test @@ -0,0 +1,37 @@ +# source: test/sql/catalog/test_querying_from_detached_catalog.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +CREATE TABLE db2.tbl (i INTEGER, j INTEGER); +-- +ok +== +INSERT INTO db2.tbl VALUES (1, 2), (3,4); +-- +ok +== +SELECT CURRENT_SETTING('search_path'); +-- +ok +== +FROM db2.tbl; +-- +ok +== +FROM db2.main.tbl; +-- +ok +== +CREATE TABLE db2.tbl2 AS SELECT 42; +-- +ok +== +FROM db2.non_existent_table; +-- +ok +== +SHOW TABLES; +-- +ok +== diff --git a/parser/testdata/corpus/sql/catalog/test_quoted_column_name.test b/parser/testdata/corpus/sql/catalog/test_quoted_column_name.test new file mode 100644 index 0000000..2c993be --- /dev/null +++ b/parser/testdata/corpus/sql/catalog/test_quoted_column_name.test @@ -0,0 +1,29 @@ +# source: test/sql/catalog/test_quoted_column_name.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +CREATE TABLE integers("42" INTEGER) +-- +ok +== +INSERT INTO integers VALUES (33) +-- +ok +== +SELECT "42" FROM integers; +-- +ok +== +CREATE TABLE "table ""." ( "col ""." TEXT) +-- +ok +== +INSERT INTO "table ""." ("col "".") VALUES ('quote_escaped_quote_''') +-- +ok +== +SELECT "table ""."."col "".", "col ""." FROM "table ""."; +-- +ok +== diff --git a/parser/testdata/corpus/sql/catalog/test_schema.test b/parser/testdata/corpus/sql/catalog/test_schema.test new file mode 100644 index 0000000..392a834 --- /dev/null +++ b/parser/testdata/corpus/sql/catalog/test_schema.test @@ -0,0 +1,73 @@ +# source: test/sql/catalog/test_schema.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +CREATE OR REPLACE SCHEMA test; +-- +ok +== +CREATE TABLE test.hello(i INTEGER); +-- +ok +== +DROP TABLE test.hello; +-- +ok +== +DROP SCHEMA test; +-- +ok +== +INSERT INTO test.hello VALUES (2), (3), (4) +-- +ok +== +SELECT * FROM test.hello +-- +ok +== +SELECT COUNT(*) FROM non_exist_schema.data +-- +ok +== +SELECT COUNT(*) FROM nonexistent_schema.some_table +-- +ok +== +ATTACH ':memory:' AS test_catalog; +-- +ok +== +CREATE TABLE test_catalog.main.existing_table(i INTEGER); +-- +ok +== +SELECT COUNT(*) FROM test_catalog.nonexistent_schema.some_table +-- +ok +== +SELECT COUNT(*) FROM test_catalog.main.nonexistent_table +-- +ok +== +SELECT * FROM test_catalog.missing_schema.missing_table +-- +ok +== +ATTACH ':memory:' AS another_catalog; +-- +ok +== +SELECT COUNT(*) FROM another_catalog.invalid_schema.table_name +-- +ok +== +DETACH test_catalog; +-- +ok +== +DETACH another_catalog; +-- +ok +== diff --git a/parser/testdata/corpus/sql/catalog/test_set_schema.test b/parser/testdata/corpus/sql/catalog/test_set_schema.test new file mode 100644 index 0000000..220ba7a --- /dev/null +++ b/parser/testdata/corpus/sql/catalog/test_set_schema.test @@ -0,0 +1,453 @@ +# source: test/sql/catalog/test_set_schema.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +CREATE SCHEMA out_of_path; +-- +ok +== +SET SESSION schema = 'test'; +-- +ok +== +CREATE TABLE main.main_table(j INTEGER); +-- +ok +== +CREATE TABLE test_table(i INTEGER); +-- +ok +== +CREATE TABLE out_of_path.oop_table(k INTEGER); +-- +ok +== +SELECT * FROM test.test_table; +-- +ok +== +SELECT * FROM test_table; +-- +ok +== +SELECT * FROM main_table; +-- +ok +== +SELECT * FROM out_of_path.oop_table; +-- +ok +== +SELECT * FROM out_of_path.test_table; +-- +ok +== +SELECT * FROM main.test_table; +-- +ok +== +INSERT INTO main.test_table (i) VALUES (1); +-- +ok +== +INSERT INTO test_table (i) VALUES (1); +-- +ok +== +INSERT INTO test.test_table (i) VALUES (2), (3); +-- +ok +== +INSERT INTO main_table (j) VALUES (4); +-- +ok +== +INSERT INTO main.main_table (j) VALUES (5), (6); +-- +ok +== +INSERT INTO oop_table (k) VALUES (7); +-- +ok +== +INSERT INTO out_of_path.oop_table (k) VALUES (8), (9); +-- +ok +== +DELETE FROM main.test_table WHERE i=3; +-- +ok +== +DELETE FROM test.main_table WHERE i=5; +-- +ok +== +DELETE FROM oop_table WHERE k=8; +-- +ok +== +DELETE FROM test.test_table WHERE i=1; +-- +ok +== +DELETE FROM test_table WHERE i=2; +-- +ok +== +DELETE FROM main.main_table WHERE j=4; +-- +ok +== +DELETE FROM main_table WHERE j=5; +-- +ok +== +DELETE FROM out_of_path.oop_table WHERE k=8; +-- +ok +== +SELECT i FROM test_table; +-- +ok +== +SELECT j FROM main.main_table; +-- +ok +== +SELECT k FROM out_of_path.oop_table; +-- +ok +== +UPDATE main.test_table SET i=10 WHERE i=1; +-- +ok +== +UPDATE test_table SET i=30 WHERE i=3; +-- +ok +== +UPDATE test.test_table SET i=300 WHERE i=30; +-- +ok +== +UPDATE main_table SET j=60 WHERE j=6; +-- +ok +== +UPDATE main.main_table SET j=600 WHERE j=60; +-- +ok +== +SELECT j FROM main_table; +-- +ok +== +CREATE TEMP TABLE test_temp_table(i INTEGER); +-- +ok +== +SELECT * FROM memory.main.test_temp_table; +-- +ok +== +SELECT * FROM test.test_temp_table; +-- +ok +== +SELECT * FROM test_temp_table; +-- +ok +== +SELECT * FROM temp.test_temp_table; +-- +ok +== +SELECT abs(i) FROM test_table; +-- +ok +== +SELECT sum(i) FROM test_table; +-- +ok +== +CREATE VIEW test_view AS SELECT * FROM test_table; +-- +ok +== +CREATE VIEW main.main_view AS SELECT * FROM main.main_table; +-- +ok +== +CREATE VIEW out_of_path.oop_view AS SELECT * FROM out_of_path.oop_table; +-- +ok +== +SELECT * FROM main.test_view; +-- +ok +== +SELECT * FROM test.test_view; +-- +ok +== +SELECT * FROM test_view; +-- +ok +== +SELECT * FROM main.main_view; +-- +ok +== +SELECT * FROM main_view; +-- +ok +== +SELECT * FROM oop_view; +-- +ok +== +SELECT * FROM out_of_path.oop_view; +-- +ok +== +SET SESSION schema = 'main'; +-- +ok +== +CREATE VIEW bad_test_view AS SELECT * FROM test_table; +-- +ok +== +DROP VIEW main.test_view +-- +ok +== +DROP VIEW main_view +-- +ok +== +DROP VIEW oop_view +-- +ok +== +DROP VIEW out_of_path.oop_view +-- +ok +== +CREATE MACRO test_macro(a, b) AS a + b; +-- +ok +== +CREATE MACRO test_macro2(c, d) AS c * d; +-- +ok +== +CREATE MACRO main.main_macro(a, b) AS a - b; +-- +ok +== +CREATE MACRO out_of_path.oop_macro(a, b) AS a * b; +-- +ok +== +SELECT main.test_macro(1, 2); +-- +ok +== +SELECT oop_macro(1, 2); +-- +ok +== +SELECT main_macro(1, 2); +-- +ok +== +SELECT main.main_macro(1, 2); +-- +ok +== +SELECT test.test_macro(1, 2); +-- +ok +== +SELECT test_macro(1, 2); +-- +ok +== +SELECT out_of_path.oop_macro(1, 2); +-- +ok +== +DROP MACRO main.test_macro; +-- +ok +== +DROP MACRO test_macro; +-- +ok +== +DROP MACRO test.test_macro2; +-- +ok +== +DROP MACRO main_macro; +-- +ok +== +DROP MACRO oop_macro; +-- +ok +== +DROP MACRO out_of_path.oop_macro; +-- +ok +== +CREATE SEQUENCE test_sequence2; +-- +ok +== +CREATE SEQUENCE main.main_sequence; +-- +ok +== +CREATE SEQUENCE out_of_path.oop_sequence; +-- +ok +== +SELECT main.nextval('main.test_sequence'); +-- +ok +== +SELECT main.nextval('test.test_sequence'); +-- +ok +== +SELECT main.nextval('test_sequence'); +-- +ok +== +SELECT main.nextval('main.main_sequence'); +-- +ok +== +SELECT main.nextval('main_sequence'); +-- +ok +== +SELECT main.nextval('oop_sequence'); +-- +ok +== +SELECT main.nextval('out_of_path.oop_sequence'); +-- +ok +== +DROP SEQUENCE main.test_sequence; +-- +ok +== +DROP SEQUENCE test_sequence; +-- +ok +== +DROP SEQUENCE test.test_sequence2; +-- +ok +== +DROP SEQUENCE main_sequence; +-- +ok +== +DROP SEQUENCE oop_sequence; +-- +ok +== +DROP SEQUENCE out_of_path.oop_sequence; +-- +ok +== +ALTER TABLE main.test_table ADD COLUMN k INTEGER; +-- +ok +== +ALTER TABLE main.main_table ADD COLUMN k INTEGER; +-- +ok +== +ALTER TABLE main_table ADD COLUMN l INTEGER; +-- +ok +== +ALTER TABLE test_table ADD COLUMN m INTEGER; +-- +ok +== +ALTER TABLE test.test_table ADD COLUMN n INTEGER; +-- +ok +== +ALTER TABLE oop_table ADD COLUMN o INTEGER; +-- +ok +== +ALTER TABLE out_of_path.oop_table ADD COLUMN p INTEGER; +-- +ok +== +DROP TABLE main.test_table; +-- +ok +== +DROP TABLE test.main_table; +-- +ok +== +DROP TABLE test_table; +-- +ok +== +DROP TABLE main_table; +-- +ok +== +DROP TABLE oop_table; +-- +ok +== +DROP TABLE out_of_path.oop_table; +-- +ok +== +CREATE TABLE test_table2(i INTEGER); +-- +ok +== +DROP TABLE test.test_table2; +-- +ok +== +CREATE TABLE test_table3(i INTEGER); +-- +ok +== +DROP TABLE IF EXISTS test_table3; +-- +ok +== +CREATE TABLE test_table4(i INTEGER); +-- +ok +== +DROP TABLE IF EXISTS test.test_table4; +-- +ok +== +CREATE TABLE main.main_table2(i INTEGER); +-- +ok +== +DROP TABLE IF EXISTS main.main_table2; +-- +ok +== diff --git a/parser/testdata/corpus/sql/catalog/test_set_search_path.test b/parser/testdata/corpus/sql/catalog/test_set_search_path.test new file mode 100644 index 0000000..5c8f23b --- /dev/null +++ b/parser/testdata/corpus/sql/catalog/test_set_search_path.test @@ -0,0 +1,185 @@ +# source: test/sql/catalog/test_set_search_path.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +CREATE TABLE main_table(i INTEGER); +-- +ok +== +CREATE TABLE test.test_table(i INTEGER); +-- +ok +== +CREATE SCHEMA test2; +-- +ok +== +CREATE TABLE test2.bye(i INTEGER); +-- +ok +== +CREATE TABLE test2.test2_table(i INTEGER); +-- +ok +== +CREATE SCHEMA test3; +-- +ok +== +CREATE SCHEMA test4; +-- +ok +== +CREATE SCHEMA test5; +-- +ok +== +CREATE TABLE test5.test5_table(i INTEGER); +-- +ok +== +SELECT CURRENT_SETTING('schema'); +-- +ok +== +SET SEARCH_PATH = 'test'; +-- +ok +== +SET SEARCH_PATH = 'test,test2'; +-- +ok +== +SET SEARCH_PATH = '"test","test2"'; +-- +ok +== +SET SEARCH_PATH = 'does_not_exist'; +-- +ok +== +SET SCHEMA = 'test'; +-- +ok +== +SET SCHEMA 'main'; +-- +ok +== +SET SCHEMA 'test'; +-- +ok +== +SET SCHEMA = 'test,test2'; +-- +error: Parser Error: Failed to convert entry "test,test2" to CatalogSearchEntry - expected a single entry +== +SET SCHEMA = 'does_not_exist'; +-- +ok +== +SET SEARCH_PATH = '"invalid quoted string list'; +-- +error: Parser Error: Unterminated quote in qualified name! +== +SELECT MAIN.CURRENT_SETTING('search_path'); +-- +ok +== +SELECT MAIN.CURRENT_SCHEMAS(false); +-- +ok +== +SELECT pg_catalog.CURRENT_SCHEMAS(false); +-- +ok +== +SELECT MAIN.CURRENT_SCHEMA(); +-- +ok +== +SELECT pg_catalog.CURRENT_SCHEMA(); +-- +ok +== +SELECT current_schema(); +-- +ok +== +SELECT current_schemas(true); +-- +ok +== +SET schema = 'test2'; +-- +ok +== +SET search_path = 'test3'; +-- +ok +== +SELECT i FROM test2_table; +-- +ok +== +SELECT i FROM main_table; +-- +ok +== +CREATE TABLE main.table_with_same_name(in_main INTEGER); +-- +ok +== +CREATE TABLE test.table_with_same_name(in_test INTEGER); +-- +ok +== +CREATE TABLE test2.table_with_same_name(in_test2 INTEGER); +-- +ok +== +SELECT in_main FROM table_with_same_name; +-- +ok +== +SELECT in_test2 FROM table_with_same_name; +-- +ok +== +SELECT in_test FROM table_with_same_name; +-- +ok +== +SET SEARCH_PATH = 'test,test2,test3,test4,test5'; +-- +ok +== +SELECT i FROM test5_table; +-- +ok +== +SET SEARCH_PATH = 'test,test,test2'; +-- +ok +== +SET schema = 'test'; +-- +ok +== +SET search_path = pg_catalog; +-- +ok +== +SELECT current_database(); +-- +ok +== +SELECT current_catalog(); +-- +ok +== +SELECT current_query(); +-- +ok +== diff --git a/parser/testdata/corpus/sql/catalog/test_set_search_path.test.metadata.json b/parser/testdata/corpus/sql/catalog/test_set_search_path.test.metadata.json new file mode 100644 index 0000000..0a73c16 --- /dev/null +++ b/parser/testdata/corpus/sql/catalog/test_set_search_path.test.metadata.json @@ -0,0 +1,6 @@ +{ + "todo": { + "64443d42a674a5dd": "transformer-raised parser error: upstream rejects in the transformer, not the grammar; expected to clear as transformers land (milestones 3-5)", + "c08e8748bc9dce3d": "transformer-raised parser error: upstream rejects in the transformer, not the grammar; expected to clear as transformers land (milestones 3-5)" + } +} diff --git a/parser/testdata/corpus/sql/catalog/test_standard_schema.test b/parser/testdata/corpus/sql/catalog/test_standard_schema.test new file mode 100644 index 0000000..34cc61b --- /dev/null +++ b/parser/testdata/corpus/sql/catalog/test_standard_schema.test @@ -0,0 +1,29 @@ +# source: test/sql/catalog/test_standard_schema.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +DROP SCHEMA main CASCADE; +-- +ok +== +CREATE SCHEMA IF NOT EXISTS test; +-- +ok +== +CREATE TABLE test2.hello(i INTEGER); +-- +ok +== +SELECT * FROM hello +-- +ok +== +DROP SCHEMA test CASCADE; +-- +ok +== +DROP SCHEMA IF EXISTS test; +-- +ok +== diff --git a/parser/testdata/corpus/sql/catalog/test_temporary.test b/parser/testdata/corpus/sql/catalog/test_temporary.test new file mode 100644 index 0000000..a88a8fc --- /dev/null +++ b/parser/testdata/corpus/sql/catalog/test_temporary.test @@ -0,0 +1,113 @@ +# source: test/sql/catalog/test_temporary.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +CREATE TEMPORARY TABLE integers(i INTEGER) ON COMMIT PRESERVE ROWS +-- +ok +== +CREATE TEMPORARY TABLE integersx(i INTEGER) +-- +ok +== +CREATE TEMPORARY TABLE main.integersy(i INTEGER) +-- +ok +== +CREATE TEMPORARY TABLE s1 AS SELECT 42 +-- +ok +== +SELECT * FROM temp.s1 +-- +ok +== +SELECT * FROM s1 +-- +ok +== +CREATE TABLE temp.integersy(i INTEGER) +-- +error: Parser Error: Only TEMPORARY table names can use the "temp" catalog +== +CREATE SCHEMA temp +-- +ok +== +CREATE TABLE memory.temp.integersy(i INTEGER) +-- +ok +== +DROP SCHEMA temp CASCADE +-- +ok +== +DROP TABLE memory.main.integersx +-- +ok +== +DROP TABLE integersx +-- +ok +== +CREATE TEMPORARY TABLE temp.integersx(i INTEGER) +-- +ok +== +DROP TABLE temp.integersx +-- +ok +== +CREATE TEMPORARY TABLE integers2(i INTEGER) ON COMMIT DELETE ROWS +-- +ok +== +CREATE TEMPORARY TABLE integers(i INTEGER) +-- +ok +== +INSERT INTO integers VALUES (42) +-- +ok +== +SELECT i from integers +-- +ok +== +CREATE TEMPORARY TABLE integers2(i INTEGER) +-- +ok +== +CREATE TEMPORARY SEQUENCE seq +-- +ok +== +CREATE TEMPORARY VIEW v1 AS SELECT 42 +-- +ok +== +INSERT INTO integers2 VALUES (42) +-- +ok +== +SELECT i from integers2 +-- +ok +== +SELECT * from v1 +-- +ok +== +CREATE TEMPORARY TABLE integers3(i INTEGER) +-- +ok +== +INSERT INTO integers3 VALUES (42) +-- +ok +== +SELECT i from integers3 +-- +ok +== diff --git a/parser/testdata/corpus/sql/catalog/test_temporary.test.metadata.json b/parser/testdata/corpus/sql/catalog/test_temporary.test.metadata.json new file mode 100644 index 0000000..8523322 --- /dev/null +++ b/parser/testdata/corpus/sql/catalog/test_temporary.test.metadata.json @@ -0,0 +1,5 @@ +{ + "todo": { + "af16bac22724a9c9": "transformer-raised parser error: upstream rejects in the transformer, not the grammar; expected to clear as transformers land (milestones 3-5)" + } +} diff --git a/parser/testdata/corpus/sql/catalog/test_unicode_schema.test b/parser/testdata/corpus/sql/catalog/test_unicode_schema.test new file mode 100644 index 0000000..e31e3f3 --- /dev/null +++ b/parser/testdata/corpus/sql/catalog/test_unicode_schema.test @@ -0,0 +1,49 @@ +# source: test/sql/catalog/test_unicode_schema.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +CREATE TABLE 👤(🔑 INTEGER PRIMARY KEY, 🗣 varchar(64), 🗓 DATE); +-- +ok +== +CREATE TABLE ✍(🔑 INTEGER PRIMARY KEY, 🗣 varchar(64)); +-- +ok +== +CREATE TABLE 📕(🔑 INTEGER PRIMARY KEY, 💬 varchar(64), 🔖 varchar(64), ✍ INTEGER); +-- +ok +== +CREATE TABLE 👤🏠📕(👤 INTEGER, 📕 INTEGER, ⭐ TEXT); +-- +ok +== +INSERT INTO 👤 VALUES (1, 'Jeff', '2019-01-01'), (2, 'Annie', '2019-01-01'); +-- +ok +== +INSERT INTO ✍ VALUES (1, 'Herman Melville'), (2, 'Lewis Carroll'); +-- +ok +== +INSERT INTO 📕 VALUES (1, 'Alice in Wonderland', '🔮', 2), (2, 'Moby Dick', '📖', 1), (3, 'Through the Looking-Glass', '🔮', 2); +-- +ok +== +INSERT INTO 👤🏠📕 VALUES (1, 1, '😍'), (1, 2, '🤢'), (2, 2, '🙂'); +-- +ok +== +SELECT 👤.🗣 AS 👤, 📕.💬 AS 📕 FROM 👤 JOIN 👤🏠📕 ON 👤.🔑 = 👤🏠📕.👤 JOIN 📕 ON 📕.🔑 = 👤🏠📕.📕 ORDER BY 👤, 📕; +-- +ok +== +SELECT 👤.🗣, 👤🏠📕.⭐ FROM 👤🏠📕 JOIN 📕 ON 👤🏠📕.📕 = 📕.🔑 JOIN 👤 ON 👤🏠📕.👤=👤.🔑 WHERE 📕.💬 = 'Moby Dick' ORDER BY 👤.🗣; +-- +ok +== +SELECT type, name FROM sqlite_master WHERE name='👤' ORDER BY name; +-- +ok +== diff --git a/parser/testdata/corpus/sql/catalog/view/deferred_binding.test b/parser/testdata/corpus/sql/catalog/view/deferred_binding.test new file mode 100644 index 0000000..2735f1e --- /dev/null +++ b/parser/testdata/corpus/sql/catalog/view/deferred_binding.test @@ -0,0 +1,13 @@ +# source: test/sql/catalog/view/deferred_binding.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +CREATE VIEW v1 WITH (DEFER_BINDING) AS SELECT * FROM tbl; +-- +ok +== +FROM v1 +-- +ok +== diff --git a/parser/testdata/corpus/sql/catalog/view/recursive_view.test b/parser/testdata/corpus/sql/catalog/view/recursive_view.test new file mode 100644 index 0000000..97bd8c2 --- /dev/null +++ b/parser/testdata/corpus/sql/catalog/view/recursive_view.test @@ -0,0 +1,29 @@ +# source: test/sql/catalog/view/recursive_view.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +CREATE TABLE IF NOT EXISTS test (val INTEGER); +-- +ok +== +INSERT INTO test(val) VALUES (1), (2), (3); +-- +ok +== +CREATE OR REPLACE VIEW foo AS (SELECT * FROM test); +-- +ok +== +CREATE OR REPLACE VIEW foo AS (SELECT * FROM foo); +-- +ok +== +CREATE OR REPLACE VIEW foo2 AS (SELECT * FROM foo); +-- +ok +== +CREATE OR REPLACE VIEW foo AS (SELECT (SELECT * FROM foo2)); +-- +ok +== diff --git a/parser/testdata/corpus/sql/catalog/view/recursive_view_with_dependencies.test b/parser/testdata/corpus/sql/catalog/view/recursive_view_with_dependencies.test new file mode 100644 index 0000000..87cf375 --- /dev/null +++ b/parser/testdata/corpus/sql/catalog/view/recursive_view_with_dependencies.test @@ -0,0 +1,9 @@ +# source: test/sql/catalog/view/recursive_view_with_dependencies.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +set storage_compatibility_version='v1.0.0' +-- +ok +== diff --git a/parser/testdata/corpus/sql/catalog/view/test_loosely_qualified_view_sql.test b/parser/testdata/corpus/sql/catalog/view/test_loosely_qualified_view_sql.test new file mode 100644 index 0000000..25e860c --- /dev/null +++ b/parser/testdata/corpus/sql/catalog/view/test_loosely_qualified_view_sql.test @@ -0,0 +1,48 @@ +# source: test/sql/catalog/view/test_loosely_qualified_view_sql.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +attach ':memory:' as db1; +-- +ok +== +attach ':memory:' as db2; +-- +ok +== +create schema db1.s1; +-- +ok +== +create schema db2.s1; +-- +ok +== +create table db1.s1.t1 as select 1 col; +-- +ok +== +create or replace view v1 as +from s1.t1; +-- +ok +== +create or replace view v1 as +from (select col+5 from s1.t1); +-- +ok +== +create or replace view v1 as +select (from s1.t1) +-- +ok +== +from db1.v1; +-- +ok +== +use db2.s1; +-- +ok +== diff --git a/parser/testdata/corpus/sql/catalog/view/test_stacked_view.test b/parser/testdata/corpus/sql/catalog/view/test_stacked_view.test new file mode 100644 index 0000000..c6a99bd --- /dev/null +++ b/parser/testdata/corpus/sql/catalog/view/test_stacked_view.test @@ -0,0 +1,29 @@ +# source: test/sql/catalog/view/test_stacked_view.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +CREATE TABLE t1(i INTEGER) +-- +ok +== +INSERT INTO t1 VALUES (41), (42), (43), (44) +-- +ok +== +CREATE VIEW v1 (v1c1, v1c2) AS SELECT i,i+1 FROM t1 WHERE i > 41 +-- +ok +== +CREATE VIEW v2 (v2c1, v2c2, v2c3) AS SELECT v1c1, v1c2, v1c1+v1c2 FROM v1 WHERE v1c2 > 42 +-- +ok +== +CREATE VIEW v3 (v3c1, v3c2) AS SELECT v2c1, v2c3 FROM v2 WHERE v2c1 > 43 +-- +ok +== +SELECT v3c2+1 FROM v3 WHERE v3c1 > 42 +-- +ok +== diff --git a/parser/testdata/corpus/sql/catalog/view/test_view.test b/parser/testdata/corpus/sql/catalog/view/test_view.test new file mode 100644 index 0000000..c745ea3 --- /dev/null +++ b/parser/testdata/corpus/sql/catalog/view/test_view.test @@ -0,0 +1,47 @@ +# source: test/sql/catalog/view/test_view.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +INSERT INTO t1 VALUES (41), (42), (43) +-- +ok +== +CREATE VIEW v1 AS SELECT + i AS j +FROM t1 WHERE i < 43 +-- +ok +== +CREATE VIEW v1 AS SELECT 'whatever' +-- +ok +== +SELECT j FROM v1 WHERE j > 41 +-- +ok +== +SELECT x FROM v1 t1(x) WHERE x > 41 +-- +ok +== +DROP VIEW v1 +-- +ok +== +CREATE OR REPLACE VIEW v1 AS SELECT 42 +-- +ok +== +INSERT INTO v1 VALUES (1) +-- +ok +== +DROP VIEW IF EXISTS v1 +-- +ok +== +CREATE VIEW v1 AS SELECT * FROM dontexist +-- +ok +== diff --git a/parser/testdata/corpus/sql/catalog/view/test_view_alias.test b/parser/testdata/corpus/sql/catalog/view/test_view_alias.test new file mode 100644 index 0000000..c052439 --- /dev/null +++ b/parser/testdata/corpus/sql/catalog/view/test_view_alias.test @@ -0,0 +1,29 @@ +# source: test/sql/catalog/view/test_view_alias.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +CREATE VIEW v1 (j, "j2") AS SELECT * FROM t1 +-- +ok +== +CREATE VIEW v1 (j, "j2") AS SELECT i,i+1 FROM t1 +-- +ok +== +SELECT j, j2 FROM v1 +-- +ok +== +CREATE VIEW v1 (j, "j2") AS SELECT i,i+1, i+2 FROM t1 +-- +ok +== +CREATE VIEW v1 (j, "j2") AS SELECT i,i+1, i+2 as x FROM t1 +-- +ok +== +SELECT j, j2, x FROM v1 +-- +ok +== diff --git a/parser/testdata/corpus/sql/catalog/view/test_view_delete_update.test b/parser/testdata/corpus/sql/catalog/view/test_view_delete_update.test new file mode 100644 index 0000000..8ba1a12 --- /dev/null +++ b/parser/testdata/corpus/sql/catalog/view/test_view_delete_update.test @@ -0,0 +1,17 @@ +# source: test/sql/catalog/view/test_view_delete_update.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +CREATE VIEW v1 AS SELECT i AS j FROM t1 WHERE i < 43 +-- +ok +== +DELETE FROM v1; +-- +ok +== +UPDATE v1 SET j=1; +-- +ok +== diff --git a/parser/testdata/corpus/sql/catalog/view/test_view_drop_concurrent.test b/parser/testdata/corpus/sql/catalog/view/test_view_drop_concurrent.test new file mode 100644 index 0000000..38c1194 --- /dev/null +++ b/parser/testdata/corpus/sql/catalog/view/test_view_drop_concurrent.test @@ -0,0 +1,13 @@ +# source: test/sql/catalog/view/test_view_drop_concurrent.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +CREATE TEMPORARY VIEW df AS select 0,0,0 from range(10); +-- +ok +== +DROP VIEW df; +-- +ok +== diff --git a/parser/testdata/corpus/sql/catalog/view/test_view_duplicate_columns.test b/parser/testdata/corpus/sql/catalog/view/test_view_duplicate_columns.test new file mode 100644 index 0000000..d844c55 --- /dev/null +++ b/parser/testdata/corpus/sql/catalog/view/test_view_duplicate_columns.test @@ -0,0 +1,35 @@ +# source: test/sql/catalog/view/test_view_duplicate_columns.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +create or replace table basic_table_a as select 42 as column_a; +-- +ok +== +create or replace table basic_table_b as select 37 as column_a; +-- +ok +== +create or replace view duplicate_column_view as ( + from basic_table_a t1 + cross join basic_table_b t2 + select + t1.*, + t2.* +); +-- +ok +== +from duplicate_column_view; +-- +ok +== +select column_name FROM (describe from duplicate_column_view) order by all; +-- +ok +== +select column_name from duckdb_columns() where table_name = 'duplicate_column_view' order by all; +-- +ok +== diff --git a/parser/testdata/corpus/sql/catalog/view/test_view_schema_change.test b/parser/testdata/corpus/sql/catalog/view/test_view_schema_change.test new file mode 100644 index 0000000..edc3723 --- /dev/null +++ b/parser/testdata/corpus/sql/catalog/view/test_view_schema_change.test @@ -0,0 +1,37 @@ +# source: test/sql/catalog/view/test_view_schema_change.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +CREATE VIEW v1 AS SELECT * FROM t1 +-- +ok +== +CREATE TABLE t1(i DATE) +-- +ok +== +CREATE TABLE t1(i INTEGER, j INTEGER) +-- +ok +== +CREATE TABLE t1(k INTEGER) +-- +ok +== +ALTER TABLE t1 ALTER i TYPE VARCHAR; +-- +ok +== +select * from v1; +-- +ok +== +ALTER TABLE t1 ALTER i TYPE INTEGER +-- +ok +== +ALTER TABLE t1 RENAME i TO j +-- +ok +== diff --git a/parser/testdata/corpus/sql/catalog/view/test_view_schema_change_with_dependencies.test b/parser/testdata/corpus/sql/catalog/view/test_view_schema_change_with_dependencies.test new file mode 100644 index 0000000..be24b5f --- /dev/null +++ b/parser/testdata/corpus/sql/catalog/view/test_view_schema_change_with_dependencies.test @@ -0,0 +1,13 @@ +# source: test/sql/catalog/view/test_view_schema_change_with_dependencies.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +DROP TABLE t1 CASCADE +-- +ok +== +drop view v1; +-- +ok +== diff --git a/parser/testdata/corpus/sql/catalog/view/test_view_sql.test b/parser/testdata/corpus/sql/catalog/view/test_view_sql.test new file mode 100644 index 0000000..2ee5950 --- /dev/null +++ b/parser/testdata/corpus/sql/catalog/view/test_view_sql.test @@ -0,0 +1,67 @@ +# source: test/sql/catalog/view/test_view_sql.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +create schema my_schema; +-- +ok +== +CREATE VIEW my_schema.X (a) AS SELECT 'x' as x, 'y' as y; +-- +ok +== +select trim(sql, chr(10)) from duckdb_views() where internal = false; +-- +ok +== +alter view my_schema.X rename to Y; +-- +ok +== +drop schema my_schema cascade; +-- +ok +== +create table tbl ( + a integer, + b varchar +) +-- +ok +== +alter table tbl rename column b to x; +-- +ok +== +create or replace view vw (c1, c2) as select * from tbl; +-- +ok +== +create or replace table "table name" ( + "column name 1" integer, + "column name 2" varchar +) +-- +ok +== +create or replace view "view name" as select * from "table name"; +-- +ok +== +drop view vw; +-- +ok +== +drop view "view name" +-- +ok +== +create schema "schema name"; +-- +ok +== +CREATE VIEW "schema name"."view name" ("other name 1", "column name 2") AS SELECT * FROM "table name"; +-- +ok +== diff --git a/parser/testdata/corpus/sql/catalog/view/test_view_sql_with_dependencies.test b/parser/testdata/corpus/sql/catalog/view/test_view_sql_with_dependencies.test new file mode 100644 index 0000000..6b16383 --- /dev/null +++ b/parser/testdata/corpus/sql/catalog/view/test_view_sql_with_dependencies.test @@ -0,0 +1,9 @@ +# source: test/sql/catalog/view/test_view_sql_with_dependencies.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +CREATE VIEW vw AS SELECT * FROM tbl; +-- +ok +== diff --git a/parser/testdata/corpus/sql/catalog/view/view_if_not_exists.test b/parser/testdata/corpus/sql/catalog/view/view_if_not_exists.test new file mode 100644 index 0000000..c532403 --- /dev/null +++ b/parser/testdata/corpus/sql/catalog/view/view_if_not_exists.test @@ -0,0 +1,13 @@ +# source: test/sql/catalog/view/view_if_not_exists.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +CREATE VIEW v1 AS SELECT 42 +-- +ok +== +CREATE VIEW IF NOT EXISTS v1 AS SELECT 84; +-- +ok +== diff --git a/parser/testdata/corpus/sql/collate/collate_filter_pushdown.test b/parser/testdata/corpus/sql/collate/collate_filter_pushdown.test new file mode 100644 index 0000000..cd0f048 --- /dev/null +++ b/parser/testdata/corpus/sql/collate/collate_filter_pushdown.test @@ -0,0 +1,25 @@ +# source: test/sql/collate/collate_filter_pushdown.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +CREATE TABLE t0(c0 BOOLEAN, PRIMARY KEY(c0)); +-- +ok +== +CREATE TABLE t63(c0 VARCHAR COLLATE C, PRIMARY KEY(c0)); +-- +ok +== +insert into t0(c0) values (0.7); +-- +ok +== +insert into t63(c0) values ('1'); +-- +ok +== +SELECT t63.c0 FROM t0 NATURAL LEFT JOIN t63; +-- +ok +== diff --git a/parser/testdata/corpus/sql/collate/collate_in_subquery.test b/parser/testdata/corpus/sql/collate/collate_in_subquery.test new file mode 100644 index 0000000..a8a4f0b --- /dev/null +++ b/parser/testdata/corpus/sql/collate/collate_in_subquery.test @@ -0,0 +1,29 @@ +# source: test/sql/collate/collate_in_subquery.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +select 'ABC' collate nocase in (select 'aBc'); +-- +ok +== +select upper in (select lower) from (values ('ABC' COLLATE nocase, 'aBc' COLLATE nocase)) t(upper, lower); +-- +ok +== +select 'ABC' collate nocase in (select s) from (values ('aBc')) t(s); +-- +ok +== +select 'ABC' in (select s collate nocase) from (values ('aBc')) t(s); +-- +ok +== +select 'AB' collate nocase in (select 'AB'); +-- +ok +== +select 'Ab' collate nocase in (select 'Ab'); +-- +ok +== diff --git a/parser/testdata/corpus/sql/collate/collate_like.test b/parser/testdata/corpus/sql/collate/collate_like.test new file mode 100644 index 0000000..3df0bf7 --- /dev/null +++ b/parser/testdata/corpus/sql/collate/collate_like.test @@ -0,0 +1,77 @@ +# source: test/sql/collate/collate_like.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +SELECT 'a' LIKE 'A' COLLATE NOCASE +-- +ok +== +SELECT 'a' NOT LIKE 'A' COLLATE NOCASE +-- +ok +== +SELECT 'A' COLLATE NOCASE LIKE 'a' +-- +ok +== +SELECT 'a' LIKE 'A%' COLLATE NOCASE +-- +ok +== +SELECT 'A' COLLATE NOCASE LIKE '%A' COLLATE NOCASE +-- +ok +== +SELECT 'a' COLLATE NOCASE LIKE '%A%' COLLATE NOCASE +-- +ok +== +SELECT 'OX' COLLATE NOACCENT.NOCASE LIKE 'ö%' +-- +ok +== +CREATE TABLE t1 (c1 VARCHAR, pattern VARCHAR) +-- +ok +== +INSERT INTO t1 VALUES('A', 'a'),('a', 'A'),('AAAA', 'AaAa'),('aaaa', 'baba') +-- +ok +== +SELECT c1 FROM t1 WHERE c1 LIKE pattern +-- +ok +== +SELECT c1 FROM t1 WHERE c1 LIKE pattern COLLATE NOCASE +-- +ok +== +SELECT 'a%ö' COLLATE NOACCENT LIKE 'a$%ö' ESCAPE '$' +-- +ok +== +SELECT 'a%ö' COLLATE NOACCENT NOT LIKE 'a$%ö' ESCAPE '$' +-- +ok +== +SELECT 'oX' ILIKE 'Ö%' +-- +ok +== +SELECT 'OX' COLLATE NOACCENT ILIKE 'ö%' +-- +ok +== +SELECT 'öX' COLLATE NOACCENT NOT ILIKE 'Ö%' +-- +ok +== +SELECT 'oX' GLOB 'O*' +-- +ok +== +SELECT 'oX' COLLATE NOCASE GLOB 'O*' +-- +ok +== diff --git a/parser/testdata/corpus/sql/collate/collate_non_varchar.test b/parser/testdata/corpus/sql/collate/collate_non_varchar.test new file mode 100644 index 0000000..a3b7f88 --- /dev/null +++ b/parser/testdata/corpus/sql/collate/collate_non_varchar.test @@ -0,0 +1,13 @@ +# source: test/sql/collate/collate_non_varchar.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +PRAGMA default_collation=NOCASE; +-- +ok +== +select typeof(x) from (select 1::INT as x group by x); +-- +ok +== diff --git a/parser/testdata/corpus/sql/collate/collate_order_by_alias.test b/parser/testdata/corpus/sql/collate/collate_order_by_alias.test new file mode 100644 index 0000000..4c63155 --- /dev/null +++ b/parser/testdata/corpus/sql/collate/collate_order_by_alias.test @@ -0,0 +1,38 @@ +# source: test/sql/collate/collate_order_by_alias.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +CREATE TABLE CreditCardTable(id BIGINT, creditCard_number VARCHAR); +-- +ok +== +CREATE TABLE CustomerTable(id BIGINT, pk BIGINT); +-- +ok +== +INSERT INTO CreditCardTable VALUES (1, 'A'), (2, 'z'); +-- +ok +== +INSERT INTO CustomerTable VALUES (1, 100), (2, 0); +-- +ok +== +select + creditCard_number as "pk", CustomerTable.pk AS inner_pk +from + CreditCardTable JOIN CustomerTable USING (id) +order by + "pk" COLLATE NOCASE; +-- +ok +== +select + creditCard_number as "pk", CustomerTable.pk AS inner_pk +from + CreditCardTable JOIN CustomerTable USING (id) +order by #1 COLLATE NOCASE; +-- +ok +== diff --git a/parser/testdata/corpus/sql/collate/collate_ordered_aggregate.test b/parser/testdata/corpus/sql/collate/collate_ordered_aggregate.test new file mode 100644 index 0000000..e8990df --- /dev/null +++ b/parser/testdata/corpus/sql/collate/collate_ordered_aggregate.test @@ -0,0 +1,17 @@ +# source: test/sql/collate/collate_ordered_aggregate.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +create table tbl(id int, val varchar); +-- +ok +== +insert into tbl values (0, 'a'), (1, 'B'); +-- +ok +== +select list(id order by val collate nocase) from tbl; +-- +ok +== diff --git a/parser/testdata/corpus/sql/collate/collate_string_col.test b/parser/testdata/corpus/sql/collate/collate_string_col.test new file mode 100644 index 0000000..b3ab256 --- /dev/null +++ b/parser/testdata/corpus/sql/collate/collate_string_col.test @@ -0,0 +1,19 @@ +# source: test/sql/collate/collate_string_col.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +CREATE TABLE tbl ( + col1 STRING COLLATE NOCASE +); +-- +ok +== +INSERT INTO tbl VALUES ('Hello'), ('hello'), ('HELLO'), ('hElLo'); +-- +ok +== +SELECT * FROM tbl WHERE col1 = 'hello'; +-- +ok +== diff --git a/parser/testdata/corpus/sql/collate/collate_subquery.test b/parser/testdata/corpus/sql/collate/collate_subquery.test new file mode 100644 index 0000000..1bd6c0e --- /dev/null +++ b/parser/testdata/corpus/sql/collate/collate_subquery.test @@ -0,0 +1,21 @@ +# source: test/sql/collate/collate_subquery.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +create table t0(c1 varchar); +-- +ok +== +insert into t0 values ('XXX'); +-- +ok +== +select (select c1 from t0) collate nocase; +-- +ok +== +select (select c1 from t0) collate nocase='xxx'; +-- +ok +== diff --git a/parser/testdata/corpus/sql/collate/collation_sort_keys.test b/parser/testdata/corpus/sql/collate/collation_sort_keys.test new file mode 100644 index 0000000..e44e739 --- /dev/null +++ b/parser/testdata/corpus/sql/collate/collation_sort_keys.test @@ -0,0 +1,113 @@ +# source: test/sql/collate/collation_sort_keys.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +SELECT icu_sort_key('a', 'en') +-- +ok +== +SELECT icu_sort_key('A', 'en') +-- +ok +== +SELECT icu_sort_key('ab', 'en') +-- +ok +== +SELECT icu_sort_key('1', 'en') +-- +ok +== +SELECT icu_sort_key(' ', 'en') +-- +ok +== +SELECT icu_sort_key('æ', 'en') +-- +ok +== +SELECT icu_sort_key(chr(19968), 'en') +-- +ok +== +SELECT icu_sort_key(chr(19969), 'en') +-- +ok +== +SELECT icu_sort_key(chr(40869), 'en') +-- +ok +== +SELECT icu_sort_key(chr(262144), 'en') +-- +ok +== +SELECT icu_sort_key(chr(44032), 'en') +-- +ok +== +SELECT icu_sort_key(chr(44032), 'en') = icu_sort_key(chr(4352) || chr(4449), 'en') +-- +ok +== +SELECT icu_sort_key('ch', 'cs') +-- +ok +== +SELECT icu_sort_key('aa', 'da') +-- +ok +== +SELECT icu_sort_key('ーあ', 'ja') +-- +ok +== +SELECT icu_sort_key('α', 'el') +-- +ok +== +SELECT icu_sort_key('б', 'ru') +-- +ok +== +SELECT icu_sort_key('А', 'cu') +-- +ok +== +SELECT icu_sort_key('côte', 'fr_ca') +-- +ok +== +SELECT icu_sort_key('-', 'th') +-- +ok +== +CREATE TABLE strings(s VARCHAR) +-- +ok +== +INSERT INTO strings VALUES ('a'), ('Müller'), ('ch'), ('aa'), ('ーあ'), (chr(44032)), (chr(19968)), ('') +-- +ok +== +SELECT count(*) FROM strings WHERE hex(collate_de(s)) <> icu_sort_key(s, 'de') +-- +ok +== +SELECT count(*) FROM strings WHERE hex(collate_de(s)) <> icu_collate_de(s) +-- +ok +== +SELECT typeof(collate_de('a')), typeof(icu_collate_de('a')) +-- +ok +== +SELECT s FROM (VALUES ('h'), ('ch'), ('i')) t(s) ORDER BY s COLLATE cs +-- +ok +== +SELECT s FROM (VALUES ('z'), ('aa'), ('å'), ('a')) t(s) ORDER BY s COLLATE da, s +-- +ok +== diff --git a/parser/testdata/corpus/sql/collate/icu_collation_propagation.test b/parser/testdata/corpus/sql/collate/icu_collation_propagation.test new file mode 100644 index 0000000..aa813e7 --- /dev/null +++ b/parser/testdata/corpus/sql/collate/icu_collation_propagation.test @@ -0,0 +1,69 @@ +# source: test/sql/collate/icu_collation_propagation.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +create table tbl (a varchar, b varchar); +-- +ok +== +insert into tbl values ('ö', '>>>>>ö<<<<<'), ('o', '>>>>>o<<<<<'), ('p', '>>>>>p<<<<<'); +-- +ok +== +select concat(a collate de, a) from tbl order by all; +-- +ok +== +select lower(a collate de) from tbl order by all; +-- +ok +== +select upper(a collate de) from tbl order by all; +-- +ok +== +select trim(b collate de, '<>') from tbl order by all +-- +ok +== +select ltrim(b collate de, '<>') from tbl order by all +-- +ok +== +select rtrim(b collate de, '<>') from tbl order by all +-- +ok +== +select repeat(a collate de, 10) from tbl order by all; +-- +ok +== +select left(b collate de, 6) from tbl order by all; +-- +ok +== +select right(b collate de, 6) from tbl order by all; +-- +ok +== +select right(left(b collate de, 6), 1) from tbl order by all; +-- +ok +== +select reverse(a collate de) from tbl order by all; +-- +ok +== +select a from tbl where contains(b collate de, 'o') order by all +-- +ok +== +select a from tbl where starts_with(b collate de, '>>>>>o') order by all +-- +ok +== +select a from tbl where b collate de like '%>o<%' order by all +-- +ok +== diff --git a/parser/testdata/corpus/sql/collate/nop_collation_join_filter_pushdown.test b/parser/testdata/corpus/sql/collate/nop_collation_join_filter_pushdown.test new file mode 100644 index 0000000..14f1acf --- /dev/null +++ b/parser/testdata/corpus/sql/collate/nop_collation_join_filter_pushdown.test @@ -0,0 +1,33 @@ +# source: test/sql/collate/nop_collation_join_filter_pushdown.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +PRAGMA explain_output='optimized_only' +-- +ok +== +SET disabled_optimizers TO 'column_lifetime,compressed_materialization'; +-- +ok +== +CREATE TABLE s (a text); +-- +ok +== +INSERT INTO s SELECT 'val_' || range FROM range(10000);; +-- +ok +== +CREATE TABLE t (b text); +-- +ok +== +INSERT INTO t VALUES ('val_3'); +-- +ok +== +EXPLAIN ANALYZE SELECT * FROM s, t WHERE a = b COLLATE C; +-- +ok +== diff --git a/parser/testdata/corpus/sql/collate/test_collate_accent_insensitive.test b/parser/testdata/corpus/sql/collate/test_collate_accent_insensitive.test new file mode 100644 index 0000000..3d58cec --- /dev/null +++ b/parser/testdata/corpus/sql/collate/test_collate_accent_insensitive.test @@ -0,0 +1,57 @@ +# source: test/sql/collate/test_collate_accent_insensitive.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +CREATE TABLE collate_test(s VARCHAR COLLATE NOACCENT) +-- +ok +== +INSERT INTO collate_test VALUES ('Mühleisen'), ('Hëllö') +-- +ok +== +SELECT * FROM collate_test WHERE s='Muhleisen' +-- +ok +== +SELECT * FROM collate_test WHERE s='mühleisen' +-- +ok +== +SELECT * FROM collate_test WHERE s='Hello' +-- +ok +== +CREATE TABLE collate_join_table(s VARCHAR, i INTEGER) +-- +ok +== +INSERT INTO collate_join_table VALUES ('Hello', 1), ('Muhleisen', 3) +-- +ok +== +SELECT collate_test.s, collate_join_table.s, i FROM collate_test JOIN collate_join_table ON (collate_test.s=collate_join_table.s) ORDER BY 1 +-- +ok +== +DROP TABLE collate_test +-- +ok +== +INSERT INTO collate_test VALUES ('Hällo'), ('Hallo'), ('Hello') +-- +ok +== +SELECT * FROM collate_test ORDER BY s +-- +ok +== +INSERT INTO collate_test VALUES ('Hällo'), ('Hallo') +-- +ok +== +SELECT DISTINCT s FROM collate_test +-- +ok +== diff --git a/parser/testdata/corpus/sql/collate/test_collate_and_grouping_sets.test b/parser/testdata/corpus/sql/collate/test_collate_and_grouping_sets.test new file mode 100644 index 0000000..e973818 --- /dev/null +++ b/parser/testdata/corpus/sql/collate/test_collate_and_grouping_sets.test @@ -0,0 +1,53 @@ +# source: test/sql/collate/test_collate_and_grouping_sets.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +set default_collation=c; +-- +ok +== +CREATE TABLE sales ( + product_id INT, + region VARCHAR(50), + year INT, + amount_sold DECIMAL(10,2) +); +-- +ok +== +INSERT INTO sales VALUES + (1, 'North', 2020, 1000.00), + (1, 'North', 2021, 1500.00), + (1, 'South', 2020, 800.00), + (1, 'South', 2021, 700.00), + (2, 'North', 2020, 500.00), + (2, 'North', 2021, 600.00), + (2, 'South', 2020, 400.00), + (2, 'South', 2021, 550.00); +-- +ok +== +SELECT product_id, region, SUM(amount_sold) AS total_amount +FROM sales +GROUP BY GROUPING SETS ((product_id), (region), ()) +ORDER BY product_id, region, total_amount; +-- +ok +== +set default_collation=en_us; +-- +ok +== +set default_collation=c +-- +ok +== +select NULL product_id, region, sum(amount_sold) from sales group by region +UNION ALL +select NULL product_id, NULL region, sum(amount_sold) from sales +UNION ALL +select product_id, NULL region, sum(amount_sold) from sales group by product_id order by 1,2; +-- +ok +== diff --git a/parser/testdata/corpus/sql/collate/test_collate_between.test b/parser/testdata/corpus/sql/collate/test_collate_between.test new file mode 100644 index 0000000..fdbfc97 --- /dev/null +++ b/parser/testdata/corpus/sql/collate/test_collate_between.test @@ -0,0 +1,33 @@ +# source: test/sql/collate/test_collate_between.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +CREATE TABLE collate_test(s VARCHAR, t VARCHAR) +-- +ok +== +INSERT INTO collate_test VALUES ('mark', 'muhleisen') +-- +ok +== +SELECT COUNT(*) FROM collate_test WHERE 'mórritz' BETWEEN s AND t +-- +ok +== +SELECT COUNT(*) FROM collate_test WHERE 'mórritz' COLLATE NOACCENT BETWEEN s AND t +-- +ok +== +SELECT COUNT(*) FROM collate_test WHERE 'mórritz' BETWEEN (s COLLATE NOACCENT) AND t +-- +ok +== +SELECT COUNT(*) FROM collate_test WHERE 'mórritz' BETWEEN s AND (t COLLATE NOACCENT) +-- +ok +== +PRAGMA default_collation='NOACCENT' +-- +ok +== diff --git a/parser/testdata/corpus/sql/collate/test_collate_case_insensitive.test b/parser/testdata/corpus/sql/collate/test_collate_case_insensitive.test new file mode 100644 index 0000000..5e324e9 --- /dev/null +++ b/parser/testdata/corpus/sql/collate/test_collate_case_insensitive.test @@ -0,0 +1,41 @@ +# source: test/sql/collate/test_collate_case_insensitive.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +CREATE TABLE collate_test(s VARCHAR COLLATE NOCASE) +-- +ok +== +INSERT INTO collate_test VALUES ('hello'), ('WoRlD'), ('world'), ('Mühleisen') +-- +ok +== +SELECT * FROM collate_test WHERE s='HeLlo' +-- +ok +== +SELECT * FROM collate_test WHERE s='MÜhleisen' +-- +ok +== +SELECT * FROM collate_test WHERE s='world' +-- +ok +== +INSERT INTO collate_join_table VALUES ('HeLlO', 1), ('mÜHLEISEN', 3) +-- +ok +== +SELECT collate_test.s, collate_join_table.s, i FROM collate_test JOIN collate_join_table ON (collate_test.s=collate_join_table.s) ORDER BY i +-- +ok +== +INSERT INTO collate_test VALUES ('Hallo'), ('ham'), ('HELLO'), ('hElp') +-- +ok +== +INSERT INTO collate_test VALUES ('Hallo'), ('hallo') +-- +ok +== diff --git a/parser/testdata/corpus/sql/collate/test_collate_expression.test b/parser/testdata/corpus/sql/collate/test_collate_expression.test new file mode 100644 index 0000000..049c22d --- /dev/null +++ b/parser/testdata/corpus/sql/collate/test_collate_expression.test @@ -0,0 +1,49 @@ +# source: test/sql/collate/test_collate_expression.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +CREATE TABLE collate_test(s VARCHAR) +-- +ok +== +INSERT INTO collate_test VALUES ('hEllO'), ('WöRlD'), ('wozld') +-- +ok +== +SELECT 'hëllo' COLLATE NOACCENT='hello' +-- +ok +== +SELECT 'hëllo' COLLATE POSIX='hello' +-- +ok +== +SELECT 'hëllo' COLLATE C='hello' +-- +ok +== +SELECT * FROM collate_test WHERE s='hello' +-- +ok +== +SELECT * FROM collate_test WHERE s='hello' COLLATE NOCASE +-- +ok +== +SELECT * FROM collate_test WHERE s COLLATE NOCASE='hello' +-- +ok +== +SELECT * FROM collate_test WHERE s COLLATE NOCASE='hello' COLLATE NOACCENT +-- +ok +== +SELECT * FROM collate_test ORDER BY s COLLATE NOCASE +-- +ok +== +SELECT * FROM collate_test ORDER BY s COLLATE NOCASE.NOACCENT +-- +ok +== diff --git a/parser/testdata/corpus/sql/collate/test_collate_list.test b/parser/testdata/corpus/sql/collate/test_collate_list.test new file mode 100644 index 0000000..87b700a --- /dev/null +++ b/parser/testdata/corpus/sql/collate/test_collate_list.test @@ -0,0 +1,13 @@ +# source: test/sql/collate/test_collate_list.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +PRAGMA collations +-- +ok +== +PRAGMA collations=3 +-- +ok +== diff --git a/parser/testdata/corpus/sql/collate/test_collate_list_contains.test b/parser/testdata/corpus/sql/collate/test_collate_list_contains.test new file mode 100644 index 0000000..7bc648e --- /dev/null +++ b/parser/testdata/corpus/sql/collate/test_collate_list_contains.test @@ -0,0 +1,85 @@ +# source: test/sql/collate/test_collate_list_contains.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +SELECT list_contains(['hello', 'world'], 'HELLO' COLLATE NOCASE) +-- +ok +== +SELECT list_contains(['hello', 'world'], 'XYZ' COLLATE NOCASE) +-- +ok +== +SELECT list_position(['hello', 'world'], 'WORLD' COLLATE NOCASE) +-- +ok +== +SELECT list_position(['hello', 'world'], 'XYZ' COLLATE NOCASE) +-- +ok +== +SELECT contains(['hello', 'world'], 'World' COLLATE NOCASE) +-- +ok +== +SELECT list_contains(['hello', 'world'], 'HELLO') +-- +ok +== +SELECT list_contains(['hello', 'world'], 'hello') +-- +ok +== +SELECT list_contains(['héllo', 'world'], 'HELLO' COLLATE NOACCENT.NOCASE) +-- +ok +== +SELECT list_position([NULL, 'BB'], 'bb' COLLATE NOCASE) +-- +ok +== +SELECT list_contains([NULL, 'BB'], 'bb' COLLATE NOCASE) +-- +ok +== +SELECT list_contains([]::VARCHAR[], 'x' COLLATE NOCASE) +-- +ok +== +SELECT list_contains(NULL::VARCHAR[], 'x' COLLATE NOCASE) +-- +ok +== +CREATE TABLE null_needle(n VARCHAR COLLATE NOCASE); +-- +ok +== +INSERT INTO null_needle VALUES (NULL); +-- +ok +== +SELECT list_position(['a', 'b'], n) FROM null_needle +-- +ok +== +CREATE TABLE t(id INTEGER, l VARCHAR[], needle VARCHAR COLLATE NOCASE); +-- +ok +== +INSERT INTO t VALUES (1, ['Apple', 'Banana'], 'banana'), (2, ['Cherry', 'date'], 'DATE'), (3, ['Egg'], 'fig'); +-- +ok +== +SELECT id, list_contains(l, needle), list_position(l, needle) FROM t ORDER BY id +-- +ok +== +SELECT list_contains([needle], 'BANANA'), list_position([needle], 'BANANA') FROM t WHERE id = 1 +-- +ok +== +SELECT list_contains([1, 2, 3], 2) +-- +ok +== diff --git a/parser/testdata/corpus/sql/collate/test_collate_null_constant.test b/parser/testdata/corpus/sql/collate/test_collate_null_constant.test new file mode 100644 index 0000000..56fbd69 --- /dev/null +++ b/parser/testdata/corpus/sql/collate/test_collate_null_constant.test @@ -0,0 +1,109 @@ +# source: test/sql/collate/test_collate_null_constant.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +SELECT AGE(NULL, NULL) GROUP BY AGE(NULL, NULL); +-- +ok +== +SELECT AGE(DATE '2024-01-01', NULL::TIMESTAMP) GROUP BY AGE(DATE '2024-01-01', NULL::TIMESTAMP); +-- +ok +== +SELECT NULL::{type} GROUP BY NULL::{type}; +-- +error: Parser Error: syntax error at or near "{" +== +SET default_collation='nocase' +-- +ok +== +SELECT NULL::VARCHAR GROUP BY NULL::VARCHAR; +-- +ok +== +SELECT NULL::VARCHAR[] GROUP BY NULL::VARCHAR[]; +-- +ok +== +SELECT NULL::VARCHAR[2] GROUP BY NULL::VARCHAR[2]; +-- +ok +== +SELECT NULL::VARCHAR COLLATE nocase; +-- +ok +== +SELECT min(NULL::VARCHAR); +-- +ok +== +SELECT arg_min(1, NULL::VARCHAR); +-- +ok +== +RESET default_collation +-- +ok +== +SELECT DISTINCT NULL::INTERVAL; +-- +ok +== +SELECT 1 ORDER BY NULL::INTERVAL; +-- +ok +== +SELECT row_number() OVER (PARTITION BY NULL::INTERVAL ORDER BY NULL::INTERVAL); +-- +ok +== +SELECT string_agg(s, ',' ORDER BY NULL::INTERVAL) FROM (SELECT 'a' s) t; +-- +ok +== +SELECT NULL::INTERVAL = NULL::INTERVAL; +-- +ok +== +SELECT NULL::INTERVAL BETWEEN NULL::INTERVAL AND NULL::INTERVAL; +-- +ok +== +SELECT NULL::INTERVAL IN (NULL::INTERVAL, INTERVAL 1 DAY); +-- +ok +== +SELECT NULL::INTERVAL IN (SELECT INTERVAL 1 DAY); +-- +ok +== +SELECT NULL::INTERVAL = ANY (SELECT INTERVAL 1 DAY); +-- +ok +== +SELECT (SELECT 1 WHERE t.i = NULL::INTERVAL) FROM (SELECT INTERVAL 1 DAY i) t; +-- +ok +== +SELECT NULL::INTERVAL UNION SELECT NULL::INTERVAL; +-- +ok +== +SELECT NULL::INTERVAL EXCEPT SELECT NULL::INTERVAL; +-- +ok +== +SELECT max(NULL::BIT); +-- +ok +== +SELECT AGE(TIMESTAMP '2014-04-25', TIMESTAMP '2014-04-17') GROUP BY AGE(TIMESTAMP '2014-04-25', TIMESTAMP '2014-04-17'); +-- +ok +== +SELECT i, count(*) FROM (VALUES (INTERVAL '30' DAY), (INTERVAL '1' MONTH), (INTERVAL '720' HOUR)) t(i) GROUP BY i; +-- +ok +== diff --git a/parser/testdata/corpus/sql/collate/test_collate_orderby_column_number.test b/parser/testdata/corpus/sql/collate/test_collate_orderby_column_number.test new file mode 100644 index 0000000..0fca129 --- /dev/null +++ b/parser/testdata/corpus/sql/collate/test_collate_orderby_column_number.test @@ -0,0 +1,81 @@ +# source: test/sql/collate/test_collate_orderby_column_number.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +SELECT 'a' AS c1 ORDER BY 1 COLLATE NOCASE; +-- +ok +== +SELECT 'a' ORDER BY 1 COLLATE NOCASE; +-- +ok +== +SELECT 'A', 'B' ORDER BY 2 COLLATE NOCASE; +-- +ok +== +SELECT 999::VARCHAR ORDER BY 1 COLLATE NOCASE; +-- +ok +== +SELECT 999 FROM ORDER BY 1 COLLATE NOCASE; +-- +error: Parser Error: syntax error at or near "ORDER" +== +SELECT 'a' FROM ORDER BY -1 COLLATE NOCASE; +-- +error: Parser Error: syntax error at or near "ORDER" +== +SELECT 'a' FROM ORDER BY 0 COLLATE NOCASE; +-- +error: Parser Error: syntax error at or near "ORDER" +== +SELECT 'a' FROM ORDER BY -0 COLLATE NOCASE; +-- +error: Parser Error: syntax error at or near "ORDER" +== +CREATE TABLE collate_test(s VARCHAR); +-- +ok +== +INSERT INTO collate_test VALUES ('ã'),('B'),('a'),('A'); +-- +ok +== +SELECT s FROM collate_test ORDER BY 1 COLLATE NOCASE; +-- +ok +== +SELECT s FROM collate_test ORDER BY s COLLATE NOCASE; +-- +ok +== +SELECT CONCAT(s, s) FROM collate_test ORDER BY 1 COLLATE NOCASE; +-- +ok +== +SELECT CONCAT(s, s) AS concat, concat FROM collate_test ORDER BY 2 COLLATE NOCASE; +-- +ok +== +SELECT collate_test.s FROM collate_test ORDER BY 1 COLLATE NOCASE; +-- +ok +== +SELECT CASE WHEN s[1]='a' THEN s ELSE NULL END FROM collate_test ORDER BY 1 COLLATE NOCASE; +-- +ok +== +SELECT (SELECT s) FROM collate_test ORDER BY 1 COLLATE NOCASE; +-- +ok +== +SELECT (SELECT s) AS c1 FROM collate_test ORDER BY c11 COLLATE NOCASE; +-- +ok +== +SELECT concat('a', (SELECT s)) FROM collate_test ORDER BY 1 COLLATE NOCASE; +-- +ok +== diff --git a/parser/testdata/corpus/sql/collate/test_collate_pivot.test b/parser/testdata/corpus/sql/collate/test_collate_pivot.test new file mode 100644 index 0000000..79fe4da --- /dev/null +++ b/parser/testdata/corpus/sql/collate/test_collate_pivot.test @@ -0,0 +1,71 @@ +# source: test/sql/collate/test_collate_pivot.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +PRAGMA default_collation=NOACCENT; +-- +ok +== +CREATE TABLE Cities ( + Country VARCHAR, Name VARCHAR, Year INTEGER, Population INTEGER +); +-- +ok +== +INSERT INTO Cities VALUES ('NL', 'Amsterdam', 2010, 1005); +-- +ok +== +INSERT INTO Cities VALUES ('NL', 'Amsterdam', 2011, 1065); +-- +ok +== +INSERT INTO Cities VALUES ('NL', 'Amsterdam', 2012, 1158); +-- +ok +== +INSERT INTO Cities VALUES ('US', 'Seattle', 2013, 564); +-- +ok +== +INSERT INTO Cities VALUES ('US', 'Seattle', 2014, 608); +-- +ok +== +INSERT INTO Cities VALUES ('US', 'Seattle', 2015, 738); +-- +ok +== +INSERT INTO Cities VALUES ('US', 'New York City', 2016, 8015); +-- +ok +== +INSERT INTO Cities VALUES ('US', 'New York City', 2017, 8175); +-- +ok +== +INSERT INTO Cities VALUES ('US', 'New York City', 2018, 8772); +-- +ok +== +INSERT INTO Cities VALUES ('US', 'New York City', 2019, 8772); +-- +ok +== +INSERT INTO Cities VALUES ('US', 'New York City', 2020, 8772); +-- +ok +== +SET pivot_filter_threshold=99 +-- +ok +== +PIVOT Cities ON Year USING sum(Population); +-- +ok +== +SET pivot_filter_threshold=0 +-- +ok +== diff --git a/parser/testdata/corpus/sql/collate/test_collation_propagation.test b/parser/testdata/corpus/sql/collate/test_collation_propagation.test new file mode 100644 index 0000000..9520ad0 --- /dev/null +++ b/parser/testdata/corpus/sql/collate/test_collation_propagation.test @@ -0,0 +1,65 @@ +# source: test/sql/collate/test_collation_propagation.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +select a from tbl where contains(b collate nocase, 'O') order by all +-- +ok +== +select concat(a collate noaccent, a) from tbl order by all; +-- +ok +== +select lower(a collate noaccent) from tbl order by all; +-- +ok +== +select upper(a collate noaccent) from tbl order by all; +-- +ok +== +select trim(b collate noaccent, '<>') from tbl order by all +-- +ok +== +select ltrim(b collate noaccent, '<>') from tbl order by all +-- +ok +== +select rtrim(b collate noaccent, '<>') from tbl order by all +-- +ok +== +select repeat(a collate noaccent, 10) from tbl order by all; +-- +ok +== +select left(b collate noaccent, 6) from tbl order by all; +-- +ok +== +select right(b collate noaccent, 6) from tbl order by all; +-- +ok +== +select right(left(b collate noaccent, 6), 1) from tbl order by all; +-- +ok +== +select reverse(a collate noaccent) from tbl order by all; +-- +ok +== +select a from tbl where contains(b collate noaccent, 'o') order by all +-- +ok +== +select a from tbl where contains(b, 'ö' collate noaccent) order by all +-- +ok +== +select a from tbl where starts_with(b collate noaccent, '>>>>>o') order by all +-- +ok +== diff --git a/parser/testdata/corpus/sql/collate/test_combined_collation.test b/parser/testdata/corpus/sql/collate/test_combined_collation.test new file mode 100644 index 0000000..fdd23a0 --- /dev/null +++ b/parser/testdata/corpus/sql/collate/test_combined_collation.test @@ -0,0 +1,17 @@ +# source: test/sql/collate/test_combined_collation.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +CREATE TABLE collate_test(s VARCHAR COLLATE NOACCENT.NOCASE) +-- +ok +== +SELECT * FROM collate_test WHERE s='muhleisen' +-- +ok +== +SELECT * FROM collate_test WHERE s='hEllô' +-- +ok +== diff --git a/parser/testdata/corpus/sql/collate/test_default_collations.test b/parser/testdata/corpus/sql/collate/test_default_collations.test new file mode 100644 index 0000000..aff22fa --- /dev/null +++ b/parser/testdata/corpus/sql/collate/test_default_collations.test @@ -0,0 +1,17 @@ +# source: test/sql/collate/test_default_collations.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +PRAGMA default_collation='NOCASE' +-- +ok +== +SELECT COUNT(*) FROM collate_test WHERE 'BlA'='bLa' +-- +ok +== +PRAGMA default_collation='NOCASE.NOACCENT' +-- +ok +== diff --git a/parser/testdata/corpus/sql/collate/test_icu_collate.test b/parser/testdata/corpus/sql/collate/test_icu_collate.test new file mode 100644 index 0000000..fc8d8b6 --- /dev/null +++ b/parser/testdata/corpus/sql/collate/test_icu_collate.test @@ -0,0 +1,110 @@ +# source: test/sql/collate/test_icu_collate.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +INSERT INTO strings VALUES ('Gabel'), ('Göbel'), ('Goethe'), ('Goldmann'), ('Göthe'), ('Götz'); +-- +ok +== +SELECT * FROM strings ORDER BY s COLLATE de; +-- +ok +== +SELECT * FROM strings WHERE 'Goethe' > s COLLATE de ORDER BY 1 +-- +ok +== +SELECT * FROM strings WHERE 'Goethe' > s ORDER BY 1 +-- +ok +== +SELECT * FROM strings WHERE 'goethe' > s COLLATE de.NOCASE ORDER BY 1 +-- +ok +== +SELECT * FROM strings WHERE 'goethe' > s COLLATE NOCASE.de ORDER BY 1 +-- +ok +== +SELECT * FROM strings WHERE 'goethe' > s COLLATE NOACCENT.de ORDER BY 1 +-- +ok +== +DELETE FROM strings +-- +ok +== +INSERT INTO strings VALUES ('賃貸人側連絡先 (Lessor side contact)'), ('賃借人側連絡先 (Lessee side contact)'), ('解約連絡先 (Termination contacts)'), ('更新連絡先 (Update contact)') +-- +ok +== +SELECT * FROM strings ORDER BY s +-- +ok +== +SELECT * FROM strings ORDER BY s COLLATE ja.NOCASE +-- +ok +== +select icu_sort_key('Ş', 'ro'); +-- +ok +== +SELECT icu_sort_key('goose', 'DUCK_DUCK_ENUM'); +-- +ok +== +select icu_sort_key('æ', 'icu_noaccent'); +-- +ok +== +select icu_sort_key('Æ', 'icu_noaccent'); +-- +ok +== +select chr(2*16*256+1*256+2*16+11) collate da =chr(12*16+5) collate da; +-- +ok +== +select icu_sort_key(chr(2*16*256+1*256+2*16+11),'da')=icu_sort_key(chr(12*16+5),'da'); +-- +ok +== +select chr(2*16*256+1*256+2*16+11) collate da > chr(12*16+5) collate da; +-- +ok +== +select count(*) from (select chr(2*16*256+1*256+2*16+11) union select chr(12*16+5)) as t(s) group by s collate da; +-- +ok +== +select nfc_normalize(chr(2*16*256+1*256+2*16+11))=nfc_normalize(chr(12*16+5)); +-- +ok +== +select count(*) from (select chr(2*16*256+1*256+2*16+11) union select chr(12*16+5)) as t(s) group by s collate nfc; +-- +ok +== +CREATE TABLE t1 (c1 CHAR(10)) +-- +ok +== +INSERT INTO t1 VALUES('z'),('Z'),('a'),('A'),('æ'),('Æ'),('à'),('À'),('á'),('Á'),('â'),('Â'), +('ã'),('Ã'),('ä'),('Ä'),('å'),('Å'),('b'),('B') +-- +ok +== +SELECT GROUP_CONCAT(c1, '') as group_c1 FROM t1 GROUP BY c1 COLLATE "NOCASE.ICU_NOACCENT" ORDER BY group_c1 COLLATE "NOCASE.ICU_NOACCENT" +-- +ok +== +SELECT 'Á' COLLATE "ICU_NOACCENT.NOACCENT" +-- +ok +== +SELECT 'Á' COLLATE "NOACCENT.ICU_NOACCENT" +-- +ok +== diff --git a/parser/testdata/corpus/sql/collate/test_pragma_collations.test b/parser/testdata/corpus/sql/collate/test_pragma_collations.test new file mode 100644 index 0000000..7102c13 --- /dev/null +++ b/parser/testdata/corpus/sql/collate/test_pragma_collations.test @@ -0,0 +1,11 @@ +# source: test/sql/collate/test_pragma_collations.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +from pragma_collations() +where collname like 'n%' +order by all +-- +ok +== diff --git a/parser/testdata/corpus/sql/collate/test_strpos_collate.test b/parser/testdata/corpus/sql/collate/test_strpos_collate.test new file mode 100644 index 0000000..723c693 --- /dev/null +++ b/parser/testdata/corpus/sql/collate/test_strpos_collate.test @@ -0,0 +1,121 @@ +# source: test/sql/collate/test_strpos_collate.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +SELECT strpos('HELLO' COLLATE NOCASE, 'el') +-- +ok +== +SELECT strpos('HELLO' COLLATE NOCASE, 'EL') +-- +ok +== +SELECT strpos('hello' COLLATE NOCASE, 'EL') +-- +ok +== +SELECT strpos('HeLLo' COLLATE NOCASE, 'el') +-- +ok +== +SELECT instr('HELLO' COLLATE NOCASE, 'el') +-- +ok +== +SELECT instr('hello' COLLATE NOCASE, 'EL') +-- +ok +== +SELECT position('el' IN ('HELLO' COLLATE NOCASE)) +-- +ok +== +SELECT position('EL' IN ('hello' COLLATE NOCASE)) +-- +ok +== +SELECT strpos('HELLO' COLLATE NOCASE, '') +-- +ok +== +SELECT strpos('HELLO' COLLATE NOCASE, 'xyz') +-- +ok +== +SELECT strpos('HELLO' COLLATE NOCASE, 'HELLO') +-- +ok +== +SELECT strpos('Hello World' COLLATE NOCASE, 'world') +-- +ok +== +SELECT strpos('HELLO WORLD' COLLATE NOCASE, 'o w') +-- +ok +== +SELECT contains('HELLO' COLLATE NOCASE, 'hEllO') +-- +ok +== +SELECT starts_with('HELLO' COLLATE NOCASE, 'heL') +-- +ok +== +INSERT INTO collate_test VALUES ('Hello World'), ('HELLO WORLD'), ('hElLo WoRlD') +-- +ok +== +SELECT strpos(s COLLATE NOCASE, 'hello') FROM collate_test ORDER BY s +-- +ok +== +SELECT strpos(s COLLATE NOCASE, 'world') FROM collate_test ORDER BY s +-- +ok +== +SELECT strpos('HELLO' COLLATE NOCASE, 'el' COLLATE NOCASE) +-- +ok +== +SELECT strpos('HELLO', 'el') +-- +ok +== +SELECT strpos('HELLO', 'EL') +-- +ok +== +SELECT strpos('' COLLATE NOCASE, '') +-- +ok +== +SELECT strpos('' COLLATE NOCASE, 'a') +-- +ok +== +SELECT strpos('a' COLLATE NOCASE, '') +-- +ok +== +SELECT strpos('HéLLO' COLLATE NOCASE, 'éll') +-- +ok +== +SELECT strpos('HÉLLO' COLLATE NOCASE, 'éll') +-- +ok +== +SELECT strpos('HELLO', 'HELLO') +-- +ok +== +SELECT strpos('HELLO', '') +-- +ok +== +SELECT strpos('HELLO', 'xyz') +-- +ok +== diff --git a/parser/testdata/corpus/sql/collate/test_unsupported_collations.test b/parser/testdata/corpus/sql/collate/test_unsupported_collations.test new file mode 100644 index 0000000..a121805 --- /dev/null +++ b/parser/testdata/corpus/sql/collate/test_unsupported_collations.test @@ -0,0 +1,29 @@ +# source: test/sql/collate/test_unsupported_collations.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +CREATE TABLE collate_test(s VARCHAR COLLATE blabla) +-- +ok +== +CREATE TABLE collate_test(s INTEGER COLLATE blabla) +-- +error: Parser Error: Only VARCHAR columns can have collations! +== +CREATE TABLE collate_test(s VARCHAR COLLATE NOACCENT.NOACCENT) +-- +ok +== +CREATE TABLE collate_test(s VARCHAR COLLATE 1) +-- +error: Parser Error: syntax error at or near "1" +== +CREATE TABLE collate_test(s VARCHAR COLLATE 'hello') +-- +error: Parser Error: syntax error at or near "'hello'" +== +PRAGMA default_collation='blabla' +-- +ok +== diff --git a/parser/testdata/corpus/sql/collate/test_unsupported_collations.test.metadata.json b/parser/testdata/corpus/sql/collate/test_unsupported_collations.test.metadata.json new file mode 100644 index 0000000..a97fb23 --- /dev/null +++ b/parser/testdata/corpus/sql/collate/test_unsupported_collations.test.metadata.json @@ -0,0 +1,5 @@ +{ + "todo": { + "eb15b92628017c19": "transformer-raised parser error: upstream rejects in the transformer, not the grammar; expected to clear as transformers land (milestones 3-5)" + } +} diff --git a/parser/testdata/corpus/sql/conjunction/or_between.test b/parser/testdata/corpus/sql/conjunction/or_between.test new file mode 100644 index 0000000..6d5d3ad --- /dev/null +++ b/parser/testdata/corpus/sql/conjunction/or_between.test @@ -0,0 +1,53 @@ +# source: test/sql/conjunction/or_between.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +CREATE TABLE tab0(pk INTEGER PRIMARY KEY, col0 INTEGER, col1 FLOAT, col2 VARCHAR, col3 INTEGER, col4 FLOAT, col5 VARCHAR); +-- +ok +== +INSERT INTO tab0 VALUES(0,22,43.95999908447265625,'yoyca',0,80.1399993896484375,'eoenc'); +-- +ok +== +INSERT INTO tab0 VALUES(1,51,34.900001525878905361,'zeqhw',44,13.489999771118164062,'easox'); +-- +ok +== +INSERT INTO tab0 VALUES(2,42,59.759998321533203125,'ylshk',15,4.4499998092651367187,'xgrvy'); +-- +ok +== +INSERT INTO tab0 VALUES(3,67,90.660003662109378552,'rnadc',77,50.360000610351560723,'knooo'); +-- +ok +== +INSERT INTO tab0 VALUES(4,48,53.099998474121097302,'txhlv',75,9.770000457763671875,'gvudx'); +-- +ok +== +INSERT INTO tab0 VALUES(5,18,40.580001831054683947,'wgfxz',96,12.5,'mmxbj'); +-- +ok +== +INSERT INTO tab0 VALUES(6,84,24.239999771118165838,'ttodp',31,72.999999999999998223,'wujjl'); +-- +ok +== +INSERT INTO tab0 VALUES(7,86,67.449996948242185723,'mwgbl',38,10.479999542236329013,'ypcha'); +-- +ok +== +INSERT INTO tab0 VALUES(8,68,38.470001220703125,'kaoqh',8,41.500000000000003552,'fyhzl'); +-- +ok +== +INSERT INTO tab0 VALUES(9,29,19.600000381469726562,'kbenw',20,19.579999923706054687,'gsszq'); +-- +ok +== +SELECT pk FROM tab0 WHERE (col0 BETWEEN 67 AND 0 OR col0 > 17 AND (col0 > 3)); +-- +ok +== diff --git a/parser/testdata/corpus/sql/conjunction/or_comparison.test b/parser/testdata/corpus/sql/conjunction/or_comparison.test new file mode 100644 index 0000000..68ba232 --- /dev/null +++ b/parser/testdata/corpus/sql/conjunction/or_comparison.test @@ -0,0 +1,57 @@ +# source: test/sql/conjunction/or_comparison.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +CREATE TABLE tab0(pk INTEGER PRIMARY KEY, col0 INTEGER, col1 FLOAT, col2 VARCHAR, col3 INTEGER, col4 FLOAT, col5 VARCHAR);; +-- +ok +== +INSERT INTO tab0 VALUES(0,86,94.959999084472652697,'vuopk',91,47.779998779296875,'sikuk'); +-- +ok +== +INSERT INTO tab0 VALUES(1,37,20.850000381469726562,'zfuqj',30,10.689999580383300337,'rtcha'); +-- +ok +== +INSERT INTO tab0 VALUES(2,6,47.540000915527347302,'vubiv',38,46.630001068115234375,'nnuey'); +-- +ok +== +INSERT INTO tab0 VALUES(3,72,30.629999160766603338,'rezor',59,11.189999580383300781,'mdler'); +-- +ok +== +INSERT INTO tab0 VALUES(4,12,29.620000839233400213,'gvmir',68,69.669998168945310723,'yfnxa'); +-- +ok +== +INSERT INTO tab0 VALUES(5,64,21.489999771118162286,'ruygp',31,13.659999847412109819,'fhwkn'); +-- +ok +== +INSERT INTO tab0 VALUES(6,90,9.3699998855590820312,'tehgk',71,65.720001220703121447,'uibwi'); +-- +ok +== +INSERT INTO tab0 VALUES(7,38,43.139999389648435723,'axgch',27,98.949996948242180394,'oikcl'); +-- +ok +== +INSERT INTO tab0 VALUES(8,3,22.399999618530275213,'yigev',19,45.650001525878902697,'tbbkw'); +-- +ok +== +INSERT INTO tab0 VALUES(9,95,14.31999969482421875,'vssyg',8,12.930000305175781605,'epgyr'); +-- +ok +== +SELECT pk FROM tab0 WHERE col0 < 84 OR col0 < 8 ; +-- +ok +== +select pk from tab0 where col0 = 37 or col0 = 86 +-- +ok +== diff --git a/parser/testdata/corpus/sql/connect/concurrent_connect_detach.test b/parser/testdata/corpus/sql/connect/concurrent_connect_detach.test new file mode 100644 index 0000000..935ccda --- /dev/null +++ b/parser/testdata/corpus/sql/connect/concurrent_connect_detach.test @@ -0,0 +1,29 @@ +# source: test/sql/connect/concurrent_connect_detach.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +CALL quack_serve(token='test_token'); +-- +ok +== +ATTACH 'quack:localhost' AS qk (TOKEN 'test_token'); +-- +ok +== +DETACH qk; +-- +ok +== +DISCONNECT; +-- +ok +== +CONNECT qk; +-- +ok +== +SELECT 42; +-- +ok +== diff --git a/parser/testdata/corpus/sql/connect/connect_quack.test b/parser/testdata/corpus/sql/connect/connect_quack.test new file mode 100644 index 0000000..bc4b6b0 --- /dev/null +++ b/parser/testdata/corpus/sql/connect/connect_quack.test @@ -0,0 +1,45 @@ +# source: test/sql/connect/connect_quack.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +SELECT range AS x, range * 2 AS y FROM range(3); +-- +ok +== +SELECT 1 + 1; +-- +ok +== +SELECT 'hello'::VARCHAR; +-- +ok +== +SET VARIABLE my_var = 42; +-- +ok +== +SELECT getvariable('my_var'); +-- +ok +== +SET VARIABLE v = 7; +-- +ok +== +SELECT getvariable('v'); +-- +ok +== +CONNECT 'quack:localhost' (TOKEN 'test_token'); +-- +ok +== +SELECT count(*) FROM pragma_database_list WHERE name LIKE '__connect%'; +-- +ok +== +CONNECT 'quack:localhost' (TOKEN 'wrong_token'); +-- +ok +== diff --git a/parser/testdata/corpus/sql/connect/connect_string_ephemeral.test b/parser/testdata/corpus/sql/connect/connect_string_ephemeral.test new file mode 100644 index 0000000..72118b9 --- /dev/null +++ b/parser/testdata/corpus/sql/connect/connect_string_ephemeral.test @@ -0,0 +1,9 @@ +# source: test/sql/connect/connect_string_ephemeral.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +CONNECT ':memory:'; +-- +ok +== diff --git a/parser/testdata/corpus/sql/connect/connect_syntax.test b/parser/testdata/corpus/sql/connect/connect_syntax.test new file mode 100644 index 0000000..1bb3008 --- /dev/null +++ b/parser/testdata/corpus/sql/connect/connect_syntax.test @@ -0,0 +1,29 @@ +# source: test/sql/connect/connect_syntax.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +CONNECT; +-- +ok +== +CONNECT LOCAL; +-- +ok +== +CONNECT my_database; +-- +ok +== +ATTACH ':memory:' AS plain_duckdb; +-- +ok +== +CONNECT plain_duckdb; +-- +ok +== +DETACH plain_duckdb; +-- +ok +== diff --git a/parser/testdata/corpus/sql/constraints/check/check_struct.test b/parser/testdata/corpus/sql/constraints/check/check_struct.test new file mode 100644 index 0000000..d6ef269 --- /dev/null +++ b/parser/testdata/corpus/sql/constraints/check/check_struct.test @@ -0,0 +1,25 @@ +# source: test/sql/constraints/check/check_struct.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +CREATE TABLE tbl(t ROW(t INTEGER) CHECK(t.t=42)); +-- +ok +== +INSERT INTO tbl VALUES ({'t': 43}) +-- +ok +== +INSERT INTO tbl VALUES ({'t': 42}) +-- +ok +== +DROP TABLE tbl; +-- +ok +== +CREATE TABLE tbl(t ROW(t INTEGER) CHECK(tbl.t.t=42)); +-- +ok +== diff --git a/parser/testdata/corpus/sql/constraints/check/test_check.test b/parser/testdata/corpus/sql/constraints/check/test_check.test new file mode 100644 index 0000000..464283e --- /dev/null +++ b/parser/testdata/corpus/sql/constraints/check/test_check.test @@ -0,0 +1,68 @@ +# source: test/sql/constraints/check/test_check.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +CREATE TABLE integers(i INTEGER CHECK(i < 5)) +-- +ok +== +INSERT INTO integers VALUES (3) +-- +ok +== +INSERT INTO integers VALUES (7) +-- +ok +== +INSERT INTO integers VALUES (NULL) +-- +ok +== +CREATE TABLE integers(i INTEGER CHECK(i + j < 10), j INTEGER) +-- +ok +== +INSERT INTO integers VALUES (3, 3) +-- +ok +== +INSERT INTO integers VALUES (5, 5) +-- +ok +== +INSERT INTO integers VALUES (3, 3), (5, 5) +-- +ok +== +CREATE TABLE indirect_subq( + i INTEGER, + CHECK (i > (2 * (SELECT(1)))) +); +-- +error: Parser Error: subqueries prohibited in CHECK constraints +== +CREATE TABLE integers2(i INTEGER CHECK(i > (SELECT 42)), j INTEGER) +-- +error: Parser Error: subqueries prohibited in CHECK constraints +== +CREATE TABLE integers2(i INTEGER CHECK(i > SUM(j)), j INTEGER) +-- +ok +== +CREATE TABLE integers3(i INTEGER CHECK(k < 10), j INTEGER) +-- +ok +== +CREATE TABLE integers3(i INTEGER CHECK(integers3.k < 10), j INTEGER) +-- +ok +== +CREATE TABLE integers3(i INTEGER CHECK(integers2.i < 10), j INTEGER) +-- +ok +== +CREATE TABLE integers4(i INTEGER CHECK(integers4.i < 10), j INTEGER) +-- +ok +== diff --git a/parser/testdata/corpus/sql/constraints/check/test_check.test.metadata.json b/parser/testdata/corpus/sql/constraints/check/test_check.test.metadata.json new file mode 100644 index 0000000..554998d --- /dev/null +++ b/parser/testdata/corpus/sql/constraints/check/test_check.test.metadata.json @@ -0,0 +1,6 @@ +{ + "todo": { + "62968f60bd8a6ea6": "transformer-raised parser error: upstream rejects in the transformer, not the grammar; expected to clear as transformers land (milestones 3-5)", + "a81fe167c4d02b92": "transformer-raised parser error: upstream rejects in the transformer, not the grammar; expected to clear as transformers land (milestones 3-5)" + } +} diff --git a/parser/testdata/corpus/sql/constraints/check/test_update_check_non_updated_columns.test b/parser/testdata/corpus/sql/constraints/check/test_update_check_non_updated_columns.test new file mode 100644 index 0000000..0987f95 --- /dev/null +++ b/parser/testdata/corpus/sql/constraints/check/test_update_check_non_updated_columns.test @@ -0,0 +1,129 @@ +# source: test/sql/constraints/check/test_update_check_non_updated_columns.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +CREATE TABLE v0 ( + v3 INTEGER, + v2 INTEGER, + v4 INTEGER, + v1 INTEGER, + CHECK ( ( ( NOT (v2 = v1) = v3 - 0 ) > (18 = 10) ) ), + CHECK ( v3 = v4 ) +); +-- +ok +== +INSERT INTO v0 (v4) VALUES (2), (1); +-- +ok +== +UPDATE v0 SET v4 = 44; +-- +ok +== +SELECT COUNT(*), MIN(v4) FROM v0; +-- +ok +== +CREATE TABLE v1 ( + a INTEGER, + b INTEGER, + c INTEGER, + CHECK (a = b), + CHECK (b = c) +); +-- +ok +== +INSERT INTO v1 VALUES (1, 1, 1); +-- +ok +== +UPDATE v1 SET c = 2; +-- +ok +== +SELECT a, b, c FROM v1; +-- +ok +== +CREATE TABLE v2 ( + x INTEGER, + y INTEGER, + z INTEGER, + CHECK (x + y = z) +); +-- +ok +== +INSERT INTO v2 VALUES (1, 2, 3); +-- +ok +== +INSERT INTO v2 VALUES (2, 3, 5); +-- +ok +== +UPDATE v2 SET z = 7 WHERE x = 2; +-- +ok +== +SELECT x, y, z FROM v2 ORDER BY x; +-- +ok +== +CREATE TABLE v3 ( + id INTEGER, + payload INTEGER, + flag BOOLEAN, + CHECK (flag IS NOT NULL) +); +-- +ok +== +INSERT INTO v3 VALUES (1, 42, TRUE); +-- +ok +== +UPDATE v3 SET payload = 99; +-- +ok +== +SELECT id, payload, flag FROM v3; +-- +ok +== +CREATE TABLE v_char ( + username VARCHAR, + status VARCHAR, + CHECK (length(username) >= 3), + CHECK (status IN ('active', 'inactive')) +); +-- +ok +== +INSERT INTO v_char VALUES ('alice', 'active'); +-- +ok +== +INSERT INTO v_char VALUES ('ab', 'active'); +-- +ok +== +INSERT INTO v_char VALUES ('charlie', 'pending'); +-- +ok +== +UPDATE v_char SET status = 'deleted' WHERE username = 'alice'; +-- +ok +== +UPDATE v_char SET status = 'inactive' WHERE username = 'alice'; +-- +ok +== +SELECT username, status FROM v_char; +-- +ok +== diff --git a/parser/testdata/corpus/sql/constraints/foreignkey/fk_19469.test b/parser/testdata/corpus/sql/constraints/foreignkey/fk_19469.test new file mode 100644 index 0000000..2f90691 --- /dev/null +++ b/parser/testdata/corpus/sql/constraints/foreignkey/fk_19469.test @@ -0,0 +1,115 @@ +# source: test/sql/constraints/foreignkey/fk_19469.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +CREATE TABLE B (b1 INTEGER, +b2 INTEGER, +PRIMARY KEY(b1, b2)); +-- +ok +== +CREATE TABLE A (a1 VARCHAR(1), +a2 VARCHAR(1), +a3 VARCHAR(1), +a4 VARCHAR(1), +a5 INTEGER, +a6 INTEGER, +PRIMARY KEY(a1, a2), +UNIQUE(a3, a4), +FOREIGN KEY (a5, a6) REFERENCES B(b1, b2)); +-- +ok +== +INSERT INTO B (b1, b2) VALUES +(1, 2), +(2, 3), +(6, 7); +-- +ok +== +INSERT INTO A (a1, a2, a3, a4, a5, a6) VALUES +('x', 'y', 'z', 'u', 1, 2), +('y', 'z', 'x', 'v', 1, 2), +('x', 'x', 'y', 'y', 2, 3), +('z', 'z', 'v', 'x', 4, 5); +-- +ok +== +CREATE TABLE C ( + c1 INTEGER, + c2 INTEGER, + c3 VARCHAR(1), + c4 VARCHAR(1), + PRIMARY KEY (c1, c2), + UNIQUE (c3, c4) +); +-- +ok +== +CREATE TABLE D ( + d1 INTEGER, + d2 INTEGER, + d3 VARCHAR(1), + d4 VARCHAR(1), + payload INTEGER, + FOREIGN KEY (d1, d2) REFERENCES C (c1, c2), + FOREIGN KEY (d3, d4) REFERENCES C (c3, c4) +); +-- +ok +== +INSERT INTO C VALUES +(0, 1, 'a', 'b'), +(1, 0, 'a', 'c'), +(2, 2, 'd', 'e'); +-- +ok +== +INSERT INTO D VALUES +(0, 1, 'a', 'b', 10), +(1, 0, 'a', 'c', 20), +(2, 2, 'd', 'e', 30); +-- +ok +== +INSERT INTO D VALUES +(9, 9, 'a', 'b', 40); +-- +ok +== +INSERT INTO D VALUES +(0, 1, 'x', 'y', 50); +-- +ok +== +CREATE TABLE fk_19990_reference ( + reference_id BIGINT PRIMARY KEY +); +-- +ok +== +INSERT INTO fk_19990_reference VALUES (1), (2); +-- +ok +== +CREATE TABLE fk_19990_data ( + data_id INTEGER PRIMARY KEY, + reference_id BIGINT, + FOREIGN KEY (reference_id) REFERENCES fk_19990_reference (reference_id) +); +-- +ok +== +CREATE TABLE fk_19990_temp_data AS + SELECT * + FROM (VALUES (1, 1), (2, 3)) AS t(data_id, reference_id); +-- +ok +== +INSERT INTO fk_19990_data BY NAME + SELECT * + FROM fk_19990_temp_data; +-- +ok +== diff --git a/parser/testdata/corpus/sql/constraints/foreignkey/fk_20530.test b/parser/testdata/corpus/sql/constraints/foreignkey/fk_20530.test new file mode 100644 index 0000000..0910d4d --- /dev/null +++ b/parser/testdata/corpus/sql/constraints/foreignkey/fk_20530.test @@ -0,0 +1,65 @@ +# source: test/sql/constraints/foreignkey/fk_20530.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +CREATE SCHEMA freddy; +-- +ok +== +SET schema = freddy; +-- +ok +== +CREATE TABLE zippy( + id INTEGER PRIMARY KEY +); +-- +ok +== +CREATE TABLE george( + zippy_id INTEGER, + FOREIGN KEY (zippy_id) REFERENCES zippy(id) +); +-- +ok +== +INSERT INTO zippy VALUES (1); +-- +ok +== +INSERT INTO george VALUES (1); +-- +ok +== +SELECT constraint_text +FROM duckdb_constraints() +WHERE table_name = 'george' + AND constraint_type = 'FOREIGN KEY'; +-- +ok +== +SET schema = main; +-- +ok +== +CREATE TABLE zippy_main( + id INTEGER PRIMARY KEY +); +-- +ok +== +CREATE TABLE george_main( + zippy_id INTEGER, + FOREIGN KEY (zippy_id) REFERENCES zippy_main(id) +); +-- +ok +== +SELECT constraint_text +FROM duckdb_constraints() +WHERE table_name = 'george_main' + AND constraint_type = 'FOREIGN KEY'; +-- +ok +== diff --git a/parser/testdata/corpus/sql/constraints/foreignkey/fk_4309.test b/parser/testdata/corpus/sql/constraints/foreignkey/fk_4309.test new file mode 100644 index 0000000..e62897e --- /dev/null +++ b/parser/testdata/corpus/sql/constraints/foreignkey/fk_4309.test @@ -0,0 +1,83 @@ +# source: test/sql/constraints/foreignkey/fk_4309.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +CREATE TABLE tf_1 ( + a integer, b integer, c integer, + PRIMARY KEY (a), + UNIQUE (b), + UNIQUE (c) +); +-- +ok +== +CREATE TABLE tf_2 ( + d integer, e integer, f integer, + FOREIGN KEY (d) REFERENCES tf_1 (a), + FOREIGN KEY (e) REFERENCES tf_1 (b), + FOREIGN KEY (f) REFERENCES tf_1 (c) +); +-- +ok +== +INSERT INTO tf_2 VALUES (1, 1, 1); +-- +ok +== +INSERT INTO tf_1 VALUES (1, 1, 1); +-- +ok +== +INSERT INTO tf_2 VALUES (2, 1, 1); +-- +ok +== +INSERT INTO tf_2 VALUES (1, 2, 1); +-- +ok +== +INSERT INTO tf_2 VALUES (1, 1, 2); +-- +ok +== +INSERT INTO tf_1 VALUES (2, NULL, NULL); +-- +ok +== +INSERT INTO tf_2 VALUES (2, NULL, NULL); +-- +ok +== +DELETE FROM tf_1 WHERE a = 2; +-- +ok +== +DELETE FROM tf_2 WHERE d=2; +-- +ok +== +DELETE FROM tf_1 WHERE a=2; +-- +ok +== +INSERT INTO tf_1 VALUES (2, 3, NULL); +-- +ok +== +INSERT INTO tf_2 VALUES (1, 3, 1); +-- +ok +== +DELETE FROM tf_2 WHERE d=2 OR e=3; +-- +ok +== +INSERT INTO tf_1 VALUES (2, NULL, 4); +-- +ok +== +INSERT INTO tf_2 VALUES (1, 1, 4); +-- +ok +== diff --git a/parser/testdata/corpus/sql/constraints/foreignkey/fk_4365.test b/parser/testdata/corpus/sql/constraints/foreignkey/fk_4365.test new file mode 100644 index 0000000..fac4499 --- /dev/null +++ b/parser/testdata/corpus/sql/constraints/foreignkey/fk_4365.test @@ -0,0 +1,17 @@ +# source: test/sql/constraints/foreignkey/fk_4365.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +create table x (c1 integer, primary key (c1)); +-- +ok +== +create table y (c1 integer, foreign key (c1) references x (c1)); +-- +ok +== +select count(*) from duckdb_constraints() where constraint_type = 'NOT NULL'; +-- +ok +== diff --git a/parser/testdata/corpus/sql/constraints/foreignkey/fk_case_insensitivity.test b/parser/testdata/corpus/sql/constraints/foreignkey/fk_case_insensitivity.test new file mode 100644 index 0000000..1c6294e --- /dev/null +++ b/parser/testdata/corpus/sql/constraints/foreignkey/fk_case_insensitivity.test @@ -0,0 +1,33 @@ +# source: test/sql/constraints/foreignkey/fk_case_insensitivity.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +create table a (a int not null, constraint pk_a primary key (A)); +-- +ok +== +create table b (a int references a (a)); +-- +ok +== +drop table b; +-- +ok +== +drop table a; +-- +ok +== +create table a (i int primary key); +-- +ok +== +create table b (i int references A (i)); +-- +ok +== +create table c (i int primary key, j int references C (i)); +-- +ok +== diff --git a/parser/testdata/corpus/sql/constraints/foreignkey/fk_implicit_primary_key.test b/parser/testdata/corpus/sql/constraints/foreignkey/fk_implicit_primary_key.test new file mode 100644 index 0000000..d97f85f --- /dev/null +++ b/parser/testdata/corpus/sql/constraints/foreignkey/fk_implicit_primary_key.test @@ -0,0 +1,29 @@ +# source: test/sql/constraints/foreignkey/fk_implicit_primary_key.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +create table b (i int references a); +-- +ok +== +insert into b values (1) +-- +ok +== +insert into a values (1); +-- +ok +== +create table a (i int); +-- +ok +== +drop table a +-- +ok +== +create table a (i int, j int, primary key(i,j)); +-- +ok +== diff --git a/parser/testdata/corpus/sql/constraints/foreignkey/foreign_key_matching_columns.test b/parser/testdata/corpus/sql/constraints/foreignkey/foreign_key_matching_columns.test new file mode 100644 index 0000000..5dba587 --- /dev/null +++ b/parser/testdata/corpus/sql/constraints/foreignkey/foreign_key_matching_columns.test @@ -0,0 +1,80 @@ +# source: test/sql/constraints/foreignkey/foreign_key_matching_columns.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +CREATE TABLE routes ( + route_id TEXT PRIMARY KEY, + agency_id TEXT, + FOREIGN KEY (agency_id) REFERENCES agency +); +-- +ok +== +CREATE TABLE agency ( + agency_id TEXT PRIMARY KEY, + agency_name TEXT UNIQUE NOT NULL +); +-- +ok +== +CREATE TABLE routes ( + route_id TEXT PRIMARY KEY, + agency_id TEXT, + FOREIGN KEY (route_id, agency_id) REFERENCES agency +); +-- +ok +== +INSERT INTO routes VALUES (1, 1); +-- +ok +== +INSERT INTO agency VALUES (1, 1); +-- +ok +== +DROP TABLE agency; +-- +ok +== +DROP TABLE routes; +-- +ok +== +CREATE TABLE agency ( + agency_id TEXT, + agency_name TEXT NOT NULL +); +-- +ok +== +CREATE TABLE routes ( + route_id TEXT PRIMARY KEY, + agency_id TEXT, + FOREIGN KEY (agency_id) REFERENCES routes +); +-- +ok +== +INSERT INTO routes VALUES (1, NULL); +-- +ok +== +INSERT INTO routes VALUES (2, 2); +-- +ok +== +INSERT INTO routes VALUES (2, 1); +-- +ok +== +CREATE TABLE agency ( + agency_id TEXT, + agency_id_2 TEXT, + agency_name TEXT NOT NULL, + PRIMARY KEY (agency_id, agency_id_2) +); +-- +ok +== diff --git a/parser/testdata/corpus/sql/constraints/foreignkey/test_action.test b/parser/testdata/corpus/sql/constraints/foreignkey/test_action.test new file mode 100644 index 0000000..657c4a6 --- /dev/null +++ b/parser/testdata/corpus/sql/constraints/foreignkey/test_action.test @@ -0,0 +1,53 @@ +# source: test/sql/constraints/foreignkey/test_action.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +CREATE TABLE t1(id INTEGER PRIMARY KEY); +-- +ok +== +CREATE TABLE t2(id INTEGER PRIMARY KEY, t1_id INTEGER, FOREIGN KEY (t1_id) REFERENCES t1(id)); +-- +ok +== +CREATE TABLE t3(id INTEGER PRIMARY KEY, t1_id INTEGER, FOREIGN KEY (t1_id) REFERENCES t1(id) ON UPDATE NO ACTION); +-- +ok +== +CREATE TABLE t4(id INTEGER PRIMARY KEY, t1_id INTEGER, FOREIGN KEY (t1_id) REFERENCES t1(id) ON DELETE NO ACTION); +-- +ok +== +CREATE TABLE t5(id INTEGER PRIMARY KEY, t1_id INTEGER, FOREIGN KEY (t1_id) REFERENCES t1(id) ON UPDATE RESTRICT); +-- +ok +== +CREATE TABLE t6(id INTEGER PRIMARY KEY, t1_id INTEGER, FOREIGN KEY (t1_id) REFERENCES t1(id) ON DELETE RESTRICT); +-- +ok +== +CREATE TABLE t7(id INTEGER PRIMARY KEY, t1_id INTEGER, FOREIGN KEY (t1_id) REFERENCES t1(id) ON UPDATE CASCADE); +-- +error: Parser Error: FOREIGN KEY constraints cannot use CASCADE, SET NULL or SET DEFAULT +== +CREATE TABLE t8(id INTEGER PRIMARY KEY, t1_id INTEGER, FOREIGN KEY (t1_id) REFERENCES t1(id) ON DELETE CASCADE); +-- +error: Parser Error: FOREIGN KEY constraints cannot use CASCADE, SET NULL or SET DEFAULT +== +CREATE TABLE t9(id INTEGER PRIMARY KEY, t1_id INTEGER, FOREIGN KEY (t1_id) REFERENCES t1(id) ON UPDATE SET DEFAULT); +-- +error: Parser Error: FOREIGN KEY constraints cannot use CASCADE, SET NULL or SET DEFAULT +== +CREATE TABLE t10(id INTEGER PRIMARY KEY, t1_id INTEGER, FOREIGN KEY (t1_id) REFERENCES t1(id) ON DELETE SET DEFAULT); +-- +error: Parser Error: FOREIGN KEY constraints cannot use CASCADE, SET NULL or SET DEFAULT +== +CREATE TABLE t11(id INTEGER PRIMARY KEY, t1_id INTEGER, FOREIGN KEY (t1_id) REFERENCES t1(id) ON UPDATE SET NULL); +-- +error: Parser Error: FOREIGN KEY constraints cannot use CASCADE, SET NULL or SET DEFAULT +== +CREATE TABLE t12(id INTEGER PRIMARY KEY, t1_id INTEGER, FOREIGN KEY (t1_id) REFERENCES t1(id) ON DELETE SET NULL); +-- +error: Parser Error: FOREIGN KEY constraints cannot use CASCADE, SET NULL or SET DEFAULT +== diff --git a/parser/testdata/corpus/sql/constraints/foreignkey/test_action.test.metadata.json b/parser/testdata/corpus/sql/constraints/foreignkey/test_action.test.metadata.json new file mode 100644 index 0000000..b1c0fcb --- /dev/null +++ b/parser/testdata/corpus/sql/constraints/foreignkey/test_action.test.metadata.json @@ -0,0 +1,10 @@ +{ + "todo": { + "5a5620b9f1876141": "transformer-raised parser error: upstream rejects in the transformer, not the grammar; expected to clear as transformers land (milestones 3-5)", + "798f960dc772a64a": "transformer-raised parser error: upstream rejects in the transformer, not the grammar; expected to clear as transformers land (milestones 3-5)", + "81ee07e70de6c75c": "transformer-raised parser error: upstream rejects in the transformer, not the grammar; expected to clear as transformers land (milestones 3-5)", + "b5391f27b3d830bf": "transformer-raised parser error: upstream rejects in the transformer, not the grammar; expected to clear as transformers land (milestones 3-5)", + "c48915e973daf228": "transformer-raised parser error: upstream rejects in the transformer, not the grammar; expected to clear as transformers land (milestones 3-5)", + "cccd1b3b0fc27fa4": "transformer-raised parser error: upstream rejects in the transformer, not the grammar; expected to clear as transformers land (milestones 3-5)" + } +} diff --git a/parser/testdata/corpus/sql/constraints/foreignkey/test_fk_alter.test b/parser/testdata/corpus/sql/constraints/foreignkey/test_fk_alter.test new file mode 100644 index 0000000..aea2c3f --- /dev/null +++ b/parser/testdata/corpus/sql/constraints/foreignkey/test_fk_alter.test @@ -0,0 +1,32 @@ +# source: test/sql/constraints/foreignkey/test_fk_alter.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +CREATE TABLE departments ( + department_id INTEGER PRIMARY KEY, + department_name VARCHAR(100) NOT NULL +); +-- +ok +== +CREATE TABLE employees ( + employee_id INTEGER PRIMARY KEY, + employee_name VARCHAR(100) NOT NULL, + department_id INT REFERENCES departments(department_id) +); +-- +ok +== +drop table departments +-- +ok +== +ALTER TABLE departments RENAME TO old_departments +-- +ok +== +ALTER TABLE employees RENAME TO old_employees +-- +ok +== diff --git a/parser/testdata/corpus/sql/constraints/foreignkey/test_fk_chain.test b/parser/testdata/corpus/sql/constraints/foreignkey/test_fk_chain.test new file mode 100644 index 0000000..405064b --- /dev/null +++ b/parser/testdata/corpus/sql/constraints/foreignkey/test_fk_chain.test @@ -0,0 +1,89 @@ +# source: test/sql/constraints/foreignkey/test_fk_chain.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +CREATE TABLE t1(i1 INTEGER UNIQUE) +-- +ok +== +INSERT INTO t1 VALUES (1), (2), (3), (4) +-- +ok +== +CREATE TABLE t2(i2 INTEGER PRIMARY KEY, FOREIGN KEY (i2) REFERENCES t1(i1)) +-- +ok +== +INSERT INTO t2 VALUES (1), (2), (3) +-- +ok +== +CREATE TABLE t3(i3 INTEGER UNIQUE, FOREIGN KEY (i3) REFERENCES t2(i2)) +-- +ok +== +INSERT INTO t3 VALUES (1), (2) +-- +ok +== +CREATE TABLE t4(i4 INTEGER, FOREIGN KEY (i4) REFERENCES t3(i3)) +-- +ok +== +INSERT INTO t4 VALUES (1) +-- +ok +== +INSERT INTO t2 VALUES (5) +-- +ok +== +INSERT INTO t3 VALUES (4) +-- +ok +== +INSERT INTO t4 VALUES (3) +-- +ok +== +INSERT INTO t2 VALUES (4) +-- +ok +== +INSERT INTO t3 VALUES (3) +-- +ok +== +INSERT INTO t4 VALUES (2) +-- +ok +== +DELETE FROM t1 WHERE i1=4 +-- +ok +== +DELETE FROM t2 WHERE i2=3 +-- +ok +== +DELETE FROM t3 WHERE i3=2 +-- +ok +== +DELETE FROM t2 WHERE i2=4 +-- +ok +== +DELETE FROM t3 WHERE i3=3 +-- +ok +== +DELETE FROM t4 WHERE i4=2 +-- +ok +== +DROP TABLE t4; +-- +ok +== diff --git a/parser/testdata/corpus/sql/constraints/foreignkey/test_fk_concurrency_conflicts.test b/parser/testdata/corpus/sql/constraints/foreignkey/test_fk_concurrency_conflicts.test new file mode 100644 index 0000000..344675e --- /dev/null +++ b/parser/testdata/corpus/sql/constraints/foreignkey/test_fk_concurrency_conflicts.test @@ -0,0 +1,37 @@ +# source: test/sql/constraints/foreignkey/test_fk_concurrency_conflicts.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +CREATE TABLE pk_integers(i INTEGER PRIMARY KEY) +-- +ok +== +INSERT INTO pk_integers VALUES (1), (2), (3) +-- +ok +== +CREATE TABLE fk_integers(j INTEGER, FOREIGN KEY (j) REFERENCES pk_integers(i)) +-- +ok +== +INSERT INTO fk_integers VALUES (1) +-- +ok +== +DROP TABLE fk_integers +-- +ok +== +INSERT INTO fk_integers VALUES (1), (2) +-- +ok +== +INSERT INTO fk_integers VALUES (4), (5) +-- +ok +== +CREATE TABLE fk_integers_another(j INTEGER, FOREIGN KEY (j) REFERENCES pk_integers(i)) +-- +ok +== diff --git a/parser/testdata/corpus/sql/constraints/foreignkey/test_fk_create_type.test b/parser/testdata/corpus/sql/constraints/foreignkey/test_fk_create_type.test new file mode 100644 index 0000000..3417bcd --- /dev/null +++ b/parser/testdata/corpus/sql/constraints/foreignkey/test_fk_create_type.test @@ -0,0 +1,41 @@ +# source: test/sql/constraints/foreignkey/test_fk_create_type.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +create type custom_type as integer; +-- +ok +== +create table parent ( + id custom_type primary key +); +-- +ok +== +create table child ( + parent custom_type references parent +); +-- +ok +== +drop table child; +-- +ok +== +create table child ( + parent integer references parent +); +-- +ok +== +create type another_custom_type as integer; +-- +ok +== +create table child ( + parent another_custom_type references parent +); +-- +ok +== diff --git a/parser/testdata/corpus/sql/constraints/foreignkey/test_fk_cross_schema.test b/parser/testdata/corpus/sql/constraints/foreignkey/test_fk_cross_schema.test new file mode 100644 index 0000000..d9c31a4 --- /dev/null +++ b/parser/testdata/corpus/sql/constraints/foreignkey/test_fk_cross_schema.test @@ -0,0 +1,21 @@ +# source: test/sql/constraints/foreignkey/test_fk_cross_schema.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +CREATE SCHEMA s2 +-- +ok +== +CREATE TABLE s1.pk_integers(i INTEGER PRIMARY KEY) +-- +ok +== +INSERT INTO s1.pk_integers VALUES (1), (2), (3) +-- +ok +== +CREATE TABLE s2.fk_integers(j INTEGER, FOREIGN KEY (j) REFERENCES s1.pk_intexgers(i)) +-- +ok +== diff --git a/parser/testdata/corpus/sql/constraints/foreignkey/test_fk_eager_constraint_checking.test b/parser/testdata/corpus/sql/constraints/foreignkey/test_fk_eager_constraint_checking.test new file mode 100644 index 0000000..0ad6e13 --- /dev/null +++ b/parser/testdata/corpus/sql/constraints/foreignkey/test_fk_eager_constraint_checking.test @@ -0,0 +1,53 @@ +# source: test/sql/constraints/foreignkey/test_fk_eager_constraint_checking.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +SET storage_compatibility_version = 'v0.10.3'; +-- +ok +== +ATTACH '{TEST_DIR}/test_fk_eager.db' AS fk_db; +-- +ok +== +USE fk_db; +-- +ok +== +CREATE TABLE tbl_pk (i INT PRIMARY KEY, payload STRUCT(v VARCHAR, i INTEGER[])); +-- +ok +== +INSERT INTO tbl_pk VALUES (1, {'v': 'hello', 'i': [42]}), (2, {'v': 'world', 'i': [43]}); +-- +ok +== +CREATE TABLE tbl_fk (i INT REFERENCES tbl_pk(i)); +-- +ok +== +INSERT INTO tbl_fk VALUES (1), (1), (1); +-- +ok +== +ATTACH '{TEST_DIR}/test_other_fk_eager.db' AS other_fk_db; +-- +ok +== +USE other_fk_db; +-- +ok +== +CHECKPOINT fk_db; +-- +ok +== +DETACH fk_db; +-- +ok +== +UPDATE fk_db.tbl_pk SET payload = {'v': 'new hello', 'i': [7]} WHERE i = 1; +-- +ok +== diff --git a/parser/testdata/corpus/sql/constraints/foreignkey/test_fk_export.test b/parser/testdata/corpus/sql/constraints/foreignkey/test_fk_export.test new file mode 100644 index 0000000..6c8eb91 --- /dev/null +++ b/parser/testdata/corpus/sql/constraints/foreignkey/test_fk_export.test @@ -0,0 +1,45 @@ +# source: test/sql/constraints/foreignkey/test_fk_export.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +EXPORT DATABASE '{TEST_DIR}/fk_constraint' +-- +ok +== +DROP TABLE fk_integers; +-- +ok +== +DROP TABLE pk_integers; +-- +ok +== +IMPORT DATABASE '{TEST_DIR}/fk_constraint' +-- +ok +== +INSERT INTO fk_integers VALUES (4) +-- +ok +== +INSERT INTO fk_integers VALUES (3) +-- +ok +== +DELETE FROM pk_integers WHERE i=3 +-- +ok +== +DELETE FROM fk_integers WHERE j=3 +-- +ok +== +UPDATE pk_integers SET i=5 WHERE i=2 +-- +ok +== +UPDATE fk_integers SET i=4 WHERE j=2 +-- +ok +== diff --git a/parser/testdata/corpus/sql/constraints/foreignkey/test_fk_multiple.test b/parser/testdata/corpus/sql/constraints/foreignkey/test_fk_multiple.test new file mode 100644 index 0000000..3f28750 --- /dev/null +++ b/parser/testdata/corpus/sql/constraints/foreignkey/test_fk_multiple.test @@ -0,0 +1,153 @@ +# source: test/sql/constraints/foreignkey/test_fk_multiple.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +CREATE TABLE pkt1( + i1 INTEGER PRIMARY KEY CHECK(i1 < 3), + j1 INTEGER UNIQUE +); +-- +ok +== +CREATE TABLE pkt2( + i2 INTEGER PRIMARY KEY, + j2 INTEGER UNIQUE CHECK (j2 > 1000) +); +-- +ok +== +CREATE TABLE fkt1( + k1 INTEGER, + l1 INTEGER, + FOREIGN KEY(k1) REFERENCES pkt1(i1), + FOREIGN KEY(l1) REFERENCES pkt2(i2) +); +-- +ok +== +CREATE TABLE fkt2( + k2 INTEGER, + l2 INTEGER, + FOREIGN KEY(k2) REFERENCES pkt1(j1), + FOREIGN KEY(l2) REFERENCES pkt2(j2) +); +-- +ok +== +INSERT INTO pkt1 VALUES (3, 11); +-- +ok +== +INSERT INTO pkt2 VALUES (101, 1000); +-- +ok +== +INSERT INTO pkt1 VALUES (1, 11), (2, 12); +-- +ok +== +INSERT INTO pkt2 VALUES (101, 1001), (102, 1002); +-- +ok +== +INSERT INTO fkt1 VALUES (3, 101); +-- +ok +== +INSERT INTO fkt1 VALUES (2, 103); +-- +ok +== +INSERT INTO fkt1 VALUES (1, 102), (2, 101); +-- +ok +== +INSERT INTO fkt2 VALUES (13, 1002); +-- +ok +== +INSERT INTO fkt1 VALUES (12, 1003); +-- +ok +== +INSERT INTO fkt2 VALUES (12, 1001), (11, 1002); +-- +ok +== +DELETE FROM pkt1 WHERE i1=1 +-- +ok +== +DELETE FROM pkt2 WHERE i2=102 +-- +ok +== +DELETE FROM fkt1 WHERE k1=1 +-- +ok +== +DELETE FROM fkt2 WHERE k2=11 +-- +ok +== +SELECT * FROM pkt1; +-- +ok +== +SELECT * FROM pkt2; +-- +ok +== +SELECT * FROM fkt1; +-- +ok +== +SELECT * FROM fkt2; +-- +ok +== +UPDATE pkt1 SET i1=3, j1=13 WHERE i1=2; +-- +ok +== +UPDATE pkt2 SET i2=103, j2=1003 WHERE i2=101; +-- +ok +== +UPDATE pkt2 SET i2=103, j2=1003 WHERE i2=102; +-- +ok +== +DELETE FROM fkt1 WHERE k1=2 +-- +ok +== +DELETE FROM fkt2 WHERE k2=12 +-- +ok +== +UPDATE pkt1 SET i1=1, j1=11 WHERE i1=2; +-- +ok +== +UPDATE pkt2 SET i2=104, j2=1004 WHERE i2=101; +-- +ok +== +DROP TABLE pkt1 +-- +ok +== +DROP TABLE pkt2 +-- +ok +== +DROP TABLE fkt2 +-- +ok +== +DROP TABLE fkt1 +-- +ok +== diff --git a/parser/testdata/corpus/sql/constraints/foreignkey/test_fk_on_view_error.test b/parser/testdata/corpus/sql/constraints/foreignkey/test_fk_on_view_error.test new file mode 100644 index 0000000..52bb37d --- /dev/null +++ b/parser/testdata/corpus/sql/constraints/foreignkey/test_fk_on_view_error.test @@ -0,0 +1,17 @@ +# source: test/sql/constraints/foreignkey/test_fk_on_view_error.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +CREATE TABLE vdata AS SELECT * FROM (VALUES ('v2',)) v(id); +-- +ok +== +CREATE VIEW v AS SELECT * FROM vdata; +-- +ok +== +CREATE TABLE t(v_id TEXT, FOREIGN KEY (v_id) REFERENCES v(id)); +-- +ok +== diff --git a/parser/testdata/corpus/sql/constraints/foreignkey/test_fk_pk_multi_transaction_delete.test b/parser/testdata/corpus/sql/constraints/foreignkey/test_fk_pk_multi_transaction_delete.test new file mode 100644 index 0000000..6c087fc --- /dev/null +++ b/parser/testdata/corpus/sql/constraints/foreignkey/test_fk_pk_multi_transaction_delete.test @@ -0,0 +1,29 @@ +# source: test/sql/constraints/foreignkey/test_fk_pk_multi_transaction_delete.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +CREATE TABLE primary_table (id INT PRIMARY KEY) +-- +ok +== +CREATE TABLE secondary_table (primary_id INT, FOREIGN KEY (primary_id) REFERENCES primary_table(id)) +-- +ok +== +INSERT INTO primary_table VALUES (42) +-- +ok +== +SELECT id FROM primary_table LIMIT 1 +-- +ok +== +DELETE FROM primary_table WHERE id = 42 +-- +ok +== +INSERT INTO secondary_table VALUES (42) +-- +ok +== diff --git a/parser/testdata/corpus/sql/constraints/foreignkey/test_fk_rollback.test b/parser/testdata/corpus/sql/constraints/foreignkey/test_fk_rollback.test new file mode 100644 index 0000000..97c0542 --- /dev/null +++ b/parser/testdata/corpus/sql/constraints/foreignkey/test_fk_rollback.test @@ -0,0 +1,29 @@ +# source: test/sql/constraints/foreignkey/test_fk_rollback.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +INSERT INTO pk_integers VALUES (1); +-- +ok +== +DROP TABLE pk_integers +-- +ok +== +INSERT INTO pk_integers VALUES (1), (2); +-- +ok +== +INSERT INTO fk_integers VALUES (2); +-- +ok +== +DELETE FROM pk_integers WHERE i=2; +-- +ok +== +INSERT INTO fk_integers VALUES (3); +-- +ok +== diff --git a/parser/testdata/corpus/sql/constraints/foreignkey/test_fk_self_reference_export.test b/parser/testdata/corpus/sql/constraints/foreignkey/test_fk_self_reference_export.test new file mode 100644 index 0000000..2de05a2 --- /dev/null +++ b/parser/testdata/corpus/sql/constraints/foreignkey/test_fk_self_reference_export.test @@ -0,0 +1,25 @@ +# source: test/sql/constraints/foreignkey/test_fk_self_reference_export.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +CREATE TABLE self_ref(id INTEGER PRIMARY KEY, parent_id INTEGER REFERENCES self_ref(id)); +-- +ok +== +INSERT INTO self_ref VALUES (1, NULL); +-- +ok +== +INSERT INTO self_ref VALUES (2, 1); +-- +ok +== +EXPORT DATABASE '{TEST_DIR}/test_data' +-- +ok +== +DROP TABLE self_ref; +-- +ok +== diff --git a/parser/testdata/corpus/sql/constraints/foreignkey/test_fk_self_referencing.test b/parser/testdata/corpus/sql/constraints/foreignkey/test_fk_self_referencing.test new file mode 100644 index 0000000..ece7a70 --- /dev/null +++ b/parser/testdata/corpus/sql/constraints/foreignkey/test_fk_self_referencing.test @@ -0,0 +1,109 @@ +# source: test/sql/constraints/foreignkey/test_fk_self_referencing.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +CREATE TABLE employee( + id INTEGER PRIMARY KEY, + managerid INTEGER, + name VARCHAR, + FOREIGN KEY(managerid) REFERENCES employee(emp_id)); +-- +ok +== +CREATE TABLE employee( + id INTEGER PRIMARY KEY, + managerid INTEGER, + name VARCHAR, + FOREIGN KEY(managerid) REFERENCES employee(id)); +-- +ok +== +INSERT INTO employee VALUES (1, NULL, 'Smith'), (2, NULL, 'Jhon'), (3, NULL, 'Romeo'); +-- +ok +== +INSERT INTO employee VALUES (4, 4, 'Mark'); +-- +ok +== +INSERT INTO employee VALUES (4, 2, 'Mark'); +-- +ok +== +UPDATE employee SET id = 5 WHERE id = 2; +-- +ok +== +DELETE FROM employee WHERE id = 2; +-- +ok +== +DELETE FROM employee WHERE id = 4; +-- +ok +== +SELECT * FROM employee ORDER BY ALL; +-- +ok +== +UPDATE employee SET name = 'Juliet' WHERE id = 3; +-- +ok +== +UPDATE employee SET id = 2 WHERE id = 3; +-- +ok +== +UPDATE employee SET id = 4 WHERE id = 3; +-- +ok +== +UPDATE employee SET managerid = 5 WHERE id = 4; +-- +ok +== +UPDATE employee SET managerid = 2 WHERE id = 4; +-- +ok +== +UPDATE employee SET id = 5, managerid = 2 WHERE id = 4; +-- +ok +== +SELECT * FROM employee WHERE managerid = 2; +-- +ok +== +ALTER TABLE employee RENAME COLUMN managerid TO managerid_new; +-- +ok +== +ALTER TABLE employee RENAME COLUMN name TO name_new; +-- +ok +== +ALTER TABLE employee ALTER COLUMN id SET DATA TYPE TEXT; +-- +ok +== +ALTER TABLE employee ALTER COLUMN name_new SET DATA TYPE TEXT; +-- +ok +== +ALTER TABLE employee DROP COLUMN id; +-- +ok +== +ALTER TABLE employee DROP COLUMN managerid; +-- +ok +== +ALTER TABLE employee DROP COLUMN name_new; +-- +ok +== +DROP TABLE employee; +-- +ok +== diff --git a/parser/testdata/corpus/sql/constraints/foreignkey/test_fk_temporary.test b/parser/testdata/corpus/sql/constraints/foreignkey/test_fk_temporary.test new file mode 100644 index 0000000..b3d59e0 --- /dev/null +++ b/parser/testdata/corpus/sql/constraints/foreignkey/test_fk_temporary.test @@ -0,0 +1,242 @@ +# source: test/sql/constraints/foreignkey/test_fk_temporary.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +CREATE TEMPORARY TABLE album (artistid INTEGER, albumname TEXT, albumcover TEXT, UNIQUE (artistid, albumname)); +-- +ok +== +CREATE TEMPORARY TABLE song (songid INTEGER, songartist INTEGER, songalbum TEXT, songname TEXT, +FOREIGN KEY (songartist, songalbum) REFERENCES album (artistid, albumname)); +-- +ok +== +INSERT INTO song VALUES (11, 1, 'A', 'A_song'), (12, 2, 'E', 'B_song'), (13, 3, 'C', 'C_song'); +-- +ok +== +INSERT INTO song VALUES (11, 1, 'A', 'A_song'), (12, 5, 'D', 'B_song'), (13, 3, 'C', 'C_song'); +-- +ok +== +INSERT INTO song VALUES (11, 1, 'A', 'A_song'), (12, 2, 'B', 'B_song'), (13, 3, 'C', 'C_song'); +-- +ok +== +DELETE FROM album WHERE albumname = 'C'; +-- +ok +== +DELETE FROM album WHERE albumname = 'D'; +-- +ok +== +SELECT * FROM album ORDER BY ALL; +-- +ok +== +UPDATE song SET songartist = 5, songalbum = 'A' WHERE songname = 'B_song'; +-- +ok +== +UPDATE song SET songartist = 1, songalbum = 'A' WHERE songname = 'B_song'; +-- +ok +== +SELECT * FROM song ORDER BY ALL; +-- +ok +== +UPDATE album SET albumname='B' WHERE albumcover='C_cover'; +-- +ok +== +UPDATE song SET songalbum='E' WHERE albumcover='C_song'; +-- +ok +== +UPDATE album SET artistid=5, albumname='D' WHERE albumcover='B_cover'; +-- +ok +== +SELECT * FROM album; +-- +ok +== +UPDATE album SET albumcover='C_cover_new' WHERE artistid=3; +-- +ok +== +UPDATE song SET songname='C_song_new' WHERE songartist=3; +-- +ok +== +SELECT * FROM song; +-- +ok +== +ALTER TABLE album RENAME COLUMN albumname TO albumname_new; +-- +ok +== +ALTER TABLE song RENAME COLUMN songalbum TO songalbum_new; +-- +ok +== +ALTER TABLE song RENAME COLUMN songname TO songname_new; +-- +ok +== +ALTER TABLE song ALTER COLUMN songartist SET DATA TYPE TEXT; +-- +ok +== +ALTER TABLE album ALTER COLUMN artistid SET DATA TYPE TEXT; +-- +ok +== +ALTER TABLE song ALTER COLUMN songname_new SET DATA TYPE VARCHAR; +-- +ok +== +ALTER TABLE album DROP COLUMN artistid; +-- +ok +== +ALTER TABLE song DROP COLUMN songname_new; +-- +ok +== +DROP TABLE album; +-- +ok +== +DROP TABLE song; +-- +ok +== +ALTER TABLE album ALTER COLUMN albumcover SET DATA TYPE VARCHAR; +-- +ok +== +ALTER TABLE album DROP COLUMN albumcover; +-- +ok +== +CREATE TABLE pkt(i INTEGER UNIQUE, k INTEGER UNIQUE) +-- +ok +== +INSERT INTO pkt VALUES (1, 11), (2, 12), (3, 13) +-- +ok +== +CREATE TABLE fkt(j INTEGER, l INTEGER UNIQUE, FOREIGN KEY (j) REFERENCES pkt(i)) +-- +ok +== +CREATE INDEX k_index ON pkt(k) +-- +ok +== +CREATE INDEX l_index ON fkt(l) +-- +ok +== +INSERT INTO fkt VALUES (1, 101), (2, 102) +-- +ok +== +INSERT INTO fkt VALUES (4, 104) +-- +ok +== +INSERT INTO fkt VALUES (3, 103) +-- +ok +== +DELETE FROM pkt WHERE k=13 +-- +ok +== +DELETE FROM fkt WHERE l=103 +-- +ok +== +UPDATE pkt SET i=5 WHERE k=12 +-- +ok +== +UPDATE fkt SET i=4 WHERE l=102 +-- +ok +== +DROP INDEX k_index +-- +ok +== +DROP INDEX l_index +-- +ok +== +DROP TABLE pkt; +-- +ok +== +DROP TABLE fkt; +-- +ok +== +CREATE TABLE s1.pkt(i INTEGER PRIMARY KEY) +-- +ok +== +CREATE TABLE s1.fkt(j INTEGER, FOREIGN KEY (j) REFERENCES s1.pkt(i)) +-- +ok +== +INSERT INTO s1.pkt VALUES (1), (2), (3), (4), (5) +-- +ok +== +INSERT INTO s1.fkt VALUES (2), (3) +-- +ok +== +INSERT INTO s1.fkt VALUES (6) +-- +ok +== +INSERT INTO s1.fkt VALUES (1) +-- +ok +== +DELETE FROM s1.pkt WHERE i=2 +-- +ok +== +DELETE FROM s1.pkt WHERE i=5 +-- +ok +== +DROP TABLE s1.pkt; +-- +ok +== +DROP TABLE s1.fkt; +-- +ok +== +CREATE TABLE pkt(i INTEGER UNIQUE) +-- +ok +== +CREATE TABLE fkt(j INTEGER, FOREIGN KEY (j) REFERENCES pkt(i)) +-- +ok +== +INSERT INTO fkt VALUES (NULL) +-- +ok +== diff --git a/parser/testdata/corpus/sql/constraints/foreignkey/test_fk_transaction.test b/parser/testdata/corpus/sql/constraints/foreignkey/test_fk_transaction.test new file mode 100644 index 0000000..40b649b --- /dev/null +++ b/parser/testdata/corpus/sql/constraints/foreignkey/test_fk_transaction.test @@ -0,0 +1,77 @@ +# source: test/sql/constraints/foreignkey/test_fk_transaction.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +CREATE TABLE pkt(i INTEGER PRIMARY KEY) +-- +ok +== +INSERT INTO pkt VALUES (1) +-- +ok +== +INSERT INTO fkt VALUES (1) +-- +ok +== +INSERT INTO pkt VALUES (2) +-- +ok +== +INSERT INTO fkt VALUES (3) +-- +ok +== +DELETE FROM pkt WHERE i = 1 +-- +ok +== +INSERT INTO fkt VALUES (1), (2) +-- +ok +== +DELETE FROM fkt WHERE j = 1 +-- +ok +== +DELETE FROM pkt WHERE i = 2 +-- +ok +== +DELETE FROM fkt WHERE j = 2 +-- +ok +== +INSERT INTO pkt VALUES (3) +-- +ok +== +DELETE FROM pkt WHERE i = 3 +-- +ok +== +CREATE TABLE a(i INTEGER PRIMARY KEY) +-- +ok +== +CREATE TABLE b(j INTEGER, FOREIGN KEY (j) REFERENCES a(i)) +-- +ok +== +INSERT INTO a VALUES (1), (2) +-- +ok +== +INSERT INTO b VALUES (1), (2) +-- +ok +== +DELETE FROM b +-- +ok +== +DELETE FROM a +-- +ok +== diff --git a/parser/testdata/corpus/sql/constraints/foreignkey/test_fk_with_attached_db.test b/parser/testdata/corpus/sql/constraints/foreignkey/test_fk_with_attached_db.test new file mode 100644 index 0000000..79f9a0e --- /dev/null +++ b/parser/testdata/corpus/sql/constraints/foreignkey/test_fk_with_attached_db.test @@ -0,0 +1,29 @@ +# source: test/sql/constraints/foreignkey/test_fk_with_attached_db.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +ATTACH '{TEST_DIR}/attach_fk_db.db' AS db1; +-- +ok +== +CREATE TABLE IF NOT EXISTS t1 ( + cache_key VARCHAR PRIMARY KEY, + created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP, +); +-- +ok +== +CREATE TABLE IF NOT EXISTS t2 ( + cache_key VARCHAR NOT NULL, + dose DOUBLE NOT NULL, + PRIMARY KEY (cache_key, dose), + FOREIGN KEY (cache_key) REFERENCES t1 (cache_key) +); +-- +ok +== +ATTACH '{TEST_DIR}/attach_fk_db.db' AS db2; +-- +ok +== diff --git a/parser/testdata/corpus/sql/constraints/foreignkey/test_foreignkey.test b/parser/testdata/corpus/sql/constraints/foreignkey/test_foreignkey.test new file mode 100644 index 0000000..3443404 --- /dev/null +++ b/parser/testdata/corpus/sql/constraints/foreignkey/test_foreignkey.test @@ -0,0 +1,65 @@ +# source: test/sql/constraints/foreignkey/test_foreignkey.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +CREATE TABLE song(songid INTEGER, songartist INTEGER, songalbum TEXT, songname TEXT, FOREIGN KEY(songartist, songalbum) REFERENCES album(artistid)); +-- +error: Parser Error: The number of referencing and referenced columns for foreign keys must be the same +== +CREATE TABLE song(songid INTEGER, songartist INTEGER, songalbum TEXT, songname TEXT, FOREIGN KEY(songalbum) REFERENCES album(artistid, albumname)); +-- +error: Parser Error: The number of referencing and referenced columns for foreign keys must be the same +== +CREATE TABLE song(songid INTEGER, songartist INTEGER, songalbum TEXT, songname TEXT, FOREIGN KEY(songartist, songalbum) REFERENCES albumlist(artistid, albumname)); +-- +ok +== +CREATE TABLE song(songid INTEGER, songartist INTEGER, songalbum TEXT, songname TEXT, FOREIGN KEY(songartist, songalbum) REFERENCES album(artistid, album_name)); +-- +ok +== +CREATE TABLE song(songid INTEGER, songartist INTEGER, songalbum TEXT, songname TEXT, FOREIGN KEY(songartist, song_album) REFERENCES album(artistid, albumname)); +-- +ok +== +DELETE FROM album WHERE albumname='C'; +-- +ok +== +DELETE FROM album WHERE albumname='D'; +-- +ok +== +UPDATE song SET songartist=5, songalbum='A' WHERE songname='B_song'; +-- +ok +== +UPDATE song SET songartist=1, songalbum='A' WHERE songname='B_song'; +-- +ok +== +CREATE TABLE fkt( + j INTEGER, + l INTEGER UNIQUE, + FOREIGN KEY (j) REFERENCES pkt(i) +) +-- +ok +== +CREATE TABLE t (id INT PRIMARY KEY, parent INT REFERENCES t (id)); +-- +ok +== +INSERT INTO t VALUES (1, NULL); +-- +ok +== +INSERT INTO t VALUES (2, 1), (3, 1); +-- +ok +== +TRUNCATE t; +-- +ok +== diff --git a/parser/testdata/corpus/sql/constraints/foreignkey/test_foreignkey.test.metadata.json b/parser/testdata/corpus/sql/constraints/foreignkey/test_foreignkey.test.metadata.json new file mode 100644 index 0000000..fc2be33 --- /dev/null +++ b/parser/testdata/corpus/sql/constraints/foreignkey/test_foreignkey.test.metadata.json @@ -0,0 +1,6 @@ +{ + "todo": { + "97428731c1de2c0b": "transformer-raised parser error: upstream rejects in the transformer, not the grammar; expected to clear as transformers land (milestones 3-5)", + "a79b6e6f6b9fc911": "transformer-raised parser error: upstream rejects in the transformer, not the grammar; expected to clear as transformers land (milestones 3-5)" + } +} diff --git a/parser/testdata/corpus/sql/constraints/primarykey/test_pk_bool.test b/parser/testdata/corpus/sql/constraints/primarykey/test_pk_bool.test new file mode 100644 index 0000000..4ef554d --- /dev/null +++ b/parser/testdata/corpus/sql/constraints/primarykey/test_pk_bool.test @@ -0,0 +1,25 @@ +# source: test/sql/constraints/primarykey/test_pk_bool.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +CREATE TABLE integers(i INTEGER, j BOOLEAN, PRIMARY KEY(i, j)) +-- +ok +== +INSERT INTO integers VALUES (1, false), (1, true), (2, false) +-- +ok +== +INSERT INTO integers VALUES (1, false) +-- +ok +== +INSERT INTO integers VALUES (2, true) +-- +ok +== +SELECT * FROM integers ORDER BY 1, 2 +-- +ok +== diff --git a/parser/testdata/corpus/sql/constraints/primarykey/test_pk_col_subset.test b/parser/testdata/corpus/sql/constraints/primarykey/test_pk_col_subset.test new file mode 100644 index 0000000..99eedfa --- /dev/null +++ b/parser/testdata/corpus/sql/constraints/primarykey/test_pk_col_subset.test @@ -0,0 +1,37 @@ +# source: test/sql/constraints/primarykey/test_pk_col_subset.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +CREATE TABLE numbers(a integer, b integer, c integer, d integer, e integer, PRIMARY KEY(a,b)) +-- +ok +== +INSERT INTO numbers VALUES (1,1,1,1,1), (1,1,1,1,1) +-- +ok +== +INSERT INTO numbers VALUES (1,1,1,1,1),(1,2,1,1,1),(2,1,2,1,1),(2,2,2,2,2) +-- +ok +== +INSERT INTO numbers VALUES (1,1,1,1,1),(1,5,1,1,4); +-- +ok +== +INSERT INTO numbers VALUES (1,5,1,1,4); +-- +ok +== +UPDATE numbers SET c=1 WHERE c=2 +-- +ok +== +UPDATE numbers SET b=1 WHERE b=2 +-- +ok +== +UPDATE numbers SET b=3 WHERE b=2 +-- +ok +== diff --git a/parser/testdata/corpus/sql/constraints/primarykey/test_pk_concurrency_conflicts.test b/parser/testdata/corpus/sql/constraints/primarykey/test_pk_concurrency_conflicts.test new file mode 100644 index 0000000..6f22506 --- /dev/null +++ b/parser/testdata/corpus/sql/constraints/primarykey/test_pk_concurrency_conflicts.test @@ -0,0 +1,29 @@ +# source: test/sql/constraints/primarykey/test_pk_concurrency_conflicts.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +CREATE TABLE integers(i INTEGER PRIMARY KEY) +-- +ok +== +UPDATE integers SET i=4 WHERE i=2 +-- +ok +== +UPDATE integers SET i=5 WHERE i=2 +-- +ok +== +DELETE FROM integers WHERE i=2 +-- +ok +== +UPDATE integers SET i=5 WHERE i=3 +-- +ok +== +SELECT * FROM integers ORDER BY i +-- +ok +== diff --git a/parser/testdata/corpus/sql/constraints/primarykey/test_pk_many_columns.test b/parser/testdata/corpus/sql/constraints/primarykey/test_pk_many_columns.test new file mode 100644 index 0000000..59b5257 --- /dev/null +++ b/parser/testdata/corpus/sql/constraints/primarykey/test_pk_many_columns.test @@ -0,0 +1,21 @@ +# source: test/sql/constraints/primarykey/test_pk_many_columns.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +CREATE TABLE numbers(a integer, b integer, c integer, d integer, e integer, PRIMARY KEY(a,b,c,d,e)) +-- +ok +== +INSERT INTO numbers VALUES (1,1,1,1,1),(1,2,1,1,1),(1,1,2,1,1),(2,2,2,2,2) +-- +ok +== +INSERT INTO numbers VALUES (1,1,1,1,1),(1,1,1,1,4); +-- +ok +== +INSERT INTO numbers VALUES (1,1,1,1,4); +-- +ok +== diff --git a/parser/testdata/corpus/sql/constraints/primarykey/test_pk_multi_column.test b/parser/testdata/corpus/sql/constraints/primarykey/test_pk_multi_column.test new file mode 100644 index 0000000..ab9b865 --- /dev/null +++ b/parser/testdata/corpus/sql/constraints/primarykey/test_pk_multi_column.test @@ -0,0 +1,21 @@ +# source: test/sql/constraints/primarykey/test_pk_multi_column.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +CREATE TABLE integers(i INTEGER, j VARCHAR, PRIMARY KEY(i, j)) +-- +ok +== +INSERT INTO integers VALUES (3, 'hello'), (3, 'world') +-- +ok +== +INSERT INTO integers VALUES (6, 'bla'), (3, 'hello'); +-- +ok +== +INSERT INTO integers VALUES (6, 'bla'); +-- +ok +== diff --git a/parser/testdata/corpus/sql/constraints/primarykey/test_pk_multi_string.test b/parser/testdata/corpus/sql/constraints/primarykey/test_pk_multi_string.test new file mode 100644 index 0000000..4611e47 --- /dev/null +++ b/parser/testdata/corpus/sql/constraints/primarykey/test_pk_multi_string.test @@ -0,0 +1,33 @@ +# source: test/sql/constraints/primarykey/test_pk_multi_string.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +CREATE TABLE tst(a varchar, b varchar,PRIMARY KEY(a,b)) +-- +ok +== +INSERT INTO tst VALUES ('hell', 'hello'), ('hell','hello') +-- +ok +== +INSERT INTO tst VALUES ('hell', 'hello'), ('hello','hell'), ('hel','hell'), ('hell','hel') +-- +ok +== +INSERT INTO tst VALUES ('hell', 'hello'),('hel', 'hello'); +-- +ok +== +INSERT INTO tst VALUES ('hel', 'hello'); +-- +ok +== +UPDATE tst SET b='hello' WHERE b='hel' +-- +ok +== +UPDATE tst SET b='hell' WHERE b='hel' +-- +ok +== diff --git a/parser/testdata/corpus/sql/constraints/primarykey/test_pk_rollback.test b/parser/testdata/corpus/sql/constraints/primarykey/test_pk_rollback.test new file mode 100644 index 0000000..6cf56fd --- /dev/null +++ b/parser/testdata/corpus/sql/constraints/primarykey/test_pk_rollback.test @@ -0,0 +1,9 @@ +# source: test/sql/constraints/primarykey/test_pk_rollback.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +INSERT INTO integers VALUES (1); +-- +ok +== diff --git a/parser/testdata/corpus/sql/constraints/primarykey/test_pk_string.test b/parser/testdata/corpus/sql/constraints/primarykey/test_pk_string.test new file mode 100644 index 0000000..2bd71d7 --- /dev/null +++ b/parser/testdata/corpus/sql/constraints/primarykey/test_pk_string.test @@ -0,0 +1,37 @@ +# source: test/sql/constraints/primarykey/test_pk_string.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +CREATE TABLE numbers(i varchar PRIMARY KEY, j INTEGER) +-- +ok +== +INSERT INTO numbers VALUES ('1', 4), ('1', 5) +-- +ok +== +INSERT INTO numbers VALUES ('1', 4), ('2', 5) +-- +ok +== +SELECT * FROM numbers +-- +ok +== +INSERT INTO numbers VALUES ('6', 6), ('1', 4); +-- +ok +== +INSERT INTO numbers VALUES ('6', 6); +-- +ok +== +INSERT INTO numbers VALUES (NULL, 4); +-- +ok +== +UPDATE numbers SET i=NULL; +-- +ok +== diff --git a/parser/testdata/corpus/sql/constraints/primarykey/test_pk_update_delete.test b/parser/testdata/corpus/sql/constraints/primarykey/test_pk_update_delete.test new file mode 100644 index 0000000..6153c5b --- /dev/null +++ b/parser/testdata/corpus/sql/constraints/primarykey/test_pk_update_delete.test @@ -0,0 +1,49 @@ +# source: test/sql/constraints/primarykey/test_pk_update_delete.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +CREATE TABLE test (a INTEGER PRIMARY KEY, b INTEGER); +-- +ok +== +INSERT INTO test VALUES (11, 1), (12, 2), (13, 3) +-- +ok +== +UPDATE test SET b=2 WHERE b=3; +-- +ok +== +UPDATE test SET a=a+1 WHERE b=1; +-- +ok +== +UPDATE test SET a=4; +-- +ok +== +DELETE FROM test WHERE a=11 +-- +ok +== +SELECT * FROM test ORDER BY a; +-- +ok +== +INSERT INTO test VALUES (11, 1); +-- +ok +== +UPDATE test SET a=4 WHERE b=1; +-- +ok +== +UPDATE test SET a=NULL WHERE b=1; +-- +ok +== +UPDATE test SET a=NULL; +-- +ok +== diff --git a/parser/testdata/corpus/sql/constraints/primarykey/test_pk_updel_local.test b/parser/testdata/corpus/sql/constraints/primarykey/test_pk_updel_local.test new file mode 100644 index 0000000..1064d89 --- /dev/null +++ b/parser/testdata/corpus/sql/constraints/primarykey/test_pk_updel_local.test @@ -0,0 +1,13 @@ +# source: test/sql/constraints/primarykey/test_pk_updel_local.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +UPDATE integers SET i=33; +-- +ok +== +INSERT INTO integers VALUES (33); +-- +ok +== diff --git a/parser/testdata/corpus/sql/constraints/primarykey/test_pk_updel_multi_column.test b/parser/testdata/corpus/sql/constraints/primarykey/test_pk_updel_multi_column.test new file mode 100644 index 0000000..fbd4e95 --- /dev/null +++ b/parser/testdata/corpus/sql/constraints/primarykey/test_pk_updel_multi_column.test @@ -0,0 +1,61 @@ +# source: test/sql/constraints/primarykey/test_pk_updel_multi_column.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +CREATE TABLE test (a INTEGER, b VARCHAR, PRIMARY KEY(a, b)); +-- +ok +== +INSERT INTO test VALUES (11, 'hello'), (12, 'world'), (13, 'blablabla'); +-- +ok +== +UPDATE test SET b = 'pandas'; +-- +ok +== +SELECT * FROM test ORDER BY ALL; +-- +ok +== +UPDATE test SET a = a + 3; +-- +ok +== +UPDATE test SET a = 15 WHERE a = 14; +-- +ok +== +UPDATE test SET a = 4; +-- +ok +== +UPDATE test SET a = a - 3; +-- +ok +== +DELETE FROM test WHERE a = 12; +-- +ok +== +INSERT INTO test VALUES (12, 'pandas'); +-- +ok +== +INSERT INTO test VALUES (12, 'other pandas'); +-- +ok +== +UPDATE test SET a = 4 WHERE a = 42; +-- +ok +== +UPDATE test SET a = 4 WHERE a = 12; +-- +ok +== +UPDATE test SET b = NULL WHERE a = 13; +-- +ok +== diff --git a/parser/testdata/corpus/sql/constraints/primarykey/test_primary_key.test b/parser/testdata/corpus/sql/constraints/primarykey/test_primary_key.test new file mode 100644 index 0000000..85f5cfa --- /dev/null +++ b/parser/testdata/corpus/sql/constraints/primarykey/test_primary_key.test @@ -0,0 +1,41 @@ +# source: test/sql/constraints/primarykey/test_primary_key.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +CREATE TABLE integers(i INTEGER PRIMARY KEY, j INTEGER) +-- +ok +== +INSERT INTO integers VALUES (3, 4), (3, 5) +-- +ok +== +INSERT INTO integers VALUES (3, 4), (2, 5) +-- +ok +== +INSERT INTO integers VALUES (6, 6), (3, 4); +-- +ok +== +INSERT INTO integers VALUES (6, 6); +-- +ok +== +INSERT INTO integers VALUES (NULL, 4); +-- +ok +== +UPDATE integers SET i=NULL; +-- +ok +== +INSERT INTO integers VALUES (7, 8); +-- +ok +== +INSERT INTO integers VALUES (7, 33); +-- +ok +== diff --git a/parser/testdata/corpus/sql/constraints/test_constraint_with_updates.test b/parser/testdata/corpus/sql/constraints/test_constraint_with_updates.test new file mode 100644 index 0000000..e080c9b --- /dev/null +++ b/parser/testdata/corpus/sql/constraints/test_constraint_with_updates.test @@ -0,0 +1,57 @@ +# source: test/sql/constraints/test_constraint_with_updates.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +CREATE TABLE integers(i INTEGER, j INTEGER CHECK(i + j < 5), k INTEGER) +-- +ok +== +INSERT INTO integers VALUES (1, 2, 4) +-- +ok +== +UPDATE integers SET k=7 +-- +ok +== +UPDATE integers SET i=i, j=3 +-- +ok +== +UPDATE integers SET i=i, i=10 +-- +ok +== +UPDATE integers SET i=i, j=10 +-- +ok +== +UPDATE integers SET j=2 +-- +ok +== +UPDATE integers SET j=10 +-- +ok +== +CREATE TABLE integers(i INTEGER NOT NULL, j INTEGER NOT NULL) +-- +ok +== +INSERT INTO integers VALUES (1, 2) +-- +ok +== +UPDATE integers SET j=3 +-- +ok +== +UPDATE integers SET i=NULL +-- +ok +== +UPDATE integers SET j=NULL +-- +ok +== diff --git a/parser/testdata/corpus/sql/constraints/test_not_null.test b/parser/testdata/corpus/sql/constraints/test_not_null.test new file mode 100644 index 0000000..eed9950 --- /dev/null +++ b/parser/testdata/corpus/sql/constraints/test_not_null.test @@ -0,0 +1,33 @@ +# source: test/sql/constraints/test_not_null.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +CREATE TABLE integers(i INTEGER NOT NULL) +-- +ok +== +UPDATE integers SET i=4 +-- +ok +== +CREATE TABLE integers_with_null(i INTEGER) +-- +ok +== +INSERT INTO integers_with_null VALUES (3), (4), (5), (NULL); +-- +ok +== +INSERT INTO integers (i) SELECT * FROM integers_with_null +-- +ok +== +INSERT INTO integers (i) SELECT * FROM integers_with_null WHERE i IS NOT NULL +-- +ok +== +UPDATE integers SET i=4 WHERE i>4 +-- +ok +== diff --git a/parser/testdata/corpus/sql/constraints/unique/test_unique.test b/parser/testdata/corpus/sql/constraints/unique/test_unique.test new file mode 100644 index 0000000..6a16137 --- /dev/null +++ b/parser/testdata/corpus/sql/constraints/unique/test_unique.test @@ -0,0 +1,29 @@ +# source: test/sql/constraints/unique/test_unique.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +CREATE TABLE integers(i INTEGER UNIQUE, j INTEGER) +-- +ok +== +INSERT INTO integers VALUES (NULL, 6), (NULL, 7) +-- +ok +== +UPDATE integers SET i=77 WHERE i IS NULL +-- +ok +== +SELECT * FROM integers ORDER BY i, j +-- +ok +== +UPDATE integers SET i=77 WHERE i IS NULL AND j=6 +-- +ok +== +INSERT INTO integers VALUES (NULL, 6), (3, 7) +-- +ok +== diff --git a/parser/testdata/corpus/sql/constraints/unique/test_unique_error.test b/parser/testdata/corpus/sql/constraints/unique/test_unique_error.test new file mode 100644 index 0000000..a4a27c1 --- /dev/null +++ b/parser/testdata/corpus/sql/constraints/unique/test_unique_error.test @@ -0,0 +1,17 @@ +# source: test/sql/constraints/unique/test_unique_error.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +CREATE TEMPORARY TABLE integers(i INTEGER, j VARCHAR) +-- +ok +== +INSERT INTO integers VALUES (3, '4'), (2, '4') +-- +ok +== +CREATE UNIQUE INDEX uidx ON integers (j) +-- +ok +== diff --git a/parser/testdata/corpus/sql/constraints/unique/test_unique_multi_column.test b/parser/testdata/corpus/sql/constraints/unique/test_unique_multi_column.test new file mode 100644 index 0000000..1646e40 --- /dev/null +++ b/parser/testdata/corpus/sql/constraints/unique/test_unique_multi_column.test @@ -0,0 +1,25 @@ +# source: test/sql/constraints/unique/test_unique_multi_column.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +CREATE TEMPORARY TABLE integers(i INTEGER, j INTEGER) +-- +ok +== +CREATE UNIQUE INDEX uidx ON integers (i,j) +-- +ok +== +INSERT INTO integers VALUES (NULL, 6), (NULL, 6), (NULL, 7) +-- +ok +== +UPDATE integers SET i=77 WHERE i IS NULL AND j=7 +-- +ok +== +INSERT INTO integers VALUES (3, 4) +-- +ok +== diff --git a/parser/testdata/corpus/sql/constraints/unique/test_unique_multi_constraint.test b/parser/testdata/corpus/sql/constraints/unique/test_unique_multi_constraint.test new file mode 100644 index 0000000..1cd17a3 --- /dev/null +++ b/parser/testdata/corpus/sql/constraints/unique/test_unique_multi_constraint.test @@ -0,0 +1,45 @@ +# source: test/sql/constraints/unique/test_unique_multi_constraint.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +CREATE TABLE integers(i INTEGER PRIMARY KEY, j INTEGER UNIQUE) +-- +ok +== +INSERT INTO integers VALUES (1, 1), (2, 2) +-- +ok +== +INSERT INTO integers VALUES (3, 3), (4, 1) +-- +ok +== +INSERT INTO integers VALUES (3, 3), (4, 4) +-- +ok +== +INSERT INTO integers VALUES (5, 5), (6, 6), (7, 7), (8, 8), (9, 9), (10, 10), (11, 11), (12, 12), (13, 13), (14, 14), (15, 15), (16, 16), (17, 17), (18, 18), (19, 19), (20, 20), (21, 21), (22, 22), (23, 23), (24, 24), (25, 25), (26, 26), (27, 27), (28, 28), (29, 29), (30, 30), (31, 31), (32, 32), (33, 33), (34, 34), (35, 35), (36, 36), (37, 37), (38, 38), (39, 39), (40, 40), (41, 41), (42, 42), (43, 43), (44, 44), (45, 45), (46, 46), (47, 47), (48, 48), (49, 49), (50, 50), (51, 51), (52, 52), (53, 53), (54, 54), (55, 55), (56, 56), (57, 57), (58, 58), (59, 59), (60, 60), (61, 61), (62, 62), (63, 63), (64, 64), (65, 65), (66, 66), (67, 67), (68, 68), (69, 69), (70, 70), (71, 71), (72, 72), (73, 73), (74, 74), (75, 75), (76, 76), (77, 77), (78, 78), (79, 79), (80, 80), (81, 81), (82, 82), (83, 83), (84, 84), (85, 85), (86, 86), (87, 87), (88, 88), (89, 89), (90, 90), (91, 91), (92, 92), (93, 93), (94, 94), (95, 95), (96, 96), (97, 97), (98, 98), (99, 99), (5, 5), (NULL, NULL), (NULL, NULL), (NULL, NULL), (NULL, NULL) +-- +ok +== +SELECT * FROM integers WHERE i > 0 ORDER BY 1 +-- +ok +== +INSERT INTO integers VALUES (5, 5), (6, 6) +-- +ok +== +UPDATE integers SET i=4, j=100 WHERE i=1 +-- +ok +== +UPDATE integers SET i=100, j=4 WHERE j=1 +-- +ok +== +INSERT INTO integers VALUES (100, 100) +-- +ok +== diff --git a/parser/testdata/corpus/sql/constraints/unique/test_unique_string.test b/parser/testdata/corpus/sql/constraints/unique/test_unique_string.test new file mode 100644 index 0000000..2057a14 --- /dev/null +++ b/parser/testdata/corpus/sql/constraints/unique/test_unique_string.test @@ -0,0 +1,33 @@ +# source: test/sql/constraints/unique/test_unique_string.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +CREATE UNIQUE INDEX "uidx" ON "integers" ("j") +-- +ok +== +INSERT INTO integers VALUES (3, '4'), (2, '5') +-- +ok +== +INSERT INTO integers VALUES (6, '6'), (3, '4'); +-- +ok +== +INSERT INTO integers VALUES (6,NULL), (7,NULL) +-- +ok +== +UPDATE integers SET j='77' WHERE j IS NULL +-- +ok +== +UPDATE integers SET j='7777777777777777777777777777' WHERE j IS NULL AND i=6 +-- +ok +== +INSERT INTO integers VALUES (3, '4') +-- +ok +== diff --git a/parser/testdata/corpus/sql/constraints/unique/test_unique_temp.test b/parser/testdata/corpus/sql/constraints/unique/test_unique_temp.test new file mode 100644 index 0000000..2351b9b --- /dev/null +++ b/parser/testdata/corpus/sql/constraints/unique/test_unique_temp.test @@ -0,0 +1,9 @@ +# source: test/sql/constraints/unique/test_unique_temp.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +CREATE UNIQUE INDEX uidx ON integers (i) +-- +ok +== diff --git a/parser/testdata/corpus/sql/copy/async_file_lifecycle.test b/parser/testdata/corpus/sql/copy/async_file_lifecycle.test new file mode 100644 index 0000000..8a064f1 --- /dev/null +++ b/parser/testdata/corpus/sql/copy/async_file_lifecycle.test @@ -0,0 +1,88 @@ +# source: test/sql/copy/async_file_lifecycle.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +SET async_threads=2; +-- +ok +== +SET GLOBAL debug_fs_delay_mean_ms=1.0; +-- +ok +== +CREATE TABLE lifecycle AS +SELECT i, i % 3 AS p, repeat('x', 10) AS payload +FROM range(0, 4096) t(i); +-- +ok +== +COPY lifecycle TO '{TEST_DIR}/async_lifecycle_single.parquet' (FORMAT PARQUET, RETURN_FILES); +-- +ok +== +SELECT count(*) FROM read_parquet('{TEST_DIR}/async_lifecycle_single.parquet'); +-- +ok +== +COPY lifecycle TO '{TEST_DIR}/async_lifecycle_stats.parquet' (FORMAT PARQUET, RETURN_STATS); +-- +ok +== +COPY lifecycle TO '{TEST_DIR}/async_lifecycle_tmp.parquet' (FORMAT PARQUET, USE_TMP_FILE TRUE); +-- +ok +== +SELECT count(*) FROM read_parquet('{TEST_DIR}/async_lifecycle_tmp.parquet'); +-- +ok +== +COPY lifecycle TO '{TEST_DIR}/async_lifecycle_rotate' +(FORMAT PARQUET, ROW_GROUP_SIZE 1024, ROW_GROUPS_PER_FILE 1); +-- +ok +== +SELECT count(*) FROM read_parquet('{TEST_DIR}/async_lifecycle_rotate/*.parquet'); +-- +ok +== +SELECT count(*) > 1 FROM glob('{TEST_DIR}/async_lifecycle_rotate/*.parquet'); +-- +ok +== +COPY lifecycle TO '{TEST_DIR}/async_lifecycle_per_thread' (FORMAT PARQUET, PER_THREAD_OUTPUT TRUE); +-- +ok +== +SELECT count(*) FROM read_parquet('{TEST_DIR}/async_lifecycle_per_thread/*.parquet'); +-- +ok +== +SET partitioned_write_max_open_files=2; +-- +ok +== +COPY lifecycle TO '{TEST_DIR}/async_lifecycle_partitioned' (FORMAT PARQUET, PARTITION_BY (p)); +-- +ok +== +SELECT count(*) FROM read_parquet('{TEST_DIR}/async_lifecycle_partitioned/**/*.parquet', hive_partitioning=true); +-- +ok +== +SET async_threads=0; +-- +ok +== +COPY lifecycle TO '{TEST_DIR}/async_lifecycle_sync.parquet' (FORMAT PARQUET); +-- +ok +== +SELECT count(*) FROM read_parquet('{TEST_DIR}/async_lifecycle_sync.parquet'); +-- +ok +== +SET GLOBAL debug_fs_delay_mean_ms=0.0; +-- +ok +== diff --git a/parser/testdata/corpus/sql/copy/copy_blob.test b/parser/testdata/corpus/sql/copy/copy_blob.test new file mode 100644 index 0000000..4000e09 --- /dev/null +++ b/parser/testdata/corpus/sql/copy/copy_blob.test @@ -0,0 +1,41 @@ +# source: test/sql/copy/copy_blob.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +COPY (select 'foo') TO '{TEST_DIR}/test.blob' (FORMAT BLOB); +-- +ok +== +COPY (select 'foo'::BLOB, 10) TO '{TEST_DIR}/test.blob' (FORMAT BLOB); +-- +ok +== +COPY (select 'foo'::BLOB) TO '{TEST_DIR}/test.blob' (FORMAT BLOB); +-- +ok +== +select filename LIKE '%test.blob', content, size from read_blob('{TEST_DIR}/test.blob'); +-- +ok +== +COPY (select 'foo'::BLOB) TO '{TEST_DIR}/test.blob.gz' (FORMAT BLOB, ASDFGH); +-- +ok +== +COPY (select 'foo'::BLOB) TO '{TEST_DIR}/test.blob.gz' (FORMAT BLOB); +-- +ok +== +select filename LIKE '%test.blob.gz', size from read_blob('{TEST_DIR}/test.blob.gz'); +-- +ok +== +COPY (select 'foo'::BLOB) TO '{TEST_DIR}/test2.blob' (FORMAT BLOB, COMPRESSION 'GZIP'); +-- +ok +== +select filename LIKE '%test2.blob', size from read_blob('{TEST_DIR}/test2.blob'); +-- +ok +== diff --git a/parser/testdata/corpus/sql/copy/copy_cte.test b/parser/testdata/corpus/sql/copy/copy_cte.test new file mode 100644 index 0000000..ab95cd3 --- /dev/null +++ b/parser/testdata/corpus/sql/copy/copy_cte.test @@ -0,0 +1,138 @@ +# source: test/sql/copy/copy_cte.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +CREATE TABLE copy_cte_source (i INTEGER, s VARCHAR); +-- +ok +== +INSERT INTO copy_cte_source VALUES (1, 'one'), (2, 'two'), (3, 'three'); +-- +ok +== +COPY ( + WITH stats AS ( + COPY (SELECT * FROM copy_cte_source ORDER BY i) + TO '{TEST_DIR}/copy_cte_data.parquet' (FORMAT PARQUET, RETURN_STATS) + ) + SELECT filename, count FROM stats +) TO '{TEST_DIR}/copy_cte_stats.csv' (FORMAT CSV, HEADER); +-- +ok +== +SELECT filename LIKE '%copy_cte_data.parquet', count +FROM read_csv('{TEST_DIR}/copy_cte_stats.csv', HEADER = true, AUTO_DETECT = true); +-- +ok +== +SELECT * FROM read_parquet('{TEST_DIR}/copy_cte_data.parquet'); +-- +ok +== +WITH copied(rows_written) AS ( + COPY copy_cte_source TO '{TEST_DIR}/copy_cte_table.csv' (FORMAT CSV, HEADER) +) +SELECT rows_written FROM copied; +-- +ok +== +WITH copied AS ( + COPY (SELECT * FROM copy_cte_source) + TO '{TEST_DIR}/copy_cte_unreferenced.parquet' (FORMAT PARQUET) +) +SELECT 42; +-- +ok +== +SELECT count(*) FROM read_parquet('{TEST_DIR}/copy_cte_unreferenced.parquet'); +-- +ok +== +WITH copied AS ( + COPY (SELECT * FROM copy_cte_source) + TO '{TEST_DIR}/copy_cte_once.parquet' (FORMAT PARQUET) +) +SELECT lhs.Count, rhs.Count FROM copied lhs, copied rhs; +-- +ok +== +WITH first_copy AS ( + COPY copy_cte_source TO '{TEST_DIR}/copy_cte_first.csv' (FORMAT CSV) +), second_copy AS ( + COPY copy_cte_source TO '{TEST_DIR}/copy_cte_second.csv' (FORMAT CSV) +) +SELECT first_copy.Count, second_copy.Count +FROM first_copy, second_copy; +-- +ok +== +SELECT + (SELECT count(*) FROM glob('{TEST_DIR}/copy_cte_first.csv')), + (SELECT count(*) FROM glob('{TEST_DIR}/copy_cte_second.csv')); +-- +ok +== +WITH copied AS ( + COPY copy_cte_source TO '{TEST_DIR}/copy_cte_empty_consumer.csv' (FORMAT CSV) +) +SELECT 42 WHERE false; +-- +ok +== +SELECT count(*) FROM glob('{TEST_DIR}/copy_cte_empty_consumer.csv'); +-- +ok +== +WITH copied AS ( + COPY (SELECT * FROM copy_cte_source) + TO '{TEST_DIR}/copy_cte_return_files.parquet' (FORMAT PARQUET, RETURN_FILES) +) +SELECT Count, len(Files) FROM copied; +-- +ok +== +PREPARE copy_cte_prepared AS +WITH copied AS ( + COPY (SELECT * FROM copy_cte_source) + TO ($1) (FORMAT PARQUET, OVERWRITE) +) +SELECT * FROM copied; +-- +ok +== +EXECUTE copy_cte_prepared('{TEST_DIR}/copy_cte_prepared.parquet'); +-- +ok +== +WITH copied AS ( + COPY copy_cte_source FROM '{TEST_DIR}/copy_cte_table.csv' (FORMAT CSV, HEADER) +) +SELECT * FROM copied; +-- +error: Parser Error: COPY FROM cannot be used as a CTE body +== +WITH RECURSIVE copied AS ( + COPY copy_cte_source TO '{TEST_DIR}/copy_cte_recursive.csv' (FORMAT CSV) +) +SELECT * FROM copied; +-- +error: Parser Error: Recursive CTEs with COPY statements are not supported +== +SELECT * FROM ( + WITH copied AS ( + COPY copy_cte_source TO '{TEST_DIR}/copy_cte_nested.csv' (FORMAT CSV) + ) + SELECT * FROM copied +); +-- +ok +== +CREATE VIEW copy_cte_view AS +WITH copied AS ( + COPY copy_cte_source TO '{TEST_DIR}/copy_cte_view.csv' (FORMAT CSV) +) +SELECT * FROM copied; +-- +ok +== diff --git a/parser/testdata/corpus/sql/copy/copy_cte.test.metadata.json b/parser/testdata/corpus/sql/copy/copy_cte.test.metadata.json new file mode 100644 index 0000000..8181349 --- /dev/null +++ b/parser/testdata/corpus/sql/copy/copy_cte.test.metadata.json @@ -0,0 +1,6 @@ +{ + "todo": { + "33bee8e3be0a0dbb": "transformer-raised parser error: upstream rejects in the transformer, not the grammar; expected to clear as transformers land (milestones 3-5)", + "994308b4a109b147": "transformer-raised parser error: upstream rejects in the transformer, not the grammar; expected to clear as transformers land (milestones 3-5)" + } +} diff --git a/parser/testdata/corpus/sql/copy/csv/14512.test b/parser/testdata/corpus/sql/copy/csv/14512.test new file mode 100644 index 0000000..9b98f64 --- /dev/null +++ b/parser/testdata/corpus/sql/copy/csv/14512.test @@ -0,0 +1,21 @@ +# source: test/sql/copy/csv/14512.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +FROM read_csv('{DATA_DIR}/csv/14512.csv', strict_mode=TRUE); +-- +ok +== +select columns FROM sniff_csv('{DATA_DIR}/csv/14512.csv') +-- +ok +== +FROM read_csv('{DATA_DIR}/csv/14512_og.csv', strict_mode = false, delim = ',', quote = '"', escape = '"'); +-- +ok +== +select columns FROM sniff_csv('{DATA_DIR}/csv/14512_og.csv', strict_mode = false, delim = ',', quote = '"', escape = '"') +-- +ok +== diff --git a/parser/testdata/corpus/sql/copy/csv/14874.test b/parser/testdata/corpus/sql/copy/csv/14874.test new file mode 100644 index 0000000..f77e49b --- /dev/null +++ b/parser/testdata/corpus/sql/copy/csv/14874.test @@ -0,0 +1,13 @@ +# source: test/sql/copy/csv/14874.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +SELECT count(*) FROM read_csv('{DATA_DIR}/csv/drug_exposure.csv'); +-- +ok +== +SELECT * FROM read_csv('{DATA_DIR}/csv/drug_exposure.csv') ORDER BY ALL limit 5; +-- +ok +== diff --git a/parser/testdata/corpus/sql/copy/csv/17738.test b/parser/testdata/corpus/sql/copy/csv/17738.test new file mode 100644 index 0000000..611089a --- /dev/null +++ b/parser/testdata/corpus/sql/copy/csv/17738.test @@ -0,0 +1,21 @@ +# source: test/sql/copy/csv/17738.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +FROM read_csv('{DATA_DIR}/csv/17738_rn.csv',header=False,skip=3, delim = ';'); +-- +ok +== +FROM read_csv('{DATA_DIR}/csv/17738.csv',header=False,skip=3); +-- +ok +== +FROM read_csv('{DATA_DIR}/csv/17738.csv',header=False,skip=4); +-- +ok +== +FROM read_csv('{DATA_DIR}/csv/17738.csv',header=False,skip=7); +-- +ok +== diff --git a/parser/testdata/corpus/sql/copy/csv/17744.test b/parser/testdata/corpus/sql/copy/csv/17744.test new file mode 100644 index 0000000..066b359 --- /dev/null +++ b/parser/testdata/corpus/sql/copy/csv/17744.test @@ -0,0 +1,67 @@ +# source: test/sql/copy/csv/17744.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +COPY ( + SELECT + -- The string must start with a hash to reproduce the issue + '#hash start' AS first_column, + 1 AS second_column + UNION ALL + SELECT + -- Quoted value can go anywhere between rows 1 and 2048 just not 1 or 2048. It must be between the hashes + '"my, quoted value"' AS first_column, + 1 AS second_column + UNION ALL + -- These rows make the csv 2048 rows long which is required to reproduce + SELECT + 'any value' AS first_column, + 1 AS second_column + FROM range(0, 2045) + UNION ALL + SELECT + -- This hash value must be somewhere in the string just not at the beginning + 'hash not at start #' AS column_value, + 1 AS second_column +) TO '{TEST_DIR}/test.csv' (format csv, header 1); +-- +ok +== +SELECT columns, comment FROM sniff_csv('{TEST_DIR}/test.csv', null_padding = true) +-- +ok +== +SELECT columns, comment FROM sniff_csv('{TEST_DIR}/test.csv', null_padding = true, comment = '#') +-- +ok +== +COPY ( + SELECT + -- The string must start with a hash to reproduce the issue + '#hash start' AS first_column, + 1 AS second_column + UNION ALL + SELECT + -- Quoted value can go anywhere between rows 1 and 2048 just not 1 or 2048. It must be between the hashes + '"my, quoted value"' AS first_column, + 1 AS second_column + UNION ALL + -- These rows make the csv 2048 rows long which is required to reproduce + SELECT + 'any value' AS first_column, + 1 AS second_column + FROM range(0, 2045) + UNION ALL + SELECT + -- This hash value must be somewhere in the string just not at the beginning + 'hash not at start #' AS column_value, + 1 AS second_column +) TO '{TEST_DIR}/test_2.csv' (format csv, header 1, QUOTE ''); +-- +ok +== +SELECT columns, comment FROM sniff_csv('{TEST_DIR}/test_2.csv') +-- +ok +== diff --git a/parser/testdata/corpus/sql/copy/csv/18579.test b/parser/testdata/corpus/sql/copy/csv/18579.test new file mode 100644 index 0000000..22da003 --- /dev/null +++ b/parser/testdata/corpus/sql/copy/csv/18579.test @@ -0,0 +1,9 @@ +# source: test/sql/copy/csv/18579.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +DESCRIBE FROM read_csv('{DATA_DIR}/csv/18579/*.csv', union_by_name = true); +-- +ok +== diff --git a/parser/testdata/corpus/sql/copy/csv/19578.test b/parser/testdata/corpus/sql/copy/csv/19578.test new file mode 100644 index 0000000..e13f243 --- /dev/null +++ b/parser/testdata/corpus/sql/copy/csv/19578.test @@ -0,0 +1,13 @@ +# source: test/sql/copy/csv/19578.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +SELECT Delimiter, Quote, Escape FROM sniff_csv("data/19578.csv"); +-- +ok +== +SELECT Delimiter, Quote, Escape FROM sniff_csv("data/19578.csv", strict_mode=false); +-- +ok +== diff --git a/parser/testdata/corpus/sql/copy/csv/21248.test b/parser/testdata/corpus/sql/copy/csv/21248.test new file mode 100644 index 0000000..4fd3c72 --- /dev/null +++ b/parser/testdata/corpus/sql/copy/csv/21248.test @@ -0,0 +1,9 @@ +# source: test/sql/copy/csv/21248.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +SELECT * FROM read_csv(['data/csv/unionbyname_21248_*.csv'], union_by_name = true, ignore_errors = true, all_varchar = true); +-- +ok +== diff --git a/parser/testdata/corpus/sql/copy/csv/7702.test b/parser/testdata/corpus/sql/copy/csv/7702.test new file mode 100644 index 0000000..a915d06 --- /dev/null +++ b/parser/testdata/corpus/sql/copy/csv/7702.test @@ -0,0 +1,13 @@ +# source: test/sql/copy/csv/7702.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +SELECT count(*) FROM read_csv_auto( ['{DATA_DIR}/csv/error/mismatch/half1.csv', '{DATA_DIR}/csv/error/mismatch/half2.csv'], ignore_errors=true, sample_size=1); +-- +ok +== +SELECT count(*) FROM read_csv_auto( ['{DATA_DIR}/csv/error/mismatch/half2.csv', '{DATA_DIR}/csv/error/mismatch/half1.csv'], ignore_errors=true, sample_size=1); +-- +ok +== diff --git a/parser/testdata/corpus/sql/copy/csv/afl/fuzz_20250211_crash.test b/parser/testdata/corpus/sql/copy/csv/afl/fuzz_20250211_crash.test new file mode 100644 index 0000000..b057068 --- /dev/null +++ b/parser/testdata/corpus/sql/copy/csv/afl/fuzz_20250211_crash.test @@ -0,0 +1,9 @@ +# source: test/sql/copy/csv/afl/fuzz_20250211_crash.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +FROM read_csv('{DATA_DIR}/csv/afl/20250211_csv_fuzz_crash/case_53.csv', buffer_size=42); +-- +ok +== diff --git a/parser/testdata/corpus/sql/copy/csv/afl/fuzz_20250226.test b/parser/testdata/corpus/sql/copy/csv/afl/fuzz_20250226.test new file mode 100644 index 0000000..adb7afe --- /dev/null +++ b/parser/testdata/corpus/sql/copy/csv/afl/fuzz_20250226.test @@ -0,0 +1,13 @@ +# source: test/sql/copy/csv/afl/fuzz_20250226.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +select count(file) from glob('./data/csv/afl/20250226_csv_fuzz_error/*'); +-- +ok +== +FROM read_csv('{DATA_DIR}/csv/afl/20250226_csv_fuzz_error/case_1.csv', force_not_null=012%0, columns={'a':'JSON'}); +-- +ok +== diff --git a/parser/testdata/corpus/sql/copy/csv/afl/test_afl_ignore_errors.test b/parser/testdata/corpus/sql/copy/csv/afl/test_afl_ignore_errors.test new file mode 100644 index 0000000..0dd2e7f --- /dev/null +++ b/parser/testdata/corpus/sql/copy/csv/afl/test_afl_ignore_errors.test @@ -0,0 +1,9 @@ +# source: test/sql/copy/csv/afl/test_afl_ignore_errors.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +FROM read_csv('{DATA_DIR}/csv/afl/ignore_errors/{i}.csv', ignore_errors = true) +-- +ok +== diff --git a/parser/testdata/corpus/sql/copy/csv/afl/test_afl_no_parameter.test b/parser/testdata/corpus/sql/copy/csv/afl/test_afl_no_parameter.test new file mode 100644 index 0000000..a404db8 --- /dev/null +++ b/parser/testdata/corpus/sql/copy/csv/afl/test_afl_no_parameter.test @@ -0,0 +1,9 @@ +# source: test/sql/copy/csv/afl/test_afl_no_parameter.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +FROM '{DATA_DIR}/csv/afl/no_parameter/{i}.csv' +-- +ok +== diff --git a/parser/testdata/corpus/sql/copy/csv/afl/test_afl_null_padding.test b/parser/testdata/corpus/sql/copy/csv/afl/test_afl_null_padding.test new file mode 100644 index 0000000..786fd84 --- /dev/null +++ b/parser/testdata/corpus/sql/copy/csv/afl/test_afl_null_padding.test @@ -0,0 +1,9 @@ +# source: test/sql/copy/csv/afl/test_afl_null_padding.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +FROM read_csv('{DATA_DIR}/csv/afl/null_padding/{i}.csv', null_padding=true) +-- +ok +== diff --git a/parser/testdata/corpus/sql/copy/csv/afl/test_afl_skip.test b/parser/testdata/corpus/sql/copy/csv/afl/test_afl_skip.test new file mode 100644 index 0000000..e0690c1 --- /dev/null +++ b/parser/testdata/corpus/sql/copy/csv/afl/test_afl_skip.test @@ -0,0 +1,9 @@ +# source: test/sql/copy/csv/afl/test_afl_skip.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +FROM read_csv('{DATA_DIR}/csv/afl/skip/{i}.csv', skip=1) +-- +ok +== diff --git a/parser/testdata/corpus/sql/copy/csv/afl/test_fuzz_3977.test b/parser/testdata/corpus/sql/copy/csv/afl/test_fuzz_3977.test new file mode 100644 index 0000000..4951322 --- /dev/null +++ b/parser/testdata/corpus/sql/copy/csv/afl/test_fuzz_3977.test @@ -0,0 +1,361 @@ +# source: test/sql/copy/csv/afl/test_fuzz_3977.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +select count(file) from glob('./data/csv/afl/3977/*'); +-- +ok +== +FROM read_csv('{DATA_DIR}/csv/afl/3977/case_1.csv', rejects_scan=0, buffer_size=655371, all_varchar=false, rejects_scan=0, buffer_size=42); +-- +ok +== +FROM read_csv('{DATA_DIR}/csv/afl/3977/case_2.csv', names=['a','b','c','d'], store_rejects=true); +-- +ok +== +FROM read_csv('{DATA_DIR}/csv/afl/3977/case_3.csv', names=['a','b','c','d'], store_rejects=true); +-- +ok +== +FROM read_csv('{DATA_DIR}/csv/afl/3977/case_4.csv', names=['a','b','c','d'], store_rejects=true); +-- +ok +== +FROM read_csv('{DATA_DIR}/csv/afl/3977/case_5.csv', auto_detect=false, columns={'a': 'VARCHAR'}, escape='"', header=false, quote='"', strict_mode=true, store_rejects=true); +-- +ok +== +FROM read_csv('{DATA_DIR}/csv/afl/3977/case_6.csv', auto_detect=false, buffer_size=42, columns={'a':'INTEGER','b':'INTEGER', 'c':'VARCHAR'}, delim=';', rejects_table='"', strict_mode=true); +-- +ok +== +FROM read_csv('{DATA_DIR}/csv/afl/3977/case_7.csv', auto_detect=false, buffer_size=42, columns={'a':'INTEGER','b':'INTEGER', 'c':'VARCHAR'}, delim=';', rejects_table='"', strict_mode=true); +-- +ok +== +FROM read_csv('{DATA_DIR}/csv/afl/3977/case_8.csv', auto_detect=false, buffer_size=42, columns={'a':'INTEGER','b':'INTEGER', 'c':'VARCHAR'}, delim=';', rejects_table='"', strict_mode=true); +-- +ok +== +FROM read_csv('{DATA_DIR}/csv/afl/3977/case_9.csv', auto_detect=false, buffer_size=42, columns={'a':'INTEGER','b':'INTEGER', 'c':'VARCHAR'}, delim=';', rejects_table='"', strict_mode=false); +-- +ok +== +FROM read_csv('{DATA_DIR}/csv/afl/3977/case_10.csv', auto_detect=false, buffer_size=42, columns={'a':'INTEGER','b':'INTEGER', 'c':'VARCHAR'}, delim=';', rejects_table='"', strict_mode=true); +-- +ok +== +FROM read_csv('{DATA_DIR}/csv/afl/3977/case_11.csv', auto_detect=false, buffer_size=42, columns={'a':'INTEGER','b':'INTEGER', 'c':'VARCHAR'}, delim=';', rejects_table='"', strict_mode=true); +-- +ok +== +FROM read_csv('{DATA_DIR}/csv/afl/3977/case_12.csv', auto_detect=false, buffer_size=42, columns={'a':'INTEGER','b':'INTEGER', 'c':'VARCHAR'}, delim=';', rejects_table='"', strict_mode=true); +-- +ok +== +FROM read_csv('{DATA_DIR}/csv/afl/3977/case_13.csv', auto_detect=false, buffer_size=42, columns={'a':'INTEGER','b':'INTEGER', 'c':'VARCHAR'}, delim=';', rejects_table='"', strict_mode=true); +-- +ok +== +FROM read_csv('{DATA_DIR}/csv/afl/3977/case_14.csv', auto_detect=false, buffer_size=42, columns={'a':'INTEGER','b':'INTEGER', 'c':'VARCHAR'}, delim=';', rejects_table='"', strict_mode=true); +-- +ok +== +FROM read_csv('{DATA_DIR}/csv/afl/3977/case_15.csv', auto_detect=false, buffer_size=42, columns={'a':'INTEGER','b':'INTEGER', 'c':'VARCHAR'}, delim=';', rejects_table='"', strict_mode=true); +-- +ok +== +FROM read_csv('{DATA_DIR}/csv/afl/3977/case_16.csv', auto_detect=false, buffer_size=42, columns={'a':'INTEGER','b':'INTEGER', 'c':'VARCHAR'}, delim=';', rejects_table='"', strict_mode=true); +-- +ok +== +FROM read_csv('{DATA_DIR}/csv/afl/3977/case_17.csv', auto_detect=false, buffer_size=42, columns={'a':'INTEGER','b':'INTEGER', 'c':'VARCHAR'}, delim=';', rejects_table='"', strict_mode=true); +-- +ok +== +FROM read_csv('{DATA_DIR}/csv/afl/3977/case_18.csv', auto_detect=false, buffer_size=42, columns={'a':'INTEGER','b':'INTEGER', 'c':'VARCHAR'}, delim=';', rejects_table='"', strict_mode=true); +-- +ok +== +FROM read_csv('{DATA_DIR}/csv/afl/3977/case_19.csv', auto_detect=false, buffer_size=42, columns={'a':'INTEGER','b':'INTEGER', 'c':'VARCHAR'}, delim=';', rejects_table='"', strict_mode=true); +-- +ok +== +FROM read_csv('{DATA_DIR}/csv/afl/3977/case_20.csv', auto_detect=false, buffer_size=42, columns={'a':'INTEGER','b':'INTEGER', 'c':'VARCHAR'}, delim=';', rejects_table='"', strict_mode=true); +-- +ok +== +FROM read_csv('{DATA_DIR}/csv/afl/3977/case_21.csv', auto_detect=false, buffer_size=42, columns={'a':'INTEGER','b':'INTEGER', 'c':'VARCHAR'}, delim=';', rejects_table='"', strict_mode=true); +-- +ok +== +FROM read_csv('{DATA_DIR}/csv/afl/3977/case_22.csv', auto_detect=false, buffer_size=42, columns={'a':'INTEGER','b':'INTEGER', 'c':'VARCHAR'}, delim=';', rejects_table='"', strict_mode=true); +-- +ok +== +FROM read_csv('{DATA_DIR}/csv/afl/3977/case_23.csv', auto_detect=false, buffer_size=42, columns={'a':'INTEGER','b':'INTEGER', 'c':'VARCHAR'}, delim=';', rejects_table='"', strict_mode=true); +-- +ok +== +FROM read_csv('{DATA_DIR}/csv/afl/3977/case_24.csv', auto_detect=false, buffer_size=42, columns={'a':'INTEGER','b':'INTEGER', 'c':'VARCHAR'}, delim=';', rejects_table='"', strict_mode=true); +-- +ok +== +FROM read_csv('{DATA_DIR}/csv/afl/3977/case_25.csv', auto_detect=false, buffer_size=42, columns={'a':'INTEGER','b':'INTEGER', 'c':'VARCHAR'}, delim=';', rejects_table='"', strict_mode=true); +-- +ok +== +FROM read_csv('{DATA_DIR}/csv/afl/3977/case_26.csv', auto_detect=false, buffer_size=42, columns={'a':'INTEGER','b':'INTEGER', 'c':'VARCHAR'}, delim=';', rejects_table='"', strict_mode=true); +-- +ok +== +FROM read_csv('{DATA_DIR}/csv/afl/3977/case_27.csv', auto_detect=false, buffer_size=42, columns={'a':'INTEGER','b':'INTEGER', 'c':'VARCHAR'}, delim=';', rejects_table='"', strict_mode=true); +-- +ok +== +FROM read_csv('{DATA_DIR}/csv/afl/3977/case_28.csv', auto_detect=false, buffer_size=42, columns={'a':'INTEGER','b':'INTEGER', 'c':'VARCHAR'}, delim=';', rejects_table='"', strict_mode=true); +-- +ok +== +FROM read_csv('{DATA_DIR}/csv/afl/3977/case_29.csv', auto_detect=false, buffer_size=65536, columns={'a':'INTEGER','b':'INTEGER', 'c':'VARCHAR'}, delim=';', rejects_table='"', strict_mode=true); +-- +ok +== +FROM read_csv('{DATA_DIR}/csv/afl/3977/case_30.csv', auto_detect=false, buffer_size=42, columns={'a':'INTEGER','b':'INTEGER', 'c':'VARCHAR'}, delim=';', rejects_table='"', strict_mode=true); +-- +ok +== +FROM read_csv('{DATA_DIR}/csv/afl/3977/case_31.csv', auto_detect=false, buffer_size=42, columns={'a':'INTEGER','b':'INTEGER', 'c':'VARCHAR'}, delim=';', rejects_table='"', strict_mode=true); +-- +ok +== +FROM read_csv('{DATA_DIR}/csv/afl/3977/case_32.csv', auto_detect=false, buffer_size=42, columns={'a':'INTEGER','b':'INTEGER', 'c':'VARCHAR'}, delim=';', rejects_table='"', strict_mode=true); +-- +ok +== +FROM read_csv('{DATA_DIR}/csv/afl/3977/case_33.csv', auto_detect=false, buffer_size=42, columns={'a':'INTEGER','b':'INTEGER', 'c':'VARCHAR'}, delim=';', rejects_table='"', strict_mode=true); +-- +ok +== +FROM read_csv('{DATA_DIR}/csv/afl/3977/case_34.csv', auto_detect=false, buffer_size=42, columns={'a':'INTEGER','b':'INTEGER', 'c':'VARCHAR'}, delim=';', rejects_table='"', strict_mode=true); +-- +ok +== +FROM read_csv('{DATA_DIR}/csv/afl/3977/case_35.csv', auto_detect=false, buffer_size=42, columns={'a':'INTEGER','b':'INTEGER', 'c':'VARCHAR'}, delim=';', rejects_table='"', strict_mode=true); +-- +ok +== +FROM read_csv('{DATA_DIR}/csv/afl/3977/case_36.csv', auto_detect=false, buffer_size=42, columns={'a':'INTEGER','b':'INTEGER', 'c':'VARCHAR'}, delim=';', rejects_table='"', strict_mode=true); +-- +ok +== +FROM read_csv('{DATA_DIR}/csv/afl/3977/case_37.csv', auto_detect=false, buffer_size=42, columns={'a':'INTEGER','b':'INTEGER', 'c':'VARCHAR'}, delim=';', rejects_table='"', strict_mode=true); +-- +ok +== +FROM read_csv('{DATA_DIR}/csv/afl/3977/case_38.csv', auto_detect=false, buffer_size=42, columns={'a':'INTEGER','b':'INTEGER', 'c':'VARCHAR'}, delim=';', rejects_table='"', strict_mode=true); +-- +ok +== +FROM read_csv('{DATA_DIR}/csv/afl/3977/case_39.csv', auto_detect=false, buffer_size=42, columns={'a':'INTEGER','b':'INTEGER', 'c':'VARCHAR'}, delim=';', rejects_table='"', strict_mode=true); +-- +ok +== +FROM read_csv('{DATA_DIR}/csv/afl/3977/case_40.csv', auto_detect=false, buffer_size=42, columns={'a':'INTEGER','b':'INTEGER', 'c':'VARCHAR'}, comment=';', rejects_table='"', strict_mode=false); +-- +ok +== +FROM read_csv('{DATA_DIR}/csv/afl/3977/case_41.csv', auto_detect=false, buffer_size=42, columns={'a':'INTEGER','b':'INTEGER', 'c':'VARCHAR'}, delim=';', rejects_table='"', strict_mode=true); +-- +ok +== +FROM read_csv('{DATA_DIR}/csv/afl/3977/case_42.csv', auto_detect=false, buffer_size=42, columns={'a':'INTEGER','b':'INTEGER', 'c':'VARCHAR'}, delim=';', rejects_table='"', strict_mode=true); +-- +ok +== +FROM read_csv('{DATA_DIR}/csv/afl/3977/case_43.csv', auto_detect=false, buffer_size=42, columns={'a':'INTEGER','b':'INTEGER', 'c':'VARCHAR'}, delim=';', rejects_table='"', strict_mode=true); +-- +ok +== +FROM read_csv('{DATA_DIR}/csv/afl/3977/case_44.csv', auto_detect=false, buffer_size=42, columns={'a':'INTEGER','b':'INTEGER', 'c':'VARCHAR'}, delim=';', rejects_table='"', strict_mode=true); +-- +ok +== +FROM read_csv('{DATA_DIR}/csv/afl/3977/case_45.csv', auto_detect=false, buffer_size=810, columns={'a':'INTEGER','b':'INTEGER', 'c':'VARCHAR'}, delim=';', rejects_table='"', strict_mode=true); +-- +ok +== +FROM read_csv('{DATA_DIR}/csv/afl/3977/case_46.csv', auto_detect=false, buffer_size=42, columns={'a':'INTEGER','b':'INTEGER', 'c':'VARCHAR'}, delim=';', rejects_table='"', strict_mode=true); +-- +ok +== +FROM read_csv('{DATA_DIR}/csv/afl/3977/case_47.csv', auto_detect=false, buffer_size=42, columns={'a':'INTEGER','b':'INTEGER', 'c':'VARCHAR'}, delim=';', rejects_table='"', strict_mode=true); +-- +ok +== +FROM read_csv('{DATA_DIR}/csv/afl/3977/case_48.csv', auto_detect=false, buffer_size=42, columns={'a':'INTEGER','b':'INTEGER', 'c':'VARCHAR'}, delim=';', rejects_table='"', strict_mode=true); +-- +ok +== +FROM read_csv('{DATA_DIR}/csv/afl/3977/case_49.csv', auto_detect=false, buffer_size=42, columns={'a':'INTEGER','b':'INTEGER', 'c':'VARCHAR'}, delim=';', rejects_table='"', strict_mode=true); +-- +ok +== +FROM read_csv('{DATA_DIR}/csv/afl/3977/case_50.csv', auto_detect=false, buffer_size=42, columns={'a':'INTEGER','':'INTEGER', 'c':'VARCHAR'}, delim=';', rejects_table='"', strict_mode=true); +-- +ok +== +FROM read_csv('{DATA_DIR}/csv/afl/3977/case_51.csv', auto_detect=false, buffer_size=42, columns={'a':'INTEGER','b':'INTEGER', '|':'VARCHAR'}, delim=';', rejects_table='"', strict_mode=true); +-- +ok +== +FROM read_csv('{DATA_DIR}/csv/afl/3977/case_52.csv', auto_detect=false, buffer_size=42, columns={'a':'INTEGER','b':'INTEGER', 'c':'VARCHAR'}, delim=';', rejects_table='"', strict_mode=true); +-- +ok +== +FROM read_csv('{DATA_DIR}/csv/afl/3977/case_53.csv', auto_detect=false, buffer_size=42, columns={'a':'INTEGER','b':'INTEGER', 'c':'VARCHAR'}, delim=';', rejects_table='"', strict_mode=true); +-- +ok +== +FROM read_csv('{DATA_DIR}/csv/afl/3977/case_54.csv', auto_detect=false, buffer_size=42, columns={'a':'INTEGER','b':'INTEGER', 'c':'VARCHAr'}, delim=';', rejects_table='"', strict_mode=true); +-- +ok +== +FROM read_csv('{DATA_DIR}/csv/afl/3977/case_55.csv', auto_detect=false, buffer_size=42, columns={'a':'INTEGER','b':'INTEGER', 'c':'VARCHAR'}, delim=';', rejects_table='"', strict_mode=true); +-- +ok +== +FROM read_csv('{DATA_DIR}/csv/afl/3977/case_56.csv', auto_detect=false, buffer_size=42, columns={'a':'INTEGER','b':'INTEGER', 'c':'VARCHAR'}, delim=';', rejects_table='"', strict_mode=true); +-- +ok +== +FROM read_csv('{DATA_DIR}/csv/afl/3977/case_57.csv', auto_detect=false, buffer_size=42, columns={'a':'INTEGER','b':'INTEGER', 'c':'VARCHAR'}, delim=';', rejects_table='"', strict_mode=true); +-- +ok +== +FROM read_csv('{DATA_DIR}/csv/afl/3977/case_58.csv', auto_detect=false, buffer_size=42, columns={'a':'INTEGER','b':'INTEGER', 'c':'VARCHAR'}, delim=';', rejects_table='"', strict_mode=true); +-- +ok +== +FROM read_csv('{DATA_DIR}/csv/afl/3977/case_59.csv', auto_detect=false, buffer_size=42, columns={'a':'INTEGER','"':'INTEGER', 'c':'VARCHAR'}, delim=';', rejects_table='"', strict_mode=true); +-- +ok +== +FROM read_csv('{DATA_DIR}/csv/afl/3977/case_60.csv', auto_detect=false, buffer_size=42, columns={'a':'INTEGER','b':'INTEGER', 'c':'VARCHAR'}, delim=';', rejects_table='"', strict_mode=true); +-- +ok +== +FROM read_csv('{DATA_DIR}/csv/afl/3977/case_61.csv', auto_detect=false, buffer_size=42, columns={'a':'INTEGER','b':'INTEGER', 'c':'VARCHAR'}, delim=';', rejects_table='"', strict_mode=true); +-- +ok +== +FROM read_csv('{DATA_DIR}/csv/afl/3977/case_62.csv', auto_detect=false, buffer_size=42, columns={'a':'INTEGER','b':'INTEGER', 'c':'VARCHAR'}, delim=';', rejects_table='"', strict_mode=true); +-- +ok +== +FROM read_csv('{DATA_DIR}/csv/afl/3977/case_63.csv', auto_detect=false, buffer_size=42, columns={'a':'INTEGER','b':'INTEGER', 'c':'VARCHAR'}, delim=';', rejects_table='"', strict_mode=true); +-- +ok +== +FROM read_csv('{DATA_DIR}/csv/afl/3977/case_64.csv', auto_detect=false, buffer_size=42, columns={'a':'INTEGER','b':'INTEGER', 'c':'VARCHAR'}, delim=';', rejects_table='"', strict_mode=true); +-- +ok +== +FROM read_csv('{DATA_DIR}/csv/afl/3977/case_65.csv', auto_detect=false, buffer_size=42, columns={'a':'INTEGER','b':'INTEGER', 'c':'VARCHAR'}, delim=';', rejects_table='"', strict_mode=true); +-- +ok +== +FROM read_csv('{DATA_DIR}/csv/afl/3977/case_66.csv', auto_detect=false, buffer_size=42, columns={'a':'INTEGER','b':'INTEGER', 'c':'VARCHAR'}, delim=';', rejects_table='"', strict_mode=true); +-- +ok +== +FROM read_csv('{DATA_DIR}/csv/afl/3977/case_67.csv', auto_detect=false, buffer_size=42, columns={'a':'INTEGER','b':'INTEGER', 'c':'VARCHAR'}, delim=';', rejects_table='"', strict_mode=true); +-- +ok +== +FROM read_csv('{DATA_DIR}/csv/afl/3977/case_68.csv', auto_detect=false, buffer_size=42, columns={'a':'INTEGER','b':'INTEGER', 'c':'VARCHAR'}, delim=';', rejects_table='"', strict_mode=true); +-- +ok +== +FROM read_csv('{DATA_DIR}/csv/afl/3977/case_69.csv', auto_detect=false, buffer_size=42, columns={'a':'INTEGER','b':'INTEGER', 'c':'VARCHAR'}, delim=';', rejects_table='"', strict_mode=true); +-- +ok +== +FROM read_csv('{DATA_DIR}/csv/afl/3977/case_70.csv', auto_detect=false, buffer_size=42, columns={'a':'INTEGER','b':'INTEGER', 'c':'VARCHAR'}, delim=';', rejects_table='"', strict_mode=true); +-- +ok +== +FROM read_csv('{DATA_DIR}/csv/afl/3977/case_71.csv', auto_detect=false, buffer_size=16711722, columns={'a':'INTEGER','b':'INTEGER', 'c':'VARCHAR'}, delim=';', rejects_table='"', strict_mode=true); +-- +ok +== +FROM read_csv('{DATA_DIR}/csv/afl/3977/case_72.csv', auto_detect=false, buffer_size=42, columns={'a':'INTEGER','F':'INTEGER', 'c':'VARCHAR'}, delim=';', rejects_table='"', strict_mode=true); +-- +ok +== +FROM read_csv('{DATA_DIR}/csv/afl/3977/case_73.csv', auto_detect=false, buffer_size=42, columns={'a':'INTEGER','b':'INTEGER', 'c':'VARCHAR'}, delim=';', rejects_table='"', strict_mode=true); +-- +ok +== +FROM read_csv('{DATA_DIR}/csv/afl/3977/case_74.csv', auto_detect=false, buffer_size=42, columns={'a':'INTEGER','b':'INTEGER', 'c':'VARCHAR'}, delim=';', rejects_table='"', strict_mode=true); +-- +ok +== +FROM read_csv('{DATA_DIR}/csv/afl/3977/case_75.csv', auto_detect=false, buffer_size=42, columns={'a':'INTEGER','b':'INTEGER', 'c':'VARCHAR'}, delim=';', rejects_table='"', strict_mode=true); +-- +ok +== +FROM read_csv('{DATA_DIR}/csv/afl/3977/case_76.csv', auto_detect=false, buffer_size=42, columns={'a':'INTEGER','b':'INTEGER', 'c':'VARCHAR'}, delim=';', rejects_table='"', strict_mode=true); +-- +ok +== +FROM read_csv('{DATA_DIR}/csv/afl/3977/case_77.csv', auto_detect=false, buffer_size=42, columns={'a':'INTEGER','b':'INTEGER', 'c':'VARCHAR'}, delim=';', rejects_table='"', strict_mode=true); +-- +ok +== +FROM read_csv('{DATA_DIR}/csv/afl/3977/case_78.csv', auto_detect=false, buffer_size=42, columns={'a':'INTEGER','b':'INTEGER', 'c':'VARCHAR'}, delim=';', rejects_table='"', strict_mode=true); +-- +ok +== +FROM read_csv('{DATA_DIR}/csv/afl/3977/case_79.csv', auto_detect=false, buffer_size=42, columns={'a':'INTEGER','b':'INTEGER', 'c':'VARCHAR'}, delim=';', rejects_table='"', strict_mode=true); +-- +ok +== +FROM read_csv('{DATA_DIR}/csv/afl/3977/case_80.csv', auto_detect=false, buffer_size=42, columns={'a':'INTEGER','b':'INTEGER', 'c':'VARCHAR'}, delim=';', rejects_table='"', strict_mode=true); +-- +ok +== +FROM read_csv('{DATA_DIR}/csv/afl/3977/case_81.csv', auto_detect=false, buffer_size=42, columns={'a':'INTEGER','b':'INTEGER', 'c':'VARCHAR'}, delim=';', rejects_table='"', strict_mode=true); +-- +ok +== +FROM read_csv('{DATA_DIR}/csv/afl/3977/case_82.csv', auto_detect=false, buffer_size=42, columns={'a':'INTEGER','b':'INTEGER', 'c':'VARCHAR'}, delim=';', rejects_table='"', strict_mode=true); +-- +ok +== +FROM read_csv('{DATA_DIR}/csv/afl/3977/case_83.csv', auto_detect=false, parallel=false, columns={'a':'INTEGER','b':'INTEGER', 'c':'VARCHAR'}, delim=';', rejects_table='"', strict_mode=true); +-- +ok +== +FROM read_csv('{DATA_DIR}/csv/afl/3977/case_84.csv', auto_detect=false, buffer_size=42, columns={'a':'INTEGER','b':'INTEGER', 'c':'VARCHAR'}, delim=';', rejects_table='"', strict_mode=true); +-- +ok +== +FROM read_csv('{DATA_DIR}/csv/afl/3977/case_85.csv', auto_detect=false, buffer_size=42, columns={'a':'INTEGER','b':'INTEGER', 'c':'VARCHAR'}, delim=';', rejects_table='"', strict_mode=true); +-- +ok +== +FROM read_csv('{DATA_DIR}/csv/afl/3977/case_86.csv', auto_detect=false, buffer_size=720938, columns={'a':'INTEGER','b':'INTEGER', 'c':'VARCHAR'}, delim=';', rejects_table='"', strict_mode=true); +-- +ok +== +FROM read_csv('{DATA_DIR}/csv/afl/3977/case_87.csv', auto_detect=false, buffer_size=42, columns={'a2.0-22222222222222222.0222->>':'VARCHAR'}, delim=';', rejects_table='"', strict_mode=true); +-- +ok +== +FROM read_csv('{DATA_DIR}/csv/afl/3977/case_88.csv', auto_detect=false, buffer_size=42, columns={'a':'INTEGER','b':'INTEGER', 'c':'VARCHAR'}, delim=';', rejects_table='"', strict_mode=true); +-- +ok +== diff --git a/parser/testdata/corpus/sql/copy/csv/afl/test_fuzz_4086.test b/parser/testdata/corpus/sql/copy/csv/afl/test_fuzz_4086.test new file mode 100644 index 0000000..261dd75 --- /dev/null +++ b/parser/testdata/corpus/sql/copy/csv/afl/test_fuzz_4086.test @@ -0,0 +1,17 @@ +# source: test/sql/copy/csv/afl/test_fuzz_4086.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +FROM read_csv('{DATA_DIR}/csv/afl/4086/case_1.csv', auto_detect=false, columns={'json': 'JSON'}, delim=NULL, buffer_size=42, store_rejects=true, rejects_limit=658694493994253607); +-- +ok +== +FROM read_csv('{DATA_DIR}/csv/afl/4086/case_2.csv', auto_detect=false, columns={'json': 'JSON'}, delim=NULL, buffer_size=42, store_rejects=true, rejects_limit=658694493994253607); +-- +ok +== +FROM read_csv('{DATA_DIR}/csv/afl/4086/case_3.csv', auto_detect=false, columns={'json': 'JSON'}, delim='\0', buffer_size=42, store_rejects=true, rejects_limit=658694493994253607); +-- +ok +== diff --git a/parser/testdata/corpus/sql/copy/csv/afl/test_fuzz_4172.test b/parser/testdata/corpus/sql/copy/csv/afl/test_fuzz_4172.test new file mode 100644 index 0000000..6e15744 --- /dev/null +++ b/parser/testdata/corpus/sql/copy/csv/afl/test_fuzz_4172.test @@ -0,0 +1,9 @@ +# source: test/sql/copy/csv/afl/test_fuzz_4172.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +FROM read_csv('{DATA_DIR}/csv/afl/4172/case_4.csv', ignore_errors=true, buffer_size=1, store_rejects=false); +-- +ok +== diff --git a/parser/testdata/corpus/sql/copy/csv/afl/test_fuzz_4234.test b/parser/testdata/corpus/sql/copy/csv/afl/test_fuzz_4234.test new file mode 100644 index 0000000..bd5cc20 --- /dev/null +++ b/parser/testdata/corpus/sql/copy/csv/afl/test_fuzz_4234.test @@ -0,0 +1,9 @@ +# source: test/sql/copy/csv/afl/test_fuzz_4234.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +FROM read_csv('{DATA_DIR}/csv/afl/4234/test_fuzz_4234.csv', buffer_size=30, delim=';', header=false, null_padding=true, union_by_name=false); +-- +ok +== diff --git a/parser/testdata/corpus/sql/copy/csv/afl/test_fuzz_4329.test b/parser/testdata/corpus/sql/copy/csv/afl/test_fuzz_4329.test new file mode 100644 index 0000000..d255115 --- /dev/null +++ b/parser/testdata/corpus/sql/copy/csv/afl/test_fuzz_4329.test @@ -0,0 +1,9 @@ +# source: test/sql/copy/csv/afl/test_fuzz_4329.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +FROM read_csv('{DATA_DIR}/csv/afl/4329/case_1.csv', escape='\', buffer_size=42, skip=42, strict_mode=false); +-- +ok +== diff --git a/parser/testdata/corpus/sql/copy/csv/afl/test_fuzz_4379.test b/parser/testdata/corpus/sql/copy/csv/afl/test_fuzz_4379.test new file mode 100644 index 0000000..fbccdad --- /dev/null +++ b/parser/testdata/corpus/sql/copy/csv/afl/test_fuzz_4379.test @@ -0,0 +1,26 @@ +# source: test/sql/copy/csv/afl/test_fuzz_4379.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +COPY (SELECT * FROM (VALUES + ('date,datetime,time,timestamp,time_tz'), + ('not-a-date,not-a-datetime,not-a-time,not-a-timestamp') +) AS t(col)) TO '{TEST_DIR}/fuzz_4379.csv' (HEADER false, QUOTE ''); +-- +ok +== +FROM read_csv( + '{TEST_DIR}/fuzz_4379.csv', + columns={ + 'date': 'DATE', + 'datetime': 'TIMESTAMPTZ', + 'time': 'TIME', + 'timestamp': 'TIMESTAMP', + 'time_tz': 'TIMETZ' + }, + null_padding=true, + store_rejects=true); +-- +ok +== diff --git a/parser/testdata/corpus/sql/copy/csv/afl/test_fuzz_4496.test b/parser/testdata/corpus/sql/copy/csv/afl/test_fuzz_4496.test new file mode 100644 index 0000000..de2bcad --- /dev/null +++ b/parser/testdata/corpus/sql/copy/csv/afl/test_fuzz_4496.test @@ -0,0 +1,13 @@ +# source: test/sql/copy/csv/afl/test_fuzz_4496.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +FROM read_csv('{DATA_DIR}/csv/afl/4496/crashes/case_0.csv', auto_detect=false, buffer_size=42, columns={'json': 'JSON'}, delim=NULL, rejects_limit=658694493994253607, store_rejects=true); +-- +ok +== +FROM read_csv('{DATA_DIR}/csv/afl/4496/crashes/case_1.csv', auto_detect=false, buffer_size=42, columns={'json': 'JSON'}, delim=NULL, rejects_limit=658694493994253607, store_rejects=true); +-- +ok +== diff --git a/parser/testdata/corpus/sql/copy/csv/afl/test_fuzz_4793.test b/parser/testdata/corpus/sql/copy/csv/afl/test_fuzz_4793.test new file mode 100644 index 0000000..483714c --- /dev/null +++ b/parser/testdata/corpus/sql/copy/csv/afl/test_fuzz_4793.test @@ -0,0 +1,13 @@ +# source: test/sql/copy/csv/afl/test_fuzz_4793.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +FROM read_csv('{DATA_DIR}/csv/afl/4793/crashes/case_0.csv', auto_detect=false, columns={'a':'varchar'}, delim='', encoding='latin-1', header=false, quote=''); +-- +ok +== +FROM read_csv('{DATA_DIR}/csv/afl/4793/crashes/case_1.csv', auto_detect=false, buffer_size=42, columns={'a':'INTEGER','b':'INTEGER', 'c':'VARCHAR'}, delim=';', escape='"', quote='"'); +-- +ok +== diff --git a/parser/testdata/corpus/sql/copy/csv/afl/test_fuzz_5194.test b/parser/testdata/corpus/sql/copy/csv/afl/test_fuzz_5194.test new file mode 100644 index 0000000..22fdb8d --- /dev/null +++ b/parser/testdata/corpus/sql/copy/csv/afl/test_fuzz_5194.test @@ -0,0 +1,13 @@ +# source: test/sql/copy/csv/afl/test_fuzz_5194.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +FROM read_csv('{DATA_DIR}/csv/afl/5194/crashes/case_0.csv', auto_detect=false, buffer_size=8, columns={'a': 'integer','b': 'integer','c': 'integer'}, header=true, maximum_line_size=0); +-- +ok +== +FROM read_csv('{DATA_DIR}/csv/afl/5194/crashes/case_4.csv', buffer_size=30, delim=';', union_by_name=false, header=false, null_padding=true); +-- +ok +== diff --git a/parser/testdata/corpus/sql/copy/csv/allow_empty.test b/parser/testdata/corpus/sql/copy/csv/allow_empty.test new file mode 100644 index 0000000..18bb45d --- /dev/null +++ b/parser/testdata/corpus/sql/copy/csv/allow_empty.test @@ -0,0 +1,36 @@ +# source: test/sql/copy/csv/allow_empty.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +SELECT * FROM read_csv('{TEST_DIR}/allow_empty_missing.csv'); +-- +ok +== +SELECT column_name, column_type +FROM (DESCRIBE SELECT * FROM read_csv('{TEST_DIR}/allow_empty_missing.csv', allow_empty = true)); +-- +ok +== +SELECT count(*) FROM read_csv('{TEST_DIR}/allow_empty_missing.csv', allow_empty = true); +-- +ok +== +CREATE TABLE allow_empty_source(id INTEGER, payload VARCHAR); +-- +ok +== +INSERT INTO allow_empty_source VALUES (1, 'first row'), (2, 'second row'); +-- +ok +== +COPY allow_empty_source TO '{TEST_DIR}/allow_empty.csv' (FORMAT CSV, HEADER TRUE); +-- +ok +== +SELECT * +FROM read_csv('{TEST_DIR}/allow_empty.csv', header = true, columns = {'id': 'INTEGER', 'payload': 'VARCHAR'}, allow_empty = true) +ORDER BY id; +-- +ok +== diff --git a/parser/testdata/corpus/sql/copy/csv/auto/test_14177.test b/parser/testdata/corpus/sql/copy/csv/auto/test_14177.test new file mode 100644 index 0000000..15c8288 --- /dev/null +++ b/parser/testdata/corpus/sql/copy/csv/auto/test_14177.test @@ -0,0 +1,9 @@ +# source: test/sql/copy/csv/auto/test_14177.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +select count(*) FROM (FROM read_csv('{DATA_DIR}/csv/auto/14177.csv', buffer_size=80, ignore_errors = true)) as t +-- +ok +== diff --git a/parser/testdata/corpus/sql/copy/csv/auto/test_auto_5250.test b/parser/testdata/corpus/sql/copy/csv/auto/test_auto_5250.test new file mode 100644 index 0000000..dec82be --- /dev/null +++ b/parser/testdata/corpus/sql/copy/csv/auto/test_auto_5250.test @@ -0,0 +1,9 @@ +# source: test/sql/copy/csv/auto/test_auto_5250.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +select count(*) from read_csv_auto('{DATA_DIR}/csv/page_namespacepage_title_sample.csv', SAMPLE_SIZE = -1) +-- +ok +== diff --git a/parser/testdata/corpus/sql/copy/csv/auto/test_auto_5378.test b/parser/testdata/corpus/sql/copy/csv/auto/test_auto_5378.test new file mode 100644 index 0000000..6f7475d --- /dev/null +++ b/parser/testdata/corpus/sql/copy/csv/auto/test_auto_5378.test @@ -0,0 +1,9 @@ +# source: test/sql/copy/csv/auto/test_auto_5378.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +SELECT count(*) FROM read_csv_auto ('{DATA_DIR}/csv/auto/titlebasicsdebug.tsv', nullstr='\N', sample_size = -1); +-- +ok +== diff --git a/parser/testdata/corpus/sql/copy/csv/auto/test_auto_8231.test b/parser/testdata/corpus/sql/copy/csv/auto/test_auto_8231.test new file mode 100644 index 0000000..dcefd0f --- /dev/null +++ b/parser/testdata/corpus/sql/copy/csv/auto/test_auto_8231.test @@ -0,0 +1,17 @@ +# source: test/sql/copy/csv/auto/test_auto_8231.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +create view locations_header_trailing_comma as SELECT * from read_csv_auto('{DATA_DIR}/csv/locations_row_trailing_comma.csv', null_padding=True) +-- +ok +== +SELECT * from locations_header_trailing_comma +-- +ok +== +describe locations_header_trailing_comma; +-- +ok +== diff --git a/parser/testdata/corpus/sql/copy/csv/auto/test_auto_8573.test b/parser/testdata/corpus/sql/copy/csv/auto/test_auto_8573.test new file mode 100644 index 0000000..fa7f036 --- /dev/null +++ b/parser/testdata/corpus/sql/copy/csv/auto/test_auto_8573.test @@ -0,0 +1,13 @@ +# source: test/sql/copy/csv/auto/test_auto_8573.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +SELECT typeof(bignumber), typeof(bignumber::DECIMAL(25,3)) FROM read_csv('{DATA_DIR}/csv/big_number.csv', COLUMNS={'bignumber': 'DECIMAL(25,3)'}, QUOTE='"', DELIM=','); +-- +ok +== +SELECT typeof(bignumber), typeof(bignumber::DECIMAL(25,3)) FROM read_csv_auto('{DATA_DIR}/csv/big_number.csv', COLUMNS={'bignumber': 'DECIMAL(25,3)'}, QUOTE='"', DELIM=','); +-- +ok +== diff --git a/parser/testdata/corpus/sql/copy/csv/auto/test_auto_8649.test b/parser/testdata/corpus/sql/copy/csv/auto/test_auto_8649.test new file mode 100644 index 0000000..780a3a1 --- /dev/null +++ b/parser/testdata/corpus/sql/copy/csv/auto/test_auto_8649.test @@ -0,0 +1,9 @@ +# source: test/sql/copy/csv/auto/test_auto_8649.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +SELECT * FROM read_csv_auto("{DATA_DIR}/csv/dim0.csv") ; +-- +ok +== diff --git a/parser/testdata/corpus/sql/copy/csv/auto/test_auto_8860.test b/parser/testdata/corpus/sql/copy/csv/auto/test_auto_8860.test new file mode 100644 index 0000000..b6b423d --- /dev/null +++ b/parser/testdata/corpus/sql/copy/csv/auto/test_auto_8860.test @@ -0,0 +1,9 @@ +# source: test/sql/copy/csv/auto/test_auto_8860.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +SELECT count(*) FROM read_csv_auto("{DATA_DIR}/csv/auto/product_codes_HS17_V202301.csv.gz", quote = '"', comment='', delim = ',') ; +-- +ok +== diff --git a/parser/testdata/corpus/sql/copy/csv/auto/test_auto_column_type_opt.test b/parser/testdata/corpus/sql/copy/csv/auto/test_auto_column_type_opt.test new file mode 100644 index 0000000..f6aadca --- /dev/null +++ b/parser/testdata/corpus/sql/copy/csv/auto/test_auto_column_type_opt.test @@ -0,0 +1,49 @@ +# source: test/sql/copy/csv/auto/test_auto_column_type_opt.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +select * from read_csv('{DATA_DIR}/csv/test/multi_column_string.csv', COLUMN_TYPES=STRUCT_PACK(a := 'INTEGER')) +-- +ok +== +select * from read_csv_auto('{DATA_DIR}/csv/test/multi_column_string.csv', COLUMN_TYPES=1) +-- +ok +== +select * from read_csv_auto('{DATA_DIR}/csv/test/multi_column_string.csv', COLUMN_TYPES=STRUCT_PACK()) +-- +ok +== +select * from read_csv_auto('{DATA_DIR}/csv/test/multi_column_string.csv', COLUMN_TYPES=STRUCT_PACK(a := 'BLA')) +-- +ok +== +select * from read_csv_auto('{DATA_DIR}/csv/test/multi_column_string.csv', COLUMN_TYPES=STRUCT_PACK(bla := 'INTEGER')) +-- +ok +== +select * from read_csv_auto('{DATA_DIR}/csv/test/multi_column_string.csv', COLUMN_TYPES=STRUCT_PACK(column3 := 'INTEGER')) +-- +ok +== +SELECT typeof(#1) from read_csv_auto('{DATA_DIR}/csv/test/multi_column_string.csv', COLUMN_TYPES=STRUCT_PACK(column0 := 'DOUBLE')) LIMIT 1 +-- +ok +== +SELECT typeof(#1) from read_csv_auto('{DATA_DIR}/csv/test/multi_column_string.csv', COLUMN_TYPES=STRUCT_PACK(column0 := 'INTEGER')) LIMIT 1 +-- +ok +== +SELECT typeof(#3) from read_csv_auto('{DATA_DIR}/csv/test/multi_column_string.csv', COLUMN_TYPES=STRUCT_PACK( column2 := 'HUGEINT')) LIMIT 1 +-- +ok +== +SELECT typeof(#1),typeof(#3) from read_csv_auto('{DATA_DIR}/csv/test/multi_column_string.csv', COLUMN_TYPES=STRUCT_PACK(column0 := 'BIGINT', column2 := 'HUGEINT')) LIMIT 1 +-- +ok +== +SELECT * from read_csv_auto('{DATA_DIR}/csv/test/multi_column_string.csv', COLUMN_TYPES=STRUCT_PACK(column0 := 'BIGINT', column2 := 'HUGEINT')) +-- +ok +== diff --git a/parser/testdata/corpus/sql/copy/csv/auto/test_auto_cranlogs.test b/parser/testdata/corpus/sql/copy/csv/auto/test_auto_cranlogs.test new file mode 100644 index 0000000..c8444b2 --- /dev/null +++ b/parser/testdata/corpus/sql/copy/csv/auto/test_auto_cranlogs.test @@ -0,0 +1,27 @@ +# source: test/sql/copy/csv/auto/test_auto_cranlogs.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +CREATE TABLE cranlogs AS SELECT * FROM read_csv_auto ('{DATA_DIR}/csv/real/tmp2013-06-15.csv.gz'); +-- +ok +== +SELECT COUNT(*) FROM cranlogs; +-- +ok +== +SELECT * FROM cranlogs LIMIT 5; +-- +ok +== +CREATE TABLE cranlogs2 AS SELECT * FROM read_csv_auto ('{DATA_DIR}/csv/real/tmp2013-06-15.csv.gz'); +-- +ok +== +(SELECT * FROM cranlogs EXCEPT SELECT * FROM cranlogs2) +UNION ALL +(SELECT * FROM cranlogs2 EXCEPT SELECT * FROM cranlogs) +-- +ok +== diff --git a/parser/testdata/corpus/sql/copy/csv/auto/test_auto_greek_ncvoter.test b/parser/testdata/corpus/sql/copy/csv/auto/test_auto_greek_ncvoter.test new file mode 100644 index 0000000..8a404a1 --- /dev/null +++ b/parser/testdata/corpus/sql/copy/csv/auto/test_auto_greek_ncvoter.test @@ -0,0 +1,31 @@ +# source: test/sql/copy/csv/auto/test_auto_greek_ncvoter.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +CREATE TABLE IF NOT EXISTS ncvoters(county_id INTEGER, county_desc STRING, voter_reg_num STRING,status_cd STRING, voter_status_desc STRING, reason_cd STRING, voter_status_reason_desc STRING, absent_ind STRING, name_prefx_cd STRING,last_name STRING, first_name STRING, midl_name STRING, name_sufx_cd STRING, full_name_rep STRING,full_name_mail STRING, house_num STRING, half_code STRING, street_dir STRING, street_name STRING, street_type_cd STRING, street_sufx_cd STRING, unit_designator STRING, unit_num STRING, res_city_desc STRING,state_cd STRING, zip_code STRING, res_street_address STRING, res_city_state_zip STRING, mail_addr1 STRING, mail_addr2 STRING, mail_addr3 STRING, mail_addr4 STRING, mail_city STRING, mail_state STRING, mail_zipcode STRING, mail_city_state_zip STRING, area_cd STRING, phone_num STRING, full_phone_number STRING, drivers_lic STRING, race_code STRING, race_desc STRING, ethnic_code STRING, ethnic_desc STRING, party_cd STRING, party_desc STRING, sex_code STRING, sex STRING, birth_age STRING, birth_place STRING, registr_dt STRING, precinct_abbrv STRING, precinct_desc STRING,municipality_abbrv STRING, municipality_desc STRING, ward_abbrv STRING, ward_desc STRING, cong_dist_abbrv STRING, cong_dist_desc STRING, super_court_abbrv STRING, super_court_desc STRING, judic_dist_abbrv STRING, judic_dist_desc STRING, nc_senate_abbrv STRING, nc_senate_desc STRING, nc_house_abbrv STRING, nc_house_desc STRING,county_commiss_abbrv STRING, county_commiss_desc STRING, township_abbrv STRING, township_desc STRING,school_dist_abbrv STRING, school_dist_desc STRING, fire_dist_abbrv STRING, fire_dist_desc STRING, water_dist_abbrv STRING, water_dist_desc STRING, sewer_dist_abbrv STRING, sewer_dist_desc STRING, sanit_dist_abbrv STRING, sanit_dist_desc STRING, rescue_dist_abbrv STRING, rescue_dist_desc STRING, munic_dist_abbrv STRING, munic_dist_desc STRING, dist_1_abbrv STRING, dist_1_desc STRING, dist_2_abbrv STRING, dist_2_desc STRING, confidential_ind STRING, age STRING, ncid STRING, vtd_abbrv STRING, vtd_desc STRING); +-- +ok +== +COPY ncvoters FROM '{DATA_DIR}/csv/real/ncvoter.csv' (FORMAT CSV, AUTO_DETECT TRUE); +-- +ok +== +SELECT county_id, county_desc, vtd_desc, name_prefx_cd FROM ncvoters; +-- +ok +== +CREATE TABLE ncvoters2 AS SELECT * FROM ncvoters LIMIT 0 +-- +ok +== +COPY ncvoters2 FROM '{DATA_DIR}/csv/real/ncvoter.csv' (FORMAT CSV, AUTO_DETECT TRUE); +-- +ok +== +(SELECT * FROM ncvoters EXCEPT SELECT * FROM ncvoters2) +UNION ALL +(SELECT * FROM ncvoters2 EXCEPT SELECT * FROM ncvoters) +-- +ok +== diff --git a/parser/testdata/corpus/sql/copy/csv/auto/test_auto_greek_utf8.test b/parser/testdata/corpus/sql/copy/csv/auto/test_auto_greek_utf8.test new file mode 100644 index 0000000..17fba7e --- /dev/null +++ b/parser/testdata/corpus/sql/copy/csv/auto/test_auto_greek_utf8.test @@ -0,0 +1,21 @@ +# source: test/sql/copy/csv/auto/test_auto_greek_utf8.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +CREATE TABLE greek_utf8 AS SELECT i, nfc_normalize(j) j, k FROM read_csv_auto ('{DATA_DIR}/csv/real/greek_utf8.csv') t(i, j, k) +-- +ok +== +SELECT COUNT(*) FROM greek_utf8; +-- +ok +== +SELECT * FROM greek_utf8 ORDER BY 1; +-- +ok +== +SELECT i, nfc_normalize(j) j, k FROM '{DATA_DIR}/csv/real/greek_utf8.csv' t(i, j, k) +-- +ok +== diff --git a/parser/testdata/corpus/sql/copy/csv/auto/test_auto_imdb.test b/parser/testdata/corpus/sql/copy/csv/auto/test_auto_imdb.test new file mode 100644 index 0000000..993c458 --- /dev/null +++ b/parser/testdata/corpus/sql/copy/csv/auto/test_auto_imdb.test @@ -0,0 +1,23 @@ +# source: test/sql/copy/csv/auto/test_auto_imdb.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +CREATE TABLE movie_info AS SELECT * FROM read_csv_auto ('{DATA_DIR}/csv/real/imdb_movie_info_escaped.csv'); +-- +ok +== +SELECT COUNT(*) FROM movie_info; +-- +ok +== +CREATE TABLE movie_info2 AS SELECT * FROM read_csv_auto ('{DATA_DIR}/csv/real/imdb_movie_info_escaped.csv'); +-- +ok +== +(FROM movie_info EXCEPT FROM movie_info2) +UNION ALL +(FROM movie_info2 EXCEPT FROM movie_info) +-- +ok +== diff --git a/parser/testdata/corpus/sql/copy/csv/auto/test_auto_lineitem.test b/parser/testdata/corpus/sql/copy/csv/auto/test_auto_lineitem.test new file mode 100644 index 0000000..4e2e925 --- /dev/null +++ b/parser/testdata/corpus/sql/copy/csv/auto/test_auto_lineitem.test @@ -0,0 +1,35 @@ +# source: test/sql/copy/csv/auto/test_auto_lineitem.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +CREATE TABLE lineitem(l_orderkey INT NOT NULL, l_partkey INT NOT NULL, l_suppkey INT NOT NULL, l_linenumber INT NOT NULL, l_quantity INTEGER NOT NULL, l_extendedprice DECIMAL(15,2) NOT NULL, l_discount DECIMAL(15,2) NOT NULL, l_tax DECIMAL(15,2) NOT NULL, l_returnflag VARCHAR(1) NOT NULL, l_linestatus VARCHAR(1) NOT NULL, l_shipdate DATE NOT NULL, l_commitdate DATE NOT NULL, l_receiptdate DATE NOT NULL, l_shipinstruct VARCHAR(25) NOT NULL, l_shipmode VARCHAR(10) NOT NULL, l_comment VARCHAR(44) NOT NULL); +-- +ok +== +COPY lineitem FROM '{DATA_DIR}/csv/real/lineitem_sample.csv' (FORMAT CSV, AUTO_DETECT TRUE); +-- +ok +== +SELECT COUNT(*) FROM lineitem; +-- +ok +== +SELECT l_partkey, l_comment FROM lineitem WHERE l_orderkey=1 ORDER BY l_linenumber; +-- +ok +== +CREATE TABLE lineitem2 AS SELECT * FROM lineitem LIMIT 0 +-- +ok +== +COPY lineitem2 FROM '{DATA_DIR}/csv/real/lineitem_sample.csv' (FORMAT CSV, AUTO_DETECT TRUE); +-- +ok +== +(SELECT * FROM lineitem EXCEPT SELECT * FROM lineitem2) +UNION ALL +(SELECT * FROM lineitem2 EXCEPT SELECT * FROM lineitem) +-- +ok +== diff --git a/parser/testdata/corpus/sql/copy/csv/auto/test_auto_ontime.test b/parser/testdata/corpus/sql/copy/csv/auto/test_auto_ontime.test new file mode 100644 index 0000000..74f764d --- /dev/null +++ b/parser/testdata/corpus/sql/copy/csv/auto/test_auto_ontime.test @@ -0,0 +1,31 @@ +# source: test/sql/copy/csv/auto/test_auto_ontime.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +CREATE TABLE ontime(year SMALLINT, quarter SMALLINT, month SMALLINT, dayofmonth SMALLINT, dayofweek SMALLINT, flightdate DATE, uniquecarrier CHAR(7), airlineid DECIMAL(8,2), carrier CHAR(2), tailnum VARCHAR(50), flightnum VARCHAR(10), originairportid INTEGER, originairportseqid INTEGER, origincitymarketid INTEGER, origin CHAR(5), origincityname VARCHAR(100), originstate CHAR(2), originstatefips VARCHAR(10), originstatename VARCHAR(100), originwac DECIMAL(8,2), destairportid INTEGER, destairportseqid INTEGER, destcitymarketid INTEGER, dest CHAR(5), destcityname VARCHAR(100), deststate CHAR(2), deststatefips VARCHAR(10), deststatename VARCHAR(100), destwac DECIMAL(8,2), crsdeptime DECIMAL(8,2), deptime DECIMAL(8,2), depdelay DECIMAL(8,2), depdelayminutes DECIMAL(8,2), depdel15 DECIMAL(8,2), departuredelaygroups DECIMAL(8,2), deptimeblk VARCHAR(20), taxiout DECIMAL(8,2), wheelsoff DECIMAL(8,2), wheelson DECIMAL(8,2), taxiin DECIMAL(8,2), crsarrtime DECIMAL(8,2), arrtime DECIMAL(8,2), arrdelay DECIMAL(8,2), arrdelayminutes DECIMAL(8,2), arrdel15 DECIMAL(8,2), arrivaldelaygroups DECIMAL(8,2), arrtimeblk VARCHAR(20), cancelled DECIMAL(8,2), cancellationcode CHAR(1), diverted DECIMAL(8,2), crselapsedtime DECIMAL(8,2), actualelapsedtime DECIMAL(8,2), airtime DECIMAL(8,2), flights DECIMAL(8,2), distance DECIMAL(8,2), distancegroup DECIMAL(8,2), carrierdelay DECIMAL(8,2), weatherdelay DECIMAL(8,2), nasdelay DECIMAL(8,2), securitydelay DECIMAL(8,2), lateaircraftdelay DECIMAL(8,2), firstdeptime VARCHAR(10), totaladdgtime VARCHAR(10), longestaddgtime VARCHAR(10), divairportlandings VARCHAR(10), divreacheddest VARCHAR(10), divactualelapsedtime VARCHAR(10), divarrdelay VARCHAR(10), divdistance VARCHAR(10), div1airport VARCHAR(10), div1aiportid INTEGER, div1airportseqid INTEGER, div1wheelson VARCHAR(10), div1totalgtime VARCHAR(10), div1longestgtime VARCHAR(10), div1wheelsoff VARCHAR(10), div1tailnum VARCHAR(10), div2airport VARCHAR(10), div2airportid INTEGER, div2airportseqid INTEGER, div2wheelson VARCHAR(10), div2totalgtime VARCHAR(10), div2longestgtime VARCHAR(10), div2wheelsoff VARCHAR(10), div2tailnum VARCHAR(10), div3airport VARCHAR(10), div3airportid INTEGER, div3airportseqid INTEGER, div3wheelson VARCHAR(10), div3totalgtime VARCHAR(10), div3longestgtime VARCHAR(10), div3wheelsoff VARCHAR(10), div3tailnum VARCHAR(10), div4airport VARCHAR(10), div4airportid INTEGER, div4airportseqid INTEGER, div4wheelson VARCHAR(10), div4totalgtime VARCHAR(10), div4longestgtime VARCHAR(10), div4wheelsoff VARCHAR(10), div4tailnum VARCHAR(10), div5airport VARCHAR(10), div5airportid INTEGER, div5airportseqid INTEGER, div5wheelson VARCHAR(10), div5totalgtime VARCHAR(10), div5longestgtime VARCHAR(10), div5wheelsoff VARCHAR(10), div5tailnum VARCHAR(10)); +-- +ok +== +COPY ontime FROM '{DATA_DIR}/csv/real/ontime_sample.csv'; +-- +ok +== +SELECT year, uniquecarrier, origin, origincityname, div5longestgtime FROM ontime; +-- +ok +== +CREATE TABLE ontime2 AS SELECT * FROM ontime LIMIT 0 +-- +ok +== +COPY ontime2 FROM '{DATA_DIR}/csv/real/ontime_sample.csv'; +-- +ok +== +(SELECT * FROM ontime EXCEPT SELECT * FROM ontime2) +UNION ALL +(SELECT * FROM ontime2 EXCEPT SELECT * FROM ontime) +-- +ok +== diff --git a/parser/testdata/corpus/sql/copy/csv/auto/test_auto_web_page.test b/parser/testdata/corpus/sql/copy/csv/auto/test_auto_web_page.test new file mode 100644 index 0000000..32cf29a --- /dev/null +++ b/parser/testdata/corpus/sql/copy/csv/auto/test_auto_web_page.test @@ -0,0 +1,27 @@ +# source: test/sql/copy/csv/auto/test_auto_web_page.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +CREATE TABLE web_page AS SELECT * FROM read_csv_auto ('{DATA_DIR}/csv/real/web_page.csv'); +-- +ok +== +SELECT COUNT(*) FROM web_page; +-- +ok +== +SELECT * FROM web_page ORDER BY column00 LIMIT 3; +-- +ok +== +CREATE TABLE web_page2 AS SELECT * FROM read_csv_auto ('{DATA_DIR}/csv/real/web_page.csv'); +-- +ok +== +(SELECT * FROM web_page EXCEPT SELECT * FROM web_page2) +UNION ALL +(SELECT * FROM web_page2 EXCEPT SELECT * FROM web_page) +-- +ok +== diff --git a/parser/testdata/corpus/sql/copy/csv/auto/test_csv_auto.test b/parser/testdata/corpus/sql/copy/csv/auto/test_csv_auto.test new file mode 100644 index 0000000..499fc89 --- /dev/null +++ b/parser/testdata/corpus/sql/copy/csv/auto/test_csv_auto.test @@ -0,0 +1,127 @@ +# source: test/sql/copy/csv/auto/test_csv_auto.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +FROM read_csv('{DATA_DIR}/csv/repromarket.csv', + columns={ + 'email': 'varchar', + 'password': 'varchar' + }, + all_varchar=true, + delim=':', + header=false, + skip=0, + null_padding=true, + ignore_errors=true, + strict_mode=false +); +-- +ok +== +FROM read_csv('{DATA_DIR}/csv/pipe_delim.csv', columns={'a': 'VARCHAR'}, auto_detect=False) +-- +ok +== +FROM read_csv('{DATA_DIR}/csv/nullterm.csv') +-- +ok +== +FROM read_csv('{DATA_DIR}/csv/nullterm.csv', quote = '"', escape = '"') +-- +ok +== +FROM read_csv('{DATA_DIR}/csv/single_quote.csv', quote = '"') +-- +ok +== +select columns FROM sniff_csv('{DATA_DIR}/csv/auto/mock_duckdb_test_data.csv', ignore_errors = true); +-- +ok +== +FROM read_csv('{DATA_DIR}/csv/auto/mock_duckdb_test_data.csv', ignore_errors = true, + strict_mode=true) +-- +ok +== +select * from read_csv_auto('{DATA_DIR}/csv/dates.csv', auto_detect=false, delim=',', quote='"', columns={'a': 'VARCHAR'}, + strict_mode=true) +-- +ok +== +select * from read_csv_auto('{DATA_DIR}/csv/dates.csv') +-- +ok +== +select * from read_csv_auto('{DATA_DIR}/csv/from_df.csv', quote='''') +-- +ok +== +CREATE TABLE test AS SELECT * FROM read_csv_auto ('{DATA_DIR}/csv/auto/rfc_conform.csv'); +-- +ok +== +SELECT * FROM test ORDER BY column0; +-- +ok +== +CREATE TABLE test AS SELECT * FROM read_csv_auto ('{DATA_DIR}/csv/auto/rfc_conform_quote.csv'); +-- +ok +== +CREATE TABLE test AS SELECT * FROM read_csv_auto ('{DATA_DIR}/csv/auto/leading_space_numerics.csv'); +-- +ok +== +CREATE TABLE test AS SELECT * FROM read_csv_auto ('{DATA_DIR}/csv/auto/pipe_delim.csv'); +-- +ok +== +CREATE TABLE test AS SELECT * FROM read_csv_auto ('{DATA_DIR}/csv/auto/pipe_delim_quote.csv'); +-- +ok +== +CREATE TABLE test AS SELECT * FROM read_csv_auto ('{DATA_DIR}/csv/auto/quote_escape.csv'); +-- +ok +== +CREATE TABLE test AS SELECT * FROM read_csv_auto ('{DATA_DIR}/csv/auto/backslash_escape.csv'); +-- +ok +== +CREATE TABLE test AS SELECT * FROM read_csv_auto ('{DATA_DIR}/csv/auto/single_quote_backslash.csv'); +-- +ok +== +CREATE TABLE test AS SELECT * FROM read_csv_auto ('{DATA_DIR}/csv/auto/semicolon_delim.csv'); +-- +ok +== +CREATE TABLE test AS SELECT * FROM read_csv_auto ('{DATA_DIR}/csv/auto/semicolon_quote.csv'); +-- +ok +== +CREATE TABLE test AS SELECT * FROM read_csv_auto ('{DATA_DIR}/csv/auto/semicolon_escape.csv'); +-- +ok +== +CREATE TABLE test AS SELECT * FROM read_csv_auto ('{DATA_DIR}/csv/auto/tab.csv'); +-- +ok +== +CREATE TABLE test AS SELECT * FROM read_csv_auto ('{DATA_DIR}/csv/auto/tab_single_quote.csv'); +-- +ok +== +CREATE TABLE test AS SELECT * FROM read_csv_auto ('{DATA_DIR}/csv/auto/tab_single_quote_varchar.csv'); +-- +ok +== +CREATE TABLE test AS SELECT * FROM read_csv_auto ('{DATA_DIR}/csv/auto/issue_1254.csv'); +-- +ok +== +SELECT a, b FROM test; +-- +ok +== diff --git a/parser/testdata/corpus/sql/copy/csv/auto/test_date_format_bug_linux.test b/parser/testdata/corpus/sql/copy/csv/auto/test_date_format_bug_linux.test new file mode 100644 index 0000000..caabd00 --- /dev/null +++ b/parser/testdata/corpus/sql/copy/csv/auto/test_date_format_bug_linux.test @@ -0,0 +1,9 @@ +# source: test/sql/copy/csv/auto/test_date_format_bug_linux.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +SELECT * FROM read_csv_auto('{DATA_DIR}/csv/auto/date_format_bug_linux.csv') +-- +ok +== diff --git a/parser/testdata/corpus/sql/copy/csv/auto/test_describe_order.test b/parser/testdata/corpus/sql/copy/csv/auto/test_describe_order.test new file mode 100644 index 0000000..a6c388a --- /dev/null +++ b/parser/testdata/corpus/sql/copy/csv/auto/test_describe_order.test @@ -0,0 +1,17 @@ +# source: test/sql/copy/csv/auto/test_describe_order.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +create view v as select * from read_csv_auto('{DATA_DIR}/csv/who.csv.gz'); +-- +ok +== +describe v; +-- +ok +== +describe select * from v; +-- +ok +== diff --git a/parser/testdata/corpus/sql/copy/csv/auto/test_double_quoted_header.test b/parser/testdata/corpus/sql/copy/csv/auto/test_double_quoted_header.test new file mode 100644 index 0000000..7dc0d05 --- /dev/null +++ b/parser/testdata/corpus/sql/copy/csv/auto/test_double_quoted_header.test @@ -0,0 +1,13 @@ +# source: test/sql/copy/csv/auto/test_double_quoted_header.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +describe from '{DATA_DIR}/csv/double_quoted_header.csv'; +-- +ok +== +from '{DATA_DIR}/csv/double_quoted_header.csv'; +-- +ok +== diff --git a/parser/testdata/corpus/sql/copy/csv/auto/test_early_out.test b/parser/testdata/corpus/sql/copy/csv/auto/test_early_out.test new file mode 100644 index 0000000..4730270 --- /dev/null +++ b/parser/testdata/corpus/sql/copy/csv/auto/test_early_out.test @@ -0,0 +1,10 @@ +# source: test/sql/copy/csv/auto/test_early_out.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +SELECT * +FROM read_csv('{DATA_DIR}/csv/auto/early_out_error.csv', buffer_size = 8, maximum_line_size = 8, auto_detect = false, columns = {'a': 'integer','b': 'integer','c': 'integer'}, header = true) +-- +ok +== diff --git a/parser/testdata/corpus/sql/copy/csv/auto/test_header_completion.test b/parser/testdata/corpus/sql/copy/csv/auto/test_header_completion.test new file mode 100644 index 0000000..b9b3def --- /dev/null +++ b/parser/testdata/corpus/sql/copy/csv/auto/test_header_completion.test @@ -0,0 +1,69 @@ +# source: test/sql/copy/csv/auto/test_header_completion.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +CREATE TABLE test AS SELECT * FROM read_csv_auto ('{DATA_DIR}/csv/auto/missing_header_col.csv'); +-- +ok +== +SELECT a, column1, c FROM test ORDER BY a; +-- +ok +== +CREATE TABLE test AS SELECT * FROM read_csv_auto ('{DATA_DIR}/csv/auto/duplicate_header_col.csv'); +-- +ok +== +SELECT a, b, a_1 FROM test ORDER BY a; +-- +ok +== +CREATE TABLE test AS SELECT * FROM read_csv_auto ('{DATA_DIR}/csv/auto/duplicate_header_collision.csv'); +-- +ok +== +SELECT a, b, a_1, a_1_1 FROM test ORDER BY a; +-- +ok +== +CREATE TABLE test AS SELECT * FROM read_csv_auto ('{DATA_DIR}/csv/auto/empty_header.csv'); +-- +ok +== +SELECT column0, column1, column2 FROM test ORDER BY column0; +-- +ok +== +CREATE TABLE test AS SELECT * FROM read_csv_auto ('{DATA_DIR}/csv/auto/missing_many_col.csv'); +-- +ok +== +SELECT a, column01, column12 FROM test; +-- +ok +== +CREATE TABLE test AS SELECT * FROM read_csv_auto ('{DATA_DIR}/csv/auto/duplicate_header_columns.csv'); +-- +ok +== +SELECT a, a_8, a_9, column12 FROM test; +-- +ok +== +CREATE TABLE test AS SELECT * FROM read_csv_auto ('{DATA_DIR}/csv/auto/test_header_mix.csv'); +-- +ok +== +SELECT a, a_8, a_9, column12, column11, column12_1 FROM test; +-- +ok +== +CREATE TABLE test AS SELECT * FROM read_csv_auto ('{DATA_DIR}/csv/auto/unnamed_columns.csv'); +-- +ok +== +SELECT column00, column01, column02, column03, column04, column05, column06, column07, column08, column09, column10, column11, column12 FROM test; +-- +ok +== diff --git a/parser/testdata/corpus/sql/copy/csv/auto/test_header_detection.test b/parser/testdata/corpus/sql/copy/csv/auto/test_header_detection.test new file mode 100644 index 0000000..b15aabd --- /dev/null +++ b/parser/testdata/corpus/sql/copy/csv/auto/test_header_detection.test @@ -0,0 +1,97 @@ +# source: test/sql/copy/csv/auto/test_header_detection.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +CREATE TABLE test AS SELECT * FROM read_csv_auto ('{DATA_DIR}/csv/auto/no_header.csv'); +-- +ok +== +CREATE TABLE test AS SELECT * FROM read_csv_auto ('{DATA_DIR}/csv/auto/single_header.csv'); +-- +ok +== +SELECT number, text, date FROM test ORDER BY number; +-- +ok +== +CREATE TABLE test AS SELECT * FROM read_csv_auto ('{DATA_DIR}/csv/auto/skip_row.csv'); +-- +ok +== +CREATE TABLE test AS SELECT * FROM read_csv_auto ('{DATA_DIR}/csv/auto/multiple_skip_row.csv'); +-- +ok +== +CREATE TABLE test AS SELECT * FROM read_csv_auto ('{DATA_DIR}/csv/auto/varchar_multi_line.csv', header = 0); +-- +ok +== +CREATE TABLE test AS SELECT * FROM read_csv_auto ('{DATA_DIR}/csv/auto/varchar_single_line.csv', header = 0); +-- +ok +== +SELECT column0, column1 FROM test ORDER BY column0; +-- +ok +== +CREATE TABLE test AS SELECT * FROM read_csv_auto ('{DATA_DIR}/csv/auto/mixed_single_line.csv'); +-- +ok +== +CREATE TABLE test AS SELECT * FROM read_csv_auto ('{DATA_DIR}/csv/auto/single_value.csv'); +-- +ok +== +CREATE TABLE test AS SELECT * FROM read_csv_auto ('{DATA_DIR}/csv/auto/single_numeric.csv'); +-- +ok +== +CREATE TABLE test AS SELECT * FROM read_csv_auto('{DATA_DIR}/csv/auto/utf8bom.csv'); +-- +ok +== +SELECT id FROM test; +-- +ok +== +CREATE TABLE my_varchars(a VARCHAR, b VARCHAR, c VARCHAR); +-- +ok +== +INSERT INTO my_varchars VALUES ('Hello', 'Beautiful', 'World'); +-- +ok +== +COPY my_varchars TO '{TEMP_DIR}/varchar_header.csv' (HEADER 1); +-- +ok +== +COPY my_varchars TO '{TEMP_DIR}/varchar_no_header.csv' (HEADER 0); +-- +ok +== +COPY my_varchars FROM '{TEMP_DIR}/varchar_header.csv' ; +-- +ok +== +COPY my_varchars FROM '{TEMP_DIR}/varchar_no_header.csv' (HEADER 0); +-- +ok +== +FROM my_varchars ; +-- +ok +== +COPY my_varchars TO '{TEMP_DIR}/big_varchar.csv'; +-- +ok +== +COPY my_varchars FROM '{TEMP_DIR}/big_varchar.csv'; +-- +ok +== +FROM my_varchars; +-- +ok +== diff --git a/parser/testdata/corpus/sql/copy/csv/auto/test_large_integer_detection.test b/parser/testdata/corpus/sql/copy/csv/auto/test_large_integer_detection.test new file mode 100644 index 0000000..0fa2836 --- /dev/null +++ b/parser/testdata/corpus/sql/copy/csv/auto/test_large_integer_detection.test @@ -0,0 +1,74 @@ +# source: test/sql/copy/csv/auto/test_large_integer_detection.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +CREATE TABLE large_integer_detection AS +SELECT * FROM (VALUES ( + '12345678901234567890', + '340282366920938463463374607431768211456', + '+340282366920938463463374607431768211456', + '-340282366920938463463374607431768211456', + '-170141183460469231731687303715884105728', + '340282366920938463463374607431768211455', + '000340282366920938463463374607431768211456', + '1.5', + ' 340282366920938463463374607431768211456 ', + ' -340282366920938463463374607431768211456 ', + '340,282,366,920,938,463,463,374,607,431,768,211,456' +)) AS t( + hugeint_value, + bignum_value, + plus_bignum_value, + negative_bignum_value, + signed_hugeint_value, + unsigned_hugeint_value, + leading_zero_bignum_value, + decimal_value, + whitespace_bignum_value, + negative_whitespace_bignum_value, + thousands_bignum_value +); +-- +ok +== +COPY large_integer_detection TO '{TEST_DIR}/csv_large_integer_detection.csv' (FORMAT CSV, HEADER); +-- +ok +== +SELECT unnest([ + typeof(hugeint_value) || ':' || hugeint_value::VARCHAR, + typeof(bignum_value) || ':' || bignum_value::VARCHAR, + typeof(plus_bignum_value) || ':' || plus_bignum_value::VARCHAR, + typeof(negative_bignum_value) || ':' || negative_bignum_value::VARCHAR, + typeof(signed_hugeint_value) || ':' || signed_hugeint_value::VARCHAR, + typeof(unsigned_hugeint_value) || ':' || unsigned_hugeint_value::VARCHAR, + typeof(leading_zero_bignum_value) || ':' || leading_zero_bignum_value, + typeof(decimal_value) || ':' || decimal_value::VARCHAR, + typeof(whitespace_bignum_value) || ':' || whitespace_bignum_value::VARCHAR, + typeof(negative_whitespace_bignum_value) || ':' || negative_whitespace_bignum_value::VARCHAR, + typeof(thousands_bignum_value) || ':' || thousands_bignum_value::VARCHAR +]) +FROM read_csv_auto('{TEST_DIR}/csv_large_integer_detection.csv', thousands = ','); +-- +ok +== +COPY (SELECT * FROM (VALUES + ('340282366920938463463374607431768211456') +) AS t(value)) TO '{TEST_DIR}/csv_merge_bignum.csv' (FORMAT CSV, HEADER); +-- +ok +== +COPY (SELECT * FROM (VALUES + ('1.5') +) AS t(value)) TO '{TEST_DIR}/csv_merge_double.csv' (FORMAT CSV, HEADER); +-- +ok +== +SELECT typeof(value) FROM read_csv_auto([ + '{TEST_DIR}/csv_merge_bignum.csv', + '{TEST_DIR}/csv_merge_double.csv' +], files_to_sniff = -1) LIMIT 1; +-- +ok +== diff --git a/parser/testdata/corpus/sql/copy/csv/auto/test_normalize_names.test b/parser/testdata/corpus/sql/copy/csv/auto/test_normalize_names.test new file mode 100644 index 0000000..181e87e --- /dev/null +++ b/parser/testdata/corpus/sql/copy/csv/auto/test_normalize_names.test @@ -0,0 +1,69 @@ +# source: test/sql/copy/csv/auto/test_normalize_names.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +select columns from sniff_csv('{DATA_DIR}/csv/test_commit_rollback.csv', normalize_names = true) +-- +ok +== +CREATE TABLE test AS SELECT * FROM read_csv_auto ('{DATA_DIR}/csv/auto/normalize_names_1.csv', normalize_names=TRUE); +-- +ok +== +SELECT a, b, c FROM test ORDER BY a; +-- +ok +== +CREATE TABLE test AS SELECT * FROM read_csv_auto ('{DATA_DIR}/csv/auto/normalize_names_1.csv'); +-- +ok +== +SELECT A, B, C FROM test ORDER BY a; +-- +ok +== +select columns from sniff_csv('{DATA_DIR}/csv/auto/normalize_names_2.csv', normalize_names = true) +-- +ok +== +CREATE TABLE test AS SELECT * FROM read_csv_auto ('{DATA_DIR}/csv/auto/normalize_names_2.csv', normalize_names=TRUE); +-- +ok +== +SELECT _select, _insert, _join FROM test ORDER BY _select; +-- +ok +== +CREATE TABLE test AS SELECT * FROM read_csv_auto ('{DATA_DIR}/csv/auto/normalize_names_3.csv', normalize_names=TRUE); +-- +ok +== +SELECT _0_a, _1_b, _9_c FROM test ORDER BY _0_a; +-- +ok +== +CREATE TABLE test AS SELECT * FROM read_csv_auto ('{DATA_DIR}/csv/auto/normalize_names_4.csv', normalize_names=TRUE); +-- +ok +== +SELECT allo, teost, _ FROM test ORDER BY allo; +-- +ok +== +CREATE TABLE test AS SELECT * FROM read_csv_auto ('{DATA_DIR}/csv/auto/normalize_names_5.csv', normalize_names=TRUE); +-- +ok +== +CREATE TABLE test AS SELECT * FROM read_csv_auto ('{DATA_DIR}/csv/auto/normalize_names_6.csv', normalize_names=TRUE); +-- +ok +== +SELECT aax, hello_world, qty_m2 FROM test ORDER BY aax; +-- +ok +== +select columns from sniff_csv('{DATA_DIR}/csv/normalize.csv', normalize_names = true) +-- +ok +== diff --git a/parser/testdata/corpus/sql/copy/csv/auto/test_sample_size.test b/parser/testdata/corpus/sql/copy/csv/auto/test_sample_size.test new file mode 100644 index 0000000..45d15d1 --- /dev/null +++ b/parser/testdata/corpus/sql/copy/csv/auto/test_sample_size.test @@ -0,0 +1,45 @@ +# source: test/sql/copy/csv/auto/test_sample_size.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +CREATE TABLE test AS SELECT * FROM read_csv_auto ('{DATA_DIR}/csv/auto/issue_811.csv', SAMPLE_SIZE=1); +-- +ok +== +SELECT typeof(TestInteger), typeof(TestDouble), typeof(TestDate), typeof(TestText) FROM test LIMIT 1 +-- +ok +== +CREATE TABLE test AS SELECT * FROM read_csv_auto ('{DATA_DIR}/csv/auto/issue_811.csv', SAMPLE_SIZE=-1); +-- +ok +== +CREATE TABLE test AS SELECT * FROM read_csv_auto ('{DATA_DIR}/csv/auto/issue_811.csv', SAMPLE_SIZE = -1); +-- +ok +== +SELECT TestInteger, TestDouble, TestDate, TestText FROM test WHERE TestDouble is not NULL ; +-- +ok +== +SELECT typeof(TestInteger), typeof(TestDouble), typeof(TestDate), typeof(TestText) FROM test LIMIT 1; +-- +ok +== +CREATE TABLE test AS SELECT * FROM read_csv_auto ('{DATA_DIR}/csv/auto/issue_811.csv'); +-- +ok +== +CREATE TABLE test (TestInteger integer, TestDouble double, TestDate varchar, TestText varchar); +-- +ok +== +COPY test FROM '{DATA_DIR}/csv/auto/issue_811.csv' (AUTO_DETECT TRUE); +-- +ok +== +COPY test FROM '{DATA_DIR}/csv/auto/issue_811.csv' (SAMPLE_SIZE -1, AUTO_DETECT TRUE); +-- +ok +== diff --git a/parser/testdata/corpus/sql/copy/csv/auto/test_sniffer_blob.test b/parser/testdata/corpus/sql/copy/csv/auto/test_sniffer_blob.test new file mode 100644 index 0000000..b817f1d --- /dev/null +++ b/parser/testdata/corpus/sql/copy/csv/auto/test_sniffer_blob.test @@ -0,0 +1,25 @@ +# source: test/sql/copy/csv/auto/test_sniffer_blob.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +select count(*) from read_csv('{DATA_DIR}/csv/test/blob.csv',auto_type_candidates=['blob']) +-- +ok +== +select count(*) from read_csv('{DATA_DIR}/csv/test/blob.csv',types=['blob'], header = 0) +-- +ok +== +select count(*) from read_csv('{DATA_DIR}/csv/test/blob.csv',columns={'col1': 'BLOB'}) +-- +ok +== +create table t ( a blob) +-- +ok +== +COPY t FROM '{DATA_DIR}/csv/test/blob.csv'; +-- +ok +== diff --git a/parser/testdata/corpus/sql/copy/csv/auto/test_sniffer_empty_start_value.test b/parser/testdata/corpus/sql/copy/csv/auto/test_sniffer_empty_start_value.test new file mode 100644 index 0000000..5bf4039 --- /dev/null +++ b/parser/testdata/corpus/sql/copy/csv/auto/test_sniffer_empty_start_value.test @@ -0,0 +1,9 @@ +# source: test/sql/copy/csv/auto/test_sniffer_empty_start_value.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +from read_csv('{DATA_DIR}/csv/empty_space_start_value.csv') +-- +ok +== diff --git a/parser/testdata/corpus/sql/copy/csv/auto/test_timings_csv.test b/parser/testdata/corpus/sql/copy/csv/auto/test_timings_csv.test new file mode 100644 index 0000000..46739d5 --- /dev/null +++ b/parser/testdata/corpus/sql/copy/csv/auto/test_timings_csv.test @@ -0,0 +1,13 @@ +# source: test/sql/copy/csv/auto/test_timings_csv.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +CREATE OR REPLACE TABLE timings(tool string, sf float, day string, batch_type string, q string, parameters string, time float); +-- +ok +== +COPY timings FROM '{DATA_DIR}/csv/timings.csv' (HEADER, DELIMITER '|') +-- +ok +== diff --git a/parser/testdata/corpus/sql/copy/csv/auto/test_type_candidates.test b/parser/testdata/corpus/sql/copy/csv/auto/test_type_candidates.test new file mode 100644 index 0000000..e842639 --- /dev/null +++ b/parser/testdata/corpus/sql/copy/csv/auto/test_type_candidates.test @@ -0,0 +1,97 @@ +# source: test/sql/copy/csv/auto/test_type_candidates.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +create table t (a integer, b double, c varchar) +-- +ok +== +insert into t values (1,1.1,'bla'); +-- +ok +== +COPY (SELECT * from t) TO '{TEST_DIR}/csv_file.csv' (FORMAT CSV, DELIMITER '|', HEADER 0); +-- +ok +== +SELECT * FROM read_csv_auto ('{TEST_DIR}/csv_file.csv'); +-- +ok +== +SELECT typeof(column0), typeof(column1), typeof(column2) FROM read_csv_auto ('{TEST_DIR}/csv_file.csv'); +-- +ok +== +SELECT * FROM read_csv_auto ('{TEST_DIR}/csv_file.csv', auto_type_candidates=['BIGINT', 'DOUBLE', 'VARCHAR']); +-- +ok +== +SELECT * FROM read_csv_auto ('{TEST_DIR}/csv_file.csv', auto_type_candidates=['MAP']); +-- +ok +== +SELECT typeof(column0), typeof(column1), typeof(column2) FROM read_csv_auto ('{TEST_DIR}/csv_file.csv', auto_type_candidates=['BIGINT', 'DOUBLE', 'VARCHAR']); +-- +ok +== +SELECT * FROM read_csv_auto ('{TEST_DIR}/csv_file.csv', auto_type_candidates=['VARCHAR'], header = 0); +-- +ok +== +SELECT typeof(column0), typeof(column1), typeof(column2) FROM read_csv_auto ('{TEST_DIR}/csv_file.csv', auto_type_candidates=['VARCHAR'], header = 0); +-- +ok +== +SELECT * FROM read_csv_auto ('{TEST_DIR}/csv_file.csv', auto_type_candidates=['BIGINT']); +-- +ok +== +SELECT typeof(column0), typeof(column1), typeof(column2) FROM read_csv_auto ('{TEST_DIR}/csv_file.csv', auto_type_candidates=['BIGINT']); +-- +ok +== +SELECT * FROM read_csv_auto ('{TEST_DIR}/csv_file.csv', auto_type_candidates=['BIGINT','VARCHAR']); +-- +ok +== +SELECT typeof(column0), typeof(column1), typeof(column2) FROM read_csv_auto ('{TEST_DIR}/csv_file.csv', auto_type_candidates=['BIGINT','VARCHAR']); +-- +ok +== +SELECT * FROM read_csv_auto ('{TEST_DIR}/csv_file.csv', auto_type_candidates=['FLOAT','VARCHAR']); +-- +ok +== +SELECT typeof(column0), typeof(column1), typeof(column2) FROM read_csv_auto ('{TEST_DIR}/csv_file.csv', auto_type_candidates=['FLOAT','VARCHAR']); +-- +ok +== +SELECT * FROM read_csv_auto ('{TEST_DIR}/csv_file.csv', auto_type_candidates=['SMALLINT','BIGINT', 'DOUBLE', 'FLOAT','VARCHAR']); +-- +ok +== +SELECT typeof(column0), typeof(column1), typeof(column2) FROM read_csv_auto ('{TEST_DIR}/csv_file.csv', auto_type_candidates=['SMALLINT','BIGINT', 'DOUBLE', 'FLOAT','VARCHAR']); +-- +ok +== +SELECT * FROM read_csv_auto ('{TEST_DIR}/csv_file.csv', auto_type_candidates=['SMALLINT','BIGINT', 'DOUBLE', 'FLOAT','VARCHAR','SMALLINT','BIGINT', 'DOUBLE', 'FLOAT','VARCHAR']); +-- +ok +== +SELECT typeof(column0), typeof(column1), typeof(column2) FROM read_csv_auto ('{TEST_DIR}/csv_file.csv', auto_type_candidates=['SMALLINT','BIGINT', 'DOUBLE', 'FLOAT','VARCHAR','SMALLINT','BIGINT', 'DOUBLE', 'FLOAT','VARCHAR']); +-- +ok +== +SELECT * FROM read_csv_auto ('{TEST_DIR}/csv_file.csv', auto_type_candidates=['USMALLINT', 'VARCHAR']); +-- +ok +== +SELECT * FROM read_csv_auto ('{TEST_DIR}/csv_file.csv', auto_type_candidates=['bla', 'VARCHAR']) +-- +ok +== +SELECT * FROM read_csv_auto ('{TEST_DIR}/csv_file.csv', auto_type_candidates=[]); +-- +ok +== diff --git a/parser/testdata/corpus/sql/copy/csv/auto/test_type_detection.test b/parser/testdata/corpus/sql/copy/csv/auto/test_type_detection.test new file mode 100644 index 0000000..75b2a03 --- /dev/null +++ b/parser/testdata/corpus/sql/copy/csv/auto/test_type_detection.test @@ -0,0 +1,85 @@ +# source: test/sql/copy/csv/auto/test_type_detection.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +CREATE TABLE test AS SELECT * FROM read_csv_auto ('{DATA_DIR}/csv/auto/large_mixed_data.csv', SAMPLE_SIZE=-1); +-- +ok +== +SELECT linenr, mixed_string, mixed_double FROM test LIMIT 3; +-- +ok +== +SELECT typeof(linenr), typeof(mixed_string), typeof(mixed_double) FROM test LIMIT 1; +-- +ok +== +SELECT linenr, mixed_string, mixed_double FROM test WHERE linenr > 27000 LIMIT 3; +-- +ok +== +SELECT count(*) FROM test; +-- +ok +== +CREATE TABLE test AS SELECT * FROM read_csv_auto ('{DATA_DIR}/csv/auto/time_date_timestamp.csv'); +-- +ok +== +SELECT a, b, t, d, ts FROM test ORDER BY a; +-- +ok +== +SELECT typeof(a), typeof(b), typeof(t), typeof(d), typeof(ts) FROM test LIMIT 1; +-- +ok +== +CREATE TABLE test AS SELECT * FROM read_csv_auto ('{DATA_DIR}/csv/auto/time_date_timestamp_trailing.csv'); +-- +ok +== +SELECT a, b, t, tf, d, df FROM test ORDER BY a; +-- +ok +== +SELECT typeof(a), typeof(b), typeof(t), typeof(tf), typeof(d), typeof(df) FROM test LIMIT 1; +-- +ok +== +CREATE TABLE test AS SELECT * FROM read_csv_auto ('{DATA_DIR}/csv/auto/time_date_timestamp_mm-dd-yyyy.csv'); +-- +ok +== +CREATE TABLE test AS SELECT * FROM read_csv_auto ('{DATA_DIR}/csv/auto/time_date_timestamp_mm-dd-yy.csv'); +-- +ok +== +CREATE TABLE test AS SELECT * FROM read_csv_auto ('{DATA_DIR}/csv/auto/time_date_timestamp_dd-mm-yyyy.csv'); +-- +ok +== +CREATE TABLE test AS SELECT * FROM read_csv_auto ('{DATA_DIR}/csv/auto/time_date_timestamp_dd-mm-yy.csv'); +-- +ok +== +CREATE TABLE test AS SELECT * FROM read_csv_auto ('{DATA_DIR}/csv/auto/time_date_timestamp_yyyy.mm.dd.csv'); +-- +ok +== +CREATE TABLE test AS SELECT * FROM read_csv_auto ('{DATA_DIR}/csv/auto/time_date_timestamp_yy.mm.dd.csv'); +-- +ok +== +CREATE TABLE test AS SELECT * FROM read_csv_auto ('{DATA_DIR}/csv/auto/int_bol.csv'); +-- +ok +== +SELECT i FROM test ORDER BY i; +-- +ok +== +SELECT typeof(i), typeof(b) FROM test LIMIT 1; +-- +ok +== diff --git a/parser/testdata/corpus/sql/copy/csv/auto_glob_directory.test b/parser/testdata/corpus/sql/copy/csv/auto_glob_directory.test new file mode 100644 index 0000000..b5fd667 --- /dev/null +++ b/parser/testdata/corpus/sql/copy/csv/auto_glob_directory.test @@ -0,0 +1,13 @@ +# source: test/sql/copy/csv/auto_glob_directory.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +COPY (SELECT i%2 AS grp, i FROM range(1000) t(i)) TO '{TEST_DIR}/partitioned_glob_csv' (FORMAT csv, PARTITION_BY (grp)); +-- +ok +== +SELECT grp, COUNT(*) FROM read_csv('{TEST_DIR}/partitioned_glob_csv') GROUP BY ALL ORDER BY ALL +-- +ok +== diff --git a/parser/testdata/corpus/sql/copy/csv/code_cov/buffer_manager_finalize.test b/parser/testdata/corpus/sql/copy/csv/code_cov/buffer_manager_finalize.test new file mode 100644 index 0000000..0a6a665 --- /dev/null +++ b/parser/testdata/corpus/sql/copy/csv/code_cov/buffer_manager_finalize.test @@ -0,0 +1,21 @@ +# source: test/sql/copy/csv/code_cov/buffer_manager_finalize.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +CREATE TABLE t1 AS select i, (i+1) as j from range(0,3000) tbl(i) +-- +ok +== +COPY t1 TO '{TEMP_DIR}/t1.csv' (FORMAT CSV, DELIMITER '|', HEADER); +-- +ok +== +select count(*) from '{TEMP_DIR}/t1.csv' +-- +ok +== +select count(*) from read_csv('{DATA_DIR}/csv/empty.csv', columns=STRUCT_PACK(d := 'BIGINT'), header=0, auto_detect = false) +-- +ok +== diff --git a/parser/testdata/corpus/sql/copy/csv/code_cov/csv_dialect_detection.test b/parser/testdata/corpus/sql/copy/csv/code_cov/csv_dialect_detection.test new file mode 100644 index 0000000..3bebbb2 --- /dev/null +++ b/parser/testdata/corpus/sql/copy/csv/code_cov/csv_dialect_detection.test @@ -0,0 +1,17 @@ +# source: test/sql/copy/csv/code_cov/csv_dialect_detection.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +SELECT * from read_csv_auto('{DATA_DIR}/csv/escape.csv', escape=']', header = 0) +-- +ok +== +SELECT * from read_csv_auto('{DATA_DIR}/csv/escape.csv', header = 0) +-- +ok +== +SELECT * from read_csv_auto('{DATA_DIR}/csv/no_opt.csv', delim = ';') +-- +ok +== diff --git a/parser/testdata/corpus/sql/copy/csv/code_cov/csv_exact_buffer_size.test b/parser/testdata/corpus/sql/copy/csv/code_cov/csv_exact_buffer_size.test new file mode 100644 index 0000000..fef0b7e --- /dev/null +++ b/parser/testdata/corpus/sql/copy/csv/code_cov/csv_exact_buffer_size.test @@ -0,0 +1,21 @@ +# source: test/sql/copy/csv/code_cov/csv_exact_buffer_size.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +FROM read_csv('{DATA_DIR}/csv/auto/issue_1254_rn.csv', buffer_size=10) +-- +ok +== +FROM read_csv('{DATA_DIR}/csv/auto/issue_1254_rn.csv', buffer_size=8) +-- +ok +== +select count(*) from read_csv_auto('{DATA_DIR}/csv/small_file.csv', buffer_size = 7) +-- +ok +== +select count(*) from read_csv('{DATA_DIR}/csv/quoted_comment_buffer_boundary.csv', buffer_size=30, delim=';', header=false, null_padding=true, union_by_name=false, ignore_errors=true) +-- +ok +== diff --git a/parser/testdata/corpus/sql/copy/csv/code_cov/csv_sniffer_header.test b/parser/testdata/corpus/sql/copy/csv/code_cov/csv_sniffer_header.test new file mode 100644 index 0000000..b443229 --- /dev/null +++ b/parser/testdata/corpus/sql/copy/csv/code_cov/csv_sniffer_header.test @@ -0,0 +1,21 @@ +# source: test/sql/copy/csv/code_cov/csv_sniffer_header.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +SELECT count(*) from read_csv_auto('{DATA_DIR}/csv/header_left_space.csv') +-- +ok +== +create table t as select * from read_csv_auto('{DATA_DIR}/csv/header_normalize.csv', normalize_names=1) +-- +ok +== +describe t +-- +ok +== +FROM read_csv(['{DATA_DIR}/csv/auto/sample.csv','{DATA_DIR}/csv/auto/sample.csv','{DATA_DIR}/csv/auto/sample.csv']) +-- +ok +== diff --git a/parser/testdata/corpus/sql/copy/csv/code_cov/csv_state_machine_invalid_utf.test b/parser/testdata/corpus/sql/copy/csv/code_cov/csv_state_machine_invalid_utf.test new file mode 100644 index 0000000..18ee629 --- /dev/null +++ b/parser/testdata/corpus/sql/copy/csv/code_cov/csv_state_machine_invalid_utf.test @@ -0,0 +1,77 @@ +# source: test/sql/copy/csv/code_cov/csv_state_machine_invalid_utf.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +from read_csv_auto('{DATA_DIR}/csv/test/invalid_utf.csv') +-- +ok +== +from read_csv('{DATA_DIR}/csv/test/invalid_utf.csv',columns = {'col1': 'VARCHAR','col2': 'VARCHAR','col3': 'VARCHAR'}, auto_detect=false, header = 0, delim = ',') +-- +ok +== +from read_csv('{DATA_DIR}/csv/test/invalid_utf_complex.csv',columns = {'col1': 'VARCHAR','col2': 'VARCHAR','col3': 'VARCHAR'}, auto_detect=false, header = 0, delim = ',') +-- +ok +== +from read_csv('{DATA_DIR}/csv/test/invalid_utf_complex.csv',columns = {'col1': 'VARCHAR','col2': 'VARCHAR','col3': 'VARCHAR'}, auto_detect=false, header = 0, delim = ',', ignore_errors=true) +-- +ok +== +create table t as from read_csv('{DATA_DIR}/csv/test/invalid_utf_big.csv',columns = {'col1': 'VARCHAR','col2': 'VARCHAR','col3': 'VARCHAR'}, auto_detect=false, header = 0, delim = ',', ignore_errors=true) +-- +ok +== +select count(*) from t +-- +ok +== +from read_csv('{DATA_DIR}/csv/test/invalid_utf_big.csv',columns = {'col1': 'VARCHAR','col2': 'VARCHAR','col3': 'VARCHAR'}, auto_detect=false, header = 0, delim = ',') +-- +ok +== +from read_csv('{DATA_DIR}/csv/test/invalid_utf_quoted.csv',columns = {'col1': 'VARCHAR','col2': 'VARCHAR','col3': 'VARCHAR'}, auto_detect=false, header = 0, delim = ',', quote = '"') +-- +ok +== +from read_csv('{DATA_DIR}/csv/test/invalid_utf_complex.csv',columns = {'col1': 'VARCHAR','col2': 'VARCHAR','col3': 'VARCHAR'}, auto_detect=false, header = 0, delim = ',', quote = '"', ignore_errors=true) +-- +ok +== +from read_csv('{DATA_DIR}/csv/test/invalid_utf_header.csv', delim = ',', quote = '"') +-- +ok +== +from read_csv('{DATA_DIR}/csv/test/invalid_utf_header.csv', header=1, delim = ',', quote = '"') +-- +ok +== +from read_csv('{DATA_DIR}/csv/test/invalid_utf_header.csv', header=1, delim = ',', quote = '"', ignore_errors = true) +-- +ok +== +from read_csv('{DATA_DIR}/csv/test/invalid_utf_quoted_nl.csv',columns = {'col1': 'VARCHAR','col2': 'VARCHAR','col3': 'VARCHAR'}, auto_detect=false, header = 0, delim = ',', quote = '"') +-- +ok +== +from read_csv('{DATA_DIR}/csv/test/invalid_utf_quoted_nl.csv',columns = {'col1': 'VARCHAR','col2': 'VARCHAR','col3': 'VARCHAR'}, auto_detect=false, header = 0, delim = ',', quote = '"', ignore_errors=true) +-- +ok +== +from read_csv('{DATA_DIR}/csv/test/invalid_utf_complex.csv',columns = {'col1': 'VARCHAR','col2': 'VARCHAR','col3': 'VARCHAR'}, auto_detect=false, header = 0, delim = ',', quote = '"', buffer_size = 198) +-- +ok +== +from read_csv('{DATA_DIR}/csv/test/invalid_utf_complex.csv',columns = {'col1': 'VARCHAR','col2': 'VARCHAR','col3': 'VARCHAR'}, auto_detect=false, header = 0, delim = ',', ignore_errors=true, buffer_size = 198) +-- +ok +== +SELECT * FROM read_csv('{DATA_DIR}/csv/test/invalid_utf_list.csv', header=0, auto_detect=false, quote = '"',columns = {'col1': 'INTEGER[]'} ) +-- +ok +== +SELECT * FROM read_csv('{DATA_DIR}/csv/test/invalid_utf_list.csv', header=0, auto_detect=false, quote = '"',columns = {'col1': 'VARCHAR'} ) +-- +ok +== diff --git a/parser/testdata/corpus/sql/copy/csv/code_cov/csv_type_detection.test b/parser/testdata/corpus/sql/copy/csv/code_cov/csv_type_detection.test new file mode 100644 index 0000000..5f5500b --- /dev/null +++ b/parser/testdata/corpus/sql/copy/csv/code_cov/csv_type_detection.test @@ -0,0 +1,21 @@ +# source: test/sql/copy/csv/code_cov/csv_type_detection.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +from read_csv_auto('{DATA_DIR}/csv/invalid_utf8.csv', auto_detect = false, columns={'c01': 'VARCHAR'} ) +-- +ok +== +select * from read_csv_auto('{DATA_DIR}/csv/empty.csv') +-- +ok +== +select * from read_csv_auto('{DATA_DIR}/csv/small_file.csv', sample_size=1) +-- +ok +== +select * from read_csv_auto('{DATA_DIR}/csv/date_format_percentage.csv') +-- +ok +== diff --git a/parser/testdata/corpus/sql/copy/csv/code_cov/csv_type_refinement.test b/parser/testdata/corpus/sql/copy/csv/code_cov/csv_type_refinement.test new file mode 100644 index 0000000..82b8867 --- /dev/null +++ b/parser/testdata/corpus/sql/copy/csv/code_cov/csv_type_refinement.test @@ -0,0 +1,13 @@ +# source: test/sql/copy/csv/code_cov/csv_type_refinement.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +select count(*) from read_csv_auto('{DATA_DIR}/csv/borked_date.csv', header = 0) +-- +ok +== +select count(*) from read_csv_auto('{DATA_DIR}/csv/big_not_bool.csv', header = 0) +-- +ok +== diff --git a/parser/testdata/corpus/sql/copy/csv/column_names.test b/parser/testdata/corpus/sql/copy/csv/column_names.test new file mode 100644 index 0000000..bb818bb --- /dev/null +++ b/parser/testdata/corpus/sql/copy/csv/column_names.test @@ -0,0 +1,29 @@ +# source: test/sql/copy/csv/column_names.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +CREATE TABLE t1 AS SELECT * FROM read_csv_auto('{DATA_DIR}/csv/test/issue2518.csv', header=False, columns={'rsID':'INT', 'CHR': 'VARCHAR', 'POS': 'INT','REFB': 'VARCHAR','ALTB':'VARCHAR'}, auto_detect = false) +-- +ok +== +SELECT rsID, chr, pos, refb, altb FROM t1 +-- +ok +== +CREATE TABLE t2 AS SELECT * FROM read_csv_auto('{DATA_DIR}/csv/test/issue2518.csv', header=False, columns={'rsID':'INT', 'CHR': 'VARCHAR', 'POS': 'INT','REFB': 'VARCHAR','ALTB':'VARCHAR'}, AUTO_DETECT=0) +-- +ok +== +SELECT rsID, chr, pos, refb, altb FROM t2 +-- +ok +== +CREATE TABLE t3 AS SELECT * FROM read_csv_auto('{DATA_DIR}/csv/test/issue2518.csv', columns={'rsID':'INT', 'CHR': 'VARCHAR', 'POS': 'INT','REFB': 'VARCHAR','ALTB':'VARCHAR'}, auto_detect = false) +-- +ok +== +SELECT rsID, chr, pos, refb, altb FROM t3 +-- +ok +== diff --git a/parser/testdata/corpus/sql/copy/csv/copy_disable_parallelism.test b/parser/testdata/corpus/sql/copy/csv/copy_disable_parallelism.test new file mode 100644 index 0000000..3707a01 --- /dev/null +++ b/parser/testdata/corpus/sql/copy/csv/copy_disable_parallelism.test @@ -0,0 +1,9 @@ +# source: test/sql/copy/csv/copy_disable_parallelism.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +CREATE TABLE test (a INTEGER, b INTEGER, c VARCHAR(10)); +-- +ok +== diff --git a/parser/testdata/corpus/sql/copy/csv/copy_expression.test b/parser/testdata/corpus/sql/copy/csv/copy_expression.test new file mode 100644 index 0000000..e790a1e --- /dev/null +++ b/parser/testdata/corpus/sql/copy/csv/copy_expression.test @@ -0,0 +1,29 @@ +# source: test/sql/copy/csv/copy_expression.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +SET VARIABLE copy_target = '{TEST_DIR}/copy_expression_target.csv'; +-- +ok +== +COPY (SELECT * FROM range(5) t(i)) TO (getvariable('copy_target')) WITH (HEADER) +-- +ok +== +COPY tbl FROM (getvariable('copy_target')); +-- +ok +== +PREPARE v1 AS COPY (SELECT 'hello world' str) TO $1; +-- +ok +== +EXECUTE v1('{TEST_DIR}/prepared_copy.csv'); +-- +ok +== +FROM '{TEST_DIR}/prepared_copy.csv' +-- +ok +== diff --git a/parser/testdata/corpus/sql/copy/csv/copy_to_overwrite.test b/parser/testdata/corpus/sql/copy/csv/copy_to_overwrite.test new file mode 100644 index 0000000..54bf0dc --- /dev/null +++ b/parser/testdata/corpus/sql/copy/csv/copy_to_overwrite.test @@ -0,0 +1,33 @@ +# source: test/sql/copy/csv/copy_to_overwrite.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +COPY (SELECT * FROM range(5) t(i)) TO '{TEST_DIR}/copy_to_overwrite.csv' (HEADER) +-- +ok +== +SELECT * FROM '{TEST_DIR}/copy_to_overwrite.csv' +-- +ok +== +COPY (SELECT * FROM range(5, 10) t(i)) TO '{TEST_DIR}/copy_to_overwrite.csv' (HEADER) +-- +ok +== +COPY (SELECT * FROM range(5) t(i)) TO '{TEST_DIR}/copy_to_overwrite.csv.gz' (HEADER) +-- +ok +== +SELECT * FROM '{TEST_DIR}/copy_to_overwrite.csv.gz' +-- +ok +== +COPY (SELECT * FROM range(5, 10) t(i)) TO '{TEST_DIR}/copy_to_overwrite.csv.gz' (HEADER) +-- +ok +== +SET preserve_insertion_order=false +-- +ok +== diff --git a/parser/testdata/corpus/sql/copy/csv/csv_copy_sniffer.test b/parser/testdata/corpus/sql/copy/csv/csv_copy_sniffer.test new file mode 100644 index 0000000..a484b23 --- /dev/null +++ b/parser/testdata/corpus/sql/copy/csv/csv_copy_sniffer.test @@ -0,0 +1,23 @@ +# source: test/sql/copy/csv/csv_copy_sniffer.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +CREATE TABLE sales ( + salesid INTEGER NOT NULL PRIMARY KEY, + listid INTEGER NOT NULL, + sellerid INTEGER NOT NULL, + buyerid INTEGER NOT NULL, + eventid INTEGER NOT NULL, + dateid SMALLINT NOT NULL, + qtysold SMALLINT NOT NULL, + pricepaid DECIMAL (8,2), + commission DECIMAL (8,2), + saletime TIMESTAMP); +-- +ok +== +COPY sales FROM '{DATA_DIR}/csv/sales_snippet.csv' (TIMESTAMPFORMAT '%m/%d/%Y %I:%M:%S', IGNORE_ERRORS true); +-- +ok +== diff --git a/parser/testdata/corpus/sql/copy/csv/csv_decimal_separator.test b/parser/testdata/corpus/sql/copy/csv/csv_decimal_separator.test new file mode 100644 index 0000000..2dd9c34 --- /dev/null +++ b/parser/testdata/corpus/sql/copy/csv/csv_decimal_separator.test @@ -0,0 +1,69 @@ +# source: test/sql/copy/csv/csv_decimal_separator.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +CREATE TABLE decimal_separators AS SELECT * FROM read_csv_auto('{DATA_DIR}/csv/decimal_separators/decimal_separators.csv', column_types={'commas': 'double', 'periods': 'double'}, delim=';', decimal_separator=',') +-- +ok +== +CREATE TABLE decimal_separators AS SELECT * FROM read_csv_auto('{DATA_DIR}/csv/decimal_separators/decimal_separators.csv', column_types={'commas': 'double'}, delim=';', decimal_separator=',') +-- +ok +== +SELECT commas, periods FROM decimal_separators; +-- +ok +== +SELECT typeof(commas), typeof(periods) FROM decimal_separators limit 1; +-- +ok +== +CREATE TABLE decimal_separators2 AS SELECT * FROM read_csv_auto('{DATA_DIR}/csv/decimal_separators/decimal_separators.csv', column_types={'commas': 'decimal', 'periods': 'decimal'}, delim=';', decimal_separator='.') +-- +ok +== +CREATE TABLE decimal_separators2 AS SELECT * FROM read_csv_auto('{DATA_DIR}/csv/decimal_separators/decimal_separators.csv', column_types={'commas': 'float', 'periods': 'decimal'}, delim=';', decimal_separator='.') +-- +ok +== +CREATE TABLE decimal_separators2 AS SELECT * FROM read_csv_auto('{DATA_DIR}/csv/decimal_separators/decimal_separators.csv', column_types={'commas': 'decimal'}, delim=';', decimal_separator=',') +-- +ok +== +SELECT commas, periods FROM decimal_separators2; +-- +ok +== +SELECT typeof(commas), typeof(periods) FROM decimal_separators2 limit 1; +-- +ok +== +CREATE TABLE decimal_separators3 AS SELECT * FROM read_csv_auto('{DATA_DIR}/csv/decimal_separators/decimal_separators.csv', column_types={'periods': 'decimal'}, delim=';') +-- +ok +== +SELECT commas, periods FROM decimal_separators3; +-- +ok +== +CREATE TABLE decimal_separators4 AS SELECT * FROM read_csv_auto('{DATA_DIR}/csv/decimal_separators/decimal_separators_csv.csv', column_types={'commas': 'double'}, quote='"',delim=',',decimal_separator=',') +-- +ok +== +SELECT commas, periods FROM decimal_separators4; +-- +ok +== +SELECT typeof(commas), typeof(periods) FROM decimal_separators4 limit 1; +-- +ok +== +SELECT * FROM read_csv_auto('{DATA_DIR}/csv/decimal_separators/invalid_char.csv', column_types={'foo': 'double'}, decimal_separator='ö') +-- +ok +== +SELECT * FROM read_csv_auto('{DATA_DIR}/csv/decimal_separators/mixed_format_fail.csv', column_types={'foo': 'double'}, decimal_separator=',', skip=0) +-- +ok +== diff --git a/parser/testdata/corpus/sql/copy/csv/csv_dtypes.test b/parser/testdata/corpus/sql/copy/csv/csv_dtypes.test new file mode 100644 index 0000000..5c008e0 --- /dev/null +++ b/parser/testdata/corpus/sql/copy/csv/csv_dtypes.test @@ -0,0 +1,73 @@ +# source: test/sql/copy/csv/csv_dtypes.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +select typeof(Year), typeof(Quarter) from '{DATA_DIR}/csv/real/ontime_sample.csv' LIMIT 1; +-- +ok +== +select typeof(Year), typeof(Quarter) from read_csv_auto('{DATA_DIR}/csv/real/ontime_sample.csv', dtypes={'Quarter': 'TINYINT'}) LIMIT 1 +-- +ok +== +select typeof(Year), typeof(Quarter) from read_csv_auto('{DATA_DIR}/csv/real/ontime_sample.csv', dtypes={'quArTeR': 'TINYINT'}) LIMIT 1 +-- +ok +== +select typeof(Year), typeof(Quarter) from read_csv_auto('{DATA_DIR}/csv/real/ontime_sample.csv', dtypes=['INT', 'TINYINT']) LIMIT 1 +-- +ok +== +select * from read_csv_auto('{DATA_DIR}/csv/real/ontime_sample.csv', dtypes=['INT'], column_types={'Quarter': 'TINYINT'}) LIMIT 1 +-- +ok +== +select * from read_csv_auto('{DATA_DIR}/csv/real/ontime_sample.csv', dtypes=[42]) LIMIT 1 +-- +ok +== +select * from read_csv_auto('{DATA_DIR}/csv/real/ontime_sample.csv', dtypes=['unknown_type']) LIMIT 1 +-- +ok +== +select * from read_csv_auto('{DATA_DIR}/csv/real/ontime_sample.csv', dtypes={'Quarter': 42}) LIMIT 1 +-- +ok +== +select * from read_csv_auto('{DATA_DIR}/csv/auto/int_bol.csv', dtypes=['varchar', 'varchar', 'varchar']) LIMIT 1 +-- +ok +== +select * from read_csv('{DATA_DIR}/csv/auto/int_bol.csv', auto_detect=false, columns={'a':'varchar'}, types=['BIGINT', 'DATE']) +-- +ok +== +select * from read_csv('{DATA_DIR}/csv/auto/int_bol.csv', auto_detect=false, columns={'a':'varchar'}, dtypes=['BIGINT']) +-- +ok +== +select * from read_csv('{DATA_DIR}/csv/auto/int_bol.csv', auto_detect=false, columns={'a':'varchar'}, column_types={'a': 'BIGINT'}) +-- +ok +== +select typeof(i), typeof(b) from read_csv('{DATA_DIR}/csv/auto/int_bol.csv', columns={'i':'varchar', 'b':'varchar'}, types=['VARCHAR', 'VARCHAR']) LIMIT 1 +-- +ok +== +select * from read_csv('{DATA_DIR}/csv/auto/int_bol.csv', columns={'i':'varchar', 'b':'varchar'}, types=['VARCHAR', 'INTEGER']) +-- +ok +== +select typeof(i), typeof(b) from read_csv('{DATA_DIR}/csv/auto/int_bol.csv', columns={'i':'varchar', 'b':'varchar'}, column_types={'x': 'VARCHAR', 'y': 'VARCHAR'}) LIMIT 1 +-- +ok +== +select * from read_csv('{DATA_DIR}/csv/auto/int_bol.csv', columns={'i':'varchar', 'b':'varchar'}, column_types={'x': 'INTEGER', 'y': 'BOOLEAN'}) +-- +ok +== +select typeof(i), typeof(b) from read_csv('{DATA_DIR}/csv/auto/int_bol.csv', columns={'i':'varchar', 'b':'varchar'}) LIMIT 1 +-- +ok +== diff --git a/parser/testdata/corpus/sql/copy/csv/csv_dtypes_union_by_name.test b/parser/testdata/corpus/sql/copy/csv/csv_dtypes_union_by_name.test new file mode 100644 index 0000000..70a497b --- /dev/null +++ b/parser/testdata/corpus/sql/copy/csv/csv_dtypes_union_by_name.test @@ -0,0 +1,71 @@ +# source: test/sql/copy/csv/csv_dtypes_union_by_name.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +CREATE TABLE ubn1(a BIGINT); +-- +ok +== +CREATE TABLE ubn2(a INTEGER, b INTEGER); +-- +ok +== +CREATE TABLE ubn3(a INTEGER, c INTEGER); +-- +ok +== +INSERT INTO ubn1 VALUES (1), (2), (9223372036854775807); +-- +ok +== +INSERT INTO ubn2 VALUES (3,4), (5, 6); +-- +ok +== +INSERT INTO ubn3 VALUES (100,101), (102, 103); +-- +ok +== +COPY ubn1 TO '{TEST_DIR}/ubn1.csv' WITH (DELIMITER ','); +-- +ok +== +COPY ubn2 TO '{TEST_DIR}/ubn2.csv' WITH ( DELIMITER ','); +-- +ok +== +COPY ubn3 TO '{TEST_DIR}/ubn3.csv' WITH (DELIMITER ','); +-- +ok +== +SELECT typeof(a), typeof(b), typeof(c) +FROM read_csv_auto('{TEST_DIR}/ubn*.csv', UNION_BY_NAME=TRUE, dtypes={'c': TINYINT}) +LIMIT 1; +-- +ok +== +SELECT typeof(a), typeof(b), typeof(c) +FROM read_csv_auto('{TEST_DIR}/ubn*.csv', UNION_BY_NAME=TRUE, dtypes={'c': TINYINT, 'A': DOUBLE}) +LIMIT 1; +-- +ok +== +SELECT typeof(a), typeof(b), typeof(c) +FROM read_csv_auto('{TEST_DIR}/ubn*.csv', UNION_BY_NAME=TRUE, dtypes={'xxx': TINYINT}) +LIMIT 1; +-- +ok +== +SELECT typeof(a), typeof(b), typeof(c) +FROM read_csv_auto('{TEST_DIR}/ubn*.csv', UNION_BY_NAME=TRUE, dtypes={'c': TINYINT, 'A': DOUBLE, 'C': FLOAT}) +LIMIT 1; +-- +ok +== +SELECT typeof(a), typeof(b), typeof(c) +FROM read_csv_auto('{TEST_DIR}/ubn*.csv', UNION_BY_NAME=TRUE, dtypes={'c': TINYINT, 'A': DOUBLE, 'xZX': FLOAT}) +LIMIT 1; +-- +ok +== diff --git a/parser/testdata/corpus/sql/copy/csv/csv_duck_fuzz.test b/parser/testdata/corpus/sql/copy/csv/csv_duck_fuzz.test new file mode 100644 index 0000000..41dd7ab --- /dev/null +++ b/parser/testdata/corpus/sql/copy/csv/csv_duck_fuzz.test @@ -0,0 +1,21 @@ +# source: test/sql/copy/csv/csv_duck_fuzz.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +SELECT NULL FROM sniff_csv('{DATA_DIR}/csv/14512.csv', {parameter} := NULL) +-- +error: Parser Error: syntax error at or near "}" +== +SELECT NULL FROM read_csv('{DATA_DIR}/csv/14512.csv', {parameter} := NULL) +-- +error: Parser Error: syntax error at or near "}" +== +SELECT NULL FROM sniff_csv(NULL) +-- +ok +== +SELECT NULL FROM read_csv(NULL) +-- +error: Parser Error: read_csv cannot take NULL list as parameter +== diff --git a/parser/testdata/corpus/sql/copy/csv/csv_duck_fuzz.test.metadata.json b/parser/testdata/corpus/sql/copy/csv/csv_duck_fuzz.test.metadata.json new file mode 100644 index 0000000..4158379 --- /dev/null +++ b/parser/testdata/corpus/sql/copy/csv/csv_duck_fuzz.test.metadata.json @@ -0,0 +1,5 @@ +{ + "todo": { + "3eede6463cafd305": "transformer-raised parser error: upstream rejects in the transformer, not the grammar; expected to clear as transformers land (milestones 3-5)" + } +} diff --git a/parser/testdata/corpus/sql/copy/csv/csv_enum.test b/parser/testdata/corpus/sql/copy/csv/csv_enum.test new file mode 100644 index 0000000..d0c3652 --- /dev/null +++ b/parser/testdata/corpus/sql/copy/csv/csv_enum.test @@ -0,0 +1,25 @@ +# source: test/sql/copy/csv/csv_enum.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +CREATE TYPE bla AS ENUM ('Y', 'N'); +-- +ok +== +select * from read_csv_auto('{DATA_DIR}/csv/response.csv', header = 0) +-- +ok +== +FROM read_csv('{DATA_DIR}/csv/response.csv', columns={'response': 'bla'}, nullstr = 'Null'); +-- +ok +== +FROM read_csv_auto('{DATA_DIR}/csv/response.csv', types={'column0': 'bla'}, nullstr = 'Null', header = 0); +-- +ok +== +FROM read_csv_auto('{DATA_DIR}/csv/response.csv', auto_type_candidates=['bla'], nullstr = 'Null'); +-- +ok +== diff --git a/parser/testdata/corpus/sql/copy/csv/csv_error_message.test b/parser/testdata/corpus/sql/copy/csv/csv_error_message.test new file mode 100644 index 0000000..b94a016 --- /dev/null +++ b/parser/testdata/corpus/sql/copy/csv/csv_error_message.test @@ -0,0 +1,29 @@ +# source: test/sql/copy/csv/csv_error_message.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +FROM read_csv('{DATA_DIR}/csv/15473.csv', delim = ',', columns = {'A' : 'VARCHAR','B' : 'VARCHAR','C' : 'VARCHAR','D' : 'VARCHAR'}) +-- +ok +== +COPY (SELECT i::VARCHAR i FROM range(103) tbl(i) UNION ALL SELECT 'hello') TO '{TEMP_DIR}/int_parse_error.csv' (HEADER, DELIMITER '|') +-- +ok +== +SELECT * FROM read_csv('{TEMP_DIR}/int_parse_error.csv', columns={'i': 'INT'}) +-- +ok +== +SELECT * FROM read_csv('{TEMP_DIR}/int_parse_error.csv', columns={'i': 'INT'}, header=True, auto_detect=false) +-- +ok +== +COPY (SELECT i::VARCHAR i FROM range(103) tbl(i) UNION ALL SELECT 'hello') TO '{TEMP_DIR}/int_parse_error.csv' (HEADER 0, DELIMITER '|') +-- +ok +== +SELECT * FROM read_csv('{TEMP_DIR}/int_parse_error.csv', columns={'i': 'INT'}, header=False, auto_detect=false) +-- +ok +== diff --git a/parser/testdata/corpus/sql/copy/csv/csv_external_access.test b/parser/testdata/corpus/sql/copy/csv/csv_external_access.test new file mode 100644 index 0000000..72facce --- /dev/null +++ b/parser/testdata/corpus/sql/copy/csv/csv_external_access.test @@ -0,0 +1,37 @@ +# source: test/sql/copy/csv/csv_external_access.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +CREATE TABLE date_test(d date); +-- +ok +== +COPY date_test FROM '{DATA_DIR}/csv/test/date.csv'; +-- +ok +== +SET enable_external_access=false; +-- +ok +== +SELECT * FROM read_csv('{DATA_DIR}/csv/test/date.csv', columns = {'d': 'DATE'}); +-- +ok +== +SELECT * FROM read_csv_auto('{DATA_DIR}/csv/test/date.csv'); +-- +ok +== +COPY date_test TO '{TEMP_DIR}/date.csv' +-- +ok +== +SET enable_external_access=true; +-- +ok +== +FROM sniff_csv('{DATA_DIR}/csv/test/date.csv'); +-- +ok +== diff --git a/parser/testdata/corpus/sql/copy/csv/csv_glob_fallback.test b/parser/testdata/corpus/sql/copy/csv/csv_glob_fallback.test new file mode 100644 index 0000000..fc4423e --- /dev/null +++ b/parser/testdata/corpus/sql/copy/csv/csv_glob_fallback.test @@ -0,0 +1,13 @@ +# source: test/sql/copy/csv/csv_glob_fallback.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +SELECT * FROM '{DATA_DIR}/csv/[avalon]_daily-avg.csv' +-- +ok +== +SELECT * FROM '{DATA_DIR}/csv/[avxalon]_daily-avg.csv' +-- +ok +== diff --git a/parser/testdata/corpus/sql/copy/csv/csv_hive.test b/parser/testdata/corpus/sql/copy/csv/csv_hive.test new file mode 100644 index 0000000..e9ad4ee --- /dev/null +++ b/parser/testdata/corpus/sql/copy/csv/csv_hive.test @@ -0,0 +1,102 @@ +# source: test/sql/copy/csv/csv_hive.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +CREATE TABLE test AS SELECT 1 as id, 'value1' as value; +CREATE TABLE test2 AS SELECT 2 as id, 'value2' as value; +-- +ok +== +SELECT id, value, parse_path(filename)[-4:] from read_csv_auto('{DATA_DIR}/csv/hive-partitioning/simple/*/*/test.csv', FILENAME=1) order by id +-- +ok +== +select id, value, part, date from read_csv_auto('{DATA_DIR}/csv/hive-partitioning/simple/*/*/test.csv', HIVE_PARTITIONING=1) order by id +-- +ok +== +select id, value, part, date from read_csv_auto('{DATA_DIR}/csv/hive-partitioning/different_order/*/*/test.csv', HIVE_PARTITIONING=1) order by id +-- +ok +== +select * from read_csv_auto('{DATA_DIR}/csv/hive-partitioning/mismatching_names/*/*/test.csv', HIVE_PARTITIONING=1) +-- +ok +== +select * from read_csv_auto('{DATA_DIR}/csv/hive-partitioning/mismatching_count/*/*/test.csv', HIVE_PARTITIONING=1) +-- +ok +== +select id, value, part, date from read_csv_auto('{DATA_DIR}/csv/hive-partitioning/different_order/*/*/test.csv', HIVE_PARTITIONING=1) where part='a' +-- +ok +== +select id, value, part, date from read_csv_auto('{DATA_DIR}/csv/hive-partitioning/different_order/*/*/test.csv', HIVE_PARTITIONING=1) where part='b' +-- +ok +== +select id, value, CAST(part AS INT) as part_cast, CAST(date AS DATE) as date_cast from read_csv_auto('{DATA_DIR}/csv/hive-partitioning/types/*/*/test.csv', HIVE_PARTITIONING=1) where part_cast > 0 and part_cast < 5000; +-- +ok +== +select id, value, CAST(part AS INT) as part_cast, CAST(date AS DATE) as date_cast from read_csv_auto('{DATA_DIR}/csv/hive-partitioning/types/*/*/test.csv', HIVE_PARTITIONING=1) where part_cast > 5000; +-- +ok +== +select id, value, CAST(part AS INT) as part_cast, CAST(date AS DATE) as date_cast from read_csv_auto('{DATA_DIR}/csv/hive-partitioning/types/*/*/test.csv', HIVE_PARTITIONING=1) where date_cast > CAST('2000-01-01' as DATE) and date_cast < CAST('2012-12-12' as DATE); +-- +ok +== +select id, value, CAST(part AS INT) as part_cast, CAST(date AS DATE) as date_cast from read_csv_auto('{DATA_DIR}/csv/hive-partitioning/types/*/*/test.csv', HIVE_PARTITIONING=1) where date_cast > CAST('2000-01-01' as DATE) order by date_cast; +-- +ok +== +select id, value, CAST(part AS INT) as part_cast, CAST(date AS DATE) as date_cast from read_csv_auto('{DATA_DIR}/csv/hive-partitioning/types/*/*/test.csv', HIVE_PARTITIONING=1) where date_cast=CAST('2012-01-01' as DATE) OR part_cast=9000 ORDER BY date_cast; +-- +ok +== +select id, value, CAST(part AS INT) as part_cast, CAST(date AS DATE) as date_cast from read_csv_auto('{DATA_DIR}/csv/hive-partitioning/types/*/*/test.csv', HIVE_PARTITIONING=1) where (date_cast=CAST('2012-01-01' as DATE) AND concat(date_cast::VARCHAR, part_cast::VARCHAR) == '2012-01-011000') OR (part_cast=9000) ORDER BY date_cast; +-- +ok +== +EXPLAIN select id, value, CAST(part AS INT) as part_cast, CAST(date AS DATE) as date_cast from read_csv_auto('{DATA_DIR}/csv/hive-partitioning/types/*/*/test.csv', HIVE_PARTITIONING=1) where (date_cast=CAST('2012-01-01' as DATE) AND concat(date_cast::VARCHAR, part_cast::VARCHAR) == '2012-01-011000') OR (part_cast=9000) ORDER BY date_cast; +-- +ok +== +select id, value, CAST(part AS INT) as part_cast, CAST(date AS DATE) as date_cast from read_csv_auto('{DATA_DIR}/csv/hive-partitioning/types/*/*/test.csv', HIVE_PARTITIONING=1) where (date_cast=CAST('2012-01-01' as DATE) AND concat(date_cast::VARCHAR, part_cast::VARCHAR) == 'foobar') OR (part_cast=9000) ORDER BY date_cast; +-- +ok +== +explain select id, value, CAST(part AS INT) as part_cast, CAST(date AS DATE) as date_cast from read_csv_auto('{DATA_DIR}/csv/hive-partitioning/types/*/*/test.csv', HIVE_PARTITIONING=1) where (date_cast=CAST('2012-01-01' as DATE) AND concat(date_cast::VARCHAR, part_cast::VARCHAR) == 'foobar') OR (part_cast=9000) ORDER BY date_cast; +-- +ok +== +select id, value, CAST(part AS INT) as part_cast, CAST(date AS DATE) as date_cast from read_csv_auto('{DATA_DIR}/csv/hive-partitioning/types/*/*/test.csv', HIVE_PARTITIONING=1) where (date_cast=CAST('2012-01-01' as DATE) AND concat(date_cast::VARCHAR, part_cast::VARCHAR) == '2012-01-011000') OR (part_cast=1337) ORDER BY date_cast; +-- +ok +== +explain select id, value, CAST(part AS INT) as part_cast, CAST(date AS DATE) as date_cast from read_csv_auto('{DATA_DIR}/csv/hive-partitioning/types/*/*/test.csv', HIVE_PARTITIONING=1) where (date_cast=CAST('2012-01-01' as DATE) AND concat(date_cast::VARCHAR, part_cast::VARCHAR) == '2012-01-011000') OR (part_cast=1337) ORDER BY date_cast; +-- +ok +== +select id, value, CAST(part AS INT) as part_cast, CAST(date AS DATE) as date_cast from read_csv_auto('{DATA_DIR}/csv/hive-partitioning/types/*/*/test.csv', HIVE_PARTITIONING=1) where (date_cast=CAST('2012-01-01' as DATE) AND concat(date_cast::VARCHAR, part_cast::VARCHAR) == 'foobar') OR (part_cast=1337) ORDER BY date_cast; +-- +ok +== +EXPLAIN select id, value, CAST(part AS INT) as part_cast, CAST(date AS DATE) as date_cast from read_csv_auto('{DATA_DIR}/csv/hive-partitioning/types/*/*/test.csv', HIVE_PARTITIONING=1) where (date_cast=CAST('2012-01-01' as DATE) AND concat(date_cast::VARCHAR, part_cast::VARCHAR) == 'foobar') OR (part_cast=1337) ORDER BY date_cast; +-- +ok +== +select value from read_csv_auto('{DATA_DIR}/csv/hive-partitioning/different_order/*/*/test.csv', HIVE_PARTITIONING=1) order by 1 +-- +ok +== +select part from read_csv_auto('{DATA_DIR}/csv/hive-partitioning/different_order/*/*/test.csv', HIVE_PARTITIONING=1) order by 1 +-- +ok +== +select date from read_csv_auto('{DATA_DIR}/csv/hive-partitioning/different_order/*/*/test.csv', HIVE_PARTITIONING=1) order by 1 +-- +ok +== diff --git a/parser/testdata/corpus/sql/copy/csv/csv_hive_filename_union.test b/parser/testdata/corpus/sql/copy/csv/csv_hive_filename_union.test new file mode 100644 index 0000000..2d72f45 --- /dev/null +++ b/parser/testdata/corpus/sql/copy/csv/csv_hive_filename_union.test @@ -0,0 +1,49 @@ +# source: test/sql/copy/csv/csv_hive_filename_union.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +select filename.replace('\', '/').split('/')[-2] from read_csv_auto('{DATA_DIR}/csv/hive-partitioning/simple/*/*/test.csv', HIVE_PARTITIONING=1, FILENAME=1) order by 1 +-- +ok +== +select part, filename.replace('\', '/').split('/')[-2], value from read_csv_auto('{DATA_DIR}/csv/hive-partitioning/simple/*/*/test.csv', HIVE_PARTITIONING=1, FILENAME=1) order by 1 +-- +ok +== +select part, filename.replace('\', '/').split('/')[-2], value from read_csv_auto('{DATA_DIR}/csv/hive-partitioning/simple/*/*/test.csv', HIVE_PARTITIONING=1, FILENAME=1, UNION_BY_NAME=1) order by 1 +-- +ok +== +select * exclude(filename) from read_csv_auto('{DATA_DIR}/csv/hive-partitioning/mismatching_types/*/*.csv', HIVE_PARTITIONING=1, FILENAME=1) order by 1 +-- +ok +== +select * from read_csv_auto('{DATA_DIR}/csv/hive-partitioning/mismatching_types/*/*.csv', HIVE_PARTITIONING=1, UNION_BY_NAME=1) order by 1 +-- +ok +== +select * exclude(filename), filename.replace('\', '/').split('/')[-2] from read_csv_auto('{DATA_DIR}/csv/hive-partitioning/mismatching_types/*/*.csv', HIVE_PARTITIONING=1, FILENAME=1, UNION_BY_NAME=1) order by 1 +-- +ok +== +select part, filename.replace('\', '/').split('/')[-2], a, b from read_csv_auto('{DATA_DIR}/csv/hive-partitioning/mismatching_types/*/*.csv', HIVE_PARTITIONING=1, FILENAME=1, UNION_BY_NAME=1) order by 1 +-- +ok +== +select * exclude (filename) from read_csv_auto('{DATA_DIR}/csv/hive-partitioning/mismatching_types/*/*.csv', HIVE_PARTITIONING=0, FILENAME=1, UNION_BY_NAME=1) order by 1 +-- +ok +== +select * from read_csv_auto(['{DATA_DIR}/csv/hive-partitioning/mismatching_contents/part=1/test.csv', '{DATA_DIR}/csv/hive-partitioning/mismatching_contents/part=2/test.csv']) order by 1 +-- +ok +== +select a, b, c from read_csv_auto('{DATA_DIR}/csv/hive-partitioning/mismatching_contents/*/*.csv', UNION_BY_NAME=1) order by 2 NULLS LAST +-- +ok +== +select a, b, part, c from read_csv_auto('{DATA_DIR}/csv/hive-partitioning/mismatching_contents/*/*.csv', UNION_BY_NAME=1, HIVE_PARTITIONING=1) order by 2 NULLS LAST +-- +ok +== diff --git a/parser/testdata/corpus/sql/copy/csv/csv_home_directory.test b/parser/testdata/corpus/sql/copy/csv/csv_home_directory.test new file mode 100644 index 0000000..693bb75 --- /dev/null +++ b/parser/testdata/corpus/sql/copy/csv/csv_home_directory.test @@ -0,0 +1,41 @@ +# source: test/sql/copy/csv/csv_home_directory.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +CREATE TABLE integers AS SELECT * FROM range(10) +-- +ok +== +COPY integers TO '{TEST_DIR}/integers.csv' (FORMAT CSV); +-- +ok +== +SELECT * FROM '~/integers.csv' +-- +ok +== +CREATE TABLE integers_load(i INTEGER); +-- +ok +== +COPY integers_load FROM '~/integers.csv' +-- +ok +== +SELECT * FROM integers_load +-- +ok +== +COPY integers TO '{TEST_DIR}/homedir_integers1.csv' +-- +ok +== +COPY integers TO '{TEST_DIR}/homedir_integers2.csv' +-- +ok +== +SELECT COUNT(*) FROM '~/homedir_integers*.csv' +-- +ok +== diff --git a/parser/testdata/corpus/sql/copy/csv/csv_limit_copy.test b/parser/testdata/corpus/sql/copy/csv/csv_limit_copy.test new file mode 100644 index 0000000..e1c5666 --- /dev/null +++ b/parser/testdata/corpus/sql/copy/csv/csv_limit_copy.test @@ -0,0 +1,17 @@ +# source: test/sql/copy/csv/csv_limit_copy.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +CREATE TABLE integers AS FROM range(1000000) t(i); +-- +ok +== +COPY (FROM integers LIMIT 30000) TO '{TEST_DIR}/limit_copy.csv' +-- +ok +== +SELECT COUNT(*) FROM '{TEST_DIR}/limit_copy.csv' +-- +ok +== diff --git a/parser/testdata/corpus/sql/copy/csv/csv_line_too_long.test b/parser/testdata/corpus/sql/copy/csv/csv_line_too_long.test new file mode 100644 index 0000000..b035352 --- /dev/null +++ b/parser/testdata/corpus/sql/copy/csv/csv_line_too_long.test @@ -0,0 +1,21 @@ +# source: test/sql/copy/csv/csv_line_too_long.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +CREATE TABLE T1 (name VARCHAR); +-- +ok +== +COPY T1(name) from '{DATA_DIR}/csv/line_too_long.csv.gz' (DELIMITER ',', HEADER {header} , COMPRESSION gzip, ALLOW_QUOTED_NULLS false); +-- +error: Parser Error: syntax error at or near "}" +== +COPY T1(name) from '{DATA_DIR}/csv/line_too_long_with_newline.csv.gz' (DELIMITER ',', HEADER {header} , COMPRESSION gzip, ALLOW_QUOTED_NULLS false); +-- +error: Parser Error: syntax error at or near "}" +== +COPY T1(name) from '{DATA_DIR}/csv/multiple_line_too_long.csv.gz' (DELIMITER ',', HEADER {header} , COMPRESSION gzip, ALLOW_QUOTED_NULLS false); +-- +error: Parser Error: syntax error at or near "}" +== diff --git a/parser/testdata/corpus/sql/copy/csv/csv_names.test b/parser/testdata/corpus/sql/copy/csv/csv_names.test new file mode 100644 index 0000000..b7a4b3c --- /dev/null +++ b/parser/testdata/corpus/sql/copy/csv/csv_names.test @@ -0,0 +1,101 @@ +# source: test/sql/copy/csv/csv_names.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +from read_csv('{DATA_DIR}/csv/header_bug.csv', names=['col1', 'col1']) LIMIT 1; +-- +ok +== +from read_csv('{DATA_DIR}/csv/header_bug.csv', names=['']) LIMIT 1; +-- +ok +== +from read_csv('{DATA_DIR}/csv/header_bug.csv', names=[' ', ' '], header = 0); +-- +ok +== +select column00, column01, column02, column03 from '{DATA_DIR}/csv/real/lineitem_sample.csv' LIMIT 1; +-- +ok +== +select l_orderkey, l_partkey, column02, column03 from read_csv_auto('{DATA_DIR}/csv/real/lineitem_sample.csv', names=['l_orderkey', 'l_partkey']) LIMIT 1; +-- +ok +== +select column00, column01, column02, column03 from read_csv_auto('{DATA_DIR}/csv/real/lineitem_sample.csv', names=[]) LIMIT 1; +-- +ok +== +select l_orderkey, l_partkey, l_commitdate, l_comment from read_csv_auto('{DATA_DIR}/csv/real/lineitem_sample.csv', column_names=['l_orderkey', 'l_partkey', 'l_suppkey', 'l_linenumber', 'l_quantity', 'l_extendedprice', 'l_discount', 'l_tax', 'l_returnflag', 'l_linestatus', 'l_shipdate', 'l_commitdate', 'l_receiptdate', 'l_shipinstruct', 'l_shipmode', 'l_comment']) LIMIT 1; +-- +ok +== +select l_orderkey, l_partkey, l_commitdate, l_comment from read_csv_auto('{DATA_DIR}/csv/real/lineitem_sample.csv', names=['l_orderkey', 'l_partkey', 'l_suppkey', 'l_linenumber', 'l_quantity', 'l_extendedprice', 'l_discount', 'l_tax', 'l_returnflag', 'l_linestatus', 'l_shipdate', 'l_commitdate', 'l_receiptdate', 'l_shipinstruct', 'l_shipmode', 'l_comment', 'xx']) LIMIT 1; +-- +ok +== +select yr, Quarter from read_csv_auto('{DATA_DIR}/csv/real/ontime_sample.csv', names=['yr']) LIMIT 1; +-- +ok +== +select column00, column01, column02, column03 from read_csv_auto('{DATA_DIR}/csv/real/lineitem_sample.csv', names=NULL) LIMIT 1; +-- +ok +== +select l_orderkey, l_partkey, column02, column03 from read_csv_auto('{DATA_DIR}/csv/real/lineitem_sample.csv', names=['l_orderkey', 'l_partkey'], column_names=['l_orderkey']) LIMIT 1; +-- +ok +== +select l_orderkey, l_partkey, column02, column03 from read_csv_auto('{DATA_DIR}/csv/real/lineitem_sample.csv', names=42) LIMIT 1; +-- +ok +== +select column00 from read_csv_auto('{DATA_DIR}/csv/real/lineitem_sample.csv', delim='|', sep='|') LIMIT 1; +-- +ok +== +select l_orderkey, l_partkey, column02, column03 from read_csv_auto('{DATA_DIR}/csv/real/lineitem_sample.csv', names=['l_orderkey', 'l_orderkey']) LIMIT 1; +-- +ok +== +select Columns FROM sniff_csv('{DATA_DIR}/csv/header.csv', names = ['a']) +-- +ok +== +FROM read_csv('{DATA_DIR}/csv/header.csv', names = ['a']) +-- +ok +== +select Columns FROM sniff_csv('{DATA_DIR}/csv/header.csv', names = ['a'], header = false) +-- +ok +== +FROM read_csv('{DATA_DIR}/csv/header.csv', names = ['a'], header = false) +-- +ok +== +select Columns FROM sniff_csv('{DATA_DIR}/csv/header_2.csv', names = ['a']) +-- +ok +== +FROM read_csv('{DATA_DIR}/csv/header_2.csv', names = ['a']) +-- +ok +== +select Columns FROM sniff_csv('{DATA_DIR}/csv/header_2.csv', names = ['a'], header=False) +-- +ok +== +select Columns FROM sniff_csv('{DATA_DIR}/csv/header_2.csv', names = ['a','b','c','d']) +-- +ok +== +select Columns FROM sniff_csv('{DATA_DIR}/csv/header_2.csv', names = ['a','b','c','d'], null_padding = True) +-- +ok +== +FROM read_csv('{DATA_DIR}/csv/header_2.csv', names = ['a','b','c','d'], null_padding = True) +-- +ok +== diff --git a/parser/testdata/corpus/sql/copy/csv/csv_null_byte.test b/parser/testdata/corpus/sql/copy/csv/csv_null_byte.test new file mode 100644 index 0000000..382c41b --- /dev/null +++ b/parser/testdata/corpus/sql/copy/csv/csv_null_byte.test @@ -0,0 +1,25 @@ +# source: test/sql/copy/csv/csv_null_byte.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +select * from '{DATA_DIR}/csv/nullbyte.csv'; +-- +ok +== +select * from read_csv('{DATA_DIR}/csv/nullbyte.csv', columns={'col1': 'VARCHAR', 'col2': 'VARCHAR', 'col3': 'VARCHAR'}, delim='|'); +-- +ok +== +select * from '{DATA_DIR}/csv/nullbyte_header.csv'; +-- +ok +== +select * from read_csv('{DATA_DIR}/csv/nullbyte_header.csv', columns={'col1': 'VARCHAR', 'col2': 'VARCHAR'}, delim='|', header=False); +-- +ok +== +select * from read_csv('{DATA_DIR}/csv/nullbyte_header.csv', columns={'col1': 'VARCHAR', 'col2': 'VARCHAR'}, delim='|', header=True); +-- +ok +== diff --git a/parser/testdata/corpus/sql/copy/csv/csv_null_padding.test b/parser/testdata/corpus/sql/copy/csv/csv_null_padding.test new file mode 100644 index 0000000..32c5703 --- /dev/null +++ b/parser/testdata/corpus/sql/copy/csv/csv_null_padding.test @@ -0,0 +1,25 @@ +# source: test/sql/copy/csv/csv_null_padding.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +FROM read_csv_auto('{DATA_DIR}/csv/nullpadding_header.csv', null_padding=True, comment = '') +-- +ok +== +FROM read_csv_auto('{DATA_DIR}/csv/nullpadding_header.csv', null_padding=False, header = 0) +-- +ok +== +FROM read_csv_auto('{DATA_DIR}/csv/nullpadding_header.csv', null_padding=False, skip=1, header = 0, comment = '') +-- +ok +== +FROM read_csv_auto('{DATA_DIR}/csv/nullpadding_header.csv', null_padding=False, skip=2) +-- +ok +== +FROM read_csv_auto('{DATA_DIR}/csv/blank_line.csv', null_padding=True) +-- +ok +== diff --git a/parser/testdata/corpus/sql/copy/csv/csv_nullstr_list.test b/parser/testdata/corpus/sql/copy/csv/csv_nullstr_list.test new file mode 100644 index 0000000..be2b268 --- /dev/null +++ b/parser/testdata/corpus/sql/copy/csv/csv_nullstr_list.test @@ -0,0 +1,105 @@ +# source: test/sql/copy/csv/csv_nullstr_list.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +FROM read_csv('{DATA_DIR}/csv/null/multiple_nulls.csv', auto_detect=false, delim=',', quote='"', escape='"', skip=0, header=true, columns={'name': 'VARCHAR', 'age': 'VARCHAR', 'height': 'VARCHAR'}, nullstr = ['','none','null']); +-- +ok +== +FROM read_csv('{DATA_DIR}/csv/null/multiple_quoted_nulls.csv', auto_detect=false, delim=',', quote='"', escape='"', skip=0, header=true, columns={'name': 'VARCHAR', 'age': 'VARCHAR', 'height': 'VARCHAR'}, nullstr = ['','none','null']); +-- +ok +== +FROM read_csv('{DATA_DIR}/csv/null/multiple_quoted_nulls.csv', auto_detect=false, delim=',', quote='"', escape='"', skip=0, header=true, columns={'name': 'VARCHAR', 'age': 'VARCHAR', 'height': 'VARCHAR'}, nullstr = ['','none','null'], allow_quoted_nulls = false); +-- +ok +== +FROM read_csv('{DATA_DIR}/csv/null/multiple_nulls.csv', auto_detect=false, delim=',', quote='"', escape='"', skip=0, header=true, columns={'name': 'VARCHAR', 'age': 'VARCHAR', 'height': 'VARCHAR'}, nullstr = []); +-- +ok +== +FROM read_csv('{DATA_DIR}/csv/null/multiple_nulls.csv', auto_detect=false, delim=',', quote='"', escape='"', skip=0, header=true, columns={'name': 'VARCHAR', 'age': 'VARCHAR', 'height': 'VARCHAR'}, nullstr = ['a', NULL]); +-- +ok +== +FROM read_csv('{DATA_DIR}/csv/null/multiple_nulls.csv', auto_detect=false, delim=',', quote='"', escape='"', skip=0, header=true, columns={'name': 'VARCHAR', 'age': 'VARCHAR', 'height': 'VARCHAR'}, nullstr = NULL); +-- +ok +== +FROM read_csv('{DATA_DIR}/csv/null/multiple_nulls.csv', auto_detect=false, delim=',', quote='"', escape='"', skip=0, header=true, columns={'name': 'VARCHAR', 'age': 'VARCHAR', 'height': 'VARCHAR'}, nullstr = [42]); +-- +ok +== +FROM read_csv('{DATA_DIR}/csv/null/multiple_quoted_nulls.csv', auto_detect=false, delim=',', quote='"', escape='"', skip=0, header=true, columns={'name': 'VARCHAR', 'age': 'VARCHAR', 'height': 'VARCHAR'}, nullstr = ['',',','null'], allow_quoted_nulls = false); +-- +ok +== +FROM read_csv('{DATA_DIR}/csv/null/multiple_quoted_nulls.csv', auto_detect=false, delim=',', quote='"', escape='\', skip=0, header=true, columns={'name': 'VARCHAR', 'age': 'VARCHAR', 'height': 'VARCHAR'}, nullstr = ['','"','null'], allow_quoted_nulls = false); +-- +ok +== +FROM read_csv('{DATA_DIR}/csv/null/multiple_quoted_nulls.csv', auto_detect=false, delim=',', quote='"', escape='\', skip=0, header=true, columns={'name': 'VARCHAR', 'age': 'VARCHAR', 'height': 'VARCHAR'}, nullstr = ['','\','null'], allow_quoted_nulls = false); +-- +ok +== +FROM read_csv('{DATA_DIR}/csv/null/multiple_quoted_nulls.csv', auto_detect=false, delim=',', quote='"', escape='"', skip=0, header=true, columns={'name': 'VARCHAR', 'age': 'VARCHAR', 'height': 'VARCHAR'}, nullstr = ['','none','null','','none','null'], allow_quoted_nulls = false); +-- +ok +== +FROM read_csv('{DATA_DIR}/csv/null/multiple_nulls.csv', auto_detect=false, delim=',', quote='"', escape='"', skip=0, header=true, columns={'name': 'VARCHAR', 'age': 'VARCHAR', 'height': 'VARCHAR'}, nullstr = ['','none','null'], force_not_null = ['height']); +-- +ok +== +FROM read_csv('{DATA_DIR}/csv/null/multiple_nulls.csv', auto_detect=false, delim=',', quote='"', escape='"', skip=0, header=true, columns={'name': 'VARCHAR', 'age': 'VARCHAR', 'height': 'VARCHAR'}, nullstr = ['','none','null'], force_not_null = ['age','height']); +-- +ok +== +FROM read_csv('{DATA_DIR}/csv/null/multiple_quoted_nulls.csv', auto_detect=false, delim=',', quote='"', escape='"', skip=0, header=true, columns={'name': 'VARCHAR', 'age': 'VARCHAR', 'height': 'VARCHAR'}, nullstr = ['','none','null'], force_not_null = ['height']); +-- +ok +== +FROM read_csv('{DATA_DIR}/csv/null/multiple_quoted_nulls.csv', auto_detect=true, delim=',', quote='"', escape='"', skip=0, header=true, nullstr = ['','none','null'], force_not_null = ['age','height'], ALL_VARCHAR = 1); +-- +ok +== +select height FROM read_csv('{DATA_DIR}/csv/null/multiple_nulls.csv', delim=',', quote='"', escape='"', skip=0, header=true, nullstr = ['','none','null']); +-- +ok +== +select age FROM read_csv('{DATA_DIR}/csv/null/multiple_nulls.csv', delim=',', quote='"', escape='"', skip=0, header=true, nullstr = ['','none','null']); +-- +ok +== +FROM read_csv('{DATA_DIR}/csv/null/multiple_nulls.csv', auto_detect=false, delim=',', quote='"', escape='"', skip=0, header=true, columns={'name': 'VARCHAR', 'age': 'VARCHAR', 'height': 'VARCHAR'}, nullstr = ['','none','null'], force_not_null = ['dont_exist']); +-- +ok +== +CREATE TABLE data (a VARCHAR, b VARCHAR, c VARCHAR) +-- +ok +== +COPY data FROM '{DATA_DIR}/csv/null/multiple_nulls.csv' (nullstr ['','none','null'], HEADER 1); +-- +ok +== +COPY data FROM '{DATA_DIR}/csv/null/multiple_nulls.csv' (nullstr NULL, HEADER 1); +-- +ok +== +COPY data FROM '{DATA_DIR}/csv/null/multiple_nulls.csv' (nullstr [NULL], HEADER 1); +-- +ok +== +COPY data FROM '{DATA_DIR}/csv/null/multiple_nulls.csv' (nullstr [42], HEADER 1); +-- +ok +== +FROM data +-- +ok +== +COPY data TO '{TEMP_DIR}/multiple_nulls.csv' (nullstr ['a', 'b']); +-- +ok +== diff --git a/parser/testdata/corpus/sql/copy/csv/csv_projection_pushdown.test b/parser/testdata/corpus/sql/copy/csv/csv_projection_pushdown.test new file mode 100644 index 0000000..aa3b7b7 --- /dev/null +++ b/parser/testdata/corpus/sql/copy/csv/csv_projection_pushdown.test @@ -0,0 +1,37 @@ +# source: test/sql/copy/csv/csv_projection_pushdown.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +CREATE TABLE tbl(i INT, j VARCHAR, k DATE); +-- +ok +== +INSERT INTO tbl VALUES (42, 'hello world', NULL), (NULL, NULL, DATE '1992-01-01'), (100, 'thisisalongstring', DATE '2000-01-01'); +-- +ok +== +COPY tbl TO '{TEST_DIR}/projection_pushdown.csv' (FORMAT CSV); +-- +ok +== +CREATE VIEW v1 AS FROM read_csv_auto('{TEST_DIR}/projection_pushdown.csv', filename=True) +-- +ok +== +SELECT COUNT(*) FROM v1 +-- +ok +== +SELECT i, j, k FROM v1 ORDER BY i NULLS LAST +-- +ok +== +SELECT j FROM v1 ORDER BY j NULLS LAST +-- +ok +== +SELECT filename.replace('\', '/').split('/')[-1] FROM v1 LIMIT 1 +-- +ok +== diff --git a/parser/testdata/corpus/sql/copy/csv/csv_quoted_newline_incorrect.test b/parser/testdata/corpus/sql/copy/csv/csv_quoted_newline_incorrect.test new file mode 100644 index 0000000..0f3d6be --- /dev/null +++ b/parser/testdata/corpus/sql/copy/csv/csv_quoted_newline_incorrect.test @@ -0,0 +1,9 @@ +# source: test/sql/copy/csv/csv_quoted_newline_incorrect.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +from '{DATA_DIR}/csv/csv_quoted_newline_odd.csv'; +-- +ok +== diff --git a/parser/testdata/corpus/sql/copy/csv/csv_roundtrip_single_null.test b/parser/testdata/corpus/sql/copy/csv/csv_roundtrip_single_null.test new file mode 100644 index 0000000..094a450 --- /dev/null +++ b/parser/testdata/corpus/sql/copy/csv/csv_roundtrip_single_null.test @@ -0,0 +1,17 @@ +# source: test/sql/copy/csv/csv_roundtrip_single_null.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +COPY (SELECT NULL) TO '{TEST_DIR}/single_null.csv' (HEADER 0) +-- +ok +== +COPY integers FROM '{TEST_DIR}/single_null.csv' (HEADER 0) +-- +ok +== +FROM integers +-- +ok +== diff --git a/parser/testdata/corpus/sql/copy/csv/csv_windows_mixed_separators.test b/parser/testdata/corpus/sql/copy/csv/csv_windows_mixed_separators.test new file mode 100644 index 0000000..ca66bef --- /dev/null +++ b/parser/testdata/corpus/sql/copy/csv/csv_windows_mixed_separators.test @@ -0,0 +1,29 @@ +# source: test/sql/copy/csv/csv_windows_mixed_separators.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +SELECT * FROM '{DATA_DIR}\csv/test/date.csv' +-- +ok +== +SELECT parse_path(g)[-3:] FROM glob('{DATA_DIR}/csv\test/*.csv') t(g) WHERE g LIKE '%date.csv' +-- +ok +== +ATTACH '{TEMP_DIR}/windows_test.db' AS s1 +-- +ok +== +CREATE TABLE s1.tbl AS SELECT * FROM range(10) t(i); +-- +ok +== +SELECT SUM(i) FROM s1.tbl +-- +ok +== +ATTACH '{TEMP_DIR}\windows_test.db' AS s1 +-- +ok +== diff --git a/parser/testdata/corpus/sql/copy/csv/duck_fuzz/test_internal_4048.test b/parser/testdata/corpus/sql/copy/csv/duck_fuzz/test_internal_4048.test new file mode 100644 index 0000000..825b9ab --- /dev/null +++ b/parser/testdata/corpus/sql/copy/csv/duck_fuzz/test_internal_4048.test @@ -0,0 +1,14 @@ +# source: test/sql/copy/csv/duck_fuzz/test_internal_4048.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +FROM sniff_csv('{DATA_DIR}/csv/14512.csv', names := [NULL]); +-- +ok +== +SELECT DISTINCT NULL, c3, (c4 <= c1), (c3 BETWEEN c4 AND c2) +FROM sniff_csv('1a616242-1dcd-4914-99d1-16119d9b6e4c', "names" := ['1970-01-01'::DATE, 'infinity'::DATE, '-infinity'::DATE, NULL, '2022-05-12'::DATE], filename := '9be2bc9d-d49f-4564-bfa4-6336b211a874') AS t5(c1, c2, c3, c4) WHERE c1 GROUP BY c3 LIMIT ('c4000757-69ca-400e-b58a-1dac73b85595' IS NULL); +-- +ok +== diff --git a/parser/testdata/corpus/sql/copy/csv/empty_first_line.test b/parser/testdata/corpus/sql/copy/csv/empty_first_line.test new file mode 100644 index 0000000..b8d69e4 --- /dev/null +++ b/parser/testdata/corpus/sql/copy/csv/empty_first_line.test @@ -0,0 +1,13 @@ +# source: test/sql/copy/csv/empty_first_line.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +SELECT * FROM read_csv_auto('{DATA_DIR}/csv/empty_first_line.csv', delim=' '); +-- +ok +== +SELECT * FROM read_csv_auto('{DATA_DIR}/csv/empty_first_line.csv', delim='|', auto_detect=false, columns={'column00': 'VARCHAR'}, skip = 1); +-- +ok +== diff --git a/parser/testdata/corpus/sql/copy/csv/empty_string_quote.test b/parser/testdata/corpus/sql/copy/csv/empty_string_quote.test new file mode 100644 index 0000000..10ffef8 --- /dev/null +++ b/parser/testdata/corpus/sql/copy/csv/empty_string_quote.test @@ -0,0 +1,29 @@ +# source: test/sql/copy/csv/empty_string_quote.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +CREATE TABLE customer(c_customer_sk INTEGER, c_customer_id VARCHAR, c_current_cdemo_sk INTEGER, c_current_hdemo_sk INTEGER, c_current_addr_sk INTEGER, c_first_shipto_date_sk INTEGER, c_first_sales_date_sk INTEGER, c_salutation VARCHAR, c_first_name VARCHAR, c_last_name VARCHAR, c_preferred_cust_flag VARCHAR, c_birth_day INTEGER, c_birth_month INTEGER, c_birth_year INTEGER, c_birth_country VARCHAR, c_login VARCHAR, c_email_address VARCHAR, c_last_review_date_sk INTEGER); +-- +ok +== +COPY customer FROM '{DATA_DIR}/csv/customer.csv' (FORMAT 'csv', quote '"', delimiter ',', header 0); +-- +ok +== +SELECT * FROM customer +-- +ok +== +CREATE TABLE customer_quoted_nulls(c_customer_sk INTEGER, c_customer_id VARCHAR, c_current_cdemo_sk INTEGER, c_current_hdemo_sk INTEGER, c_current_addr_sk INTEGER, c_first_shipto_date_sk INTEGER, c_first_sales_date_sk INTEGER, c_salutation VARCHAR, c_first_name VARCHAR, c_last_name VARCHAR, c_preferred_cust_flag VARCHAR, c_birth_day INTEGER, c_birth_month INTEGER, c_birth_year INTEGER, c_birth_country VARCHAR, c_login VARCHAR, c_email_address VARCHAR, c_last_review_date_sk INTEGER); +-- +ok +== +insert into customer_quoted_nulls select * from read_csv_auto('{DATA_DIR}/csv/customer.csv', allow_quoted_nulls=False) +-- +ok +== +SELECT COUNT(c_login) FROM customer_quoted_nulls +-- +ok +== diff --git a/parser/testdata/corpus/sql/copy/csv/except.test b/parser/testdata/corpus/sql/copy/csv/except.test new file mode 100644 index 0000000..364d186 --- /dev/null +++ b/parser/testdata/corpus/sql/copy/csv/except.test @@ -0,0 +1,13 @@ +# source: test/sql/copy/csv/except.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +COPY (SELECT 1 a, 2 b) TO '{TEST_DIR}/mismatch_types_except.csv'; +-- +ok +== +FROM '{TEST_DIR}/mismatch_types_except.csv' EXCEPT select 'bla' as a, 1 as b; +-- +ok +== diff --git a/parser/testdata/corpus/sql/copy/csv/glob/copy_csv_glob.test b/parser/testdata/corpus/sql/copy/csv/glob/copy_csv_glob.test new file mode 100644 index 0000000..e08a705 --- /dev/null +++ b/parser/testdata/corpus/sql/copy/csv/glob/copy_csv_glob.test @@ -0,0 +1,21 @@ +# source: test/sql/copy/csv/glob/copy_csv_glob.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +CREATE TABLE dates(d DATE); +-- +ok +== +COPY dates FROM '{DATA_DIR}/csv/glob/a?/*.csv' (AUTO_DETECT 1); +-- +ok +== +SELECT * FROM dates ORDER BY 1 +-- +ok +== +COPY dates FROM read_csv('{DATA_DIR}/csv/glob/*/a*a.csv', auto_detect=1) +-- +error: Parser Error: syntax error at or near "'{DATA_DIR}/csv/glob/*/a*a.csv'" +== diff --git a/parser/testdata/corpus/sql/copy/csv/glob/read_csv_glob.test b/parser/testdata/corpus/sql/copy/csv/glob/read_csv_glob.test new file mode 100644 index 0000000..c616660 --- /dev/null +++ b/parser/testdata/corpus/sql/copy/csv/glob/read_csv_glob.test @@ -0,0 +1,161 @@ +# source: test/sql/copy/csv/glob/read_csv_glob.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +select typeof(#1),typeof(#2),typeof(#3),typeof(#4),typeof(#5) FROM read_csv('{DATA_DIR}/csv/per_thread/*.csv') limit 1 +-- +ok +== +select typeof(#1),typeof(#2),typeof(#3),typeof(#4),typeof(#5) FROM read_csv(['{DATA_DIR}/csv/per_thread/c1.csv', '{DATA_DIR}/csv/per_thread/c2.csv']) limit 1 +-- +ok +== +select typeof(#1),typeof(#2),typeof(#3),typeof(#4),typeof(#5) FROM read_csv(['{DATA_DIR}/csv/per_thread/c2.csv', '{DATA_DIR}/csv/per_thread/c1.csv', '{DATA_DIR}/csv/per_thread/c3.csv']) limit 1 +-- +ok +== +SELECT * FROM read_csv('{DATA_DIR}/csv/glob/a?/*.csv') ORDER BY 1 +-- +ok +== +SELECT * FROM read_csv('{DATA_DIR}/csv/glob/a?/a*.csv') ORDER BY 1 +-- +ok +== +SELECT * FROM read_csv(['{DATA_DIR}/csv/glob/a1/a1.csv', '{DATA_DIR}/csv/glob/a2/a2.csv']) ORDER BY 1 +-- +ok +== +SELECT * FROM read_csv_auto(['{DATA_DIR}/csv/glob/a1/a1.csv', '{DATA_DIR}/csv/glob/a2/a2.csv']) ORDER BY 1 +-- +ok +== +SELECT * FROM read_csv(['{DATA_DIR}/csv/glob/a?/a*.csv', '{DATA_DIR}/csv/glob/a?/a*.csv']) ORDER BY 1 +-- +ok +== +SELECT * FROM read_csv('{DATA_DIR}/csv/*/a?/a*.csv') ORDER BY 1 +-- +ok +== +SELECT a, b LIKE '%a1.csv%' FROM read_csv('{DATA_DIR}/csv/*/a?/a*.csv', filename=1) t1(a,b) ORDER BY 1 +-- +ok +== +SELECT * FROM read_csv('{DATA_DIR}/csv/glob/*/*.csv') ORDER BY 1 +-- +ok +== +SELECT * FROM read_csv('{DATA_DIR}/csv/glob/*/*.csv', columns=STRUCT_PACK(d := 'STRING'), header=1) ORDER BY 1 +-- +ok +== +SELECT a, b LIKE '%a_.csv' FROM read_csv('{DATA_DIR}/csv/glob/*/*.csv', columns=STRUCT_PACK(d := 'STRING'), filename=1, header=1) t(a,b) ORDER BY 1 +-- +ok +== +SELECT COUNT(*) FROM glob('{DATA_DIR}/csv/glob/*/*.csv') +-- +ok +== +SELECT COUNT(*) FROM glob(['{DATA_DIR}/csv/glob/*/*.csv']) +-- +ok +== +SELECT COUNT(*) FROM glob(['{DATA_DIR}/csv/glob/*/*.csv', '{DATA_DIR}/csv/glob/*/*.csv']) +-- +ok +== +SELECT COUNT(*) FROM glob('{DATA_DIR}\csv\glob\*\*.csv') +-- +ok +== +SELECT COUNT(*) FROM glob('{DATA_DIR}//csv///glob///*//////*.csv') +-- +ok +== +SELECT * FROM read_csv('{DATA_DIR}/csv/glob/*/a*a.csv') ORDER BY 1 +-- +ok +== +SELECT * FROM read_csv(['{DATA_DIR}/csv/glob/*/a*a.csv']) ORDER BY 1 +-- +ok +== +SELECT * FROM read_csv_auto(['{DATA_DIR}/csv/glob/*/a*a.csv']) ORDER BY 1 +-- +ok +== +SELECT COUNT(*) FROM glob('{DATA_DIR}/csv/glob/*/a*a.csv') +-- +ok +== +select count(*) from glob('/rewoiarwiouw3rajkawrasdf790273489*.csv') limit 10; +-- +ok +== +select count(*) from glob('~/rewoiarwiouw3rajkawrasdf790273489*.py') limit 10; +-- +ok +== +set file_search_path='{DATA_DIR}/csv/glob'; +-- +ok +== +SELECT COUNT(*) FROM glob('*/*.csv'); +-- +ok +== +set file_search_path='{DATA_DIR}/csv/glob/a1,data/csv/glob/a2'; +-- +ok +== +SELECT COUNT(*) FROM glob('*.csv'); +-- +ok +== +set file_search_path='{DATA_DIR}/csv/glob,garbage'; +-- +ok +== +SELECT COUNT(*) FROM glob('csv/glob/*/*.csv'); +-- +ok +== +set file_search_path=''; +-- +ok +== +SELECT COUNT(*) FROM glob('{DATA_DIR}/csv/glob/*/*.csv'); +-- +ok +== +SELECT * FROM read_csv_auto([]::INT[]) ORDER BY 1 +-- +ok +== +SELECT * FROM read_csv_auto([]::VARCHAR[]) ORDER BY 1 +-- +ok +== +SELECT * FROM read_csv_auto(NULL) ORDER BY 1 +-- +error: Parser Error: read_csv_auto cannot take NULL list as parameter +== +SELECT * FROM read_csv_auto([NULL]) ORDER BY 1 +-- +error: Parser Error: read_csv_auto reader cannot take NULL input as parameter +== +SELECT * FROM read_csv_auto(NULL::VARCHAR) ORDER BY 1 +-- +error: Parser Error: read_csv_auto cannot take NULL list as parameter +== +SELECT * FROM read_csv_auto(NULL::VARCHAR[]) ORDER BY 1 +-- +error: Parser Error: read_csv_auto cannot take NULL list as parameter +== +FROM read_csv('{DATA_DIR}/csv/glob/*/*.csv'); +-- +ok +== diff --git a/parser/testdata/corpus/sql/copy/csv/glob/read_csv_glob.test.metadata.json b/parser/testdata/corpus/sql/copy/csv/glob/read_csv_glob.test.metadata.json new file mode 100644 index 0000000..bee18ab --- /dev/null +++ b/parser/testdata/corpus/sql/copy/csv/glob/read_csv_glob.test.metadata.json @@ -0,0 +1,8 @@ +{ + "todo": { + "0f661413e61de6d5": "transformer-raised parser error: upstream rejects in the transformer, not the grammar; expected to clear as transformers land (milestones 3-5)", + "1744b353dc7a29b0": "transformer-raised parser error: upstream rejects in the transformer, not the grammar; expected to clear as transformers land (milestones 3-5)", + "715542898e8196a6": "transformer-raised parser error: upstream rejects in the transformer, not the grammar; expected to clear as transformers land (milestones 3-5)", + "7416adf675a44fe4": "transformer-raised parser error: upstream rejects in the transformer, not the grammar; expected to clear as transformers land (milestones 3-5)" + } +} diff --git a/parser/testdata/corpus/sql/copy/csv/glob/test_unmatch_globs.test b/parser/testdata/corpus/sql/copy/csv/glob/test_unmatch_globs.test new file mode 100644 index 0000000..e564c3c --- /dev/null +++ b/parser/testdata/corpus/sql/copy/csv/glob/test_unmatch_globs.test @@ -0,0 +1,21 @@ +# source: test/sql/copy/csv/glob/test_unmatch_globs.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +FROM '{DATA_DIR}/csv/glob_dif_dialect/14166/__200*.csv'; +-- +ok +== +FROM read_csv(['{DATA_DIR}/csv/glob_dif_dialect/14166/__2000.csv', '{DATA_DIR}/csv/glob_dif_dialect/14166/__2001.csv', '{DATA_DIR}/csv/glob_dif_dialect/14166/empty.csv']); +-- +ok +== +FROM read_csv(['{DATA_DIR}/csv/glob_dif_dialect/14166/__2000.csv','{DATA_DIR}/csv/glob_dif_dialect/14166/matching_types.csv']); +-- +ok +== +FROM '{DATA_DIR}/csv/glob_dif_dialect/f_*.csv' order by all +-- +ok +== diff --git a/parser/testdata/corpus/sql/copy/csv/inconsistent_cells_error.test b/parser/testdata/corpus/sql/copy/csv/inconsistent_cells_error.test new file mode 100644 index 0000000..18070d6 --- /dev/null +++ b/parser/testdata/corpus/sql/copy/csv/inconsistent_cells_error.test @@ -0,0 +1,9 @@ +# source: test/sql/copy/csv/inconsistent_cells_error.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +from '{DATA_DIR}/csv/inconsistent_cells.csv' +-- +ok +== diff --git a/parser/testdata/corpus/sql/copy/csv/integer_exponent.test b/parser/testdata/corpus/sql/copy/csv/integer_exponent.test new file mode 100644 index 0000000..2f11c6e --- /dev/null +++ b/parser/testdata/corpus/sql/copy/csv/integer_exponent.test @@ -0,0 +1,9 @@ +# source: test/sql/copy/csv/integer_exponent.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +from '{DATA_DIR}/csv/integer_exponent.csv' +-- +ok +== diff --git a/parser/testdata/corpus/sql/copy/csv/issue_22153.test b/parser/testdata/corpus/sql/copy/csv/issue_22153.test new file mode 100644 index 0000000..4cecfdb --- /dev/null +++ b/parser/testdata/corpus/sql/copy/csv/issue_22153.test @@ -0,0 +1,13 @@ +# source: test/sql/copy/csv/issue_22153.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +COPY (SELECT 'hello "world"' AS a, 42 AS b) TO '{TEST_DIR}/test_escape_default.csv' (HEADER false); +-- +ok +== +SELECT * FROM read_csv('{TEST_DIR}/test_escape_default.csv', auto_detect=false, columns={'a':'VARCHAR','b':'INTEGER'}) +-- +ok +== diff --git a/parser/testdata/corpus/sql/copy/csv/issue_6690.test b/parser/testdata/corpus/sql/copy/csv/issue_6690.test new file mode 100644 index 0000000..e263a26 --- /dev/null +++ b/parser/testdata/corpus/sql/copy/csv/issue_6690.test @@ -0,0 +1,13 @@ +# source: test/sql/copy/csv/issue_6690.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +FROM read_csv_auto('{DATA_DIR}/csv/comma_decimal_null.csv',SEP=',',SAMPLE_SIZE=-1,decimal_separator=',') +-- +ok +== +SELECT FINANZ_STATO_FSC FROM read_csv_auto('{DATA_DIR}/csv/comma_decimal_null.csv',SEP=',',SAMPLE_SIZE=-1,decimal_separator=',') +-- +ok +== diff --git a/parser/testdata/corpus/sql/copy/csv/issue_6764.test b/parser/testdata/corpus/sql/copy/csv/issue_6764.test new file mode 100644 index 0000000..0741705 --- /dev/null +++ b/parser/testdata/corpus/sql/copy/csv/issue_6764.test @@ -0,0 +1,29 @@ +# source: test/sql/copy/csv/issue_6764.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +FROM read_csv_auto('{DATA_DIR}/csv/issue6764.csv', all_varchar=true, skip=1, null_padding=True) +-- +ok +== +FROM read_csv_auto('{DATA_DIR}/csv/issue6764.csv', all_varchar=true, header=false, skip=1, null_padding=True) +-- +ok +== +FROM read_csv_auto('{DATA_DIR}/csv/issue6764.csv', null_padding=True) +-- +ok +== +FROM read_csv_auto('{DATA_DIR}/csv/issue6764.csv', all_varchar=true, null_padding=True) +-- +ok +== +FROM read_csv_auto('{DATA_DIR}/csv/issue6764.csv', header=false, null_padding=True) +-- +ok +== +FROM read_csv_auto('{DATA_DIR}/csv/issue6764.csv', all_varchar=true, header=false, skip=0, sep=',', null_padding=True) +-- +ok +== diff --git a/parser/testdata/corpus/sql/copy/csv/leading_zeros_autodetect.test b/parser/testdata/corpus/sql/copy/csv/leading_zeros_autodetect.test new file mode 100644 index 0000000..81eb3fe --- /dev/null +++ b/parser/testdata/corpus/sql/copy/csv/leading_zeros_autodetect.test @@ -0,0 +1,37 @@ +# source: test/sql/copy/csv/leading_zeros_autodetect.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +CREATE TABLE leading_zeros AS SELECT * FROM read_csv_auto('{DATA_DIR}/csv/leading_zeros.csv') +-- +ok +== +SELECT CODGEO FROM leading_zeros LIMIT 1; +-- +ok +== +SELECT typeof(CODGEO) FROM leading_zeros LIMIT 1; +-- +ok +== +CREATE TABLE leading_zeros2 AS SELECT * FROM read_csv_auto('{DATA_DIR}/csv/leading_zeros2.csv') +-- +ok +== +SELECT * FROM leading_zeros2; +-- +ok +== +SELECT typeof(comune), typeof(codice_regione), typeof(codice_provincia) FROM leading_zeros2 LIMIT 1; +-- +ok +== +select '09001'::int; +-- +ok +== +select '00009001'::int; +-- +ok +== diff --git a/parser/testdata/corpus/sql/copy/csv/multidelimiter/test_2_byte_delimiter.test b/parser/testdata/corpus/sql/copy/csv/multidelimiter/test_2_byte_delimiter.test new file mode 100644 index 0000000..3b8dc07 --- /dev/null +++ b/parser/testdata/corpus/sql/copy/csv/multidelimiter/test_2_byte_delimiter.test @@ -0,0 +1,29 @@ +# source: test/sql/copy/csv/multidelimiter/test_2_byte_delimiter.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +FROM read_csv('{DATA_DIR}/csv/multidelimiter/aa_delim_small.csv', delim = 'aa', header = False, buffer_size = 8) +-- +ok +== +FROM read_csv('{DATA_DIR}/csv/multidelimiter/ab_delim.csv', delim = 'ab', header = False, buffer_size = {buffer_size}) +-- +error: Parser Error: syntax error at or near "}" +== +FROM read_csv('{DATA_DIR}/csv/multidelimiter/aa_delim.csv', delim = 'aa', header = False, buffer_size = {buffer_size}) +-- +error: Parser Error: syntax error at or near "}" +== +FROM read_csv('{DATA_DIR}/csv/multidelimiter/aa_delim_quoted.csv', delim = 'aa', header = False, buffer_size = {buffer_size}) +-- +error: Parser Error: syntax error at or near "}" +== +FROM read_csv('{DATA_DIR}/csv/multidelimiter/aa_delim_quoted_2.csv', delim = 'aa', header = False, buffer_size = {buffer_size}) +-- +error: Parser Error: syntax error at or near "}" +== +FROM read_csv('{DATA_DIR}/csv/multidelimiter/many_bytes.csv', delim = '\|', header = False) +-- +ok +== diff --git a/parser/testdata/corpus/sql/copy/csv/multidelimiter/test_3_4_byte_delimiter.test b/parser/testdata/corpus/sql/copy/csv/multidelimiter/test_3_4_byte_delimiter.test new file mode 100644 index 0000000..715afc7 --- /dev/null +++ b/parser/testdata/corpus/sql/copy/csv/multidelimiter/test_3_4_byte_delimiter.test @@ -0,0 +1,17 @@ +# source: test/sql/copy/csv/multidelimiter/test_3_4_byte_delimiter.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +FROM read_csv('{DATA_DIR}/csv/multidelimiter/aaa_delim.csv', delim = 'aaa', header = False, buffer_size = {buffer_size}) +-- +error: Parser Error: syntax error at or near "}" +== +FROM read_csv('{DATA_DIR}/csv/multidelimiter/aaaa_delim.csv', delim = 'aaaa', header = False, buffer_size = {buffer_size}) +-- +error: Parser Error: syntax error at or near "}" +== +FROM read_csv('{DATA_DIR}/csv/multidelimiter/aaaa_delim_rn.csv', delim = 'aaaa', header = False, buffer_size = {buffer_size}) +-- +error: Parser Error: syntax error at or near "}" +== diff --git a/parser/testdata/corpus/sql/copy/csv/multidelimiter/test_abac.test b/parser/testdata/corpus/sql/copy/csv/multidelimiter/test_abac.test new file mode 100644 index 0000000..e598029 --- /dev/null +++ b/parser/testdata/corpus/sql/copy/csv/multidelimiter/test_abac.test @@ -0,0 +1,101 @@ +# source: test/sql/copy/csv/multidelimiter/test_abac.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +FROM read_csv('{DATA_DIR}/csv/multidelimiter/aaab_delim.csv', delim = 'AAAB') +-- +ok +== +FROM read_csv('{DATA_DIR}/csv/multidelimiter/aab_delim.csv', delim = 'AAB') +-- +ok +== +CREATE TABLE abac_tbl (a VARCHAR, b VARCHAR, c VARCHAR); +-- +ok +== +COPY abac_tbl FROM '{DATA_DIR}/csv/multidelimiter/abac.csv' (DELIMITER 'ABAC', AUTO_DETECT FALSE); +-- +ok +== +SELECT * FROM abac_tbl +-- +ok +== +DELETE FROM abac_tbl; +-- +ok +== +DROP TABLE abac_tbl +-- +ok +== +CREATE TABLE abac_tbl (a VARCHAR); +-- +ok +== +COPY abac_tbl FROM '{DATA_DIR}/csv/multidelimiter/simple_unterminated_quote.csv' (QUOTE '"', AUTO_DETECT FALSE, strict_mode TRUE); +-- +ok +== +COPY abac_tbl FROM '{DATA_DIR}/csv/multidelimiter/file_ends_in_quoted_value.csv' (QUOTE '"', AUTO_DETECT FALSE); +-- +ok +== +COPY abac_tbl FROM '{DATA_DIR}/csv/multidelimiter/file_ends_in_quoted_value.csv' (QUOTE '"', DELIMITER 'AAAB', AUTO_DETECT FALSE); +-- +ok +== +COPY abac_tbl FROM '{DATA_DIR}/csv/multidelimiter/unterminated_quote_with_escape.csv' (QUOTE '"', ESCAPE '|', AUTO_DETECT FALSE, strict_mode TRUE); +-- +ok +== +COPY abac_tbl FROM '{DATA_DIR}/csv/multidelimiter/unterminated_quote_escape.csv' (QUOTE '"', ESCAPE '"', AUTO_DETECT FALSE, strict_mode TRUE); +-- +ok +== +COPY abac_tbl FROM '{DATA_DIR}/csv/multidelimiter/unterminated_escape.csv' (QUOTE '"', ESCAPE '''', AUTO_DETECT FALSE, strict_mode TRUE); +-- +ok +== +COPY abac_tbl FROM '{DATA_DIR}/csv/multidelimiter/incomplete_multibyte_delimiter.csv' (DELIMITER 'ABAC', AUTO_DETECT FALSE, quote '"', strict_mode TRUE); +-- +ok +== +COPY abac_tbl FROM '{DATA_DIR}/csv/multidelimiter/incomplete_multibyte_delimiter.csv' (DELIMITER 'AB', AUTO_DETECT FALSE , quote '"'); +-- +ok +== +COPY abac_tbl FROM '{DATA_DIR}/csv/multidelimiter/abac.csv' (DELIMITER 'aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa', AUTO_DETECT FALSE); +-- +ok +== +CREATE TABLE abac_tbl (a VARCHAR, b VARCHAR); +-- +ok +== +COPY abac_tbl FROM '{DATA_DIR}/csv/multidelimiter/carriage_feed_newline.csv' (DELIMITER 'BA', AUTO_DETECT FALSE); +-- +ok +== +COPY abac_tbl FROM '{DATA_DIR}/csv/multidelimiter/windows_newline.csv' (DELIMITER 'BA', AUTO_DETECT FALSE); +-- +ok +== +COPY abac_tbl FROM '{DATA_DIR}/csv/multidelimiter/unterminated_quote_multi_line.csv' (DELIMITER 'BA', AUTO_DETECT FALSE, strict_mode TRUE); +-- +ok +== +COPY abac_tbl FROM '{DATA_DIR}/csv/multidelimiter/unquote_without_delimiter.csv' (DELIMITER 'BA', AUTO_DETECT FALSE, strict_mode TRUE); +-- +ok +== +COPY abac_tbl FROM '{DATA_DIR}/csv/multidelimiter/trailing_delimiter_complex.csv' (DELIMITER 'BA', AUTO_DETECT FALSE); +-- +ok +== +COPY abac_tbl FROM '{DATA_DIR}/csv/multidelimiter/trailing_delimiter.csv' (DELIMITER '|', AUTO_DETECT FALSE); +-- +ok +== diff --git a/parser/testdata/corpus/sql/copy/csv/multidelimiter/test_options_inconsistencies.test b/parser/testdata/corpus/sql/copy/csv/multidelimiter/test_options_inconsistencies.test new file mode 100644 index 0000000..6041193 --- /dev/null +++ b/parser/testdata/corpus/sql/copy/csv/multidelimiter/test_options_inconsistencies.test @@ -0,0 +1,17 @@ +# source: test/sql/copy/csv/multidelimiter/test_options_inconsistencies.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +FROM read_csv('{DATA_DIR}/csv/multidelimiter/aaa_delim.csv', delim = '"\', quote ='"') +-- +ok +== +FROM read_csv('{DATA_DIR}/csv/multidelimiter/aaa_delim.csv', delim = '\\', escape ='\') +-- +ok +== +FROM read_csv('{DATA_DIR}/csv/multidelimiter/aaa_delim.csv', delim = '|#', comment ='#', auto_detect = false, columns = {'a': 'varchar'}) +-- +ok +== diff --git a/parser/testdata/corpus/sql/copy/csv/null_padding_big.test b/parser/testdata/corpus/sql/copy/csv/null_padding_big.test new file mode 100644 index 0000000..3765b3f --- /dev/null +++ b/parser/testdata/corpus/sql/copy/csv/null_padding_big.test @@ -0,0 +1,45 @@ +# source: test/sql/copy/csv/null_padding_big.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +CREATE TABLE test (a VARCHAR, b INTEGER, c INTEGER); +-- +ok +== +INSERT INTO test SELECT * FROM read_csv_auto('{DATA_DIR}/csv/nullpadding_big_mixed.csv', null_padding=True) +-- +ok +== +SELECT COUNT(*) FROM read_csv_auto('{DATA_DIR}/csv/nullpadding_big_mixed.csv', null_padding=True) +-- +ok +== +SELECT COUNT(*) FROM read_csv_auto('{DATA_DIR}/csv/nullpadding_big_mixed.csv', null_padding=False, ignore_errors=True) +-- +ok +== +SELECT COUNT(*) FROM read_csv_auto('{DATA_DIR}/csv/nullpadding_big_mixed.csv') +-- +ok +== +CREATE TABLE test2 (a VARCHAR, b INTEGER, c INTEGER, d INTEGER); +-- +ok +== +SELECT COUNT(*) FROM read_csv_auto('{DATA_DIR}/csv/nullpadding_commas.csv', null_padding=True) +-- +ok +== +SELECT COUNT(*) FROM read_csv('{DATA_DIR}/csv/nullpadding_commas.csv', sep=',', columns={'a': INT, 'b': INT, 'c': INT, 'd': INT}, ignore_errors=True, null_padding=False) +-- +ok +== +SELECT COUNT(*) FROM read_csv_auto('{DATA_DIR}/csv/nullpadding_big_mixed.csv', buffer_size=55) +-- +ok +== +SELECT COUNT(*) FROM read_csv_auto('{DATA_DIR}/csv/nullpadding_big_mixed.csv', buffer_size=55, null_padding=False) +-- +ok +== diff --git a/parser/testdata/corpus/sql/copy/csv/null_terminator.test b/parser/testdata/corpus/sql/copy/csv/null_terminator.test new file mode 100644 index 0000000..158c457 --- /dev/null +++ b/parser/testdata/corpus/sql/copy/csv/null_terminator.test @@ -0,0 +1,33 @@ +# source: test/sql/copy/csv/null_terminator.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +FROM '{DATA_DIR}/csv/null_terminator.csv' +-- +ok +== +FROM read_csv('{DATA_DIR}/csv/null_terminator.csv', header = 0) +-- +ok +== +FROM read_csv('{DATA_DIR}/csv/null_terminator.csv', header = 0, escape = '') +-- +ok +== +FROM read_csv('{DATA_DIR}/csv/null_terminator.csv', header = 0, delim = '\t', quote = '', escape = '') +-- +ok +== +create or replace table t as (from values ('a' || chr(0) || 'b') t(i)); +-- +ok +== +copy t to '{TEMP_DIR}/csv2tsv.tsv' (header false, delimiter '\t', escape '', quote ''); +-- +ok +== +FROM read_csv('{TEMP_DIR}/csv2tsv.tsv', header = 0) +-- +ok +== diff --git a/parser/testdata/corpus/sql/copy/csv/null_value_wrong_type.test b/parser/testdata/corpus/sql/copy/csv/null_value_wrong_type.test new file mode 100644 index 0000000..8ce6349 --- /dev/null +++ b/parser/testdata/corpus/sql/copy/csv/null_value_wrong_type.test @@ -0,0 +1,9 @@ +# source: test/sql/copy/csv/null_value_wrong_type.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +describe from '{DATA_DIR}/csv/null_mismatch.csv' +-- +ok +== diff --git a/parser/testdata/corpus/sql/copy/csv/overwrite/test_copy_overwrite.test b/parser/testdata/corpus/sql/copy/csv/overwrite/test_copy_overwrite.test new file mode 100644 index 0000000..3f57ed2 --- /dev/null +++ b/parser/testdata/corpus/sql/copy/csv/overwrite/test_copy_overwrite.test @@ -0,0 +1,41 @@ +# source: test/sql/copy/csv/overwrite/test_copy_overwrite.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +CREATE TABLE test (a INTEGER, b VARCHAR(10)); +-- +ok +== +INSERT INTO test VALUES (1, 'hello'), (2, 'world '), (3, ' xx'); +-- +ok +== +SELECT * FROM test ORDER BY 1; +-- +ok +== +COPY test TO '{TEST_DIR}/overwrite.csv'; +-- +ok +== +COPY (SELECT * FROM test LIMIT 2) TO '{TEST_DIR}/overwrite.csv'; +-- +ok +== +DELETE FROM test; +-- +ok +== +COPY test FROM '{TEST_DIR}/overwrite.csv'; +-- +ok +== +COPY (SELECT i FROM range(1) tbl(i) UNION ALL SELECT concat('hello', i)::INT i FROM range(1) tbl(i)) to '{TEST_DIR}/overwrite.csv'; +-- +ok +== +COPY (SELECT i FROM range(1) tbl(i) UNION ALL SELECT concat('hello', i)::INT i FROM range(1) tbl(i)) to '{TEST_DIR}/overwrite.csv' (USE_TMP_FILE FALSE); +-- +ok +== diff --git a/parser/testdata/corpus/sql/copy/csv/overwrite/test_overwrite_pipe_windows.test b/parser/testdata/corpus/sql/copy/csv/overwrite/test_overwrite_pipe_windows.test new file mode 100644 index 0000000..5171b8b --- /dev/null +++ b/parser/testdata/corpus/sql/copy/csv/overwrite/test_overwrite_pipe_windows.test @@ -0,0 +1,9 @@ +# source: test/sql/copy/csv/overwrite/test_overwrite_pipe_windows.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +copy (select 42) to 'con:' +-- +ok +== diff --git a/parser/testdata/corpus/sql/copy/csv/parallel/csv_parallel_buffer_size.test b/parser/testdata/corpus/sql/copy/csv/parallel/csv_parallel_buffer_size.test new file mode 100644 index 0000000..7f3edf8 --- /dev/null +++ b/parser/testdata/corpus/sql/copy/csv/parallel/csv_parallel_buffer_size.test @@ -0,0 +1,49 @@ +# source: test/sql/copy/csv/parallel/csv_parallel_buffer_size.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +SELECT sum(a), sum(b), sum(c) FROM read_csv('{DATA_DIR}/csv/test/multi_column_integer.csv', COLUMNS=STRUCT_PACK(a := 'INTEGER', b := 'INTEGER', c := 'INTEGER'), auto_detect='true', delim = '|', buffer_size=30) +-- +ok +== +SELECT sum(a) FROM read_csv('{DATA_DIR}/csv/test/multi_column_integer.csv', COLUMNS=STRUCT_PACK(a := 'INTEGER', b := 'INTEGER', c := 'INTEGER'), auto_detect='true', delim = '|', buffer_size=30) +-- +ok +== +SELECT sum(a) FROM read_csv('{DATA_DIR}/csv/test/multi_column_integer_rn.csv', COLUMNS=STRUCT_PACK(a := 'INTEGER', b := 'INTEGER', c := 'INTEGER'), auto_detect='true', delim = '|', buffer_size=30) +-- +ok +== +select * from read_csv('{DATA_DIR}/csv/test/multi_column_string.csv', COLUMNS=STRUCT_PACK(a := 'INTEGER', b := 'INTEGER', c := 'INTEGER', d := 'VARCHAR'), auto_detect='true', delim = '|', buffer_size=30) +-- +ok +== +select * from read_csv('{DATA_DIR}/csv/test/multi_column_string_rn.csv', COLUMNS=STRUCT_PACK(a := 'INTEGER', b := 'INTEGER', c := 'INTEGER', d := 'VARCHAR'), auto_detect='true', delim = '|', buffer_size=27) +-- +ok +== +SELECT sum(a) FROM read_csv('{DATA_DIR}/csv/test/new_line_string_rn.csv', COLUMNS=STRUCT_PACK(a := 'INTEGER', b := 'INTEGER', c := 'INTEGER', d := 'VARCHAR'), auto_detect='true', delim = '|') +-- +ok +== +SELECT sum(a) FROM read_csv('{DATA_DIR}/csv/test/new_line_string_rn.csv', COLUMNS=STRUCT_PACK(a := 'INTEGER', b := 'INTEGER', c := 'INTEGER', d := 'VARCHAR'), auto_detect='true', delim = '|', buffer_size=100) +-- +ok +== +SELECT sum(a) FROM read_csv('{DATA_DIR}/csv/test/new_line_string_rn_exc.csv', COLUMNS=STRUCT_PACK(a := 'INTEGER', b := 'INTEGER', c := 'INTEGER', d := 'VARCHAR'), auto_detect='true', delim = '|') +-- +ok +== +SELECT sum(a) FROM read_csv('{DATA_DIR}/csv/test/new_line_string_rn_exc.csv', COLUMNS=STRUCT_PACK(a := 'INTEGER', b := 'INTEGER', c := 'INTEGER', d := 'VARCHAR'), auto_detect='true', delim = '|', buffer_size=80) +-- +ok +== +SELECT sum(a) FROM read_csv('{DATA_DIR}/csv/test/new_line_string.csv', COLUMNS=STRUCT_PACK(a := 'INTEGER', b := 'INTEGER', c := 'INTEGER', d := 'VARCHAR'), auto_detect='true', delim = '|') +-- +ok +== +SELECT sum(a) FROM read_csv('{DATA_DIR}/csv/test/new_line_string.csv', COLUMNS=STRUCT_PACK(a := 'INTEGER', b := 'INTEGER', c := 'INTEGER', d := 'VARCHAR'), quote ='"', escape ='"', comment = '', auto_detect='true', delim = '|', buffer_size=100, new_line = '\r\n', strict_mode = false) +-- +ok +== diff --git a/parser/testdata/corpus/sql/copy/csv/parallel/csv_parallel_null_option.test b/parser/testdata/corpus/sql/copy/csv/parallel/csv_parallel_null_option.test new file mode 100644 index 0000000..29eeccb --- /dev/null +++ b/parser/testdata/corpus/sql/copy/csv/parallel/csv_parallel_null_option.test @@ -0,0 +1,51 @@ +# source: test/sql/copy/csv/parallel/csv_parallel_null_option.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +PRAGMA enable_profiling +-- +ok +== +PRAGMA profiling_output='{TEST_DIR}/test.txt' +-- +ok +== +PRAGMA profiling_mode = detailed +-- +ok +== +SELECT min (i + i) FROM integers +-- +ok +== +CREATE TABLE exprtest (a INTEGER, b INTEGER) +-- +ok +== +INSERT INTO exprtest VALUES (42, 10), (43, 100), (NULL, 1), (45, -1) +-- +ok +== +SELECT min (a + a ) FROM exprtest +-- +ok +== +SELECT a FROM exprtest WHERE a BETWEEN 43 AND 44 +-- +ok +== +SELECT CASE a WHEN 42 THEN 100 WHEN 43 THEN 200 ELSE 300 END FROM exprtest +-- +ok +== +PRAGMA profiling_output='{TEST_DIR}/test_2.txt' +-- +ok +== +SELECT COUNT(*) > 0 +FROM read_csv('{TEST_DIR}/test.txt', columns={'c': 'VARCHAR'}, delim=NULL, header=0, quote=NULL, escape=NULL, auto_detect = false) +WHERE contains(c, 'Total Time'); +-- +ok +== diff --git a/parser/testdata/corpus/sql/copy/csv/parallel/parallel_csv_hive_partitioning.test b/parser/testdata/corpus/sql/copy/csv/parallel/parallel_csv_hive_partitioning.test new file mode 100644 index 0000000..7298ec6 --- /dev/null +++ b/parser/testdata/corpus/sql/copy/csv/parallel/parallel_csv_hive_partitioning.test @@ -0,0 +1,13 @@ +# source: test/sql/copy/csv/parallel/parallel_csv_hive_partitioning.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +select id, value, filename.replace('\', '/').split('/')[-2], filename.replace('\', '/').split('/')[-3] from read_csv_auto('{DATA_DIR}/csv/hive-partitioning/simple/*/*/test.csv', FILENAME=1) order by id +-- +ok +== +select part, value, date from read_csv_auto('{DATA_DIR}/csv/hive-partitioning/simple/*/*/test.csv', HIVE_PARTITIONING=1) order by 1 +-- +ok +== diff --git a/parser/testdata/corpus/sql/copy/csv/parallel/parallel_csv_union_by_name.test b/parser/testdata/corpus/sql/copy/csv/parallel/parallel_csv_union_by_name.test new file mode 100644 index 0000000..57d0fee --- /dev/null +++ b/parser/testdata/corpus/sql/copy/csv/parallel/parallel_csv_union_by_name.test @@ -0,0 +1,41 @@ +# source: test/sql/copy/csv/parallel/parallel_csv_union_by_name.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +SELECT id, value, a, part +FROM read_csv_auto('{DATA_DIR}/csv/union-by-name/part=[ab]/*',HIVE_PARTITIONING=TRUE ,UNION_BY_NAME=TRUE) +ORDER BY id +-- +ok +== +SELECT k, c, ts, parse_filename(filename) +FROM read_csv_auto('{DATA_DIR}/csv/union-by-name/ubn[!1-2].csv',FILENAME=TRUE ,UNION_BY_NAME=TRUE) +ORDER BY c +-- +ok +== +SELECT a, b, c, ts, k +FROM read_csv_auto('{DATA_DIR}/csv/union-by-name/ubn*.csv',UNION_BY_NAME=TRUE) +ORDER BY a, c, ts +-- +ok +== +SELECT typeof(a), typeof(b), typeof(c), typeof(ts), typeof(k) +FROM read_csv_auto('{DATA_DIR}/csv/union-by-name/ubn*.csv',UNION_BY_NAME=TRUE) +LIMIT 1; +-- +ok +== +SELECT c, k +FROM read_csv_auto('{DATA_DIR}/csv/union-by-name/ubn*.csv',UNION_BY_NAME=TRUE) +ORDER BY c NULLS LAST, k NULLS LAST +-- +ok +== +SELECT ts +FROM read_csv_auto('{DATA_DIR}/csv/union-by-name/ubn*.csv',UNION_BY_NAME=TRUE) +ORDER BY ts NULLS LAST +-- +ok +== diff --git a/parser/testdata/corpus/sql/copy/csv/parallel/test_5438.test b/parser/testdata/corpus/sql/copy/csv/parallel/test_5438.test new file mode 100644 index 0000000..9aa3c75 --- /dev/null +++ b/parser/testdata/corpus/sql/copy/csv/parallel/test_5438.test @@ -0,0 +1,9 @@ +# source: test/sql/copy/csv/parallel/test_5438.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +SELECT j->>'duck' FROM read_csv_auto('{DATA_DIR}/csv/test/5438.csv', delim='', columns={'j': 'JSON'}, auto_detect = false) +-- +ok +== diff --git a/parser/testdata/corpus/sql/copy/csv/parallel/test_5566.test b/parser/testdata/corpus/sql/copy/csv/parallel/test_5566.test new file mode 100644 index 0000000..9d15d0c --- /dev/null +++ b/parser/testdata/corpus/sql/copy/csv/parallel/test_5566.test @@ -0,0 +1,21 @@ +# source: test/sql/copy/csv/parallel/test_5566.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +select * from read_csv_auto('{DATA_DIR}/csv/auto/test_single_column.csv') +-- +ok +== +select * from read_csv_auto('{DATA_DIR}/csv/auto/test_single_column_rn.csv') +-- +ok +== +select foo, count(1) cnt from read_csv_auto('{DATA_DIR}/csv/auto/test_multiple_columns.csv') group by foo order by cnt desc +-- +ok +== +select foo, count(1) cnt from read_csv_auto('{DATA_DIR}/csv/auto/test_multiple_columns_rn.csv') group by foo order by cnt desc +-- +ok +== diff --git a/parser/testdata/corpus/sql/copy/csv/parallel/test_7578.test b/parser/testdata/corpus/sql/copy/csv/parallel/test_7578.test new file mode 100644 index 0000000..2f9b217 --- /dev/null +++ b/parser/testdata/corpus/sql/copy/csv/parallel/test_7578.test @@ -0,0 +1,41 @@ +# source: test/sql/copy/csv/parallel/test_7578.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +select * +from read_csv('{DATA_DIR}/csv/bug_7578.csv', delim='\t', quote = '`', columns={ + 'transaction_id': 'VARCHAR', + 'team_id': 'INT', + 'direction': 'INT', + 'amount':'DOUBLE', + 'account_id':'INT', + 'transaction_date':'DATE', + 'recorded_date':'DATE', + 'tags.transaction_id':'VARCHAR', + 'tags.team_id':'INT', + 'tags':'varchar' +}) order by all +-- +ok +== +pragma threads=2 +-- +ok +== +select * +from read_csv('{DATA_DIR}/csv/bug_7578.csv', delim='\t', columns={ + 'transaction_id': 'VARCHAR', + 'team_id': 'INT', + 'direction': 'INT', + 'amount':'DOUBLE', + 'account_id':'INT', + 'transaction_date':'DATE', + 'recorded_date':'DATE', + 'tags.transaction_id':'VARCHAR', + 'tags.team_id':'INT', + 'tags':'varchar' +}) +-- +ok +== diff --git a/parser/testdata/corpus/sql/copy/csv/parallel/test_multiple_files.test b/parser/testdata/corpus/sql/copy/csv/parallel/test_multiple_files.test new file mode 100644 index 0000000..bad7172 --- /dev/null +++ b/parser/testdata/corpus/sql/copy/csv/parallel/test_multiple_files.test @@ -0,0 +1,21 @@ +# source: test/sql/copy/csv/parallel/test_multiple_files.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +select * from read_csv_auto('{DATA_DIR}/csv/auto/glob/[0-9].csv'); +-- +ok +== +select * from read_csv_auto('{DATA_DIR}/csv/auto/glob/[0-9].csv', buffer_size=100) +-- +ok +== +select * from read_csv('{DATA_DIR}/csv/auto/glob/[0-9].csv', AUTO_DETECT=true) +-- +ok +== +select * from read_csv('{DATA_DIR}/csv/auto/glob/[0-9].csv', sample_size=-1, new_line = '\r\n', columns={'row_id':'BIGINT','integer':'INTEGER','float':'DOUBLE', 'text':'VARCHAR'}) +-- +ok +== diff --git a/parser/testdata/corpus/sql/copy/csv/parallel/test_parallel_csv.test b/parser/testdata/corpus/sql/copy/csv/parallel/test_parallel_csv.test new file mode 100644 index 0000000..9480cd9 --- /dev/null +++ b/parser/testdata/corpus/sql/copy/csv/parallel/test_parallel_csv.test @@ -0,0 +1,25 @@ +# source: test/sql/copy/csv/parallel/test_parallel_csv.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +FROM read_csv('{DATA_DIR}/csv/14512_og.csv', buffer_size = 473, strict_mode = false, delim = ',', quote = '"', escape = '"') +-- +ok +== +select * from read_csv_auto('{DATA_DIR}/csv/dirty_line.csv', skip = 1) +-- +ok +== +select * from read_csv_auto('{DATA_DIR}/csv/null_string.csv', nullstr="null") +-- +ok +== +select * from read_csv_auto('{DATA_DIR}/csv/null_string.csv', header = false) +-- +ok +== +select * from read_csv_auto('{DATA_DIR}/csv/aws_locations.csv') +-- +ok +== diff --git a/parser/testdata/corpus/sql/copy/csv/parallel/test_parallel_error_messages.test b/parser/testdata/corpus/sql/copy/csv/parallel/test_parallel_error_messages.test new file mode 100644 index 0000000..31dad8c --- /dev/null +++ b/parser/testdata/corpus/sql/copy/csv/parallel/test_parallel_error_messages.test @@ -0,0 +1,97 @@ +# source: test/sql/copy/csv/parallel/test_parallel_error_messages.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +SET threads=4 +-- +ok +== +SET preserve_insertion_order={batched} +-- +error: Parser Error: syntax error at or near "}" +== +SELECT * FROM read_csv('{DATA_DIR}/csv/missing_column.csv', sep=',', buffer_size=100, columns={'h1': int, 'h2': varchar}, header=True, auto_detect = false) +-- +ok +== +SELECT * FROM read_csv('{DATA_DIR}/csv/wrongtype.csv', sep=',', buffer_size=100, columns={'h1': int, 'h2': varchar}, header=True) +-- +ok +== +SELECT * FROM read_csv('{DATA_DIR}/csv/wrongtype.csv', sep=',', buffer_size=100, columns={'h1': int, 'h2': varchar}, header=True, auto_detect = false) +-- +ok +== +SELECT * FROM read_csv('{DATA_DIR}/csv/wrongtype.csv', sep=',', columns={'h1': int, 'h2': varchar}, header=True) +-- +ok +== +SELECT * FROM read_csv('{DATA_DIR}/csv/error/mixedtypes.csv', parallel=false, sep=',', columns={'h1': int, 'h2': varchar}, header=True) +-- +ok +== +SELECT * FROM read_csv('{DATA_DIR}/csv/error/mixedtypes.csv', parallel=true, sep=',', buffer_size=100, columns={'h1': int, 'h2': varchar}, header=True) +-- +ok +== +SELECT * FROM read_csv('{DATA_DIR}/csv/error/mixedtypes.csv', parallel=false, sep=',', buffer_size=100, columns={'h1': int, 'h2': varchar}, header=True) +-- +ok +== +SELECT * FROM read_csv('{DATA_DIR}/csv/error/mixedtypes_rn.csv', parallel=false, sep=',', columns={'h1': int, 'h2': varchar}, header=True) +-- +ok +== +SELECT * FROM read_csv('{DATA_DIR}/csv/error/mixedtypes_rn.csv', parallel=true, sep=',', buffer_size=100, columns={'h1': int, 'h2': varchar}, header=True) +-- +ok +== +SELECT * FROM read_csv('{DATA_DIR}/csv/error/mixedtypes_rn.csv', parallel=false, sep=',', buffer_size=100, columns={'h1': int, 'h2': varchar}, header=True) +-- +ok +== +SELECT * FROM read_csv('{DATA_DIR}/csv/error/quotednewlines.csv', parallel=true, sep=',', buffer_size=100, columns={'h1': varchar, 'h2': varchar}, header=True) +-- +ok +== +SELECT * FROM read_csv('{DATA_DIR}/csv/error/quotednewlines.csv', parallel=true, sep=',', buffer_size=200, columns={'h1': int, 'h2': varchar}, header=True) +-- +ok +== +SELECT * FROM read_csv('{DATA_DIR}/csv/error/csv_error.csv', parallel=true, sep=',', buffer_size=100, columns={'h1': {type}, 'h2': varchar}, header=True) +-- +error: Parser Error: syntax error at or near "}" +== +SELECT * FROM read_csv('{DATA_DIR}/csv/error/csv_error.csv', parallel=false, sep=',', buffer_size=100, columns={'h1': {type}, 'h2': varchar}, header=True) +-- +error: Parser Error: syntax error at or near "}" +== +SELECT * FROM read_csv('{DATA_DIR}/csv/error/date.csv', parallel=true, sep=',', buffer_size=100, columns={'h1': date, 'h2': varchar}, header=True) +-- +ok +== +SELECT * FROM read_csv('{DATA_DIR}/csv/error/date.csv', parallel=false, sep=',', buffer_size=100, columns={'h1': date, 'h2': varchar}, header=True) +-- +ok +== +SELECT * FROM read_csv('{DATA_DIR}/csv/error/time.csv', parallel=true, sep=',', buffer_size=100, columns={'h1': time, 'h2': varchar}, header=True) +-- +ok +== +SELECT * FROM read_csv('{DATA_DIR}/csv/error/time.csv', parallel=false, sep=',', buffer_size=100, columns={'h1': time, 'h2': varchar}, header=True) +-- +ok +== +SELECT * FROM read_csv('{DATA_DIR}/csv/error/timestamp.csv', parallel=true, sep=',', buffer_size=200, columns={'h1': timestamp, 'h2': varchar}, header=True) +-- +ok +== +SELECT * FROM read_csv('{DATA_DIR}/csv/error/timestamp.csv', parallel=false, sep=',', columns={'h1': timestamp, 'h2': varchar}, header=True) +-- +ok +== +SELECT * FROM read_csv('{DATA_DIR}/csv/error/timestamp.csv', parallel=true, sep=',', buffer_size=100, columns={'h1': timestamp, 'h2': varchar}, header=True) +-- +ok +== diff --git a/parser/testdata/corpus/sql/copy/csv/plus_autodetect.test b/parser/testdata/corpus/sql/copy/csv/plus_autodetect.test new file mode 100644 index 0000000..23c245c --- /dev/null +++ b/parser/testdata/corpus/sql/copy/csv/plus_autodetect.test @@ -0,0 +1,17 @@ +# source: test/sql/copy/csv/plus_autodetect.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +CREATE TABLE phone_numbers AS SELECT * FROM read_csv_auto('{DATA_DIR}/csv/phonenumbers.csv') +-- +ok +== +SELECT phone FROM phone_numbers; +-- +ok +== +SELECT typeof(phone) FROM phone_numbers LIMIT 1; +-- +ok +== diff --git a/parser/testdata/corpus/sql/copy/csv/pollock/test_field_delimiter.test b/parser/testdata/corpus/sql/copy/csv/pollock/test_field_delimiter.test new file mode 100644 index 0000000..223e032 --- /dev/null +++ b/parser/testdata/corpus/sql/copy/csv/pollock/test_field_delimiter.test @@ -0,0 +1,11 @@ +# source: test/sql/copy/csv/pollock/test_field_delimiter.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +FROM read_csv('{DATA_DIR}/csv/pollock/file_field_delimiter_0x20.csv', delim = ' ', escape = '"', quote='"', header = false, skip=1, +columns = {'Date':'VARCHAR','TIME':'VARCHAR','Qty':'VARCHAR','PRODUCTID':'VARCHAR','Price':'VARCHAR' +,'ProductType':'VARCHAR','ProductDescription':'VARCHAR','URL':'VARCHAR','Comments':'VARCHAR'}, auto_detect = false, strict_mode=FALSE, null_padding = true) +-- +ok +== diff --git a/parser/testdata/corpus/sql/copy/csv/pollock/test_quotation_char.test b/parser/testdata/corpus/sql/copy/csv/pollock/test_quotation_char.test new file mode 100644 index 0000000..7f5cf1b --- /dev/null +++ b/parser/testdata/corpus/sql/copy/csv/pollock/test_quotation_char.test @@ -0,0 +1,11 @@ +# source: test/sql/copy/csv/pollock/test_quotation_char.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +FROM read_csv('{DATA_DIR}/csv/pollock/file_quotation_char_0x27.csv', delim = ',', escape = '"', quote='''', +columns = {'Date':'VARCHAR','TIME':'VARCHAR','Qty':'VARCHAR','PRODUCTID':'VARCHAR','Price':'VARCHAR' +,'ProductType':'VARCHAR','ProductDescription':'VARCHAR','URL':'VARCHAR','Comments':'VARCHAR'}, auto_detect = false, strict_mode=FALSE, null_padding = true) +-- +ok +== diff --git a/parser/testdata/corpus/sql/copy/csv/read_ahead/csv_readahead_gzip.test b/parser/testdata/corpus/sql/copy/csv/read_ahead/csv_readahead_gzip.test new file mode 100644 index 0000000..0300844 --- /dev/null +++ b/parser/testdata/corpus/sql/copy/csv/read_ahead/csv_readahead_gzip.test @@ -0,0 +1,32 @@ +# source: test/sql/copy/csv/read_ahead/csv_readahead_gzip.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +SET threads=8 +-- +ok +== +COPY (SELECT range AS i FROM range(0, 100000)) TO '{TEST_DIR}/csv_ra_0.csv.gz' (FORMAT csv, COMPRESSION gzip) +-- +ok +== +COPY (SELECT range AS i FROM range(100000, 200000)) TO '{TEST_DIR}/csv_ra_1.csv.gz' (FORMAT csv, COMPRESSION gzip) +-- +ok +== +COPY (SELECT range AS i FROM range(200000, 300000)) TO '{TEST_DIR}/csv_ra_2.csv.gz' (FORMAT csv, COMPRESSION gzip) +-- +ok +== +SET read_ahead_depth={depth} +-- +error: Parser Error: syntax error at or near "}" +== +SELECT count(*) FROM ( + SELECT i, row_number() OVER () AS rn + FROM read_csv(['{TEST_DIR}/csv_ra_0.csv.gz', '{TEST_DIR}/csv_ra_1.csv.gz', '{TEST_DIR}/csv_ra_2.csv.gz']) +) WHERE i + 1 <> rn +-- +ok +== diff --git a/parser/testdata/corpus/sql/copy/csv/read_ahead/csv_readahead_multi_file.test b/parser/testdata/corpus/sql/copy/csv/read_ahead/csv_readahead_multi_file.test new file mode 100644 index 0000000..39eaa23 --- /dev/null +++ b/parser/testdata/corpus/sql/copy/csv/read_ahead/csv_readahead_multi_file.test @@ -0,0 +1,40 @@ +# source: test/sql/copy/csv/read_ahead/csv_readahead_multi_file.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +COPY (SELECT range AS i FROM range(0, 100000)) TO '{TEST_DIR}/csv_ra_0.csv' (FORMAT csv) +-- +ok +== +COPY (SELECT range AS i FROM range(100000, 200000)) TO '{TEST_DIR}/csv_ra_1.csv' (FORMAT csv) +-- +ok +== +COPY (SELECT range AS i FROM range(200000, 300000)) TO '{TEST_DIR}/csv_ra_2.csv' (FORMAT csv) +-- +ok +== +COPY (SELECT range AS i FROM range(300000, 400000)) TO '{TEST_DIR}/csv_ra_3.csv' (FORMAT csv) +-- +ok +== +SELECT count(*) FROM ( + SELECT i, row_number() OVER () AS rn + FROM read_csv(['{TEST_DIR}/csv_ra_0.csv', '{TEST_DIR}/csv_ra_1.csv', '{TEST_DIR}/csv_ra_2.csv', '{TEST_DIR}/csv_ra_3.csv']) +) WHERE i + 1 <> rn +-- +ok +== +RESET read_ahead_depth +-- +ok +== +COPY (SELECT range AS i, range * 2 AS j FROM range(0, 1000)) TO '{TEST_DIR}/csv_ra_union.csv' (FORMAT csv) +-- +ok +== +SELECT count(*), sum(j) FROM read_csv(['{TEST_DIR}/csv_ra_0.csv', '{TEST_DIR}/csv_ra_union.csv'], union_by_name=true) +-- +ok +== diff --git a/parser/testdata/corpus/sql/copy/csv/read_ahead/csv_readahead_rejects.test b/parser/testdata/corpus/sql/copy/csv/read_ahead/csv_readahead_rejects.test new file mode 100644 index 0000000..8696eb7 --- /dev/null +++ b/parser/testdata/corpus/sql/copy/csv/read_ahead/csv_readahead_rejects.test @@ -0,0 +1,46 @@ +# source: test/sql/copy/csv/read_ahead/csv_readahead_rejects.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +COPY (SELECT range::VARCHAR AS i FROM range(0, 100000)) TO '{TEST_DIR}/csv_ra_rejects_0.csv' (FORMAT csv, HEADER false) +-- +ok +== +COPY (SELECT range::VARCHAR AS i FROM range(100000, 200000)) TO '{TEST_DIR}/csv_ra_rejects_1.csv' (FORMAT csv, HEADER false) +-- +ok +== +COPY (SELECT CASE WHEN range >= 299995 THEN 'oops' ELSE range::VARCHAR END AS i FROM range(200000, 300000)) +TO '{TEST_DIR}/csv_ra_rejects_2.csv' (FORMAT csv, HEADER false) +-- +ok +== +SELECT count(i) FROM read_csv( + ['{TEST_DIR}/csv_ra_rejects_0.csv', '{TEST_DIR}/csv_ra_rejects_1.csv', '{TEST_DIR}/csv_ra_rejects_2.csv'], + columns={'i': 'INTEGER'}, header=false, buffer_size=65536, store_rejects=true) +-- +ok +== +SELECT count(*) FROM reject_errors +-- +ok +== +SELECT count(*) FROM reject_scans WHERE file_path LIKE '%csv_ra_rejects_2%' +-- +ok +== +DROP TABLE reject_errors +-- +ok +== +DROP TABLE reject_scans +-- +ok +== +SELECT sum(i) FROM read_csv( + ['{TEST_DIR}/csv_ra_rejects_0.csv', '{TEST_DIR}/csv_ra_rejects_1.csv', '{TEST_DIR}/csv_ra_rejects_2.csv'], + columns={'i': 'INTEGER'}, header=false, buffer_size=65536) +-- +ok +== diff --git a/parser/testdata/corpus/sql/copy/csv/read_ahead/csv_readahead_single_file.test b/parser/testdata/corpus/sql/copy/csv/read_ahead/csv_readahead_single_file.test new file mode 100644 index 0000000..a259b0a --- /dev/null +++ b/parser/testdata/corpus/sql/copy/csv/read_ahead/csv_readahead_single_file.test @@ -0,0 +1,20 @@ +# source: test/sql/copy/csv/read_ahead/csv_readahead_single_file.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +COPY (SELECT range AS i FROM range(0, 500000)) TO '{TEST_DIR}/csv_ra_single.csv' (FORMAT csv) +-- +ok +== +SELECT count(*), sum(i) FROM read_csv('{TEST_DIR}/csv_ra_single.csv', buffer_size=65536) +-- +ok +== +SELECT count(*) FROM ( + SELECT i, row_number() OVER () AS rn + FROM read_csv('{TEST_DIR}/csv_ra_single.csv', buffer_size=65536) +) WHERE i + 1 <> rn +-- +ok +== diff --git a/parser/testdata/corpus/sql/copy/csv/read_csv_subquery.test b/parser/testdata/corpus/sql/copy/csv/read_csv_subquery.test new file mode 100644 index 0000000..7b008d8 --- /dev/null +++ b/parser/testdata/corpus/sql/copy/csv/read_csv_subquery.test @@ -0,0 +1,30 @@ +# source: test/sql/copy/csv/read_csv_subquery.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +WITH urls AS ( + SELECT 'a.csv' AS url UNION ALL SELECT 'b.csv' +) +SELECT * +FROM read_csv_auto((SELECT url FROM urls LIMIT 3), delim=',') +WHERE properties.height > -1.0 +LIMIT 10 +-- +ok +== +SELECT * +FROM read_csv_auto(sum(a) over ()) +-- +ok +== +SELECT * +FROM read_csv_auto(sum(a)) +-- +ok +== +SELECT * +FROM read_csv_auto('a.csv', delim=',', 42) +-- +ok +== diff --git a/parser/testdata/corpus/sql/copy/csv/read_csv_variable.test b/parser/testdata/corpus/sql/copy/csv/read_csv_variable.test new file mode 100644 index 0000000..5bad5ee --- /dev/null +++ b/parser/testdata/corpus/sql/copy/csv/read_csv_variable.test @@ -0,0 +1,21 @@ +# source: test/sql/copy/csv/read_csv_variable.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +CREATE TABLE globbed_files AS FROM glob('{DATA_DIR}/csv/glob/a?/*.csv'); +-- +ok +== +SET VARIABLE csv_files=(SELECT LIST(file ORDER BY file) FROM globbed_files) +-- +ok +== +SELECT [parse_path(x)[-2:] for x in getvariable('csv_files')] +-- +ok +== +SELECT * FROM read_csv(getvariable('csv_files')) ORDER BY 1 +-- +error: Parser Error: read_csv cannot take NULL list as parameter +== diff --git a/parser/testdata/corpus/sql/copy/csv/read_csv_variable.test.metadata.json b/parser/testdata/corpus/sql/copy/csv/read_csv_variable.test.metadata.json new file mode 100644 index 0000000..21cd7bc --- /dev/null +++ b/parser/testdata/corpus/sql/copy/csv/read_csv_variable.test.metadata.json @@ -0,0 +1,5 @@ +{ + "todo": { + "d7806464bf25c9a5": "transformer-raised parser error: upstream rejects in the transformer, not the grammar; expected to clear as transformers land (milestones 3-5)" + } +} diff --git a/parser/testdata/corpus/sql/copy/csv/recursive_csv_union_by_name.test b/parser/testdata/corpus/sql/copy/csv/recursive_csv_union_by_name.test new file mode 100644 index 0000000..c0b49a2 --- /dev/null +++ b/parser/testdata/corpus/sql/copy/csv/recursive_csv_union_by_name.test @@ -0,0 +1,23 @@ +# source: test/sql/copy/csv/recursive_csv_union_by_name.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +create view r AS from read_csv_auto('{DATA_DIR}/csv/hive-partitioning/mismatching_contents/*/*.csv', UNION_BY_NAME=1, HIVE_PARTITIONING=1) +-- +ok +== +WITH RECURSIVE t(i, j) AS +( + SELECT 1, 0 + UNION ALL + ( + SELECT i + 1, j + a + FROM t, r + WHERE i <= part + ) +) +SELECT * FROM t ORDER BY i; +-- +ok +== diff --git a/parser/testdata/corpus/sql/copy/csv/recursive_read_csv.test b/parser/testdata/corpus/sql/copy/csv/recursive_read_csv.test new file mode 100644 index 0000000..486d221 --- /dev/null +++ b/parser/testdata/corpus/sql/copy/csv/recursive_read_csv.test @@ -0,0 +1,55 @@ +# source: test/sql/copy/csv/recursive_read_csv.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +create table r AS SELECT * FROM read_csv('{DATA_DIR}/csv/test/date.csv', columns=STRUCT_PACK(d := 'DATE'), header=0, auto_detect=0); +-- +ok +== +WITH RECURSIVE t(i) AS +( + SELECT 1, NULL::DATE + UNION ALL + ( + SELECT i+1, d + FROM t, r + WHERE i<5 + ) +) +SELECT * FROM t ORDER BY i; +-- +ok +== +WITH RECURSIVE t(i) AS +( + SELECT 1, NULL::DATE + UNION ALL + ( + SELECT i+1, d + FROM t, read_csv('{DATA_DIR}/csv/test/date.csv', columns=STRUCT_PACK(d := 'DATE'), header=0, auto_detect=0) + WHERE i<5 + ) +) +SELECT * FROM t ORDER BY i; +-- +ok +== +SELECT * FROM read_csv_auto('{DATA_DIR}/csv/test/date.csv') +-- +ok +== +WITH RECURSIVE t(i) AS +( + SELECT 1, NULL::DATE + UNION ALL + ( + SELECT i+1, d + FROM t, read_csv('{DATA_DIR}/csv/test/date.csv', header=0, auto_detect=1) r(d) + WHERE i<5 + ) +) +SELECT * FROM t ORDER BY i; +-- +ok +== diff --git a/parser/testdata/corpus/sql/copy/csv/rejects/csv_incorrect_columns_amount_rejects.test b/parser/testdata/corpus/sql/copy/csv/rejects/csv_incorrect_columns_amount_rejects.test new file mode 100644 index 0000000..45aa13b --- /dev/null +++ b/parser/testdata/corpus/sql/copy/csv/rejects/csv_incorrect_columns_amount_rejects.test @@ -0,0 +1,56 @@ +# source: test/sql/copy/csv/rejects/csv_incorrect_columns_amount_rejects.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +SELECT * FROM read_csv( + '{DATA_DIR}/csv/rejects/incorrect_columns/few_columns.csv', + columns = {'a': 'INTEGER', 'b': 'INTEGER', 'c': 'INTEGER', 'd': 'INTEGER'}, + store_rejects=true, auto_detect=false, header = 1); +-- +ok +== +SELECT * EXCLUDE (scan_id) FROM reject_errors order by all; +-- +ok +== +DROP TABLE reject_errors; +-- +ok +== +DROP TABLE reject_scans; +-- +ok +== +SELECT * FROM read_csv( + '{DATA_DIR}/csv/rejects/incorrect_columns/many_columns.csv', + columns = {'a': 'INTEGER', 'b': 'INTEGER', 'c': 'INTEGER', 'd': 'INTEGER'}, + store_rejects=true, auto_detect=false, header = 1, strict_mode=True); +-- +ok +== +SELECT * FROM read_csv( + '{DATA_DIR}/csv/rejects/incorrect_columns/mix_columns.csv', + columns = {'a': 'INTEGER', 'b': 'INTEGER', 'c': 'INTEGER', 'd': 'INTEGER'}, + store_rejects=true, auto_detect=false, header = 1, strict_mode=True); +-- +ok +== +SELECT * FROM read_csv( + '{DATA_DIR}/csv/rejects/incorrect_columns/small_mix.csv', + columns = {'a': 'INTEGER', 'b': 'INTEGER', 'c': 'INTEGER', 'd': 'INTEGER'}, + store_rejects=true, auto_detect=false, header = 1, strict_mode=True); +-- +ok +== +SELECT * EXCLUDE (scan_id) FROM reject_errors order by all +-- +ok +== +SELECT * FROM read_csv( + '{DATA_DIR}/csv/rejects/incorrect_columns/*.csv', + columns = {'a': 'INTEGER', 'b': 'INTEGER', 'c': 'INTEGER', 'd': 'INTEGER'}, + store_rejects=true, auto_detect=false, header = 1, strict_mode=True); +-- +ok +== diff --git a/parser/testdata/corpus/sql/copy/csv/rejects/csv_rejects_auto.test b/parser/testdata/corpus/sql/copy/csv/rejects/csv_rejects_auto.test new file mode 100644 index 0000000..4e48662 --- /dev/null +++ b/parser/testdata/corpus/sql/copy/csv/rejects/csv_rejects_auto.test @@ -0,0 +1,41 @@ +# source: test/sql/copy/csv/rejects/csv_rejects_auto.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +SELECT typeof(first(column0)), typeof(first(column1)), COUNT(*), SUM(column0), MAX(len(column1)) FROM read_csv_auto( + '{DATA_DIR}/csv/error/mismatch/big_bad*.csv', + sample_size=1, + store_rejects=true); +-- +ok +== +SELECT SUM(num) FROM read_csv_auto( + '{DATA_DIR}/csv/error/mismatch/half1.csv', + header=true, + sample_size=1, + store_rejects=true) +-- +ok +== +SELECT COUNT(*) FROM reject_errors; +-- +ok +== +SELECT SUM(num) FROM read_csv_auto( + '{DATA_DIR}/csv/error/mismatch/half2.csv', + header=true, + ignore_errors=true, + sample_size=1, + rejects_table='csv_rejects_table'); +-- +ok +== +SELECT COUNT(*) FROM csv_rejects_table; +-- +ok +== +DROP TABLE csv_rejects_table; +-- +ok +== diff --git a/parser/testdata/corpus/sql/copy/csv/rejects/csv_rejects_flush_cast.test b/parser/testdata/corpus/sql/copy/csv/rejects/csv_rejects_flush_cast.test new file mode 100644 index 0000000..b0815f2 --- /dev/null +++ b/parser/testdata/corpus/sql/copy/csv/rejects/csv_rejects_flush_cast.test @@ -0,0 +1,14 @@ +# source: test/sql/copy/csv/rejects/csv_rejects_flush_cast.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +SELECT first(a), first(b), typeof(first(a)), typeof(first(b)), COUNT(*) FROM read_csv( + '{DATA_DIR}/csv/error/flush_cast.csv', + columns = {'a': 'DATE', 'b': 'VARCHAR'}, + store_rejects = true, + delim = ',', + dateformat = '%d-%m-%Y'); +-- +ok +== diff --git a/parser/testdata/corpus/sql/copy/csv/rejects/csv_rejects_flush_message.test b/parser/testdata/corpus/sql/copy/csv/rejects/csv_rejects_flush_message.test new file mode 100644 index 0000000..54d2feb --- /dev/null +++ b/parser/testdata/corpus/sql/copy/csv/rejects/csv_rejects_flush_message.test @@ -0,0 +1,12 @@ +# source: test/sql/copy/csv/rejects/csv_rejects_flush_message.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +SELECT * FROM read_csv( + '{DATA_DIR}/csv/rejects/flush.csv', + columns = {'a': 'DECIMAL'}, + store_rejects = true); +-- +ok +== diff --git a/parser/testdata/corpus/sql/copy/csv/rejects/csv_rejects_maximum_line.test b/parser/testdata/corpus/sql/copy/csv/rejects/csv_rejects_maximum_line.test new file mode 100644 index 0000000..6ec6d3c --- /dev/null +++ b/parser/testdata/corpus/sql/copy/csv/rejects/csv_rejects_maximum_line.test @@ -0,0 +1,33 @@ +# source: test/sql/copy/csv/rejects/csv_rejects_maximum_line.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +SELECT * FROM read_csv( + '{DATA_DIR}/csv/rejects/maximum_line/max_10.csv', + columns = {'a': 'VARCHAR', 'b': 'INTEGER'}, + store_rejects=true, auto_detect=false, header = 1, max_line_size=10); +-- +ok +== +SELECT * FROM read_csv( + '{DATA_DIR}/csv/rejects/maximum_line/max_10.csv', + columns = {'a': 'VARCHAR', 'b': 'INTEGER'}, + store_rejects = true, auto_detect=false, header = 1, max_line_size=10, buffer_size={buffer_size}); +-- +error: Parser Error: syntax error at or near "}" +== +SELECT * FROM read_csv( + '{DATA_DIR}/csv/rejects/maximum_line/over_vector.csv', + columns = {'a': 'VARCHAR', 'b': 'INTEGER'}, + store_rejects = true, auto_detect=false, header = 1, max_line_size=20); +-- +ok +== +SELECT * FROM read_csv( + '{DATA_DIR}/csv/rejects/maximum_line/*.csv', + columns = {'a': 'VARCHAR', 'b': 'INTEGER'}, + store_rejects = true, auto_detect=false, header = 1, max_line_size=10); +-- +ok +== diff --git a/parser/testdata/corpus/sql/copy/csv/rejects/csv_rejects_read.test b/parser/testdata/corpus/sql/copy/csv/rejects/csv_rejects_read.test new file mode 100644 index 0000000..1a4b926 --- /dev/null +++ b/parser/testdata/corpus/sql/copy/csv/rejects/csv_rejects_read.test @@ -0,0 +1,116 @@ +# source: test/sql/copy/csv/rejects/csv_rejects_read.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +SELECT * FROM read_csv( + '{DATA_DIR}/csv/error/mismatch/bad.csv', + columns = {'col0': 'INTEGER', 'col1': 'INTEGER', 'col2': 'VARCHAR'}, + store_rejects = true, auto_detect=true); +-- +ok +== +SELECT * EXCLUDE (scan_id) FROM reject_errors; +-- +ok +== +SELECT * FROM read_csv( + '{DATA_DIR}/csv/error/mismatch/bad2.csv', + columns = {'col0': 'INTEGER', 'col1': 'INTEGER', 'col2': 'INTEGER'}, + store_rejects = true, auto_detect=false); +-- +ok +== +SELECT * EXCLUDE (scan_id) FROM reject_errors ORDER BY ALL; +-- +ok +== +SELECT * FROM read_csv( + '{DATA_DIR}/csv/error/mismatch/bad*.csv', + columns = {'col0': 'INTEGER', 'col1': 'INTEGER', 'col2': 'VARCHAR'}, + store_rejects = true, auto_detect=false); +-- +ok +== +SELECT * FROM read_csv( + '{DATA_DIR}/csv/error/mismatch/bad*.csv', + columns = {'col0': 'INTEGER', 'col1': 'INTEGER', 'col2': 'VARCHAR'}, + store_rejects = true,rejects_limit=2, ignore_errors=true, auto_detect=false); +-- +ok +== +SELECT COUNT(*) FROM reject_errors +-- +ok +== +SELECT SUM(num) FROM read_csv( + '{DATA_DIR}/csv/error/mismatch/big_bad.csv', + columns = {'num': 'INTEGER', 'str': 'VARCHAR'}, + store_rejects = true, auto_detect=false); +-- +ok +== +SELECT SUM(num) FROM read_csv( + '{DATA_DIR}/csv/error/mismatch/big_bad2.csv', + columns = {'num': 'INTEGER', 'str': 'VARCHAR'}, + store_rejects = true, auto_detect=false) +-- +ok +== +SELECT SUM(num) FROM read_csv( + '{DATA_DIR}/csv/error/mismatch/big_*.csv', + columns = {'num': 'INTEGER', 'str': 'VARCHAR'}, + store_rejects = true, auto_detect=false); +-- +ok +== +SELECT * +FROM read_csv( + '{DATA_DIR}/csv/error/mismatch/small1.csv', + columns = {'num': 'INTEGER', 'str': 'VARCHAR'}, + store_rejects = true) as L +JOIN read_csv( + '{DATA_DIR}/csv/error/mismatch/small2.csv', + columns = {'num': 'INTEGER', 'str': 'VARCHAR'}, + store_rejects = true) as R +ON L.num = R.num; +-- +ok +== +SELECT * EXCLUDE (scan_id, file_id) FROM reject_scans ORDER BY ALL; +-- +ok +== +SELECT * EXCLUDE (scan_id, file_id) FROM reject_errors ORDER BY ALL; +-- +ok +== +SELECT * +FROM read_csv( + '{DATA_DIR}/csv/error/mismatch/small1.csv', + columns = {'num': 'INTEGER', 'str': 'VARCHAR'}, + store_rejects = true) as L +JOIN read_csv( + '{DATA_DIR}/csv/error/mismatch/small2.csv', + columns = {'num': 'INTEGER', 'str': 'VARCHAR'}, + store_rejects = true, rejects_limit=1) as R +ON L.num = R.num; +-- +ok +== +FROM read_csv('{DATA_DIR}/csv/rejects/dr_who.csv', columns={ 'date': 'DATE', 'datetime': 'TIMESTAMPTZ', 'time': 'TIME', 'timestamp': 'TIMESTAMP', 'time_tz': 'TIMETZ' }, store_rejects=true); +-- +ok +== +SELECT * EXCLUDE (scan_id, file_id) FROM reject_errors ORDER BY column_name; +-- +ok +== +FROM read_csv('{DATA_DIR}/csv/comments/error.csv', store_rejects = true, comment = '#'); +-- +ok +== +FROM read_csv('{DATA_DIR}/csv/error.csv', store_rejects=1, strict_mode=True); +-- +ok +== diff --git a/parser/testdata/corpus/sql/copy/csv/rejects/csv_rejects_truncate_line_invalid_utf8.test b/parser/testdata/corpus/sql/copy/csv/rejects/csv_rejects_truncate_line_invalid_utf8.test new file mode 100644 index 0000000..62e82d6 --- /dev/null +++ b/parser/testdata/corpus/sql/copy/csv/rejects/csv_rejects_truncate_line_invalid_utf8.test @@ -0,0 +1,13 @@ +# source: test/sql/copy/csv/rejects/csv_rejects_truncate_line_invalid_utf8.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +select * from read_csv('data/csv/test/no_newline_unicode.csv', sep='🦆', names=['a','b','c'], types=['date','int','int'], header=false, ignore_errors=true, store_rejects=true, rejects_line_size_limit=4); +-- +ok +== +SELECT csv_line FROM reject_errors LIMIT 5 +-- +ok +== diff --git a/parser/testdata/corpus/sql/copy/csv/rejects/csv_rejects_two_tables.test b/parser/testdata/corpus/sql/copy/csv/rejects/csv_rejects_two_tables.test new file mode 100644 index 0000000..63bb83b --- /dev/null +++ b/parser/testdata/corpus/sql/copy/csv/rejects/csv_rejects_two_tables.test @@ -0,0 +1,178 @@ +# source: test/sql/copy/csv/rejects/csv_rejects_two_tables.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +SELECT * EXCLUDE (scan_id) FROM reject_scans order by all; +-- +ok +== +SELECT typeof(first(column0)), typeof(first(column1)), COUNT(*), SUM(column0), MAX(len(column1)) FROM read_csv_auto( + '{DATA_DIR}/csv/error/mismatch/big_bad*.csv', + sample_size=1, + rejects_table = 'rejects_errors_2'); +-- +ok +== +drop table reject_scans; +-- +ok +== +SELECT typeof(first(column0)), typeof(first(column1)), COUNT(*), SUM(column0), MAX(len(column1)) FROM read_csv_auto( + '{DATA_DIR}/csv/error/mismatch/big_bad*.csv', + sample_size=1, + rejects_table = 'rejects_errors_2' + ); +-- +ok +== +SELECT * EXCLUDE (scan_id) FROM rejects_errors_2 order by all; +-- +ok +== +drop table reject_errors; +-- +ok +== +SELECT typeof(first(column0)), typeof(first(column1)), COUNT(*), SUM(column0), MAX(len(column1)) FROM read_csv_auto( + '{DATA_DIR}/csv/error/mismatch/big_bad*.csv', + sample_size=1, + rejects_scan = 'rejects_scan_2'); +-- +ok +== +SELECT * EXCLUDE (scan_id) FROM rejects_scan_2 order by all; +-- +ok +== +SELECT typeof(first(column0)), typeof(first(column1)), COUNT(*), SUM(column0), MAX(len(column1)) FROM read_csv_auto( + '{DATA_DIR}/csv/error/mismatch/big_bad*.csv', + sample_size=1, + rejects_scan = 'rejects_scan_3', + rejects_table = 'rejects_errors_3' + ); +-- +ok +== +SELECT * EXCLUDE (scan_id) +FROM rejects_scan_3 order by all; +-- +ok +== +SELECT * EXCLUDE (scan_id) FROM rejects_errors_3 order by all; +-- +ok +== +create temporary table t (a integer); +-- +ok +== +SELECT typeof(first(column0)), typeof(first(column1)), COUNT(*), SUM(column0), MAX(len(column1)) FROM read_csv_auto( + '{DATA_DIR}/csv/error/mismatch/big_bad*.csv', + sample_size=1, + rejects_table = 't' + ); +-- +ok +== +SELECT typeof(first(column0)), typeof(first(column1)), COUNT(*), SUM(column0), MAX(len(column1)) FROM read_csv_auto( + '{DATA_DIR}/csv/error/mismatch/big_bad*.csv', + sample_size=1, + rejects_scan = 't' + ); +-- +ok +== +SELECT typeof(first(column0)), typeof(first(column1)), COUNT(*), SUM(column0), MAX(len(column1)) FROM read_csv_auto( + '{DATA_DIR}/csv/error/mismatch/big_bad*.csv', + sample_size=1, + rejects_table = 't', + rejects_scan = 't' + ); +-- +ok +== +SELECT typeof(first(column0)), typeof(first(column1)), COUNT(*), SUM(column0), MAX(len(column1)) FROM read_csv_auto( + '{DATA_DIR}/csv/error/mismatch/big_bad*.csv', + sample_size=1, + rejects_scan = 'rejects_scan_3', + rejects_table = 'rejects_errors_3', + ignore_errors = false + ); +-- +ok +== +SELECT typeof(first(column0)), typeof(first(column1)), COUNT(*), SUM(column0), MAX(len(column1)) FROM read_csv_auto( + '{DATA_DIR}/csv/error/mismatch/big_bad*.csv', + sample_size=1, + store_rejects = true, + ignore_errors = false + ); +-- +ok +== +SELECT typeof(first(column0)), typeof(first(column1)), COUNT(*), SUM(column0), MAX(len(column1)) FROM read_csv_auto( + '{DATA_DIR}/csv/error/mismatch/big_bad*.csv', + sample_size=1, + rejects_table = 'rejects_errors_3', + ignore_errors = false + ); +-- +ok +== +SELECT typeof(first(column0)), typeof(first(column1)), COUNT(*), SUM(column0), MAX(len(column1)) FROM read_csv_auto( + '{DATA_DIR}/csv/error/mismatch/big_bad*.csv', + sample_size=1, + rejects_scan = 'rejects_scan_3', + ignore_errors = false + ); +-- +ok +== +SELECT typeof(first(column0)), typeof(first(column1)), COUNT(*), SUM(column0), MAX(len(column1)) FROM read_csv_auto( + '{DATA_DIR}/csv/error/mismatch/big_bad*.csv', + sample_size=1, + rejects_scan = 'rejects_scan_3', + rejects_table = 'rejects_errors_3', + store_rejects = false + ); +-- +ok +== +SELECT typeof(first(column0)), typeof(first(column1)), COUNT(*), SUM(column0), MAX(len(column1)) FROM read_csv_auto( + '{DATA_DIR}/csv/error/mismatch/big_bad*.csv', + sample_size=1, + rejects_table = 'rejects_errors_3', + store_rejects = false + ); +-- +ok +== +SELECT typeof(first(column0)), typeof(first(column1)), COUNT(*), SUM(column0), MAX(len(column1)) FROM read_csv_auto( + '{DATA_DIR}/csv/error/mismatch/big_bad*.csv', + sample_size=1, + rejects_scan = 'rejects_scan_3', + store_rejects = false + ); +-- +ok +== +SELECT typeof(first(column0)), typeof(first(column1)), COUNT(*), SUM(column0), MAX(len(column1)) FROM read_csv_auto( + '{DATA_DIR}/csv/error/mismatch/big_bad*.csv', + sample_size=1, + rejects_scan = 'same_name_because_why_not', + rejects_table = 'same_name_because_why_not', + store_rejects = true + ); +-- +ok +== +SELECT typeof(first(column0)), typeof(first(column1)), COUNT(*), SUM(column0), MAX(len(column1)) FROM read_csv_auto( + '{DATA_DIR}/csv/error/mismatch/big_bad*.csv', + sample_size=1, + rejects_scan = 'same_name_because_why_not', + rejects_table = 'same_name_because_why_not_2', + store_rejects = true); +-- +ok +== diff --git a/parser/testdata/corpus/sql/copy/csv/rejects/csv_unquoted_rejects.test b/parser/testdata/corpus/sql/copy/csv/rejects/csv_unquoted_rejects.test new file mode 100644 index 0000000..2d8afd2 --- /dev/null +++ b/parser/testdata/corpus/sql/copy/csv/rejects/csv_unquoted_rejects.test @@ -0,0 +1,44 @@ +# source: test/sql/copy/csv/rejects/csv_unquoted_rejects.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +SELECT * FROM read_csv( + '{DATA_DIR}/csv/rejects/unquoted/basic.csv', + columns = {'a': 'VARCHAR', 'b': 'INTEGER'}, + store_rejects=true, auto_detect=false, header = 1, quote = '"', escape = '"', strict_mode=true); +-- +ok +== +SELECT regexp_replace(file_path, '\\', '/', 'g'), line, column_idx, column_name, error_type, csv_line,line_byte_position, byte_position +FROM reject_scans inner join reject_errors on (reject_scans.scan_id = reject_errors.scan_id and reject_scans.file_id = reject_errors.file_id); +-- +ok +== +SELECT * FROM read_csv( + '{DATA_DIR}/csv/rejects/unquoted/unquoted_new_line.csv', + columns = {'a': 'VARCHAR', 'b': 'INTEGER'}, + store_rejects=true, auto_detect=false, header = 1, quote = '"', escape = '"', strict_mode=true); +-- +ok +== +SELECT regexp_replace(file_path, '\\', '/', 'g'), line, column_idx, column_name, error_type, line_byte_position,byte_position +FROM reject_scans inner join reject_errors on (reject_scans.scan_id = reject_errors.scan_id and reject_scans.file_id = reject_errors.file_id); +-- +ok +== +SELECT * FROM read_csv( + '{DATA_DIR}/csv/rejects/unquoted/unquoted_last_value.csv', + columns = {'a': 'VARCHAR'}, + store_rejects=true, auto_detect=false, header = 0, quote = '"', escape = '"', strict_mode = true); +-- +ok +== +SELECT * FROM read_csv( + '{DATA_DIR}/csv/rejects/unquoted/basic.csv', + columns = {'a': 'VARCHAR', 'b': 'INTEGER'}, + buffer_size={buffer_size}, + store_rejects=true, auto_detect=false, header = 1, quote = '"', escape = '"', strict_mode=true); +-- +error: Parser Error: syntax error at or near "}" +== diff --git a/parser/testdata/corpus/sql/copy/csv/rejects/test_invalid_parameters.test b/parser/testdata/corpus/sql/copy/csv/rejects/test_invalid_parameters.test new file mode 100644 index 0000000..ec8f985 --- /dev/null +++ b/parser/testdata/corpus/sql/copy/csv/rejects/test_invalid_parameters.test @@ -0,0 +1,94 @@ +# source: test/sql/copy/csv/rejects/test_invalid_parameters.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +SELECT * FROM read_csv( + '{DATA_DIR}/csv/error/mismatch/bad.csv', + columns = {'col0': 'INTEGER', 'col1': 'INTEGER', 'col2': 'VARCHAR'}, + ignore_errors=false, + store_rejects=true +) +-- +ok +== +SELECT * FROM read_csv( + '{DATA_DIR}/csv/error/mismatch/bad.csv', + columns = {'col0': 'INTEGER', 'col1': 'INTEGER', 'col2': 'VARCHAR'}, + ignore_errors=true, + rejects_table='') +-- +ok +== +SELECT * FROM read_csv( + '{DATA_DIR}/csv/error/mismatch/bad.csv', + columns = {'col0': 'INTEGER', 'col1': 'INTEGER', 'col2': 'VARCHAR'}, + ignore_errors=true, + rejects_table='csv_rejects_table', + union_by_name=true) +-- +ok +== +SELECT * FROM read_csv( + '{DATA_DIR}/csv/error/mismatch/bad.csv', + columns = {'col0': 'INTEGER', 'col1': 'INTEGER', 'col2': 'VARCHAR'}, + ignore_errors=true, + rejects_limit=10) +-- +ok +== +SELECT * FROM read_csv( + '{DATA_DIR}/csv/error/mismatch/bad.csv', + columns = {'col0': 'INTEGER', 'col1': 'INTEGER', 'col2': 'VARCHAR'}, + ignore_errors=true, + rejects_table='csv_rejects_table', + rejects_limit=-1) +-- +ok +== +SELECT * FROM read_csv_auto( + '{DATA_DIR}/csv/error/mismatch/bad.csv', + ignore_errors=false, + rejects_table='csv_rejects_table' +) +-- +ok +== +SELECT * FROM read_csv_auto( + '{DATA_DIR}/csv/error/mismatch/bad.csv', + ignore_errors=true, + rejects_table='') +-- +ok +== +SELECT * FROM read_csv_auto( + '{DATA_DIR}/csv/error/mismatch/bad.csv', + ignore_errors=true, + rejects_table='csv_rejects_table', + union_by_name=true) +-- +ok +== +SELECT * FROM read_csv_auto( + '{DATA_DIR}/csv/error/mismatch/bad.csv', + ignore_errors=true, + rejects_limit=10) +-- +ok +== +SELECT * FROM read_csv_auto( + '{DATA_DIR}/csv/error/mismatch/bad.csv', + ignore_errors=true, + rejects_table='csv_rejects_table', + rejects_limit=-1) +-- +ok +== +SELECT typeof(first(column0)), typeof(first(column1)), COUNT(*) FROM read_csv_auto( + '{DATA_DIR}/csv/error/mismatch/big_bad*.csv', + sample_size=3000, + rejects_table='csv_rejects_table', + ignore_errors=true, header = 0); +-- +ok +== diff --git a/parser/testdata/corpus/sql/copy/csv/rejects/test_invalid_utf_rejects.test b/parser/testdata/corpus/sql/copy/csv/rejects/test_invalid_utf_rejects.test new file mode 100644 index 0000000..1e862d9 --- /dev/null +++ b/parser/testdata/corpus/sql/copy/csv/rejects/test_invalid_utf_rejects.test @@ -0,0 +1,10 @@ +# source: test/sql/copy/csv/rejects/test_invalid_utf_rejects.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +from read_csv('{DATA_DIR}/csv/test/invalid_utf_big.csv',columns = {'col1': 'VARCHAR','col2': 'VARCHAR','col3': 'VARCHAR'}, + auto_detect=false, header = 0, delim = ',', store_rejects=true) +-- +ok +== diff --git a/parser/testdata/corpus/sql/copy/csv/rejects/test_mixed.test b/parser/testdata/corpus/sql/copy/csv/rejects/test_mixed.test new file mode 100644 index 0000000..9b937c8 --- /dev/null +++ b/parser/testdata/corpus/sql/copy/csv/rejects/test_mixed.test @@ -0,0 +1,12 @@ +# source: test/sql/copy/csv/rejects/test_mixed.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +SELECT * FROM read_csv( + '{DATA_DIR}/csv/rejects/frankstein/nightmare.csv', + columns = {'a': 'INTEGER', 'b': 'INTEGER', 'c': 'VARCHAR'}, + store_rejects = true, auto_detect=false, header = 1, max_line_size=20, strict_mode=true); +-- +ok +== diff --git a/parser/testdata/corpus/sql/copy/csv/rejects/test_multiple_errors_same_line.test b/parser/testdata/corpus/sql/copy/csv/rejects/test_multiple_errors_same_line.test new file mode 100644 index 0000000..e2759f1 --- /dev/null +++ b/parser/testdata/corpus/sql/copy/csv/rejects/test_multiple_errors_same_line.test @@ -0,0 +1,129 @@ +# source: test/sql/copy/csv/rejects/test_multiple_errors_same_line.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +FROM read_csv('{DATA_DIR}/csv/rejects/multiple_errors/cast_and_more_col.csv', + columns = {'name': 'VARCHAR', 'age': 'INTEGER', 'current_day': 'DATE', 'barks': 'INTEGER'}, + store_rejects = true, auto_detect=false, header = 1, strict_mode=True); +-- +ok +== +SElECT * EXCLUDE (scan_id) FROM reject_errors ORDER BY ALL; +-- +ok +== +FROM read_csv('{DATA_DIR}/csv/rejects/multiple_errors/multiple_cast_implicit.csv', + columns = {'name': 'VARCHAR', 'age': 'INTEGER', 'current_day': 'DATE', 'barks': 'INTEGER'}, + store_rejects = true, auto_detect=false, header = 1, strict_mode=True); +-- +ok +== +FROM read_csv('{DATA_DIR}/csv/rejects/multiple_errors/multiple_casts_flush.csv', + columns = {'name': 'VARCHAR', 'age': 'INTEGER', 'current_day': 'DATE', 'tomorrow': 'DATE'}, + store_rejects = true, auto_detect=false, header = 1); +-- +ok +== +FROM read_csv('{DATA_DIR}/csv/rejects/multiple_errors/multiple_casts_mixed.csv', + columns = {'name': 'VARCHAR', 'age': 'INTEGER', 'current_day': 'DATE', 'barks': 'INTEGER'}, + store_rejects = true, auto_detect=false, header = 1); +-- +ok +== +FROM read_csv('{DATA_DIR}/csv/rejects/multiple_errors/cast_and_less_col.csv', + columns = {'name': 'VARCHAR', 'age': 'INTEGER', 'current_day': 'DATE', 'barks': 'INTEGER'}, + store_rejects = true, auto_detect=false, header = 1); +-- +ok +== +FROM read_csv('{DATA_DIR}/csv/rejects/multiple_errors/cast_and_maxline.csv', + columns = {'name': 'VARCHAR', 'age': 'INTEGER', 'current_day': 'DATE', 'barks': 'INTEGER'}, + store_rejects = true, auto_detect=false, header = 1, max_line_size=40); +-- +ok +== +FROM read_csv('{DATA_DIR}/csv/rejects/multiple_errors/less_col_and_max_line.csv', + columns = {'name': 'VARCHAR', 'age': 'INTEGER', 'current_day': 'DATE', 'barks': 'INTEGER'}, + store_rejects = true, auto_detect=false, header = 1, max_line_size=40); +-- +ok +== +SElECT * EXCLUDE (scan_id) FROM reject_errors ORDER BY byte_position; +-- +ok +== +FROM read_csv('{DATA_DIR}/csv/rejects/multiple_errors/more_col_and_max_line.csv', + columns = {'name': 'VARCHAR', 'age': 'INTEGER', 'current_day': 'DATE', 'barks': 'INTEGER'}, + store_rejects = true, auto_detect=false, header = 1, max_line_size=40, strict_mode=True); +-- +ok +== +FROM read_csv('{DATA_DIR}/csv/rejects/multiple_errors/unquoted_cast.csv', + columns = {'name': 'VARCHAR', 'age': 'INTEGER', 'current_day': 'DATE', 'barks': 'INTEGER'}, + store_rejects = true, auto_detect=false, header = 1, max_line_size=40, strict_mode=true); +-- +ok +== +SElECT * EXCLUDE (scan_id) FROM reject_errors ORDER BY byte_position; +-- +ok +== +FROM read_csv('{DATA_DIR}/csv/rejects/multiple_errors/unquoted_less.csv', + columns = {'name': 'VARCHAR', 'age': 'INTEGER', 'current_day': 'DATE', 'barks': 'INTEGER'}, + store_rejects = true, auto_detect=false, header = 1, max_line_size=40, strict_mode=true); +-- +ok +== +FROM read_csv('{DATA_DIR}/csv/rejects/multiple_errors/unquoted_maxline.csv', + columns = {'name': 'VARCHAR', 'age': 'INTEGER', 'current_day': 'DATE', 'barks': 'INTEGER'}, + store_rejects = true, auto_detect=false, header = 1, max_line_size=40, strict_mode=true); +-- +ok +== +FROM read_csv('{DATA_DIR}/csv/rejects/multiple_errors/unquoted_more.csv', + columns = {'name': 'VARCHAR', 'age': 'INTEGER', 'current_day': 'DATE', 'barks': 'INTEGER'}, + store_rejects = true, auto_detect=false, header = 1, max_line_size=40, strict_mode=true); +-- +ok +== +FROM read_csv('{DATA_DIR}/csv/rejects/multiple_errors/invalid_utf_cast.csv', + columns = {'name': 'VARCHAR', 'age': 'INTEGER', 'current_day': 'DATE', 'barks': 'INTEGER'}, + store_rejects = true, auto_detect=false, header = 1, max_line_size=40); +-- +ok +== +FROM read_csv('{DATA_DIR}/csv/rejects/multiple_errors/invalid_utf_less.csv', + columns = {'name': 'VARCHAR', 'age': 'INTEGER', 'current_day': 'DATE', 'barks': 'INTEGER'}, + store_rejects = true, auto_detect=false, header = 1, max_line_size=40); +-- +ok +== +FROM read_csv('{DATA_DIR}/csv/rejects/multiple_errors/invalid_utf_max_line.csv', + columns = {'name': 'VARCHAR', 'age': 'INTEGER', 'current_day': 'DATE', 'barks': 'INTEGER'}, + store_rejects = true, auto_detect=false, header = 1, max_line_size=40, strict_mode=True); +-- +ok +== +SElECT * EXCLUDE (scan_id) FROM reject_errors ORDER BY byte_position, error_message; +-- +ok +== +FROM read_csv('{DATA_DIR}/csv/rejects/multiple_errors/invalid_utf_more.csv', + columns = {'name': 'VARCHAR', 'age': 'INTEGER', 'current_day': 'DATE', 'barks': 'INTEGER'}, + store_rejects = true, auto_detect=false, header = 1, max_line_size=40, strict_mode=True); +-- +ok +== +FROM read_csv('{DATA_DIR}/csv/rejects/multiple_errors/invalid_utf_unquoted.csv', + columns = {'name': 'VARCHAR', 'last_name': 'VARCHAR', 'age': 'INTEGER', 'current_day': 'DATE', 'barks': 'INTEGER'}, + store_rejects = true, auto_detect=false, header = 1, max_line_size=40, strict_mode=true); +-- +ok +== +FROM read_csv('{DATA_DIR}/csv/rejects/multiple_errors/multiple_errors.csv', + columns = {'name': 'VARCHAR', 'age': 'INTEGER', 'current_day': 'DATE', 'barks': 'INTEGER'}, + store_rejects = true, auto_detect=false, header = 1, max_line_size=40, strict_mode=true); +-- +ok +== diff --git a/parser/testdata/corpus/sql/copy/csv/relaxed_quotes.test b/parser/testdata/corpus/sql/copy/csv/relaxed_quotes.test new file mode 100644 index 0000000..1cdd9cc --- /dev/null +++ b/parser/testdata/corpus/sql/copy/csv/relaxed_quotes.test @@ -0,0 +1,73 @@ +# source: test/sql/copy/csv/relaxed_quotes.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +from read_csv('{DATA_DIR}/csv/unescaped_quotes/stops.csv'); +-- +ok +== +from read_csv('{DATA_DIR}/csv/unescaped_quotes/stops.csv', strict_mode=false); +-- +ok +== +from read_csv('{DATA_DIR}/csv/unescaped_quotes/unescaped_quote.csv', escape = '"', strict_mode=false); +-- +ok +== +from read_csv('{DATA_DIR}/csv/unescaped_quotes/unescaped_quote.csv', strict_mode=false, escape = '', quote = '"', delim = ';'); +-- +ok +== +from read_csv('{DATA_DIR}/csv/unescaped_quotes/unescaped_quote.csv', strict_mode=false, escape = '', buffer_size = {buffer_size}, header = 0) +-- +error: Parser Error: syntax error at or near "}" +== +create table t as from read_csv('{DATA_DIR}/csv/unescaped_quotes/unescaped_quote_new_line.csv', strict_mode=false, header = 0) +-- +ok +== +select count(*) from t; +-- +ok +== +drop table t; +-- +ok +== +create table t as from read_csv('{DATA_DIR}/csv/unescaped_quotes/unescaped_quote_new_line_rn.csv', strict_mode=false, buffer_size = 20, header = 0, delim = ';') +-- +ok +== +create table t as from read_csv('{DATA_DIR}/csv/unescaped_quotes/unescaped_quote_new_line.csv', strict_mode=false, buffer_size = 30, header = 0, parallel = false) +-- +ok +== +drop table t +-- +ok +== +create table t as from read_csv('{DATA_DIR}/csv/unescaped_quotes/unescaped_quote_new_line_rn.csv', strict_mode=false, buffer_size = 30, header = 0, parallel = false) +-- +ok +== +FROM read_csv('{DATA_DIR}/csv/unescaped_quotes/end_quote.csv', columns = {'a':'varchar'}, header = false, quote = '"', strict_mode = false) +-- +ok +== +FROM read_csv('{DATA_DIR}/csv/unescaped_quotes/end_quote_2.csv', columns = {'a':'varchar'}, header = false, quote = '"', strict_mode = false) +-- +ok +== +FROM read_csv('{DATA_DIR}/csv/unescaped_quotes/end_quote_3.csv', columns = {'a':'varchar'}, header = false, quote = '"', strict_mode = false) +-- +ok +== +FROM read_csv('{DATA_DIR}/csv/unescaped_quotes/some_escaped_some_not.csv', columns = {'a':'varchar'}, header = false, quote = '"', escape = '"', strict_mode = false) +-- +ok +== +FROM read_csv('{DATA_DIR}/csv/unescaped_quotes/end_quote_mixed.csv', columns = {'a':'varchar'}, header = false, quote = '"', escape = '', strict_mode = false) +-- +ok +== diff --git a/parser/testdata/corpus/sql/copy/csv/struct.test b/parser/testdata/corpus/sql/copy/csv/struct.test new file mode 100644 index 0000000..9438ec3 --- /dev/null +++ b/parser/testdata/corpus/sql/copy/csv/struct.test @@ -0,0 +1,9 @@ +# source: test/sql/copy/csv/struct.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +FROM '{DATA_DIR}/csv/struct.csv' +-- +ok +== diff --git a/parser/testdata/corpus/sql/copy/csv/struct_padding.test b/parser/testdata/corpus/sql/copy/csv/struct_padding.test new file mode 100644 index 0000000..f72f455 --- /dev/null +++ b/parser/testdata/corpus/sql/copy/csv/struct_padding.test @@ -0,0 +1,9 @@ +# source: test/sql/copy/csv/struct_padding.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +SELECT * FROM read_csv('{DATA_DIR}/csv/test/struct_padding.csv', columns={'col': 'STRUCT(val VARCHAR)'}) ORDER BY 1; +-- +ok +== diff --git a/parser/testdata/corpus/sql/copy/csv/test_11403.test b/parser/testdata/corpus/sql/copy/csv/test_11403.test new file mode 100644 index 0000000..28c7a41 --- /dev/null +++ b/parser/testdata/corpus/sql/copy/csv/test_11403.test @@ -0,0 +1,13 @@ +# source: test/sql/copy/csv/test_11403.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +SELECT COUNT(*) FROM '{DATA_DIR}/csv/quoted_newline.csv' +-- +ok +== +SELECT quote FROM sniff_csv('{DATA_DIR}/csv/quoted_newline.csv') +-- +ok +== diff --git a/parser/testdata/corpus/sql/copy/csv/test_11840.test b/parser/testdata/corpus/sql/copy/csv/test_11840.test new file mode 100644 index 0000000..d114d09 --- /dev/null +++ b/parser/testdata/corpus/sql/copy/csv/test_11840.test @@ -0,0 +1,13 @@ +# source: test/sql/copy/csv/test_11840.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +FROM '{DATA_DIR}/csv/date_specificity.csv' +-- +ok +== +select d FROM '{DATA_DIR}/csv/special_date.csv' +-- +ok +== diff --git a/parser/testdata/corpus/sql/copy/csv/test_12596.test b/parser/testdata/corpus/sql/copy/csv/test_12596.test new file mode 100644 index 0000000..27223cb --- /dev/null +++ b/parser/testdata/corpus/sql/copy/csv/test_12596.test @@ -0,0 +1,17 @@ +# source: test/sql/copy/csv/test_12596.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +from read_csv('{DATA_DIR}/csv/bug_12596.csv', skip=1, delim=',', header=false, columns={'c1': 'INTEGER', 'c2': 'INTEGER', 'column2': 'VARCHAR'}, null_padding = true); +-- +ok +== +from read_csv('{DATA_DIR}/csv/bug_12596.csv', skip=1, delim=',', header=false, columns={'c1': 'INTEGER', 'c2': 'INTEGER', 'column2': 'VARCHAR'}, null_padding = true, parallel = false, auto_detect = false); +-- +ok +== +from read_csv('{DATA_DIR}/csv/bug_12596.csv', skip=1, delim=',', header=false, columns={'c1': 'INTEGER', 'c2': 'INTEGER', 'column2': 'VARCHAR'}, null_padding = true, parallel = false); +-- +ok +== diff --git a/parser/testdata/corpus/sql/copy/csv/test_15473.test b/parser/testdata/corpus/sql/copy/csv/test_15473.test new file mode 100644 index 0000000..c4aa559 --- /dev/null +++ b/parser/testdata/corpus/sql/copy/csv/test_15473.test @@ -0,0 +1,41 @@ +# source: test/sql/copy/csv/test_15473.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +select columns from sniff_csv('{DATA_DIR}/csv/15473.csv'); +-- +ok +== +select columns from sniff_csv('{DATA_DIR}/csv/15473_time.csv'); +-- +ok +== +select columns from sniff_csv('{DATA_DIR}/csv/15473_timestamp.csv'); +-- +ok +== +select columns from sniff_csv('{DATA_DIR}/csv/15473_date_timestamp.csv'); +-- +ok +== +select columns from sniff_csv('{DATA_DIR}/csv/15473_time_timestamp.csv'); +-- +ok +== +CREATE TABLE t1 AS select '2024/12/12' as a, '01:02:03' as b, '2020/01/01 01:02:03' as c from range(0,10000) ; +-- +ok +== +insert into t1 values ('1','1','1'); +-- +ok +== +COPY t1 TO '{TEMP_DIR}/date_int.csv' (FORMAT CSV); +-- +ok +== +select columns from sniff_csv('{TEMP_DIR}/date_int.csv'); +-- +ok +== diff --git a/parser/testdata/corpus/sql/copy/csv/test_8890.test b/parser/testdata/corpus/sql/copy/csv/test_8890.test new file mode 100644 index 0000000..f6a8c38 --- /dev/null +++ b/parser/testdata/corpus/sql/copy/csv/test_8890.test @@ -0,0 +1,23 @@ +# source: test/sql/copy/csv/test_8890.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +select + field1, + field2, + min(datum) as firstseen, + max(datum) as lastseen +from read_csv('{DATA_DIR}/csv/hebere.csv.gz', + delim='\t', + header=0, + columns={field1: varchar, field2: varchar, datum: varchar}, + compression='gzip', + ignore_errors=0, + auto_detect = false) +group by field1, field2 +order by all +limit 10; +-- +ok +== diff --git a/parser/testdata/corpus/sql/copy/csv/test_9005.test b/parser/testdata/corpus/sql/copy/csv/test_9005.test new file mode 100644 index 0000000..a9a3d3a --- /dev/null +++ b/parser/testdata/corpus/sql/copy/csv/test_9005.test @@ -0,0 +1,9 @@ +# source: test/sql/copy/csv/test_9005.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +SELECT * FROM read_csv_auto('{DATA_DIR}/csv/bug_9005/teste*.csv',filename=true,union_by_name=True) where filename='{DATA_DIR}/csv/bug_9005/teste1.csv'; +-- +ok +== diff --git a/parser/testdata/corpus/sql/copy/csv/test_afl.test b/parser/testdata/corpus/sql/copy/csv/test_afl.test new file mode 100644 index 0000000..757d73b --- /dev/null +++ b/parser/testdata/corpus/sql/copy/csv/test_afl.test @@ -0,0 +1,105 @@ +# source: test/sql/copy/csv/test_afl.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +FROM read_csv('{DATA_DIR}/csv/afl/1.csv', force_not_null=012%0); +-- +ok +== +FROM read_csv('{DATA_DIR}/csv/afl/2.csv', max_line_size=-9151315542319464311); +-- +ok +== +FROM read_csv('{DATA_DIR}/csv/afl/3.csv', max_line_size=-1003718790012071149, ignore_errors=true); +-- +ok +== +FROM read_csv('{DATA_DIR}/csv/afl/4.csv', max_line_size=-432344490485710328, all_varchar=false); +-- +ok +== +FROM read_csv('{DATA_DIR}/csv/afl/5.csv', max_line_size=-68088296696312078); +-- +ok +== +FROM read_csv('{DATA_DIR}/csv/afl/6.csv', buffer_size=42); +-- +ok +== +FROM read_csv('{DATA_DIR}/csv/afl/7.csv', buffer_size=42); +-- +ok +== +FROM read_csv('{DATA_DIR}/csv/afl/8.csv', buffer_size=42); +-- +ok +== +FROM read_csv('{DATA_DIR}/csv/afl/9.csv', buffer_size=42); +-- +ok +== +FROM read_csv('{DATA_DIR}/csv/afl/10.csv', buffer_size=42); +-- +ok +== +FROM read_csv('{DATA_DIR}/csv/afl/11.csv', max_line_size=-7987305294711008699, rejects_limit=42); +-- +ok +== +FROM read_csv('{DATA_DIR}/csv/afl/12.csv', rejects_table='d'); +-- +ok +== +FROM read_csv('{DATA_DIR}/csv/afl/13.csv', rejects_table='d'); +-- +ok +== +FROM read_csv('{DATA_DIR}/csv/afl/14.csv', rejects_table='d'); +-- +ok +== +FROM read_csv('{DATA_DIR}/csv/afl/15.csv', rejects_table='d'); +-- +ok +== +FROM read_csv('{DATA_DIR}/csv/afl/16.csv', rejects_table='d'); +-- +ok +== +FROM read_csv('{DATA_DIR}/csv/afl/17.csv', rejects_table='d'); +-- +ok +== +FROM read_csv('{DATA_DIR}/csv/afl/18.csv', rejects_table='d'); +-- +ok +== +FROM read_csv('{DATA_DIR}/csv/afl/19.csv', rejects_table='d'); +-- +ok +== +FROM read_csv('{DATA_DIR}/csv/afl/20.csv', rejects_table='d'); +-- +ok +== +FROM read_csv('{DATA_DIR}/csv/afl/21.csv', rejects_table='d'); +-- +ok +== +FROM read_csv('{DATA_DIR}/csv/afl/22.csv', rejects_table='d'); +-- +ok +== +FROM read_csv('{DATA_DIR}/csv/afl/23.csv', buffer_size=42); +-- +ok +== +FROM read_csv('{DATA_DIR}/csv/afl/24.csv', buffer_size=26, delim=';', header=true, allow_quoted_nulls=true, allow_quoted_nulls=true); +-- +ok +== +FROM read_csv('{DATA_DIR}/csv/afl/25.csv', buffer_size=734771105608237082, max_line_size=-8825501086615982989, allow_quoted_nulls=true); +-- +ok +== diff --git a/parser/testdata/corpus/sql/copy/csv/test_all_quotes.test b/parser/testdata/corpus/sql/copy/csv/test_all_quotes.test new file mode 100644 index 0000000..8e07296 --- /dev/null +++ b/parser/testdata/corpus/sql/copy/csv/test_all_quotes.test @@ -0,0 +1,9 @@ +# source: test/sql/copy/csv/test_all_quotes.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +SELECT quote FROM sniff_csv('{DATA_DIR}/csv/all_quotes.csv', ignore_errors = 1) +-- +ok +== diff --git a/parser/testdata/corpus/sql/copy/csv/test_allow_quoted_nulls_option.test b/parser/testdata/corpus/sql/copy/csv/test_allow_quoted_nulls_option.test new file mode 100644 index 0000000..290a02d --- /dev/null +++ b/parser/testdata/corpus/sql/copy/csv/test_allow_quoted_nulls_option.test @@ -0,0 +1,17 @@ +# source: test/sql/copy/csv/test_allow_quoted_nulls_option.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +SELECT * FROM read_csv_auto('{DATA_DIR}/csv/null_comparison.csv'); +-- +ok +== +SELECT * FROM read_csv_auto('{DATA_DIR}/csv/null_comparison.csv', allow_quoted_nulls=False); +-- +ok +== +SELECT * FROM read_csv_auto('{DATA_DIR}/csv/null_comparison.csv', allow_quoted_nulls=True); +-- +ok +== diff --git a/parser/testdata/corpus/sql/copy/csv/test_auto_date.test b/parser/testdata/corpus/sql/copy/csv/test_auto_date.test new file mode 100644 index 0000000..ee18b1a --- /dev/null +++ b/parser/testdata/corpus/sql/copy/csv/test_auto_date.test @@ -0,0 +1,65 @@ +# source: test/sql/copy/csv/test_auto_date.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +CREATE TABLE date_tests (a DATE) +-- +ok +== +copy date_tests from '{DATA_DIR}/csv/auto_date/date_example_1.csv'; +-- +ok +== +copy date_tests from '{DATA_DIR}/csv/auto_date/date_example_2.csv'; +-- +ok +== +FROM date_tests +-- +ok +== +DROP TABLE date_tests +-- +ok +== +copy date_tests from '{DATA_DIR}/csv/auto_date/date_example_1.csv' WITH (dateformat 'AUTO'); +-- +ok +== +copy date_tests from '{DATA_DIR}/csv/auto_date/date_example_2.csv' WITH (dateformat 'AUTO'); +-- +ok +== +CREATE TABLE stg_device_metadata_with_dates ( + device_id VARCHAR, + device_name VARCHAR, + device_type VARCHAR, + manufacturer VARCHAR, + model_number VARCHAR, + firmware_version VARCHAR, + installation_date DATE, + location_id VARCHAR, + location_name VARCHAR, + facility_zone VARCHAR, + is_active BOOLEAN, + expected_lifetime_months INT, + maintenance_interval_days INT, + last_maintenance_date DATE +); +-- +ok +== +COPY stg_device_metadata_with_dates + FROM '{DATA_DIR}/csv/auto_date/device_metadata_1.csv' WITH ( + delimiter ',', + skip '1', + header 'false' +) +-- +ok +== +FROM stg_device_metadata_with_dates +-- +ok +== diff --git a/parser/testdata/corpus/sql/copy/csv/test_auto_detection_headers.test b/parser/testdata/corpus/sql/copy/csv/test_auto_detection_headers.test new file mode 100644 index 0000000..d04d0a0 --- /dev/null +++ b/parser/testdata/corpus/sql/copy/csv/test_auto_detection_headers.test @@ -0,0 +1,25 @@ +# source: test/sql/copy/csv/test_auto_detection_headers.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +from read_csv('{DATA_DIR}/csv/headers/undetected_type.csv', delim = ';') +-- +ok +== +from '{DATA_DIR}/csv/headers/all_varchar.csv' +-- +ok +== +from '{DATA_DIR}/csv/headers/single_line.csv' +-- +ok +== +from '{DATA_DIR}/csv/headers/borked_type.csv' +-- +ok +== +from '{DATA_DIR}/csv/headers/integer.csv' +-- +ok +== diff --git a/parser/testdata/corpus/sql/copy/csv/test_bgzf_read.test b/parser/testdata/corpus/sql/copy/csv/test_bgzf_read.test new file mode 100644 index 0000000..4f838df --- /dev/null +++ b/parser/testdata/corpus/sql/copy/csv/test_bgzf_read.test @@ -0,0 +1,21 @@ +# source: test/sql/copy/csv/test_bgzf_read.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +CREATE TABLE bgzf AS SELECT * FROM read_csv_auto('{DATA_DIR}/csv/test/bgzf.gz'); +-- +ok +== +SELECT COUNT(*) FROM bgzf; +-- +ok +== +CREATE TABLE concat AS SELECT * FROM read_csv_auto('{DATA_DIR}/csv/test/concat.gz'); +-- +ok +== +SELECT COUNT(*) FROM concat; +-- +ok +== diff --git a/parser/testdata/corpus/sql/copy/csv/test_big_header.test b/parser/testdata/corpus/sql/copy/csv/test_big_header.test new file mode 100644 index 0000000..8106db4 --- /dev/null +++ b/parser/testdata/corpus/sql/copy/csv/test_big_header.test @@ -0,0 +1,25 @@ +# source: test/sql/copy/csv/test_big_header.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +CREATE TABLE test (foo INTEGER, bar VARCHAR(10), baz VARCHAR(10), bam VARCHAR(10)); +-- +ok +== +COPY test FROM '{DATA_DIR}/csv/test/big_header.csv' (DELIMITER ' ', HEADER false, SKIP 3); +-- +ok +== +SELECT COUNT(bam) FROM test WHERE bam = '!'; +-- +ok +== +INSERT INTO test SELECT * FROM read_csv('{DATA_DIR}/csv/test/big_header.csv', HEADER=FALSE, SKIP=3, DELIM=' ', columns=STRUCT_PACK(foo := 'INTEGER', bar := 'VARCHAR', baz := 'VARCHAR', bam := 'VARCHAR')); +-- +ok +== +INSERT INTO test SELECT * FROM read_csv_auto('{DATA_DIR}/csv/test/big_header.csv', HEADER=FALSE, SKIP=3, DELIM=' '); +-- +ok +== diff --git a/parser/testdata/corpus/sql/copy/csv/test_blob.test b/parser/testdata/corpus/sql/copy/csv/test_blob.test new file mode 100644 index 0000000..ef605cd --- /dev/null +++ b/parser/testdata/corpus/sql/copy/csv/test_blob.test @@ -0,0 +1,37 @@ +# source: test/sql/copy/csv/test_blob.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +CREATE TABLE blobs (b BYTEA); +-- +ok +== +COPY blobs FROM '{DATA_DIR}/csv/test/blob.csv' (HEADER 0, AUTO_DETECT 0); +-- +ok +== +SELECT b FROM blobs +-- +ok +== +COPY blobs TO '{TEMP_DIR}/blob.csv'; +-- +ok +== +DELETE FROM blobs +-- +ok +== +COPY blobs FROM '{TEMP_DIR}/blob.csv'; +-- +ok +== +COPY blobs TO '{TEMP_DIR}/blob.csv' DELIMITER 'A' QUOTE 'B' ESCAPE 'C'; +-- +ok +== +COPY blobs FROM '{TEMP_DIR}/blob.csv' (DELIMITER 'A', QUOTE 'B', ESCAPE 'C'); +-- +ok +== diff --git a/parser/testdata/corpus/sql/copy/csv/test_bug_10273.test b/parser/testdata/corpus/sql/copy/csv/test_bug_10273.test new file mode 100644 index 0000000..4ac3313 --- /dev/null +++ b/parser/testdata/corpus/sql/copy/csv/test_bug_10273.test @@ -0,0 +1,9 @@ +# source: test/sql/copy/csv/test_bug_10273.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +FROM read_csv('{DATA_DIR}/csv/bug_10273.csv', header=0) +-- +ok +== diff --git a/parser/testdata/corpus/sql/copy/csv/test_column_inconsistencies.test b/parser/testdata/corpus/sql/copy/csv/test_column_inconsistencies.test new file mode 100644 index 0000000..b94f177 --- /dev/null +++ b/parser/testdata/corpus/sql/copy/csv/test_column_inconsistencies.test @@ -0,0 +1,45 @@ +# source: test/sql/copy/csv/test_column_inconsistencies.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +FROM read_csv('{DATA_DIR}/csv/inconsistencies/inconsistent_columns_3.csv') +-- +ok +== +FROM read_csv('{DATA_DIR}/csv/inconsistencies/inconsistent_columns_3.csv', null_padding = true) +-- +ok +== +FROM read_csv('{DATA_DIR}/csv/inconsistencies/inconsistent_columns_3.csv', null_padding = true, ignore_errors = true) +-- +ok +== +FROM read_csv('{DATA_DIR}/csv/inconsistencies/inconsistent_columns_6.csv') +-- +ok +== +FROM read_csv('{DATA_DIR}/csv/inconsistencies/inconsistent_columns_6.csv', null_padding = true) +-- +ok +== +FROM read_csv('{DATA_DIR}/csv/inconsistencies/inconsistent_columns_6.csv', null_padding = true, ignore_errors = true) +-- +ok +== +FROM read_csv('{DATA_DIR}/csv/inconsistencies/inconsistent_columns_6.csv', null_padding = true, ignore_errors = true, header = false) +-- +ok +== +FROM read_csv('{DATA_DIR}/csv/inconsistencies/line_with_spaces.csv') +-- +ok +== +FROM read_csv('{DATA_DIR}/csv/inconsistencies/line_with_spaces.csv', null_padding = true, header = false) +-- +ok +== +FROM read_csv('{DATA_DIR}/csv/inconsistencies/line_with_spaces.csv', null_padding = true, ignore_errors = true) +-- +ok +== diff --git a/parser/testdata/corpus/sql/copy/csv/test_comment_midline.test b/parser/testdata/corpus/sql/copy/csv/test_comment_midline.test new file mode 100644 index 0000000..70ff1ad --- /dev/null +++ b/parser/testdata/corpus/sql/copy/csv/test_comment_midline.test @@ -0,0 +1,92 @@ +# source: test/sql/copy/csv/test_comment_midline.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +from read_csv('{DATA_DIR}/csv/comments/14648.csv', + header=false, + sep=',', + null_padding=true, + comment='#', + ignore_errors=true + ); +-- +ok +== +from read_csv('{DATA_DIR}/csv/comments/14648.csv', + header=false, + sep=',', + comment='#', + ignore_errors=true + ); +-- +ok +== +from read_csv('{DATA_DIR}/csv/comments/14648.csv', + header=false, + sep=',', + comment='#' + ); +-- +ok +== +FROM '{DATA_DIR}/csv/comments/14635.csv' +-- +ok +== +FROM read_csv('{DATA_DIR}/csv/comments/14635.csv', ignore_errors = true, columns = {'header1': 'VARCHAR', 'header2': 'VARCHAR', 'header3': 'VARCHAR'}, quote = '', escape = '', delim =','); +-- +ok +== +FROM '{DATA_DIR}/csv/comments/only_midline.csv'; +-- +ok +== +FROM read_csv('{DATA_DIR}/csv/comments/only_midline.csv', comment = '#'); +-- +ok +== +FROM '{DATA_DIR}/csv/comments/mid_line.csv'; +-- +ok +== +FROM '{DATA_DIR}/csv/comments/mid_line_header.csv'; +-- +ok +== +FROM '{DATA_DIR}/csv/comments/mid_line_quote.csv'; +-- +ok +== +FROM '{DATA_DIR}/csv/comments/mid_line_null.csv'; +-- +ok +== +FROM '{DATA_DIR}/csv/comments/simple_mid_line.csv'; +-- +ok +== +FROM '{DATA_DIR}/csv/comments/midline_empty_space.csv'; +-- +ok +== +FROM read_csv('{DATA_DIR}/csv/comments/mid_line_invalid.csv', ignore_errors = true, delim = ';', comment = '#', auto_detect = false, columns= {'a':'integer', 'b':'integer'}, strict_mode=True); +-- +ok +== +FROM '{DATA_DIR}/csv/comments/midline_big.csv' limit 5; +-- +ok +== +FROM '{DATA_DIR}/csv/comments/midline_big.csv' where a = 20 +-- +ok +== +SELECT count(*) FROM '{DATA_DIR}/csv/comments/midline_big.csv' +-- +ok +== +FROM read_csv('{DATA_DIR}/csv/comments/simple_mid_line.csv', buffer_size = {buffer_size}) limit 5; +-- +error: Parser Error: syntax error at or near "}" +== diff --git a/parser/testdata/corpus/sql/copy/csv/test_comment_option.test b/parser/testdata/corpus/sql/copy/csv/test_comment_option.test new file mode 100644 index 0000000..f79d987 --- /dev/null +++ b/parser/testdata/corpus/sql/copy/csv/test_comment_option.test @@ -0,0 +1,81 @@ +# source: test/sql/copy/csv/test_comment_option.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +FROM read_csv('{DATA_DIR}/csv/comments/17226.csv', comment='#', all_varchar=True, skip=0, ignore_errors=True) +-- +ok +== +FROM read_csv('{DATA_DIR}/csv/comments/mixed_options.csv', delim = ',', comment = ',', auto_detect = false, columns= {'a':'integer'}) +-- +ok +== +FROM read_csv('{DATA_DIR}/csv/comments/mixed_options.csv', quote = ',', comment = ',', escape = '', delim = ';', auto_detect = false, columns= {'a':'integer'}) +-- +ok +== +FROM '{DATA_DIR}/csv/comments/simple.csv'; +-- +ok +== +FROM '{DATA_DIR}/csv/comments/simple_comma.csv'; +-- +ok +== +FROM read_csv('{DATA_DIR}/csv/comments/simple_comma.csv', comment = ','); +-- +ok +== +FROM '{DATA_DIR}/csv/comments/big.csv' limit 5; +-- +ok +== +FROM '{DATA_DIR}/csv/comments/big.csv' where a = 20 +-- +ok +== +SELECT count(*) FROM '{DATA_DIR}/csv/comments/big.csv' +-- +ok +== +FROM '{DATA_DIR}/csv/comments/empty_space.csv'; +-- +ok +== +FROM read_csv('{DATA_DIR}/csv/comments/simple.csv', buffer_size = {buffer_size}) limit 5; +-- +error: Parser Error: syntax error at or near "}" +== +FROM read_csv('{DATA_DIR}/csv/comments/simple.csv', skip = 2); +-- +ok +== +FROM '{DATA_DIR}/csv/comments/invalid_rows.csv'; +-- +ok +== +select SkipRows, Comment FROM sniff_csv('{DATA_DIR}/csv/comments/invalid_rows.csv'); +-- +ok +== +select count(*) FROM '{DATA_DIR}/csv/comments/error.csv'; +-- +ok +== +select count(*) FROM read_csv('{DATA_DIR}/csv/comments/error.csv', ignore_errors = true); +-- +ok +== +select count(*) FROM read_csv('{DATA_DIR}/csv/comments/error.csv', ignore_errors = true, comment = '#'); +-- +ok +== +select comment, columns from sniff_csv('{DATA_DIR}/csv/comments/error.csv', ignore_errors = true); +-- +ok +== +FROM read_csv('{DATA_DIR}/csv/comments/simple.csv',skip={i}); +-- +error: Parser Error: syntax error at or near "}" +== diff --git a/parser/testdata/corpus/sql/copy/csv/test_compression_flag.test b/parser/testdata/corpus/sql/copy/csv/test_compression_flag.test new file mode 100644 index 0000000..db065b3 --- /dev/null +++ b/parser/testdata/corpus/sql/copy/csv/test_compression_flag.test @@ -0,0 +1,43 @@ +# source: test/sql/copy/csv/test_compression_flag.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +CREATE TABLE lineitem(a INT NOT NULL, + b INT NOT NULL, + c INT NOT NULL); +-- +ok +== +COPY lineitem FROM '{DATA_DIR}/csv/test/test_comp.csv.gzz' (COMPRESSION 'gzip', AUTO_DETECT 1); +-- +ok +== +SELECT COUNT(*) FROM lineitem +-- +ok +== +SELECT a, b, c FROM lineitem ORDER BY a +-- +ok +== +DROP TABLE lineitem +-- +ok +== +COPY lineitem FROM '{DATA_DIR}/csv/test/test_comp.csv.gz' (COMPRESSION 'infer', AUTO_DETECT 1); +-- +ok +== +COPY lineitem FROM '{DATA_DIR}/csv/test/test_comp.csv.gz' COMPRESSION 'none'; +-- +error: Parser Error: syntax error at or near "COMPRESSION" +== +CREATE TABLE lineitem AS SELECT * FROM read_csv_auto('{DATA_DIR}/csv/test/test_comp.csv.gzz', compression='gzip'); +-- +ok +== +CREATE TABLE lineitem AS SELECT * FROM read_csv('{DATA_DIR}/csv/test/test_comp.csv.gzz', compression='gzip', AUTO_DETECT=TRUE); +-- +ok +== diff --git a/parser/testdata/corpus/sql/copy/csv/test_copy.test b/parser/testdata/corpus/sql/copy/csv/test_copy.test new file mode 100644 index 0000000..62e8a17 --- /dev/null +++ b/parser/testdata/corpus/sql/copy/csv/test_copy.test @@ -0,0 +1,213 @@ +# source: test/sql/copy/csv/test_copy.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +SELECT COUNT(a), SUM(a) FROM test; +-- +ok +== +SELECT * FROM test ORDER BY 1 LIMIT 3; +-- +ok +== +COPY test TO '{TEMP_DIR}/test2.csv'; +-- +ok +== +CREATE TABLE test2 (a INTEGER, b INTEGER, c VARCHAR(10)); +-- +ok +== +COPY test2 FROM '{TEMP_DIR}/test2.csv' ; +-- +ok +== +SELECT * FROM test2 ORDER BY 1 LIMIT 3; +-- +ok +== +CREATE TABLE test_too_few_rows (a INTEGER, b INTEGER, c VARCHAR, d INTEGER); +-- +ok +== +COPY test_too_few_rows FROM '{TEMP_DIR}/test2.csv' (NULL_PADDING 0); +-- +ok +== +COPY (SELECT a,b FROM test WHERE a < 4000) TO '{TEMP_DIR}/test3.csv'; +-- +ok +== +CREATE TABLE test3 (a INTEGER, b INTEGER); +-- +ok +== +COPY test3 FROM '{TEMP_DIR}/test3.csv'; +-- +ok +== +SELECT * FROM test3 ORDER BY 1 LIMIT 3; +-- +ok +== +COPY test (a,c) TO '{TEMP_DIR}/test4.csv' (DELIMITER ',', HEADER false); +-- +ok +== +CREATE TABLE test4 (a INTEGER, b INTEGER, c VARCHAR(10)); +-- +ok +== +COPY test4 (a,c) FROM '{TEMP_DIR}/test4.csv' (DELIM ','); +-- +ok +== +SELECT * FROM test4 ORDER BY 1 LIMIT 3; +-- +ok +== +COPY test4 (a,c) FROM '{TEMP_DIR}/test4.csv' (SEP ',', HEADER 0.2); +-- +ok +== +COPY test4 (a,c) FROM '{TEMP_DIR}/test4.csv' (SEP); +-- +ok +== +COPY test4 (a,c) FROM '{TEMP_DIR}/test4.csv' (SEP 1); +-- +ok +== +COPY test4 (a,c) FROM '{TEMP_DIR}/test4.csv' (FORMAT 'csv', FORMAT 'some_other_copy_function'); +-- +error: Parser Error: Unexpected duplicate option format +== +COPY test4 (a,c) FROM '{TEMP_DIR}/test4.csv' (FORMAT 'some_other_copy_function', FORMAT 'csv'); +-- +error: Parser Error: Unexpected duplicate option format +== +COPY test4 (a,c) FROM '{TEMP_DIR}/test4.csv' (ESCAPE 1); +-- +ok +== +COPY test4 (a,c) FROM '{TEMP_DIR}/test4.csv' (ESCAPE); +-- +ok +== +COPY test4 (a,c) FROM '{TEMP_DIR}/test4.csv' (QUOTE 1); +-- +ok +== +COPY test4 (a,c) FROM '{TEMP_DIR}/test4.csv' (QUOTE); +-- +ok +== +COPY test4 (a,c) FROM '{TEMP_DIR}/test4.csv' (FORMAT); +-- +error: Parser Error: Unsupported parameter type for FORMAT: expected e.g. FORMAT 'csv', 'parquet' +== +COPY test4 (a,c) FROM '{TEMP_DIR}/test4.csv' (ENCODING); +-- +ok +== +COPY test4 (a,c) FROM '{TEMP_DIR}/test4.csv' (ENCODING 42); +-- +ok +== +COPY test4 (a,c) FROM '{TEMP_DIR}/test4.csv' (ENCODING 'utf-42'); +-- +ok +== +COPY test4 (a,c) FROM '{TEMP_DIR}/test4.csv' (MAGIC '42'); +-- +ok +== +COPY test TO '{TEMP_DIR}/test_crlf.csv' (new_line '\r\n'); +-- +ok +== +select count(*) from '{TEMP_DIR}/test_crlf.csv' +-- +ok +== +COPY test TO '{TEMP_DIR}/test_r.csv' (new_line '\r'); +-- +ok +== +select count(*) from '{TEMP_DIR}/test_r.csv' +-- +ok +== +COPY test TO '{TEMP_DIR}/test_n.csv' (new_line '\n'); +-- +ok +== +select count(*) from '{TEMP_DIR}/test_n.csv' +-- +ok +== +COPY test TO '{TEMP_DIR}/test_crlfe.csv' (new_line e'\r\n'); +-- +ok +== +select count(*) from '{TEMP_DIR}/test_crlfe.csv' +-- +ok +== +COPY test TO '{TEMP_DIR}/test_re.csv' (new_line e'\r'); +-- +ok +== +select count(*) from '{TEMP_DIR}/test_re.csv' +-- +ok +== +COPY test TO '{TEMP_DIR}/test_en.csv' (new_line e'\n'); +-- +ok +== +select count(*) from '{TEMP_DIR}/test_en.csv' +-- +ok +== +COPY test FROM '{DATA_DIR}/csv/test/test_pipe.csv' (SEPARATOR '|'); +-- +ok +== +COPY test FROM '{DATA_DIR}/csv/test/too_many_values.csv'; +-- +ok +== +COPY test FROM '{DATA_DIR}/csv/test/test_null_csv.csv' DELIMITER '|'; +-- +ok +== +COPY test FROM '{DATA_DIR}/csv/test/invalid_utf.csv' DELIMITER '|'; +-- +ok +== +CREATE TABLE empty_table (a INTEGER, b INTEGER, c VARCHAR(10)); +-- +ok +== +COPY empty_table FROM '{DATA_DIR}/csv/test/empty.csv' (HEADER 0); +-- +ok +== +CREATE TABLE unterminated (a VARCHAR); +-- +ok +== +COPY unterminated FROM '{DATA_DIR}/csv/test/unterminated.csv' (HEADER 0, AUTO_DETECT FALSE, strict_mode TRUE); +-- +ok +== +CREATE TABLE vsize (a INTEGER, b INTEGER, c VARCHAR(10)); +-- +ok +== +COPY vsize FROM '{DATA_DIR}/csv/test/vsize.csv'; +-- +ok +== diff --git a/parser/testdata/corpus/sql/copy/csv/test_copy.test.metadata.json b/parser/testdata/corpus/sql/copy/csv/test_copy.test.metadata.json new file mode 100644 index 0000000..6c59e24 --- /dev/null +++ b/parser/testdata/corpus/sql/copy/csv/test_copy.test.metadata.json @@ -0,0 +1,7 @@ +{ + "todo": { + "a021fe27e1ab7b97": "transformer-raised parser error: upstream rejects in the transformer, not the grammar; expected to clear as transformers land (milestones 3-5)", + "b08fcfb601074519": "transformer-raised parser error: upstream rejects in the transformer, not the grammar; expected to clear as transformers land (milestones 3-5)", + "c677abb2b9f03ec4": "transformer-raised parser error: upstream rejects in the transformer, not the grammar; expected to clear as transformers land (milestones 3-5)" + } +} diff --git a/parser/testdata/corpus/sql/copy/csv/test_copy_default.test b/parser/testdata/corpus/sql/copy/csv/test_copy_default.test new file mode 100644 index 0000000..604f209 --- /dev/null +++ b/parser/testdata/corpus/sql/copy/csv/test_copy_default.test @@ -0,0 +1,21 @@ +# source: test/sql/copy/csv/test_copy_default.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +CREATE TABLE test (a INTEGER, b VARCHAR DEFAULT('hello'), c INTEGER DEFAULT(3+4)); +-- +ok +== +COPY test (a) FROM '{DATA_DIR}/csv/test/test_default.csv'; +-- +ok +== +COPY test (c) FROM '{DATA_DIR}/csv/test/test_default.csv'; +-- +ok +== +SELECT COUNT(a), COUNT(b), COUNT(c), MIN(LENGTH(b)), MAX(LENGTH(b)), SUM(a), SUM(c) FROM test; +-- +ok +== diff --git a/parser/testdata/corpus/sql/copy/csv/test_copy_gzip.test b/parser/testdata/corpus/sql/copy/csv/test_copy_gzip.test new file mode 100644 index 0000000..39f8679 --- /dev/null +++ b/parser/testdata/corpus/sql/copy/csv/test_copy_gzip.test @@ -0,0 +1,44 @@ +# source: test/sql/copy/csv/test_copy_gzip.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +CREATE TABLE lineitem(l_orderkey INT NOT NULL, + l_partkey INT NOT NULL, + l_suppkey INT NOT NULL, + l_linenumber INT NOT NULL, + l_quantity INTEGER NOT NULL, + l_extendedprice DECIMAL(15, 2) NOT NULL, + l_discount DECIMAL(15, 2) NOT NULL, + l_tax DECIMAL(15, 2) NOT NULL, + l_returnflag VARCHAR(1) NOT NULL, + l_linestatus VARCHAR(1) NOT NULL, + l_shipdate DATE NOT NULL, + l_commitdate DATE NOT NULL, + l_receiptdate DATE NOT NULL, + l_shipinstruct VARCHAR(25) NOT NULL, + l_shipmode VARCHAR(10) NOT NULL, + l_comment VARCHAR(44) NOT NULL); +-- +ok +== +COPY lineitem FROM '{DATA_DIR}/csv/lineitem1k.tbl.gz' DELIMITER '|'; +-- +ok +== +SELECT l_partkey FROM lineitem WHERE l_orderkey=1 ORDER BY l_linenumber +-- +ok +== +COPY lineitem TO '{TEMP_DIR}/lineitem1k.csv.gz' (DELIMITER '|', HEADER); +-- +ok +== +CREATE TABLE lineitem_rt AS FROM '{TEMP_DIR}/lineitem1k.csv.gz'; +-- +ok +== +SELECT COUNT(*) FROM (FROM lineitem EXCEPT FROM lineitem_rt) +-- +ok +== diff --git a/parser/testdata/corpus/sql/copy/csv/test_copy_many_empty_lines.test b/parser/testdata/corpus/sql/copy/csv/test_copy_many_empty_lines.test new file mode 100644 index 0000000..f2df950 --- /dev/null +++ b/parser/testdata/corpus/sql/copy/csv/test_copy_many_empty_lines.test @@ -0,0 +1,17 @@ +# source: test/sql/copy/csv/test_copy_many_empty_lines.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +CREATE TABLE test (a INTEGER); +-- +ok +== +COPY test FROM '{DATA_DIR}/csv/test/many_empty_lines.csv' (HEADER 0); +-- +ok +== +SELECT SUM(a) FROM test; +-- +ok +== diff --git a/parser/testdata/corpus/sql/copy/csv/test_copy_null.test b/parser/testdata/corpus/sql/copy/csv/test_copy_null.test new file mode 100644 index 0000000..07a7721 --- /dev/null +++ b/parser/testdata/corpus/sql/copy/csv/test_copy_null.test @@ -0,0 +1,85 @@ +# source: test/sql/copy/csv/test_copy_null.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +CREATE TABLE test_null_option (col_a INTEGER, col_b VARCHAR(10), col_c VARCHAR(10), col_d VARCHAR(10), col_e VARCHAR); +-- +ok +== +COPY test_null_option FROM '{DATA_DIR}/csv/test/test_null_option.csv' (NULL 'NULL'); +-- +ok +== +SELECT * FROM test_null_option ORDER BY 1 LIMIT 3; +-- +ok +== +DELETE FROM test_null_option; +-- +ok +== +COPY test_null_option FROM '{DATA_DIR}/csv/test/test_null_option.csv' (NULL ''); +-- +ok +== +COPY test_null_option FROM '{DATA_DIR}/csv/test/test_null_option.csv' (NULL 'test'); +-- +ok +== +COPY test_null_option FROM '{DATA_DIR}/csv/test/test_null_option.csv' (NULL 'null'); +-- +ok +== +COPY test_null_option FROM '{DATA_DIR}/csv/test/test_null_option.csv' (NULL null); +-- +ok +== +COPY test_null_option FROM '{DATA_DIR}/csv/test/test_null_option.csv' (NULL 'null,', DELIMITER ','); +-- +ok +== +COPY test_null_option FROM '{DATA_DIR}/csv/test/test_null_option.csv' (DELIMITER 'null', NULL 'null'); +-- +ok +== +COPY test_null_option FROM '{DATA_DIR}/csv/test/test_null_option.csv' (DELIMITER 'null', NULL 'nu'); +-- +ok +== +COPY test_null_option FROM '{DATA_DIR}/csv/test/test_null_option.csv' (NULL); +-- +ok +== +CREATE TABLE test_null_option_2 (col_a INTEGER, col_b INTEGER, col_c VARCHAR(10), col_d VARCHAR(10)); +-- +ok +== +COPY test_null_option_2 FROM '{DATA_DIR}/csv/test/test_null_option.csv' (NULL 'null'); +-- +ok +== +COPY test_null_option TO '{TEMP_DIR}/test_null_option_2.csv'; +-- +ok +== +COPY test_null_option FROM '{TEMP_DIR}/test_null_option_2.csv'; +-- +ok +== +COPY test_null_option TO '{TEMP_DIR}/test_null_option_3.csv' (NULL ''); +-- +ok +== +COPY test_null_option FROM '{TEMP_DIR}/test_null_option_3.csv' (NULL ''); +-- +ok +== +COPY test_null_option TO '{TEMP_DIR}/test_null_option_4.csv' (NULL 'null'); +-- +ok +== +COPY test_null_option FROM '{TEMP_DIR}/test_null_option_4.csv' (NULL 'null'); +-- +ok +== diff --git a/parser/testdata/corpus/sql/copy/csv/test_csv_duplicate_columns.test b/parser/testdata/corpus/sql/copy/csv/test_csv_duplicate_columns.test new file mode 100644 index 0000000..1c785ce --- /dev/null +++ b/parser/testdata/corpus/sql/copy/csv/test_csv_duplicate_columns.test @@ -0,0 +1,25 @@ +# source: test/sql/copy/csv/test_csv_duplicate_columns.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +COPY (SELECT 1 as a, 2 as a, 3 as a) TO '{TEST_DIR}/dupe_cols.csv' (FORMAT CSV, HEADER); +-- +ok +== +SELECT a, "a_1", "a_2" FROM '{TEST_DIR}/dupe_cols.csv'; +-- +ok +== +COPY (SELECT 1 as a, 2 as a, 3 as "a_1") TO '{TEST_DIR}/dupe_cols.csv' (FORMAT CSV, HEADER); +-- +ok +== +SELECT a, "a_1", "a_1_1" FROM '{TEST_DIR}/dupe_cols.csv'; +-- +ok +== +COPY (SELECT 1 as a, 3 as "a_1", 2 as a) TO '{TEST_DIR}/dupe_cols.csv' (FORMAT CSV, HEADER); +-- +ok +== diff --git a/parser/testdata/corpus/sql/copy/csv/test_csv_error_message_type.test b/parser/testdata/corpus/sql/copy/csv/test_csv_error_message_type.test new file mode 100644 index 0000000..ba7704d --- /dev/null +++ b/parser/testdata/corpus/sql/copy/csv/test_csv_error_message_type.test @@ -0,0 +1,69 @@ +# source: test/sql/copy/csv/test_csv_error_message_type.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +CREATE TABLE venue ( + venueid SMALLINT NOT NULL /*PRIMARY KEY*/ + , venuename VARCHAR (100) + , venuecity VARCHAR (30) + , venuestate CHAR (2) + , venueseats INTEGER +); +-- +ok +== +copy venue from '{DATA_DIR}/csv/venue_pipe.csv' +-- +ok +== +SELECT * FROM read_csv('{DATA_DIR}/csv/venue_pipe.csv', types=['SMALLINT','VARCHAR','VARCHAR','VARCHAR','INTEGER']); +-- +ok +== +SELECT * FROM read_csv('{DATA_DIR}/csv/venue_pipe.csv', types={'venueseats':'INTEGER'}); +-- +ok +== +SELECT * FROM read_csv('{DATA_DIR}/csv/venue_pipe_big.csv', sample_size = 1); +-- +ok +== +CREATE TABLE venue_2 ( + venueid SMALLINT NOT NULL /*PRIMARY KEY*/ + , venuename VARCHAR (100) + , venuecity VARCHAR (30) + , venuestate CHAR (2) + , venueseats VARCHAR +); +-- +ok +== +INSERT INTO venue_2 SELECT * FROM read_csv('{DATA_DIR}/csv/venue_pipe_big.csv', sample_size = 1); +-- +ok +== +SELECT COUNT(*) from venue_2 +-- +ok +== +DROP TABLE venue_2 +-- +ok +== +INSERT INTO venue_2 SELECT * FROM read_csv('{DATA_DIR}/csv/venue_pipe_big.csv', sample_size = 1, types={'venueseats': 'VARCHAR'}); +-- +ok +== +INSERT INTO venue_2 SELECT * FROM read_csv('{DATA_DIR}/csv/venue_pipe_big.csv', sample_size = -1); +-- +ok +== +copy venue_2 from '{DATA_DIR}/csv/venue_pipe_big.csv' +-- +ok +== +INSERT INTO venue SELECT * FROM read_csv('{DATA_DIR}/csv/venue_pipe.csv'); +-- +ok +== diff --git a/parser/testdata/corpus/sql/copy/csv/test_csv_json.test b/parser/testdata/corpus/sql/copy/csv/test_csv_json.test new file mode 100644 index 0000000..7830e18 --- /dev/null +++ b/parser/testdata/corpus/sql/copy/csv/test_csv_json.test @@ -0,0 +1,25 @@ +# source: test/sql/copy/csv/test_csv_json.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +FROM read_csv('{DATA_DIR}/csv/error/json.csv', columns={'a':'JSON'}) +-- +ok +== +FROM read_csv('{DATA_DIR}/csv/error/json.csv', columns={'a':'JSON'}, ignore_errors = true) +-- +ok +== +create table t (a json); +-- +ok +== +insert into t FROM read_csv('{DATA_DIR}/csv/error/json.csv', columns={'a':'JSON'}, ignore_errors = true) +-- +ok +== +FROM t +-- +ok +== diff --git a/parser/testdata/corpus/sql/copy/csv/test_csv_mixed_casts.test b/parser/testdata/corpus/sql/copy/csv/test_csv_mixed_casts.test new file mode 100644 index 0000000..cd95dbd --- /dev/null +++ b/parser/testdata/corpus/sql/copy/csv/test_csv_mixed_casts.test @@ -0,0 +1,116 @@ +# source: test/sql/copy/csv/test_csv_mixed_casts.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +FROM read_csv( + '{DATA_DIR}/csv/mixed_dates.csv', + auto_detect = false, + header = true, + columns = { + 'A': 'INTEGER', + 'B': 'DATE', + }, + dateformat = '%m/%d/%Y', + ignore_errors = true +); +-- +ok +== +FROM read_csv( + '{DATA_DIR}/csv/mixed_timestamps.csv', + auto_detect = false, + header = true, + columns = { + 'A': 'INTEGER', + 'B': 'TIMESTAMP', + }, + timestampformat = '%m/%d/%Y %H:%M:%S', + ignore_errors = true +); +-- +ok +== +FROM read_csv( + '{DATA_DIR}/csv/mixed_double.csv', + auto_detect = false, + header = true, + columns = { + 'A': 'INTEGER', + 'B': 'FLOAT', + }, + ignore_errors = true +); +-- +ok +== +FROM read_csv( + '{DATA_DIR}/csv/mixed_double.csv', + auto_detect = false, + header = true, + columns = { + 'A': 'INTEGER', + 'B': 'DOUBLE', + }, + ignore_errors = true +); +-- +ok +== +FROM read_csv( + '{DATA_DIR}/csv/mixed_double.csv', + auto_detect = false, + header = true, + columns = { + 'A': 'INTEGER', + 'B': 'DECIMAL', + }, + ignore_errors = true +); +-- +ok +== +FROM read_csv( + '{DATA_DIR}/csv/mixed_decimal.csv', + auto_detect = false, + header = true, + delim = ';', + columns = { + 'A': 'INTEGER', + 'B': 'DECIMAL', + }, + ignore_errors = true +); +-- +ok +== +FROM read_csv( + '{DATA_DIR}/csv/mixed_decimal.csv', + auto_detect = false, + header = true, + delim = ';', + decimal_separator = ',', + columns = { + 'A': 'INTEGER', + 'B': 'DECIMAL', + }, + ignore_errors = true +); +-- +ok +== +FROM read_csv( + '{DATA_DIR}/csv/mixed_decimal.csv', + auto_detect = false, + header = true, + delim = '|', + decimal_separator = ';', + columns = { + 'A': 'INTEGER', + 'B': 'DECIMAL', + }, + ignore_errors = true +); +-- +ok +== diff --git a/parser/testdata/corpus/sql/copy/csv/test_csv_no_trailing_newline.test b/parser/testdata/corpus/sql/copy/csv/test_csv_no_trailing_newline.test new file mode 100644 index 0000000..7f70484 --- /dev/null +++ b/parser/testdata/corpus/sql/copy/csv/test_csv_no_trailing_newline.test @@ -0,0 +1,17 @@ +# source: test/sql/copy/csv/test_csv_no_trailing_newline.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +CREATE TABLE no_newline (a INTEGER, b INTEGER, c VARCHAR(10)); +-- +ok +== +COPY no_newline FROM '{DATA_DIR}/csv/test/no_newline.csv'; +-- +ok +== +FROM read_csv('{DATA_DIR}/csv/test/no_newline_unicode.csv', delim= '🦆') limit 5; +-- +ok +== diff --git a/parser/testdata/corpus/sql/copy/csv/test_csv_projection_pushdown.test b/parser/testdata/corpus/sql/copy/csv/test_csv_projection_pushdown.test new file mode 100644 index 0000000..9a845f1 --- /dev/null +++ b/parser/testdata/corpus/sql/copy/csv/test_csv_projection_pushdown.test @@ -0,0 +1,79 @@ +# source: test/sql/copy/csv/test_csv_projection_pushdown.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +select l_returnflag, l_linenumber from read_csv('{DATA_DIR}/csv/real/lineitem_sample.csv', delim='|', header=False, columns={ + 'l_orderkey': 'INT', + 'l_partkey': 'INT', + 'l_suppkey': 'INT', + 'l_linenumber': 'INT', + 'l_quantity': 'INTEGER', + 'l_extendedprice': 'DECIMAL(15,2)', + 'l_discount': 'DECIMAL(15,2)', + 'l_tax': 'DECIMAL(15,2)', + 'l_returnflag': 'VARCHAR(1)', + 'l_linestatus': 'VARCHAR(1)', + 'l_shipdate': 'DATE', + 'l_commitdate': 'DATE', + 'l_receiptdate': 'DATE', + 'l_shipinstruct': 'VARCHAR(25)', + 'l_shipmode': 'VARCHAR(10)', + 'l_comment': 'VARCHAR(44)' +}) +-- +ok +== +SELECT COUNT(*) FROM '{DATA_DIR}/csv/real/lineitem_sample.csv' +-- +ok +== +CREATE VIEW lineitem_csv AS SELECT * FROM read_csv('{DATA_DIR}/csv/real/lineitem_sample.csv', delim='|', header=False, columns={ + 'l_orderkey': 'INT', + 'l_partkey': 'INT', + 'l_suppkey': 'INT', + 'l_linenumber': 'INT', + 'l_quantity': 'INTEGER', + 'l_extendedprice': 'DECIMAL(15,2)', + 'l_discount': 'DECIMAL(15,2)', + 'l_tax': 'DECIMAL(15,2)', + 'l_returnflag': 'VARCHAR(1)', + 'l_linestatus': 'VARCHAR(1)', + 'l_shipdate': 'DATE', + 'l_commitdate': 'DATE', + 'l_receiptdate': 'DATE', + 'l_shipinstruct': 'VARCHAR(25)', + 'l_shipmode': 'VARCHAR(10)', + 'l_comment': 'VARCHAR(44)' +}) +-- +ok +== +CREATE VIEW lineitem_csv_auto AS SELECT * FROM read_csv_auto('{DATA_DIR}/csv/real/lineitem_sample.csv', header=False) lineitem(l_orderkey, l_partkey, l_suppkey, l_linenumber, l_quantity, l_extendedprice, l_discount, l_tax, l_returnflag, l_linestatus, l_shipdate, l_commitdate, l_receiptdate, l_shipinstruct, l_shipmode, l_comment) +-- +ok +== +SELECT l_orderkey FROM {lineitem} +-- +error: Parser Error: syntax error at or near "{" +== +SELECT l_partkey FROM {lineitem} +-- +error: Parser Error: syntax error at or near "{" +== +SELECT l_shipdate FROM {lineitem} +-- +error: Parser Error: syntax error at or near "{" +== +SELECT COUNT(*) FROM {lineitem} +-- +error: Parser Error: syntax error at or near "{" +== +select count(*) from read_csv('{DATA_DIR}/csv/projection_buffer.csv', quote = '"', escape = '"', buffer_size=35) +-- +ok +== +select d,b,a from read_csv('{DATA_DIR}/csv/projection_buffer.csv', quote = '"', escape = '"', buffer_size=35) +-- +ok +== diff --git a/parser/testdata/corpus/sql/copy/csv/test_csv_projection_pushdown_glob.test b/parser/testdata/corpus/sql/copy/csv/test_csv_projection_pushdown_glob.test new file mode 100644 index 0000000..b0c631b --- /dev/null +++ b/parser/testdata/corpus/sql/copy/csv/test_csv_projection_pushdown_glob.test @@ -0,0 +1,41 @@ +# source: test/sql/copy/csv/test_csv_projection_pushdown_glob.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +COPY (SELECT DATE '1992-01-01' d, 42 i, 'hello' s) TO '{TEST_DIR}/projection_pushdown_f1.csv' (HEADER, DELIMITER '|') +-- +ok +== +COPY (SELECT DATE '1993-01-01' d, 84 i, 'world' s) TO '{TEST_DIR}/projection_pushdown_f2.csv' (HEADER, DELIMITER '|') +-- +ok +== +COPY (SELECT DATE '1994-01-01' d, 100 i, 'this is a long string' s) TO '{TEST_DIR}/projection_pushdown_f3.csv' (HEADER, DELIMITER '|') +-- +ok +== +CREATE VIEW glob_view AS SELECT * FROM read_csv_auto('{TEST_DIR}/projection_pushdown_f*.csv') +-- +ok +== +CREATE VIEW list_view AS SELECT * FROM read_csv_auto(['{TEST_DIR}/projection_pushdown_f1.csv', '{TEST_DIR}/projection_pushdown_f2.csv', '{TEST_DIR}/projection_pushdown_f3.csv']) +-- +ok +== +SELECT i FROM {tbl} ORDER BY i +-- +error: Parser Error: syntax error at or near "{" +== +SELECT d FROM {tbl} ORDER BY d +-- +error: Parser Error: syntax error at or near "{" +== +SELECT s FROM {tbl} ORDER BY s +-- +error: Parser Error: syntax error at or near "{" +== +SELECT COUNT(*) FROM {tbl} +-- +error: Parser Error: syntax error at or near "{" +== diff --git a/parser/testdata/corpus/sql/copy/csv/test_csv_timestamp_tz.test b/parser/testdata/corpus/sql/copy/csv/test_csv_timestamp_tz.test new file mode 100644 index 0000000..c56d483 --- /dev/null +++ b/parser/testdata/corpus/sql/copy/csv/test_csv_timestamp_tz.test @@ -0,0 +1,67 @@ +# source: test/sql/copy/csv/test_csv_timestamp_tz.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +copy ( +select '2021-05-25 04:55:03.382494 UTC'::timestamp as ts, '2021-05-25 04:55:03.382494 UTC'::timestamptz as tstz +) to '{TEMP_DIR}/timestamps.csv' ( timestampformat '%A'); +-- +ok +== +SET TimeZone='UTC' +-- +ok +== +FROM read_csv('{DATA_DIR}/csv/timestamp_timezone.csv', columns = {'time':'timestamptz', 'description':'varchar'}) +-- +ok +== +FROM read_csv('{DATA_DIR}/csv/timestamp_timezone.csv', auto_type_candidates = ['BOOLEAN', 'BIGINT', 'DOUBLE', 'TIME', 'DATE', 'TIMESTAMP','TIMESTAMPTZ', 'VARCHAR']) +-- +ok +== +FROM read_csv('{DATA_DIR}/csv/timestamp_timezone.csv', auto_type_candidates = ['BOOLEAN', 'BIGINT', 'DOUBLE', 'TIME', 'DATE', 'TIMESTAMPTZ', 'VARCHAR']) +-- +ok +== +SELECT columns FROM sniff_csv('{DATA_DIR}/csv/timestamp_timezone.csv') +-- +ok +== +FROM '{DATA_DIR}/csv/timestamp_timezone.csv' +-- +ok +== +SELECT columns FROM sniff_csv('{DATA_DIR}/csv/timestamp_with_tz.csv') +-- +ok +== +FROM '{DATA_DIR}/csv/timestamp_with_tz.csv' +-- +ok +== +create table t as SELECT '1; 2020-01-01 00:00:00+00' as ts from range (10000) +-- +ok +== +copy t to '{TEMP_DIR}/timetz.csv' +-- +ok +== +SELECT columns FROM sniff_csv('{TEMP_DIR}/timetz.csv') +-- +ok +== +insert into t values ('2; thisisastring') +-- +ok +== +copy t to '{TEMP_DIR}/timetz_2.csv' +-- +ok +== +SELECT columns FROM sniff_csv('{TEMP_DIR}/timetz_2.csv') +-- +ok +== diff --git a/parser/testdata/corpus/sql/copy/csv/test_csv_timestamp_tz_icu.test b/parser/testdata/corpus/sql/copy/csv/test_csv_timestamp_tz_icu.test new file mode 100644 index 0000000..9990f2f --- /dev/null +++ b/parser/testdata/corpus/sql/copy/csv/test_csv_timestamp_tz_icu.test @@ -0,0 +1,23 @@ +# source: test/sql/copy/csv/test_csv_timestamp_tz_icu.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +SET Calendar = 'gregorian'; +-- +ok +== +SET TimeZone = 'America/Los_Angeles'; +-- +ok +== +COPY ( + SELECT make_timestamptz(1713193669561000) AS t +) TO '{TEST_DIR}/timestamp-format.csv' (FORMAT CSV, timestampformat '%x %X.%g%z'); +-- +ok +== +select * from read_csv('{TEST_DIR}/timestamp-format.csv', all_varchar=true) +-- +ok +== diff --git a/parser/testdata/corpus/sql/copy/csv/test_date.test b/parser/testdata/corpus/sql/copy/csv/test_date.test new file mode 100644 index 0000000..7e53fbc --- /dev/null +++ b/parser/testdata/corpus/sql/copy/csv/test_date.test @@ -0,0 +1,37 @@ +# source: test/sql/copy/csv/test_date.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +SELECT cast(d as string) FROM date_test; +-- +ok +== +Select * from read_csv('{DATA_DIR}/csv/custom_date.csv', header=true, dateformat='%m/%d/%Y, %-I:%-M %p', types = ['BIGINT', 'DATE'] ); +-- +ok +== +Select * from read_csv('{DATA_DIR}/csv/custom_date.csv', header=true, dateformat='%m/%d/%Y, %-I:%-M %p'); +-- +ok +== +Select * from read_csv('{DATA_DIR}/csv/custom_date.csv', header=true, timestampformat='%m/%d/%Y, %-I:%-M %p', types = ['BIGINT', 'TIMESTAMP'] ); +-- +ok +== +Select * from read_csv('{DATA_DIR}/csv/custom_date.csv', header=true, timestampformat='%m/%d/%Y, %-I:%-M %p'); +-- +ok +== +select typeof(#1),typeof(#2),typeof(#3) FROM '{DATA_DIR}/csv/versions.csv' limit 1 +-- +ok +== +select typeof(#1) FROM read_csv('{DATA_DIR}/csv/dates_special_format.csv', dateformat = '%b %-d, %Y', columns = {'Date': 'DATE'}) limit 1; +-- +ok +== +select typeof(#1) FROM read_csv('{DATA_DIR}/csv/dates_special_format.csv', dateformat = '%b %-d, %Y') limit 1; +-- +ok +== diff --git a/parser/testdata/corpus/sql/copy/csv/test_date_sniffer.test b/parser/testdata/corpus/sql/copy/csv/test_date_sniffer.test new file mode 100644 index 0000000..ada25ac --- /dev/null +++ b/parser/testdata/corpus/sql/copy/csv/test_date_sniffer.test @@ -0,0 +1,41 @@ +# source: test/sql/copy/csv/test_date_sniffer.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +FROM '{DATA_DIR}/csv/bad_date.csv' +-- +ok +== +SELECT columns FROM sniff_csv('{DATA_DIR}/csv/bad_date.csv') +-- +ok +== +FROM '{DATA_DIR}/csv/bad_date_2.csv' +-- +ok +== +SELECT columns[1].type FROM sniff_csv('{DATA_DIR}/csv/bad_date_2.csv') +-- +ok +== +SELECT columns FROM sniff_csv('{DATA_DIR}/csv/bad_date_2.csv') +-- +ok +== +FROM '{DATA_DIR}/csv/conflict_timestamp.csv' +-- +ok +== +SELECT columns[1].type, columns[2].type FROM sniff_csv('{DATA_DIR}/csv/conflict_timestamp.csv') +-- +ok +== +FROM '{DATA_DIR}/csv/bad_date_timestamp_mix.csv' +-- +ok +== +SELECT columns FROM sniff_csv('{DATA_DIR}/csv/bad_date_timestamp_mix.csv') +-- +ok +== diff --git a/parser/testdata/corpus/sql/copy/csv/test_dateformat.test b/parser/testdata/corpus/sql/copy/csv/test_dateformat.test new file mode 100644 index 0000000..c807a5d --- /dev/null +++ b/parser/testdata/corpus/sql/copy/csv/test_dateformat.test @@ -0,0 +1,101 @@ +# source: test/sql/copy/csv/test_dateformat.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +CREATE TABLE dates (d DATE); +-- +ok +== +COPY dates FROM '{DATA_DIR}/csv/test/dateformat.csv' (AUTO_DETECT 0, HEADER 0) +-- +ok +== +COPY dates FROM '{DATA_DIR}/csv/test/dateformat.csv' (HEADER 0, DATEFORMAT '%d/%m/%Y') +-- +ok +== +SELECT * FROM dates +-- +ok +== +COPY dates FROM '{DATA_DIR}/csv/test/dateformat.csv' (HEADER 0, DATEFORMAT '%m/%d/%Y') +-- +ok +== +SELECT * FROM dates ORDER BY d +-- +ok +== +CREATE TABLE new_dates (d DATE); +-- +ok +== +COPY dates TO '{TEMP_DIR}/dateformat.csv' (HEADER 0, DATEFORMAT '%d/%m/%Y') +-- +ok +== +COPY new_dates FROM '{TEMP_DIR}/dateformat.csv' (HEADER 0, DATEFORMAT '%d/%m/%Y') +-- +ok +== +SELECT * FROM new_dates ORDER BY 1 +-- +ok +== +CREATE TABLE timestamps(t TIMESTAMP); +-- +ok +== +COPY timestamps FROM '{DATA_DIR}/csv/test/timestampformat.csv' (HEADER 0, DELIMITER '|', TIMESTAMPFORMAT '%a %d, %B %Y, %I:%M:%S %p') +-- +ok +== +SELECT * FROM timestamps +-- +ok +== +CREATE TABLE new_timestamps (t TIMESTAMP); +-- +ok +== +COPY timestamps TO '{TEMP_DIR}/timestampformat.csv' (HEADER 0, TIMESTAMPFORMAT '%a %d, %B %Y, %I:%M:%S %p') +-- +ok +== +COPY new_timestamps FROM '{TEMP_DIR}/timestampformat.csv' (HEADER 0, TIMESTAMPFORMAT '%a %d, %B %Y, %I:%M:%S %p') +-- +ok +== +SELECT * FROM new_timestamps ORDER BY 1 +-- +ok +== +DELETE FROM new_timestamps +-- +ok +== +COPY timestamps TO '{TEMP_DIR}/timestampformat.csv' (HEADER 0, TIMESTAMPFORMAT ISO) +-- +ok +== +COPY new_timestamps FROM '{TEMP_DIR}/timestampformat.csv' (HEADER 0) +-- +ok +== +COPY dates FROM '{DATA_DIR}/csv/test/dateformat.csv' (HEADER 0, DATEFORMAT '%') +-- +ok +== +COPY timestamps FROM '{DATA_DIR}/csv/test/timestampformat.csv' (HEADER 0, DELIMITER '|', TIMESTAMPFORMAT '%') +-- +ok +== +select columns FROM sniff_csv('{DATA_DIR}/csv/dateformat/working.csv', header=true,dateformat='%d-%b-%Y'); +-- +ok +== +select columns FROM sniff_csv('{DATA_DIR}/csv/dateformat/not_working.csv', header=true,dateformat='%d-%b-%Y'); +-- +ok +== diff --git a/parser/testdata/corpus/sql/copy/csv/test_decimal.test b/parser/testdata/corpus/sql/copy/csv/test_decimal.test new file mode 100644 index 0000000..a030181 --- /dev/null +++ b/parser/testdata/corpus/sql/copy/csv/test_decimal.test @@ -0,0 +1,61 @@ +# source: test/sql/copy/csv/test_decimal.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +FROM '{DATA_DIR}/csv/decimal.csv' +-- +ok +== +select typeof (col_a) FROM '{DATA_DIR}/csv/decimal.csv' +-- +ok +== +SELECT * FROM read_csv( + '{DATA_DIR}/csv/decimal.csv', + columns = {'col_a': 'DECIMAL'}); +-- +ok +== +SELECT typeof(col_a) FROM read_csv( + '{DATA_DIR}/csv/decimal.csv', + columns = {'col_a': 'DECIMAL'}); +-- +ok +== +SELECT * FROM read_csv( + '{DATA_DIR}/csv/decimal.csv', + columns = {'col_a': 'DECIMAL(18,15)'}); +-- +ok +== +SELECT typeof(col_a) FROM read_csv( + '{DATA_DIR}/csv/decimal.csv', + columns = {'col_a': 'DECIMAL(18,15)'}); +-- +ok +== +SELECT typeof(col_a) FROM read_csv( + '{DATA_DIR}/csv/decimal.csv', + auto_type_candidates=['NULL', 'DECIMAL', 'VARCHAR']); +-- +ok +== +SELECT typeof(col_a) FROM read_csv( + '{DATA_DIR}/csv/decimal.csv', + auto_type_candidates=['NULL', 'DECIMAL(18,3)','DECIMAL(18,15)', 'VARCHAR']); +-- +ok +== +SELECT typeof(col_a) FROM read_csv( + '{DATA_DIR}/csv/decimal.csv', + auto_type_candidates=['NULL','DECIMAL(18,15)', 'DECIMAL(18,3)', 'VARCHAR']); +-- +ok +== +SELECT typeof(col_a) FROM read_csv( + '{DATA_DIR}/csv/decimal.csv', + auto_type_candidates=['NULL', 'DECIMAL(18,15)', 'VARCHAR']); +-- +ok +== diff --git a/parser/testdata/corpus/sql/copy/csv/test_double_sniffer.test b/parser/testdata/corpus/sql/copy/csv/test_double_sniffer.test new file mode 100644 index 0000000..c70dcd6 --- /dev/null +++ b/parser/testdata/corpus/sql/copy/csv/test_double_sniffer.test @@ -0,0 +1,25 @@ +# source: test/sql/copy/csv/test_double_sniffer.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +SELECT typeof(number) FROM read_csv('{DATA_DIR}/csv/double_trouble.csv', decimal_separator=',') limit 1; +-- +ok +== +SELECT typeof(number) FROM read_csv('{DATA_DIR}/csv/double_trouble.csv', decimal_separator=',', auto_type_candidates = ['FLOAT']) limit 1; +-- +ok +== +SELECT typeof(number) FROM read_csv('{DATA_DIR}/csv/double_trouble.csv', decimal_separator=',', auto_type_candidates = ['FLOAT', 'DOUBLE']) limit 1; +-- +ok +== +SELECT typeof(number) FROM read_csv('{DATA_DIR}/csv/double_trouble.csv', decimal_separator=',', auto_type_candidates = ['DOUBLE', 'FLOAT']) limit 1; +-- +ok +== +SELECT typeof(number) FROM read_csv('{DATA_DIR}/csv/double_trouble.csv', decimal_separator=',', auto_type_candidates = ['DECIMAL']) limit 1; +-- +ok +== diff --git a/parser/testdata/corpus/sql/copy/csv/test_empty_header.test b/parser/testdata/corpus/sql/copy/csv/test_empty_header.test new file mode 100644 index 0000000..f37ebd0 --- /dev/null +++ b/parser/testdata/corpus/sql/copy/csv/test_empty_header.test @@ -0,0 +1,10 @@ +# source: test/sql/copy/csv/test_empty_header.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +select columns[1].name,columns[2].name,columns[3].name,columns[4].name,columns[5].name +from sniff_csv('{DATA_DIR}/csv/headers/empty_{i}.csv') +-- +ok +== diff --git a/parser/testdata/corpus/sql/copy/csv/test_empty_quote.test b/parser/testdata/corpus/sql/copy/csv/test_empty_quote.test new file mode 100644 index 0000000..24bf6cc --- /dev/null +++ b/parser/testdata/corpus/sql/copy/csv/test_empty_quote.test @@ -0,0 +1,21 @@ +# source: test/sql/copy/csv/test_empty_quote.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +CREATE TABLE no_quote(a VARCHAR, b VARCHAR); +-- +ok +== +COPY no_quote FROM '{DATA_DIR}/csv/no_quote.csv' ( QUOTE '', ESCAPE '', DELIM '|'); +-- +ok +== +SELECT * FROM no_quote; +-- +ok +== +SELECT * FROM read_csv('{DATA_DIR}/csv/no_quote.csv', auto_detect=1, quote=''); +-- +ok +== diff --git a/parser/testdata/corpus/sql/copy/csv/test_enum_csv.test b/parser/testdata/corpus/sql/copy/csv/test_enum_csv.test new file mode 100644 index 0000000..c1d019c --- /dev/null +++ b/parser/testdata/corpus/sql/copy/csv/test_enum_csv.test @@ -0,0 +1,13 @@ +# source: test/sql/copy/csv/test_enum_csv.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +CREATE TYPE mood AS ENUM ('happy', 'sad', 'angry') +-- +ok +== +FROM read_csv('{DATA_DIR}/csv/enum_type.csv', types=[mood]) +-- +ok +== diff --git a/parser/testdata/corpus/sql/copy/csv/test_escape_long_value.test b/parser/testdata/corpus/sql/copy/csv/test_escape_long_value.test new file mode 100644 index 0000000..02a219a --- /dev/null +++ b/parser/testdata/corpus/sql/copy/csv/test_escape_long_value.test @@ -0,0 +1,41 @@ +# source: test/sql/copy/csv/test_escape_long_value.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +CREATE TABLE T AS FROM read_csv('{DATA_DIR}/csv/big_escape.csv', buffer_size = {buffer_size}, quote = '"', escape = '"', delim = ';', columns = {'a':'INTEGER','b':'INTEGER', 'c':'VARCHAR'}, auto_detect = false) +-- +error: Parser Error: syntax error at or near "}" +== +select count(*) from T; +-- +ok +== +DROP TABLE T; +-- +ok +== +CREATE TABLE long_escaped_value (a INTEGER, b INTEGER, c VARCHAR); +-- +ok +== +COPY long_escaped_value FROM '{DATA_DIR}/csv/test/long_escaped_value.csv' (DELIMITER '🦆', AUTO_DETECT FALSE, QUOTE '"', ESCAPE '"'); +-- +ok +== +SELECT * FROM long_escaped_value +-- +ok +== +CREATE TABLE long_escaped_value_unicode (a INTEGER, b INTEGER, c VARCHAR); +-- +ok +== +COPY long_escaped_value_unicode FROM '{DATA_DIR}/csv/test/long_escaped_value_unicode.csv'; +-- +ok +== +SELECT * FROM long_escaped_value_unicode +-- +ok +== diff --git a/parser/testdata/corpus/sql/copy/csv/test_export_force_quotes.test b/parser/testdata/corpus/sql/copy/csv/test_export_force_quotes.test new file mode 100644 index 0000000..152dd9e --- /dev/null +++ b/parser/testdata/corpus/sql/copy/csv/test_export_force_quotes.test @@ -0,0 +1,17 @@ +# source: test/sql/copy/csv/test_export_force_quotes.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +export database '{TEST_DIR}/test_export' (force_quote *); +-- +ok +== +import database '{TEST_DIR}/test_export'; +-- +ok +== +select * from integers; +-- +ok +== diff --git a/parser/testdata/corpus/sql/copy/csv/test_export_not_null.test b/parser/testdata/corpus/sql/copy/csv/test_export_not_null.test new file mode 100644 index 0000000..99817f5 --- /dev/null +++ b/parser/testdata/corpus/sql/copy/csv/test_export_not_null.test @@ -0,0 +1,49 @@ +# source: test/sql/copy/csv/test_export_not_null.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +create table tbl(a VARCHAR NOT NULL) +-- +ok +== +insert into tbl values (''); +-- +ok +== +EXPORT DATABASE '{TEST_DIR}/broken_empty_string'; +-- +ok +== +abort; +-- +ok +== +IMPORT DATABASE '{TEST_DIR}/broken_empty_string'; +-- +ok +== +EXPORT DATABASE '{TEST_DIR}/broken_empty_string_2' (FORCE_NOT_NULL ['A']); +-- +ok +== +create table tbl_2(a VARCHAR NOT NULL, b VARCHAR NOT NULL, c VARCHAR NOT NULL, d VARCHAR) +-- +ok +== +insert into tbl_2 values ('','','',''); +-- +ok +== +EXPORT DATABASE '{TEST_DIR}/multiple'; +-- +ok +== +IMPORT DATABASE '{TEST_DIR}/multiple'; +-- +ok +== +select * from tbl_2 +-- +ok +== diff --git a/parser/testdata/corpus/sql/copy/csv/test_extra_delimiters_rfc.test b/parser/testdata/corpus/sql/copy/csv/test_extra_delimiters_rfc.test new file mode 100644 index 0000000..1457cc0 --- /dev/null +++ b/parser/testdata/corpus/sql/copy/csv/test_extra_delimiters_rfc.test @@ -0,0 +1,9 @@ +# source: test/sql/copy/csv/test_extra_delimiters_rfc.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +FROM read_csv('{DATA_DIR}/csv/extra_delimiters.csv', strict_mode = false, columns={'a':'VARCHAR','b':'VARCHAR','c':'VARCHAR'}, auto_detect = false, delim = ',', header = true) +-- +ok +== diff --git a/parser/testdata/corpus/sql/copy/csv/test_filename_filter.test b/parser/testdata/corpus/sql/copy/csv/test_filename_filter.test new file mode 100644 index 0000000..9f36f3b --- /dev/null +++ b/parser/testdata/corpus/sql/copy/csv/test_filename_filter.test @@ -0,0 +1,21 @@ +# source: test/sql/copy/csv/test_filename_filter.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +SELECT column1, column2, column3, parse_filename(filename) FROM read_csv('{DATA_DIR}/csv/filename_filter/*.csv', filename=true); +-- +ok +== +SELECT column1, column2, column3, parse_filename(filename) FROM read_csv(['{DATA_DIR}/csv/filename_filter/a.csv','{DATA_DIR}/csv/filename_filter/b.csv','{DATA_DIR}/csv/filename_filter/c.csv','{DATA_DIR}/csv/filename_filter/d.csv'], filename=true) WHERE filename like '%d.csv'; +-- +ok +== +SELECT column1, column2, column3, parse_filename(filename) FROM read_csv(['{DATA_DIR}/csv/filename_filter/a.csv','{DATA_DIR}/csv/filename_filter/b.csv','{DATA_DIR}/csv/filename_filter/c.csv','{DATA_DIR}/csv/filename_filter/d.csv'], filename=true, union_by_name=true) WHERE filename like '%d.csv'; +-- +ok +== +SELECT column1, column2, column3, parse_filename(filename) FROM read_csv('{DATA_DIR}/csv/filename_filter/*.csv', filename=true, union_by_name=true) WHERE filename like '%d.csv'; +-- +ok +== diff --git a/parser/testdata/corpus/sql/copy/csv/test_force_not_null.test b/parser/testdata/corpus/sql/copy/csv/test_force_not_null.test new file mode 100644 index 0000000..821e927 --- /dev/null +++ b/parser/testdata/corpus/sql/copy/csv/test_force_not_null.test @@ -0,0 +1,45 @@ +# source: test/sql/copy/csv/test_force_not_null.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +CREATE TABLE test (col_a INTEGER, col_b VARCHAR(10), col_c VARCHAR(10)); +-- +ok +== +COPY test FROM '{DATA_DIR}/csv/test/force_not_null.csv' (FORCE_NOT_NULL (col_b), NULL 'test', HEADER 0,allow_quoted_nulls false ); +-- +ok +== +COPY test (col_a, col_b, col_c) FROM '{DATA_DIR}/csv/test/force_not_null.csv' (FORCE_NOT_NULL (col_b), NULL 'test', HEADER 0, allow_quoted_nulls false); +-- +ok +== +COPY test TO '{DATA_DIR}/csv/test/force_not_null.csv' (FORCE_NOT_NULL (col_b), NULL 'test', HEADER 0); +-- +ok +== +COPY test FROM '{DATA_DIR}/csv/test/force_not_null.csv' (FORCE_NOT_NULL, NULL 'test'); +-- +ok +== +COPY test FROM '{DATA_DIR}/csv/test/force_not_null.csv' (FORCE_NOT_NULL 42, NULL 'test'); +-- +ok +== +COPY test (col_b, col_a) FROM '{DATA_DIR}/csv/test/force_not_null_reordered.csv' (FORCE_NOT_NULL (col_c, col_b)); +-- +ok +== +COPY test FROM '{DATA_DIR}/csv/test/force_not_null_reordered.csv' (FORCE_NOT_NULL (col_c, col_d)); +-- +ok +== +COPY test FROM '{DATA_DIR}/csv/test/force_not_null.csv' (FORCE_NOT_NULL (col_a), HEADER 0); +-- +ok +== +COPY test FROM '{DATA_DIR}/csv/test/force_not_null_inull.csv' (FORCE_NOT_NULL (col_a), HEADER 0); +-- +ok +== diff --git a/parser/testdata/corpus/sql/copy/csv/test_force_quote.test b/parser/testdata/corpus/sql/copy/csv/test_force_quote.test new file mode 100644 index 0000000..2971315 --- /dev/null +++ b/parser/testdata/corpus/sql/copy/csv/test_force_quote.test @@ -0,0 +1,57 @@ +# source: test/sql/copy/csv/test_force_quote.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +COPY test FROM '{DATA_DIR}/csv/test/force_quote.csv' (HEADER 0); +-- +ok +== +COPY test TO '{TEMP_DIR}/test_star.csv' (FORCE_QUOTE *, HEADER 0); +-- +ok +== +COPY test TO '{TEMP_DIR}/test_chosen_columns.csv' (FORCE_QUOTE (col_a, col_c), QUOTE 't', NULL 'ea'); +-- +ok +== +CREATE TABLE test2 (col_a INTEGER, col_b VARCHAR(10), col_c VARCHAR(10)); +-- +ok +== +COPY test2 FROM '{TEMP_DIR}/test_chosen_columns.csv' (QUOTE 't', NULL 'ea'); +-- +ok +== +COPY test (col_b, col_c, col_a) TO '{TEMP_DIR}/test_reorder.csv' (FORCE_QUOTE (col_c, col_b), NULL 'test'); +-- +ok +== +CREATE TABLE test3 (col_a INTEGER, col_b VARCHAR(10), col_c VARCHAR(10)); +-- +ok +== +COPY test3(col_b, col_c, col_a) FROM '{TEMP_DIR}/test_reorder.csv' (NULL 'test'); +-- +ok +== +COPY test (col_b, col_a) TO '{TEMP_DIR}/test_reorder.csv' (FORCE_QUOTE (col_c, col_b)); +-- +ok +== +COPY test TO '{TEMP_DIR}/test_reorder.csv' (FORCE_QUOTE (col_c, col_d)); +-- +ok +== +COPY test FROM '{TEMP_DIR}/test_reorder.csv' (FORCE_QUOTE (col_c, col_d)); +-- +ok +== +COPY test TO '{TEMP_DIR}/test_reorder.csv' (FORCE_QUOTE); +-- +ok +== +COPY test TO '{TEMP_DIR}/test_reorder.csv' (FORCE_QUOTE 42); +-- +ok +== diff --git a/parser/testdata/corpus/sql/copy/csv/test_glob_reorder_lineitem.test b/parser/testdata/corpus/sql/copy/csv/test_glob_reorder_lineitem.test new file mode 100644 index 0000000..0118253 --- /dev/null +++ b/parser/testdata/corpus/sql/copy/csv/test_glob_reorder_lineitem.test @@ -0,0 +1,38 @@ +# source: test/sql/copy/csv/test_glob_reorder_lineitem.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +copy (select l_orderkey,l_partkey,l_suppkey,l_linenumber,l_quantity,l_extendedprice,l_discount,l_tax,l_returnflag,l_linestatus,l_shipdate,l_commitdate,l_receiptdate,l_shipinstruct,l_shipmode,l_comment from lineitem limit 10000 offset 0) + to '{TEST_DIR}/lineitem_part1.csv'; +-- +ok +== +copy (select l_orderkey,l_partkey,l_suppkey,l_linenumber,l_quantity,l_extendedprice,l_tax,l_discount,l_returnflag,l_linestatus,l_shipdate,l_commitdate,l_receiptdate,l_shipinstruct,l_shipmode,l_comment from lineitem limit 10000 offset 10000) + to '{TEST_DIR}/lineitem_part2.csv'; +-- +ok +== +copy (select l_comment,l_orderkey,l_partkey,l_suppkey,l_linenumber,l_quantity,l_extendedprice,l_tax,l_discount,l_returnflag,l_linestatus,l_shipdate,l_commitdate,l_receiptdate,l_shipinstruct,l_shipmode from lineitem limit 10000 offset 20000) + to '{TEST_DIR}/lineitem_part3.csv'; +-- +ok +== +copy (select l_comment,l_orderkey,l_returnflag,l_linestatus,l_shipdate,l_commitdate,l_receiptdate,l_shipinstruct,l_partkey,l_suppkey,l_linenumber,l_quantity,l_extendedprice,l_tax,l_discount,l_shipmode from lineitem limit 10000 offset 30000) + to '{TEST_DIR}/lineitem_part4.csv'; +-- +ok +== +copy (select l_comment,l_orderkey,l_returnflag,l_linestatus,l_shipdate,l_commitdate,l_receiptdate,l_shipinstruct,l_partkey,l_suppkey,l_linenumber,l_quantity,l_extendedprice,l_tax,l_discount,l_shipmode,l_shipmode as shipmode2 from lineitem limit 10000 offset 40000) + to '{TEST_DIR}/lineitem_part5.csv'; +-- +ok +== +create table t as from read_csv(['{TEST_DIR}/lineitem_part1.csv', '{TEST_DIR}/lineitem_part3.csv']); +-- +ok +== +create table t as from read_csv(['{TEST_DIR}/lineitem_part*.csv']); +-- +ok +== diff --git a/parser/testdata/corpus/sql/copy/csv/test_glob_reorder_null.test b/parser/testdata/corpus/sql/copy/csv/test_glob_reorder_null.test new file mode 100644 index 0000000..2145376 --- /dev/null +++ b/parser/testdata/corpus/sql/copy/csv/test_glob_reorder_null.test @@ -0,0 +1,33 @@ +# source: test/sql/copy/csv/test_glob_reorder_null.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +create table t1 as select 1 as a,1 as b from range(3); +-- +ok +== +create table t2 (b integer, a integer); +-- +ok +== +insert into t2 select NULL as b,NULL as a from range(30000); +-- +ok +== +insert into t2 values (3,4); +-- +ok +== +copy t1 to '{TEST_DIR}/null_glob_reorder_1.csv'; +-- +ok +== +copy t2 to '{TEST_DIR}/null_glob_reorder_2.csv'; +-- +ok +== +select a,b from read_csv(['{TEST_DIR}/null_glob_reorder_*.csv']) where b is not null order by all; +-- +ok +== diff --git a/parser/testdata/corpus/sql/copy/csv/test_glob_type.test b/parser/testdata/corpus/sql/copy/csv/test_glob_type.test new file mode 100644 index 0000000..06842ca --- /dev/null +++ b/parser/testdata/corpus/sql/copy/csv/test_glob_type.test @@ -0,0 +1,53 @@ +# source: test/sql/copy/csv/test_glob_type.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +SET threads=1 +-- +ok +== +SELECT typeof(bar) FROM '{DATA_DIR}/csv/17451/*.csv' limit 1 +-- +ok +== +CREATE TABLE T AS SELECT 'bar,baz', UNION ALL SELECT ',baz' from range (0,100000) +-- +ok +== +COPY T TO '{TEMP_DIR}/t.csv' (QUOTE '', HEADER 0) +-- +ok +== +SELECT typeof(bar) FROM read_csv(['{DATA_DIR}/csv/17451/1.csv', '{TEMP_DIR}/t.csv']) limit 1 +-- +ok +== +SELECT typeof(bar) FROM read_csv(['{DATA_DIR}/csv/17451/1.csv','{DATA_DIR}/csv/17451/1.csv','{DATA_DIR}/csv/17451/1.csv','{DATA_DIR}/csv/17451/1.csv','{DATA_DIR}/csv/17451/1.csv','{DATA_DIR}/csv/17451/1.csv','{DATA_DIR}/csv/17451/1.csv','{DATA_DIR}/csv/17451/1.csv','{DATA_DIR}/csv/17451/1.csv','{DATA_DIR}/csv/17451/1.csv','{DATA_DIR}/csv/17451/1.csv','{DATA_DIR}/csv/17451/2.csv','{DATA_DIR}/csv/17451/extra/3.csv'], files_to_sniff = 0) limit 1 +-- +ok +== +SELECT typeof(bar) FROM read_csv(['{DATA_DIR}/csv/17451/1.csv','{DATA_DIR}/csv/17451/1.csv','{DATA_DIR}/csv/17451/1.csv','{DATA_DIR}/csv/17451/1.csv','{DATA_DIR}/csv/17451/1.csv','{DATA_DIR}/csv/17451/1.csv','{DATA_DIR}/csv/17451/1.csv','{DATA_DIR}/csv/17451/1.csv','{DATA_DIR}/csv/17451/1.csv','{DATA_DIR}/csv/17451/1.csv','{DATA_DIR}/csv/17451/1.csv','{DATA_DIR}/csv/17451/2.csv','{DATA_DIR}/csv/17451/extra/3.csv'], files_to_sniff = 5) limit 1 +-- +ok +== +FROM read_csv(['{DATA_DIR}/csv/17451/1.csv','{DATA_DIR}/csv/17451/1.csv','{DATA_DIR}/csv/17451/1.csv','{DATA_DIR}/csv/17451/1.csv','{DATA_DIR}/csv/17451/1.csv','{DATA_DIR}/csv/17451/1.csv','{DATA_DIR}/csv/17451/1.csv','{DATA_DIR}/csv/17451/1.csv','{DATA_DIR}/csv/17451/1.csv','{DATA_DIR}/csv/17451/1.csv','{DATA_DIR}/csv/17451/1.csv','{DATA_DIR}/csv/17451/2.csv','{DATA_DIR}/csv/17451/extra/3.csv'], files_to_sniff = 5) +-- +ok +== +SELECT typeof(bar) FROM read_csv(['{DATA_DIR}/csv/17451/1.csv','{DATA_DIR}/csv/17451/1.csv','{DATA_DIR}/csv/17451/1.csv','{DATA_DIR}/csv/17451/1.csv','{DATA_DIR}/csv/17451/1.csv','{DATA_DIR}/csv/17451/1.csv','{DATA_DIR}/csv/17451/1.csv','{DATA_DIR}/csv/17451/1.csv','{DATA_DIR}/csv/17451/1.csv','{DATA_DIR}/csv/17451/1.csv','{DATA_DIR}/csv/17451/1.csv','{DATA_DIR}/csv/17451/2.csv','{DATA_DIR}/csv/17451/extra/3.csv'], files_to_sniff = -1) limit 1 +-- +ok +== +COPY (SELECT 1 WHERE false) TO '{TEST_DIR}/empty_glob_1.csv' (HEADER 0) +-- +ok +== +COPY (SELECT 1 WHERE false) TO '{TEST_DIR}/empty_glob_2.csv' (HEADER 0) +-- +ok +== +SELECT * FROM read_csv_auto(['{TEST_DIR}/empty_glob_1.csv', '{TEST_DIR}/empty_glob_2.csv']) +-- +ok +== diff --git a/parser/testdata/corpus/sql/copy/csv/test_greek_utf8.test b/parser/testdata/corpus/sql/copy/csv/test_greek_utf8.test new file mode 100644 index 0000000..2b5b922 --- /dev/null +++ b/parser/testdata/corpus/sql/copy/csv/test_greek_utf8.test @@ -0,0 +1,25 @@ +# source: test/sql/copy/csv/test_greek_utf8.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +CREATE TABLE greek_utf8 AS SELECT i, nfc_normalize(j) j, k FROM read_csv('{DATA_DIR}/csv/real/greek_utf8.csv', columns=STRUCT_PACK(i := 'INTEGER', j := 'VARCHAR', k := 'INTEGER'), delim='|') +-- +ok +== +COPY greek_utf8 TO '{TEMP_DIR}/greek_utf8.csv' DELIMITER ' ' HEADER; +-- +ok +== +DELETE FROM greek_utf8; +-- +ok +== +SELECT * FROM greek_utf8; +-- +ok +== +COPY greek_utf8 FROM '{TEMP_DIR}/greek_utf8.csv' DELIMITER ' ' HEADER; +-- +ok +== diff --git a/parser/testdata/corpus/sql/copy/csv/test_header_only.test b/parser/testdata/corpus/sql/copy/csv/test_header_only.test new file mode 100644 index 0000000..cf6d133 --- /dev/null +++ b/parser/testdata/corpus/sql/copy/csv/test_header_only.test @@ -0,0 +1,72 @@ +# source: test/sql/copy/csv/test_header_only.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +SELECT columns from sniff_csv('{DATA_DIR}/csv/header_only.csv', header=True, ignore_errors=True) +-- +ok +== +SELECT abs_file_name FROM read_csv('{DATA_DIR}/csv/header_only.csv', header=True, ignore_errors=True) +-- +ok +== +SELECT REGEXP_MATCHES(abs_file_name, 'foo') + FROM ( SELECT abs_file_name FROM read_csv('{DATA_DIR}/csv/header_only.csv', header=True, ignore_errors=True)) +-- +ok +== +SELECT REGEXP_MATCHES(abs_file_name, 'foo') + FROM ( SELECT abs_file_name FROM read_csv(['{DATA_DIR}/csv/header_only.csv','{DATA_DIR}/csv/header_only.csv'], header=True, ignore_errors=True)) +-- +ok +== +SELECT REGEXP_MATCHES(abs_file_name, 'foo') + FROM ( SELECT abs_file_name FROM read_csv(['{DATA_DIR}/csv/header_only.csv','{DATA_DIR}/csv/bool.csv','{DATA_DIR}/csv/header_only.csv'], header=True, ignore_errors=True)) +-- +ok +== +SELECT columns from sniff_csv('{DATA_DIR}/csv/header_only.csv', types = ['INTEGER']) +-- +ok +== +SELECT columns from sniff_csv('{DATA_DIR}/csv/header_only.csv', types = {'abs_file_name':'INTEGER'}) +-- +ok +== +CREATE TABLE T AS from read_csv('{DATA_DIR}/csv/header_only.csv',types = ['INTEGER']) +-- +ok +== +DESCRIBE T +-- +ok +== +CREATE OR REPLACE TABLE T AS from read_csv('{DATA_DIR}/csv/header_only.csv', types = {'abs_file_name':'INTEGER'}) +-- +ok +== +SELECT columns from sniff_csv('{DATA_DIR}/csv/header_only_2.csv', types = ['INTEGER']) +-- +ok +== +SELECT columns from sniff_csv('{DATA_DIR}/csv/header_only_2.csv', types = {'foo':'INTEGER'}) +-- +ok +== +SELECT columns from sniff_csv('{DATA_DIR}/csv/header_only_2.csv', types = {'bar':'INTEGER'}) +-- +ok +== +CREATE OR REPLACE TABLE T AS from read_csv('{DATA_DIR}/csv/header_only_2.csv', types = ['INTEGER']) +-- +ok +== +CREATE OR REPLACE TABLE T AS from read_csv('{DATA_DIR}/csv/header_only_2.csv', types = {'foo':'INTEGER'}) +-- +ok +== +CREATE OR REPLACE TABLE T AS from read_csv('{DATA_DIR}/csv/header_only_2.csv', types = {'bar':'INTEGER'}) +-- +ok +== diff --git a/parser/testdata/corpus/sql/copy/csv/test_headers_12089.test b/parser/testdata/corpus/sql/copy/csv/test_headers_12089.test new file mode 100644 index 0000000..d39e2c7 --- /dev/null +++ b/parser/testdata/corpus/sql/copy/csv/test_headers_12089.test @@ -0,0 +1,13 @@ +# source: test/sql/copy/csv/test_headers_12089.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +select columns FROM sniff_csv('{DATA_DIR}/csv/headers/escaped_quote.csv'); +-- +ok +== +select columns FROM sniff_csv('{DATA_DIR}/csv/headers/unescaped_quote.csv'); +-- +ok +== diff --git a/parser/testdata/corpus/sql/copy/csv/test_hits_problematic.test b/parser/testdata/corpus/sql/copy/csv/test_hits_problematic.test new file mode 100644 index 0000000..bcc2702 --- /dev/null +++ b/parser/testdata/corpus/sql/copy/csv/test_hits_problematic.test @@ -0,0 +1,21 @@ +# source: test/sql/copy/csv/test_hits_problematic.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +FROM read_csv('{DATA_DIR}/csv/hits_problematic.csv', auto_detect=false, delim=',', quote='"', escape='\', new_line='\n', skip=0, comment='', header=false, columns={'column000': 'BIGINT', 'column001': 'BIGINT', 'column002': 'VARCHAR', 'column003': 'BIGINT', 'column004': 'TIMESTAMP', 'column005': 'DATE', 'column006': 'BIGINT', 'column007': 'BIGINT', 'column008': 'BIGINT', 'column009': 'BIGINT', 'column010': 'BIGINT', 'column011': 'BIGINT', 'column012': 'BIGINT', 'column013': 'VARCHAR', 'column014': 'VARCHAR', 'column015': 'BIGINT', 'column016': 'BIGINT', 'column017': 'BIGINT', 'column018': 'BIGINT', 'column019': 'BIGINT', 'column020': 'BIGINT', 'column021': 'BIGINT', 'column022': 'BIGINT', 'column023': 'BIGINT', 'column024': 'BIGINT', 'column025': 'DOUBLE', 'column026': 'BIGINT', 'column027': 'BIGINT', 'column028': 'BIGINT', 'column029': 'VARCHAR', 'column030': 'BIGINT', 'column031': 'BIGINT', 'column032': 'BIGINT', 'column033': 'BIGINT', 'column034': 'VARCHAR', 'column035': 'VARCHAR', 'column036': 'BIGINT', 'column037': 'BIGINT', 'column038': 'BIGINT', 'column039': 'VARCHAR', 'column040': 'BIGINT', 'column041': 'BIGINT', 'column042': 'BIGINT', 'column043': 'BIGINT', 'column044': 'BIGINT', 'column045': 'TIMESTAMP', 'column046': 'BIGINT', 'column047': 'BIGINT', 'column048': 'BIGINT', 'column049': 'BIGINT', 'column050': 'VARCHAR', 'column051': 'BIGINT', 'column052': 'BIGINT', 'column053': 'BIGINT', 'column054': 'BIGINT', 'column055': 'BIGINT', 'column056': 'VARCHAR', 'column057': 'BIGINT', 'column058': 'BIGINT', 'column059': 'BIGINT', 'column060': 'BIGINT', 'column061': 'BIGINT', 'column062': 'BIGINT', 'column063': 'VARCHAR', 'column064': 'TIMESTAMP', 'column065': 'BIGINT', 'column066': 'BIGINT', 'column067': 'BIGINT', 'column068': 'BIGINT', 'column069': 'BIGINT', 'column070': 'BIGINT', 'column071': 'BIGINT', 'column072': 'BIGINT', 'column073': 'BIGINT', 'column074': 'VARCHAR', 'column075': 'VARCHAR', 'column076': 'VARCHAR', 'column077': 'VARCHAR', 'column078': 'BIGINT', 'column079': 'BIGINT', 'column080': 'BIGINT', 'column081': 'BIGINT', 'column082': 'BIGINT', 'column083': 'BIGINT', 'column084': 'BIGINT', 'column085': 'BIGINT', 'column086': 'VARCHAR', 'column087': 'BIGINT', 'column088': 'VARCHAR', 'column089': 'VARCHAR', 'column090': 'BIGINT', 'column091': 'VARCHAR', 'column092': 'VARCHAR', 'column093': 'VARCHAR', 'column094': 'VARCHAR', 'column095': 'VARCHAR', 'column096': 'VARCHAR', 'column097': 'VARCHAR', 'column098': 'VARCHAR', 'column099': 'VARCHAR', 'column100': 'VARCHAR', 'column101': 'BIGINT', 'column102': 'BIGINT', 'column103': 'BIGINT', 'column104': 'BIGINT'}, dateformat='%Y-%m-%d'); +-- +ok +== +FROM read_csv('{DATA_DIR}/csv/hits_problematic.csv', auto_detect=false, delim=',', quote='"', escape='\', new_line='\n', skip=0, comment='', header=false, columns={'column000': 'BIGINT', 'column001': 'BIGINT', 'column002': 'VARCHAR', 'column003': 'BIGINT', 'column004': 'TIMESTAMP', 'column005': 'DATE', 'column006': 'BIGINT', 'column007': 'BIGINT', 'column008': 'BIGINT', 'column009': 'BIGINT', 'column010': 'BIGINT', 'column011': 'BIGINT', 'column012': 'BIGINT', 'column013': 'VARCHAR', 'column014': 'VARCHAR', 'column015': 'BIGINT', 'column016': 'BIGINT', 'column017': 'BIGINT', 'column018': 'BIGINT', 'column019': 'BIGINT', 'column020': 'BIGINT', 'column021': 'BIGINT', 'column022': 'BIGINT', 'column023': 'BIGINT', 'column024': 'BIGINT', 'column025': 'DOUBLE', 'column026': 'BIGINT', 'column027': 'BIGINT', 'column028': 'BIGINT', 'column029': 'VARCHAR', 'column030': 'BIGINT', 'column031': 'BIGINT', 'column032': 'BIGINT', 'column033': 'BIGINT', 'column034': 'VARCHAR', 'column035': 'VARCHAR', 'column036': 'BIGINT', 'column037': 'BIGINT', 'column038': 'BIGINT', 'column039': 'VARCHAR', 'column040': 'BIGINT', 'column041': 'BIGINT', 'column042': 'BIGINT', 'column043': 'BIGINT', 'column044': 'BIGINT', 'column045': 'TIMESTAMP', 'column046': 'BIGINT', 'column047': 'BIGINT', 'column048': 'BIGINT', 'column049': 'BIGINT', 'column050': 'VARCHAR', 'column051': 'BIGINT', 'column052': 'BIGINT', 'column053': 'BIGINT', 'column054': 'BIGINT', 'column055': 'BIGINT', 'column056': 'VARCHAR', 'column057': 'BIGINT', 'column058': 'BIGINT', 'column059': 'BIGINT', 'column060': 'BIGINT', 'column061': 'BIGINT', 'column062': 'BIGINT', 'column063': 'VARCHAR', 'column064': 'TIMESTAMP', 'column065': 'BIGINT', 'column066': 'BIGINT', 'column067': 'BIGINT', 'column068': 'BIGINT', 'column069': 'BIGINT', 'column070': 'BIGINT', 'column071': 'BIGINT', 'column072': 'BIGINT', 'column073': 'BIGINT', 'column074': 'VARCHAR', 'column075': 'VARCHAR', 'column076': 'VARCHAR', 'column077': 'VARCHAR', 'column078': 'BIGINT', 'column079': 'BIGINT', 'column080': 'BIGINT', 'column081': 'BIGINT', 'column082': 'BIGINT', 'column083': 'BIGINT', 'column084': 'BIGINT', 'column085': 'BIGINT', 'column086': 'VARCHAR', 'column087': 'BIGINT', 'column088': 'VARCHAR', 'column089': 'VARCHAR', 'column090': 'BIGINT', 'column091': 'VARCHAR', 'column092': 'VARCHAR', 'column093': 'VARCHAR', 'column094': 'VARCHAR', 'column095': 'VARCHAR', 'column096': 'VARCHAR', 'column097': 'VARCHAR', 'column098': 'VARCHAR', 'column099': 'VARCHAR', 'column100': 'VARCHAR', 'column101': 'BIGINT', 'column102': 'BIGINT', 'column103': 'BIGINT', 'column104': 'BIGINT'}, dateformat='%Y-%m-%d', strict_mode = False); +-- +ok +== +FROM read_csv('{DATA_DIR}/csv/hits_problematic.csv', auto_detect=false, delim=',', quote='"', escape='', new_line='\n', skip=0, comment='', header=false, columns={'column000': 'BIGINT', 'column001': 'BIGINT', 'column002': 'VARCHAR', 'column003': 'BIGINT', 'column004': 'TIMESTAMP', 'column005': 'DATE', 'column006': 'BIGINT', 'column007': 'BIGINT', 'column008': 'BIGINT', 'column009': 'BIGINT', 'column010': 'BIGINT', 'column011': 'BIGINT', 'column012': 'BIGINT', 'column013': 'VARCHAR', 'column014': 'VARCHAR', 'column015': 'BIGINT', 'column016': 'BIGINT', 'column017': 'BIGINT', 'column018': 'BIGINT', 'column019': 'BIGINT', 'column020': 'BIGINT', 'column021': 'BIGINT', 'column022': 'BIGINT', 'column023': 'BIGINT', 'column024': 'BIGINT', 'column025': 'DOUBLE', 'column026': 'BIGINT', 'column027': 'BIGINT', 'column028': 'BIGINT', 'column029': 'VARCHAR', 'column030': 'BIGINT', 'column031': 'BIGINT', 'column032': 'BIGINT', 'column033': 'BIGINT', 'column034': 'VARCHAR', 'column035': 'VARCHAR', 'column036': 'BIGINT', 'column037': 'BIGINT', 'column038': 'BIGINT', 'column039': 'VARCHAR', 'column040': 'BIGINT', 'column041': 'BIGINT', 'column042': 'BIGINT', 'column043': 'BIGINT', 'column044': 'BIGINT', 'column045': 'TIMESTAMP', 'column046': 'BIGINT', 'column047': 'BIGINT', 'column048': 'BIGINT', 'column049': 'BIGINT', 'column050': 'VARCHAR', 'column051': 'BIGINT', 'column052': 'BIGINT', 'column053': 'BIGINT', 'column054': 'BIGINT', 'column055': 'BIGINT', 'column056': 'VARCHAR', 'column057': 'BIGINT', 'column058': 'BIGINT', 'column059': 'BIGINT', 'column060': 'BIGINT', 'column061': 'BIGINT', 'column062': 'BIGINT', 'column063': 'VARCHAR', 'column064': 'TIMESTAMP', 'column065': 'BIGINT', 'column066': 'BIGINT', 'column067': 'BIGINT', 'column068': 'BIGINT', 'column069': 'BIGINT', 'column070': 'BIGINT', 'column071': 'BIGINT', 'column072': 'BIGINT', 'column073': 'BIGINT', 'column074': 'VARCHAR', 'column075': 'VARCHAR', 'column076': 'VARCHAR', 'column077': 'VARCHAR', 'column078': 'BIGINT', 'column079': 'BIGINT', 'column080': 'BIGINT', 'column081': 'BIGINT', 'column082': 'BIGINT', 'column083': 'BIGINT', 'column084': 'BIGINT', 'column085': 'BIGINT', 'column086': 'VARCHAR', 'column087': 'BIGINT', 'column088': 'VARCHAR', 'column089': 'VARCHAR', 'column090': 'BIGINT', 'column091': 'VARCHAR', 'column092': 'VARCHAR', 'column093': 'VARCHAR', 'column094': 'VARCHAR', 'column095': 'VARCHAR', 'column096': 'VARCHAR', 'column097': 'VARCHAR', 'column098': 'VARCHAR', 'column099': 'VARCHAR', 'column100': 'VARCHAR', 'column101': 'BIGINT', 'column102': 'BIGINT', 'column103': 'BIGINT', 'column104': 'BIGINT'}, dateformat='%Y-%m-%d'); +-- +ok +== +FROM read_csv('{DATA_DIR}/csv/hits_problematic.csv', auto_detect=false, delim=',', quote='"', escape='', new_line='\n', skip=0, comment='', header=false, columns={'column000': 'BIGINT', 'column001': 'BIGINT', 'column002': 'VARCHAR', 'column003': 'BIGINT', 'column004': 'TIMESTAMP', 'column005': 'DATE', 'column006': 'BIGINT', 'column007': 'BIGINT', 'column008': 'BIGINT', 'column009': 'BIGINT', 'column010': 'BIGINT', 'column011': 'BIGINT', 'column012': 'BIGINT', 'column013': 'VARCHAR', 'column014': 'VARCHAR', 'column015': 'BIGINT', 'column016': 'BIGINT', 'column017': 'BIGINT', 'column018': 'BIGINT', 'column019': 'BIGINT', 'column020': 'BIGINT', 'column021': 'BIGINT', 'column022': 'BIGINT', 'column023': 'BIGINT', 'column024': 'BIGINT', 'column025': 'DOUBLE', 'column026': 'BIGINT', 'column027': 'BIGINT', 'column028': 'BIGINT', 'column029': 'VARCHAR', 'column030': 'BIGINT', 'column031': 'BIGINT', 'column032': 'BIGINT', 'column033': 'BIGINT', 'column034': 'VARCHAR', 'column035': 'VARCHAR', 'column036': 'BIGINT', 'column037': 'BIGINT', 'column038': 'BIGINT', 'column039': 'VARCHAR', 'column040': 'BIGINT', 'column041': 'BIGINT', 'column042': 'BIGINT', 'column043': 'BIGINT', 'column044': 'BIGINT', 'column045': 'TIMESTAMP', 'column046': 'BIGINT', 'column047': 'BIGINT', 'column048': 'BIGINT', 'column049': 'BIGINT', 'column050': 'VARCHAR', 'column051': 'BIGINT', 'column052': 'BIGINT', 'column053': 'BIGINT', 'column054': 'BIGINT', 'column055': 'BIGINT', 'column056': 'VARCHAR', 'column057': 'BIGINT', 'column058': 'BIGINT', 'column059': 'BIGINT', 'column060': 'BIGINT', 'column061': 'BIGINT', 'column062': 'BIGINT', 'column063': 'VARCHAR', 'column064': 'TIMESTAMP', 'column065': 'BIGINT', 'column066': 'BIGINT', 'column067': 'BIGINT', 'column068': 'BIGINT', 'column069': 'BIGINT', 'column070': 'BIGINT', 'column071': 'BIGINT', 'column072': 'BIGINT', 'column073': 'BIGINT', 'column074': 'VARCHAR', 'column075': 'VARCHAR', 'column076': 'VARCHAR', 'column077': 'VARCHAR', 'column078': 'BIGINT', 'column079': 'BIGINT', 'column080': 'BIGINT', 'column081': 'BIGINT', 'column082': 'BIGINT', 'column083': 'BIGINT', 'column084': 'BIGINT', 'column085': 'BIGINT', 'column086': 'VARCHAR', 'column087': 'BIGINT', 'column088': 'VARCHAR', 'column089': 'VARCHAR', 'column090': 'BIGINT', 'column091': 'VARCHAR', 'column092': 'VARCHAR', 'column093': 'VARCHAR', 'column094': 'VARCHAR', 'column095': 'VARCHAR', 'column096': 'VARCHAR', 'column097': 'VARCHAR', 'column098': 'VARCHAR', 'column099': 'VARCHAR', 'column100': 'VARCHAR', 'column101': 'BIGINT', 'column102': 'BIGINT', 'column103': 'BIGINT', 'column104': 'BIGINT'}, dateformat='%Y-%m-%d', strict_mode = False); +-- +ok +== diff --git a/parser/testdata/corpus/sql/copy/csv/test_ignore_errors.test b/parser/testdata/corpus/sql/copy/csv/test_ignore_errors.test new file mode 100644 index 0000000..685816e --- /dev/null +++ b/parser/testdata/corpus/sql/copy/csv/test_ignore_errors.test @@ -0,0 +1,85 @@ +# source: test/sql/copy/csv/test_ignore_errors.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +COPY integers FROM '{DATA_DIR}/csv/test/error_too_little.csv' (HEADER, IGNORE_ERRORS, NULL_PADDING FALSE) +-- +ok +== +COPY integers FROM '{DATA_DIR}/csv/test/error_too_little.csv' (HEADER, NULL_PADDING FALSE) +-- +ok +== +SELECT * FROM integers AS too_little_columns +-- +ok +== +DELETE FROM integers; +-- +ok +== +INSERT INTO integers SELECT * FROM read_csv('{DATA_DIR}/csv/test/error_too_little.csv', columns={'i': 'INTEGER', 'j': 'INTEGER'}, ignore_errors=1, null_padding=0) +-- +ok +== +INSERT INTO integers SELECT * FROM read_csv('{DATA_DIR}/csv/test/error_too_little.csv', columns={'i': 'INTEGER'}, null_padding=0) +-- +ok +== +COPY integers FROM '{DATA_DIR}/csv/test/error_too_little_single.csv' (HEADER, IGNORE_ERRORS, NULL_PADDING 0) +-- +ok +== +COPY integers FROM '{DATA_DIR}/csv/test/error_too_little_single.csv' (HEADER, NULL_PADDING 0) +-- +ok +== +COPY integers FROM '{DATA_DIR}/csv/test/error_too_many.csv' (HEADER, IGNORE_ERRORS, SAMPLE_SIZE -1, strict_mode TRUE) +-- +ok +== +COPY integers FROM '{DATA_DIR}/csv/test/error_too_many.csv' (HEADER) +-- +ok +== +SELECT * FROM integers AS too_many_columns +-- +ok +== +COPY integers FROM '{DATA_DIR}/csv/test/error_invalid_type.csv' (HEADER, IGNORE_ERRORS) +-- +ok +== +COPY integers FROM '{DATA_DIR}/csv/test/error_invalid_type.csv' (HEADER) +-- +ok +== +CREATE TABLE nullable_type (col_a INTEGER, col_b VARCHAR(10), col_c VARCHAR(10), col_d VARCHAR(10)); +-- +ok +== +COPY nullable_type FROM '{DATA_DIR}/csv/test/test_incompatible_type_with_nullable.csv' +-- +ok +== +SELECT * FROM nullable_type +-- +ok +== +FROM read_csv('{DATA_DIR}/csv/titanic.csv', ignore_errors=1) limit 10 +-- +ok +== +SELECT * FROM read_csv('{DATA_DIR}/csv/test_ignore_errors.csv', columns = {'Order ref ID': 'VARCHAR'}, delim = ',', ignore_errors=true); +-- +ok +== +SELECT * FROM read_csv('{DATA_DIR}/csv/test_ignore_errors.csv', types = {'Order ref ID': 'VARCHAR'}, ignore_errors=true); +-- +ok +== +FROM read_csv('{DATA_DIR}/csv/rejects_sniffer.csv',ignore_errors = true) +-- +ok +== diff --git a/parser/testdata/corpus/sql/copy/csv/test_ignore_errors_end_of_chunk.test b/parser/testdata/corpus/sql/copy/csv/test_ignore_errors_end_of_chunk.test new file mode 100644 index 0000000..9f4dc3e --- /dev/null +++ b/parser/testdata/corpus/sql/copy/csv/test_ignore_errors_end_of_chunk.test @@ -0,0 +1,29 @@ +# source: test/sql/copy/csv/test_ignore_errors_end_of_chunk.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +COPY integers FROM '{DATA_DIR}/csv/test/error_too_little_end_of_filled_chunk.csv' (HEADER, IGNORE_ERRORS, NULL_PADDING 0, AUTO_DETECT 0) +-- +ok +== +COPY integers FROM '{DATA_DIR}/csv/test/error_too_little_end_of_filled_chunk.csv' (HEADER, NULL_PADDING 0, AUTO_DETECT 0) +-- +ok +== +SELECT * FROM integers limit 1 +-- +ok +== +select count(*) from integers; +-- +ok +== +COPY integers FROM '{DATA_DIR}/csv/test/error_too_little_end_of_filled_chunk.csv' (HEADER, IGNORE_ERRORS, NULL_PADDING 0) +-- +ok +== +COPY integers FROM '{DATA_DIR}/csv/test/error_too_little_end_of_filled_chunk.csv' (HEADER, NULL_PADDING 0) +-- +ok +== diff --git a/parser/testdata/corpus/sql/copy/csv/test_ignore_mid_null_line.test b/parser/testdata/corpus/sql/copy/csv/test_ignore_mid_null_line.test new file mode 100644 index 0000000..337a524 --- /dev/null +++ b/parser/testdata/corpus/sql/copy/csv/test_ignore_mid_null_line.test @@ -0,0 +1,10 @@ +# source: test/sql/copy/csv/test_ignore_mid_null_line.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +FROM read_csv('{DATA_DIR}/csv/error/mid_null.csv', delim = ';', + columns = {'a':'integer','b':'integer','c':'integer'}, auto_detect = false, header = true, ignore_errors = true, strict_mode=True) +-- +ok +== diff --git a/parser/testdata/corpus/sql/copy/csv/test_imdb.test b/parser/testdata/corpus/sql/copy/csv/test_imdb.test new file mode 100644 index 0000000..c826eb0 --- /dev/null +++ b/parser/testdata/corpus/sql/copy/csv/test_imdb.test @@ -0,0 +1,17 @@ +# source: test/sql/copy/csv/test_imdb.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +CREATE TABLE movie_info (id integer NOT NULL PRIMARY KEY, movie_id integer NOT NULL, info_type_id integer NOT NULL, info text NOT NULL, note text); +-- +ok +== +COPY movie_info FROM '{DATA_DIR}/csv/real/imdb_movie_info_escaped.csv' DELIMITER ',' ESCAPE '\'; +-- +ok +== +SELECT * FROM movie_info; +-- +ok +== diff --git a/parser/testdata/corpus/sql/copy/csv/test_infinite_loop_escape.test b/parser/testdata/corpus/sql/copy/csv/test_infinite_loop_escape.test new file mode 100644 index 0000000..721fabb --- /dev/null +++ b/parser/testdata/corpus/sql/copy/csv/test_infinite_loop_escape.test @@ -0,0 +1,17 @@ +# source: test/sql/copy/csv/test_infinite_loop_escape.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +CREATE TABLE trigger_loop (a VARCHAR); +-- +ok +== +INSERT INTO trigger_loop VALUES ('"'); +-- +ok +== +COPY trigger_loop TO '{TEST_DIR}/infinite_loop_fix.csv' (FORMAT CSV, QUOTE '"', ESCAPE ''); +-- +ok +== diff --git a/parser/testdata/corpus/sql/copy/csv/test_insert_into_types.test b/parser/testdata/corpus/sql/copy/csv/test_insert_into_types.test new file mode 100644 index 0000000..7d3bbfc --- /dev/null +++ b/parser/testdata/corpus/sql/copy/csv/test_insert_into_types.test @@ -0,0 +1,195 @@ +# source: test/sql/copy/csv/test_insert_into_types.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +CREATE TABLE users ( + id INTEGER NOT NULL, /*primary key*/ + name VARCHAR(10) NOT NULL, + email VARCHAR +); +-- +ok +== +INSERT INTO users +SELECT * +FROM read_csv('{DATA_DIR}/csv/glob/f_*.csv', ignore_errors=true, null_padding=true); +-- +ok +== +select * from users order by all; +-- +ok +== +DROP TABLE users; +-- +ok +== +INSERT INTO users +SELECT * +FROM read_csv('{DATA_DIR}/csv/file_error.csv', ignore_errors=true, null_padding=true); +-- +ok +== +select * from users; +-- +ok +== +CREATE TABLE proj ( + id INTEGER NOT NULL, /*primary key*/ +); +-- +ok +== +INSERT INTO proj +SELECT id +FROM read_csv('{DATA_DIR}/csv/file_error.csv', ignore_errors=true, null_padding=true); +-- +ok +== +select * from proj; +-- +ok +== +INSERT INTO proj +SELECT id +FROM read_csv('{DATA_DIR}/csv/file_error.csv'); +-- +ok +== +DROP table proj; +-- +ok +== +CREATE TABLE proj ( + name VARCHAR(10) NOT NULL, + id INTEGER NOT NULL, /*primary key*/ +); +-- +ok +== +INSERT INTO proj +SELECT name, id +FROM read_csv('{DATA_DIR}/csv/file_error.csv', ignore_errors=true, null_padding=true); +-- +ok +== +INSERT INTO proj +SELECT name, id +FROM read_csv('{DATA_DIR}/csv/file_error.csv'); +-- +ok +== +CREATE TABLE proj ( + email VARCHAR, + id INTEGER NOT NULL, /*primary key*/ +); +-- +ok +== +INSERT INTO proj +SELECT email, id +FROM read_csv('{DATA_DIR}/csv/file_error.csv', ignore_errors=true, null_padding=true); +-- +ok +== +CREATE TABLE proj ( + email VARCHAR, + id VARCHAR NOT NULL, /*primary key*/ +); +-- +ok +== +INSERT INTO proj +SELECT name, id::INTEGER +FROM read_csv('{DATA_DIR}/csv/file_error.csv'); +-- +ok +== +CREATE TABLE proj ( + email VARCHAR, + id integer NOT NULL, /*primary key*/ +); +-- +ok +== +INSERT INTO proj +SELECT 'Pedro', id +FROM read_csv('{DATA_DIR}/csv/file_error.csv'); +-- +ok +== +CREATE TABLE ppl ( + name VARCHAR +); +-- +ok +== +insert into ppl values ('alice'), ('bob'), ('pedro') +-- +ok +== +INSERT INTO proj +SELECT ppl.name,id +FROM read_csv('{DATA_DIR}/csv/file_error.csv') T inner join ppl on (ppl.name = T.name); +-- +ok +== +INSERT INTO proj +SELECT T.name,id +FROM read_csv('{DATA_DIR}/csv/file_error.csv') T inner join ppl on (ppl.name = T.name); +-- +ok +== +DROP table users; +-- +ok +== +CREATE TABLE proj ( + email VARCHAR, + id integer NOT NULL +); +-- +ok +== +INSERT INTO proj +SELECT email, id +FROM read_csv('{DATA_DIR}/csv/glob/f_*.csv', ignore_errors=true, null_padding=true); +-- +ok +== +select * from proj order by all; +-- +ok +== +CREATE TABLE users_age ( + id INTEGER NOT NULL, + name VARCHAR(10) NOT NULL, + email VARCHAR, + age integer +); +-- +ok +== +INSERT INTO users_age +SELECT * +FROM read_csv('{DATA_DIR}/csv/union-by-name/type_mismatch/f_*.csv', ignore_errors=true, null_padding=true, union_by_name=true); +-- +ok +== +select * from users_age; +-- +ok +== +create table timestamps(ts timestamp, dt date); +-- +ok +== +insert into timestamps select ts,ts from read_csv('{DATA_DIR}/csv/timestamp.csv'); +-- +ok +== +from timestamps; +-- +ok +== diff --git a/parser/testdata/corpus/sql/copy/csv/test_issue3562_assertion.test b/parser/testdata/corpus/sql/copy/csv/test_issue3562_assertion.test new file mode 100644 index 0000000..b96b619 --- /dev/null +++ b/parser/testdata/corpus/sql/copy/csv/test_issue3562_assertion.test @@ -0,0 +1,13 @@ +# source: test/sql/copy/csv/test_issue3562_assertion.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +create table test as SELECT * FROM read_csv('{DATA_DIR}/csv/test/issue3562_assertion.csv.gz', columns={'OBJECTID': 'DECIMAL(18,3)', 'URL': 'TEXT', 'NAME': 'TEXT', 'the_geom':'TEXT', 'LINE': 'TEXT'}); +-- +ok +== +select objectid, name from test ORDER BY objectid limit 10 +-- +ok +== diff --git a/parser/testdata/corpus/sql/copy/csv/test_issue5077.test b/parser/testdata/corpus/sql/copy/csv/test_issue5077.test new file mode 100644 index 0000000..7441d55 --- /dev/null +++ b/parser/testdata/corpus/sql/copy/csv/test_issue5077.test @@ -0,0 +1,17 @@ +# source: test/sql/copy/csv/test_issue5077.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +select * from '{DATA_DIR}/csv/issue5077_aligned.csv' +-- +ok +== +select * from read_csv('{DATA_DIR}/csv/issue5077.csv', header=0) +-- +ok +== +select * from '{DATA_DIR}/csv/lineitem-carriage.csv'; +-- +ok +== diff --git a/parser/testdata/corpus/sql/copy/csv/test_lineitem.test b/parser/testdata/corpus/sql/copy/csv/test_lineitem.test new file mode 100644 index 0000000..e939754 --- /dev/null +++ b/parser/testdata/corpus/sql/copy/csv/test_lineitem.test @@ -0,0 +1,25 @@ +# source: test/sql/copy/csv/test_lineitem.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +COPY lineitem FROM '{DATA_DIR}/csv/real/lineitem_sample.csv' DELIMITER '|' +-- +ok +== +COPY lineitem TO '{TEMP_DIR}/lineitem.csv' (DELIMITER ' ', HEADER); +-- +ok +== +DELETE FROM lineitem; +-- +ok +== +SELECT * FROM lineitem; +-- +ok +== +COPY lineitem FROM '{TEMP_DIR}/lineitem.csv' DELIMITER ' ' HEADER; +-- +ok +== diff --git a/parser/testdata/corpus/sql/copy/csv/test_lineitem_gz.test b/parser/testdata/corpus/sql/copy/csv/test_lineitem_gz.test new file mode 100644 index 0000000..58d5f28 --- /dev/null +++ b/parser/testdata/corpus/sql/copy/csv/test_lineitem_gz.test @@ -0,0 +1,32 @@ +# source: test/sql/copy/csv/test_lineitem_gz.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +CALL dbgen(sf=10); +-- +ok +== +copy lineitem to '{TEST_DIR}/lineitem1.csv.gz' +-- +ok +== +set memory_limit='32gb'; +-- +ok +== +select count(*) from read_csv([ +'{TEST_DIR}/lineitem1.csv.gz','{TEST_DIR}/lineitem1.csv.gz','{TEST_DIR}/lineitem1.csv.gz','{TEST_DIR}/lineitem1.csv.gz','{TEST_DIR}/lineitem1.csv.gz', +'{TEST_DIR}/lineitem1.csv.gz','{TEST_DIR}/lineitem1.csv.gz','{TEST_DIR}/lineitem1.csv.gz','{TEST_DIR}/lineitem1.csv.gz','{TEST_DIR}/lineitem1.csv.gz', +'{TEST_DIR}/lineitem1.csv.gz','{TEST_DIR}/lineitem1.csv.gz','{TEST_DIR}/lineitem1.csv.gz','{TEST_DIR}/lineitem1.csv.gz','{TEST_DIR}/lineitem1.csv.gz', +'{TEST_DIR}/lineitem1.csv.gz','{TEST_DIR}/lineitem1.csv.gz','{TEST_DIR}/lineitem1.csv.gz','{TEST_DIR}/lineitem1.csv.gz','{TEST_DIR}/lineitem1.csv.gz', +'{TEST_DIR}/lineitem1.csv.gz','{TEST_DIR}/lineitem1.csv.gz','{TEST_DIR}/lineitem1.csv.gz','{TEST_DIR}/lineitem1.csv.gz','{TEST_DIR}/lineitem1.csv.gz', +'{TEST_DIR}/lineitem1.csv.gz','{TEST_DIR}/lineitem1.csv.gz','{TEST_DIR}/lineitem1.csv.gz','{TEST_DIR}/lineitem1.csv.gz','{TEST_DIR}/lineitem1.csv.gz', +'{TEST_DIR}/lineitem1.csv.gz','{TEST_DIR}/lineitem1.csv.gz','{TEST_DIR}/lineitem1.csv.gz','{TEST_DIR}/lineitem1.csv.gz','{TEST_DIR}/lineitem1.csv.gz', +'{TEST_DIR}/lineitem1.csv.gz','{TEST_DIR}/lineitem1.csv.gz','{TEST_DIR}/lineitem1.csv.gz','{TEST_DIR}/lineitem1.csv.gz','{TEST_DIR}/lineitem1.csv.gz', +'{TEST_DIR}/lineitem1.csv.gz','{TEST_DIR}/lineitem1.csv.gz','{TEST_DIR}/lineitem1.csv.gz','{TEST_DIR}/lineitem1.csv.gz','{TEST_DIR}/lineitem1.csv.gz', +'{TEST_DIR}/lineitem1.csv.gz','{TEST_DIR}/lineitem1.csv.gz','{TEST_DIR}/lineitem1.csv.gz','{TEST_DIR}/lineitem1.csv.gz','{TEST_DIR}/lineitem1.csv.gz' +]); +-- +ok +== diff --git a/parser/testdata/corpus/sql/copy/csv/test_linesize.test b/parser/testdata/corpus/sql/copy/csv/test_linesize.test new file mode 100644 index 0000000..d44934b --- /dev/null +++ b/parser/testdata/corpus/sql/copy/csv/test_linesize.test @@ -0,0 +1,9 @@ +# source: test/sql/copy/csv/test_linesize.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +FROM read_csv('{DATA_DIR}/csv/15473.csv', max_line_size = 10) +-- +ok +== diff --git a/parser/testdata/corpus/sql/copy/csv/test_long_line.test b/parser/testdata/corpus/sql/copy/csv/test_long_line.test new file mode 100644 index 0000000..9073b91 --- /dev/null +++ b/parser/testdata/corpus/sql/copy/csv/test_long_line.test @@ -0,0 +1,21 @@ +# source: test/sql/copy/csv/test_long_line.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +CREATE TABLE test (a INTEGER, b VARCHAR, c INTEGER); +-- +ok +== +COPY test FROM '{DATA_DIR}/csv/test/test_long_line.csv'; +-- +ok +== +SELECT LENGTH(b) FROM test ORDER BY a; +-- +ok +== +SELECT SUM(a), SUM(c) FROM test; +-- +ok +== diff --git a/parser/testdata/corpus/sql/copy/csv/test_many_columns.test b/parser/testdata/corpus/sql/copy/csv/test_many_columns.test new file mode 100644 index 0000000..b65e247 --- /dev/null +++ b/parser/testdata/corpus/sql/copy/csv/test_many_columns.test @@ -0,0 +1,13 @@ +# source: test/sql/copy/csv/test_many_columns.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +CREATE TABLE t AS SELECT * FROM read_csv_auto('{DATA_DIR}/csv/manycolumns.csv'); +-- +ok +== +SHOW t +-- +ok +== diff --git a/parser/testdata/corpus/sql/copy/csv/test_mismatch_schemas.test b/parser/testdata/corpus/sql/copy/csv/test_mismatch_schemas.test new file mode 100644 index 0000000..a513c26 --- /dev/null +++ b/parser/testdata/corpus/sql/copy/csv/test_mismatch_schemas.test @@ -0,0 +1,48 @@ +# source: test/sql/copy/csv/test_mismatch_schemas.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +SELECT * FROM read_csv(['{DATA_DIR}/csv/multiple_files/more_columns/file_1.csv','{DATA_DIR}/csv/multiple_files/more_columns/file_2.csv', +'{DATA_DIR}/csv/multiple_files/more_columns/file_3.csv','{DATA_DIR}/csv/multiple_files/more_columns/file_4.csv']) +ORDER BY ALL; +-- +ok +== +SELECT * FROM read_csv(['{DATA_DIR}/csv/multiple_files/more_columns/file_1.csv','{DATA_DIR}/csv/multiple_files/more_columns/file_2.csv', +'{DATA_DIR}/csv/multiple_files/more_columns/file_3.csv','{DATA_DIR}/csv/multiple_files/more_columns/file_no_header.csv']) +ORDER BY ALL; +-- +ok +== +SELECT * FROM read_csv(['{DATA_DIR}/csv/multiple_files/more_columns/file_1.csv','{DATA_DIR}/csv/multiple_files/more_columns/file_2.csv', +'{DATA_DIR}/csv/multiple_files/more_columns/file_3.csv','{DATA_DIR}/csv/multiple_files/more_columns/file_5.csv']) +ORDER BY ALL; +-- +ok +== +SELECT * FROM read_csv(['{DATA_DIR}/csv/multiple_files/more_columns/file_2.csv','{DATA_DIR}/csv/multiple_files/more_columns/file_1.csv', +'{DATA_DIR}/csv/multiple_files/more_columns/file_3.csv','{DATA_DIR}/csv/multiple_files/more_columns/file_4.csv']) +-- +ok +== +SELECT * FROM read_csv(['{DATA_DIR}/csv/multiple_files/different_order/file_1.csv','{DATA_DIR}/csv/multiple_files/different_order/file_2.csv']) +ORDER BY ALL; +-- +ok +== +SELECT * FROM read_csv(['{DATA_DIR}/csv/multiple_files/more_columns/file_1.csv','{DATA_DIR}/csv/multiple_files/more_columns/file_6.csv']) +ORDER BY ALL; +-- +ok +== +SELECT * FROM read_csv(['{DATA_DIR}/csv/multiple_files/more_columns/file_6.csv','{DATA_DIR}/csv/multiple_files/more_columns/file_1.csv']) +ORDER BY ALL; +-- +ok +== +SELECT * FROM read_csv(['{DATA_DIR}/csv/multiple_files/more_columns/file_6.csv','{DATA_DIR}/csv/multiple_files/more_columns/file_6.csv']) +ORDER BY ALL; +-- +ok +== diff --git a/parser/testdata/corpus/sql/copy/csv/test_missing_row.test b/parser/testdata/corpus/sql/copy/csv/test_missing_row.test new file mode 100644 index 0000000..2271e78 --- /dev/null +++ b/parser/testdata/corpus/sql/copy/csv/test_missing_row.test @@ -0,0 +1,9 @@ +# source: test/sql/copy/csv/test_missing_row.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +FROM read_csv('{DATA_DIR}/csv/customer.4.csv', auto_detect=false, delim='|', quote='"', escape='"', new_line='\n', skip=0, header=false, columns = {'c_custkey': 'BIGINT', 'c_name': 'VARCHAR', 'c_address': 'VARCHAR', 'c_nationkey': 'INTEGER', 'c_phone': 'VARCHAR', 'c_acctbal': 'DECIMAL(15, 2)', 'c_mktsegment': 'VARCHAR', 'c_comment': 'VARCHAR'}, parallel=true, buffer_size = 300); +-- +ok +== diff --git a/parser/testdata/corpus/sql/copy/csv/test_mixed_line_endings.test b/parser/testdata/corpus/sql/copy/csv/test_mixed_line_endings.test new file mode 100644 index 0000000..d6e7e7d --- /dev/null +++ b/parser/testdata/corpus/sql/copy/csv/test_mixed_line_endings.test @@ -0,0 +1,9 @@ +# source: test/sql/copy/csv/test_mixed_line_endings.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +insert into test select * from read_csv_auto('{DATA_DIR}/csv/test/mixed_line_endings.csv', strict_mode=false); +-- +ok +== diff --git a/parser/testdata/corpus/sql/copy/csv/test_mixed_new_line.test b/parser/testdata/corpus/sql/copy/csv/test_mixed_new_line.test new file mode 100644 index 0000000..f6327d2 --- /dev/null +++ b/parser/testdata/corpus/sql/copy/csv/test_mixed_new_line.test @@ -0,0 +1,61 @@ +# source: test/sql/copy/csv/test_mixed_new_line.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +from read_csv('{DATA_DIR}/csv/mixed_new_line.csv', strict_mode=false) +-- +ok +== +from read_csv('{DATA_DIR}/csv/mixed_new_line.csv', new_line = {newline}, strict_mode = false) +-- +error: Parser Error: syntax error at or near "}" +== +from read_csv('{DATA_DIR}/csv/mixed_new_line.csv', columns = {'a':'integer', 'b':'integer', 'c':'integer'}, new_line = '\r\n', header = false, strict_mode=true, delim = ',') +-- +ok +== +from read_csv('{DATA_DIR}/csv/mixed_new_line.csv', columns = {'a':'integer', 'b':'integer', 'c':'integer'}, new_line = '\r\n', header = false, strict_mode=true, delim = ',', auto_detect= false) +-- +ok +== +select count(*) from read_csv('{DATA_DIR}/csv/mixed_new_line_2.csv', new_line ='\r\n', strict_mode = False, columns = {'a':'varchar', 'b':'varchar'}, delim = ',', ignore_errors = true, header = false) +-- +ok +== +select count(*) from read_csv('{DATA_DIR}/csv/mixed_new_line_2.csv', new_line ='\r\n', strict_mode = False, columns = {'a':'varchar', 'b':'varchar'}, auto_detect = false, delim = ',') +-- +ok +== +SELECT column0 like '%one%' and column0 like '%two%' as success FROM read_csv('{DATA_DIR}/csv/one_r_two.csv',new_line ='\r\n', strict_mode = TRUE, HEADER = FALSE) +-- +ok +== +SELECT column0 like '%one%' and column0 like '%two%' as success FROM read_csv('{DATA_DIR}/csv/one_r_two.csv',new_line ='\n', strict_mode = TRUE, HEADER = FALSE) +-- +ok +== +SELECT column0 FROM read_csv('{DATA_DIR}/csv/one_r_two.csv',new_line ='\r', strict_mode = TRUE, HEADER = FALSE) +-- +ok +== +SELECT column0 like '%one%' and column0 like '%two%' as success FROM read_csv('{DATA_DIR}/csv/one_n_two.csv',new_line ='\r', strict_mode = TRUE, HEADER = FALSE) +-- +ok +== +SELECT column0 like '%one%' and column0 like '%two%' as success FROM read_csv('{DATA_DIR}/csv/one_n_two.csv',new_line ='\r\n', strict_mode = TRUE, HEADER = FALSE) +-- +ok +== +SELECT column0 FROM read_csv('{DATA_DIR}/csv/one_n_two.csv',new_line ='\n', strict_mode = TRUE, HEADER = FALSE) +-- +ok +== +SELECT column0 like '%one%' and column0 like '%two%' as success FROM read_csv('{DATA_DIR}/csv/one_r_n_two.csv',new_line ='\r', strict_mode = TRUE, HEADER = FALSE) +-- +ok +== +SELECT column0 like '%one%' and column0 like '%two%' as success FROM read_csv('{DATA_DIR}/csv/one_r_n_two.csv',new_line ='\n', strict_mode = TRUE, HEADER = FALSE) +-- +ok +== diff --git a/parser/testdata/corpus/sql/copy/csv/test_ncvoter.test b/parser/testdata/corpus/sql/copy/csv/test_ncvoter.test new file mode 100644 index 0000000..4ef7115 --- /dev/null +++ b/parser/testdata/corpus/sql/copy/csv/test_ncvoter.test @@ -0,0 +1,25 @@ +# source: test/sql/copy/csv/test_ncvoter.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +COPY ncvoters FROM '{DATA_DIR}/csv/real/ncvoter.csv' DELIMITER ' '; +-- +ok +== +COPY ncvoters TO '{TEMP_DIR}/ncvoter.csv' DELIMITER 'A' HEADER; +-- +ok +== +DELETE FROM ncvoters; +-- +ok +== +SELECT * FROM ncvoters; +-- +ok +== +COPY ncvoters FROM '{TEMP_DIR}/ncvoter.csv' DELIMITER 'A' HEADER; +-- +ok +== diff --git a/parser/testdata/corpus/sql/copy/csv/test_nfc.test b/parser/testdata/corpus/sql/copy/csv/test_nfc.test new file mode 100644 index 0000000..bedd69b --- /dev/null +++ b/parser/testdata/corpus/sql/copy/csv/test_nfc.test @@ -0,0 +1,17 @@ +# source: test/sql/copy/csv/test_nfc.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +CREATE TABLE nfcstrings (s STRING); +-- +ok +== +COPY nfcstrings FROM '{DATA_DIR}/csv/test/nfc.csv' (HEADER 0); +-- +ok +== +SELECT COUNT(*) FROM nfcstrings WHERE s COLLATE NFC = 'ü' +-- +ok +== diff --git a/parser/testdata/corpus/sql/copy/csv/test_nfc_suite.test b/parser/testdata/corpus/sql/copy/csv/test_nfc_suite.test new file mode 100644 index 0000000..2c9d4c5 --- /dev/null +++ b/parser/testdata/corpus/sql/copy/csv/test_nfc_suite.test @@ -0,0 +1,33 @@ +# source: test/sql/copy/csv/test_nfc_suite.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +CREATE TABLE nfcstrings (source STRING, nfc STRING, nfd STRING); +-- +ok +== +COPY nfcstrings FROM '{DATA_DIR}/csv/real/nfc_normalization.csv' (DELIMITER '|', HEADER 0); +-- +ok +== +SELECT COUNT(*) FROM nfcstrings +-- +ok +== +SELECT COUNT(*) FROM nfcstrings WHERE source COLLATE NFC=nfc +-- +ok +== +SELECT COUNT(*) FROM nfcstrings WHERE nfc COLLATE NFC=nfd +-- +ok +== +DROP TABLE nfcstrings +-- +ok +== +COPY nfcstrings FROM '{DATA_DIR}/csv/real/nfc_normalization_rn.csv' (DELIMITER '|', HEADER 0); +-- +ok +== diff --git a/parser/testdata/corpus/sql/copy/csv/test_non_unicode_header.test b/parser/testdata/corpus/sql/copy/csv/test_non_unicode_header.test new file mode 100644 index 0000000..82444a5 --- /dev/null +++ b/parser/testdata/corpus/sql/copy/csv/test_non_unicode_header.test @@ -0,0 +1,17 @@ +# source: test/sql/copy/csv/test_non_unicode_header.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +drop table if exists reject_errors; +-- +ok +== +FROM read_csv('{DATA_DIR}/csv/error/banklist.csv', store_rejects=true) order by all limit 5 +-- +ok +== +select * exclude(scan_id ) from reject_errors order by all limit 5 +-- +ok +== diff --git a/parser/testdata/corpus/sql/copy/csv/test_null_padding_projection.test b/parser/testdata/corpus/sql/copy/csv/test_null_padding_projection.test new file mode 100644 index 0000000..b361b94 --- /dev/null +++ b/parser/testdata/corpus/sql/copy/csv/test_null_padding_projection.test @@ -0,0 +1,100 @@ +# source: test/sql/copy/csv/test_null_padding_projection.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +from read_csv('{DATA_DIR}/csv/nullpadding.csv',null_padding=true, columns={ +'a': 'INTEGER','b': 'INTEGER','c': 'INTEGER','d': 'INTEGER'}, auto_detect = false, strict_mode=True) +-- +ok +== +CREATE VIEW np AS from read_csv('{DATA_DIR}/csv/nullpadding.csv',null_padding=true, columns={ +'a': 'INTEGER','b': 'INTEGER','c': 'INTEGER','d': 'INTEGER'}, auto_detect = false, ignore_errors = true, strict_mode=True); +-- +ok +== +from np +-- +ok +== +select a from np +-- +ok +== +select b,d from np +-- +ok +== +from read_csv('{DATA_DIR}/csv/nullpadding.csv',null_padding=true, columns={ +'a': 'INTEGER','b': 'INTEGER','c': 'INTEGER','d': 'INTEGER'}, auto_detect => false, ignore_errors => true, filename => true, strict_mode=True); +-- +ok +== +select a, filename from read_csv('{DATA_DIR}/csv/nullpadding.csv',null_padding=true, columns={ +'a': 'INTEGER','b': 'INTEGER','c': 'INTEGER','d': 'INTEGER'}, auto_detect => false, ignore_errors => true, filename => true, strict_mode=True); +-- +ok +== +select filename from read_csv('{DATA_DIR}/csv/nullpadding.csv',null_padding=true, columns={ +'a': 'INTEGER','b': 'INTEGER','c': 'INTEGER','d': 'INTEGER'}, auto_detect => false, ignore_errors => true, filename => true, strict_mode=True); +-- +ok +== +select a from read_csv('{DATA_DIR}/csv/nullpadding.csv',null_padding=true, columns={ +'a': 'INTEGER','b': 'INTEGER','c': 'INTEGER','d': 'INTEGER'}, auto_detect = false, ignore_errors => true, filename => true, strict_mode=True); +-- +ok +== +select * from read_csv('{DATA_DIR}/csv/nullpadding.csv',null_padding=true, columns={ +'a': 'INTEGER','b': 'INTEGER','c': 'INTEGER','d': 'INTEGER'}, auto_detect := false, ignore_errors := true, strict_mode=True) +where b = 100; +-- +ok +== +select * from read_csv('{DATA_DIR}/csv/nullpadding.csv',null_padding=true, columns={ +'a': 'INTEGER','b': 'INTEGER','c': 'INTEGER','d': 'INTEGER'}, auto_detect = false, ignore_errors = true, filename = true, strict_mode=True) +where a = 10 and d = 10000; +-- +ok +== +select * from read_csv('{DATA_DIR}/csv/nullpadding.csv',null_padding=true, columns={ +'a': 'INTEGER','b': 'INTEGER','c': 'INTEGER','d': 'INTEGER', 'e': 'INTEGER'}, auto_detect = false, filename = true) +where a = 10 and d = 10000; +-- +ok +== +select * from read_csv('{DATA_DIR}/csv/nullpadding.csv',null_padding=true, columns={ +'a': 'INTEGER','b': 'INTEGER','c': 'INTEGER','d': 'INTEGER', 'e': 'INTEGER'}, auto_detect := false) +-- +ok +== +select * from read_csv('{DATA_DIR}/csv/nullpadding.csv',null_padding=true, columns={ +'a': 'INTEGER','b': 'INTEGER','c': 'INTEGER','d': 'INTEGER', 'e': 'INTEGER', 'f': 'INTEGER'}, auto_detect = false) +-- +ok +== +select * from read_csv('{DATA_DIR}/csv/nullpadding.csv',null_padding=true, columns={ +'a': 'INTEGER','b': 'INTEGER','c': 'INTEGER','d': 'INTEGER', 'e': 'INTEGER', 'f': 'INTEGER', 'g': 'INTEGER'}, auto_detect = false) +-- +ok +== +set threads =1 +-- +ok +== +create view T as +SELECT SETTLEMENTDATE, DUID, I, filename, UNIT, CAST(LOWER6SEC AS DOUBLE) AS LOWER6SEC, CAST(LOWER6SECFLAGS AS DOUBLE) AS LOWER6SECFLAGS, CAST(LOWER60SECFLAGS AS DOUBLE) AS LOWER60SECFLAGS, CAST(RAISE5MINACTUALAVAILABILITY AS DOUBLE) AS RAISE5MINACTUALAVAILABILITY, CAST(INTERVENTION AS DOUBLE) AS INTERVENTION, CAST(LOWER5MINFLAGS AS DOUBLE) AS LOWER5MINFLAGS, CAST(RAISEREGAVAILABILITY AS DOUBLE) AS RAISEREGAVAILABILITY, CAST(LOWERREGACTUALAVAILABILITY AS DOUBLE) AS LOWERREGACTUALAVAILABILITY, CAST(VIOLATION60SECDEGREE AS DOUBLE) AS VIOLATION60SECDEGREE, CAST(LOWER60SEC AS DOUBLE) AS LOWER60SEC, CAST(MARGINAL5MINVALUE AS DOUBLE) AS MARGINAL5MINVALUE, CAST(RAISE60SEC AS DOUBLE) AS RAISE60SEC, CAST(RAMPUPRATE AS DOUBLE) AS RAMPUPRATE, CAST(TOTALCLEARED AS DOUBLE) AS TOTALCLEARED, CAST(VIOLATION5MINDEGREE AS DOUBLE) AS VIOLATION5MINDEGREE, CAST(LOWER6SECACTUALAVAILABILITY AS DOUBLE) AS LOWER6SECACTUALAVAILABILITY, CAST(AGCSTATUS AS DOUBLE) AS AGCSTATUS, CAST(RAISE60SECFLAGS AS DOUBLE) AS RAISE60SECFLAGS, CAST("VERSION" AS DOUBLE) AS "VERSION", CAST(RAISE5MINFLAGS AS DOUBLE) AS RAISE5MINFLAGS, CAST(LOWER60SECACTUALAVAILABILITY AS DOUBLE) AS LOWER60SECACTUALAVAILABILITY, CAST(RAMPDOWNRATE AS DOUBLE) AS RAMPDOWNRATE, CAST(RAISE6SECFLAGS AS DOUBLE) AS RAISE6SECFLAGS, CAST(RAISE60SECACTUALAVAILABILITY AS DOUBLE) AS RAISE60SECACTUALAVAILABILITY, CAST(VIOLATIONDEGREE AS DOUBLE) AS VIOLATIONDEGREE, CAST(RAISE5MIN AS DOUBLE) AS RAISE5MIN, CAST(MARGINALVALUE AS DOUBLE) AS MARGINALVALUE, CAST(LOWERREGFLAGS AS DOUBLE) AS LOWERREGFLAGS, CAST(RAISEREG AS DOUBLE) AS RAISEREG, CAST(LOWERREGENABLEMENTMIN AS DOUBLE) AS LOWERREGENABLEMENTMIN, CAST(LOWERREGENABLEMENTMAX AS DOUBLE) AS LOWERREGENABLEMENTMAX, CAST(DISPATCHMODE AS DOUBLE) AS DISPATCHMODE, CAST(VIOLATION6SECDEGREE AS DOUBLE) AS VIOLATION6SECDEGREE, CAST(LOWERREG AS DOUBLE) AS LOWERREG, CAST(LOWERREGAVAILABILITY AS DOUBLE) AS LOWERREGAVAILABILITY, CAST(RAISEREGACTUALAVAILABILITY AS DOUBLE) AS RAISEREGACTUALAVAILABILITY, CAST(RAISEREGFLAGS AS DOUBLE) AS RAISEREGFLAGS, CAST(MARGINAL60SECVALUE AS DOUBLE) AS MARGINAL60SECVALUE, CAST(LOWER5MINACTUALAVAILABILITY AS DOUBLE) AS LOWER5MINACTUALAVAILABILITY, CAST(RAISEREGENABLEMENTMAX AS DOUBLE) AS RAISEREGENABLEMENTMAX, CAST(INITIALMW AS DOUBLE) AS INITIALMW, CAST(AVAILABILITY AS DOUBLE) AS AVAILABILITY, CAST(RUNNO AS DOUBLE) AS RUNNO, CAST(RAISE6SECACTUALAVAILABILITY AS DOUBLE) AS RAISE6SECACTUALAVAILABILITY, CAST(MARGINAL6SECVALUE AS DOUBLE) AS MARGINAL6SECVALUE, CAST(RAISE6SEC AS DOUBLE) AS RAISE6SEC, CAST(XX AS DOUBLE) AS XX, CAST(RAISEREGENABLEMENTMIN AS DOUBLE) AS RAISEREGENABLEMENTMIN, CAST(LOWER5MIN AS DOUBLE) AS LOWER5MIN FROM (SELECT * +FROM read_csv(main.list_value('{DATA_DIR}/csv/public_daily_sample.csv','{DATA_DIR}/csv/public_daily_sample.csv','{DATA_DIR}/csv/public_daily_sample.csv') +, ("Skip" = 1), ("header" = 0), (all_varchar = 1), ("columns" = main.struct_pack(I := 'VARCHAR', UNIT := 'VARCHAR', XX := 'VARCHAR', "VERSION" := 'VARCHAR', SETTLEMENTDATE := 'VARCHAR', RUNNO := 'VARCHAR', DUID := 'VARCHAR', INTERVENTION := 'VARCHAR', DISPATCHMODE := 'VARCHAR', AGCSTATUS := 'VARCHAR', INITIALMW := 'VARCHAR', TOTALCLEARED := 'VARCHAR', RAMPDOWNRATE := 'VARCHAR', RAMPUPRATE := 'VARCHAR', LOWER5MIN := 'VARCHAR', LOWER60SEC := 'VARCHAR', LOWER6SEC := 'VARCHAR', RAISE5MIN := 'VARCHAR', RAISE60SEC := 'VARCHAR', RAISE6SEC := 'VARCHAR', MARGINAL5MINVALUE := 'VARCHAR', MARGINAL60SECVALUE := 'VARCHAR', MARGINAL6SECVALUE := 'VARCHAR', MARGINALVALUE := 'VARCHAR', VIOLATION5MINDEGREE := 'VARCHAR', VIOLATION60SECDEGREE := 'VARCHAR', VIOLATION6SECDEGREE := 'VARCHAR', VIOLATIONDEGREE := 'VARCHAR', LOWERREG := 'VARCHAR', RAISEREG := 'VARCHAR', AVAILABILITY := 'VARCHAR', RAISE6SECFLAGS := 'VARCHAR', RAISE60SECFLAGS := 'VARCHAR', RAISE5MINFLAGS := 'VARCHAR', RAISEREGFLAGS := 'VARCHAR', LOWER6SECFLAGS := 'VARCHAR', LOWER60SECFLAGS := 'VARCHAR', LOWER5MINFLAGS := 'VARCHAR', LOWERREGFLAGS := 'VARCHAR', RAISEREGAVAILABILITY := 'VARCHAR', RAISEREGENABLEMENTMAX := 'VARCHAR', RAISEREGENABLEMENTMIN := 'VARCHAR', LOWERREGAVAILABILITY := 'VARCHAR', LOWERREGENABLEMENTMAX := 'VARCHAR', LOWERREGENABLEMENTMIN := 'VARCHAR', RAISE6SECACTUALAVAILABILITY := 'VARCHAR', RAISE60SECACTUALAVAILABILITY := 'VARCHAR', RAISE5MINACTUALAVAILABILITY := 'VARCHAR', RAISEREGACTUALAVAILABILITY := 'VARCHAR', LOWER6SECACTUALAVAILABILITY := 'VARCHAR', LOWER60SECACTUALAVAILABILITY := 'VARCHAR', LOWER5MINACTUALAVAILABILITY := 'VARCHAR', LOWERREGACTUALAVAILABILITY := 'VARCHAR')), (filename = 1), (null_padding = CAST('t' AS BOOLEAN)), (ignore_errors = 1), (auto_detect = CAST('f' AS BOOLEAN))) WHERE ((I = 'D') AND (UNIT = 'DUNIT'))); +-- +ok +== +create view T_2 as +SELECT * EXCLUDE (SETTLEMENTDATE, XX, filename, I), CAST(SETTLEMENTDATE AS TIMESTAMP) AS SETTLEMENTDATE, split(filename, '/')[8] AS file, isoyear(CAST(SETTLEMENTDATE AS TIMESTAMP)) AS "YEAR" FROM T +-- +ok +== +select count(*) from T_2 +-- +ok +== diff --git a/parser/testdata/corpus/sql/copy/csv/test_null_padding_union.test b/parser/testdata/corpus/sql/copy/csv/test_null_padding_union.test new file mode 100644 index 0000000..b2c1e80 --- /dev/null +++ b/parser/testdata/corpus/sql/copy/csv/test_null_padding_union.test @@ -0,0 +1,32 @@ +# source: test/sql/copy/csv/test_null_padding_union.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +create view v as +SELECT a, b, c, d +FROM read_csv('{DATA_DIR}/csv/union-by-name/null_padding/*.csv', UNION_BY_NAME=TRUE, sample_size = 1, null_padding = 1) +ORDER BY a,b,c,d +-- +ok +== +select * from v limit 10; +-- +ok +== +select count(*) from v where a is null +-- +ok +== +select count(*) from v where b is null +-- +ok +== +select count(*) from v where c is null +-- +ok +== +select count(*) from v where d is null +-- +ok +== diff --git a/parser/testdata/corpus/sql/copy/csv/test_ontime.test b/parser/testdata/corpus/sql/copy/csv/test_ontime.test new file mode 100644 index 0000000..390509d --- /dev/null +++ b/parser/testdata/corpus/sql/copy/csv/test_ontime.test @@ -0,0 +1,25 @@ +# source: test/sql/copy/csv/test_ontime.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +CREATE TABLE ontime(year SMALLINT, quarter SMALLINT, month SMALLINT, dayofmonth SMALLINT, dayofweek SMALLINT, flightdate DATE, uniquecarrier CHAR(7), airlineid DECIMAL(8,2), carrier CHAR(2), tailnum VARCHAR(50), flightnum VARCHAR(10), originairportid INTEGER, originairportseqid INTEGER, origincitymarketid INTEGER, origin CHAR(5), origincityname VARCHAR(100), originstate CHAR(2), originstatefips VARCHAR(10), originstatename VARCHAR(100), originwac DECIMAL(8,2), destairportid INTEGER, destairportseqid INTEGER, destcitymarketid INTEGER, dest CHAR(5), destcityname VARCHAR(100), deststate CHAR(2), deststatefips VARCHAR(10), deststatename VARCHAR(100), destwac DECIMAL(8,2), crsdeptime DECIMAL(8,2), deptime DECIMAL(8,2), depdelay DECIMAL(8,2), depdelayminutes DECIMAL(8,2), depdel15 DECIMAL(8,2), departuredelaygroups DECIMAL(8,2), deptimeblk VARCHAR(20), taxiout DECIMAL(8,2), wheelsoff DECIMAL(8,2), wheelson DECIMAL(8,2), taxiin DECIMAL(8,2), crsarrtime DECIMAL(8,2), arrtime DECIMAL(8,2), arrdelay DECIMAL(8,2), arrdelayminutes DECIMAL(8,2), arrdel15 DECIMAL(8,2), arrivaldelaygroups DECIMAL(8,2), arrtimeblk VARCHAR(20), cancelled SMALLINT, cancellationcode CHAR(1), diverted SMALLINT, crselapsedtime DECIMAL(8,2), actualelapsedtime DECIMAL(8,2), airtime DECIMAL(8,2), flights DECIMAL(8,2), distance DECIMAL(8,2), distancegroup SMALLINT, carrierdelay DECIMAL(8,2), weatherdelay DECIMAL(8,2), nasdelay DECIMAL(8,2), securitydelay DECIMAL(8,2), lateaircraftdelay DECIMAL(8,2), firstdeptime VARCHAR(10), totaladdgtime VARCHAR(10), longestaddgtime VARCHAR(10), divairportlandings VARCHAR(10), divreacheddest VARCHAR(10), divactualelapsedtime VARCHAR(10), divarrdelay VARCHAR(10), divdistance VARCHAR(10), div1airport VARCHAR(10), div1aiportid INTEGER, div1airportseqid INTEGER, div1wheelson VARCHAR(10), div1totalgtime VARCHAR(10), div1longestgtime VARCHAR(10), div1wheelsoff VARCHAR(10), div1tailnum VARCHAR(10), div2airport VARCHAR(10), div2airportid INTEGER, div2airportseqid INTEGER, div2wheelson VARCHAR(10), div2totalgtime VARCHAR(10), div2longestgtime VARCHAR(10), div2wheelsoff VARCHAR(10), div2tailnum VARCHAR(10), div3airport VARCHAR(10), div3airportid INTEGER, div3airportseqid INTEGER, div3wheelson VARCHAR(10), div3totalgtime VARCHAR(10), div3longestgtime VARCHAR(10), div3wheelsoff VARCHAR(10), div3tailnum VARCHAR(10), div4airport VARCHAR(10), div4airportid INTEGER, div4airportseqid INTEGER, div4wheelson VARCHAR(10), div4totalgtime VARCHAR(10), div4longestgtime VARCHAR(10), div4wheelsoff VARCHAR(10), div4tailnum VARCHAR(10), div5airport VARCHAR(10), div5airportid INTEGER, div5airportseqid INTEGER, div5wheelson VARCHAR(10), div5totalgtime VARCHAR(10), div5longestgtime VARCHAR(10), div5wheelsoff VARCHAR(10), div5tailnum VARCHAR(10)); +-- +ok +== +COPY ontime FROM '{DATA_DIR}/csv/real/ontime_sample.csv' DELIMITER ',' HEADER; +-- +ok +== +COPY ontime TO '{TEMP_DIR}/ontime.csv' DELIMITER ',' HEADER; +-- +ok +== +DELETE FROM ontime; +-- +ok +== +COPY ontime FROM '{TEMP_DIR}/ontime.csv' DELIMITER ',' HEADER; +-- +ok +== diff --git a/parser/testdata/corpus/sql/copy/csv/test_parallel_nullpadding.test b/parser/testdata/corpus/sql/copy/csv/test_parallel_nullpadding.test new file mode 100644 index 0000000..3935efd --- /dev/null +++ b/parser/testdata/corpus/sql/copy/csv/test_parallel_nullpadding.test @@ -0,0 +1,29 @@ +# source: test/sql/copy/csv/test_parallel_nullpadding.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +select count(*) from read_csv('{DATA_DIR}/csv/evil_nullpadding.csv', delim = ';', quote = '"', null_padding = True, header = 0) +-- +ok +== +select count(*) from read_csv('{DATA_DIR}/csv/evil_nullpadding_2.csv', delim = ';', quote = '"', null_padding = True, header = 0) +-- +ok +== +select * from read_csv('{DATA_DIR}/csv/evil_nullpadding.csv', delim = ';', quote = '"', null_padding = True, header = 0, buffer_size = 30) +-- +ok +== +select count(*) from read_csv('{DATA_DIR}/csv/evil_nullpadding.csv', delim = ';', quote = '"', null_padding = True, header = 0, buffer_size = 27) +-- +ok +== +select count(*) from read_csv('{DATA_DIR}/csv/evil_nullpadding.csv', delim = ';', quote = '"', null_padding = True, header = 0, buffer_size = 30) +-- +ok +== +select * from read_csv('{DATA_DIR}/csv/evil_nullpadding_2.csv', delim = ';', quote = '"', null_padding = True, header = 0, buffer_size = 26) +-- +ok +== diff --git a/parser/testdata/corpus/sql/copy/csv/test_partition_compression.test b/parser/testdata/corpus/sql/copy/csv/test_partition_compression.test new file mode 100644 index 0000000..cf77aea --- /dev/null +++ b/parser/testdata/corpus/sql/copy/csv/test_partition_compression.test @@ -0,0 +1,41 @@ +# source: test/sql/copy/csv/test_partition_compression.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +CREATE TABLE test AS VALUES ('a', 'foo', 1), ('a', 'foo', 2), ('a', 'bar', 1), ('b', 'bar', 1); +-- +ok +== +COPY (FROM test) TO '{TEST_DIR}/data.csv.d' (FORMAT 'csv', COMPRESSION 'gzip', PARTITION_BY ('col0', 'col1')); +-- +ok +== +FROM read_csv_auto('{TEST_DIR}/data.csv.d/*/*/*.csv') +-- +ok +== +FROM read_csv_auto('{TEST_DIR}/data.csv.d/*/*/*.csv.gz') order by all; +-- +ok +== +FROM read_csv_auto('{TEST_DIR}/data.csv.d/*/*/*.csv.*') order by all; +-- +ok +== +COPY (FROM test) TO '{TEST_DIR}/data.csv.d2' (FORMAT 'csv', COMPRESSION 'zstd', PARTITION_BY ('col0', 'col1')); +-- +ok +== +FROM read_csv_auto('{TEST_DIR}/data.csv.d2/*/*/*.csv') +-- +ok +== +FROM read_csv_auto('{TEST_DIR}/data.csv.d2/*/*/*.csv.zst') order by all; +-- +ok +== +FROM read_csv_auto('{TEST_DIR}/data.csv.d2/*/*/*.csv.*') order by all; +-- +ok +== diff --git a/parser/testdata/corpus/sql/copy/csv/test_prefix_suffix.test b/parser/testdata/corpus/sql/copy/csv/test_prefix_suffix.test new file mode 100644 index 0000000..d7eed84 --- /dev/null +++ b/parser/testdata/corpus/sql/copy/csv/test_prefix_suffix.test @@ -0,0 +1,17 @@ +# source: test/sql/copy/csv/test_prefix_suffix.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +copy (select 42) to '{TEST_DIR}/file.csv' (prefix 'a'); +-- +ok +== +copy (select 42) to '{TEST_DIR}/file.csv' (prefix 'a', suffix 'b', header); +-- +ok +== +copy (select 42) to '{TEST_DIR}/file.csv' (escape 'null', null 'null'); +-- +ok +== diff --git a/parser/testdata/corpus/sql/copy/csv/test_quote_default.test b/parser/testdata/corpus/sql/copy/csv/test_quote_default.test new file mode 100644 index 0000000..ac4178e --- /dev/null +++ b/parser/testdata/corpus/sql/copy/csv/test_quote_default.test @@ -0,0 +1,13 @@ +# source: test/sql/copy/csv/test_quote_default.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +from read_csv('{DATA_DIR}/csv/test_default_option.csv', columns = {'a':'varchar', 'b':'integer'}, auto_detect = false, header = true) where b = 1 +-- +ok +== +from read_csv('{DATA_DIR}/csv/test_default_option_2.csv', columns = {'a':'varchar', 'b':'integer'}, auto_detect = false, header = true, delim = '|') where b = 1 +-- +ok +== diff --git a/parser/testdata/corpus/sql/copy/csv/test_quoted_later_escaped.test b/parser/testdata/corpus/sql/copy/csv/test_quoted_later_escaped.test new file mode 100644 index 0000000..2798103 --- /dev/null +++ b/parser/testdata/corpus/sql/copy/csv/test_quoted_later_escaped.test @@ -0,0 +1,37 @@ +# source: test/sql/copy/csv/test_quoted_later_escaped.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +CREATE TABLE T as select '1, "Oogie Boogie"' from range (100000) +-- +ok +== +insert into T values ('2, """sir"" Oogie Boogie"') +-- +ok +== +COPY T to '{TEST_DIR}/out.csv' (FORMAT CSV, HEADER 0, QUOTE ''); +-- +ok +== +SELECT quote, escape FROM sniff_csv('{TEST_DIR}/out.csv'); +-- +ok +== +CREATE TABLE T_2 as select '1, "Oogie Boogie"' from range (5000) +-- +ok +== +insert into T_2 values ('2, "\"sir\" Oogie Boogie"') +-- +ok +== +COPY T_2 to '{TEST_DIR}/out_2.csv' (FORMAT CSV, HEADER 0, QUOTE ''); +-- +ok +== +SELECT quote, escape FROM sniff_csv('{TEST_DIR}/out_2.csv'); +-- +ok +== diff --git a/parser/testdata/corpus/sql/copy/csv/test_quoted_newline.test b/parser/testdata/corpus/sql/copy/csv/test_quoted_newline.test new file mode 100644 index 0000000..f0a8a1d --- /dev/null +++ b/parser/testdata/corpus/sql/copy/csv/test_quoted_newline.test @@ -0,0 +1,17 @@ +# source: test/sql/copy/csv/test_quoted_newline.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +COPY test FROM '{DATA_DIR}/csv/test/quoted_newline.csv' (DELIMITER ',', AUTO_DETECT 0); +-- +ok +== +SELECT SUM(b) FROM test; +-- +ok +== +SELECT string_split_regex(a, '[\r\n]+') FROM test ORDER BY a; +-- +ok +== diff --git a/parser/testdata/corpus/sql/copy/csv/test_read_csv.test b/parser/testdata/corpus/sql/copy/csv/test_read_csv.test new file mode 100644 index 0000000..0da407e --- /dev/null +++ b/parser/testdata/corpus/sql/copy/csv/test_read_csv.test @@ -0,0 +1,61 @@ +# source: test/sql/copy/csv/test_read_csv.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +select delimiter, quote FROM sniff_csv('{DATA_DIR}/csv/stats_3_muta_10_21.csv') +-- +ok +== +FROM read_csv('{DATA_DIR}/csv/comments/comment_skip.csv', comment = '#', delim = ',', skip=1, auto_detect = false, header = 1, columns = {'x':'varchar','y':'varchar','z':'varchar'}) +-- +ok +== +FROM read_csv('{DATA_DIR}/csv/multi_quote.csv', null_padding = true) +-- +ok +== +FROM read_csv('{DATA_DIR}/csv/bad_escape.csv') +-- +ok +== +FROM read_csv('{DATA_DIR}/csv/quoted_values_delimited.csv') +-- +ok +== +FROM read_csv('{DATA_DIR}/csv/quoted_values_delimited.csv', ignore_errors = true) +-- +ok +== +FROM read_csv('{DATA_DIR}/csv/quoted_values_delimited.csv', quote = '') +-- +ok +== +FROM read_csv_auto('{DATA_DIR}/csv/test/dateformat.csv') +-- +ok +== +INSERT INTO dates SELECT * FROM read_csv('{DATA_DIR}/csv/test/dateformat.csv', columns=STRUCT_PACK(d := 'DATE'), header=0) +-- +ok +== +INSERT INTO dates SELECT * FROM read_csv_auto('{DATA_DIR}/csv/test/dateformat.csv', dateformat='%m/%d/%Y') +-- +ok +== +CREATE TABLE timestamps AS SELECT * FROM read_csv_auto('{DATA_DIR}/csv/test/dateformat.csv', timestampformat='%m/%d/%Y', columns=STRUCT_PACK(d := 'TIMESTAMP')) +-- +ok +== +CREATE VIEW lineitem AS SELECT * FROM read_csv('{DATA_DIR}/csv/real/lineitem_sample.csv', sep='|', columns=STRUCT_PACK(l_orderkey := 'INT', l_partkey := 'INT', l_suppkey := 'INT', l_linenumber := 'INT', l_quantity := 'INTEGER', l_extendedprice := 'DOUBLE', l_discount := 'DOUBLE', l_tax := 'DOUBLE', l_returnflag := 'VARCHAR', l_linestatus := 'VARCHAR', l_shipdate := 'DATE', l_commitdate := 'DATE', l_receiptdate := 'DATE', l_shipinstruct := 'VARCHAR', l_shipmode := 'VARCHAR', l_comment := 'VARCHAR')); +-- +ok +== +SELECT l_partkey, RTRIM(l_comment) FROM lineitem WHERE l_orderkey=1 ORDER BY l_linenumber; +-- +ok +== +SELECT * FROM read_csv('{DATA_DIR}/csv/real/lineitem_sample.csv', sep='|', columns=STRUCT_PACK(l_orderkey := 5)) +-- +ok +== diff --git a/parser/testdata/corpus/sql/copy/csv/test_replacement_scan_alias.test b/parser/testdata/corpus/sql/copy/csv/test_replacement_scan_alias.test new file mode 100644 index 0000000..ba84666 --- /dev/null +++ b/parser/testdata/corpus/sql/copy/csv/test_replacement_scan_alias.test @@ -0,0 +1,29 @@ +# source: test/sql/copy/csv/test_replacement_scan_alias.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +select * from '{DATA_DIR}/csv/test/dateformat.csv'; +-- +ok +== +select * from '{DATA_DIR}/csv/test/dateformat.csv', '{DATA_DIR}/csv/test/dateformat_2.csv'; +-- +ok +== +select mytbl.column0 from '{DATA_DIR}/csv/test/dateformat.csv'mytbl; +-- +ok +== +select mytbl.mycol from '{DATA_DIR}/csv/test/dateformat.csv' mytbl(mycol); +-- +ok +== +select blob.ids from '{DATA_DIR}/parquet-testing/blob.parquet' +-- +ok +== +select example_n.id from '{DATA_DIR}/json/example_n.ndjson' +-- +ok +== diff --git a/parser/testdata/corpus/sql/copy/csv/test_segfault.test b/parser/testdata/corpus/sql/copy/csv/test_segfault.test new file mode 100644 index 0000000..022efe1 --- /dev/null +++ b/parser/testdata/corpus/sql/copy/csv/test_segfault.test @@ -0,0 +1,9 @@ +# source: test/sql/copy/csv/test_segfault.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +from '{DATA_DIR}/csv/fuzzing/{i}.csv' +-- +ok +== diff --git a/parser/testdata/corpus/sql/copy/csv/test_skip_bom.test b/parser/testdata/corpus/sql/copy/csv/test_skip_bom.test new file mode 100644 index 0000000..c3aef36 --- /dev/null +++ b/parser/testdata/corpus/sql/copy/csv/test_skip_bom.test @@ -0,0 +1,21 @@ +# source: test/sql/copy/csv/test_skip_bom.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +CREATE TABLE people AS SELECT * FROM read_csv('{DATA_DIR}/csv/people.csv', columns=STRUCT_PACK(a := 'VARCHAR', b := 'VARCHAR'), sep=',', auto_detect='false'); +-- +ok +== +SELECT * FROM people +-- +ok +== +CREATE TABLE people2 AS SELECT * FROM read_csv_auto('{DATA_DIR}/csv/people.csv'); +-- +ok +== +SELECT * FROM people2 +-- +ok +== diff --git a/parser/testdata/corpus/sql/copy/csv/test_skip_header.test b/parser/testdata/corpus/sql/copy/csv/test_skip_header.test new file mode 100644 index 0000000..7f4891c --- /dev/null +++ b/parser/testdata/corpus/sql/copy/csv/test_skip_header.test @@ -0,0 +1,13 @@ +# source: test/sql/copy/csv/test_skip_header.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +FROM '{DATA_DIR}/csv/skip_header.csv' +-- +ok +== +FROM read_csv_auto('{DATA_DIR}/csv/skip_header.csv', columns={'a': 'INT32', 'b': 'INT32', 'c': 'INT32'}); +-- +ok +== diff --git a/parser/testdata/corpus/sql/copy/csv/test_sniff_csv.test b/parser/testdata/corpus/sql/copy/csv/test_sniff_csv.test new file mode 100644 index 0000000..0c90eca --- /dev/null +++ b/parser/testdata/corpus/sql/copy/csv/test_sniff_csv.test @@ -0,0 +1,97 @@ +# source: test/sql/copy/csv/test_sniff_csv.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +SELECT quote, escape from sniff_csv('{DATA_DIR}/csv/16857.csv', ignore_errors = true); +-- +ok +== +SELECT quote, escape from sniff_csv('{DATA_DIR}/csv/16857.csv'); +-- +ok +== +SELECT escape,quote, delimiter from sniff_csv('{DATA_DIR}/csv/later_quotes.csv'); +-- +ok +== +SELECT Prompt FROM sniff_csv('{DATA_DIR}/csv/real/lineitem_sample.csv'); +-- +ok +== +FROM read_csv('{DATA_DIR}/csv/real/lineitem_sample.csv', auto_detect=false, delim='|', quote='"', escape='"', new_line='\n', skip=0, comment='', header=false, columns={'column00': 'BIGINT', 'column01': 'BIGINT', 'column02': 'BIGINT', 'column03': 'BIGINT', 'column04': 'BIGINT', 'column05': 'DOUBLE', 'column06': 'DOUBLE', 'column07': 'DOUBLE', 'column08': 'VARCHAR', 'column09': 'VARCHAR', 'column10': 'DATE', 'column11': 'DATE', 'column12': 'DATE', 'column13': 'VARCHAR', 'column14': 'VARCHAR', 'column15': 'VARCHAR'}, dateformat='%Y-%m-%d') limit 1; +-- +ok +== +FROM sniff_csv('{DATA_DIR}/csv/real/lineitem_sample.csv'); +-- +ok +== +FROM sniff_csv('{DATA_DIR}/csv/real/non_ecziste.csv'); +-- +ok +== +FROM sniff_csv('{DATA_DIR}/csv/error/mismatch/big_bad.csv', sample_size=1); +-- +ok +== +FROM read_csv('{DATA_DIR}/csv/error/mismatch/big_bad.csv', auto_detect=false, delim=',', quote='"', escape='"', new_line='\n', skip=0, header=0, columns={'column0': 'BIGINT', 'column1': 'VARCHAR'}, sample_size=1); +-- +ok +== +FROM sniff_csv('{DATA_DIR}/csv/error/mismatch/big_bad.csv', sample_size=10000); +-- +ok +== +FROM sniff_csv('{DATA_DIR}/csv/error/mismatch/big_bad.csv', sample_size=-1); +-- +ok +== +FROM sniff_csv('{DATA_DIR}/csv/test/dateformat.csv') +-- +ok +== +FROM read_csv('{DATA_DIR}/csv/test/dateformat.csv', auto_detect=false, delim=',', quote='"', escape='"', new_line='\n', skip=0, header=false, columns={'column0': 'DATE'}, dateformat='%d/%m/%Y'); +-- +ok +== +FROM sniff_csv('{DATA_DIR}/csv/auto/time_date_timestamp_yyyy.mm.dd.csv') +-- +ok +== +FROM read_csv('{DATA_DIR}/csv/auto/time_date_timestamp_yyyy.mm.dd.csv', auto_detect=false, delim=',', quote='"', escape='"', new_line='\n', skip=0, header=true, columns={'a': 'BIGINT', 'b': 'VARCHAR', 't': 'TIME', 'd': 'DATE', 'ts': 'TIMESTAMP'}, dateformat='%Y.%m.%d', timestampformat='%Y.%m.%d %H:%M:%S'); +-- +ok +== +FROM sniff_csv('{DATA_DIR}/csv/inconsistent_cells.csv') +-- +ok +== +FROM read_csv('{DATA_DIR}/csv/inconsistent_cells.csv', auto_detect=false, delim=',', quote='"', escape='"', new_line='\n', skip=5, header=false, columns={'column0': 'BIGINT', 'column1': 'BIGINT', 'column2': 'BIGINT', 'column3': 'BIGINT', 'column4': 'BIGINT'}); +-- +ok +== +FROM sniff_csv('{DATA_DIR}/csv/timings.csv') +-- +ok +== +FROM read_csv('{DATA_DIR}/csv/timings.csv', auto_detect=false, delim='|', quote='"', escape='\', new_line='\n', skip=0, header=true, columns={'tool': 'VARCHAR', 'sf': 'BIGINT', 'day': 'DATE', 'batch_type': 'VARCHAR', 'q': 'VARCHAR', 'parameters': 'VARCHAR', 'time': 'DOUBLE'}, dateformat='%Y-%m-%d') order by all limit 1; +-- +ok +== +FROM sniff_csv('{DATA_DIR}/csv/auto/backslash_escape.csv') +-- +ok +== +FROM read_csv('{DATA_DIR}/csv/auto/backslash_escape.csv', auto_detect=false, delim='|', quote='"', escape='\', new_line='\n', skip=0, header=false, columns={'column0': 'BIGINT', 'column1': 'VARCHAR', 'column2': 'VARCHAR'}); +-- +ok +== +FROM sniff_csv('{DATA_DIR}/csv/comments/simple.csv'); +-- +ok +== +FROM read_csv('{DATA_DIR}/csv/comments/simple.csv', auto_detect=false, delim=';', quote='', escape='', new_line='\n', skip=0, comment='#', header=true, columns={'a': 'BIGINT', 'b': 'BIGINT'}); +-- +ok +== diff --git a/parser/testdata/corpus/sql/copy/csv/test_sniff_csv_options.test b/parser/testdata/corpus/sql/copy/csv/test_sniff_csv_options.test new file mode 100644 index 0000000..23e3288 --- /dev/null +++ b/parser/testdata/corpus/sql/copy/csv/test_sniff_csv_options.test @@ -0,0 +1,121 @@ +# source: test/sql/copy/csv/test_sniff_csv_options.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +FROM sniff_csv('{DATA_DIR}/csv/real/lineitem_sample.csv', delim = ','); +-- +ok +== +FROM sniff_csv('{DATA_DIR}/csv/real/lineitem_sample.csv', delim='|'); +-- +ok +== +FROM sniff_csv('{DATA_DIR}/csv/real/lineitem_sample.csv', quote='"'); +-- +ok +== +FROM sniff_csv('{DATA_DIR}/csv/real/lineitem_sample.csv', escape='"'); +-- +ok +== +FROM sniff_csv('{DATA_DIR}/csv/real/lineitem_sample.csv', names=['c1', 'c2', 'c3', 'c4', 'c5', 'c6', 'c7', 'c8', 'c9', 'c10', 'c11', 'c12', 'c13', 'c14', 'c15', 'c16']); +-- +ok +== +FROM read_csv('{DATA_DIR}/csv/real/lineitem_sample.csv', auto_detect=false, delim='|', quote='"', escape='"', new_line='\n', skip=0, header=false, columns={'c1': 'BIGINT', 'c2': 'BIGINT', 'c3': 'BIGINT', 'c4': 'BIGINT', 'c5': 'BIGINT', 'c6': 'DOUBLE', 'c7': 'DOUBLE', 'c8': 'DOUBLE', 'c9': 'VARCHAR', 'c10': 'VARCHAR', 'c11': 'DATE', 'c12': 'DATE', 'c13': 'DATE', 'c14': 'VARCHAR', 'c15': 'VARCHAR', 'c16': 'VARCHAR'}, dateformat='%Y-%m-%d') limit 1; +-- +ok +== +FROM sniff_csv('{DATA_DIR}/csv/real/lineitem_sample.csv', columns={'c1': 'BIGINT', 'c2': 'BIGINT', 'c3': 'BIGINT', 'c4': 'BIGINT', 'c5': 'BIGINT', 'c6': 'DOUBLE', 'c7': 'DOUBLE', 'c8': 'DOUBLE', 'c9': 'VARCHAR', 'c10': 'VARCHAR', 'c11': 'DATE', 'c12': 'DATE', 'c13': 'DATE', 'c14': 'VARCHAR', 'c15': 'VARCHAR', 'c16': 'VARCHAR'}); +-- +ok +== +FROM sniff_csv('{DATA_DIR}/csv/real/lineitem_sample.csv', skip=1); +-- +ok +== +FROM sniff_csv('{DATA_DIR}/csv/real/lineitem_sample.csv', header=true); +-- +ok +== +FROM sniff_csv('{DATA_DIR}/csv/auto/time_date_timestamp_yyyy.mm.dd.csv', dateformat='%Y.%m.%d') +-- +ok +== +FROM sniff_csv('{DATA_DIR}/csv/auto/time_date_timestamp_yyyy.mm.dd.csv', timestampformat='%Y.%m.%d %H:%M:%S') +-- +ok +== +FROM sniff_csv('{DATA_DIR}/csv/auto/time_date_timestamp_yyyy.mm.dd.csv', dateformat='%Y.%m.%d', timestampformat='%Y.%m.%d %H:%M:%S') +-- +ok +== +FROM read_csv('{DATA_DIR}/csv/auto/time_date_timestamp_yyyy.mm.dd.csv', auto_detect=false, delim=',', quote='"', escape='"', new_line='\n', skip=0, header=true, columns={'a': 'BIGINT', 'b': 'VARCHAR', 't': 'TIME', 'd': 'DATE', 'ts': 'TIMESTAMP'}, timestampformat='%Y.%m.%d %H:%M:%S', dateformat='%Y.%m.%d') order by all limit 1; +-- +ok +== +FROM sniff_csv('{DATA_DIR}/csv/real/lineitem_sample.csv', columns={'c1': 'BIGINT', 'c2': 'BIGINT', 'c3': 'BIGINT', 'c4': 'BIGINT', 'c5': 'BIGINT', 'c6': 'DOUBLE', 'c7': 'DOUBLE', 'c8': 'DOUBLE', 'c9': 'VARCHAR', 'c10': 'VARCHAR', 'c11': 'DATE', 'c12': 'DATE', 'c13': 'DATE', 'c14': 'VARCHAR', 'c15': 'VARCHAR', 'c16': 'VARCHAR'}, auto_detect = false); +-- +ok +== +FROM sniff_csv('{DATA_DIR}/csv/real/lineitem_sample.csv', columns={'c1': 'BIGINT', 'c2': 'BIGINT', 'c3': 'BIGINT', 'c4': 'BIGINT', 'c5': 'BIGINT', 'c6': 'DOUBLE', 'c7': 'DOUBLE', 'c8': 'DOUBLE', 'c9': 'VARCHAR', 'c10': 'VARCHAR', 'c11': 'DATE', 'c12': 'DATE', 'c13': 'DATE', 'c14': 'VARCHAR', 'c15': 'VARCHAR', 'c16': 'VARCHAR'}, auto_detect = true); +-- +ok +== +FROM sniff_csv('{DATA_DIR}/csv/autotypecandidates.csv', auto_type_candidates=['SMALLINT','BIGINT', 'DOUBLE', 'FLOAT','VARCHAR']); +-- +ok +== +FROM read_csv('{DATA_DIR}/csv/autotypecandidates.csv', auto_detect=false, delim='|', quote='"', escape='"', new_line='\n', skip=0, header=false, columns={'column0': 'SMALLINT', 'column1': 'FLOAT', 'column2': 'VARCHAR'}); +-- +ok +== +FROM sniff_csv('{DATA_DIR}/csv/hive-partitioning/simple/*/*/test.csv'); +-- +ok +== +FROM sniff_csv('{DATA_DIR}/csv/autotypecandidates.csv', oop = True); +-- +ok +== +FROM sniff_csv('{DATA_DIR}/csv/autotypecandidates.csv', HIVE_PARTITIONING=1); +-- +ok +== +FROM sniff_csv('{DATA_DIR}/csv/real/lineitem_sample.csv', types=['INTEGER','BIGINT','BIGINT','BIGINT','BIGINT', 'DOUBLE','DOUBLE','DOUBLE','VARCHAR', 'VARCHAR','DATE', 'DATE', 'DATE', 'VARCHAR', 'VARCHAR', 'VARCHAR']); +-- +ok +== +FROM sniff_csv('{DATA_DIR}/csv/real/lineitem_sample.csv', dtypes=['INTEGER','BIGINT','BIGINT','BIGINT','BIGINT', 'DOUBLE','DOUBLE','DOUBLE','VARCHAR', 'VARCHAR','DATE', 'DATE', 'DATE', 'VARCHAR', 'VARCHAR', 'VARCHAR']); +-- +ok +== +FROM sniff_csv('{DATA_DIR}/csv/real/lineitem_sample.csv', column_types=['INTEGER','BIGINT','BIGINT','BIGINT','BIGINT', 'DOUBLE','DOUBLE','DOUBLE','VARCHAR', 'VARCHAR','DATE', 'DATE', 'DATE', 'VARCHAR', 'VARCHAR', 'VARCHAR']); +-- +ok +== +FROM sniff_csv('{DATA_DIR}/csv/real/lineitem_sample.csv', names=['c01','c02','c03','c04','c5', 'c06','c07','c08','c09', 'c10','c11', 'c12', 'c13', 'c14', 'c15', 'c16']); +-- +ok +== +SELECT delimiter FROM sniff_csv('{DATA_DIR}/csv/ignore_errors.csv'); +-- +ok +== +SELECT delimiter FROM sniff_csv('{DATA_DIR}/csv/ignore_errors.csv', ignore_errors=true); +-- +ok +== +SELECT delimiter FROM sniff_csv('{DATA_DIR}/csv/ignore_errors.csv', store_rejects=true); +-- +ok +== +SELECT delimiter FROM sniff_csv('{DATA_DIR}/csv/ignore_errors.csv', rejects_scan='a_1'); +-- +ok +== +SELECT delimiter FROM sniff_csv('{DATA_DIR}/csv/ignore_errors.csv', rejects_table='a_2'); +-- +ok +== diff --git a/parser/testdata/corpus/sql/copy/csv/test_sniffer_hang.test b/parser/testdata/corpus/sql/copy/csv/test_sniffer_hang.test new file mode 100644 index 0000000..b7ef110 --- /dev/null +++ b/parser/testdata/corpus/sql/copy/csv/test_sniffer_hang.test @@ -0,0 +1,9 @@ +# source: test/sql/copy/csv/test_sniffer_hang.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +FROM read_csv('{DATA_DIR}/csv/bad_csv_file_2047.csv', sample_size = -1) +-- +ok +== diff --git a/parser/testdata/corpus/sql/copy/csv/test_sniffer_tab_delimiter.test b/parser/testdata/corpus/sql/copy/csv/test_sniffer_tab_delimiter.test new file mode 100644 index 0000000..d0bf993 --- /dev/null +++ b/parser/testdata/corpus/sql/copy/csv/test_sniffer_tab_delimiter.test @@ -0,0 +1,33 @@ +# source: test/sql/copy/csv/test_sniffer_tab_delimiter.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +select columns from sniff_csv('{DATA_DIR}/csv/test_apple_financial.csv.gz', header = 1, skip=3, delim = '\t') +-- +ok +== +select columns from sniff_csv('{DATA_DIR}/csv/test_apple_financial.csv.gz', skip=3, delim = '\t') +-- +ok +== +select columns from sniff_csv('{DATA_DIR}/csv/test_apple_financial.csv.gz', skip=3) +-- +ok +== +select columns from sniff_csv('{DATA_DIR}/csv/test_apple_financial.csv.gz') +-- +ok +== +FROM read_csv('{DATA_DIR}/csv/test_apple_financial.csv.gz', header = 1, skip=3) +-- +ok +== +FROM read_csv('{DATA_DIR}/csv/test_apple_financial.csv.gz', skip=3) +-- +ok +== +FROM read_csv('{DATA_DIR}/csv/test_apple_financial.csv.gz') +-- +ok +== diff --git a/parser/testdata/corpus/sql/copy/csv/test_soccer_kaggle.test b/parser/testdata/corpus/sql/copy/csv/test_soccer_kaggle.test new file mode 100644 index 0000000..b46289b --- /dev/null +++ b/parser/testdata/corpus/sql/copy/csv/test_soccer_kaggle.test @@ -0,0 +1,9 @@ +# source: test/sql/copy/csv/test_soccer_kaggle.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +select count(*) from '{DATA_DIR}/csv/soccer_kaggle.csv' +-- +ok +== diff --git a/parser/testdata/corpus/sql/copy/csv/test_thijs_unquoted_file.test b/parser/testdata/corpus/sql/copy/csv/test_thijs_unquoted_file.test new file mode 100644 index 0000000..db8e221 --- /dev/null +++ b/parser/testdata/corpus/sql/copy/csv/test_thijs_unquoted_file.test @@ -0,0 +1,29 @@ +# source: test/sql/copy/csv/test_thijs_unquoted_file.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +from read_csv('{DATA_DIR}/csv/thijs_unquoted.csv', quote='"', sep='|', escape='"', columns={'a':'varchar', 'b': 'varchar', 'c': 'integer'}, auto_detect=false); +-- +ok +== +from read_csv('{DATA_DIR}/csv/thijs_unquoted.csv', quote='"', sep='|', escape='"', columns={'a':'varchar', 'b': 'varchar', 'c': 'integer'}, auto_detect=false, strict_mode = False); +-- +ok +== +SELECT DELIMITER, QUOTE FROM sniff_csv('{DATA_DIR}/csv/rabo-anon.csv.gz', strict_mode=FALSE) +-- +ok +== +CREATE TABLE T AS FROM read_csv('{DATA_DIR}/csv/rabo-anon.csv.gz', strict_mode=FALSE); +-- +ok +== +select count(*) from T +-- +ok +== +select * from T limit 1 +-- +ok +== diff --git a/parser/testdata/corpus/sql/copy/csv/test_thousands_separator.test b/parser/testdata/corpus/sql/copy/csv/test_thousands_separator.test new file mode 100644 index 0000000..4533875 --- /dev/null +++ b/parser/testdata/corpus/sql/copy/csv/test_thousands_separator.test @@ -0,0 +1,91 @@ +# source: test/sql/copy/csv/test_thousands_separator.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +FROM read_csv('{DATA_DIR}/csv/thousands_separator/simple.csv', thousands = NULL, delim = NULL) +-- +ok +== +FROM read_csv('{DATA_DIR}/csv/thousands_separator/simple.csv', thousands = '', delim = NULL) +-- +ok +== +FROM read_csv('{DATA_DIR}/csv/thousands_separator/simple.csv', thousands = 'bla', delim = NULL) +-- +ok +== +FROM read_csv('{DATA_DIR}/csv/thousands_separator/simple.csv', thousands = ',', decimal_separator = ',') +-- +ok +== +FROM read_csv('{DATA_DIR}/csv/thousands_separator/simple.csv', thousands = '.') +-- +ok +== +SELECT COUNT(*) > 0 AS has_match +FROM sniff_csv('{DATA_DIR}/csv/thousands_separator/simple.csv', thousands = ',') +WHERE prompt LIKE '%thousands='',''%'; +-- +ok +== +FROM read_csv('{DATA_DIR}/csv/thousands_separator/simple.csv', thousands = ',', delim = ';', columns = {'a':'double'}, header = False, auto_detect = false) +-- +ok +== +FROM read_csv('{DATA_DIR}/csv/thousands_separator/simple.csv', thousands = ',', delim = ';', columns = {'a':'float'}, header = False, auto_detect = false) +-- +ok +== +FROM read_csv('{DATA_DIR}/csv/thousands_separator/simple.csv', thousands = ',', delim = ';', columns = {'a':'decimal(32,3)'}, header = False, auto_detect = false) +-- +ok +== +FROM read_csv('{DATA_DIR}/csv/thousands_separator/simple.csv', thousands = ',', delim = ';', header = False) +-- +ok +== +FROM read_csv('{DATA_DIR}/csv/thousands_separator/simple_quoted.csv', thousands = ',', header = False) +-- +ok +== +FROM read_csv('{DATA_DIR}/csv/thousands_separator/simple.csv', thousands = ',', delim = ';', header = False, columns = {'a':'float'}) +-- +ok +== +FROM read_csv('{DATA_DIR}/csv/thousands_separator/simple.csv', thousands = ',', delim = ';', header = False, columns = {'a':'decimal(32,3)'}) +-- +ok +== +FROM read_csv('{DATA_DIR}/csv/thousands_separator/multi_column.csv', thousands = ',') +-- +ok +== +FROM read_csv('{DATA_DIR}/csv/thousands_separator/multi_column_quote.csv', thousands = ',') +-- +ok +== +CREATE TABLE T (name varchar, money double, city varchar); +-- +ok +== +COPY T FROM '{DATA_DIR}/csv/thousands_separator/multi_column_quote.csv' (THOUSANDS ',') ; +-- +ok +== +FROM T; +-- +ok +== +FROM read_csv('{DATA_DIR}/csv/thousands_separator/thousands_broken.csv', thousands = ',') +-- +ok +== +FROM read_csv('{DATA_DIR}/csv/thousands_separator/integers.csv', thousands = ',') +-- +ok +== +select columns from sniff_csv('{DATA_DIR}/csv/thousands_separator/integers.csv', thousands = ',') +-- +ok +== diff --git a/parser/testdata/corpus/sql/copy/csv/test_time.test b/parser/testdata/corpus/sql/copy/csv/test_time.test new file mode 100644 index 0000000..2465ecf --- /dev/null +++ b/parser/testdata/corpus/sql/copy/csv/test_time.test @@ -0,0 +1,21 @@ +# source: test/sql/copy/csv/test_time.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +from read_csv('{DATA_DIR}/csv/auto/invalid_time.csv', header = 0) +-- +ok +== +from '{DATA_DIR}/csv/auto/time.csv' +-- +ok +== +from '{DATA_DIR}/csv/auto/various_time_formats.csv' +-- +ok +== +select columns from sniff_csv('{DATA_DIR}/csv/auto/various_time_formats.csv') +-- +ok +== diff --git a/parser/testdata/corpus/sql/copy/csv/test_timestamp_offset.test b/parser/testdata/corpus/sql/copy/csv/test_timestamp_offset.test new file mode 100644 index 0000000..14bd84f --- /dev/null +++ b/parser/testdata/corpus/sql/copy/csv/test_timestamp_offset.test @@ -0,0 +1,9 @@ +# source: test/sql/copy/csv/test_timestamp_offset.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +SELECT col1, typeof(col1) FROM '{DATA_DIR}/csv/test/timestampoffset.csv' t1(col1); +-- +ok +== diff --git a/parser/testdata/corpus/sql/copy/csv/test_timestamptz_12926.test b/parser/testdata/corpus/sql/copy/csv/test_timestamptz_12926.test new file mode 100644 index 0000000..3892f2e --- /dev/null +++ b/parser/testdata/corpus/sql/copy/csv/test_timestamptz_12926.test @@ -0,0 +1,29 @@ +# source: test/sql/copy/csv/test_timestamptz_12926.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +FROM read_csv('{DATA_DIR}/csv/timestamp_tz.csv', dtypes = [TIMESTAMPTZ]); +-- +ok +== +FROM read_csv('{DATA_DIR}/csv/timestamp_tz.csv', dtypes = [TIMESTAMPTZ], timestampformat = '%d/%m/%Y'); +-- +ok +== +CREATE TABLE test (column0 timestamptz); +-- +ok +== +INSERT INTO test SELECT * FROM '{DATA_DIR}/csv/timestamp_tz.csv'; +-- +ok +== +INSERT INTO test SELECT * FROM read_csv('{DATA_DIR}/csv/timestamp_tz.csv', dtypes = [TIMESTAMPTZ], timestampformat = '%d/%m/%Y'); +-- +ok +== +FROM test +-- +ok +== diff --git a/parser/testdata/corpus/sql/copy/csv/test_union_by_name.test b/parser/testdata/corpus/sql/copy/csv/test_union_by_name.test new file mode 100644 index 0000000..f84369c --- /dev/null +++ b/parser/testdata/corpus/sql/copy/csv/test_union_by_name.test @@ -0,0 +1,82 @@ +# source: test/sql/copy/csv/test_union_by_name.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +COPY ubn1 TO '{TEMP_DIR}/ubn1.csv' WITH ( DELIMITER ','); +-- +ok +== +COPY ubn2 TO '{TEMP_DIR}/ubn2.csv' WITH (DELIMITER ','); +-- +ok +== +COPY ubn3 TO '{TEMP_DIR}/ubn3.csv' WITH (DELIMITER ','); +-- +ok +== +SELECT * FROM read_csv_auto(['{TEMP_DIR}/ubn1.csv', '{TEMP_DIR}/ubn2.csv', '{TEMP_DIR}/ubn3.csv']); +-- +ok +== +SELECT a, b, c +FROM read_csv_auto(['{TEMP_DIR}/ubn1.csv', '{TEMP_DIR}/ubn2.csv', '{TEMP_DIR}/ubn3.csv'], UNION_BY_NAME=TRUE) +ORDER BY a; +-- +ok +== +SELECT a, b, c, replace(replace(filename, '{TEMP_DIR}', ''), '\', '/')[2:] +FROM read_csv_auto(['{TEMP_DIR}/ubn1.csv', '{TEMP_DIR}/ubn2.csv', '{TEMP_DIR}/ubn3.csv'], UNION_BY_NAME=TRUE) +ORDER BY a; +-- +ok +== +SELECT COUNT(a), COUNT(b), COUNT(c), COUNT(filename) +FROM read_csv_auto(['{TEMP_DIR}/ubn1.csv', '{TEMP_DIR}/ubn2.csv', '{TEMP_DIR}/ubn3.csv'], UNION_BY_NAME=TRUE) +-- +ok +== +SELECT typeof(a), typeof(b), typeof(c) +FROM read_csv_auto(['{TEMP_DIR}/ubn1.csv', '{TEMP_DIR}/ubn2.csv', '{TEMP_DIR}/ubn3.csv'], UNION_BY_NAME=TRUE) +LIMIT 1; +-- +ok +== +SELECT * FROM read_csv_auto(['{DATA_DIR}/csv/union-by-name/ubn1.csv', '{DATA_DIR}/csv/union-by-name/ubn2.csv', '{DATA_DIR}/csv/union-by-name/ubn3.csv', '{DATA_DIR}/csv/union-by-name/ubn4.csv']) +-- +ok +== +SELECT typeof(a), typeof(b), typeof(ts) FROM read_csv_auto('{DATA_DIR}/csv/union-by-name/ubn2.csv') LIMIT 1; +-- +ok +== +SELECT a, b, c, ts, parse_filename(filename) +FROM read_csv_auto('{DATA_DIR}/csv/union-by-name/ubn[12].csv',FILENAME=TRUE ,UNION_BY_NAME=TRUE) +ORDER BY a, c, ts +-- +ok +== +SELECT typeof(a), typeof(b), typeof(c), typeof(ts) +FROM read_csv_auto('{DATA_DIR}/csv/union-by-name/ubn[12].csv',UNION_BY_NAME=TRUE) +LIMIT 1 +-- +ok +== +SELECT typeof(ts) +FROM read_csv_auto('{DATA_DIR}/csv/union-by-name/ubn[23].csv',UNION_BY_NAME=TRUE) +LIMIT 1 +-- +ok +== +SELECT * FROM read_csv_auto('{DATA_DIR}/csv/union-by-name/part=[ab]/*',HIVE_PARTITIONING=TRUE, null_padding=0) +-- +ok +== +SELECT * FROM read_csv_auto('{DATA_DIR}/csv/union-by-name/*[!a]/*',HIVE_PARTITIONING=TRUE ,UNION_BY_NAME=TRUE) +-- +ok +== +from read_csv('{DATA_DIR}/csv/union_by_name_2/*.csv', union_by_name=True, parallel = false); +-- +ok +== diff --git a/parser/testdata/corpus/sql/copy/csv/test_union_by_name_types.test b/parser/testdata/corpus/sql/copy/csv/test_union_by_name_types.test new file mode 100644 index 0000000..29bfa8d --- /dev/null +++ b/parser/testdata/corpus/sql/copy/csv/test_union_by_name_types.test @@ -0,0 +1,17 @@ +# source: test/sql/copy/csv/test_union_by_name_types.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +SELECT typeof(#1), typeof(#2), typeof(#3), typeof(#4), typeof(#5), typeof(#6), typeof(#7), typeof(#8), typeof(#9), typeof(#10), typeof(#11), typeof(#12), typeof(#13) +FROM read_csv(['{DATA_DIR}/csv/union-by-name/gabor/Post/*.csv', '{DATA_DIR}/csv/union-by-name/gabor/Comment/*.csv'], union_by_name=true) +LIMIT 1; +-- +ok +== +FROM read_csv(['{DATA_DIR}/csv/union-by-name/gabor/Post/*.csv', '{DATA_DIR}/csv/union-by-name/gabor/Comment/*.csv'], union_by_name=true) +ORDER BY ALL +LIMIT 1; +-- +ok +== diff --git a/parser/testdata/corpus/sql/copy/csv/test_validator.test b/parser/testdata/corpus/sql/copy/csv/test_validator.test new file mode 100644 index 0000000..4378704 --- /dev/null +++ b/parser/testdata/corpus/sql/copy/csv/test_validator.test @@ -0,0 +1,49 @@ +# source: test/sql/copy/csv/test_validator.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +FROM read_csv('{DATA_DIR}/csv/evil_nullpadding.csv', buffer_size=20, quote = '"') +-- +ok +== +FROM read_csv('{DATA_DIR}/csv/evil_nullpadding.csv', buffer_size=20) +-- +ok +== +FROM read_csv('{DATA_DIR}/csv/validator/single_column.csv', header = 0) +-- +ok +== +FROM read_csv('{DATA_DIR}/csv/validator/single_column.csv', header = 0, columns = {'a': 'integer'}, auto_detect = false) +-- +ok +== +FROM read_csv('{DATA_DIR}/csv/validator/single_column.csv', header = 0, columns = {'a': 'integer'}, auto_detect = false, buffer_size = 11) +-- +ok +== +FROM read_csv('{DATA_DIR}/csv/validator/single_column.csv', header = 0, columns = {'a': 'integer'}, auto_detect = false, buffer_size = 11, parallel = false) +-- +ok +== +FROM read_csv('{DATA_DIR}/csv/validator/quoted_new_value.csv') +-- +ok +== +FROM read_csv('{DATA_DIR}/csv/validator/quoted_new_value.csv', columns = {'band': 'varchar', 'album': 'varchar', 'release': 'varchar'}, quote = '''', delim = ';', header = 0) +-- +ok +== +FROM read_csv('{DATA_DIR}/csv/validator/quoted_new_value.csv', columns = {'band': 'varchar', 'album': 'varchar', 'release': 'varchar'}, quote = '''', delim = ';', header = 0, buffer_size = 48) +-- +ok +== +FROM read_csv('{DATA_DIR}/csv/validator/single_column_quoted_newline.csv', columns = {'Raffaella Carrà': 'varchar'}, quote = '"', buffer_size = 24) +-- +ok +== +FROM read_csv('{DATA_DIR}/csv/validator/single_column_notquoted_newline.csv', columns = {'Raffaella Carrà': 'varchar'}, quote = '"', buffer_size = 22) +-- +ok +== diff --git a/parser/testdata/corpus/sql/copy/csv/test_web_page.test b/parser/testdata/corpus/sql/copy/csv/test_web_page.test new file mode 100644 index 0000000..ab26284 --- /dev/null +++ b/parser/testdata/corpus/sql/copy/csv/test_web_page.test @@ -0,0 +1,33 @@ +# source: test/sql/copy/csv/test_web_page.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +CREATE TABLE web_page(wp_web_page_sk integer not null, wp_web_page_id char(16) not null, wp_rec_start_date date, wp_rec_end_date date, wp_creation_date_sk integer, wp_access_date_sk integer, wp_autogen_flag char(1), wp_customer_sk integer, wp_url varchar(100), wp_type char(50), wp_char_count integer, wp_link_count integer, wp_image_count integer, wp_max_ad_count integer, primary key (wp_web_page_sk)); +-- +ok +== +COPY web_page FROM '{DATA_DIR}/csv/real/web_page.csv' DELIMITER '|'; +-- +ok +== +SELECT * FROM web_page ORDER BY wp_web_page_sk LIMIT 3; +-- +ok +== +COPY web_page TO '{TEMP_DIR}/web_page.csv' DELIMITER ' ' HEADER; +-- +ok +== +DELETE FROM web_page; +-- +ok +== +SELECT * FROM web_page; +-- +ok +== +COPY web_page FROM '{TEMP_DIR}/web_page.csv' DELIMITER ' ' HEADER; +-- +ok +== diff --git a/parser/testdata/corpus/sql/copy/csv/test_windows_newline.test b/parser/testdata/corpus/sql/copy/csv/test_windows_newline.test new file mode 100644 index 0000000..7ac979a --- /dev/null +++ b/parser/testdata/corpus/sql/copy/csv/test_windows_newline.test @@ -0,0 +1,21 @@ +# source: test/sql/copy/csv/test_windows_newline.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +COPY test FROM '{DATA_DIR}/csv/test/windows_newline.csv'; +-- +ok +== +SELECT SUM(a), MIN(LENGTH(b)), MAX(LENGTH(b)), SUM(LENGTH(b)), SUM(c) FROM test; +-- +ok +== +COPY test FROM '{DATA_DIR}/csv/test/windows_newline.csv' (QUOTE 'BLABLABLA', AUTO_DETECT FALSE); +-- +ok +== +COPY test FROM '{DATA_DIR}/csv/test/windows_newline_empty.csv' (HEADER 0); +-- +ok +== diff --git a/parser/testdata/corpus/sql/copy/csv/test_wrong_newline_delimiter.test b/parser/testdata/corpus/sql/copy/csv/test_wrong_newline_delimiter.test new file mode 100644 index 0000000..0ceb593 --- /dev/null +++ b/parser/testdata/corpus/sql/copy/csv/test_wrong_newline_delimiter.test @@ -0,0 +1,21 @@ +# source: test/sql/copy/csv/test_wrong_newline_delimiter.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +FROM read_csv('{DATA_DIR}/csv/timestamp.csv', columns = {'a': 'BIGINT'}, new_line= '\r', strict_mode=false) +-- +ok +== +FROM read_csv('{DATA_DIR}/csv/timestamp.csv', columns = {'a': 'BIGINT'}, new_line= '\n', strict_mode=false) +-- +ok +== +FROM read_csv('{DATA_DIR}/csv/timestamp.csv', columns = {'a': 'BIGINT'}, new_line= '\r\n', auto_detect = false, strict_mode=false) +-- +ok +== +FROM read_csv('{DATA_DIR}/csv/timestamp.csv', columns = {'a': 'BIGINT'}, new_line= '\n\r', strict_mode=false) +-- +ok +== diff --git a/parser/testdata/corpus/sql/copy/csv/timestamp_with_tz.test b/parser/testdata/corpus/sql/copy/csv/timestamp_with_tz.test new file mode 100644 index 0000000..36f7f08 --- /dev/null +++ b/parser/testdata/corpus/sql/copy/csv/timestamp_with_tz.test @@ -0,0 +1,37 @@ +# source: test/sql/copy/csv/timestamp_with_tz.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +CREATE TABLE tbl(id int, ts timestamp); +-- +ok +== +COPY tbl FROM '{DATA_DIR}/csv/timestamp_with_tz.csv' (HEADER) +-- +ok +== +SELECT TRY_CAST('2022/01/27 11:04:57 PM' AS TIMESTAMPTZ); +-- +ok +== +CREATE TABLE tbl_tz(id int, ts timestamptz); +-- +ok +== +COPY tbl_tz FROM '{DATA_DIR}/csv/timestamp_with_tz.csv' (HEADER) +-- +ok +== +SET Calendar='gregorian' +-- +ok +== +SELECT * FROM tbl_tz +-- +ok +== +FROM read_csv('{DATA_DIR}/csv/17705.csv') +-- +ok +== diff --git a/parser/testdata/corpus/sql/copy/csv/tsv_copy.test b/parser/testdata/corpus/sql/copy/csv/tsv_copy.test new file mode 100644 index 0000000..ead30f1 --- /dev/null +++ b/parser/testdata/corpus/sql/copy/csv/tsv_copy.test @@ -0,0 +1,25 @@ +# source: test/sql/copy/csv/tsv_copy.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +CREATE TABLE people(id INTEGER, name VARCHAR); +-- +ok +== +INSERT INTO people VALUES (1, 'Mark'), (2, 'Hannes'); +-- +ok +== +COPY people TO '{TEST_DIR}/test.tsv' WITH (DELIMITER '\t'); +-- +ok +== +SELECT * FROM '{TEST_DIR}/test.tsv' +-- +ok +== +SELECT * FROM read_csv('{TEST_DIR}/test.tsv', sep='\t', columns={'id': 'INTEGER', 'name': 'VARCHAR'}) +-- +ok +== diff --git a/parser/testdata/corpus/sql/copy/csv/unicode_filename.test b/parser/testdata/corpus/sql/copy/csv/unicode_filename.test new file mode 100644 index 0000000..2cc93ec --- /dev/null +++ b/parser/testdata/corpus/sql/copy/csv/unicode_filename.test @@ -0,0 +1,21 @@ +# source: test/sql/copy/csv/unicode_filename.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +SELECT * FROM '{DATA_DIR}/csv/issue2628_中文.csv' +-- +ok +== +SELECT * FROM '{DATA_DIR}/csv/*中文.csv' +-- +ok +== +SELECT * FROM '{DATA_DIR}/csv/中文/*.csv' ORDER BY 1 +-- +ok +== +SELECT * FROM '{DATA_DIR}/csv/中*/*.csv' ORDER BY 1 +-- +ok +== diff --git a/parser/testdata/corpus/sql/copy/csv/unquoted_escape/basic.test b/parser/testdata/corpus/sql/copy/csv/unquoted_escape/basic.test new file mode 100644 index 0000000..cdbc5e1 --- /dev/null +++ b/parser/testdata/corpus/sql/copy/csv/unquoted_escape/basic.test @@ -0,0 +1,28 @@ +# source: test/sql/copy/csv/unquoted_escape/basic.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +SELECT * FROM read_csv('{DATA_DIR}/csv/unquoted_escape/plain.csv', escape = '\', sep = ',', strict_mode = false, nullstr = '\N'); +-- +ok +== +CREATE TABLE special_char(a INT, b STRING); +-- +ok +== +INSERT INTO special_char VALUES + (0, E'\\'), (1, E'\t'), (2, E'\n'), + (3, E'a\\a'), (4, E'b\tb'), (5, E'c\nc'), + (6, E'\\d'), (7, E'\te'), (8, E'\nf'), + (9, E'g\\'), (10, E'h\t'), (11, E'i\n'), + (12, E'\\j'), (13, E'\tk'), (14, E'\nl'), + (15, E'\\\\'), (16, E'\t\t'), (17, E'\n\n'), + (18, E'\\\t\n'); +-- +ok +== +SELECT bool_and(b = replace(s, E'\r\n', E'\n'))::int FROM special_char JOIN read_csv('{DATA_DIR}/csv/unquoted_escape/basic.tsv', quote = '', escape = '\', sep = '\t', strict_mode = false) t (i, s, j) ON i = a; +-- +ok +== diff --git a/parser/testdata/corpus/sql/copy/csv/unquoted_escape/human_eval.test b/parser/testdata/corpus/sql/copy/csv/unquoted_escape/human_eval.test new file mode 100644 index 0000000..a6dcade --- /dev/null +++ b/parser/testdata/corpus/sql/copy/csv/unquoted_escape/human_eval.test @@ -0,0 +1,55 @@ +# source: test/sql/copy/csv/unquoted_escape/human_eval.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +CREATE TABLE human_eval_jsonl AS +SELECT REPLACE(COLUMNS(*), ' ', E'\t') FROM read_ndjson_auto( +'https://raw.githubusercontent.com/openai/human-eval/refs/heads/master/data/HumanEval.jsonl.gz'); +-- +ok +== +DELETE FROM human_eval_jsonl WHERE split_part(task_id, '/', 2)::int >= 10; +-- +ok +== +CREATE TABLE human_eval_csv(task_id TEXT, prompt TEXT, entry_point TEXT, canonical_solution TEXT, test TEXT); +-- +ok +== +CREATE TABLE human_eval_tsv(task_id TEXT, prompt TEXT, entry_point TEXT, canonical_solution TEXT, test TEXT); +-- +ok +== +TRUNCATE human_eval_csv; +-- +ok +== +TRUNCATE human_eval_tsv; +-- +ok +== +INSERT INTO human_eval_csv +SELECT replace(COLUMNS(*), E'\r\n', E'\n') +FROM read_csv('data/csv/unquoted_escape/human_eval.csv', quote = '', escape = '\', sep = ',', header = false, strict_mode = false); +-- +ok +== +INSERT INTO human_eval_tsv +SELECT replace(COLUMNS(*), E'\r\n', E'\n') +FROM read_csv('data/csv/unquoted_escape/human_eval.tsv', quote = '', escape = '\', sep = '\t', header = false, strict_mode = false); +-- +ok +== +SELECT count(*), bool_and( + j.task_id = c.task_id AND j.task_id = t.task_id AND + j.prompt = c.prompt AND j.prompt = t.prompt AND + j.entry_point = c.entry_point AND j.entry_point = t.entry_point AND + j.canonical_solution = c.canonical_solution AND j.canonical_solution = t.canonical_solution AND + j.test = c.test AND j.test = t.test +)::int +FROM human_eval_jsonl j, human_eval_csv c, human_eval_tsv t +WHERE j.task_id = c.task_id AND j.task_id = t.task_id +-- +ok +== diff --git a/parser/testdata/corpus/sql/copy/csv/unquoted_escape/identical.test b/parser/testdata/corpus/sql/copy/csv/unquoted_escape/identical.test new file mode 100644 index 0000000..927b225 --- /dev/null +++ b/parser/testdata/corpus/sql/copy/csv/unquoted_escape/identical.test @@ -0,0 +1,9 @@ +# source: test/sql/copy/csv/unquoted_escape/identical.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +SELECT concat('#', columns(*), '#') FROM read_csv('{DATA_DIR}/csv/unquoted_escape/identical.csv', quote = '"', escape = '"', sep = ',', strict_mode = false); +-- +ok +== diff --git a/parser/testdata/corpus/sql/copy/csv/unquoted_escape/mixed.test b/parser/testdata/corpus/sql/copy/csv/unquoted_escape/mixed.test new file mode 100644 index 0000000..14e3d7e --- /dev/null +++ b/parser/testdata/corpus/sql/copy/csv/unquoted_escape/mixed.test @@ -0,0 +1,13 @@ +# source: test/sql/copy/csv/unquoted_escape/mixed.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +SELECT + hamming(replace(string_agg(w, '|' ORDER BY y), E'\r\n', E'\n'), E'\\|,|"|\n'), + hamming(string_agg(z, '|' ORDER BY y), '"|"a"|"b|c"'), + bool_and(x = concat(w, '"', w))::int +FROM read_csv('{DATA_DIR}/csv/unquoted_escape/mixed.csv', quote = '"', escape = '\', sep = ',', strict_mode = false); +-- +ok +== diff --git a/parser/testdata/corpus/sql/copy/csv/write_header_default.test b/parser/testdata/corpus/sql/copy/csv/write_header_default.test new file mode 100644 index 0000000..c9cbba2 --- /dev/null +++ b/parser/testdata/corpus/sql/copy/csv/write_header_default.test @@ -0,0 +1,25 @@ +# source: test/sql/copy/csv/write_header_default.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +create table t (a integer) +-- +ok +== +insert into t values (1),(2),(NULL) +-- +ok +== +COPY t TO '{TEST_DIR}/t_default.tsv' WITH (DELIMITER '\t'); +-- +ok +== +select * from read_csv_auto('{TEST_DIR}/t_default.tsv', header = 0) +-- +ok +== +COPY t TO '{TEST_DIR}/t_default.tsv' WITH (DELIMITER '\t', HEADER 0); +-- +ok +== diff --git a/parser/testdata/corpus/sql/copy/csv/zstd_crash.test b/parser/testdata/corpus/sql/copy/csv/zstd_crash.test new file mode 100644 index 0000000..aafe159 --- /dev/null +++ b/parser/testdata/corpus/sql/copy/csv/zstd_crash.test @@ -0,0 +1,53 @@ +# source: test/sql/copy/csv/zstd_crash.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +CREATE TABLE test_zst AS SELECT * FROM read_csv('{DATA_DIR}/csv/broken/test.csv.zst', AUTO_DETECT=TRUE); +-- +ok +== +CREATE TABLE test_zst(a INTEGER, b INTEGER, c INTEGER, d VARCHAR, e VARCHAR); +-- +ok +== +COPY test_zst FROM '{DATA_DIR}/csv/broken/test.csv.zst' (COMPRESSION ZSTD); +-- +ok +== +COPY test_zst FROM '{DATA_DIR}/csv/broken/test.csv.zst' (COMPRESSION GZIP); +-- +ok +== +COPY test_zst FROM '{DATA_DIR}/csv/broken/test.csv.zst' (COMPRESSION NONE); +-- +ok +== +COPY test_zst FROM '{DATA_DIR}/csv/broken/test.csv.zst' (COMPRESSION INFER); +-- +ok +== +COPY test_zst FROM '{DATA_DIR}/csv/broken/test.csv.zst' (COMPRESSION UNKNOWN); +-- +ok +== +COPY test_zst FROM '{DATA_DIR}/csv/broken/test.csv.zst' (COMPRESSION ZSTD, HEADER); +-- +ok +== +COPY test_zst FROM '{DATA_DIR}/csv/broken/test.csv.zst' (COMPRESSION ZSTD, AUTO_DETECT 1); +-- +ok +== +COPY test_zst FROM '{DATA_DIR}/csv/lineitem1k.tbl.gz' (COMPRESSION ZSTD); +-- +ok +== +COPY test_zst TO '{TEMP_DIR}/noext.csv' (COMPRESSION ZSTD); +-- +ok +== +COPY test_zst FROM '{TEMP_DIR}/noext.csv' (COMPRESSION ZSTD); +-- +ok +== diff --git a/parser/testdata/corpus/sql/copy/csv/zstd_fs.test b/parser/testdata/corpus/sql/copy/csv/zstd_fs.test new file mode 100644 index 0000000..aea6d61 --- /dev/null +++ b/parser/testdata/corpus/sql/copy/csv/zstd_fs.test @@ -0,0 +1,17 @@ +# source: test/sql/copy/csv/zstd_fs.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +COPY lineitem FROM '{DATA_DIR}/csv/zstd/lineitem1k.tbl.zst' DELIMITER '|'; +-- +ok +== +COPY ncvoters FROM '{DATA_DIR}/csv/zstd/ncvoter.csv.zst' DELIMITER ' '; +-- +ok +== +SELECT * FROM ncvoters +-- +ok +== diff --git a/parser/testdata/corpus/sql/copy/encryption/concurrent_encrypted_attach.test b/parser/testdata/corpus/sql/copy/encryption/concurrent_encrypted_attach.test new file mode 100644 index 0000000..30c4779 --- /dev/null +++ b/parser/testdata/corpus/sql/copy/encryption/concurrent_encrypted_attach.test @@ -0,0 +1,9 @@ +# source: test/sql/copy/encryption/concurrent_encrypted_attach.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +ATTACH '{TEST_DIR}/concurrent_encrypted{i}.duckdb' AS encrypted{i} (ENCRYPTION_KEY 'asdf{i}'); +-- +error: Parser Error: syntax error at or near "{" +== diff --git a/parser/testdata/corpus/sql/copy/encryption/different_aes_ciphers.test b/parser/testdata/corpus/sql/copy/encryption/different_aes_ciphers.test new file mode 100644 index 0000000..530a939 --- /dev/null +++ b/parser/testdata/corpus/sql/copy/encryption/different_aes_ciphers.test @@ -0,0 +1,49 @@ +# source: test/sql/copy/encryption/different_aes_ciphers.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +ATTACH '{TEST_DIR}/encrypted.duckdb' AS encrypted (ENCRYPTION_KEY 'asdf', ENCRYPTION_CIPHER 'random'); +-- +ok +== +ATTACH '{TEST_DIR}/encrypted.duckdb' AS encrypted (ENCRYPTION_KEY 'asdf', ENCRYPTION_CIPHER ''); +-- +ok +== +ATTACH '{TEST_DIR}/encrypted.duckdb' AS encrypted (ENCRYPTION_KEY 'asdf', ENCRYPTION_CIPHER 42); +-- +ok +== +ATTACH '{TEST_DIR}/encrypted_{cipher}.duckdb' AS encrypted_{cipher} (ENCRYPTION_KEY 'asdf', ENCRYPTION_CIPHER '{cipher}'); +-- +error: Parser Error: syntax error at or near "{" +== +select encrypted, options from duckdb_databases() where database_name = 'encrypted_{cipher}' and cipher='{cipher}'; +-- +ok +== +ATTACH '{TEST_DIR}/encrypted_default_cipher.duckdb' AS encrypted (ENCRYPTION_KEY 'asdf', ENCRYPTION_CIPHER 'CTR'); +-- +ok +== +create table encrypted.fuu as select 42; +-- +ok +== +FROM encrypted.fuu +-- +ok +== +ATTACH '{TEST_DIR}/encrypted_default_cipher.duckdb' AS encrypted (ENCRYPTION_KEY 'asdf'); +-- +ok +== +ATTACH '{TEST_DIR}/encrypted_default_cipher.duckdb' AS encrypted (ENCRYPTION_KEY 'asdf', ENCRYPTION_CIPHER 'GCM'); +-- +ok +== +ATTACH '{TEST_DIR}/CBC.duckdb' AS encrypted (ENCRYPTION_KEY 'asdf', ENCRYPTION_CIPHER 'CBC'); +-- +ok +== diff --git a/parser/testdata/corpus/sql/copy/encryption/different_encryption_versions_and_ciphers.test b/parser/testdata/corpus/sql/copy/encryption/different_encryption_versions_and_ciphers.test new file mode 100644 index 0000000..c969544 --- /dev/null +++ b/parser/testdata/corpus/sql/copy/encryption/different_encryption_versions_and_ciphers.test @@ -0,0 +1,29 @@ +# source: test/sql/copy/encryption/different_encryption_versions_and_ciphers.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +ATTACH '{TEST_DIR}/encrypted_{cipher}_{version}.duckdb' AS encrypted_{cipher}_{version} (ENCRYPTION_KEY 'asdf', ENCRYPTION_CIPHER '{cipher}', debug_encryption_version 'v9'); +-- +error: Parser Error: syntax error at or near "{" +== +ATTACH '{TEST_DIR}/encrypted_{cipher}_{version}.duckdb' AS encrypted_{cipher}_{version} (ENCRYPTION_KEY 'asdf', ENCRYPTION_CIPHER '{cipher}', debug_encryption_version '{version}'); +-- +error: Parser Error: syntax error at or near "{" +== +CREATE TABLE encrypted_{cipher}_{version}.tbl (i INTEGER); +-- +error: Parser Error: syntax error at or near "{" +== +INSERT INTO encrypted_{cipher}_{version}.tbl VALUES (42); +-- +error: Parser Error: syntax error at or near "{" +== +select encrypted from duckdb_databases() where database_name = 'encrypted_{cipher}_{version}' and cipher='{cipher}'; +-- +ok +== +SELECT * FROM encrypted_{cipher}_{version}.tbl; +-- +error: Parser Error: syntax error at or near "{" +== diff --git a/parser/testdata/corpus/sql/copy/encryption/encryption_storage_versions.test b/parser/testdata/corpus/sql/copy/encryption/encryption_storage_versions.test new file mode 100644 index 0000000..c83a1b3 --- /dev/null +++ b/parser/testdata/corpus/sql/copy/encryption/encryption_storage_versions.test @@ -0,0 +1,101 @@ +# source: test/sql/copy/encryption/encryption_storage_versions.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +ATTACH '{TEST_DIR}/unencrypted.duckdb' as unencrypted; +-- +ok +== +ATTACH '{TEST_DIR}/v_0_10_2.duckdb' as v_0_10_2 (STORAGE_VERSION 'v0.10.2'); +-- +ok +== +CREATE OR REPLACE TABLE v_0_10_2.tbl AS SELECT * FROM range(10) t(i); +-- +ok +== +SELECT SUM(i) FROM v_0_10_2.tbl +-- +ok +== +DETACH v_0_10_2 +-- +ok +== +ATTACH '{TEST_DIR}/encrypted_v2.duckdb' AS encrypted_v2 (ENCRYPTION_KEY 'asdf'); +-- +ok +== +ATTACH '{TEST_DIR}/v_0_10_2.duckdb' as v_0_10_2; +-- +ok +== +COPY FROM DATABASE unencrypted TO encrypted; +-- +ok +== +COPY FROM DATABASE v_0_10_2 TO encrypted_v2; +-- +ok +== +DETACH encrypted_v2 +-- +ok +== +SELECT SUM(i) FROM encrypted_v2.tbl +-- +ok +== +ATTACH '{TEST_DIR}/unencrypted_new.duckdb' as unencrypted_new; +-- +ok +== +ATTACH '{TEST_DIR}/unencrypted_v_1_2_0.duckdb' as unencrypted_v_1_2_0 (STORAGE_VERSION 'v1.2.0'); +-- +ok +== +COPY FROM DATABASE encrypted TO unencrypted_new; +-- +ok +== +COPY FROM DATABASE encrypted_v2 TO unencrypted_v_1_2_0; +-- +ok +== +DETACH unencrypted_new +-- +ok +== +DETACH unencrypted_v_1_2_0 +-- +ok +== +ATTACH '{TEST_DIR}/unencrypted_v_1_2_0.duckdb' AS unencrypted_v_1_2_0 (ENCRYPTION_KEY 'asdf'); +-- +ok +== +ATTACH '{TEST_DIR}/unencrypted_v_1_2_0.duckdb' AS unencrypted_v_1_2_0 (STORAGE_VERSION 'v1.0.0'); +-- +ok +== +ATTACH '{TEST_DIR}/unencrypted_v_1_2_0.duckdb' AS unencrypted_v_1_2_0; +-- +ok +== +SELECT tags['storage_version'] FROM duckdb_databases() WHERE database_name='unencrypted_v_1_2_0' +-- +ok +== +ATTACH '{TEST_DIR}/unencrypted_new.duckdb' AS unencrypted_new; +-- +ok +== +SELECT SUM(i) FROM unencrypted_v_1_2_0.tbl; +-- +ok +== +SELECT SUM(i) FROM unencrypted_new.tbl; +-- +ok +== diff --git a/parser/testdata/corpus/sql/copy/encryption/force_mbedtls.test b/parser/testdata/corpus/sql/copy/encryption/force_mbedtls.test new file mode 100644 index 0000000..60bfd6d --- /dev/null +++ b/parser/testdata/corpus/sql/copy/encryption/force_mbedtls.test @@ -0,0 +1,13 @@ +# source: test/sql/copy/encryption/force_mbedtls.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +SET force_mbedtls_unsafe = 'true'; +-- +ok +== +SET force_mbedtls_unsafe = 'false'; +-- +ok +== diff --git a/parser/testdata/corpus/sql/copy/encryption/test_different_encryption_versions.test b/parser/testdata/corpus/sql/copy/encryption/test_different_encryption_versions.test new file mode 100644 index 0000000..6cf4077 --- /dev/null +++ b/parser/testdata/corpus/sql/copy/encryption/test_different_encryption_versions.test @@ -0,0 +1,89 @@ +# source: test/sql/copy/encryption/test_different_encryption_versions.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +ATTACH '{TEST_DIR}/encrypted_invalid.duckdb' AS encrypted_invalid (ENCRYPTION_KEY 'asdf', STORAGE_VERSION 'v1.4.0', debug_encryption_version 'v1'); +-- +ok +== +ATTACH '{TEST_DIR}/encrypted_storage.duckdb' AS encrypted_storage_version (ENCRYPTION_KEY 'asdf', STORAGE_VERSION 'v1.4.0'); +-- +ok +== +SELECT tags['storage_version'] FROM duckdb_databases() WHERE database_name='encrypted_storage_version' +-- +ok +== +ATTACH '{TEST_DIR}/encrypted_v0_0.duckdb' AS encrypted_v0 (ENCRYPTION_KEY 'asdf', debug_encryption_version 'v0'); +-- +ok +== +SELECT tags['storage_version'] FROM duckdb_databases() WHERE database_name='encrypted_v0' +-- +ok +== +ATTACH '{TEST_DIR}/encrypted_v0_1.duckdb' AS encrypted_v1 (ENCRYPTION_KEY 'asdf', debug_encryption_version 'v1'); +-- +ok +== +SELECT tags['storage_version'] FROM duckdb_databases() WHERE database_name='encrypted_v1' +-- +ok +== +ATTACH '{TEST_DIR}/encrypted_error.duckdb' AS encrypted_error (ENCRYPTION_KEY 'asdf', debug_encryption_version 'v2'); +-- +ok +== +USE unencrypted; +-- +ok +== +CALL dbgen(sf=0.01); +-- +ok +== +COPY FROM DATABASE unencrypted to encrypted_storage_version; +-- +ok +== +COPY FROM DATABASE unencrypted to encrypted_v0; +-- +ok +== +COPY FROM DATABASE unencrypted to encrypted_v1; +-- +ok +== +ATTACH '{TEST_DIR}/not_relevant.duckdb' AS other; +-- +ok +== +DETACH encrypted_storage_version; +-- +ok +== +DETACH encrypted_v0 +-- +ok +== +DETACH encrypted_v1 +-- +ok +== +ATTACH '{TEST_DIR}/encrypted_storage.duckdb' AS encrypted_storage_version (ENCRYPTION_KEY 'asdf', debug_encryption_version 'v1'); +-- +ok +== +ATTACH '{TEST_DIR}/encrypted_v0_1.duckdb' AS encrypted_v1 (ENCRYPTION_KEY 'asdf', debug_encryption_version 'v0'); +-- +ok +== +SELECT l_suppkey FROM encrypted_v0.lineitem limit 10; +-- +ok +== +SELECT l_suppkey FROM encrypted_v1.lineitem limit 10; +-- +ok +== diff --git a/parser/testdata/corpus/sql/copy/encryption/unencrypted_to_encrypted.test b/parser/testdata/corpus/sql/copy/encryption/unencrypted_to_encrypted.test new file mode 100644 index 0000000..ca710d2 --- /dev/null +++ b/parser/testdata/corpus/sql/copy/encryption/unencrypted_to_encrypted.test @@ -0,0 +1,13 @@ +# source: test/sql/copy/encryption/unencrypted_to_encrypted.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +COPY FROM DATABASE unencrypted to encrypted; +-- +ok +== +SELECT l_suppkey FROM encrypted.lineitem limit 10; +-- +ok +== diff --git a/parser/testdata/corpus/sql/copy/encryption/unencrypted_to_encrypted_direct_query.test b/parser/testdata/corpus/sql/copy/encryption/unencrypted_to_encrypted_direct_query.test new file mode 100644 index 0000000..9479c3f --- /dev/null +++ b/parser/testdata/corpus/sql/copy/encryption/unencrypted_to_encrypted_direct_query.test @@ -0,0 +1,9 @@ +# source: test/sql/copy/encryption/unencrypted_to_encrypted_direct_query.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +SELECT SUM(i) FROM encrypted.tbl; +-- +ok +== diff --git a/parser/testdata/corpus/sql/copy/encryption/write_encrypted_database.test b/parser/testdata/corpus/sql/copy/encryption/write_encrypted_database.test new file mode 100644 index 0000000..d07e7db --- /dev/null +++ b/parser/testdata/corpus/sql/copy/encryption/write_encrypted_database.test @@ -0,0 +1,9 @@ +# source: test/sql/copy/encryption/write_encrypted_database.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +ATTACH '{TEST_DIR}/encrypted.duckdb' AS encrypted (ENCRYPTION_KEY 'xxxxx'); +-- +ok +== diff --git a/parser/testdata/corpus/sql/copy/file_size_bytes.test b/parser/testdata/corpus/sql/copy/file_size_bytes.test new file mode 100644 index 0000000..935312a --- /dev/null +++ b/parser/testdata/corpus/sql/copy/file_size_bytes.test @@ -0,0 +1,142 @@ +# source: test/sql/copy/file_size_bytes.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +CREATE TABLE bigdata AS SELECT i AS col_a, i AS col_b FROM range(0,10_000) tbl(i); +-- +ok +== +COPY (FROM bigdata) TO '{TEST_DIR}/file_size_bytes_csv1' (FORMAT CSV, FILE_SIZE_BYTES 1_000); +-- +ok +== +SELECT COUNT(*) FROM read_csv_auto('{TEST_DIR}/file_size_bytes_csv1/*.csv') +-- +ok +== +SELECT count(*) FROM glob('{TEST_DIR}/file_size_bytes_csv1/*.csv') +-- +ok +== +COPY (FROM bigdata) TO '{TEST_DIR}/file_size_bytes_csv2' (FORMAT CSV, FILE_SIZE_BYTES '1kb'); +-- +ok +== +SELECT COUNT(*) FROM read_csv_auto('{TEST_DIR}/file_size_bytes_csv2/*.csv') +-- +ok +== +SELECT count(*) FROM glob('{TEST_DIR}/file_size_bytes_csv2/*.csv') +-- +ok +== +COPY (FROM bigdata) TO '{TEST_DIR}/file_size_bytes_json' (FORMAT JSON, FILE_SIZE_BYTES '1kb'); +-- +ok +== +SELECT COUNT(*) FROM read_json_auto('{TEST_DIR}/file_size_bytes_json/*.json') +-- +ok +== +SELECT count(*) >= 3 and count(*) <= 12 FROM glob('{TEST_DIR}/file_size_bytes_json/*.json') +-- +ok +== +COPY (SELECT hash(col_a)::DOUBLE, hash(col_b)::DOUBLE FROM bigdata) TO '{TEST_DIR}/file_size_bytes_parquet' (FORMAT PARQUET, ROW_GROUP_SIZE 2000, FILE_SIZE_BYTES '1kb'); +-- +ok +== +SELECT COUNT(*) FROM read_parquet('{TEST_DIR}/file_size_bytes_parquet/*.parquet') +-- +ok +== +SELECT count(*) FROM glob('{TEST_DIR}/file_size_bytes_parquet/*.parquet') +-- +ok +== +INSERT INTO bigdata SELECT bigdata.* FROM bigdata, range(9) +-- +ok +== +pragma threads=4; +-- +ok +== +COPY (FROM bigdata) TO '{TEST_DIR}/file_size_bytes_csv3' (FORMAT CSV, FILE_SIZE_BYTES '500kb'); +-- +ok +== +SELECT COUNT(*) FROM read_csv_auto('{TEST_DIR}/file_size_bytes_csv3/*.csv') +-- +ok +== +SELECT count(*) FROM glob('{TEST_DIR}/file_size_bytes_csv3/*.csv') +-- +ok +== +COPY (FROM bigdata) TO '{TEST_DIR}/file_size_bytes_csv4' (FORMAT CSV, FILE_SIZE_BYTES '200kb'); +-- +ok +== +SELECT COUNT(*) FROM read_csv_auto('{TEST_DIR}/file_size_bytes_csv4/*.csv') +-- +ok +== +SELECT count(*) BETWEEN 3 AND 5 FROM glob('{TEST_DIR}/file_size_bytes_csv4/*.csv') +-- +ok +== +COPY (FROM bigdata) TO '{TEST_DIR}/file_size_bytes_csv5' (FORMAT CSV, FILE_SIZE_BYTES '700kb', PER_THREAD_OUTPUT TRUE); +-- +ok +== +SELECT COUNT(*) FROM read_csv_auto('{TEST_DIR}/file_size_bytes_csv5/*.csv') +-- +ok +== +SELECT count(*) > 1 FROM glob('{TEST_DIR}/file_size_bytes_csv5/*.csv') +-- +ok +== +COPY (FROM bigdata) TO '{TEST_DIR}/file_size_bytes_csv6' (FORMAT CSV, FILE_SIZE_BYTES '190kb', PER_THREAD_OUTPUT TRUE); +-- +ok +== +SELECT COUNT(*) FROM read_csv_auto('{TEST_DIR}/file_size_bytes_csv6/*.csv') +-- +ok +== +SELECT count(*) BETWEEN 5 AND 10 FROM glob('{TEST_DIR}/file_size_bytes_csv6/*.csv') +-- +ok +== +COPY (FROM bigdata) TO '{TEST_DIR}/file_size_bytes_csv7' (FORMAT CSV, FILE_SIZE_BYTES '190kb', USE_TMP_FILE TRUE); +-- +ok +== +COPY (SELECT col_a % 4 AS p, col_a, col_b FROM bigdata) +TO '{TEST_DIR}/file_size_bytes_csv_partitioned' +(FORMAT CSV, FILE_SIZE_BYTES '50kb', PARTITION_BY (p)); +-- +ok +== +SELECT count(*) +FROM read_csv_auto('{TEST_DIR}/file_size_bytes_csv_partitioned/**/*.csv', hive_partitioning = true); +-- +ok +== +WITH files AS ( + SELECT p, count(DISTINCT filename) file_count + FROM read_csv_auto( + '{TEST_DIR}/file_size_bytes_csv_partitioned/**/*.csv', + filename = true, + hive_partitioning = true + ) + GROUP BY p +) +SELECT count(*) = 4 AND min(file_count) > 1 +FROM files; +-- +ok +== diff --git a/parser/testdata/corpus/sql/copy/format_uuid.test b/parser/testdata/corpus/sql/copy/format_uuid.test new file mode 100644 index 0000000..972bbfb --- /dev/null +++ b/parser/testdata/corpus/sql/copy/format_uuid.test @@ -0,0 +1,173 @@ +# source: test/sql/copy/format_uuid.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +CREATE TABLE test2 as SELECT i as a, (i*2) as b, power(i,2) as c from range(0,10) tbl(i); +-- +ok +== +CREATE TABLE test3 as SELECT i as a, (i*3) as b, power(i,3) as c from range(0,10) tbl(i); +-- +ok +== +CREATE TABLE test4 as SELECT i as a, (i*4) as b, power(i,4) as c from range(0,10) tbl(i); +-- +ok +== +CREATE TABLE test5 as SELECT i as a, (i*5) as b, power(i,5) as c from range(0,10) tbl(i); +-- +ok +== +CREATE TABLE testpto as SELECT i as a, (i*10) as b, (i*100) as c from range(0,10000) tbl(i); +-- +ok +== +SELECT * FROM test2; +-- +ok +== +COPY test2 TO '{TEST_DIR}/part' (FORMAT PARQUET, PARTITION_BY (a), FILENAME_PATTERN "leading_{uuid}"); +-- +ok +== +SELECT * FROM '{TEST_DIR}/part/a=9/leading_????????-????-4???-????-????????????.parquet'; +-- +ok +== +COPY test2 TO '{TEST_DIR}/trailing' (FORMAT PARQUET, PARTITION_BY (a), FILENAME_PATTERN "{uuid}_trailing"); +-- +ok +== +SELECT * FROM '{TEST_DIR}/trailing/a=9/????????-????-4???-????-????????????_trailing.parquet'; +-- +ok +== +COPY test2 TO '{TEST_DIR}/only_offset' (FORMAT PARQUET, PARTITION_BY (a), FILENAME_PATTERN "{i}"); +-- +ok +== +SELECT * FROM '{TEST_DIR}/only_offset/a=9/?.parquet'; +-- +ok +== +COPY test3 TO '{TEST_DIR}/part' (FORMAT PARQUET, PARTITION_BY (a), overwrite_or_ignore TRUE, FILENAME_PATTERN "leading_{uuid}_trailing"); +-- +ok +== +SELECT * FROM '{TEST_DIR}/part/a=9/leading_????????-????-4???-????-????????????_trailing.parquet'; +-- +ok +== +SELECT * FROM '{TEST_DIR}/part/a=9/leading_????????-????-4???-????-????????????*.parquet'; +-- +ok +== +COPY test4 TO '{TEST_DIR}/part' (FORMAT PARQUET, PARTITION_BY (a), overwrite_or_ignore TRUE); +-- +ok +== +SELECT * FROM '{TEST_DIR}/part/a=9/data_[0-9]*.parquet'; +-- +ok +== +SELECT * FROM '{TEST_DIR}/part/a=9/*.parquet'; +-- +ok +== +COPY test5 TO '{TEST_DIR}/part' (FORMAT PARQUET, PARTITION_BY (a), overwrite_or_ignore TRUE, FILENAME_PATTERN "basename"); +-- +ok +== +SELECT * FROM '{TEST_DIR}/part/a=9/basename[0-9]*.parquet'; +-- +ok +== +COPY test5 TO '{TEST_DIR}/part' (FORMAT PARQUET, PARTITION_BY (a)); +-- +ok +== +COPY test4 TO '{TEST_DIR}/to_be_overwritten' (FORMAT PARQUET, PARTITION_BY (a), FILENAME_PATTERN); +-- +ok +== +COPY test4 TO '{TEST_DIR}/to_be_overwritten' (FORMAT PARQUET, PARTITION_BY (a), FILENAME_PATTERN a_file_name); +-- +ok +== +SELECT COUNT(*) FROM GLOB('{TEST_DIR}/to_be_overwritten/a=9/a_file_name*'); +-- +ok +== +SELECT * FROM '{TEST_DIR}/to_be_overwritten/a=9/a_file_name*.parquet'; +-- +ok +== +COPY test5 TO '{TEST_DIR}/incorrect_pos' (FORMAT PARQUET, PARTITION_BY (a), filename_pattern "a_name{i}_with_{uuid}_numbers"); +-- +ok +== +SELECT * FROM '{TEST_DIR}/incorrect_pos/a=5/a_name?_with_????????-????-4???-????-????????????_numbers.parquet'; +-- +ok +== +COPY test5 TO '{TEST_DIR}/uuid_v7' (FORMAT PARQUET, PARTITION_BY (a), filename_pattern "a_name_with_{uuidv7}"); +-- +ok +== +SELECT * FROM '{TEST_DIR}/uuid_v7/a=5/a_name_with_????????-????-7???-????-????????????.parquet'; +-- +ok +== +COPY test5 TO '{TEST_DIR}/mixed_uuid_types' (FORMAT PARQUET, PARTITION_BY (a), filename_pattern "a_name{uuid}_with_{uuidv7}_numbers"); +-- +ok +== +SELECT * FROM '{TEST_DIR}/mixed_uuid_types/a=5/a_name????????-????-4???-????-????????????_with_????????-????-7???-????-????????????_numbers.parquet'; +-- +ok +== +COPY testpto TO '{TEST_DIR}/pto' (FORMAT PARQUET, PER_THREAD_OUTPUT TRUE, OVERWRITE_OR_IGNORE TRUE, FILENAME_PATTERN "basename_{uuid}"); +-- +ok +== +SELECT COUNT(*) FROM '{TEST_DIR}/pto/basename_????????-????-4???-????-????????????.parquet'; +-- +ok +== +SELECT COUNT(*) >= 1 FROM GLOB('{TEST_DIR}/pto/basename_????????-????-4???-????-????????????.parquet'); +-- +ok +== +PRAGMA threads=1; +-- +ok +== +COPY test5 TO '{TEST_DIR}/to_be_overwritten2' (FORMAT PARQUET, PARTITION_BY (a), OVERWRITE_OR_IGNORE); +-- +ok +== +SELECT COUNT(*) FROM GLOB('{TEST_DIR}/to_be_overwritten2/a=9/*'); +-- +ok +== +SELECT * FROM '{TEST_DIR}/to_be_overwritten2/a=9/data_0*.parquet'; +-- +ok +== +COPY test5 TO '{TEST_DIR}/directory0' (FORMAT PARQUET, PARTITION_BY (a), overwrite_or_ignore TRUE, FILENAME_PATTERN "my_filename"); +-- +ok +== +SELECT COUNT(*) FROM GLOB('{TEST_DIR}/directory0/a=7/*'); +-- +ok +== +SELECT * FROM '{TEST_DIR}/directory0/a=7/my_filename0.parquet'; +-- +ok +== +COPY test5 TO '{TEST_DIR}/to_be_overwritten2' (FORMAT PARQUET, PARTITION_BY (a), OVERWRITE_OR_IGNORE, WRITE_PARTITION_COLUMNS); +-- +ok +== diff --git a/parser/testdata/corpus/sql/copy/hive_partition_null_overwrite.test b/parser/testdata/corpus/sql/copy/hive_partition_null_overwrite.test new file mode 100644 index 0000000..42da691 --- /dev/null +++ b/parser/testdata/corpus/sql/copy/hive_partition_null_overwrite.test @@ -0,0 +1,11 @@ +# source: test/sql/copy/hive_partition_null_overwrite.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +COPY (SELECT * FROM read_csv_auto('{DATA_DIR}/csv/null/hive_partition_null_overwrite.csv')) +TO '{TEST_DIR}/repro_min' +(FORMAT csv, PARTITION_BY (symbol, year, month), OVERWRITE); +-- +ok +== diff --git a/parser/testdata/corpus/sql/copy/parquet/afl.test b/parser/testdata/corpus/sql/copy/parquet/afl.test new file mode 100644 index 0000000..c458465 --- /dev/null +++ b/parser/testdata/corpus/sql/copy/parquet/afl.test @@ -0,0 +1,13 @@ +# source: test/sql/copy/parquet/afl.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +select * from parquet_scan('{DATA_DIR}/parquet-testing/afl/{i}.parquet') +-- +ok +== +select * from parquet_scan('{DATA_DIR}/parquet-testing/afl/3.parquet') +-- +ok +== diff --git a/parser/testdata/corpus/sql/copy/parquet/allow_empty.test b/parser/testdata/corpus/sql/copy/parquet/allow_empty.test new file mode 100644 index 0000000..fe348f5 --- /dev/null +++ b/parser/testdata/corpus/sql/copy/parquet/allow_empty.test @@ -0,0 +1,71 @@ +# source: test/sql/copy/parquet/allow_empty.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +SELECT * FROM read_parquet(['{TEST_DIR}/allow_empty_missing.parquet']); +-- +ok +== +SELECT column_name, column_type +FROM (DESCRIBE SELECT * FROM read_parquet(['{TEST_DIR}/allow_empty_missing.parquet'], allow_empty = true)); +-- +ok +== +SELECT count(*) FROM read_parquet(['{TEST_DIR}/allow_empty_missing.parquet'], allow_empty = true); +-- +ok +== +COPY allow_empty_source TO '{TEST_DIR}/allow_empty.parquet' (FORMAT PARQUET); +-- +ok +== +SELECT * FROM read_parquet(['{TEST_DIR}/allow_empty.parquet'], allow_empty = true) ORDER BY id; +-- +ok +== +COPY (SELECT id, payload, 'active' AS partition_key FROM allow_empty_source) TO '{TEST_DIR}/allow_empty_hive' (FORMAT PARQUET, PARTITION_BY (partition_key)); +-- +ok +== +SELECT id, payload, partition_key +FROM read_parquet(['{TEST_DIR}/allow_empty_hive/**/*.parquet'], hive_partitioning = true, allow_empty = true) +ORDER BY id; +-- +ok +== +SELECT id, payload, partition_key +FROM read_parquet('{TEST_DIR}/allow_empty_hive', hive_partitioning = true, allow_empty = true) +ORDER BY id; +-- +ok +== +SELECT column_name, column_type +FROM (DESCRIBE SELECT * FROM read_parquet(['{TEST_DIR}/allow_empty_hive/partition_key=missing/*.parquet'], hive_partitioning = true, allow_empty = true)); +-- +ok +== +SELECT column_name, column_type +FROM ( + DESCRIBE SELECT id, payload + FROM ( + SELECT * FROM read_parquet(['{TEST_DIR}/allow_empty_missing/*.parquet'], allow_empty = true) + UNION BY NAME + (SELECT 1::INTEGER AS id, 'schema'::VARCHAR AS payload LIMIT 0) + ) +); +-- +ok +== +SELECT count(*) +FROM ( + SELECT id, payload + FROM ( + SELECT * FROM read_parquet(['{TEST_DIR}/allow_empty_missing/*.parquet'], allow_empty = true) + UNION BY NAME + (SELECT 1::INTEGER AS id, 'schema'::VARCHAR AS payload LIMIT 0) + ) +); +-- +ok +== diff --git a/parser/testdata/corpus/sql/copy/parquet/alltypes-dictionaries.test b/parser/testdata/corpus/sql/copy/parquet/alltypes-dictionaries.test new file mode 100644 index 0000000..f47d659 --- /dev/null +++ b/parser/testdata/corpus/sql/copy/parquet/alltypes-dictionaries.test @@ -0,0 +1,53 @@ +# source: test/sql/copy/parquet/alltypes-dictionaries.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +copy (select (r1.range * 10)::{type} r from range(10) r1, range(1000) r2) to '{TEST_DIR}/dict-{type}.parquet' (row_group_size 2048); +-- +error: Parser Error: syntax error at or near "{" +== +select first(encodings) from parquet_metadata('{TEST_DIR}/dict-{type}.parquet') group by encodings; +-- +ok +== +SELECT COUNT(*) from '{TEST_DIR}/dict-{type}.parquet' WHERE r='20' +-- +ok +== +select column_id, BOOL_AND(bloom_filter_offset > 4), BOOL_AND(bloom_filter_length > 1) from parquet_metadata('{TEST_DIR}/dict-{type}.parquet') group by column_id order by column_id; +-- +ok +== +copy (select (r1.range * 10)::{type} r from range(10) r1, range(1000) r2) to '{TEST_DIR}/dict-{type}-v1.parquet' (row_group_size 2048, parquet_version v1); +-- +error: Parser Error: syntax error at or near "{" +== +select first(encodings) from parquet_metadata('{TEST_DIR}/dict-{type}-v1.parquet') group by encodings; +-- +ok +== +SELECT COUNT(*) from '{TEST_DIR}/dict-{type}-v1.parquet' WHERE r='20' +-- +ok +== +select column_id, BOOL_AND(bloom_filter_offset > 4), BOOL_AND(bloom_filter_length > 1) from parquet_metadata('{TEST_DIR}/dict-{type}-v1.parquet') group by column_id order by column_id; +-- +ok +== +copy (select (r1.range * 10)::{type} r from range(10) r1, range(1000) r2) to '{TEST_DIR}/dict-{type}-v2.parquet' (row_group_size 2048, parquet_version v2); +-- +error: Parser Error: syntax error at or near "{" +== +select first(encodings) from parquet_metadata('{TEST_DIR}/dict-{type}-v2.parquet') group by encodings; +-- +ok +== +SELECT COUNT(*) from '{TEST_DIR}/dict-{type}-v2.parquet' WHERE r='20' +-- +ok +== +select column_id, BOOL_AND(bloom_filter_offset > 4), BOOL_AND(bloom_filter_length > 1) from parquet_metadata('{TEST_DIR}/dict-{type}-v2.parquet') group by column_id order by column_id; +-- +ok +== diff --git a/parser/testdata/corpus/sql/copy/parquet/attach_parquet.test b/parser/testdata/corpus/sql/copy/parquet/attach_parquet.test new file mode 100644 index 0000000..4e034f1 --- /dev/null +++ b/parser/testdata/corpus/sql/copy/parquet/attach_parquet.test @@ -0,0 +1,29 @@ +# source: test/sql/copy/parquet/attach_parquet.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +COPY (SELECT 42 val) TO '{TEST_DIR}/file.parquet'; +-- +ok +== +ATTACH '{TEST_DIR}/file.parquet' AS attached_parquet +-- +ok +== +USE attached_parquet +-- +ok +== +SELECT * FROM file +-- +ok +== +SELECT * FROM attached_parquet +-- +ok +== +ATTACH 'duckdb:{TEST_DIR}/file.parquet' AS duck_attach +-- +ok +== diff --git a/parser/testdata/corpus/sql/copy/parquet/auto_glob_directory.test b/parser/testdata/corpus/sql/copy/parquet/auto_glob_directory.test new file mode 100644 index 0000000..e74d1ea --- /dev/null +++ b/parser/testdata/corpus/sql/copy/parquet/auto_glob_directory.test @@ -0,0 +1,13 @@ +# source: test/sql/copy/parquet/auto_glob_directory.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +COPY (SELECT i%2 AS grp, i FROM range(1000) t(i)) TO '{TEST_DIR}/partitioned_glob.parquet' (PARTITION_BY (grp)); +-- +ok +== +SELECT grp, COUNT(*) FROM '{TEST_DIR}/partitioned_glob.parquet' GROUP BY ALL ORDER BY ALL +-- +ok +== diff --git a/parser/testdata/corpus/sql/copy/parquet/aws2.test b/parser/testdata/corpus/sql/copy/parquet/aws2.test new file mode 100644 index 0000000..9fcc227 --- /dev/null +++ b/parser/testdata/corpus/sql/copy/parquet/aws2.test @@ -0,0 +1,9 @@ +# source: test/sql/copy/parquet/aws2.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +SELECT * FROM '{DATA_DIR}/parquet-testing/aws2.parquet' +-- +ok +== diff --git a/parser/testdata/corpus/sql/copy/parquet/aws_kinesis.test b/parser/testdata/corpus/sql/copy/parquet/aws_kinesis.test new file mode 100644 index 0000000..fd75d6b --- /dev/null +++ b/parser/testdata/corpus/sql/copy/parquet/aws_kinesis.test @@ -0,0 +1,13 @@ +# source: test/sql/copy/parquet/aws_kinesis.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +SELECT * FROM '{DATA_DIR}/parquet-testing/aws_kinesis.parquet' +-- +ok +== +SELECT * FROM '{DATA_DIR}/parquet-testing/aws_kinesis.parquet' WHERE event_timestamp=TIMESTAMP '2022-11-22 00:01:13.175'; +-- +ok +== diff --git a/parser/testdata/corpus/sql/copy/parquet/bigdecimal.test b/parser/testdata/corpus/sql/copy/parquet/bigdecimal.test new file mode 100644 index 0000000..44aaa4b --- /dev/null +++ b/parser/testdata/corpus/sql/copy/parquet/bigdecimal.test @@ -0,0 +1,9 @@ +# source: test/sql/copy/parquet/bigdecimal.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +FROM '{DATA_DIR}/parquet-testing/bigdecimal.parquet' +-- +ok +== diff --git a/parser/testdata/corpus/sql/copy/parquet/bloom_filter_decimal.test b/parser/testdata/corpus/sql/copy/parquet/bloom_filter_decimal.test new file mode 100644 index 0000000..a9f99be --- /dev/null +++ b/parser/testdata/corpus/sql/copy/parquet/bloom_filter_decimal.test @@ -0,0 +1,59 @@ +# source: test/sql/copy/parquet/bloom_filter_decimal.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +COPY ( + SELECT + (2 * (i % 2048))::DECIMAL(18,2) AS dec_int64, + (2 * (i % 50))::DECIMAL(4,2) AS dec_int32, + i + FROM range(8192) t(i) +) TO '{TEST_DIR}/bloom_decimal.parquet' ( + FORMAT parquet, + ROW_GROUP_SIZE 2048, + DICTIONARY_SIZE_LIMIT 4096, + BLOOM_FILTER_FALSE_POSITIVE_RATIO 0.0001 +); +-- +ok +== +SELECT column_id, BOOL_AND(bloom_filter_offset > 4), BOOL_AND(bloom_filter_length > 1) +FROM parquet_metadata('{TEST_DIR}/bloom_decimal.parquet') +WHERE column_id IN (0, 1) +GROUP BY column_id +ORDER BY column_id; +-- +ok +== +SELECT BOOL_AND(NOT bloom_filter_excludes) +FROM parquet_bloom_probe('{TEST_DIR}/bloom_decimal.parquet', 'dec_int64', 0.00::DECIMAL(18,2)); +-- +ok +== +SELECT BOOL_AND(bloom_filter_excludes) +FROM parquet_bloom_probe('{TEST_DIR}/bloom_decimal.parquet', 'dec_int64', 1.00::DECIMAL(18,2)); +-- +ok +== +SELECT BOOL_AND(NOT bloom_filter_excludes) +FROM parquet_bloom_probe('{TEST_DIR}/bloom_decimal.parquet', 'dec_int32', 0.00::DECIMAL(4,2)); +-- +ok +== +SELECT count(*) FROM '{TEST_DIR}/bloom_decimal.parquet' WHERE dec_int64 = 1.00::DECIMAL(18,2); +-- +ok +== +SELECT count(*) FROM '{TEST_DIR}/bloom_decimal.parquet' WHERE dec_int64 = 0.00::DECIMAL(18,2); +-- +ok +== +SELECT count(*) FROM '{TEST_DIR}/bloom_decimal.parquet' WHERE dec_int32 = 1.00::DECIMAL(4,2); +-- +ok +== +SELECT count(*) FROM '{TEST_DIR}/bloom_decimal.parquet' WHERE dec_int32 = 0.00::DECIMAL(4,2); +-- +ok +== diff --git a/parser/testdata/corpus/sql/copy/parquet/bloom_filter_interval.test b/parser/testdata/corpus/sql/copy/parquet/bloom_filter_interval.test new file mode 100644 index 0000000..fbd3057 --- /dev/null +++ b/parser/testdata/corpus/sql/copy/parquet/bloom_filter_interval.test @@ -0,0 +1,145 @@ +# source: test/sql/copy/parquet/bloom_filter_interval.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +COPY ( + SELECT + ((i % 100) * 2) * INTERVAL '1 day' AS iv, + i::BIGINT AS payload + FROM range(20480) t(i) +) TO '{TEST_DIR}/bloom_interval.parquet' ( + FORMAT PARQUET, + ROW_GROUP_SIZE 2048, + DICTIONARY_SIZE_LIMIT 1000, + BLOOM_FILTER_FALSE_POSITIVE_RATIO 0.0001 +); +-- +ok +== +SELECT count(*) +FROM parquet_kv_metadata('{TEST_DIR}/bloom_interval.parquet') +WHERE key = 'duckdb.interval_bloom_filter' + AND decode(value) = 'normalized-v1'; +-- +ok +== +SELECT BOOL_AND(bloom_filter_excludes) +FROM parquet_bloom_probe('{TEST_DIR}/bloom_interval.parquet', 'iv', INTERVAL '101 days'); +-- +ok +== +EXPLAIN ANALYZE +SELECT sum(payload) +FROM read_parquet('{TEST_DIR}/bloom_interval.parquet') +WHERE iv = INTERVAL '101 days'; +-- +ok +== +EXPLAIN ANALYZE +SELECT sum(payload) +FROM read_parquet('{TEST_DIR}/bloom_interval.parquet') +WHERE iv IN (INTERVAL '101 days', INTERVAL '103 days'); +-- +ok +== +COPY ( + SELECT + [((i % 100) * 2) * INTERVAL '1 day'] AS iv_list, + {'iv': ((i % 100) * 2) * INTERVAL '1 day'} AS iv_struct, + i::BIGINT AS payload + FROM range(20480) t(i) +) TO '{TEST_DIR}/bloom_interval_nested.parquet' ( + FORMAT PARQUET, + ROW_GROUP_SIZE 2048, + DICTIONARY_SIZE_LIMIT 1000, + BLOOM_FILTER_FALSE_POSITIVE_RATIO 0.0001 +); +-- +ok +== +SELECT count(*) +FROM parquet_kv_metadata('{TEST_DIR}/bloom_interval_nested.parquet') +WHERE key = 'duckdb.interval_bloom_filter' + AND decode(value) = 'normalized-v1'; +-- +ok +== +EXPLAIN ANALYZE +SELECT sum(payload) +FROM read_parquet('{TEST_DIR}/bloom_interval_nested.parquet') +WHERE iv_list[1] = INTERVAL '101 days'; +-- +ok +== +EXPLAIN ANALYZE +SELECT sum(payload) +FROM read_parquet('{TEST_DIR}/bloom_interval_nested.parquet') +WHERE iv_struct.iv = INTERVAL '101 days'; +-- +ok +== +COPY ( + SELECT + iv, + [iv] AS iv_list, + {'iv': iv} AS iv_struct + FROM ( + SELECT CASE i % 4 + WHEN 0 THEN INTERVAL '101 days' + WHEN 1 THEN INTERVAL '3 months 11 days' + WHEN 2 THEN INTERVAL '1 day' + ELSE INTERVAL '24 hours' + END AS iv + FROM range(4096) t(i) + ) +) TO '{TEST_DIR}/bloom_interval_equivalent.parquet' ( + FORMAT PARQUET, + ROW_GROUP_SIZE 2048, + DICTIONARY_SIZE_LIMIT 1000, + BLOOM_FILTER_FALSE_POSITIVE_RATIO 0.0001 +); +-- +ok +== +SELECT count(*) +FROM read_parquet('{TEST_DIR}/bloom_interval_equivalent.parquet') +WHERE iv = INTERVAL '101 days'; +-- +ok +== +SELECT count(*) +FROM read_parquet('{TEST_DIR}/bloom_interval_equivalent.parquet') +WHERE iv_list[1] = INTERVAL '101 days'; +-- +ok +== +SELECT count(*) +FROM read_parquet('{TEST_DIR}/bloom_interval_equivalent.parquet') +WHERE iv_struct.iv = INTERVAL '101 days'; +-- +ok +== +SELECT count(*) +FROM read_parquet('{TEST_DIR}/bloom_interval_equivalent.parquet') +WHERE iv = INTERVAL '1 day'; +-- +ok +== +SELECT count(*) +FROM read_parquet('{TEST_DIR}/bloom_interval_equivalent.parquet') +WHERE iv_list[1] = INTERVAL '1 day'; +-- +ok +== +SELECT count(*) +FROM read_parquet('{TEST_DIR}/bloom_interval_equivalent.parquet') +WHERE iv_struct.iv = INTERVAL '1 day'; +-- +ok +== +SELECT BOOL_AND(NOT bloom_filter_excludes) +FROM parquet_bloom_probe('{TEST_DIR}/bloom_interval_equivalent.parquet', 'iv', INTERVAL '101 days'); +-- +ok +== diff --git a/parser/testdata/corpus/sql/copy/parquet/bloom_filters.test b/parser/testdata/corpus/sql/copy/parquet/bloom_filters.test new file mode 100644 index 0000000..8b8c037 --- /dev/null +++ b/parser/testdata/corpus/sql/copy/parquet/bloom_filters.test @@ -0,0 +1,724 @@ +# source: test/sql/copy/parquet/bloom_filters.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +copy (select + (r1.range*10)::BIGINT r, + r::smallint r_int16, + r::integer r_int32, + r::double r_double, + r::float r_float, + 'string_' || r::VARCHAR r_string, + ('blob_' || r::VARCHAR)::BLOB r_blob +from range(100) r1, range(1000) order by r) to '{TEST_DIR}/bloom1.parquet' (format parquet, ROW_GROUP_SIZE 10000, dictionary_size_limit 1000); +-- +ok +== +select column_id, BOOL_AND(bloom_filter_offset > 4), BOOL_AND(bloom_filter_length > 1) from parquet_metadata('{TEST_DIR}/bloom1.parquet') group by column_id order by column_id; +-- +ok +== +SELECT BOOL_AND(bloom_filter_excludes) FROM parquet_bloom_probe('{TEST_DIR}/bloom1.parquet', 'r', '201'); +-- +ok +== +EXPLAIN ANALYZE SELECT count(*) FROM '{TEST_DIR}/bloom1.parquet' WHERE greatest(r, r) = 201; +-- +ok +== +EXPLAIN ANALYZE SELECT count(*) FROM '{TEST_DIR}/bloom1.parquet' WHERE r = 201; +-- +ok +== +EXPLAIN ANALYZE SELECT count(*) FROM '{TEST_DIR}/bloom1.parquet' WHERE r BETWEEN 201 AND 201; +-- +ok +== +EXPLAIN ANALYZE SELECT count(*) FROM '{TEST_DIR}/bloom1.parquet' WHERE least(r, r) = 201; +-- +ok +== +EXPLAIN ANALYZE SELECT count(*) FROM '{TEST_DIR}/bloom1.parquet' WHERE r IS NOT DISTINCT FROM 201; +-- +ok +== +EXPLAIN ANALYZE SELECT count(*) FROM '{TEST_DIR}/bloom1.parquet' WHERE r >= 201 AND r <= 201; +-- +ok +== +COPY ( + SELECT + ((i % 100) * 2)::INTEGER AS r, + i::BIGINT AS payload + FROM range(20480) t(i) +) TO '{TEST_DIR}/bloom_in.parquet' ( + FORMAT PARQUET, + ROW_GROUP_SIZE 2048, + WRITE_BLOOM_FILTER TRUE +); +-- +ok +== +EXPLAIN ANALYZE +SELECT sum(payload) +FROM read_parquet('{TEST_DIR}/bloom_in.parquet') +WHERE r IN (101, 103); +-- +ok +== +EXPLAIN ANALYZE +SELECT sum(payload) +FROM read_parquet('{TEST_DIR}/bloom_in.parquet') +WHERE r = 101 OR r = 103; +-- +ok +== +EXPLAIN ANALYZE +SELECT count(*) +FROM read_parquet('{TEST_DIR}/bloom_in.parquet') +WHERE r IN (100, 103); +-- +ok +== +SELECT count(*) +FROM read_parquet('{TEST_DIR}/bloom_in.parquet') +WHERE r IN (100, 103); +-- +ok +== +SELECT BOOL_AND(bloom_filter_excludes) FROM parquet_bloom_probe('{TEST_DIR}/bloom1.parquet', 'r', '112121212'); +-- +ok +== +COPY ( + SELECT + [v, v + 2] AS list_value, + [[[v, v + 2]]] AS deep_list, + { + 'level_1': {'level_2': {'value': v}} + } AS struct_value, + i::BIGINT AS payload + FROM ( + SELECT i, ((i % 100) * 2)::INTEGER AS v + FROM range(20480) t(i) + ) data +) TO '{TEST_DIR}/bloom_list.parquet' ( + FORMAT PARQUET, + ROW_GROUP_SIZE 2048, + DICTIONARY_SIZE_LIMIT 1000, + WRITE_BLOOM_FILTER TRUE +); +-- +ok +== +COPY ( + SELECT + printf('00000000-0000-0000-0000-%012d', (i % 100) * 2)::UUID AS u, + i::BIGINT AS payload + FROM range(20480) t(i) +) TO '{TEST_DIR}/bloom_uuid.parquet' ( + FORMAT PARQUET, + ROW_GROUP_SIZE 2048, + DICTIONARY_SIZE_LIMIT 1000, + WRITE_BLOOM_FILTER TRUE +); +-- +ok +== +SELECT count(*) +FROM read_parquet('{TEST_DIR}/bloom_list.parquet') +WHERE list_value[1] = 101; +-- +ok +== +EXPLAIN ANALYZE +SELECT list_value, payload +FROM read_parquet('{TEST_DIR}/bloom_list.parquet') +WHERE list_value[1] = 101; +-- +ok +== +SELECT count(*) +FROM read_parquet('{TEST_DIR}/bloom_list.parquet') +WHERE list_extract(list_value, 1) = 101; +-- +ok +== +EXPLAIN ANALYZE +SELECT list_value, payload +FROM read_parquet('{TEST_DIR}/bloom_list.parquet') +WHERE list_extract(list_value, 1) = 101; +-- +ok +== +SELECT count(*) +FROM read_parquet('{TEST_DIR}/bloom_list.parquet') +WHERE list_value[1] IN (101, 103); +-- +ok +== +EXPLAIN ANALYZE +SELECT list_value, payload +FROM read_parquet('{TEST_DIR}/bloom_list.parquet') +WHERE list_value[1] IN (101, 103); +-- +ok +== +SELECT count(*) +FROM read_parquet('{TEST_DIR}/bloom_list.parquet') +WHERE list_value[1] IN (101, NULL); +-- +ok +== +EXPLAIN ANALYZE +SELECT list_value, payload +FROM read_parquet('{TEST_DIR}/bloom_list.parquet') +WHERE list_value[1] IN (101, NULL); +-- +ok +== +SELECT count(*) +FROM read_parquet('{TEST_DIR}/bloom_list.parquet') +WHERE deep_list[1][1][1] = 101; +-- +ok +== +EXPLAIN ANALYZE +SELECT deep_list, payload +FROM read_parquet('{TEST_DIR}/bloom_list.parquet') +WHERE deep_list[1][1][1] = 101; +-- +ok +== +SELECT count(*) +FROM read_parquet('{TEST_DIR}/bloom_list.parquet') +WHERE struct_value.level_1.level_2.value = 101; +-- +ok +== +EXPLAIN ANALYZE +SELECT struct_value, payload +FROM read_parquet('{TEST_DIR}/bloom_list.parquet') +WHERE struct_value.level_1.level_2.value = 101; +-- +ok +== +SELECT count(*) +FROM read_parquet('{TEST_DIR}/bloom_list.parquet') +WHERE struct_value.level_1.level_2.value IS NOT DISTINCT FROM 101; +-- +ok +== +EXPLAIN ANALYZE +SELECT struct_value, payload +FROM read_parquet('{TEST_DIR}/bloom_list.parquet') +WHERE struct_value.level_1.level_2.value IS NOT DISTINCT FROM 101; +-- +ok +== +SELECT count(*) +FROM read_parquet('{TEST_DIR}/bloom_list.parquet') +WHERE struct_value.level_1.level_2.value IN (101, 103); +-- +ok +== +EXPLAIN ANALYZE +SELECT struct_value, payload +FROM read_parquet('{TEST_DIR}/bloom_list.parquet') +WHERE struct_value.level_1.level_2.value IN (101, 103); +-- +ok +== +SELECT count(deep_list) +FROM read_parquet('{TEST_DIR}/bloom_list.parquet') +WHERE deep_list[1][1][1] = 100; +-- +ok +== +SELECT count(list_value) +FROM read_parquet('{TEST_DIR}/bloom_list.parquet') +WHERE list_value[2] = 102; +-- +ok +== +SELECT BOOL_AND(bloom_filter_excludes) +FROM parquet_bloom_probe( + '{TEST_DIR}/bloom_uuid.parquet', + 'u', + '00000000-0000-0000-0000-000000000101' +); +-- +ok +== +EXPLAIN ANALYZE +SELECT sum(payload) +FROM read_parquet('{TEST_DIR}/bloom_uuid.parquet') +WHERE u = '00000000-0000-0000-0000-000000000101'::UUID; +-- +ok +== +SELECT count(*) +FROM read_parquet('{TEST_DIR}/bloom_uuid.parquet') +WHERE u = '00000000-0000-0000-0000-000000000101'::UUID; +-- +ok +== +CREATE MACRO assert_bloom_filter_hit(file, col, val) AS TABLE + SELECT COUNT(*) > 0 AND COUNT(*) < MAX(row_group_id+1) FROM parquet_bloom_probe(file, col, val) WHERE NOT bloom_filter_excludes; +-- +ok +== +FROM assert_bloom_filter_hit('{TEST_DIR}/bloom1.parquet', 'r', '200'); +-- +ok +== +FROM assert_bloom_filter_hit('{TEST_DIR}/bloom1.parquet', 'r', 200); +-- +ok +== +FROM assert_bloom_filter_hit('{TEST_DIR}/bloom10000.parquet', 'r', '200'); +-- +ok +== +FROM assert_bloom_filter_hit('{TEST_DIR}/bloom1.parquet', 'r2', '200'); +-- +ok +== +FROM assert_bloom_filter_hit('{TEST_DIR}/bloom1.parquet', NULL, '200'); +-- +ok +== +FROM assert_bloom_filter_hit('{TEST_DIR}/bloom1.parquet', 'r', NULL); +-- +ok +== +FROM assert_bloom_filter_hit('{TEST_DIR}/bloom1.parquet', 'r', 'a'); +-- +ok +== +FROM assert_bloom_filter_hit('{TEST_DIR}/bloom1.parquet', 'r_int16', 200); +-- +ok +== +FROM assert_bloom_filter_hit('{TEST_DIR}/bloom1.parquet', 'r_int32', 200); +-- +ok +== +FROM assert_bloom_filter_hit('{TEST_DIR}/bloom1.parquet', 'r_float', 200); +-- +ok +== +FROM assert_bloom_filter_hit('{TEST_DIR}/bloom1.parquet', 'r_double', 200); +-- +ok +== +FROM assert_bloom_filter_hit('{TEST_DIR}/bloom1.parquet', 'r_string', 'string_200'); +-- +ok +== +FROM assert_bloom_filter_hit('{TEST_DIR}/bloom1.parquet', 'r_blob', 'blob_200'::BLOB); +-- +ok +== +COPY (SELECT from_hex('FF')::BLOB AS b FROM range(10)) +TO '{TEST_DIR}/bloom_blob.parquet' (FORMAT PARQUET, WRITE_BLOOM_FILTER TRUE, DICTIONARY_SIZE_LIMIT 1000); +-- +ok +== +SELECT bool_and(b = from_hex('FF')::BLOB) FROM '{TEST_DIR}/bloom_blob.parquet'; +-- +ok +== +SELECT count(*) FROM '{TEST_DIR}/bloom_blob.parquet' WHERE b = from_hex('FF')::BLOB; +-- +ok +== +SELECT bloom_filter_excludes +FROM parquet_bloom_probe('{TEST_DIR}/bloom_blob.parquet', 'b', from_hex('FF')::BLOB); +-- +ok +== +SELECT bloom_filter_excludes +FROM parquet_bloom_probe('{TEST_DIR}/bloom_blob.parquet', 'b', from_hex('FE')::BLOB); +-- +ok +== +COPY ( + SELECT + (DATE '2000-01-01' + (2 * (i % 2048))::INTEGER)::DATE AS dt, + (TIMESTAMP '2000-01-01' + (2 * (i % 2048)) * INTERVAL 1 SECOND)::TIMESTAMP_S AS ts_sec, + (TIMESTAMP '2000-01-01' + (2 * (i % 2048)) * INTERVAL 1 SECOND)::TIMESTAMP AS ts, + (TIMESTAMP '2000-01-01' + (2 * (i % 2048)) * INTERVAL 1 SECOND)::TIMESTAMP_MS AS ts_ms, + (TIMESTAMP '2000-01-01' + (2 * (i % 2048)) * INTERVAL 1 SECOND)::TIMESTAMP_NS AS ts_ns, + (TIMESTAMP '2000-01-01' + (2 * (i % 2048)) * INTERVAL 1 SECOND)::TIMESTAMPTZ AS ts_tz, + (TIMESTAMP '2000-01-01' + + (2 * (i % 2048)) * INTERVAL 1 SECOND)::TIMESTAMPTZ_NS AS ts_tz_ns, + (TIME '00:00:00' + (2 * (i % 2048)) * INTERVAL 1 SECOND)::TIME AS tm, + (TIMETZ '12:00:00+02' + (2 * (i % 2048)) * INTERVAL 1 SECOND)::TIMETZ AS tm_tz + FROM range(8192) t(i) +) TO '{TEST_DIR}/bloom_temporal.parquet' ( + FORMAT PARQUET, + ROW_GROUP_SIZE 2048, + DICTIONARY_SIZE_LIMIT 4096, + BLOOM_FILTER_FALSE_POSITIVE_RATIO 0.0001 +); +-- +ok +== +SELECT column_id, bool_and(bloom_filter_offset IS NOT NULL), bool_and(bloom_filter_length IS NOT NULL) +FROM parquet_metadata('{TEST_DIR}/bloom_temporal.parquet') +GROUP BY column_id +ORDER BY column_id; +-- +ok +== +SELECT name, type, + coalesce(contains(logical_type, 'MILLIS=MilliSeconds()'), false), + coalesce(contains(logical_type, 'MICROS=MicroSeconds()'), false), + coalesce(contains(logical_type, 'NANOS=NanoSeconds()'), false), + duckdb_type +FROM parquet_schema('{TEST_DIR}/bloom_temporal.parquet') +WHERE type IS NOT NULL +ORDER BY name; +-- +ok +== +SELECT bool_and(bloom_filter_excludes) +FROM parquet_bloom_probe('{TEST_DIR}/bloom_temporal.parquet', 'dt', DATE '2000-01-01' + 1001); +-- +ok +== +SELECT bool_and(bloom_filter_excludes) +FROM parquet_bloom_probe('{TEST_DIR}/bloom_temporal.parquet', 'ts_sec', + TIMESTAMP '2000-01-01' + INTERVAL 1001 SECOND); +-- +ok +== +SELECT bool_and(bloom_filter_excludes) +FROM parquet_bloom_probe('{TEST_DIR}/bloom_temporal.parquet', 'ts', + TIMESTAMP '2000-01-01' + INTERVAL 1001 SECOND); +-- +ok +== +SELECT bool_and(bloom_filter_excludes) +FROM parquet_bloom_probe('{TEST_DIR}/bloom_temporal.parquet', 'ts_ms', + TIMESTAMP '2000-01-01' + INTERVAL 1001 SECOND); +-- +ok +== +SELECT bool_and(bloom_filter_excludes) +FROM parquet_bloom_probe('{TEST_DIR}/bloom_temporal.parquet', 'ts_ns', + TIMESTAMP_NS '2000-01-01' + INTERVAL 1001 SECOND); +-- +ok +== +SELECT bool_and(bloom_filter_excludes) +FROM parquet_bloom_probe('{TEST_DIR}/bloom_temporal.parquet', 'ts_tz', + (TIMESTAMP '2000-01-01' + INTERVAL 1001 SECOND)::TIMESTAMPTZ); +-- +ok +== +SELECT bool_and(bloom_filter_excludes) +FROM parquet_bloom_probe('{TEST_DIR}/bloom_temporal.parquet', 'ts_tz_ns', + TIMESTAMPTZ_NS '2000-01-01 00:16:41+00'); +-- +ok +== +SELECT bool_and(bloom_filter_excludes) +FROM parquet_bloom_probe('{TEST_DIR}/bloom_temporal.parquet', 'tm', TIME '00:16:41'); +-- +ok +== +SELECT bool_or(bloom_filter_excludes) +FROM parquet_bloom_probe('{TEST_DIR}/bloom_temporal.parquet', 'tm_tz', TIMETZ '12:00:00+02'); +-- +ok +== +SELECT bool_and(bloom_filter_excludes) +FROM parquet_bloom_probe('{TEST_DIR}/bloom_temporal.parquet', 'tm_tz', TIMETZ '12:16:41+02'); +-- +ok +== +EXPLAIN ANALYZE SELECT count(*) FROM '{TEST_DIR}/bloom_temporal.parquet' +WHERE dt = DATE '2000-01-01' + 1001; +-- +ok +== +EXPLAIN ANALYZE SELECT count(*) FROM '{TEST_DIR}/bloom_temporal.parquet' +WHERE ts_sec = TIMESTAMP '2000-01-01' + INTERVAL 1001 SECOND; +-- +ok +== +EXPLAIN ANALYZE SELECT count(*) FROM '{TEST_DIR}/bloom_temporal.parquet' +WHERE ts = TIMESTAMP '2000-01-01' + INTERVAL 1001 SECOND; +-- +ok +== +EXPLAIN ANALYZE SELECT count(*) FROM '{TEST_DIR}/bloom_temporal.parquet' +WHERE ts_ms = TIMESTAMP '2000-01-01' + INTERVAL 1001 SECOND; +-- +ok +== +EXPLAIN ANALYZE SELECT count(*) FROM '{TEST_DIR}/bloom_temporal.parquet' +WHERE ts_ns = TIMESTAMP_NS '2000-01-01' + INTERVAL 1001 SECOND; +-- +ok +== +EXPLAIN ANALYZE SELECT count(*) FROM '{TEST_DIR}/bloom_temporal.parquet' +WHERE ts_tz = (TIMESTAMP '2000-01-01' + INTERVAL 1001 SECOND)::TIMESTAMPTZ; +-- +ok +== +EXPLAIN ANALYZE SELECT count(*) FROM '{TEST_DIR}/bloom_temporal.parquet' +WHERE ts_tz_ns = TIMESTAMPTZ_NS '2000-01-01 00:16:41+00'; +-- +ok +== +EXPLAIN ANALYZE SELECT count(*) FROM '{TEST_DIR}/bloom_temporal.parquet' +WHERE tm = TIME '00:16:41'; +-- +ok +== +COPY ( + SELECT CASE + WHEN i = 0 THEN 'infinity'::TIMESTAMP_MS + WHEN i = 1 THEN '-infinity'::TIMESTAMP_MS + ELSE (TIMESTAMP '2000-01-01' + i * INTERVAL 1 MILLISECOND)::TIMESTAMP_MS + END AS ts + FROM range(2048) range_table(i) +) +TO '{TEST_DIR}/timestamp_ms_infinity_bloom.parquet' ( + FORMAT parquet, + ROW_GROUP_SIZE 2048, + DICTIONARY_SIZE_LIMIT 4096, + BLOOM_FILTER_FALSE_POSITIVE_RATIO 0.0001 +) +-- +ok +== +SELECT count(*) +FROM read_parquet('{TEST_DIR}/timestamp_ms_infinity_bloom.parquet') +WHERE ts = 'infinity'::TIMESTAMP +-- +ok +== +SELECT count(*) +FROM read_parquet('{TEST_DIR}/timestamp_ms_infinity_bloom.parquet') +WHERE ts = '-infinity'::TIMESTAMP +-- +ok +== +SELECT count(*) FROM '{TEST_DIR}/bloom_blob.parquet' WHERE to_hex(b) = 'FF'; +-- +ok +== +SELECT count(*) +FROM '{TEST_DIR}/bloom_blob.parquet' lhs +JOIN '{TEST_DIR}/bloom_blob.parquet' rhs ON lhs.b = rhs.b; +-- +ok +== +copy (select (r1.range*10)::BIGINT r, +from range(100) r1, range(100) order by r) to '{TEST_DIR}/bloom2.parquet' (format parquet, ROW_GROUP_SIZE 10000, dictionary_size_limit 10); +-- +ok +== +select row_group_id, bloom_filter_offset IS NOT NULL, bloom_filter_length IS NOT NULL from parquet_metadata('{TEST_DIR}/bloom2.parquet') order by row_group_id; +-- +ok +== +copy (select (r1.range*10)::BIGINT r, +from range(100) r1, range(100) order by r) to '{TEST_DIR}/disable_bloom_filter.parquet' (format parquet, ROW_GROUP_SIZE 10000, write_bloom_filter false); +-- +ok +== +select row_group_id, bloom_filter_offset IS NOT NULL, bloom_filter_length IS NOT NULL from parquet_metadata('{TEST_DIR}/disable_bloom_filter.parquet') order by row_group_id; +-- +ok +== +copy (select (r1.range*10)::BIGINT r, +from range(100) r1, range(100) order by r) to '{TEST_DIR}/bloom3.parquet' (format parquet, ROW_GROUP_SIZE 10000, dictionary_size_limit 99); +-- +ok +== +select row_group_id, bloom_filter_offset IS NOT NULL, bloom_filter_length IS NOT NULL from parquet_metadata('{TEST_DIR}/bloom3.parquet') order by row_group_id; +-- +ok +== +copy (select (r1.range*10)::BIGINT r, +from range(100) r1, range(100) order by r) to '{TEST_DIR}/bloom4.parquet' (format parquet, ROW_GROUP_SIZE 10000, dictionary_size_limit 100); +-- +ok +== +select row_group_id, bloom_filter_offset IS NOT NULL, bloom_filter_length IS NOT NULL from parquet_metadata('{TEST_DIR}/bloom4.parquet') order by row_group_id; +-- +ok +== +copy (select (r1.range*10)::BIGINT r, +from range(100) r1, range(100) order by r) to '{TEST_DIR}/bloom5.parquet' (format parquet, ROW_GROUP_SIZE 10000, dictionary_size_limit 1000); +-- +ok +== +select row_group_id, bloom_filter_offset IS NOT NULL, bloom_filter_length IS NOT NULL from parquet_metadata('{TEST_DIR}/bloom5.parquet') order by row_group_id; +-- +ok +== +copy (select (r1.range*10)::BIGINT r, +from range(100) r1, range(100) order by r) to '{TEST_DIR}/bloom6.parquet' (format parquet, ROW_GROUP_SIZE 10000, dictionary_size_limit 1000, bloom_filter_false_positive_ratio 0.01); +-- +ok +== +select row_group_id, bloom_filter_length from parquet_metadata('{TEST_DIR}/bloom6.parquet') order by row_group_id; +-- +ok +== +copy (select (r1.range*10)::BIGINT r, +from range(100) r1, range(100) order by r) to '{TEST_DIR}/bloom7.parquet' (format parquet, ROW_GROUP_SIZE 10000, dictionary_size_limit 1000, bloom_filter_false_positive_ratio 0.5); +-- +ok +== +select row_group_id, bloom_filter_length from parquet_metadata('{TEST_DIR}/bloom7.parquet') order by row_group_id; +-- +ok +== +copy (select (r1.range*10)::BIGINT r, +from range(100) r1, range(100) order by r) to '{TEST_DIR}/bloom8.parquet' (format parquet, ROW_GROUP_SIZE 10000, dictionary_size_limit 1000, bloom_filter_false_positive_ratio 0.001); +-- +ok +== +select row_group_id, bloom_filter_length from parquet_metadata('{TEST_DIR}/bloom8.parquet') order by row_group_id; +-- +ok +== +copy (select (r1.range*10)::BIGINT r, +from range(100) r1, range(100) order by r) to '{TEST_DIR}/bloom8.parquet' (format parquet, ROW_GROUP_SIZE 10000, dictionary_size_limit 1000, bloom_filter_false_positive_ratio 0.0001); +-- +ok +== +copy (select (r1.range*10)::BIGINT r, +from range(100) r1, range(100) order by r) to '{TEST_DIR}/bloom8.parquet' (format parquet, ROW_GROUP_SIZE 10000, dictionary_size_limit -1, bloom_filter_false_positive_ratio 0.0001); +-- +ok +== +copy (select (r1.range*10)::BIGINT r, +from range(100) r1, range(100) order by r) to '{TEST_DIR}/bloom8.parquet' (format parquet, ROW_GROUP_SIZE 10000, dictionary_size_limit 1000, bloom_filter_false_positive_ratio 0); +-- +ok +== +copy (select (r1.range*10)::VARCHAR r, +from range(100) r1, range(100) order by r) to '{TEST_DIR}/bloom9.parquet' (format parquet, ROW_GROUP_SIZE 10000, string_dictionary_page_size_limit 10); +-- +ok +== +select row_group_id, bloom_filter_offset IS NOT NULL, bloom_filter_length IS NOT NULL from parquet_metadata('{TEST_DIR}/bloom9.parquet') order by row_group_id; +-- +ok +== +copy (select (r1.range*10)::VARCHAR r, +from range(100) r1, range(100) order by r) to '{TEST_DIR}/bloom9.parquet' (format parquet, ROW_GROUP_SIZE 10000, string_dictionary_page_size_limit 100000); +-- +ok +== +copy (select (r1.range*10)::VARCHAR r, +from range(100) r1, range(100) order by r) to '{TEST_DIR}/bloom9.parquet' (format parquet, ROW_GROUP_SIZE 10000, string_dictionary_page_size_limit 4294967295); +-- +ok +== +copy (select (r1.range*10)::VARCHAR r, +from range(100) r1, range(100) order by r) to '{TEST_DIR}/bloom9.parquet' (format parquet, ROW_GROUP_SIZE 10000, string_dictionary_page_size_limit 0); +-- +ok +== +copy (select repeat('abc', 500_000) || (range % 10) s from range(100)) to '{TEST_DIR}/my.parquet'; +-- +ok +== +select encodings from parquet_metadata('{TEST_DIR}/my.parquet'); +-- +ok +== +copy (select repeat('abc', 500_000) || (range % 10) s from range(100)) to '{TEST_DIR}/my.parquet' (parquet_version v2); +-- +ok +== +copy (select repeat('abc', 500_000) || (range % 10) s from range(100)) to '{TEST_DIR}/my.parquet' (STRING_DICTIONARY_PAGE_SIZE_LIMIT 4_000_000); +-- +ok +== +select encodings in ('PLAIN_DICTIONARY', 'RLE_DICTIONARY') from parquet_metadata('{TEST_DIR}/my.parquet'); +-- +ok +== +COPY ( + SELECT CASE + WHEN i < 2048 THEN (-1.0::DOUBLE / 'Infinity'::DOUBLE) + WHEN i % 2 = 0 THEN -1.0::DOUBLE + ELSE 1.0::DOUBLE + END AS x + FROM range(4096) t(i) + ORDER BY i +) TO '{TEST_DIR}/bloom_ndf_signed_zero.parquet' ( + FORMAT PARQUET, + ROW_GROUP_SIZE 2048, + WRITE_BLOOM_FILTER TRUE, + DICTIONARY_SIZE_LIMIT 1000 +); +-- +ok +== +EXPLAIN ANALYZE +SELECT count(*) +FROM read_parquet('{TEST_DIR}/bloom_ndf_signed_zero.parquet') +WHERE x IS NOT DISTINCT FROM 0.0; +-- +ok +== +SELECT count(*) +FROM read_parquet('{TEST_DIR}/bloom_ndf_signed_zero.parquet') +WHERE x IS NOT DISTINCT FROM 0.0; +-- +ok +== +EXPLAIN ANALYZE +SELECT count(*) +FROM read_parquet('{TEST_DIR}/bloom_ndf_signed_zero.parquet') +WHERE x IS NOT DISTINCT FROM -0.0; +-- +ok +== +SELECT count(*) +FROM read_parquet('{TEST_DIR}/bloom_ndf_signed_zero.parquet') +WHERE x IS NOT DISTINCT FROM -0.0; +-- +ok +== +COPY ( + SELECT CASE + WHEN i < 2048 THEN '-NaN'::DOUBLE + WHEN i % 2 = 0 THEN -1.0::DOUBLE + ELSE 1.0::DOUBLE + END AS x + FROM range(4096) t(i) + ORDER BY i +) TO '{TEST_DIR}/bloom_nan.parquet' ( + FORMAT PARQUET, + ROW_GROUP_SIZE 2048, + WRITE_BLOOM_FILTER TRUE, + DICTIONARY_SIZE_LIMIT 1000 +); +-- +ok +== +SELECT count(*) +FROM read_parquet('{TEST_DIR}/bloom_nan.parquet') +WHERE x = 'NaN'::DOUBLE; +-- +ok +== +SELECT count(*) +FROM read_parquet('{TEST_DIR}/bloom_nan.parquet') +WHERE x IS NOT DISTINCT FROM 'NaN'::DOUBLE; +-- +ok +== diff --git a/parser/testdata/corpus/sql/copy/parquet/broken_parquet.test b/parser/testdata/corpus/sql/copy/parquet/broken_parquet.test new file mode 100644 index 0000000..be2dfc4 --- /dev/null +++ b/parser/testdata/corpus/sql/copy/parquet/broken_parquet.test @@ -0,0 +1,37 @@ +# source: test/sql/copy/parquet/broken_parquet.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +select count(*) from parquet_scan('test/sql/copy/parquet/broken/missingmagicatfront.parquet') +-- +ok +== +select count(*) from parquet_scan('test/sql/copy/parquet/broken/missingmagicatend.parquet') +-- +ok +== +select count(*) from parquet_scan('test/sql/copy/parquet/broken/firstmarker.parquet') +-- +ok +== +select count(*) from parquet_scan('test/sql/copy/parquet/broken/twomarkers.parquet') +-- +ok +== +select count(*) from parquet_scan('test/sql/copy/parquet/broken/footerlengthzero.parquet') +-- +ok +== +select count(*) from parquet_scan('test/sql/copy/parquet/broken/hugefooter.parquet') +-- +ok +== +select count(*) from parquet_scan('test/sql/copy/parquet/broken/garbledfooter.parquet') +-- +ok +== +from parquet_scan('test/sql/copy/parquet/broken/broken_structure.parquet') +-- +ok +== diff --git a/parser/testdata/corpus/sql/copy/parquet/byte_stream_split.test b/parser/testdata/corpus/sql/copy/parquet/byte_stream_split.test new file mode 100644 index 0000000..a1cb69a --- /dev/null +++ b/parser/testdata/corpus/sql/copy/parquet/byte_stream_split.test @@ -0,0 +1,9 @@ +# source: test/sql/copy/parquet/byte_stream_split.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +SELECT * FROM '{DATA_DIR}/parquet-testing/byte_stream_split.parquet' +-- +ok +== diff --git a/parser/testdata/corpus/sql/copy/parquet/case_insensitive_replacement.test b/parser/testdata/corpus/sql/copy/parquet/case_insensitive_replacement.test new file mode 100644 index 0000000..d4a997b --- /dev/null +++ b/parser/testdata/corpus/sql/copy/parquet/case_insensitive_replacement.test @@ -0,0 +1,9 @@ +# source: test/sql/copy/parquet/case_insensitive_replacement.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +SELECT data FROM '{DATA_DIR}/parquet-testing/CASE_INSENSITIVE.PARQUET' +-- +ok +== diff --git a/parser/testdata/corpus/sql/copy/parquet/copy_ninf_stats.test b/parser/testdata/corpus/sql/copy/parquet/copy_ninf_stats.test new file mode 100644 index 0000000..282e039 --- /dev/null +++ b/parser/testdata/corpus/sql/copy/parquet/copy_ninf_stats.test @@ -0,0 +1,13 @@ +# source: test/sql/copy/parquet/copy_ninf_stats.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +copy (select '-infinity'::double ninf) to '{TEST_DIR}/ninf.parquet'; +-- +ok +== +SELECT stats_min, stats_max FROM parquet_metadata('{TEST_DIR}/ninf.parquet') +-- +ok +== diff --git a/parser/testdata/corpus/sql/copy/parquet/copy_option_non_foldable.test b/parser/testdata/corpus/sql/copy/parquet/copy_option_non_foldable.test new file mode 100644 index 0000000..418c83d --- /dev/null +++ b/parser/testdata/corpus/sql/copy/parquet/copy_option_non_foldable.test @@ -0,0 +1,26 @@ +# source: test/sql/copy/parquet/copy_option_non_foldable.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +PREPARE statement2 as COPY ( + SELECT + 42 AS number, + true AS is_even +) TO '{TEST_DIR}/non_foldable_copy_option.parquet' ( + FORMAT parquet, + KV_METADATA { + number: random() + } +); +-- +ok +== +EXECUTE statement2; +-- +ok +== +select * from '{TEST_DIR}/non_foldable_copy_option.parquet' +-- +ok +== diff --git a/parser/testdata/corpus/sql/copy/parquet/copy_option_prepared.test b/parser/testdata/corpus/sql/copy/parquet/copy_option_prepared.test new file mode 100644 index 0000000..ab8bf7b --- /dev/null +++ b/parser/testdata/corpus/sql/copy/parquet/copy_option_prepared.test @@ -0,0 +1,26 @@ +# source: test/sql/copy/parquet/copy_option_prepared.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +PREPARE statement as COPY ( + SELECT + 42 AS number, + true AS is_even +) TO '{TEST_DIR}/prepared_parquet_copy.parquet' ( + FORMAT parquet, + KV_METADATA { + number: $1, + } +); +-- +ok +== +execute statement(42) +-- +ok +== +select * from '{TEST_DIR}/prepared_parquet_copy.parquet'; +-- +ok +== diff --git a/parser/testdata/corpus/sql/copy/parquet/copy_option_suggestion.test b/parser/testdata/corpus/sql/copy/parquet/copy_option_suggestion.test new file mode 100644 index 0000000..c55e711 --- /dev/null +++ b/parser/testdata/corpus/sql/copy/parquet/copy_option_suggestion.test @@ -0,0 +1,13 @@ +# source: test/sql/copy/parquet/copy_option_suggestion.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +copy (select 42) to 'file.parquet' (partition_b (a)); +-- +ok +== +copy (select 42) to 'file.csv' (partition_b (a)); +-- +ok +== diff --git a/parser/testdata/corpus/sql/copy/parquet/corrupt_stats.test b/parser/testdata/corpus/sql/copy/parquet/corrupt_stats.test new file mode 100644 index 0000000..03626c9 --- /dev/null +++ b/parser/testdata/corpus/sql/copy/parquet/corrupt_stats.test @@ -0,0 +1,9 @@ +# source: test/sql/copy/parquet/corrupt_stats.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +SELECT a FROM '{DATA_DIR}/parquet-testing/corrupt_stats.parquet' GROUP BY a; +-- +ok +== diff --git a/parser/testdata/corpus/sql/copy/parquet/cte_batch_exchange.test b/parser/testdata/corpus/sql/copy/parquet/cte_batch_exchange.test new file mode 100644 index 0000000..c11981b --- /dev/null +++ b/parser/testdata/corpus/sql/copy/parquet/cte_batch_exchange.test @@ -0,0 +1,56 @@ +# source: test/sql/copy/parquet/cte_batch_exchange.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +CREATE TABLE cte_parquet_source AS SELECT i FROM range(1000000) t(i); +-- +ok +== +EXPLAIN ANALYZE +COPY ( + WITH c AS MATERIALIZED (SELECT i FROM cte_parquet_source) + SELECT i FROM c +) TO '{TEST_DIR}/cte_batch_exchange.parquet' (FORMAT parquet); +-- +ok +== +SELECT count(*), min(i), max(i) +FROM read_parquet('{TEST_DIR}/cte_batch_exchange.parquet'); +-- +ok +== +SELECT row_group_num_rows +FROM parquet_metadata('{TEST_DIR}/cte_batch_exchange.parquet') +ORDER BY row_group_id; +-- +ok +== +EXPLAIN ANALYZE +COPY ( + WITH first AS MATERIALIZED ( + SELECT i FROM cte_parquet_source WHERE i < 500000 + UNION ALL + SELECT i FROM cte_parquet_source WHERE i >= 500000 + ), second AS MATERIALIZED ( + SELECT i FROM first + ) + SELECT i FROM second +) TO '{TEST_DIR}/cte_nested_batch_exchange.parquet' (FORMAT parquet); +-- +ok +== +SELECT count(*), min(i), max(i) +FROM read_parquet('{TEST_DIR}/cte_nested_batch_exchange.parquet'); +-- +ok +== +SELECT count(*) +FROM ( + SELECT i, row_number() OVER () - 1 AS expected + FROM read_parquet('{TEST_DIR}/cte_nested_batch_exchange.parquet') +) +WHERE i != expected; +-- +ok +== diff --git a/parser/testdata/corpus/sql/copy/parquet/decimal_filter.test b/parser/testdata/corpus/sql/copy/parquet/decimal_filter.test new file mode 100644 index 0000000..325e5d7 --- /dev/null +++ b/parser/testdata/corpus/sql/copy/parquet/decimal_filter.test @@ -0,0 +1,17 @@ +# source: test/sql/copy/parquet/decimal_filter.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +select * from '{DATA_DIR}/parquet-testing/decimals.parquet' +-- +ok +== +select * from '{DATA_DIR}/parquet-testing/decimals.parquet' WHERE l{i}=0.1 +-- +error: Parser Error: syntax error at or near "{" +== +select * from '{DATA_DIR}/parquet-testing/decimals.parquet' WHERE l{i}=-0.1 +-- +error: Parser Error: syntax error at or near "{" +== diff --git a/parser/testdata/corpus/sql/copy/parquet/delta_byte_array.test b/parser/testdata/corpus/sql/copy/parquet/delta_byte_array.test new file mode 100644 index 0000000..b4ae169 --- /dev/null +++ b/parser/testdata/corpus/sql/copy/parquet/delta_byte_array.test @@ -0,0 +1,13 @@ +# source: test/sql/copy/parquet/delta_byte_array.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +SELECT * FROM '{DATA_DIR}/parquet-testing/delta_byte_array.parquet' +-- +ok +== +SELECT * FROM '{DATA_DIR}/parquet-testing/delta_length_byte_array.parquet' +-- +ok +== diff --git a/parser/testdata/corpus/sql/copy/parquet/describe_parquet.test b/parser/testdata/corpus/sql/copy/parquet/describe_parquet.test new file mode 100644 index 0000000..fb8ffd5 --- /dev/null +++ b/parser/testdata/corpus/sql/copy/parquet/describe_parquet.test @@ -0,0 +1,17 @@ +# source: test/sql/copy/parquet/describe_parquet.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +DESCRIBE '{DATA_DIR}/parquet-testing/delta_byte_array.parquet' +-- +ok +== +DESCRIBE "{DATA_DIR}/parquet-testing/delta_byte_array.parquet" +-- +ok +== +DESCRIBE FROM read_parquet("{DATA_DIR}/parquet-testing/delta_byte_array.parquet") +-- +ok +== diff --git a/parser/testdata/corpus/sql/copy/parquet/dictionary_compression_ratio_threshold.test b/parser/testdata/corpus/sql/copy/parquet/dictionary_compression_ratio_threshold.test new file mode 100644 index 0000000..325d090 --- /dev/null +++ b/parser/testdata/corpus/sql/copy/parquet/dictionary_compression_ratio_threshold.test @@ -0,0 +1,41 @@ +# source: test/sql/copy/parquet/dictionary_compression_ratio_threshold.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +CREATE TABLE test AS SELECT 'thisisaverylongstringbutitrepeatsmanytimessoitshighlycompressible' || (range % 10) i FROM range(100000) +-- +ok +== +COPY test TO '{TEST_DIR}/dictionary_compression_ratio_threshold.parquet' (dictionary_compression_ratio_threshold -2) +-- +ok +== +COPY test TO '{TEST_DIR}/dictionary_compression_ratio_threshold.parquet' +-- +ok +== +SELECT dictionary_page_offset IS NULL FROM parquet_metadata('{TEST_DIR}/dictionary_compression_ratio_threshold.parquet') +-- +ok +== +COPY test TO '{TEST_DIR}/dictionary_compression_ratio_threshold.parquet' (dictionary_compression_ratio_threshold -1) +-- +ok +== +COPY test TO '{TEST_DIR}/dictionary_compression_ratio_threshold.parquet' (dictionary_compression_ratio_threshold 10) +-- +ok +== +COPY test TO '{TEST_DIR}/dictionary_compression_ratio_threshold.parquet' (dictionary_compression_ratio_threshold 20) +-- +ok +== +CREATE OR REPLACE TABLE test AS SELECT 'coolstring' || range i FROM range(100000) +-- +ok +== +COPY test TO '{TEST_DIR}/dictionary_compression_ratio_threshold.parquet' (dictionary_compression_ratio_threshold 0) +-- +ok +== diff --git a/parser/testdata/corpus/sql/copy/parquet/encryption/arrow_compatibility.test b/parser/testdata/corpus/sql/copy/parquet/encryption/arrow_compatibility.test new file mode 100644 index 0000000..9bbfa59 --- /dev/null +++ b/parser/testdata/corpus/sql/copy/parquet/encryption/arrow_compatibility.test @@ -0,0 +1,25 @@ +# source: test/sql/copy/parquet/encryption/arrow_compatibility.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +PRAGMA add_parquet_key('arrow_key', '0123456789012345') +-- +ok +== +PRAGMA add_parquet_key('arrow_key_generated_files', '0123456789abcdef') +-- +ok +== +SELECT flba_field FROM read_parquet('{DATA_DIR}/parquet-testing/encryption/arrow_uniform_encryption.parquet', encryption_config={footer_key: 'arrow_key'}) LIMIT 1; +-- +ok +== +SELECT * FROM read_parquet('{DATA_DIR}/parquet-testing/encryption/arrow_uniform_encryption_gist.parquet', encryption_config={footer_key: 'arrow_key_generated_files'}); +-- +ok +== +SELECT * FROM read_parquet('{DATA_DIR}/parquet-testing/encryption/arrow_uniform_encryption_ten_row_groups.parquet', encryption_config={footer_key: 'arrow_key_generated_files'}); +-- +ok +== diff --git a/parser/testdata/corpus/sql/copy/parquet/enum_converted_type.test b/parser/testdata/corpus/sql/copy/parquet/enum_converted_type.test new file mode 100644 index 0000000..86feec0 --- /dev/null +++ b/parser/testdata/corpus/sql/copy/parquet/enum_converted_type.test @@ -0,0 +1,9 @@ +# source: test/sql/copy/parquet/enum_converted_type.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +select * from '{DATA_DIR}/parquet-testing/enum.parquet'; +-- +ok +== diff --git a/parser/testdata/corpus/sql/copy/parquet/file_metadata.test b/parser/testdata/corpus/sql/copy/parquet/file_metadata.test new file mode 100644 index 0000000..6e64321 --- /dev/null +++ b/parser/testdata/corpus/sql/copy/parquet/file_metadata.test @@ -0,0 +1,17 @@ +# source: test/sql/copy/parquet/file_metadata.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +SET parquet_metadata_cache = true; +-- +ok +== +SELECT * FROM parquet_file_metadata('{DATA_DIR}/parquet-testing/arrow/alltypes_dictionary.parquet') +-- +ok +== +SELECT unnest(parquet_file_metadata, recursive:=True) FROM parquet_full_metadata('data/parquet-testing/arrow/column_orders.parquet') +-- +ok +== diff --git a/parser/testdata/corpus/sql/copy/parquet/fixed.test b/parser/testdata/corpus/sql/copy/parquet/fixed.test new file mode 100644 index 0000000..2de84ff --- /dev/null +++ b/parser/testdata/corpus/sql/copy/parquet/fixed.test @@ -0,0 +1,9 @@ +# source: test/sql/copy/parquet/fixed.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +SELECT data FROM parquet_scan('{DATA_DIR}/parquet-testing/fixed.parquet') +-- +ok +== diff --git a/parser/testdata/corpus/sql/copy/parquet/float16.test b/parser/testdata/corpus/sql/copy/parquet/float16.test new file mode 100644 index 0000000..5af8e9b --- /dev/null +++ b/parser/testdata/corpus/sql/copy/parquet/float16.test @@ -0,0 +1,21 @@ +# source: test/sql/copy/parquet/float16.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +select type, type_length, logical_type from parquet_schema('{DATA_DIR}/parquet-testing/float16.parquet') where name = 'x' +-- +ok +== +select typeof(x) from read_parquet('{DATA_DIR}/parquet-testing/float16.parquet') limit 1; +-- +ok +== +select x from read_parquet('{DATA_DIR}/parquet-testing/float16.parquet') order by x; +-- +ok +== +select x from read_parquet('{DATA_DIR}/parquet-testing/float16.parquet') where x > 1.1 order by x; +-- +ok +== diff --git a/parser/testdata/corpus/sql/copy/parquet/hive_partitioning_struct.test b/parser/testdata/corpus/sql/copy/parquet/hive_partitioning_struct.test new file mode 100644 index 0000000..17c4275 --- /dev/null +++ b/parser/testdata/corpus/sql/copy/parquet/hive_partitioning_struct.test @@ -0,0 +1,30 @@ +# source: test/sql/copy/parquet/hive_partitioning_struct.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +COPY ( + SELECT + i//50 id, + {'a': i, 'b': 21} s + FROM range(100) t(i) +) TO '{TEST_DIR}/hive_partitioned_struct_col' (FORMAT PARQUET, PARTITION_BY (id)) +-- +ok +== +SELECT * FROM read_parquet('{TEST_DIR}/hive_partitioned_struct_col/**/*.parquet', hive_partitioning=1) WHERE s.a=42 +-- +ok +== +SELECT s.a FROM read_parquet('{TEST_DIR}/hive_partitioned_struct_col/**/*.parquet', hive_partitioning=1) WHERE s.a=42 +-- +ok +== +COPY (SELECT i id, {'a': i//2} s FROM range(100) t(i)) TO '{TEST_DIR}/hive_partitioned_struct' (FORMAT PARQUET, PARTITION_BY (s)) +-- +ok +== +SELECT * FROM read_parquet('{TEST_DIR}/hive_partitioned_struct/**/*.parquet', hive_partitioning=1, hive_types={'s': 'STRUCT(a INT)'}) WHERE s.a=42 ORDER BY ALL +-- +ok +== diff --git a/parser/testdata/corpus/sql/copy/parquet/hive_timestamps.test b/parser/testdata/corpus/sql/copy/parquet/hive_timestamps.test new file mode 100644 index 0000000..88a688a --- /dev/null +++ b/parser/testdata/corpus/sql/copy/parquet/hive_timestamps.test @@ -0,0 +1,48 @@ +# source: test/sql/copy/parquet/hive_timestamps.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +CREATE TABLE raw_data ( + ts TIMESTAMP_S NOT NULL, + hits INTEGER NOT NULL +); +-- +ok +== +INSERT INTO raw_data +SELECT *, (random() * 500)::INTEGER +FROM RANGE(TIMESTAMP '2023-11-01', TIMESTAMP '2023-11-06', INTERVAL 1 MINUTE); +-- +ok +== +CREATE TABLE timeseries AS ( + SELECT DATE_TRUNC('hour', ts) AS bucket, SUM(hits)::BIGINT AS total + FROM raw_data + GROUP BY bucket +); +-- +ok +== +SELECT * +FROM timeseries +ORDER BY ALL +LIMIT 5 +-- +ok +== +COPY ( + SELECT * FROM timeseries +) TO '{TEST_DIR}/hive' ( + FORMAT 'PARQUET', COMPRESSION 'SNAPPY', PARTITION_BY (bucket), OVERWRITE_OR_IGNORE +); +-- +ok +== +SELECT bucket, total +FROM read_parquet('{TEST_DIR}/hive/*/*.parquet') +ORDER BY ALL +LIMIT 5 +-- +ok +== diff --git a/parser/testdata/corpus/sql/copy/parquet/incorrect_converted_type.test b/parser/testdata/corpus/sql/copy/parquet/incorrect_converted_type.test new file mode 100644 index 0000000..fc7e7dd --- /dev/null +++ b/parser/testdata/corpus/sql/copy/parquet/incorrect_converted_type.test @@ -0,0 +1,49 @@ +# source: test/sql/copy/parquet/incorrect_converted_type.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +SELECT * FROM '{DATA_DIR}/parquet-testing/broken/broken_bigint.parquet'; +-- +ok +== +SELECT * FROM '{DATA_DIR}/parquet-testing/broken/broken_date.parquet'; +-- +ok +== +SELECT * FROM '{DATA_DIR}/parquet-testing/broken/broken_int.parquet'; +-- +ok +== +SELECT * FROM '{DATA_DIR}/parquet-testing/broken/broken_smallint.parquet'; +-- +ok +== +SELECT * FROM '{DATA_DIR}/parquet-testing/broken/broken_timestamp.parquet'; +-- +ok +== +SELECT * FROM '{DATA_DIR}/parquet-testing/broken/broken_timestamp_ms.parquet'; +-- +ok +== +SELECT * FROM '{DATA_DIR}/parquet-testing/broken/broken_tinyint.parquet'; +-- +ok +== +SELECT * FROM '{DATA_DIR}/parquet-testing/broken/broken_ubigint.parquet'; +-- +ok +== +SELECT * FROM '{DATA_DIR}/parquet-testing/broken/broken_uinteger.parquet'; +-- +ok +== +SELECT * FROM '{DATA_DIR}/parquet-testing/broken/broken_usmallint.parquet'; +-- +ok +== +SELECT * FROM '{DATA_DIR}/parquet-testing/broken/broken_utinyint.parquet'; +-- +ok +== diff --git a/parser/testdata/corpus/sql/copy/parquet/infer_copy_format.test b/parser/testdata/corpus/sql/copy/parquet/infer_copy_format.test new file mode 100644 index 0000000..48f5b74 --- /dev/null +++ b/parser/testdata/corpus/sql/copy/parquet/infer_copy_format.test @@ -0,0 +1,25 @@ +# source: test/sql/copy/parquet/infer_copy_format.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +CREATE TABLE integers AS SELECT * FROM range(6) tbl(i); +-- +ok +== +COPY integers TO '{TEST_DIR}/integers.parquet'; +-- +ok +== +SELECT SUM(i) FROM '{TEST_DIR}/integers.parquet'; +-- +ok +== +COPY integers TO '{TEST_DIR}/integers.csv'; +-- +ok +== +SELECT SUM(i) FROM '{TEST_DIR}/integers.csv' tbl(i); +-- +ok +== diff --git a/parser/testdata/corpus/sql/copy/parquet/invalid_utf8_stats.test b/parser/testdata/corpus/sql/copy/parquet/invalid_utf8_stats.test new file mode 100644 index 0000000..07d3590 --- /dev/null +++ b/parser/testdata/corpus/sql/copy/parquet/invalid_utf8_stats.test @@ -0,0 +1,9 @@ +# source: test/sql/copy/parquet/invalid_utf8_stats.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +FROM 'data/parquet-testing/invalid_utf8_stats.parquet' +-- +ok +== diff --git a/parser/testdata/corpus/sql/copy/parquet/issue_21508.test b/parser/testdata/corpus/sql/copy/parquet/issue_21508.test new file mode 100644 index 0000000..9617615 --- /dev/null +++ b/parser/testdata/corpus/sql/copy/parquet/issue_21508.test @@ -0,0 +1,19 @@ +# source: test/sql/copy/parquet/issue_21508.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +PRAGMA add_parquet_key('key256', '01234567891123450123456789112345') +-- +ok +== +COPY (SELECT 1 AS id, 'Alice' AS name) TO '{TEST_DIR}/enc_union_by_name.parquet' + (FORMAT PARQUET, ENCRYPTION_CONFIG {footer_key: 'key256'}) +-- +ok +== +SELECT * FROM read_parquet('{TEST_DIR}/enc_union_by_name.parquet', + encryption_config={footer_key: 'key256'}, union_by_name=true) +-- +ok +== diff --git a/parser/testdata/corpus/sql/copy/parquet/json_parquet.test b/parser/testdata/corpus/sql/copy/parquet/json_parquet.test new file mode 100644 index 0000000..01e4c68 --- /dev/null +++ b/parser/testdata/corpus/sql/copy/parquet/json_parquet.test @@ -0,0 +1,13 @@ +# source: test/sql/copy/parquet/json_parquet.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +CREATE TABLE json_tbl AS FROM '{DATA_DIR}/parquet-testing/json_convertedtype.parquet'; +-- +ok +== +SELECT json_extract(TX_JSON[1], 'block_hash') FROM json_tbl +-- +ok +== diff --git a/parser/testdata/corpus/sql/copy/parquet/kv_metadata.test b/parser/testdata/corpus/sql/copy/parquet/kv_metadata.test new file mode 100644 index 0000000..9d22b19 --- /dev/null +++ b/parser/testdata/corpus/sql/copy/parquet/kv_metadata.test @@ -0,0 +1,41 @@ +# source: test/sql/copy/parquet/kv_metadata.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +COPY (SELECT 1, 'foo') TO '{TEST_DIR}/kv_metadata_test.parquet' (FORMAT PARQUET, KV_METADATA {foo: 'bar', baz: 42, quz: '\xC3\xB6\xC3\xA4\xC3\xA5'::BLOB}); +-- +ok +== +SELECT key::VARCHAR, value::VARCHAR FROM parquet_kv_metadata('{TEST_DIR}/kv_metadata_test.parquet'); +-- +ok +== +SELECT * FROM '{TEST_DIR}/kv_metadata_test.parquet' +-- +ok +== +SELECT key::VARCHAR, decode(value) FROM parquet_kv_metadata('{TEST_DIR}/kv_metadata_test.parquet') WHERE key = 'quz'; +-- +ok +== +COPY (SELECT 1, 'foo') TO '{TEST_DIR}/kv_metadata_test_fail.parquet' (FORMAT PARQUET, KV_METADATA 'foobar'); +-- +ok +== +COPY (SELECT 3, 'baz') TO '{TEST_DIR}/kv_metadata_test3.parquet' (FORMAT PARQUET); +-- +ok +== +SELECT key::VARCHAR, value::VARCHAR FROM parquet_kv_metadata('{TEST_DIR}/kv_metadata_test3.parquet'); +-- +ok +== +COPY (SELECT 2, 'bar') TO '{TEST_DIR}/kv_metadata_test2.parquet' (FORMAT PARQUET, KV_METADATA {a: 'b', c: 'd'}); +-- +ok +== +SELECT replace(replace(file_name, '\', '/'),replace('{TEST_DIR}/', '\', '/'), '') AS file_name, key::VARCHAR, value::VARCHAR FROM parquet_kv_metadata('{TEST_DIR}/kv_metadata_tes*') ORDER BY 1, 2; +-- +ok +== diff --git a/parser/testdata/corpus/sql/copy/parquet/lineitem_arrow.test b/parser/testdata/corpus/sql/copy/parquet/lineitem_arrow.test new file mode 100644 index 0000000..e4ea97d --- /dev/null +++ b/parser/testdata/corpus/sql/copy/parquet/lineitem_arrow.test @@ -0,0 +1,21 @@ +# source: test/sql/copy/parquet/lineitem_arrow.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +CREATE TABLE lineitem AS SELECT * FROM '{DATA_DIR}/parquet-testing/arrow/lineitem-arrow.parquet' +-- +ok +== +PRAGMA tpch(1) +-- +ok +== +PRAGMA tpch(6) +-- +ok +== +CREATE VIEW lineitem AS SELECT * FROM '{DATA_DIR}/parquet-testing/arrow/lineitem-arrow.parquet' +-- +ok +== diff --git a/parser/testdata/corpus/sql/copy/parquet/metadata_full.test b/parser/testdata/corpus/sql/copy/parquet/metadata_full.test new file mode 100644 index 0000000..3a4ef1e --- /dev/null +++ b/parser/testdata/corpus/sql/copy/parquet/metadata_full.test @@ -0,0 +1,65 @@ +# source: test/sql/copy/parquet/metadata_full.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +SELECT unnest(parquet_file_metadata, recursive:=True) FROM parquet_full_metadata('data/parquet-testing/arrow/alltypes_dictionary.parquet') +-- +ok +== +SELECT key::VARCHAR, value::VARCHAR FROM (SELECT unnest(parquet_kv_metadata, recursive:=True) FROM parquet_full_metadata('{TEST_DIR}/kv_metadata_test.parquet')); +-- +ok +== +SELECT key::VARCHAR, decode(value) FROM (SELECT unnest(parquet_kv_metadata, recursive:=True) FROM parquet_full_metadata('{TEST_DIR}/kv_metadata_test.parquet')) WHERE key = 'quz'; +-- +ok +== +SELECT key::VARCHAR, value::VARCHAR FROM (SELECT unnest(parquet_kv_metadata, recursive:=True) FROM parquet_full_metadata('{TEST_DIR}/kv_metadata_test3.parquet')); +-- +ok +== +SELECT replace(replace(file_name, '\', '/'),replace('{TEST_DIR}/', '\', '/'), '') AS file_name, key::VARCHAR, value::VARCHAR FROM (SELECT unnest(parquet_kv_metadata, recursive:=True) FROM parquet_full_metadata('{TEST_DIR}/kv_metadata_tes*')) ORDER BY 1, 2; +-- +ok +== +SELECT unnest(parquet_metadata, recursive:=True) FROM parquet_full_metadata('data/parquet-testing/lineitem-top10000.gzip.parquet'); +-- +ok +== +SELECT unnest(parquet_schema, recursive:=True) FROM parquet_full_metadata('data/parquet-testing/lineitem-top10000.gzip.parquet'); +-- +ok +== +SELECT COUNT(*) > 0 FROM (SELECT unnest(parquet_metadata, recursive:=True) FROM parquet_full_metadata('data/parquet-testing/lineitem-top10000.gzip.parquet')); +-- +ok +== +SELECT COUNT(*) > 0 FROM (SELECT unnest(parquet_schema, recursive:=True) FROM parquet_full_metadata('data/parquet-testing/lineitem-top10000.gzip.parquet')); +-- +ok +== +SELECT * FROM parquet_full_metadata('data/parquet-testing/decimal/decimal_dc.parquet'); +-- +ok +== +SELECT * FROM parquet_full_metadata('data/parquet-testing/decimal/int64_decimal.parquet'); +-- +ok +== +SELECT * FROM parquet_full_metadata('data/parquet-testing/glob/*.parquet'); +-- +ok +== +SELECT * FROM parquet_full_metadata(['data/parquet-testing/decimal/int64_decimal.parquet', 'data/parquet-testing/decimal/int64_decimal.parquet']); +-- +ok +== +SELECT name, type, duckdb_type FROM (SELECT unnest(parquet_schema, recursive:=True) FROM parquet_full_metadata('data/parquet-testing/lineitem-top10000.gzip.parquet')) WHERE type IS NOT NULL; +-- +ok +== +SELECT column_id, name FROM (SELECT unnest(parquet_schema, recursive:=True) FROM parquet_full_metadata('data/parquet-testing/lineitem-top10000.gzip.parquet')) ORDER BY column_id; +-- +ok +== diff --git a/parser/testdata/corpus/sql/copy/parquet/multi_file/adaptive_filter_carryover.test b/parser/testdata/corpus/sql/copy/parquet/multi_file/adaptive_filter_carryover.test new file mode 100644 index 0000000..11074f7 --- /dev/null +++ b/parser/testdata/corpus/sql/copy/parquet/multi_file/adaptive_filter_carryover.test @@ -0,0 +1,152 @@ +# source: test/sql/copy/parquet/multi_file/adaptive_filter_carryover.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +SET read_ahead_depth=1 +-- +ok +== +COPY (SELECT i AS a, i%10 AS b, i%100 AS c FROM range(100000) t(i)) TO '{TEST_DIR}/af_cross_1.parquet' +-- +ok +== +COPY (SELECT i AS a, i%10 AS b, i%100 AS c FROM range(100000) t(i)) TO '{TEST_DIR}/af_cross_2.parquet' +-- +ok +== +COPY (SELECT i AS a, i%10 AS b, i%100 AS c FROM range(100000) t(i)) TO '{TEST_DIR}/af_cross_3.parquet' +-- +ok +== +CALL enable_logging('AdaptiveFilter') +-- +ok +== +SELECT count(*) FROM read_parquet(['{TEST_DIR}/af_cross_1.parquet', '{TEST_DIR}/af_cross_2.parquet', '{TEST_DIR}/af_cross_3.parquet']) WHERE a > 100 AND b > 3 AND c < 50 +-- +ok +== +SELECT info['source'] FROM duckdb_logs_parsed('AdaptiveFilter') +WHERE event = 'INIT' AND file_path LIKE '%af_cross_1.parquet' ORDER BY timestamp LIMIT 1 +-- +ok +== +SELECT info['source'] FROM duckdb_logs_parsed('AdaptiveFilter') +WHERE event = 'INIT' AND file_path LIKE '%af_cross_2.parquet' ORDER BY timestamp LIMIT 1 +-- +ok +== +SELECT info['source'] FROM duckdb_logs_parsed('AdaptiveFilter') +WHERE event = 'INIT' AND file_path LIKE '%af_cross_3.parquet' ORDER BY timestamp LIMIT 1 +-- +ok +== +COPY (SELECT i AS a, i%10 AS b, i%2 AS extra FROM range(100000) t(i)) TO '{TEST_DIR}/af_cross_4.parquet' +-- +ok +== +CALL truncate_duckdb_logs() +-- +ok +== +SELECT count(*) FROM read_parquet(['{TEST_DIR}/af_cross_1.parquet', '{TEST_DIR}/af_cross_2.parquet', '{TEST_DIR}/af_cross_3.parquet', '{TEST_DIR}/af_cross_4.parquet'], union_by_name=true) WHERE a > 100 AND b > 3 +-- +ok +== +SELECT count(*) FROM duckdb_logs_parsed('AdaptiveFilter') +WHERE event = 'INIT' AND file_path LIKE '%af_cross_%.parquet' +-- +ok +== +SELECT count(*) > 0 FROM duckdb_logs_parsed('AdaptiveFilter') +WHERE event = 'INIT' AND info['source'] = 'SEEDED' AND file_path LIKE '%af_cross_4.parquet' +-- +ok +== +SELECT count(*) FROM read_parquet(['{TEST_DIR}/af_cross_1.parquet', '{TEST_DIR}/af_cross_2.parquet']) +-- +ok +== +SELECT count(*) FROM duckdb_logs_parsed('AdaptiveFilter') +-- +ok +== +COPY (SELECT i AS a, i%10 AS b, i%100 AS c, i%7 AS d FROM range(100000) t(i)) TO '{TEST_DIR}/af_mismatch_1.parquet' +-- +ok +== +COPY (SELECT i AS a, i%10 AS b, i%100 AS c FROM range(100000) t(i)) TO '{TEST_DIR}/af_mismatch_2.parquet' +-- +ok +== +SELECT count(*) FROM read_parquet(['{TEST_DIR}/af_mismatch_1.parquet', '{TEST_DIR}/af_mismatch_2.parquet'], union_by_name=true) WHERE a > 100 AND b > 3 AND d IS NULL +-- +ok +== +SELECT info['source'] FROM duckdb_logs_parsed('AdaptiveFilter') +WHERE event = 'INIT' AND file_path LIKE '%af_mismatch_2.parquet' ORDER BY timestamp LIMIT 1 +-- +ok +== +SELECT + (SELECT len(info['columns']::INTEGER[]) FROM duckdb_logs_parsed('AdaptiveFilter') + WHERE event = 'INIT' AND file_path LIKE '%af_mismatch_1.parquet' LIMIT 1), + (SELECT len(info['columns']::INTEGER[]) FROM duckdb_logs_parsed('AdaptiveFilter') + WHERE event = 'INIT' AND file_path LIKE '%af_mismatch_2.parquet' LIMIT 1) +-- +ok +== +COPY (SELECT i AS a, i%10 AS b, i%100 AS c FROM range(100000) t(i)) TO '{TEST_DIR}/ord_abc.parquet' (ROW_GROUP_SIZE 10000) +-- +ok +== +COPY (SELECT i%100 AS c, i AS a, i%10 AS b FROM range(100000) t(i)) TO '{TEST_DIR}/ord_cab.parquet' (ROW_GROUP_SIZE 10000) +-- +ok +== +SELECT count(*) FROM read_parquet(['{TEST_DIR}/ord_abc.parquet', '{TEST_DIR}/ord_cab.parquet']) WHERE a > 100 AND b > 3 AND c < 50 +-- +ok +== +SELECT info['source'] FROM duckdb_logs_parsed('AdaptiveFilter') +WHERE event = 'INIT' AND file_path LIKE '%ord_abc.parquet' ORDER BY timestamp LIMIT 1 +-- +ok +== +SELECT info['source'] FROM duckdb_logs_parsed('AdaptiveFilter') +WHERE event = 'INIT' AND file_path LIKE '%ord_cab.parquet' ORDER BY timestamp LIMIT 1 +-- +ok +== +SELECT first.columns = second.columns FROM + (SELECT info['columns'] AS columns, timestamp FROM duckdb_logs_parsed('AdaptiveFilter') + WHERE event = 'INIT' AND file_path LIKE '%ord_abc.parquet' + ORDER BY timestamp DESC LIMIT 1) AS first, + (SELECT info['columns'] AS columns, timestamp FROM duckdb_logs_parsed('AdaptiveFilter') + WHERE event = 'INIT' AND file_path LIKE '%ord_cab.parquet' AND info['source'] = 'SEEDED' + ORDER BY timestamp LIMIT 1) AS second +-- +ok +== +SET threads=2 +-- +ok +== +SELECT + (SELECT count(*) FROM duckdb_logs_parsed('AdaptiveFilter') + WHERE event = 'INIT' AND file_path LIKE '%af_cross_%.parquet' AND info['source'] = 'INITIAL') BETWEEN 1 AND 2, + (SELECT count(*) FROM duckdb_logs_parsed('AdaptiveFilter') + WHERE event = 'INIT' AND file_path LIKE '%af_cross_%.parquet' AND info['source'] = 'SEEDED') >= 1 +-- +ok +== +SELECT count(*) = 0 FROM duckdb_logs_parsed('AdaptiveFilter') AS seeded +WHERE event = 'INIT' AND file_path LIKE '%af_cross_%.parquet' AND info['source'] = 'SEEDED' + AND seeded.permutation NOT IN ( + SELECT permutation FROM duckdb_logs_parsed('AdaptiveFilter') + WHERE event = 'INIT' AND file_path LIKE '%af_cross_%.parquet' + ) +-- +ok +== diff --git a/parser/testdata/corpus/sql/copy/parquet/multi_file/multi_file_filter_integer_types.test b/parser/testdata/corpus/sql/copy/parquet/multi_file/multi_file_filter_integer_types.test new file mode 100644 index 0000000..46b2dff --- /dev/null +++ b/parser/testdata/corpus/sql/copy/parquet/multi_file/multi_file_filter_integer_types.test @@ -0,0 +1,54 @@ +# source: test/sql/copy/parquet/multi_file/multi_file_filter_integer_types.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +COPY (FROM (VALUES ('f1', 42::INT), ('f1', 8::INT), ('f1', NULL::INT)) t(f, i)) TO '{TEST_DIR}/multi_file_filter_f1.parquet' +-- +ok +== +COPY (FROM (VALUES (42::BIGINT, 'f2'), (124::BIGINT, 'f2'), (NULL::BIGINT, 'f2')) t(i, f)) TO '{TEST_DIR}/multi_file_filter_f2.parquet' +-- +ok +== +CREATE VIEW integer_file_first AS FROM read_parquet(['{TEST_DIR}/multi_file_filter_f1.parquet', '{TEST_DIR}/multi_file_filter_f2.parquet']) +-- +ok +== +CREATE VIEW bigint_file_first AS FROM read_parquet(['{TEST_DIR}/multi_file_filter_f2.parquet', '{TEST_DIR}/multi_file_filter_f1.parquet']) +-- +ok +== +SELECT f, i +FROM integer_file_first +WHERE i='042' +-- +ok +== +SELECT f, i +FROM bigint_file_first +WHERE i='042' +ORDER BY ALL +-- +ok +== +SELECT f, i +FROM integer_file_first +WHERE i>10 +ORDER BY ALL +-- +ok +== +SELECT f, i +FROM bigint_file_first +WHERE i>'10' +ORDER BY ALL +-- +ok +== +SELECT f, i +FROM integer_file_first +WHERE i IS NULL +-- +ok +== diff --git a/parser/testdata/corpus/sql/copy/parquet/multi_file/multi_file_filter_mixed.test b/parser/testdata/corpus/sql/copy/parquet/multi_file/multi_file_filter_mixed.test new file mode 100644 index 0000000..43409f7 --- /dev/null +++ b/parser/testdata/corpus/sql/copy/parquet/multi_file/multi_file_filter_mixed.test @@ -0,0 +1,30 @@ +# source: test/sql/copy/parquet/multi_file/multi_file_filter_mixed.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +COPY (FROM (VALUES ('f1', 42), ('f1', 8), ('f1', NULL)) t(f, i)) TO '{TEST_DIR}/multi_file_filter_f1.parquet' +-- +ok +== +COPY (FROM (VALUES ('042', 'f2'), ('124', 'f2'), (NULL, 'f2')) t(i, f)) TO '{TEST_DIR}/multi_file_filter_f2.parquet' +-- +ok +== +CREATE VIEW string_file_first AS FROM read_parquet(['{TEST_DIR}/multi_file_filter_f2.parquet', '{TEST_DIR}/multi_file_filter_f1.parquet']) +-- +ok +== +SELECT f, i +FROM string_file_first +WHERE i='042' +-- +ok +== +SELECT f, i +FROM string_file_first +WHERE i>'10' +ORDER BY ALL +-- +ok +== diff --git a/parser/testdata/corpus/sql/copy/parquet/multi_file/multi_file_filter_struct.test b/parser/testdata/corpus/sql/copy/parquet/multi_file/multi_file_filter_struct.test new file mode 100644 index 0000000..0c6c2ad --- /dev/null +++ b/parser/testdata/corpus/sql/copy/parquet/multi_file/multi_file_filter_struct.test @@ -0,0 +1,112 @@ +# source: test/sql/copy/parquet/multi_file/multi_file_filter_struct.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +COPY ( + SELECT { + 'f': f, + 'i': i + } struct_val +FROM ( + VALUES + ('f1', 42::INT), + ('f1', 8::INT), + ('f1', NULL::INT) + ) t(f, i) +) TO '{TEST_DIR}/multi_file_filter_f1.parquet' +-- +ok +== +COPY ( + SELECT { + 'i': i, + 'f2': f + } struct_val +FROM ( + VALUES + (42::BIGINT, 'f2'), + (124::BIGINT, 'f2'), + (NULL::BIGINT, 'f2') + ) t(i, f) +) TO '{TEST_DIR}/multi_file_filter_f2.parquet' +-- +ok +== +COPY ( + SELECT { + 'f': f, + 'i': i + }::VARIANT struct_val +FROM ( + VALUES + ('f1', 42::INT), + ('f1', 8::INT), + ('f1', NULL::INT) + ) t(f, i) +) TO '{TEST_DIR}/multi_file_filter_f1.parquet' +-- +ok +== +COPY ( + SELECT { + 'i': i, + 'f2': f + }::VARIANT struct_val +FROM ( + VALUES + (42::BIGINT, 'f2'), + (124::BIGINT, 'f2'), + (NULL::BIGINT, 'f2') + ) t(i, f) +) TO '{TEST_DIR}/multi_file_filter_f2.parquet' +-- +ok +== +CREATE OR REPLACE VIEW integer_file_first AS FROM read_parquet(['{TEST_DIR}/multi_file_filter_f1.parquet', '{TEST_DIR}/multi_file_filter_f2.parquet']) +-- +ok +== +CREATE OR REPLACE VIEW bigint_file_first AS FROM read_parquet(['{TEST_DIR}/multi_file_filter_f2.parquet', '{TEST_DIR}/multi_file_filter_f1.parquet']) +-- +ok +== +SELECT struct_val.i +FROM integer_file_first +ORDER BY ALL +-- +ok +== +SELECT struct_val.f, struct_val.i +FROM integer_file_first +WHERE struct_val.i='042'::INTEGER +-- +ok +== +SELECT struct_val.i +FROM bigint_file_first +WHERE struct_val.i='042'::INTEGER +ORDER BY ALL +-- +ok +== +SELECT struct_val.f, struct_val.i +FROM integer_file_first +WHERE struct_val.i>10 +ORDER BY ALL +-- +ok +== +SELECT struct_val.i +FROM bigint_file_first +WHERE struct_val.i>'10'::INTEGER +ORDER BY ALL +-- +ok +== +SELECT struct_val.f, struct_val.i +FROM integer_file_first +WHERE struct_val.i IS NULL +-- +ok +== diff --git a/parser/testdata/corpus/sql/copy/parquet/multi_file_conversion_error.test b/parser/testdata/corpus/sql/copy/parquet/multi_file_conversion_error.test new file mode 100644 index 0000000..12ae556 --- /dev/null +++ b/parser/testdata/corpus/sql/copy/parquet/multi_file_conversion_error.test @@ -0,0 +1,25 @@ +# source: test/sql/copy/parquet/multi_file_conversion_error.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +copy (select 42 as a) to '{TEST_DIR}/conversion_error1.parquet'; +-- +ok +== +copy (select blob 'hello world' as a) to '{TEST_DIR}/conversion_error2.parquet'; +-- +ok +== +SELECT * FROM read_parquet(['{TEST_DIR}/conversion_error1.parquet', '{TEST_DIR}/conversion_error2.parquet']) +-- +ok +== +CREATE TABLE integers(i INT); +-- +ok +== +COPY integers FROM '{TEST_DIR}/conversion_error*.parquet' +-- +ok +== diff --git a/parser/testdata/corpus/sql/copy/parquet/parallel_parquet_glob.test b/parser/testdata/corpus/sql/copy/parquet/parallel_parquet_glob.test new file mode 100644 index 0000000..370d856 --- /dev/null +++ b/parser/testdata/corpus/sql/copy/parquet/parallel_parquet_glob.test @@ -0,0 +1,29 @@ +# source: test/sql/copy/parquet/parallel_parquet_glob.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +select count(*) from parquet_scan('{DATA_DIR}/parquet-testing/glob/t?.parquet') +-- +ok +== +select count(*) from parquet_scan('{DATA_DIR}/parquet-testing/glob/*') +-- +ok +== +select count(*) from parquet_scan('{DATA_DIR}/parquet-testing/glob/*.parquet') +-- +ok +== +select count(*) from parquet_scan('{DATA_DIR}/parquet-testing/g*/*.parquet') +-- +ok +== +select count(*) from parquet_scan('{DATA_DIR}/parquet-testing/g*/t1.parquet') +-- +ok +== +SET parquet_metadata_cache=true +-- +ok +== diff --git a/parser/testdata/corpus/sql/copy/parquet/parquet2.test b/parser/testdata/corpus/sql/copy/parquet/parquet2.test new file mode 100644 index 0000000..13f486d --- /dev/null +++ b/parser/testdata/corpus/sql/copy/parquet/parquet2.test @@ -0,0 +1,33 @@ +# source: test/sql/copy/parquet/parquet2.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +SELECT id FROM '{DATA_DIR}/parquet-testing/p2.parquet' offset 4968; +-- +ok +== +SELECT id FROM '{DATA_DIR}/parquet-testing/p2.parquet' limit 10; +-- +ok +== +SELECT id FROM '{DATA_DIR}/parquet-testing/p2.parquet' limit 100; +-- +ok +== +SELECT id_with_null FROM '{DATA_DIR}/parquet-testing/p2.parquet' limit 100; +-- +ok +== +select min(id), max(id), sum(id), count(id), min(id_with_null), max(id_with_null), sum(id_with_null), count(id_with_null) from '{DATA_DIR}/parquet-testing/p2.parquet' +-- +ok +== +select min(id_int), max(id_int), sum(id_int), count(id_int) from '{DATA_DIR}/parquet-testing/p2.parquet' +-- +ok +== +select * from '{DATA_DIR}/parquet-testing/7-set.snappy.arrow2.parquet'; +-- +ok +== diff --git a/parser/testdata/corpus/sql/copy/parquet/parquet2strings.test b/parser/testdata/corpus/sql/copy/parquet/parquet2strings.test new file mode 100644 index 0000000..dbec5d1 --- /dev/null +++ b/parser/testdata/corpus/sql/copy/parquet/parquet2strings.test @@ -0,0 +1,9 @@ +# source: test/sql/copy/parquet/parquet2strings.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +SELECT id_string FROM '{DATA_DIR}/parquet-testing/p2strings.parquet' limit 10; +-- +ok +== diff --git a/parser/testdata/corpus/sql/copy/parquet/parquet_10148.test b/parser/testdata/corpus/sql/copy/parquet/parquet_10148.test new file mode 100644 index 0000000..be2265d --- /dev/null +++ b/parser/testdata/corpus/sql/copy/parquet/parquet_10148.test @@ -0,0 +1,9 @@ +# source: test/sql/copy/parquet/parquet_10148.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +SELECT CDCONO FROM '{DATA_DIR}/parquet-testing/bug10148-wide-decimal-stats.parquet' +-- +ok +== diff --git a/parser/testdata/corpus/sql/copy/parquet/parquet_10279.test b/parser/testdata/corpus/sql/copy/parquet/parquet_10279.test new file mode 100644 index 0000000..d0b693e --- /dev/null +++ b/parser/testdata/corpus/sql/copy/parquet/parquet_10279.test @@ -0,0 +1,9 @@ +# source: test/sql/copy/parquet/parquet_10279.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +SELECT * FROM '{DATA_DIR}/parquet-testing/issue10279_delta_encoding.parquet' +-- +ok +== diff --git a/parser/testdata/corpus/sql/copy/parquet/parquet_12621.test b/parser/testdata/corpus/sql/copy/parquet/parquet_12621.test new file mode 100644 index 0000000..62e0460 --- /dev/null +++ b/parser/testdata/corpus/sql/copy/parquet/parquet_12621.test @@ -0,0 +1,11 @@ +# source: test/sql/copy/parquet/parquet_12621.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +select * +from read_parquet('{DATA_DIR}/parquet-testing/issue12621.parquet') +limit 1; +-- +ok +== diff --git a/parser/testdata/corpus/sql/copy/parquet/parquet_13053_duplicate_column_names.test b/parser/testdata/corpus/sql/copy/parquet/parquet_13053_duplicate_column_names.test new file mode 100644 index 0000000..5c3d6bc --- /dev/null +++ b/parser/testdata/corpus/sql/copy/parquet/parquet_13053_duplicate_column_names.test @@ -0,0 +1,21 @@ +# source: test/sql/copy/parquet/parquet_13053_duplicate_column_names.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +select name from parquet_schema( '{DATA_DIR}/parquet-testing/bug13053.parquet') offset 1; +-- +ok +== +SELECT column_name FROM (DESCRIBE FROM '{DATA_DIR}/parquet-testing/bug13053.parquet') +-- +ok +== +select name from parquet_schema( '{DATA_DIR}/parquet-testing/bug13053-2.parquet') offset 1; +-- +ok +== +SELECT column_name FROM (DESCRIBE FROM '{DATA_DIR}/parquet-testing/bug13053-2.parquet') +-- +ok +== diff --git a/parser/testdata/corpus/sql/copy/parquet/parquet_1554.test b/parser/testdata/corpus/sql/copy/parquet/parquet_1554.test new file mode 100644 index 0000000..17262f6 --- /dev/null +++ b/parser/testdata/corpus/sql/copy/parquet/parquet_1554.test @@ -0,0 +1,13 @@ +# source: test/sql/copy/parquet/parquet_1554.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +SELECT COUNT(backlink_count) FROM parquet_scan('{DATA_DIR}/parquet-testing/bug1554.parquet') WHERE http_status_code=200 +-- +ok +== +SELECT http_status_code, COUNT(backlink_count) FROM parquet_scan('{DATA_DIR}/parquet-testing/bug1554.parquet') GROUP BY http_status_code ORDER BY http_status_code +-- +ok +== diff --git a/parser/testdata/corpus/sql/copy/parquet/parquet_1588.test b/parser/testdata/corpus/sql/copy/parquet/parquet_1588.test new file mode 100644 index 0000000..91fabf3 --- /dev/null +++ b/parser/testdata/corpus/sql/copy/parquet/parquet_1588.test @@ -0,0 +1,37 @@ +# source: test/sql/copy/parquet/parquet_1588.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +create table some_bools (val boolean); +-- +ok +== +insert into some_bools values (TRUE) +-- +ok +== +select count(*) from some_bools where val = 1; +-- +ok +== +select count(*) from some_bools where val = '1'::bool; +-- +ok +== +SELECT has_image_link FROM parquet_scan('{DATA_DIR}/parquet-testing/bug1588.parquet') where has_image_link = 1 +-- +ok +== +SELECT COUNT(*) FROM parquet_scan('{DATA_DIR}/parquet-testing/bug1588.parquet') WHERE has_image_link = 1 +-- +ok +== +SELECT COUNT(*) FROM parquet_scan('{DATA_DIR}/parquet-testing/bug1588.parquet') WHERE has_image_link = '1'::bool +-- +ok +== +SELECT COUNT(*) FROM parquet_scan('{DATA_DIR}/parquet-testing/bug1588.parquet') WHERE (has_image_link = 1 AND (has_image_alt_text = 0 OR is_image_alt_text_empty = 1)) +-- +ok +== diff --git a/parser/testdata/corpus/sql/copy/parquet/parquet_1589.test b/parser/testdata/corpus/sql/copy/parquet/parquet_1589.test new file mode 100644 index 0000000..c5a0c3f --- /dev/null +++ b/parser/testdata/corpus/sql/copy/parquet/parquet_1589.test @@ -0,0 +1,13 @@ +# source: test/sql/copy/parquet/parquet_1589.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +SELECT backlink_count FROM parquet_scan('{DATA_DIR}/parquet-testing/bug1589.parquet') LIMIT 1 +-- +ok +== +SELECT * FROM parquet_scan('{DATA_DIR}/parquet-testing/bug1589.parquet') +-- +ok +== diff --git a/parser/testdata/corpus/sql/copy/parquet/parquet_1618_struct_strings.test b/parser/testdata/corpus/sql/copy/parquet/parquet_1618_struct_strings.test new file mode 100644 index 0000000..8292db9 --- /dev/null +++ b/parser/testdata/corpus/sql/copy/parquet/parquet_1618_struct_strings.test @@ -0,0 +1,17 @@ +# source: test/sql/copy/parquet/parquet_1618_struct_strings.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +SELECT "inner"['str_field'] FROM parquet_scan('{DATA_DIR}/parquet-testing/bug1618_struct_strings.parquet') +-- +ok +== +SELECT "inner"['f64_field'] FROM parquet_scan('{DATA_DIR}/parquet-testing/bug1618_struct_strings.parquet') +-- +ok +== +SELECT "inner" FROM parquet_scan('{DATA_DIR}/parquet-testing/bug1618_struct_strings.parquet') +-- +ok +== diff --git a/parser/testdata/corpus/sql/copy/parquet/parquet_1619.test b/parser/testdata/corpus/sql/copy/parquet/parquet_1619.test new file mode 100644 index 0000000..17944cf --- /dev/null +++ b/parser/testdata/corpus/sql/copy/parquet/parquet_1619.test @@ -0,0 +1,17 @@ +# source: test/sql/copy/parquet/parquet_1619.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +select struct_extract("inner", 'f64_field') from parquet_scan('{DATA_DIR}/parquet-testing/struct.parquet'); +-- +ok +== +select ("inner")."f64_field" from parquet_scan('{DATA_DIR}/parquet-testing/struct.parquet'); +-- +ok +== +select "inner"['f64_field'] from parquet_scan('{DATA_DIR}/parquet-testing/struct.parquet'); +-- +ok +== diff --git a/parser/testdata/corpus/sql/copy/parquet/parquet_22147_union_by_name_nonnested.test b/parser/testdata/corpus/sql/copy/parquet/parquet_22147_union_by_name_nonnested.test new file mode 100644 index 0000000..4eff8f3 --- /dev/null +++ b/parser/testdata/corpus/sql/copy/parquet/parquet_22147_union_by_name_nonnested.test @@ -0,0 +1,41 @@ +# source: test/sql/copy/parquet/parquet_22147_union_by_name_nonnested.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +COPY (SELECT {'a': 1::INTEGER} AS x) TO '{TEST_DIR}/ubn22147_struct.parquet' (FORMAT PARQUET); +-- +ok +== +COPY (SELECT NULL::INTEGER AS x) TO '{TEST_DIR}/ubn22147_int.parquet' (FORMAT PARQUET); +-- +ok +== +COPY (SELECT NULL AS x) TO '{TEST_DIR}/ubn22147_null.parquet' (FORMAT PARQUET); +-- +ok +== +SELECT x FROM read_parquet(['{TEST_DIR}/ubn22147_struct.parquet', '{TEST_DIR}/ubn22147_int.parquet'], union_by_name=true); +-- +ok +== +SELECT x FROM read_parquet(['{TEST_DIR}/ubn22147_struct.parquet', '{TEST_DIR}/ubn22147_null.parquet'], union_by_name=true); +-- +ok +== +SELECT x FROM read_parquet(['{TEST_DIR}/ubn22147_struct.parquet', '{TEST_DIR}/ubn22147_int.parquet', '{TEST_DIR}/ubn22147_null.parquet'], union_by_name=true); +-- +ok +== +SELECT x FROM read_parquet(['{TEST_DIR}/ubn22147_struct.parquet', '{TEST_DIR}/ubn22147_int.parquet'], union_by_name=true) WHERE x.a = 1; +-- +ok +== +COPY (SELECT 42::INTEGER AS x) TO '{TEST_DIR}/ubn22147_int_val.parquet' (FORMAT PARQUET); +-- +ok +== +SELECT x FROM read_parquet(['{TEST_DIR}/ubn22147_struct.parquet', '{TEST_DIR}/ubn22147_int_val.parquet'], union_by_name=true); +-- +ok +== diff --git a/parser/testdata/corpus/sql/copy/parquet/parquet_2267.test b/parser/testdata/corpus/sql/copy/parquet/parquet_2267.test new file mode 100644 index 0000000..f0a8c55 --- /dev/null +++ b/parser/testdata/corpus/sql/copy/parquet/parquet_2267.test @@ -0,0 +1,13 @@ +# source: test/sql/copy/parquet/parquet_2267.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +SELECT * FROM parquet_scan('{DATA_DIR}/parquet-testing/bug2267.parquet') +-- +ok +== +SELECT assignedLicenses[1] FROM parquet_scan('{DATA_DIR}/parquet-testing/bug2267.parquet') +-- +ok +== diff --git a/parser/testdata/corpus/sql/copy/parquet/parquet_3896.test b/parser/testdata/corpus/sql/copy/parquet/parquet_3896.test new file mode 100644 index 0000000..509577f --- /dev/null +++ b/parser/testdata/corpus/sql/copy/parquet/parquet_3896.test @@ -0,0 +1,67 @@ +# source: test/sql/copy/parquet/parquet_3896.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +CREATE VIEW v1 AS +SELECT map([2], [{'key1': map([3,4],[1,2]), 'key2':2}]) AS x +-- +ok +== +SELECT * FROM v1; +-- +ok +== +COPY v1 +TO '{TEST_DIR}/map.parquet' (FORMAT 'parquet'); +-- +ok +== +SELECT * FROM '{TEST_DIR}/map.parquet'; +-- +ok +== +CREATE VIEW v2 AS +SELECT map([2], [{'key1': map([3,4],[1,2]), 'key2':2}]) AS x +UNION ALL +SELECT map([2], [{'key1': map([3,4],[1,2]), 'key2':2}]) +-- +ok +== +SELECT * FROM v2; +-- +ok +== +COPY v2 +TO '{TEST_DIR}/map.parquet' (FORMAT 'parquet'); +-- +ok +== +CREATE VIEW v3 AS +SELECT {'key': [2], 'val': [{'key1': {'key': [3,4], 'val': [1,2]}, 'key2':2}]} AS x +-- +ok +== +SELECT * FROM v3; +-- +ok +== +COPY v3 +TO '{TEST_DIR}/map.parquet' (FORMAT 'parquet'); +-- +ok +== +CREATE VIEW v4 AS +SELECT {'key': [2], 'val': [{'key1': {'key': [3,4], 'val': [1,2]}, 'key2':[2]}]} AS x +-- +ok +== +SELECT * FROM v4; +-- +ok +== +COPY v4 +TO '{TEST_DIR}/map.parquet' (FORMAT 'parquet'); +-- +ok +== diff --git a/parser/testdata/corpus/sql/copy/parquet/parquet_3989.test b/parser/testdata/corpus/sql/copy/parquet/parquet_3989.test new file mode 100644 index 0000000..dab3add --- /dev/null +++ b/parser/testdata/corpus/sql/copy/parquet/parquet_3989.test @@ -0,0 +1,17 @@ +# source: test/sql/copy/parquet/parquet_3989.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +CREATE TABLE lists as SELECT i as id, [i] as list from range(0,10000) tbl(i); +-- +ok +== +COPY lists to '{TEST_DIR}/list_bug_test.parquet'; +-- +ok +== +SELECT list from '{TEST_DIR}/list_bug_test.parquet' where id = 5000; +-- +ok +== diff --git a/parser/testdata/corpus/sql/copy/parquet/parquet_4442.test b/parser/testdata/corpus/sql/copy/parquet/parquet_4442.test new file mode 100644 index 0000000..626709a --- /dev/null +++ b/parser/testdata/corpus/sql/copy/parquet/parquet_4442.test @@ -0,0 +1,9 @@ +# source: test/sql/copy/parquet/parquet_4442.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +SELECT * FROM '{DATA_DIR}/parquet-testing/bug4442.parquet' +-- +ok +== diff --git a/parser/testdata/corpus/sql/copy/parquet/parquet_4859.test b/parser/testdata/corpus/sql/copy/parquet/parquet_4859.test new file mode 100644 index 0000000..d9cbb27 --- /dev/null +++ b/parser/testdata/corpus/sql/copy/parquet/parquet_4859.test @@ -0,0 +1,9 @@ +# source: test/sql/copy/parquet/parquet_4859.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +select "repositoryTopics.edges" from "{DATA_DIR}/parquet-testing/bug4859.parquet" +-- +ok +== diff --git a/parser/testdata/corpus/sql/copy/parquet/parquet_4903.test b/parser/testdata/corpus/sql/copy/parquet/parquet_4903.test new file mode 100644 index 0000000..75712fe --- /dev/null +++ b/parser/testdata/corpus/sql/copy/parquet/parquet_4903.test @@ -0,0 +1,9 @@ +# source: test/sql/copy/parquet/parquet_4903.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +SELECT type_param_constraints FROM '{DATA_DIR}/parquet-testing/bug4903.parquet' limit 10 +-- +ok +== diff --git a/parser/testdata/corpus/sql/copy/parquet/parquet_5209.test b/parser/testdata/corpus/sql/copy/parquet/parquet_5209.test new file mode 100644 index 0000000..4372fed --- /dev/null +++ b/parser/testdata/corpus/sql/copy/parquet/parquet_5209.test @@ -0,0 +1,20 @@ +# source: test/sql/copy/parquet/parquet_5209.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +CREATE TABLE test_5209 AS SELECT range FROM range(10000); +-- +ok +== +COPY test_5209 TO '{TEST_DIR}/test_5209.parquet' (ROW_GROUP_SIZE 1000, PARQUET_VERSION 'V1'); +-- +ok +== +SELECT SUM(total_compressed_size) > 10000, + SUM(total_uncompressed_size) > 10000, + SUM(total_uncompressed_size) > SUM(total_compressed_size) +FROM parquet_metadata('{TEST_DIR}/test_5209.parquet'); +-- +ok +== diff --git a/parser/testdata/corpus/sql/copy/parquet/parquet_6044.test b/parser/testdata/corpus/sql/copy/parquet/parquet_6044.test new file mode 100644 index 0000000..5317836 --- /dev/null +++ b/parser/testdata/corpus/sql/copy/parquet/parquet_6044.test @@ -0,0 +1,13 @@ +# source: test/sql/copy/parquet/parquet_6044.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +copy (select 0.9 AS a) to '{TEST_DIR}/tiny_decimal.parquet' (format 'parquet', codec 'zstd'); +-- +ok +== +SELECT * FROM '{TEST_DIR}/tiny_decimal.parquet' +-- +ok +== diff --git a/parser/testdata/corpus/sql/copy/parquet/parquet_6580.test b/parser/testdata/corpus/sql/copy/parquet/parquet_6580.test new file mode 100644 index 0000000..223d929 --- /dev/null +++ b/parser/testdata/corpus/sql/copy/parquet/parquet_6580.test @@ -0,0 +1,12 @@ +# source: test/sql/copy/parquet/parquet_6580.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +select *, make_timestamp(dt2*1000*1000) +from read_parquet('{DATA_DIR}/parquet-testing/bug4903.parquet') +where dt2 <= -9214570800 +limit 10 +-- +ok +== diff --git a/parser/testdata/corpus/sql/copy/parquet/parquet_6630_union_by_name.test b/parser/testdata/corpus/sql/copy/parquet/parquet_6630_union_by_name.test new file mode 100644 index 0000000..c27e96f --- /dev/null +++ b/parser/testdata/corpus/sql/copy/parquet/parquet_6630_union_by_name.test @@ -0,0 +1,25 @@ +# source: test/sql/copy/parquet/parquet_6630_union_by_name.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +select + distinct name, + true as is_suspended_or_cancelled +from read_parquet('{DATA_DIR}/parquet-testing/issue6630_*.parquet',union_by_name=True) +where "timestamp" between '2023-01-26 20:00:00' and '2023-01-28 04:00:00' + and (suspended = true or cancelled <> '' or state='SUSPENDED') + and actual_time is null; +-- +ok +== +select + distinct name, + true as is_suspended_or_cancelled +from read_parquet('{DATA_DIR}/parquet-testing/issue6630_*.parquet', union_by_name=False) +where "timestamp" between '2023-01-26 20:00:00' and '2023-01-28 04:00:00' + and (suspended = true or cancelled <> '' or state='SUSPENDED') + and actual_time is null; +-- +ok +== diff --git a/parser/testdata/corpus/sql/copy/parquet/parquet_6933.test b/parser/testdata/corpus/sql/copy/parquet/parquet_6933.test new file mode 100644 index 0000000..80fccfc --- /dev/null +++ b/parser/testdata/corpus/sql/copy/parquet/parquet_6933.test @@ -0,0 +1,50 @@ +# source: test/sql/copy/parquet/parquet_6933.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +CREATE TABLE table1 ( + name VARCHAR, +); +-- +ok +== +INSERT INTO table1 VALUES ('Test value 1!'); +-- +ok +== +INSERT INTO table1 VALUES ('Test value 2!'); +-- +ok +== +COPY table1 TO '{TEST_DIR}/output1.parquet' (FORMAT PARQUET); +-- +ok +== +CREATE TABLE table2 ( + name VARCHAR, + number INTEGER, +); +-- +ok +== +INSERT INTO table2 VALUES ('Other test value', 1); +-- +ok +== +INSERT INTO table2 VALUES ('Other test value', 2); +-- +ok +== +COPY table2 TO '{TEST_DIR}/output2.parquet' (FORMAT PARQUET); +-- +ok +== +set parquet_metadata_cache=true; +-- +ok +== +SELECT name, number FROM read_parquet(['{TEST_DIR}/output*.parquet'], union_by_name=True) ORDER BY name, number +-- +ok +== diff --git a/parser/testdata/corpus/sql/copy/parquet/parquet_all_null_column.test b/parser/testdata/corpus/sql/copy/parquet/parquet_all_null_column.test new file mode 100644 index 0000000..25c5e62 --- /dev/null +++ b/parser/testdata/corpus/sql/copy/parquet/parquet_all_null_column.test @@ -0,0 +1,77 @@ +# source: test/sql/copy/parquet/parquet_all_null_column.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +COPY (SELECT range AS i, NULL::BIGINT AS n FROM range(10000)) TO '{TEST_DIR}/all_null.parquet' (FORMAT PARQUET, ROW_GROUP_SIZE 2048); +-- +ok +== +SELECT count(n) FROM '{TEST_DIR}/all_null.parquet'; +-- +ok +== +SELECT count(*) FROM '{TEST_DIR}/all_null.parquet' WHERE n IS NULL; +-- +ok +== +SELECT count(*) FROM '{TEST_DIR}/all_null.parquet' WHERE n IS NOT NULL; +-- +ok +== +SELECT count(*) FROM '{TEST_DIR}/all_null.parquet' WHERE n > 5; +-- +ok +== +SELECT i, n FROM '{TEST_DIR}/all_null.parquet' WHERE i IN (0, 5000, 9999) ORDER BY i; +-- +ok +== +SELECT n FROM '{TEST_DIR}/all_null.parquet' WHERE i = 1234; +-- +ok +== +SELECT count(*) FROM '{TEST_DIR}/all_null.parquet' WHERE coalesce(n, i) = i; +-- +ok +== +COPY (SELECT range AS i, NULL::VARCHAR AS s, NULL::DOUBLE AS d, NULL::DATE AS dt FROM range(5000)) TO '{TEST_DIR}/all_null_types.parquet' (FORMAT PARQUET); +-- +ok +== +SELECT count(i), count(s), count(d), count(dt) FROM '{TEST_DIR}/all_null_types.parquet'; +-- +ok +== +SELECT s, d, dt FROM '{TEST_DIR}/all_null_types.parquet' WHERE i = 42; +-- +ok +== +COPY (SELECT i, CASE WHEN i % 2 = 0 THEN {'a': NULL::INTEGER} ELSE NULL END AS s FROM range(10) t(i)) TO '{TEST_DIR}/nested_null.parquet' (FORMAT PARQUET); +-- +ok +== +SELECT i, s FROM '{TEST_DIR}/nested_null.parquet' ORDER BY i; +-- +ok +== +SELECT count(*) FROM '{TEST_DIR}/nested_null.parquet' WHERE s IS NULL; +-- +ok +== +COPY (SELECT i, [NULL, NULL]::INTEGER[] AS l FROM range(5) t(i)) TO '{TEST_DIR}/list_null.parquet' (FORMAT PARQUET); +-- +ok +== +SELECT i, l FROM '{TEST_DIR}/list_null.parquet' ORDER BY i; +-- +ok +== +COPY (SELECT i, [{'a': NULL}, {'a': i}, NULL]::STRUCT(a INTEGER)[] AS los FROM range(3) t(i)) TO '{TEST_DIR}/list_of_structs.parquet' (FORMAT PARQUET); +-- +ok +== +SELECT i, los FROM '{TEST_DIR}/list_of_structs.parquet' ORDER BY i; +-- +ok +== diff --git a/parser/testdata/corpus/sql/copy/parquet/parquet_arrow_timestamp.test b/parser/testdata/corpus/sql/copy/parquet/parquet_arrow_timestamp.test new file mode 100644 index 0000000..d25f4d0 --- /dev/null +++ b/parser/testdata/corpus/sql/copy/parquet/parquet_arrow_timestamp.test @@ -0,0 +1,13 @@ +# source: test/sql/copy/parquet/parquet_arrow_timestamp.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +select * from parquet_scan('{DATA_DIR}/parquet-testing/timestamp.parquet') order by 1 +-- +ok +== +select * from parquet_scan('{DATA_DIR}/parquet-testing/timestamp-ms.parquet') order by 1 +-- +ok +== diff --git a/parser/testdata/corpus/sql/copy/parquet/parquet_blob.test b/parser/testdata/corpus/sql/copy/parquet/parquet_blob.test new file mode 100644 index 0000000..febd848 --- /dev/null +++ b/parser/testdata/corpus/sql/copy/parquet/parquet_blob.test @@ -0,0 +1,9 @@ +# source: test/sql/copy/parquet/parquet_blob.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +select * from parquet_scan('{DATA_DIR}/parquet-testing/blob.parquet') +-- +ok +== diff --git a/parser/testdata/corpus/sql/copy/parquet/parquet_blob_string.test b/parser/testdata/corpus/sql/copy/parquet/parquet_blob_string.test new file mode 100644 index 0000000..5e44b08 --- /dev/null +++ b/parser/testdata/corpus/sql/copy/parquet/parquet_blob_string.test @@ -0,0 +1,53 @@ +# source: test/sql/copy/parquet/parquet_blob_string.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +SELECT typeof(#1) FROM parquet_scan('{DATA_DIR}/parquet-testing/binary_string.parquet',binary_as_string=False) limit 1 +-- +ok +== +SELECT * FROM parquet_scan('{DATA_DIR}/parquet-testing/binary_string.parquet',binary_as_string=False) +-- +ok +== +SELECT typeof(#1) FROM parquet_scan('{DATA_DIR}/parquet-testing/binary_string.parquet',binary_as_string=True) limit 1 +-- +ok +== +SELECT * FROM parquet_scan('{DATA_DIR}/parquet-testing/binary_string.parquet',binary_as_string=True) +-- +ok +== +SELECT converted_type FROM parquet_schema('{DATA_DIR}/parquet-testing/binary_string.parquet') +-- +ok +== +SET binary_as_sting=true +-- +ok +== +SET binary_as_string=true +-- +ok +== +SELECT typeof(#1) FROM parquet_scan('{DATA_DIR}/parquet-testing/binary_string.parquet') limit 1 +-- +ok +== +SELECT * FROM parquet_scan('{DATA_DIR}/parquet-testing/binary_string.parquet') +-- +ok +== +SET binary_as_string=false +-- +ok +== +PRAGMA binary_as_string=1 +-- +ok +== +SELECT typeof(#1) FROM parquet_scan('{DATA_DIR}/parquet-testing/binary_string.parquet' ,binary_as_string=False) limit 1 +-- +ok +== diff --git a/parser/testdata/corpus/sql/copy/parquet/parquet_bloom_filter_corruption.test b/parser/testdata/corpus/sql/copy/parquet/parquet_bloom_filter_corruption.test new file mode 100644 index 0000000..c91a07d --- /dev/null +++ b/parser/testdata/corpus/sql/copy/parquet/parquet_bloom_filter_corruption.test @@ -0,0 +1,21 @@ +# source: test/sql/copy/parquet/parquet_bloom_filter_corruption.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +SELECT count(*) FROM read_parquet('{DATA_DIR}/parquet-testing/bloom_filter_bad_numbytes.parquet') +-- +ok +== +SELECT count(*) FROM read_parquet('{DATA_DIR}/parquet-testing/bloom_filter_bad_numbytes.parquet') WHERE r = 0 +-- +ok +== +SELECT count(*) FROM read_parquet('{DATA_DIR}/parquet-testing/bloom_filter_bad_length_range.parquet') WHERE r = 0 +-- +ok +== +SELECT count(*) FROM read_parquet('{DATA_DIR}/parquet-testing/bloom_filter_short_numbytes.parquet') WHERE r = 200 +-- +ok +== diff --git a/parser/testdata/corpus/sql/copy/parquet/parquet_column_metadata_corruption.test b/parser/testdata/corpus/sql/copy/parquet/parquet_column_metadata_corruption.test new file mode 100644 index 0000000..c881d26 --- /dev/null +++ b/parser/testdata/corpus/sql/copy/parquet/parquet_column_metadata_corruption.test @@ -0,0 +1,23 @@ +# source: test/sql/copy/parquet/parquet_column_metadata_corruption.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +SELECT num_values, row_group_num_rows, stats_null_count +FROM parquet_metadata('{DATA_DIR}/parquet-testing/parquet_column_num_values_mismatch.parquet') +WHERE path_in_schema = 'x' +-- +ok +== +SELECT count(*) FROM read_parquet('{DATA_DIR}/parquet-testing/parquet_column_num_values_mismatch.parquet') WHERE x = 3 +-- +ok +== +SELECT x FROM read_parquet('{DATA_DIR}/parquet-testing/parquet_column_num_values_mismatch.parquet') +-- +ok +== +PRAGMA enable_optimizer +-- +ok +== diff --git a/parser/testdata/corpus/sql/copy/parquet/parquet_copy_failure_cleans_up.test b/parser/testdata/corpus/sql/copy/parquet/parquet_copy_failure_cleans_up.test new file mode 100644 index 0000000..317baa7 --- /dev/null +++ b/parser/testdata/corpus/sql/copy/parquet/parquet_copy_failure_cleans_up.test @@ -0,0 +1,21 @@ +# source: test/sql/copy/parquet/parquet_copy_failure_cleans_up.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +copy (select 'hello'::INT) to '{TEST_DIR}/borked.parquet'; +-- +ok +== +from read_parquet('{TEST_DIR}/borked.parquet'); +-- +ok +== +copy (select 123::INT) to '{TEST_DIR}/myfile.parquet'; +-- +ok +== +from read_parquet('{TEST_DIR}/myfile.parquet'); +-- +ok +== diff --git a/parser/testdata/corpus/sql/copy/parquet/parquet_copy_type_mismatch.test b/parser/testdata/corpus/sql/copy/parquet/parquet_copy_type_mismatch.test new file mode 100644 index 0000000..e16b2e6 --- /dev/null +++ b/parser/testdata/corpus/sql/copy/parquet/parquet_copy_type_mismatch.test @@ -0,0 +1,37 @@ +# source: test/sql/copy/parquet/parquet_copy_type_mismatch.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +SET storage_compatibility_version='v1.2.0' +-- +ok +== +COPY (SELECT DATE '1992-01-01' d) TO '{TEST_DIR}/single_date.parquet' (FORMAT parquet); +-- +ok +== +COPY integers FROM '{TEST_DIR}/single_date.parquet' +-- +ok +== +COPY (SELECT DATE '1992-01-01' d, 42 k) TO '{TEST_DIR}/too_many_columns.parquet' (FORMAT parquet); +-- +ok +== +COPY integers FROM '{TEST_DIR}/too_many_columns.parquet' +-- +ok +== +COPY (SELECT 42 i) TO '{TEST_DIR}/f2.parquet' (FORMAT parquet); +-- +ok +== +COPY (SELECT date '1992-01-01' d, 84 i) TO '{TEST_DIR}/f1.parquet' (FORMAT parquet); +-- +ok +== +COPY integers FROM '{TEST_DIR}/f*.parquet' (FORMAT parquet); +-- +ok +== diff --git a/parser/testdata/corpus/sql/copy/parquet/parquet_corrupt_stats.test b/parser/testdata/corpus/sql/copy/parquet/parquet_corrupt_stats.test new file mode 100644 index 0000000..5fbc51c --- /dev/null +++ b/parser/testdata/corpus/sql/copy/parquet/parquet_corrupt_stats.test @@ -0,0 +1,9 @@ +# source: test/sql/copy/parquet/parquet_corrupt_stats.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +FROM '{DATA_DIR}/parquet-testing/out_of_range_stats.parquet' +-- +ok +== diff --git a/parser/testdata/corpus/sql/copy/parquet/parquet_count_star.test b/parser/testdata/corpus/sql/copy/parquet/parquet_count_star.test new file mode 100644 index 0000000..e52a2e3 --- /dev/null +++ b/parser/testdata/corpus/sql/copy/parquet/parquet_count_star.test @@ -0,0 +1,13 @@ +# source: test/sql/copy/parquet/parquet_count_star.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +SELECT COUNT(*) FROM '{DATA_DIR}/parquet-testing/out_of_range_stats.parquet' +-- +ok +== +select COUNT(*) from parquet_scan('{DATA_DIR}/parquet-testing/glob*/t?.parquet') +-- +ok +== diff --git a/parser/testdata/corpus/sql/copy/parquet/parquet_debug_use_openssl.test b/parser/testdata/corpus/sql/copy/parquet/parquet_debug_use_openssl.test new file mode 100644 index 0000000..4a00d96 --- /dev/null +++ b/parser/testdata/corpus/sql/copy/parquet/parquet_debug_use_openssl.test @@ -0,0 +1,13 @@ +# source: test/sql/copy/parquet/parquet_debug_use_openssl.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +COPY (SELECT 42 i) to '{TEST_DIR}/parquet_debug_use_openssl.parquet' (DEBUG_USE_OPENSSL true) +-- +ok +== +SELECT * FROM read_parquet('{TEST_DIR}/parquet_debug_use_openssl.parquet', debug_use_openssl=false) +-- +ok +== diff --git a/parser/testdata/corpus/sql/copy/parquet/parquet_dictionary_zero_sum_aggregate.test b/parser/testdata/corpus/sql/copy/parquet/parquet_dictionary_zero_sum_aggregate.test new file mode 100644 index 0000000..121dbf2 --- /dev/null +++ b/parser/testdata/corpus/sql/copy/parquet/parquet_dictionary_zero_sum_aggregate.test @@ -0,0 +1,20 @@ +# source: test/sql/copy/parquet/parquet_dictionary_zero_sum_aggregate.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +COPY ( + SELECT (i % 2)::INTEGER AS g, 0::BIGINT AS v + FROM range(4096) t(i) + ORDER BY g +) TO '{TEST_DIR}/zero_sum_dict.parquet' (FORMAT PARQUET) +-- +ok +== +SELECT sum(v), count(*) +FROM read_parquet('{TEST_DIR}/zero_sum_dict.parquet') +GROUP BY g +ORDER BY g +-- +ok +== diff --git a/parser/testdata/corpus/sql/copy/parquet/parquet_encoding_skip.test b/parser/testdata/corpus/sql/copy/parquet/parquet_encoding_skip.test new file mode 100644 index 0000000..6c5abc3 --- /dev/null +++ b/parser/testdata/corpus/sql/copy/parquet/parquet_encoding_skip.test @@ -0,0 +1,21 @@ +# source: test/sql/copy/parquet/parquet_encoding_skip.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +COPY (SELECT i id, i AS bigint, i::SMALLINT AS tinyint, i::DOUBLE dbl, 'prefix_' || i::VARCHAR str, 'constant' const_str FROM range(3000) t(i)) TO '{TEST_DIR}/skip.parquet' (PARQUET_VERSION '{parquet_version}'); +-- +ok +== +SELECT * FROM '{TEST_DIR}/skip.parquet' WHERE id>2995 +-- +ok +== +COPY (SELECT i id, [i, i + 1, i + 2] l, {'a': i, 'l': [i, i + 1, i + 2]} struct_1, [{'a': i}, {'a': i + 1}, {'a': i + 2}] struct_2 FROM range(3000) t(i)) TO '{TEST_DIR}/skip_nested.parquet' (PARQUET_VERSION '{parquet_version}'); +-- +ok +== +SELECT * FROM '{TEST_DIR}/skip_nested.parquet' WHERE id>2995 +-- +ok +== diff --git a/parser/testdata/corpus/sql/copy/parquet/parquet_encryption.test b/parser/testdata/corpus/sql/copy/parquet/parquet_encryption.test new file mode 100644 index 0000000..2fcd137 --- /dev/null +++ b/parser/testdata/corpus/sql/copy/parquet/parquet_encryption.test @@ -0,0 +1,81 @@ +# source: test/sql/copy/parquet/parquet_encryption.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +PRAGMA add_parquet_key('my_cool_key', '42') +-- +ok +== +PRAGMA add_parquet_key('my_invalid_duck_key', 'ZHVjaw==') +-- +ok +== +COPY (SELECT 42 i) to '{TEST_DIR}/encrypted.parquet' (ENCRYPTION_CONFIG {column_keys: {key_name: ['col0', 'col1']}}) +-- +ok +== +COPY (SELECT 42 i) to '{TEST_DIR}/encrypted.parquet' (ENCRYPTION_CONFIG {footer_key: 'nonexistant'}) +-- +ok +== +PRAGMA add_parquet_key('key128', '0123456789112345') +-- +ok +== +PRAGMA add_parquet_key('key192', '012345678911234501234567') +-- +ok +== +COPY (SELECT 42 i) to '{TEST_DIR}/encrypted{key_len}.parquet' (ENCRYPTION_CONFIG {footer_key: 'key{key_len}'}) +-- +ok +== +SELECT * FROM read_parquet('{TEST_DIR}/encrypted{key_len}.parquet', encryption_config={footer_key: 'key{key_len}'}) +-- +ok +== +CREATE OR REPLACE TABLE test (i INTEGER) +-- +ok +== +COPY test FROM '{TEST_DIR}/encrypted{key_len}.parquet' (ENCRYPTION_CONFIG {footer_key: 'key{key_len}'}) +-- +ok +== +SELECT * FROM read_parquet('{TEST_DIR}/encrypted128.parquet') +-- +ok +== +SELECT * FROM read_parquet('{TEST_DIR}/encrypted128.parquet', encryption_config={footer_key: 'key192'}) +-- +ok +== +COPY (SELECT 42 i) to '{TEST_DIR}/unencrypted.parquet' +-- +ok +== +SELECT * FROM read_parquet('{TEST_DIR}/unencrypted.parquet', encryption_config={footer_key: 'key256'}) +-- +ok +== +PRAGMA add_parquet_key('key256base64', 'MDEyMzQ1Njc4OTExMjM0NTAxMjM0NTY3ODkxMTIzNDU=') +-- +ok +== +SELECT * FROM read_parquet('{TEST_DIR}/encrypted256.parquet', encryption_config={footer_key: 'key256base64'}) +-- +ok +== +COPY (SELECT 84 i) TO '{TEST_DIR}/encrypted_metadata_cache.parquet' (ENCRYPTION_CONFIG {footer_key: 'key256'}) +-- +ok +== +SELECT * FROM read_parquet('{TEST_DIR}/encrypted_metadata_cache.parquet', encryption_config={footer_key: 'key256'}) +-- +ok +== +SELECT * FROM read_parquet('{TEST_DIR}/encrypted_metadata_cache.parquet', encryption_config={footer_key: 'key192'}) +-- +ok +== diff --git a/parser/testdata/corpus/sql/copy/parquet/parquet_enum_test.test b/parser/testdata/corpus/sql/copy/parquet/parquet_enum_test.test new file mode 100644 index 0000000..cb66917 --- /dev/null +++ b/parser/testdata/corpus/sql/copy/parquet/parquet_enum_test.test @@ -0,0 +1,9 @@ +# source: test/sql/copy/parquet/parquet_enum_test.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +SELECT * FROM parquet_scan('{DATA_DIR}/parquet-testing/adam_genotypes.parquet') +-- +ok +== diff --git a/parser/testdata/corpus/sql/copy/parquet/parquet_expression_filter.test b/parser/testdata/corpus/sql/copy/parquet/parquet_expression_filter.test new file mode 100644 index 0000000..5b8ed96 --- /dev/null +++ b/parser/testdata/corpus/sql/copy/parquet/parquet_expression_filter.test @@ -0,0 +1,34 @@ +# source: test/sql/copy/parquet/parquet_expression_filter.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +CREATE TABLE tbl AS +SELECT i, 'thisisalongstring'||(i%5000)::VARCHAR AS str +FROM range(100000) t(i); +-- +ok +== +COPY tbl TO '{TEST_DIR}/parquet_expr.parquet' +-- +ok +== +CREATE VIEW parq AS FROM '{TEST_DIR}/parquet_expr.parquet' +-- +ok +== +SELECT COUNT(*) FROM parq +WHERE least(str, 'thisisalongstring50') = str +-- +ok +== +SELECT COUNT(*) FROM parq +WHERE least(str, 'thisisalongstring50') = str AND str >= 'this' +-- +ok +== +SELECT COUNT(*) FROM parq +WHERE least(str, 'thisisalongstring50') = str AND str >= 'thisisalongstring2000' AND str <= 'thisisalongstring4000' +-- +ok +== diff --git a/parser/testdata/corpus/sql/copy/parquet/parquet_expression_filter_pruning.test b/parser/testdata/corpus/sql/copy/parquet/parquet_expression_filter_pruning.test new file mode 100644 index 0000000..651dd12 --- /dev/null +++ b/parser/testdata/corpus/sql/copy/parquet/parquet_expression_filter_pruning.test @@ -0,0 +1,298 @@ +# source: test/sql/copy/parquet/parquet_expression_filter_pruning.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +COPY (SELECT range AS a FROM range(102400)) TO '{TEST_DIR}/expr_prune_int.parquet' (ROW_GROUP_SIZE 10240) +-- +ok +== +COPY (SELECT range::DOUBLE AS d FROM range(102400)) TO '{TEST_DIR}/expr_prune_double.parquet' (ROW_GROUP_SIZE 10240) +-- +ok +== +COPY (SELECT range::FLOAT AS f FROM range(102400)) TO '{TEST_DIR}/expr_prune_float.parquet' (ROW_GROUP_SIZE 10240) +-- +ok +== +COPY (SELECT CASE WHEN range = 95000 THEN 'nan'::DOUBLE ELSE range::DOUBLE END AS d FROM range(102400)) TO '{TEST_DIR}/expr_prune_nan.parquet' (ROW_GROUP_SIZE 10240) +-- +ok +== +CALL enable_logging('PhysicalOperator') +-- +ok +== +SELECT count(*) FROM '{TEST_DIR}/expr_prune_int.parquet' WHERE a * 4 + 4 > 327681 +-- +ok +== +CALL disable_logging() +-- +ok +== +SELECT event, count(*) FROM duckdb_logs_parsed('PhysicalOperator') WHERE class='ParquetReader' GROUP BY event ORDER BY event +-- +ok +== +SELECT count(*) FROM '{TEST_DIR}/expr_prune_int.parquet' WHERE a * 4 - 4 < 40961 +-- +ok +== +EXPLAIN SELECT count(*) FROM '{TEST_DIR}/expr_prune_int.parquet' WHERE a * 4 + 4 > 409601 +-- +ok +== +SELECT count(*) FROM '{TEST_DIR}/expr_prune_double.parquet' WHERE d + d < 20479.5e0 +-- +ok +== +SELECT count(*) FROM '{TEST_DIR}/expr_prune_double.parquet' WHERE abs(d) = 42.0 +-- +ok +== +SELECT count(*) FROM '{TEST_DIR}/expr_prune_float.parquet' WHERE abs(f) = 42.0::FLOAT +-- +ok +== +SELECT count(*) FROM '{TEST_DIR}/expr_prune_nan.parquet' WHERE d + d > 184318.5e0 +-- +ok +== +SELECT count(*), min(d), max(d) FROM read_parquet('{TEST_DIR}/expr_prune_nan.parquet', can_have_nan=true) WHERE d + d > 184318.5e0 +-- +ok +== +COPY ( + SELECT range::INTEGER AS x, 'p' || lpad(range::VARCHAR, 6, '0') AS s + FROM range(8192) +) TO '{TEST_DIR}/expr_prune_prefix_or.parquet' (FORMAT PARQUET, ROW_GROUP_SIZE 2048) +-- +ok +== +SELECT count(*), sum(x) +FROM '{TEST_DIR}/expr_prune_prefix_or.parquet' +WHERE prefix(s, 'p0000') OR prefix(s, 'p0050') +-- +ok +== +EXPLAIN ANALYZE SELECT count(*), sum(x) +FROM '{TEST_DIR}/expr_prune_prefix_or.parquet' +WHERE prefix(s, 'p0000') OR prefix(s, 'p0050') +-- +ok +== +CREATE TABLE expr_prune_prefix_corner AS + SELECT range::INTEGER AS x, + CASE + WHEN range < 2048 THEN NULL + WHEN range < 4096 THEN 'a' || lpad((range - 2048)::VARCHAR, 4, '0') + WHEN range < 6144 THEN 'b' || lpad((range - 4096)::VARCHAR, 4, '0') + ELSE 'c' || lpad((range - 6144)::VARCHAR, 4, '0') + END AS s, + CASE WHEN range % 2 = 0 THEN 'a' ELSE 'b' END AS p + FROM range(8192) +-- +ok +== +COPY expr_prune_prefix_corner TO '{TEST_DIR}/expr_prune_prefix_corner.parquet' (FORMAT PARQUET, ROW_GROUP_SIZE 2048) +-- +ok +== +SELECT count(*) +FROM '{TEST_DIR}/expr_prune_prefix_corner.parquet' +WHERE prefix(s, 'b') OR prefix(s, 'd') +-- +ok +== +EXPLAIN ANALYZE SELECT count(*) +FROM '{TEST_DIR}/expr_prune_prefix_corner.parquet' +WHERE prefix(s, 'b') OR prefix(s, 'd') +-- +ok +== +EXPLAIN ANALYZE SELECT count(*) +FROM '{TEST_DIR}/expr_prune_prefix_corner.parquet' +WHERE prefix(s, '') OR prefix(s, 'zz') +-- +ok +== +SELECT count(*) +FROM '{TEST_DIR}/expr_prune_prefix_corner.parquet' +WHERE prefix(s, '') OR prefix(s, 'zz') +-- +ok +== +SELECT count(*) +FROM '{TEST_DIR}/expr_prune_prefix_corner.parquet' +WHERE prefix(s, 'bbbbbbbb') OR prefix(s, 'dddddddd') +-- +ok +== +EXPLAIN ANALYZE SELECT count(*) +FROM '{TEST_DIR}/expr_prune_prefix_corner.parquet' +WHERE prefix(s, 'bbbbbbbb') OR prefix(s, 'dddddddd') +-- +ok +== +SELECT count(*) +FROM '{TEST_DIR}/expr_prune_prefix_corner.parquet' +WHERE prefix(s, p) OR prefix(s, 'd') +-- +ok +== +EXPLAIN ANALYZE SELECT count(*) +FROM '{TEST_DIR}/expr_prune_prefix_corner.parquet' +WHERE prefix(s, p) OR prefix(s, 'd') +-- +ok +== +COPY ( + SELECT CASE WHEN range < 2048 THEN chr(255) || 'a' ELSE chr(256) || 'a' END AS s + FROM range(4096) +) TO '{TEST_DIR}/expr_prune_prefix_utf8_boundary.parquet' (FORMAT PARQUET, ROW_GROUP_SIZE 2048) +-- +ok +== +SELECT count(*) +FROM '{TEST_DIR}/expr_prune_prefix_utf8_boundary.parquet' +WHERE prefix(s, chr(255)) OR prefix(s, 'zz') +-- +ok +== +EXPLAIN ANALYZE SELECT count(*) +FROM '{TEST_DIR}/expr_prune_prefix_utf8_boundary.parquet' +WHERE prefix(s, chr(255)) OR prefix(s, 'zz') +-- +ok +== +SELECT count(*) +FROM '{TEST_DIR}/expr_prune_prefix_or.parquet' +WHERE s ILIKE 'P0000%' +-- +ok +== +EXPLAIN ANALYZE SELECT count(*) +FROM '{TEST_DIR}/expr_prune_prefix_or.parquet' +WHERE s ILIKE 'P0000%' +-- +ok +== +SELECT count(*) +FROM '{TEST_DIR}/expr_prune_prefix_or.parquet' +WHERE s ILIKE 'P000000' +-- +ok +== +EXPLAIN ANALYZE SELECT count(*) +FROM '{TEST_DIR}/expr_prune_prefix_or.parquet' +WHERE s ILIKE 'P000000' +-- +ok +== +COPY ( + SELECT CASE + WHEN range < 2048 THEN 'P0000' || lpad(range::VARCHAR, 4, '0') + WHEN range < 4096 THEN 'p0000' || lpad((range - 2048)::VARCHAR, 4, '0') + WHEN range < 6144 THEN 'Q0000' || lpad((range - 4096)::VARCHAR, 4, '0') + ELSE 'z0000' || lpad((range - 6144)::VARCHAR, 4, '0') + END AS s + FROM range(8192) +) TO '{TEST_DIR}/expr_prune_ilike_case.parquet' (FORMAT PARQUET, ROW_GROUP_SIZE 2048) +-- +ok +== +SELECT count(*) +FROM '{TEST_DIR}/expr_prune_ilike_case.parquet' +WHERE s ILIKE 'p0000%' +-- +ok +== +EXPLAIN ANALYZE SELECT count(*) +FROM '{TEST_DIR}/expr_prune_ilike_case.parquet' +WHERE s ILIKE 'p0000%' +-- +ok +== +COPY ( + SELECT CASE + WHEN range < 2048 THEN 'A' || lpad(range::VARCHAR, 4, '0') + WHEN range < 4096 THEN 'İ' || lpad((range - 2048)::VARCHAR, 4, '0') + WHEN range < 6144 THEN 'K' || lpad((range - 4096)::VARCHAR, 4, '0') + WHEN range < 8192 THEN 'z' || lpad((range - 6144)::VARCHAR, 4, '0') + ELSE 'Å' || lpad((range - 8192)::VARCHAR, 4, '0') + END AS s + FROM range(10240) +) TO '{TEST_DIR}/expr_prune_ilike_unicode_bounds.parquet' (FORMAT PARQUET, ROW_GROUP_SIZE 2048) +-- +ok +== +SELECT count(*) +FROM '{TEST_DIR}/expr_prune_ilike_unicode_bounds.parquet' +WHERE s ILIKE 'i%' +-- +ok +== +EXPLAIN ANALYZE SELECT count(*) +FROM '{TEST_DIR}/expr_prune_ilike_unicode_bounds.parquet' +WHERE s ILIKE 'i%' +-- +ok +== +SELECT count(*) +FROM '{TEST_DIR}/expr_prune_ilike_unicode_bounds.parquet' +WHERE s ILIKE 'k%' +-- +ok +== +EXPLAIN ANALYZE SELECT count(*) +FROM '{TEST_DIR}/expr_prune_ilike_unicode_bounds.parquet' +WHERE s ILIKE 'k%' +-- +ok +== +SELECT count(*) +FROM '{TEST_DIR}/expr_prune_ilike_unicode_bounds.parquet' +WHERE s ILIKE 'İ%' +-- +ok +== +EXPLAIN ANALYZE SELECT count(*) +FROM '{TEST_DIR}/expr_prune_ilike_unicode_bounds.parquet' +WHERE s ILIKE 'İ%' +-- +ok +== +COPY ( + SELECT + repeat('x', CASE WHEN range < 2048 THEN 4 WHEN range < 4096 THEN 20 ELSE 40 END) AS s, + repeat('y', CASE WHEN range < 2048 THEN 4 WHEN range < 4096 THEN 20 ELSE 40 END)::BLOB AS b + FROM range(6144) +) TO '{TEST_DIR}/expr_prune_string_length.parquet' (FORMAT PARQUET, ROW_GROUP_SIZE 2048) +-- +ok +== +SELECT count(*) +FROM '{TEST_DIR}/expr_prune_string_length.parquet' +WHERE strlen(s) > 30 +-- +ok +== +EXPLAIN ANALYZE SELECT sum(strlen(s)) +FROM '{TEST_DIR}/expr_prune_string_length.parquet' +WHERE strlen(s) > 30 +-- +ok +== +SELECT count(*) +FROM '{TEST_DIR}/expr_prune_string_length.parquet' +WHERE octet_length(b) > 30 +-- +ok +== +EXPLAIN ANALYZE SELECT sum(octet_length(b)) +FROM '{TEST_DIR}/expr_prune_string_length.parquet' +WHERE octet_length(b) > 30 +-- +ok +== diff --git a/parser/testdata/corpus/sql/copy/parquet/parquet_external_access.test b/parser/testdata/corpus/sql/copy/parquet/parquet_external_access.test new file mode 100644 index 0000000..6543197 --- /dev/null +++ b/parser/testdata/corpus/sql/copy/parquet/parquet_external_access.test @@ -0,0 +1,33 @@ +# source: test/sql/copy/parquet/parquet_external_access.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +SELECT * FROM '{DATA_DIR}/parquet-testing/arrow/lineitem-arrow.parquet' +-- +ok +== +SELECT * FROM parquet_metadata('{DATA_DIR}/parquet-testing/arrow/lineitem-arrow.parquet') +-- +ok +== +SELECT * FROM parquet_schema('{DATA_DIR}/parquet-testing/arrow/lineitem-arrow.parquet') +-- +ok +== +SELECT * FROM parquet_scan(['{DATA_DIR}/parquet-testing/arrow/lineitem-arrow.parquet', '{DATA_DIR}/parquet-testing/arrow/lineitem-arrow.parquet']) +-- +ok +== +SELECT * FROM glob('{DATA_DIR}/parquet-testing/arrow/lineitem-arrow.parquet') +-- +ok +== +COPY lineitem FROM '{DATA_DIR}/parquet-testing/arrow/lineitem-arrow.parquet' +-- +ok +== +COPY lineitem TO '{TEMP_DIR}/lineitem.parquet' +-- +ok +== diff --git a/parser/testdata/corpus/sql/copy/parquet/parquet_filename.test b/parser/testdata/corpus/sql/copy/parquet/parquet_filename.test new file mode 100644 index 0000000..759c8e9 --- /dev/null +++ b/parser/testdata/corpus/sql/copy/parquet/parquet_filename.test @@ -0,0 +1,87 @@ +# source: test/sql/copy/parquet/parquet_filename.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +select i, j, parse_path(filename)[-2:] from parquet_scan('{DATA_DIR}/parquet-testing/glob*/t?.parquet', FILENAME=1) order by i; +-- +ok +== +SELECT i, j, filename_tail3: array_to_string(parse_path(filename)[-3:], '/') +FROM parquet_scan('{DATA_DIR}/parquet-testing/glob*/t?.parquet', FILENAME=1) +WHERE filename_tail3 = 'parquet-testing/glob2/t1.parquet' +-- +ok +== +SELECT count(filename) FROM parquet_scan('{DATA_DIR}/parquet-testing/p2.parquet', FILENAME=1) where id < 1000; +-- +ok +== +SELECT count(id) FROM parquet_scan('{DATA_DIR}/parquet-testing/p2.parquet', FILENAME=1) where filename >= '{DATA_DIR}'; +-- +ok +== +select parse_path(filename)[-2:] from parquet_scan('{DATA_DIR}/parquet-testing/glob*/t?.parquet', FILENAME=1) where i=2; +-- +ok +== +CREATE TABLE test_csv AS SELECT 1 as id, 'test_csv_content' as filename; +-- +ok +== +COPY test_csv TO '{TEMP_DIR}/filename_as_column.csv' WITH HEADER; +-- +ok +== +SELECT id, filename FROM read_csv_auto('{TEMP_DIR}/filename_as_column.csv', FILENAME=1); +-- +ok +== +CREATE TABLE test AS SELECT 1 as id, 'test' as filename; +-- +ok +== +COPY test TO '{TEMP_DIR}/filename_as_column.parquet'; +-- +ok +== +SELECT * FROM parquet_scan('{TEMP_DIR}/filename_as_column.parquet', FILENAME=1); +-- +ok +== +CREATE TABLE test_copy (i INT, j VARCHAR, filename VARCHAR); +-- +ok +== +INSERT INTO test_copy FROM read_parquet('{DATA_DIR}/parquet-testing/glob/t1.parquet', filename=1, binary_as_string=1); +-- +ok +== +SELECT i, j, parse_path(filename)[-2:] FROM test_copy +-- +ok +== +INSERT INTO test_copy FROM read_parquet('{DATA_DIR}/parquet-testing/glob/t1.parquet', filename=1); +-- +ok +== +COPY test_copy FROM '{DATA_DIR}/parquet-testing/glob/t1.parquet'; +-- +ok +== +CREATE TABLE test_table_large AS SELECT * FROM range(0,10000) tbl(i); +-- +ok +== +COPY test_table_large TO '{TEMP_DIR}/test_table_large.parquet' (ROW_GROUP_SIZE 1000); +-- +ok +== +SELECT sum(i), max(parse_filename(filename)) FROM parquet_scan('{TEMP_DIR}/test_table_large.parquet', FILENAME=1) where i>5000; +-- +ok +== +SELECT i, j, parse_path(filename)[-2:] as file FROM parquet_scan(['{DATA_DIR}/parquet-testing/glob/t1.parquet', '{DATA_DIR}/parquet-testing/glob/t1.parquet', '{DATA_DIR}/parquet-testing/glob/t2.parquet'], FILENAME=1) where filename like '%t1%' +-- +ok +== diff --git a/parser/testdata/corpus/sql/copy/parquet/parquet_filename_filter.test b/parser/testdata/corpus/sql/copy/parquet/parquet_filename_filter.test new file mode 100644 index 0000000..1891124 --- /dev/null +++ b/parser/testdata/corpus/sql/copy/parquet/parquet_filename_filter.test @@ -0,0 +1,69 @@ +# source: test/sql/copy/parquet/parquet_filename_filter.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +select id, value as f, date from parquet_scan('{DATA_DIR}/parquet-testing/hive-partitioning/different_order/*/*/test.parquet', HIVE_PARTITIONING=1) where filename='value1'; +-- +ok +== +select i, j, filename from parquet_scan('{DATA_DIR}/parquet-testing/glob*/t?.parquet', FILENAME=1) order by i; +-- +ok +== +select i, j, filename as file from parquet_scan('{DATA_DIR}/parquet-testing/glob*/t?.parquet', FILENAME=1) where file='{DATA_DIR}/parquet-testing/glob2/t1.parquet' or file='{DATA_DIR}/parquet-testing/glob/t2.parquet' order by i; +-- +ok +== +select i, j, filename as file from parquet_scan('{DATA_DIR}/parquet-testing/glob*/t?.parquet', FILENAME=1) where file='{DATA_DIR}/parquet-testing/glob2/t1.parquet' and i=3 order by i; +-- +ok +== +select i, j, filename as file from parquet_scan('{DATA_DIR}/parquet-testing/glob*/t?.parquet', FILENAME=1) where file='{DATA_DIR}/parquet-testing/glob2/t1.parquet' and i=2 order by i; +-- +ok +== +select id, value, date, filename from parquet_scan('{DATA_DIR}/parquet-testing/hive-partitioning/different_order/*/*/test.parquet', HIVE_PARTITIONING=1, FILENAME=1) order by id; +-- +ok +== +select id, value, date, filename from parquet_scan('{DATA_DIR}/parquet-testing/hive-partitioning/different_order/*/*/test.parquet', HIVE_PARTITIONING=1, FILENAME=1) where concat(date,filename)='2013-01-01{DATA_DIR}/parquet-testing/hive-partitioning/different_order/part=b/date=2013-01-01/test.parquet'; +-- +ok +== +select id, value, date, filename from parquet_scan('{DATA_DIR}/parquet-testing/hive-partitioning/different_order/*/*/test.parquet', HIVE_PARTITIONING=1, FILENAME=1) where concat(date,filename)='2012-01-01{DATA_DIR}/parquet-testing/hive-partitioning/different_order/date=2012-01-01/part=a/test.parquet'; +-- +ok +== +select id, value as f, date from parquet_scan('{DATA_DIR}/parquet-testing/hive-partitioning/different_order/*/*/test.parquet', HIVE_PARTITIONING=1) where f='value2'; +-- +ok +== +select id, value as f, date from parquet_scan('{DATA_DIR}/parquet-testing/hive-partitioning/different_order/*/*/test.parquet', HIVE_PARTITIONING=1) where f='value1'; +-- +ok +== +SET parquet_metadata_cache=true; +-- +ok +== +select id, value from parquet_scan('{DATA_DIR}/parquet-testing/hive-partitioning/*/*/*/test.parquet', FILENAME=1) where filename like '%mismatching_count%' and id > 1; +-- +ok +== +select id, value from parquet_scan('{DATA_DIR}/parquet-testing/hive-partitioning/*/*/*/test.parquet', FILENAME=1) where filename like '%mismatching_count%' and value = 'value1'; +-- +ok +== +select id, value from parquet_scan('{DATA_DIR}/parquet-testing/hive-partitioning/*/*/*/test.parquet', FILENAME=1) where filename like '%mismatching_count%' and value = 'value2'; +-- +ok +== +select id, value from parquet_scan('{DATA_DIR}/parquet-testing/hive-partitioning/*/*/*/test.parquet', FILENAME=1) where filename like '%simple%' and value = 'value1'; +-- +ok +== +select id, value from parquet_scan('{DATA_DIR}/parquet-testing/hive-partitioning/*/*/*/test.parquet', FILENAME=1) where filename like '%simple%' and value = 'value2'; +-- +ok +== diff --git a/parser/testdata/corpus/sql/copy/parquet/parquet_filter_bug1391.test b/parser/testdata/corpus/sql/copy/parquet/parquet_filter_bug1391.test new file mode 100644 index 0000000..52acc16 --- /dev/null +++ b/parser/testdata/corpus/sql/copy/parquet/parquet_filter_bug1391.test @@ -0,0 +1,26 @@ +# source: test/sql/copy/parquet/parquet_filter_bug1391.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +CREATE VIEW tbl AS SELECT * FROM PARQUET_SCAN('{DATA_DIR}/parquet-testing/filter_bug1391.parquet'); +-- +ok +== +SELECT ORGUNITID FROM tbl LIMIT 10 +-- +ok +== +SELECT COUNT(*) FROM tbl; +-- +ok +== +SELECT COUNT(*) FROM tbl +WHERE Namevalidfrom <= '2017-03-01' +AND Namevalidto >= '2017-03-01' +AND Parentnamevalidfrom <= '2017-03-01' +AND Parentnamevalidto >= '2017-03-01' +AND CustomerCode = 'CODE'; +-- +ok +== diff --git a/parser/testdata/corpus/sql/copy/parquet/parquet_filter_dictionary_materialize.test b/parser/testdata/corpus/sql/copy/parquet/parquet_filter_dictionary_materialize.test new file mode 100644 index 0000000..5cf0b7f --- /dev/null +++ b/parser/testdata/corpus/sql/copy/parquet/parquet_filter_dictionary_materialize.test @@ -0,0 +1,32 @@ +# source: test/sql/copy/parquet/parquet_filter_dictionary_materialize.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +COPY (SELECT i::BIGINT AS k, 'this is a sufficiently long string value number ' || i AS v, + 'and here is another long string value number ' || i AS w + FROM range(1, 181) t(i)) +TO '{TEST_DIR}/dict_probe_side.parquet' (FORMAT parquet); +-- +ok +== +COPY (SELECT ((i % 179) + 1)::BIGINT AS k FROM range(0, 409) t(i)) +TO '{TEST_DIR}/dict_build_side.parquet' (FORMAT parquet); +-- +ok +== +SELECT count(*), count(DISTINCT b.v), count(DISTINCT b.w) +FROM '{TEST_DIR}/dict_build_side.parquet' a JOIN '{TEST_DIR}/dict_probe_side.parquet' b ON (a.k=b.k) +-- +ok +== +SELECT b.v, b.w +FROM '{TEST_DIR}/dict_build_side.parquet' a JOIN '{TEST_DIR}/dict_probe_side.parquet' b ON (a.k=b.k) +ORDER BY a.k LIMIT 2 +-- +ok +== +SET disabled_optimizers='join_order'; +-- +ok +== diff --git a/parser/testdata/corpus/sql/copy/parquet/parquet_fixed_length_blob_dict.test b/parser/testdata/corpus/sql/copy/parquet/parquet_fixed_length_blob_dict.test new file mode 100644 index 0000000..034add6 --- /dev/null +++ b/parser/testdata/corpus/sql/copy/parquet/parquet_fixed_length_blob_dict.test @@ -0,0 +1,16 @@ +# source: test/sql/copy/parquet/parquet_fixed_length_blob_dict.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +SELECT + MIN(sfc_key), MAX(sfc_key), + MIN(gps_time), MAX(gps_time), + MIN(intensity), MAX(intensity), + MIN(classification), MAX(classification), + MIN(return_number), MAX(return_number), + MIN(number_of_returns), MAX(number_of_returns) +FROM parquet_scan('{DATA_DIR}/parquet-testing/sorted.zstd_18_131072_small.parquet') +-- +ok +== diff --git a/parser/testdata/corpus/sql/copy/parquet/parquet_glob_cache.test b/parser/testdata/corpus/sql/copy/parquet/parquet_glob_cache.test new file mode 100644 index 0000000..e7923fb --- /dev/null +++ b/parser/testdata/corpus/sql/copy/parquet/parquet_glob_cache.test @@ -0,0 +1,9 @@ +# source: test/sql/copy/parquet/parquet_glob_cache.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +EXPLAIN select count(*) from parquet_scan('{DATA_DIR}/parquet-testing/glob/*') +-- +ok +== diff --git a/parser/testdata/corpus/sql/copy/parquet/parquet_go.test b/parser/testdata/corpus/sql/copy/parquet/parquet_go.test new file mode 100644 index 0000000..794dcc8 --- /dev/null +++ b/parser/testdata/corpus/sql/copy/parquet/parquet_go.test @@ -0,0 +1,9 @@ +# source: test/sql/copy/parquet/parquet_go.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +SELECT * FROM '{DATA_DIR}/parquet-testing/parquet_go.parquet' +-- +ok +== diff --git a/parser/testdata/corpus/sql/copy/parquet/parquet_hive.test b/parser/testdata/corpus/sql/copy/parquet/parquet_hive.test new file mode 100644 index 0000000..394a13f --- /dev/null +++ b/parser/testdata/corpus/sql/copy/parquet/parquet_hive.test @@ -0,0 +1,139 @@ +# source: test/sql/copy/parquet/parquet_hive.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +select id, value, part, date from parquet_scan('{DATA_DIR}/parquet-testing/hive-partitioning/simple/*/*/test.parquet', HIVE_PARTITIONING=1) order by id +-- +ok +== +select id, value, part, date from parquet_scan('{DATA_DIR}/parquet-testing/hive-partitioning/different_order/*/*/test.parquet', HIVE_PARTITIONING=1) order by id +-- +ok +== +select id, date from parquet_scan('{DATA_DIR}/parquet-testing/hive-partitioning/different_order/*/*/test.parquet', HIVE_PARTITIONING=1) where date = '2013-01-01'; +-- +ok +== +select id, date from parquet_scan('{DATA_DIR}/parquet-testing/hive-partitioning/different_order/*/*/test.parquet', HIVE_PARTITIONING=1) where date = '2012-01-01'; +-- +ok +== +select id, date from parquet_scan('{DATA_DIR}/parquet-testing/hive-partitioning/different_order/*/*/test.parquet', HIVE_PARTITIONING=1) where date = '2018-01-01'; +-- +ok +== +select id, value, part, date from parquet_scan('{DATA_DIR}/parquet-testing/hive-partitioning/different_order/*/*/test.parquet', HIVE_PARTITIONING=1) where part='a' OR part='b' order by id; +-- +ok +== +select id, date from parquet_scan('{DATA_DIR}/parquet-testing/hive-partitioning/different_order/*/*/test.parquet', HIVE_PARTITIONING=1) where date = '2013-01-01' and id = 2; +-- +ok +== +select id, date from parquet_scan('{DATA_DIR}/parquet-testing/hive-partitioning/different_order/*/*/test.parquet', HIVE_PARTITIONING=1) where date = '2013-01-01' and id = 1; +-- +ok +== +select id, value, date from parquet_scan('{DATA_DIR}/parquet-testing/hive-partitioning/different_order/*/*/test.parquet', HIVE_PARTITIONING=1) where date = '2012-01-01' and id = 1; +-- +ok +== +select id, value, date from parquet_scan('{DATA_DIR}/parquet-testing/hive-partitioning/different_order/*/*/test.parquet', HIVE_PARTITIONING=1) where date = '2012-01-01' or id <= 2 order by id; +-- +ok +== +select * from parquet_scan('{DATA_DIR}/parquet-testing/hive-partitioning/mismatching_names/*/*/test.parquet', HIVE_PARTITIONING=1) +-- +ok +== +select * from parquet_scan('{DATA_DIR}/parquet-testing/hive-partitioning/mismatching_count/*/*/test.parquet', HIVE_PARTITIONING=1) WHERE part=b +-- +ok +== +select * from parquet_scan('{DATA_DIR}/parquet-testing/hive-partitioning/mismatching_names/*/*/test.parquet', HIVE_PARTITIONING=1, UNION_BY_NAME=1) +-- +ok +== +EXPLAIN select id, date from parquet_scan('{DATA_DIR}/parquet-testing/hive-partitioning/different_order/*/*/test.parquet', HIVE_PARTITIONING=1, HIVE_TYPES_AUTOCAST=0) where date = '2013-01-01'; +-- +ok +== +EXPLAIN select id, date from parquet_scan('{DATA_DIR}/parquet-testing/hive-partitioning/different_order/*/*/test.parquet', HIVE_PARTITIONING=1, HIVE_TYPES_AUTOCAST=0) where date = '2018-01-01'; +-- +ok +== +EXPLAIN select id, value, part, date from parquet_scan('{DATA_DIR}/parquet-testing/hive-partitioning/different_order/*/*/test.parquet', HIVE_PARTITIONING=1) where part='a' OR part='b' order by id; +-- +ok +== +EXPLAIN select id, date from parquet_scan('{DATA_DIR}/parquet-testing/hive-partitioning/simple/*/*/test.parquet', HIVE_PARTITIONING=1, HIVE_TYPES_AUTOCAST=0) where date = '2012-01-01' and id < 10; +-- +ok +== +EXPLAIN select id, date from parquet_scan('{DATA_DIR}/parquet-testing/hive-partitioning/simple/*/*/test.parquet', HIVE_PARTITIONING=1, HIVE_TYPES_AUTOCAST=0) where date = '2013-01-01' and id < 10; +-- +ok +== +select id, value, part, CAST(date AS DATE) as date_cast from parquet_scan('{DATA_DIR}/parquet-testing/hive-partitioning/different_order/*/*/test.parquet', HIVE_PARTITIONING=1) where concat(date_cast::VARCHAR, part) == '2013-01-01b'; +-- +ok +== +explain select id, value, part, CAST(date AS DATE) as date_cast from parquet_scan('{DATA_DIR}/parquet-testing/hive-partitioning/different_order/*/*/test.parquet', HIVE_PARTITIONING=1, HIVE_TYPES_AUTOCAST=0) where concat(date_cast::VARCHAR, part) == '2013-01-01b'; +-- +ok +== +select id, value, part, CAST(date AS DATE) as date_cast from parquet_scan('{DATA_DIR}/parquet-testing/hive-partitioning/different_order/*/*/test.parquet', HIVE_PARTITIONING=1) where concat(date_cast::VARCHAR, part) == '2012-01-01a'; +-- +ok +== +explain select id, value, part, CAST(date AS DATE) as date_cast from parquet_scan('{DATA_DIR}/parquet-testing/hive-partitioning/different_order/*/*/test.parquet', HIVE_PARTITIONING=1, HIVE_TYPES_AUTOCAST=0) where concat(date_cast::VARCHAR, part) == '2012-01-01a'; +-- +ok +== +explain select id, value, part, CAST(date AS DATE) as date_cast from parquet_scan('{DATA_DIR}/parquet-testing/hive-partitioning/different_order/*/*/test.parquet', HIVE_PARTITIONING=1, HIVE_TYPES_AUTOCAST=0) where (date_cast=CAST('2013-01-01' as DATE) AND (value='value1' OR concat(date_cast::VARCHAR, part) == '2013-01-01b')); +-- +ok +== +explain select id, value, part, CAST(date AS DATE) as date_cast from parquet_scan('{DATA_DIR}/parquet-testing/hive-partitioning/different_order/*/*/test.parquet', HIVE_PARTITIONING=1, HIVE_TYPES_AUTOCAST=0) where (date_cast=CAST('2012-01-01' as DATE) AND (value='value2' OR concat(date_cast::VARCHAR, part) == '2012-01-01a')); +-- +ok +== +SELECT a, b, parse_path(filename)[-3:] filename FROM parquet_scan('{DATA_DIR}/parquet-testing/hive-partitioning/hive_col_also_in_file/*/test.parquet', HIVE_PARTITIONING=0, FILENAME=1) order by filename; +-- +ok +== +SELECT a, b, parse_path(filename)[-3:] filename FROM parquet_scan('{DATA_DIR}/parquet-testing/hive-partitioning/hive_col_also_in_file/*/test.parquet', HIVE_PARTITIONING=1, FILENAME=1) order by filename; +-- +ok +== +select id, value, part, date +from parquet_scan('{DATA_DIR}/parquet-testing/hive-partitioning/missing/*/*/test.parquet', HIVE_PARTITIONING=1) +order by id +-- +ok +== +Create table t1 (a int, b int, c int); +-- +ok +== +insert into t1 (select range, {i}*10, {i}*100 from range(0,10)); +-- +error: Parser Error: syntax error at or near "}" +== +COPY (SELECT * FROM t1) TO '{TEMP_DIR}/hive_filters' (FORMAT PARQUET, PARTITION_BY c); +-- +ok +== +COPY (SELECT * FROM t1) TO '{TEMP_DIR}/hive_filters_2' (FORMAT PARQUET, PARTITION_BY (c, b)); +-- +ok +== +EXPLAIN select a from parquet_scan('{TEMP_DIR}/hive_filters/*/*.parquet', HIVE_PARTITIONING=1, HIVE_TYPES_AUTOCAST=0) where c::INT=500 and a::INT < 4; +-- +ok +== +EXPLAIN select a from parquet_scan('{TEMP_DIR}/hive_filters_2/*/*/*.parquet', HIVE_PARTITIONING=1, HIVE_TYPES_AUTOCAST=0) where c::INT > 500 and c::INT < 500; +-- +ok +== diff --git a/parser/testdata/corpus/sql/copy/parquet/parquet_hive2.test b/parser/testdata/corpus/sql/copy/parquet/parquet_hive2.test new file mode 100644 index 0000000..0ea84b4 --- /dev/null +++ b/parser/testdata/corpus/sql/copy/parquet/parquet_hive2.test @@ -0,0 +1,45 @@ +# source: test/sql/copy/parquet/parquet_hive2.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +create or replace table orders(m int,v int,j int); +-- +ok +== +insert into orders select i%12+1,i,j from range(360)t(i),range(1000)s(j); +-- +ok +== +copy (select 2000+(v//12)y,m,v,j from orders) TO '{TEST_DIR}/orders_m' (FORMAT PARQUET, PARTITION_BY (m)); +-- +ok +== +SELECT AVG(y), AVG(m), AVG(v), AVG(j) FROM '{TEST_DIR}/orders_m/**/*.parquet' +-- +ok +== +copy (select 2000+(v//12)y,m,v,j from orders) TO '{TEST_DIR}/orders_y' (FORMAT PARQUET, PARTITION_BY (y)); +-- +ok +== +SELECT AVG(y), AVG(m), AVG(v), AVG(j) FROM '{TEST_DIR}/orders_y/**/*.parquet' +-- +ok +== +copy (select 2000+(v//12)y,m,v,j from orders) TO '{TEST_DIR}/orders_ym' (FORMAT PARQUET,PARTITION_BY (y,m)); +-- +ok +== +SELECT AVG(y), AVG(m), AVG(v), AVG(j) FROM '{TEST_DIR}/orders_ym/**/*.parquet' +-- +ok +== +copy (select 2000+(v//12)y,m,v,j from orders order by random()) TO '{TEST_DIR}/orders_ym_rand' (FORMAT PARQUET,PARTITION_BY (y,m)); +-- +ok +== +SELECT AVG(y), AVG(m), AVG(v), AVG(j) FROM '{TEST_DIR}/orders_ym_rand/**/*.parquet' +-- +ok +== diff --git a/parser/testdata/corpus/sql/copy/parquet/parquet_hive_empty.test b/parser/testdata/corpus/sql/copy/parquet/parquet_hive_empty.test new file mode 100644 index 0000000..e54cdb1 --- /dev/null +++ b/parser/testdata/corpus/sql/copy/parquet/parquet_hive_empty.test @@ -0,0 +1,29 @@ +# source: test/sql/copy/parquet/parquet_hive_empty.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +select * +from parquet_scan('{DATA_DIR}/parquet-testing/hive-partitioning/empty_string/*/*.parquet') +ORDER BY ALL +-- +ok +== +select * +from parquet_scan('{DATA_DIR}/parquet-testing/hive-partitioning/empty_string/*/*.parquet') +WHERE key='NULL' +-- +ok +== +select * +from parquet_scan('{DATA_DIR}/parquet-testing/hive-partitioning/empty_string/*/*.parquet') +WHERE key='a' +-- +ok +== +select * +from parquet_scan('{DATA_DIR}/parquet-testing/hive-partitioning/empty_string/*/*.parquet') +WHERE key='' +-- +ok +== diff --git a/parser/testdata/corpus/sql/copy/parquet/parquet_hive_null.test b/parser/testdata/corpus/sql/copy/parquet/parquet_hive_null.test new file mode 100644 index 0000000..fd44cf2 --- /dev/null +++ b/parser/testdata/corpus/sql/copy/parquet/parquet_hive_null.test @@ -0,0 +1,141 @@ +# source: test/sql/copy/parquet/parquet_hive_null.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +create table test as select i%5 as a, i%2 as b from range(0,10) tbl(i); +-- +ok +== +copy (FROM test UNION ALL select 'NULL' as a, 'NULL' as b) to '{TEST_DIR}/null-parquet' (PARTITION_BY (a,b), FORMAT 'parquet', WRITE_PARTITION_COLUMNS); +-- +ok +== +select * +from parquet_scan('{TEST_DIR}/null-parquet/**/*.parquet', hive_partitioning=1, hive_types={'a': INT}) +ORDER BY ALL +-- +ok +== +create table test2 as select i%5 as a, i%2 as b, i as c from range(0,10) tbl(i); +-- +ok +== +copy (FROM test2 UNION ALL select 'NULL' as a, 'NULL' as b, 'NULL' as c) to '{TEST_DIR}/null-parquet' (PARTITION_BY (a,b), FORMAT 'parquet', OVERWRITE); +-- +ok +== +copy (select 0 as c, NULL::INT as a, NULL::INT as b) to '{TEST_DIR}/hive-default-partition-test' (PARTITION_BY (a, b), FORMAT 'parquet', OVERWRITE); +-- +ok +== +copy (select 1 as c) to '{TEST_DIR}/hive-default-partition-test/a=__HIVE_DEFAULT_PARTITION__/b=__HIVE_DEFAULT_PARTITION__/data.parquet' (FORMAT 'parquet'); +-- +ok +== +select * +from parquet_scan('{TEST_DIR}/hive-default-partition-test/a=__HIVE_DEFAULT_PARTITION__/b=__HIVE_DEFAULT_PARTITION__/data.parquet', hive_partitioning=1, hive_types={'a': INT, 'b': INT}) +ORDER BY ALL +-- +ok +== +CREATE TABLE test_literal_null_partition AS +SELECT * +FROM (VALUES ('NULL', 1), ('ok', 2)) v(p, id); +-- +ok +== +COPY test_literal_null_partition TO '{TEST_DIR}/hive-literal-null-partition' +(FORMAT PARQUET, PARTITION_BY (p), OVERWRITE); +-- +ok +== +SELECT (p IS NULL)::INTEGER AS is_null, COALESCE((p='NULL')::INTEGER, -1) AS equals_literal, id +FROM parquet_scan('{TEST_DIR}/hive-literal-null-partition/**/*.parquet', hive_partitioning=1) +ORDER BY id +-- +ok +== +create table test_null_write as select 1 as c, NULL::INT as a, NULL::INT as b; +-- +ok +== +copy test_null_write to '{TEST_DIR}/hive-null-write-test' (PARTITION_BY (a,b), FORMAT 'parquet'); +-- +ok +== +select * +from parquet_scan('{TEST_DIR}/hive-null-write-test/**/*.parquet', hive_partitioning=1, hive_types={'a': INT, 'b': INT}) +ORDER BY ALL +-- +ok +== +select count(*) from glob('{TEST_DIR}/hive-null-write-test/a=__HIVE_DEFAULT_PARTITION__/b=__HIVE_DEFAULT_PARTITION__/*.parquet'); +-- +ok +== +CREATE TABLE test_hive_default_collision AS +SELECT * +FROM (VALUES ('__HIVE_DEFAULT_PARTITION__', 1), (NULL, 2), ('ok', 3)) v(p, id); +-- +ok +== +COPY test_hive_default_collision TO '{TEST_DIR}/hive-default-collision' +(FORMAT PARQUET, PARTITION_BY (p), OVERWRITE); +-- +ok +== +SELECT (p IS NULL)::INTEGER AS is_null, p, id +FROM parquet_scan('{TEST_DIR}/hive-default-collision/**/*.parquet', hive_partitioning=1) +ORDER BY id +-- +ok +== +select count(*) from glob('{TEST_DIR}/hive-default-collision/p=%5F_HIVE_DEFAULT_PARTITION__/*.parquet'); +-- +ok +== +select count(*) from glob('{TEST_DIR}/hive-default-collision/p=__HIVE_DEFAULT_PARTITION__/*.parquet'); +-- +ok +== +CREATE TABLE test_hive_default_collision_multi AS +SELECT * +FROM (VALUES ('__HIVE_DEFAULT_PARTITION__', 'x', 1), (NULL, 'x', 2), (NULL, NULL, 3)) v(a, b, id); +-- +ok +== +COPY test_hive_default_collision_multi TO '{TEST_DIR}/hive-default-collision-multi' +(FORMAT PARQUET, PARTITION_BY (a, b), OVERWRITE); +-- +ok +== +SELECT (a IS NULL)::INTEGER AS a_is_null, a, b, id +FROM parquet_scan('{TEST_DIR}/hive-default-collision-multi/**/*.parquet', hive_partitioning=1) +ORDER BY id +-- +ok +== +COPY ( + SELECT * FROM ( + VALUES ('__hive_default_partition__', 1), (NULL, 2) + ) v(p, id) +) TO '{TEST_DIR}/hive-default-collision-case' +(FORMAT PARQUET, PARTITION_BY (p), OVERWRITE); +-- +ok +== +SELECT (p IS NULL)::INTEGER AS is_null, p, id +FROM read_parquet('{TEST_DIR}/hive-default-collision-case/**/*.parquet', hive_partitioning=true) +ORDER BY id +-- +ok +== +select count(*) from glob('{TEST_DIR}/hive-default-collision-case/p=%5F_hive_default_partition__/*.parquet'); +-- +ok +== +select count(*) from glob('{TEST_DIR}/hive-default-collision-case/p=__HIVE_DEFAULT_PARTITION__/*.parquet'); +-- +ok +== diff --git a/parser/testdata/corpus/sql/copy/parquet/parquet_hive_override_stats.test b/parser/testdata/corpus/sql/copy/parquet/parquet_hive_override_stats.test new file mode 100644 index 0000000..8afd090 --- /dev/null +++ b/parser/testdata/corpus/sql/copy/parquet/parquet_hive_override_stats.test @@ -0,0 +1,59 @@ +# source: test/sql/copy/parquet/parquet_hive_override_stats.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +COPY (SELECT 1::UBIGINT AS id, 42::UBIGINT AS part) +TO '{TEST_DIR}/hive_override_u' (FORMAT parquet, PARTITION_BY (part), WRITE_PARTITION_COLUMNS true) +-- +ok +== +COPY (SELECT 1::UBIGINT AS id, 42::BIGINT AS part) +TO '{TEST_DIR}/hive_override_s' (FORMAT parquet, PARTITION_BY (part), WRITE_PARTITION_COLUMNS true) +-- +ok +== +SELECT typeof(part), part FROM read_parquet('{TEST_DIR}/hive_override_u/part=42/*.parquet') +-- +ok +== +SELECT typeof(part), part FROM read_parquet('{TEST_DIR}/hive_override_s/part=42/*.parquet') +-- +ok +== +SELECT count(*) +FROM read_parquet('{TEST_DIR}/hive_override_u/part=42/*.parquet') u +JOIN read_parquet('{TEST_DIR}/hive_override_s/part=42/*.parquet') s ON u.part = s.part +-- +ok +== +SELECT count(*) +FROM read_parquet('{TEST_DIR}/hive_override_u/part=42/*.parquet') u +SEMI JOIN (SELECT DISTINCT id, part FROM read_parquet('{TEST_DIR}/hive_override_s/part=42/*.parquet')) s +ON u.id = s.id AND u.part = s.part +-- +ok +== +COPY (SELECT 1::UBIGINT AS id, 7::UBIGINT AS part) +TO '{TEST_DIR}/hive_mismatch' (FORMAT parquet, PARTITION_BY (part), WRITE_PARTITION_COLUMNS false) +-- +ok +== +COPY (SELECT 1::UBIGINT AS id, 999::UBIGINT AS part) +TO '{TEST_DIR}/hive_mismatch/part=7/disagrees.parquet' (FORMAT parquet) +-- +ok +== +SELECT part, count(*) FROM read_parquet('{TEST_DIR}/hive_mismatch/part=7/disagrees.parquet') GROUP BY part +-- +ok +== +SELECT count(*) FROM read_parquet('{TEST_DIR}/hive_mismatch/part=7/disagrees.parquet') WHERE part = 7 +-- +ok +== +SELECT typeof(part), part +FROM read_parquet('{TEST_DIR}/hive_mismatch/part=7/disagrees.parquet', hive_partitioning=false) +-- +ok +== diff --git a/parser/testdata/corpus/sql/copy/parquet/parquet_json_varchar_mismatch.test b/parser/testdata/corpus/sql/copy/parquet/parquet_json_varchar_mismatch.test new file mode 100644 index 0000000..a3421b8 --- /dev/null +++ b/parser/testdata/corpus/sql/copy/parquet/parquet_json_varchar_mismatch.test @@ -0,0 +1,33 @@ +# source: test/sql/copy/parquet/parquet_json_varchar_mismatch.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +COPY (SELECT 'TEST 1' AS groupDn, NULL AS memberDn) TO '{TEST_DIR}/json_varchar_mismatch1.json'; +-- +ok +== +COPY (SELECT 'TEST 1' AS groupDn, 'a' AS memberDn) TO '{TEST_DIR}/json_varchar_mismatch2.json'; +-- +ok +== +COPY (SELECT * FROM '{TEST_DIR}/json_varchar_mismatch1.json') TO '{TEST_DIR}/json_varchar_mismatch1.parquet'; +-- +ok +== +COPY (SELECT * FROM '{TEST_DIR}/json_varchar_mismatch2.json') TO '{TEST_DIR}/json_varchar_mismatch2.parquet'; +-- +ok +== +SELECT * FROM read_parquet('{TEST_DIR}/json_varchar_mismatch*.parquet', union_by_name=true); +-- +ok +== +SELECT typeof(memberDn) FROM '{TEST_DIR}/json_varchar_mismatch1.json'; +-- +ok +== +SELECT logical_type FROM parquet_schema('{TEST_DIR}/json_varchar_mismatch1.parquet') WHERE name='memberDn'; +-- +ok +== diff --git a/parser/testdata/corpus/sql/copy/parquet/parquet_late_materialization.test b/parser/testdata/corpus/sql/copy/parquet/parquet_late_materialization.test new file mode 100644 index 0000000..77c1463 --- /dev/null +++ b/parser/testdata/corpus/sql/copy/parquet/parquet_late_materialization.test @@ -0,0 +1,101 @@ +# source: test/sql/copy/parquet/parquet_late_materialization.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +COPY (SELECT i, i + 1 AS j, i + 2 AS k, -i AS l FROM range(10) t(i)) TO '{TEST_DIR}/late_materialization.parquet'; +-- +ok +== +CREATE VIEW test AS FROM '{TEST_DIR}/late_materialization.parquet'; +-- +ok +== +SET explain_output='optimized_only' +-- +ok +== +explain SELECT * FROM test ORDER BY j DESC LIMIT 2; +-- +ok +== +SELECT * FROM test ORDER BY j DESC LIMIT 2; +-- +ok +== +explain SELECT * FROM test ORDER BY j, i LIMIT 2; +-- +ok +== +SELECT * FROM test ORDER BY j, i LIMIT 2; +-- +ok +== +explain SELECT i FROM test ORDER BY i LIMIT 2; +-- +ok +== +explain SELECT j FROM test WHERE j > 3 ORDER BY i LIMIT 2; +-- +ok +== +SELECT j FROM test WHERE j > 3 ORDER BY i LIMIT 2; +-- +ok +== +explain SELECT * FROM (SELECT i + random() AS i, j, k, l FROM test) ORDER BY i LIMIT 2; +-- +ok +== +SELECT * FROM (SELECT -i i, -j j, -k k, -l l FROM test) ORDER BY -j DESC LIMIT 2 +-- +ok +== +SELECT * FROM (SELECT 100 + i i, 1000 + j j, 10000 + k k, 100000 + l l FROM (SELECT -i i, -j j, -k k, -l l FROM test)) ORDER BY j DESC LIMIT 2 +-- +ok +== +explain SELECT * FROM test LIMIT 2 OFFSET 2; +-- +ok +== +SELECT * FROM test LIMIT 2 OFFSET 2; +-- +ok +== +explain SELECT * FROM test USING SAMPLE 2 ROWS +-- +ok +== +explain SELECT * FROM test USING SAMPLE 10% +-- +ok +== +SELECT * FROM test ORDER BY -j DESC LIMIT 2 +-- +ok +== +SELECT * FROM ( + SELECT * FROM test ORDER BY j DESC LIMIT 2 +) WHERE i=8 +-- +ok +== +SELECT l FROM ( + SELECT * FROM test ORDER BY j DESC LIMIT 2 +) WHERE k=10 +-- +ok +== +COPY (SELECT i, printf('%02d', i + 1) AS j, printf('%02d', i + 2) AS k, -i AS l FROM range(10) t(i)) TO '{TEST_DIR}/late_materialization_varchar.parquet'; +-- +ok +== +CREATE OR REPLACE VIEW test AS FROM '{TEST_DIR}/late_materialization_varchar.parquet'; +-- +ok +== +SELECT j, k, l, i FROM test WHERE i > 5 ORDER BY j DESC LIMIT 2; +-- +ok +== diff --git a/parser/testdata/corpus/sql/copy/parquet/parquet_list.test b/parser/testdata/corpus/sql/copy/parquet/parquet_list.test new file mode 100644 index 0000000..996ce5a --- /dev/null +++ b/parser/testdata/corpus/sql/copy/parquet/parquet_list.test @@ -0,0 +1,37 @@ +# source: test/sql/copy/parquet/parquet_list.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +select count(*) from parquet_scan(['{DATA_DIR}/parquet-testing/glob/t1.parquet', '{DATA_DIR}/parquet-testing/glob/t2.parquet']); +-- +ok +== +select count(*) from parquet_scan(['{DATA_DIR}/parquet-testing/glob/*.parquet', '{DATA_DIR}/parquet-testing/glob/t2.parquet']); +-- +ok +== +select count(*) from parquet_scan(['{DATA_DIR}/parquet-testing/glob/t1.parquet', '{DATA_DIR}/parquet-testing/glob/t1.parquet', '{DATA_DIR}/parquet-testing/glob/t1.parquet', '{DATA_DIR}/parquet-testing/glob/t1.parquet', '{DATA_DIR}/parquet-testing/glob/t1.parquet']); +-- +ok +== +select count(*) from parquet_scan(['{DATA_DIR}/parquet-testing/glob/t1.parquet', '{DATA_DIR}/parquet-testing/glob/t2.parquet', 'this/file/doesnot/exist/hopefully.parquet']); +-- +ok +== +select count(*) from parquet_scan([]::varchar[]); +-- +ok +== +select count(*) from parquet_scan([NULL]); +-- +error: Parser Error: parquet_scan reader cannot take NULL input as parameter +== +select count(*) from parquet_scan(NULL::VARCHAR[]); +-- +error: Parser Error: parquet_scan cannot take NULL list as parameter +== +select count(*) from parquet_scan(NULL::VARCHAR); +-- +error: Parser Error: parquet_scan cannot take NULL list as parameter +== diff --git a/parser/testdata/corpus/sql/copy/parquet/parquet_list.test.metadata.json b/parser/testdata/corpus/sql/copy/parquet/parquet_list.test.metadata.json new file mode 100644 index 0000000..49fc83f --- /dev/null +++ b/parser/testdata/corpus/sql/copy/parquet/parquet_list.test.metadata.json @@ -0,0 +1,7 @@ +{ + "todo": { + "3f979f656adf7bf3": "transformer-raised parser error: upstream rejects in the transformer, not the grammar; expected to clear as transformers land (milestones 3-5)", + "b1f1a96914a59f83": "transformer-raised parser error: upstream rejects in the transformer, not the grammar; expected to clear as transformers land (milestones 3-5)", + "f36a81f7dcade3eb": "transformer-raised parser error: upstream rejects in the transformer, not the grammar; expected to clear as transformers land (milestones 3-5)" + } +} diff --git a/parser/testdata/corpus/sql/copy/parquet/parquet_metadata.test b/parser/testdata/corpus/sql/copy/parquet/parquet_metadata.test new file mode 100644 index 0000000..7de1730 --- /dev/null +++ b/parser/testdata/corpus/sql/copy/parquet/parquet_metadata.test @@ -0,0 +1,62 @@ +# source: test/sql/copy/parquet/parquet_metadata.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +SELECT * FROM parquet_metadata('{DATA_DIR}/parquet-testing/lineitem-top10000.gzip.parquet'); +-- +ok +== +SELECT * FROM parquet_schema('{DATA_DIR}/parquet-testing/lineitem-top10000.gzip.parquet'); +-- +ok +== +SELECT COUNT(*) > 0 FROM parquet_metadata('{DATA_DIR}/parquet-testing/lineitem-top10000.gzip.parquet'); +-- +ok +== +SELECT COUNT(*) > 0 FROM parquet_schema('{DATA_DIR}/parquet-testing/lineitem-top10000.gzip.parquet'); +-- +ok +== +select * from parquet_schema('{DATA_DIR}/parquet-testing/decimal/decimal_dc.parquet'); +-- +ok +== +select * from parquet_schema('{DATA_DIR}/parquet-testing/decimal/int64_decimal.parquet'); +-- +ok +== +select * from parquet_metadata('{DATA_DIR}/parquet-testing/glob/*.parquet'); +-- +ok +== +select * from parquet_schema('{DATA_DIR}/parquet-testing/glob/*.parquet'); +-- +ok +== +select * from parquet_schema(['{DATA_DIR}/parquet-testing/decimal/int64_decimal.parquet', '{DATA_DIR}/parquet-testing/decimal/int64_decimal.parquet']); +-- +ok +== +SELECT name, type, duckdb_type FROM parquet_schema('{DATA_DIR}/parquet-testing/lineitem-top10000.gzip.parquet') WHERE type IS NOT NULL; +-- +ok +== +SELECT column_id, name FROM parquet_schema('data/parquet-testing/lineitem-top10000.gzip.parquet') ORDER BY column_id; +-- +ok +== +WITH per_file AS ( + SELECT file_name, COUNT(*) AS rows_per_file + FROM parquet_schema('data/parquet-testing/glob3/**/*.parquet') + GROUP BY file_name +) +SELECT + SUM(rows_per_file) AS total_rows, + MAX(rows_per_file) AS max_rows_per_filename, + (SELECT COUNT(DISTINCT column_id) FROM parquet_schema('data/parquet-testing/glob3/**/*.parquet')) AS distinct_column_ids +FROM per_file; +-- +ok +== diff --git a/parser/testdata/corpus/sql/copy/parquet/parquet_metadata_blob.test b/parser/testdata/corpus/sql/copy/parquet/parquet_metadata_blob.test new file mode 100644 index 0000000..228387a --- /dev/null +++ b/parser/testdata/corpus/sql/copy/parquet/parquet_metadata_blob.test @@ -0,0 +1,41 @@ +# source: test/sql/copy/parquet/parquet_metadata_blob.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +copy (select * from values ('\x0An\xC3\xB5'::blob), ('\xFFXl\x9D'::blob) tbl(b)) to '{TEST_DIR}/blobs.parquet' +-- +ok +== +select stats_min_value from parquet_metadata('{TEST_DIR}/blobs.parquet') +-- +ok +== +select min(b) from '{TEST_DIR}/blobs.parquet' +-- +ok +== +select stats_max_value from parquet_metadata('{TEST_DIR}/blobs.parquet') +-- +ok +== +select max(b) from '{TEST_DIR}/blobs.parquet' +-- +ok +== +select hex(stats_min_value::BLOB) from parquet_metadata('{TEST_DIR}/blobs.parquet') +-- +ok +== +select hex(min(b)) from '{TEST_DIR}/blobs.parquet' +-- +ok +== +select hex(stats_max_value::BLOB) from parquet_metadata('{TEST_DIR}/blobs.parquet') +-- +ok +== +select hex(max(b)) from '{TEST_DIR}/blobs.parquet' +-- +ok +== diff --git a/parser/testdata/corpus/sql/copy/parquet/parquet_metadata_cache.test b/parser/testdata/corpus/sql/copy/parquet/parquet_metadata_cache.test new file mode 100644 index 0000000..9ad044f --- /dev/null +++ b/parser/testdata/corpus/sql/copy/parquet/parquet_metadata_cache.test @@ -0,0 +1,35 @@ +# source: test/sql/copy/parquet/parquet_metadata_cache.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +select * from parquet_scan('{DATA_DIR}/parquet-testing/cache/cache1.parquet') +-- +ok +== +COPY ( + SELECT * FROM parquet_scan('{DATA_DIR}/parquet-testing/cache/cache1.parquet') + ) +TO '{TEMP_DIR}/cached.parquet' (FORMAT 'parquet') +-- +ok +== +select * from parquet_scan('{TEMP_DIR}/cached.parquet') +-- +ok +== +COPY ( + SELECT * FROM parquet_scan('{DATA_DIR}/parquet-testing/cache/cache2.parquet') + ) +TO '{TEMP_DIR}/cached.parquet' (FORMAT 'parquet') +-- +ok +== +select * from parquet_scan('{DATA_DIR}/parquet-testing/glob/t1.parquet') +-- +ok +== +select * from parquet_scan('{DATA_DIR}/parquet-testing/glob2/t1.parquet') +-- +ok +== diff --git a/parser/testdata/corpus/sql/copy/parquet/parquet_nan.test b/parser/testdata/corpus/sql/copy/parquet/parquet_nan.test new file mode 100644 index 0000000..e2acef3 --- /dev/null +++ b/parser/testdata/corpus/sql/copy/parquet/parquet_nan.test @@ -0,0 +1,30 @@ +# source: test/sql/copy/parquet/parquet_nan.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +select * from parquet_scan('{DATA_DIR}/parquet-testing/nan-float.parquet') order by 1 +-- +ok +== +select * from parquet_scan('{DATA_DIR}/parquet-testing/arrow_nan.parquet', can_have_nan := true) where f='nan'; +-- +ok +== +select * from parquet_scan('{DATA_DIR}/parquet-testing/arrow_nan.parquet', can_have_nan := true) where f>10; +-- +ok +== +select * from parquet_scan('{DATA_DIR}/parquet-testing/arrow_nan.parquet', can_have_nan := true) where d='nan'; +-- +ok +== +select * from parquet_scan('{DATA_DIR}/parquet-testing/arrow_nan.parquet', can_have_nan := true) where d>10; +-- +ok +== +SELECT sum(isnan(f)::INT), sum(isnan(d)::INT) +FROM parquet_scan('{DATA_DIR}/parquet-testing/arrow_nan.parquet', can_have_nan := true) +-- +ok +== diff --git a/parser/testdata/corpus/sql/copy/parquet/parquet_no_stats.test b/parser/testdata/corpus/sql/copy/parquet/parquet_no_stats.test new file mode 100644 index 0000000..02c9969 --- /dev/null +++ b/parser/testdata/corpus/sql/copy/parquet/parquet_no_stats.test @@ -0,0 +1,9 @@ +# source: test/sql/copy/parquet/parquet_no_stats.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +SELECT min(x), max(x) FROM read_parquet('{DATA_DIR}/parquet-testing/no_stats.parquet'); +-- +ok +== diff --git a/parser/testdata/corpus/sql/copy/parquet/parquet_nullbyte.test b/parser/testdata/corpus/sql/copy/parquet/parquet_nullbyte.test new file mode 100644 index 0000000..da29e3d --- /dev/null +++ b/parser/testdata/corpus/sql/copy/parquet/parquet_nullbyte.test @@ -0,0 +1,13 @@ +# source: test/sql/copy/parquet/parquet_nullbyte.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +select * from parquet_scan('{DATA_DIR}/parquet-testing/nullbyte.parquet') +-- +ok +== +select * from parquet_scan('{DATA_DIR}/parquet-testing/nullbyte_multiple.parquet') +-- +ok +== diff --git a/parser/testdata/corpus/sql/copy/parquet/parquet_pandas_date.test b/parser/testdata/corpus/sql/copy/parquet/parquet_pandas_date.test new file mode 100644 index 0000000..85a26f2 --- /dev/null +++ b/parser/testdata/corpus/sql/copy/parquet/parquet_pandas_date.test @@ -0,0 +1,9 @@ +# source: test/sql/copy/parquet/parquet_pandas_date.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +select * from parquet_scan('{DATA_DIR}/parquet-testing/pandas-date.parquet') order by 1 +-- +ok +== diff --git a/parser/testdata/corpus/sql/copy/parquet/parquet_prefetch_cost_model.test b/parser/testdata/corpus/sql/copy/parquet/parquet_prefetch_cost_model.test new file mode 100644 index 0000000..00b45ce --- /dev/null +++ b/parser/testdata/corpus/sql/copy/parquet/parquet_prefetch_cost_model.test @@ -0,0 +1,55 @@ +# source: test/sql/copy/parquet/parquet_prefetch_cost_model.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +COPY ( + SELECT CASE WHEN i % 7 = 0 THEN NULL ELSE i END AS a, + i + 1 AS b, + CASE WHEN i % 11 = 0 THEN NULL ELSE i + 2 END AS c, + hash(i)::VARCHAR AS d, + hash(i + 1)::VARCHAR AS e, + hash(i + 2)::VARCHAR AS f, + hash(i + 3)::VARCHAR AS g, + hash(i + 4)::VARCHAR AS h, + hash(i + 5)::VARCHAR AS ii, + i + 9 AS j + FROM RANGE(8192) t(i) +) TO '{TEST_DIR}/cost_model_gap.parquet' (ROW_GROUP_SIZE 2048, WRITE_BLOOM_FILTER FALSE) +-- +ok +== +CALL enable_logging('ParquetPrefetch') +-- +ok +== +SELECT sum(b + j) FROM read_parquet('{TEST_DIR}/cost_model_gap.parquet') WHERE a >= 0 AND c >= 0 +-- +ok +== +SELECT accepted_column_gap +FROM duckdb_logs_parsed('ParquetPrefetch') +WHERE file_path LIKE '%cost_model_gap.parquet' AND row_group_id = 0 +-- +ok +== +SELECT count(*) +FROM duckdb_logs_parsed('ParquetPrefetch') +WHERE file_path LIKE '%cost_model_gap.parquet' AND (accepted_column_gap < 4096 OR accepted_column_gap > 33554432) +-- +ok +== +SET parquet_prefetch_column_gap=4096 +-- +ok +== +SELECT DISTINCT accepted_column_gap +FROM duckdb_logs_parsed('ParquetPrefetch') +WHERE file_path LIKE '%cost_model_gap.parquet' +-- +ok +== +SET parquet_prefetch_column_gap=0 +-- +ok +== diff --git a/parser/testdata/corpus/sql/copy/parquet/parquet_prefetch_cost_model_remote.test b/parser/testdata/corpus/sql/copy/parquet/parquet_prefetch_cost_model_remote.test new file mode 100644 index 0000000..d3f5fb7 --- /dev/null +++ b/parser/testdata/corpus/sql/copy/parquet/parquet_prefetch_cost_model_remote.test @@ -0,0 +1,33 @@ +# source: test/sql/copy/parquet/parquet_prefetch_cost_model_remote.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +SET enable_external_file_cache=false +-- +ok +== +SELECT count(*) +FROM read_parquet('http://blobs.duckdb.org/data/train-services-window-self-join-benchmark.parquet') t(c0, c1) +WHERE c1 > 500000 +-- +ok +== +SELECT accepted_column_gap +FROM duckdb_logs_parsed('ParquetPrefetch') +WHERE file_path LIKE '%train-services%' AND row_group_id = 0 +-- +ok +== +SELECT count(*) +FROM duckdb_logs_parsed('ParquetPrefetch') +WHERE file_path LIKE '%train-services%' AND (accepted_column_gap < 4096 OR accepted_column_gap > 33554432) +-- +ok +== +SELECT count(DISTINCT accepted_column_gap) > 1 +FROM duckdb_logs_parsed('ParquetPrefetch') +WHERE file_path LIKE '%train-services%' +-- +ok +== diff --git a/parser/testdata/corpus/sql/copy/parquet/parquet_prefetch_metrics_multifile.test b/parser/testdata/corpus/sql/copy/parquet/parquet_prefetch_metrics_multifile.test new file mode 100644 index 0000000..c22f65a --- /dev/null +++ b/parser/testdata/corpus/sql/copy/parquet/parquet_prefetch_metrics_multifile.test @@ -0,0 +1,67 @@ +# source: test/sql/copy/parquet/parquet_prefetch_metrics_multifile.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +SET parquet_prefetch_column_gap=16384 +-- +ok +== +COPY ( + SELECT i AS a, + i + 10 AS b, + CASE + WHEN i % 100 = 50 THEN 51 + ELSE i % 100 + END AS c, + CASE + WHEN i >= 6144 AND i % 1000 = 500 THEN 501 + ELSE i % 1000 + END AS g + FROM RANGE(12288) t(i) +) TO '{TEST_DIR}/multifile_a.parquet' (ROW_GROUP_SIZE 2048, WRITE_BLOOM_FILTER FALSE) +-- +ok +== +COPY ( + SELECT i AS a, + i + 10 AS b, + CASE + WHEN i % 100 = 50 THEN 51 + ELSE i % 100 + END AS c, + CASE + WHEN i >= 6144 AND i % 1000 = 500 THEN 501 + ELSE i % 1000 + END AS g + FROM RANGE(12288) t(i) +) TO '{TEST_DIR}/multifile_b.parquet' (ROW_GROUP_SIZE 2048, WRITE_BLOOM_FILTER FALSE) +-- +ok +== +SELECT sum(a + b + c + g) +FROM read_parquet(['{TEST_DIR}/multifile_a.parquet', '{TEST_DIR}/multifile_b.parquet']) +WHERE g = 500 +-- +ok +== +SELECT row_group_id, fully_filtered, strategy, prefetch_groups +FROM duckdb_logs_parsed('ParquetPrefetch') +WHERE file_path LIKE '%multifile_a.parquet' +ORDER BY row_group_id +-- +ok +== +SELECT row_group_id, fully_filtered, strategy, prefetch_groups +FROM duckdb_logs_parsed('ParquetPrefetch') +WHERE file_path LIKE '%multifile_b.parquet' +ORDER BY row_group_id +-- +ok +== +SELECT sum(a + b + c + g) +FROM read_parquet('{TEST_DIR}/multifile_b.parquet') +WHERE g = 500 +-- +ok +== diff --git a/parser/testdata/corpus/sql/copy/parquet/parquet_prefetch_projection.test b/parser/testdata/corpus/sql/copy/parquet/parquet_prefetch_projection.test new file mode 100644 index 0000000..d67ca5e --- /dev/null +++ b/parser/testdata/corpus/sql/copy/parquet/parquet_prefetch_projection.test @@ -0,0 +1,66 @@ +# source: test/sql/copy/parquet/parquet_prefetch_projection.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +COPY ( + SELECT CASE WHEN i % 7 = 0 THEN NULL ELSE i END AS a, + CASE WHEN i % 11 = 0 THEN NULL ELSE i + 10 END AS b, + i % 1000 AS g, + i % 500 AS d, + hash(i)::VARCHAR AS unproj1, + hash(i + 1)::VARCHAR AS unproj2, + hash(i + 2)::VARCHAR AS unproj3 + FROM RANGE(8192) t(i) +) TO '{TEST_DIR}/rgo_proj.parquet' (ROW_GROUP_SIZE 2048, WRITE_BLOOM_FILTER FALSE) +-- +ok +== +SELECT sum(g + d) +FROM read_parquet('{TEST_DIR}/rgo_proj.parquet') +WHERE a >= 0 AND b >= 0 +-- +ok +== +SELECT row_group_id, fully_filtered, strategy, prefetch_groups +FROM duckdb_logs_parsed('ParquetPrefetch') +WHERE file_path LIKE '%rgo_proj.parquet' +ORDER BY row_group_id +-- +ok +== +COPY ( + SELECT CASE WHEN i % 7 = 0 THEN NULL ELSE i END AS a, + i + 1 AS b, + CASE WHEN i % 11 = 0 THEN NULL ELSE i + 2 END AS c, + hash(i)::VARCHAR AS d, + hash(i + 1)::VARCHAR AS e, + hash(i + 2)::VARCHAR AS f, + hash(i + 3)::VARCHAR AS g, + hash(i + 4)::VARCHAR AS h, + hash(i + 5)::VARCHAR AS ii, + i + 9 AS j + FROM RANGE(8192) t(i) +) TO '{TEST_DIR}/rgo_proj_gap.parquet' (ROW_GROUP_SIZE 2048, WRITE_BLOOM_FILTER FALSE) +-- +ok +== +SELECT sum(b + j) +FROM read_parquet('{TEST_DIR}/rgo_proj_gap.parquet') +WHERE a >= 0 AND c >= 0 +-- +ok +== +SELECT row_group_id, fully_filtered, strategy, prefetch_groups +FROM duckdb_logs_parsed('ParquetPrefetch') +WHERE file_path LIKE '%rgo_proj_gap.parquet' +ORDER BY row_group_id +-- +ok +== +SELECT sum(j) +FROM read_parquet('{TEST_DIR}/rgo_proj_gap.parquet') +WHERE a >= 0 AND c >= 0 +-- +ok +== diff --git a/parser/testdata/corpus/sql/copy/parquet/parquet_prefetch_row_group_outcome.test b/parser/testdata/corpus/sql/copy/parquet/parquet_prefetch_row_group_outcome.test new file mode 100644 index 0000000..b9fc8d9 --- /dev/null +++ b/parser/testdata/corpus/sql/copy/parquet/parquet_prefetch_row_group_outcome.test @@ -0,0 +1,166 @@ +# source: test/sql/copy/parquet/parquet_prefetch_row_group_outcome.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +COPY ( + SELECT i AS a, + i + 10 AS b, + CASE + WHEN i % 100 = 50 THEN 51 + ELSE i % 100 + END AS c, + CASE + WHEN i < 6144 AND i % 1000 = 500 THEN 501 + ELSE i % 1000 + END AS g + FROM RANGE(12288) t(i) +) TO '{TEST_DIR}/rgo.parquet' (ROW_GROUP_SIZE 2048, WRITE_BLOOM_FILTER FALSE) +-- +ok +== +SELECT sum(a + b + c + g) +FROM read_parquet('{TEST_DIR}/rgo.parquet') +WHERE a > 5 AND b > 15 +-- +ok +== +SELECT row_group_id, fully_filtered, strategy, prefetch_groups +FROM duckdb_logs_parsed('ParquetPrefetch') +WHERE file_path LIKE '%rgo.parquet' +ORDER BY row_group_id +-- +ok +== +SELECT sum(a + b + c + g) +FROM read_parquet('{TEST_DIR}/rgo.parquet') +WHERE c = 50 +-- +ok +== +SELECT sum(a + b + c + g) +FROM read_parquet('{TEST_DIR}/rgo.parquet') +WHERE g = 500 +-- +ok +== +SELECT sum(a + b + c + g) +FROM read_parquet('{TEST_DIR}/rgo.parquet') +WHERE a > 100 AND b > 100 AND c = 50 +-- +ok +== +SELECT row_group_id, fully_filtered, strategy, prefetch_groups, minimal_filters +FROM duckdb_logs_parsed('ParquetPrefetch') +WHERE file_path LIKE '%rgo.parquet' +ORDER BY row_group_id +-- +ok +== +COPY ( + SELECT i AS a, + i + 10 AS b, + CASE + WHEN i % 100 = 50 THEN 51 + ELSE i % 100 + END AS c, + CASE + WHEN i >= 6144 AND i % 1000 = 500 THEN 501 + ELSE i % 1000 + END AS g + FROM RANGE(12288) t(i) +) TO '{TEST_DIR}/rgo2.parquet' (ROW_GROUP_SIZE 2048, WRITE_BLOOM_FILTER FALSE) +-- +ok +== +SELECT sum(a + b + c + g) +FROM read_parquet('{TEST_DIR}/rgo2.parquet') +WHERE g = 500 +-- +ok +== +SELECT row_group_id, fully_filtered, strategy, prefetch_groups +FROM duckdb_logs_parsed('ParquetPrefetch') +WHERE file_path LIKE '%rgo2.parquet' +ORDER BY row_group_id +-- +ok +== +COPY ( + SELECT i AS a, + i + 10 AS b, + CASE + WHEN i % 100 = 50 THEN 51 + ELSE i % 100 + END AS c, + CASE + WHEN i < 2048 AND i % 1000 = 500 THEN 501 + ELSE i % 1000 + END AS g + FROM RANGE(24576) t(i) +) TO '{TEST_DIR}/rgo3.parquet' (ROW_GROUP_SIZE 2048, WRITE_BLOOM_FILTER FALSE) +-- +ok +== +SELECT sum(a + b + c + g) +FROM read_parquet('{TEST_DIR}/rgo3.parquet') +WHERE g = 500 +-- +ok +== +SELECT row_group_id, fully_filtered, strategy, prefetch_groups +FROM duckdb_logs_parsed('ParquetPrefetch') +WHERE file_path LIKE '%rgo3.parquet' +ORDER BY row_group_id +-- +ok +== +COPY ( + SELECT i % 100 AS a, + 99 - (i % 100) AS b, + i % 50 AS c, + i AS d + FROM RANGE(8192) t(i) +) TO '{TEST_DIR}/rgo_ab.parquet' (ROW_GROUP_SIZE 2048, WRITE_BLOOM_FILTER FALSE) +-- +ok +== +SELECT sum(a + b + c + d) +FROM read_parquet('{TEST_DIR}/rgo_ab.parquet') +WHERE a > 50 AND b > 50 AND c = 0 +-- +ok +== +SELECT row_group_id, fully_filtered, strategy, prefetch_groups, minimal_filters +FROM duckdb_logs_parsed('ParquetPrefetch') +WHERE file_path LIKE '%rgo_ab.parquet' +ORDER BY row_group_id +-- +ok +== +COPY ( + SELECT i AS a, + hash(i)::VARCHAR AS pad1, + hash(i + 1)::VARCHAR AS pad2, + CASE WHEN i % 100 = 50 THEN 51 ELSE i % 100 END AS c, + hash(i + 2)::VARCHAR AS pad3, + hash(i + 3)::VARCHAR AS pad4, + i AS d + FROM RANGE(8192) t(i) +) TO '{TEST_DIR}/rgo_lazy_gap.parquet' (ROW_GROUP_SIZE 2048, WRITE_BLOOM_FILTER FALSE) +-- +ok +== +SELECT sum(a + d) +FROM read_parquet('{TEST_DIR}/rgo_lazy_gap.parquet') +WHERE c = 50 +-- +ok +== +SELECT row_group_id, fully_filtered, strategy, prefetch_groups +FROM duckdb_logs_parsed('ParquetPrefetch') +WHERE file_path LIKE '%rgo_lazy_gap.parquet' +ORDER BY row_group_id +-- +ok +== diff --git a/parser/testdata/corpus/sql/copy/parquet/parquet_prefetch_strategy_option.test b/parser/testdata/corpus/sql/copy/parquet/parquet_prefetch_strategy_option.test new file mode 100644 index 0000000..e805c48 --- /dev/null +++ b/parser/testdata/corpus/sql/copy/parquet/parquet_prefetch_strategy_option.test @@ -0,0 +1,47 @@ +# source: test/sql/copy/parquet/parquet_prefetch_strategy_option.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +COPY ( + SELECT i AS a, + ((i * 73 + 41) % 1000) AS b, + i AS c, + i AS d, + i AS e + FROM RANGE(8192) t(i) +) TO '{TEST_DIR}/force.parquet' (ROW_GROUP_SIZE 2048, WRITE_BLOOM_FILTER FALSE) +-- +ok +== +SELECT sum(a) FROM read_parquet('{TEST_DIR}/force.parquet', prefetch_strategy='whole_group') +WHERE b >= 0 AND b < 10 +-- +ok +== +SELECT row_group_id, fully_filtered, strategy +FROM duckdb_logs_parsed('ParquetPrefetch') +WHERE file_path LIKE '%force.parquet' +ORDER BY row_group_id +-- +ok +== +SELECT sum(a) FROM read_parquet('{TEST_DIR}/force.parquet', prefetch_strategy='auto') +WHERE b >= 0 AND b < 10 +-- +ok +== +SELECT count(*) FROM duckdb_logs_parsed('ParquetPrefetch') +WHERE file_path LIKE '%force.parquet' + AND strategy IN ('column_wise_eager', 'prefetch_filters') +-- +ok +== +SELECT * FROM read_parquet('{TEST_DIR}/force.parquet', prefetch_strategy='garbage') +-- +ok +== +SELECT count(*) FROM read_parquet('{TEST_DIR}/force.parquet', prefetch_strategy='Whole_Group') +-- +ok +== diff --git a/parser/testdata/corpus/sql/copy/parquet/parquet_prefetch_tracked_memory.test b/parser/testdata/corpus/sql/copy/parquet/parquet_prefetch_tracked_memory.test new file mode 100644 index 0000000..bbe4d92 --- /dev/null +++ b/parser/testdata/corpus/sql/copy/parquet/parquet_prefetch_tracked_memory.test @@ -0,0 +1,21 @@ +# source: test/sql/copy/parquet/parquet_prefetch_tracked_memory.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +copy (select range i from range(16000000)) to '{TEST_DIR}/prefetch_tracked_big.parquet' (ROW_GROUP_SIZE 16000000); +-- +ok +== +set memory_limit='240mb'; +-- +ok +== +select count(*), sum(i) from '{TEST_DIR}/prefetch_tracked_big.parquet'; +-- +ok +== +set disable_parquet_prefetching=true; +-- +ok +== diff --git a/parser/testdata/corpus/sql/copy/parquet/parquet_row_number.test b/parser/testdata/corpus/sql/copy/parquet/parquet_row_number.test new file mode 100644 index 0000000..3c5b14e --- /dev/null +++ b/parser/testdata/corpus/sql/copy/parquet/parquet_row_number.test @@ -0,0 +1,61 @@ +# source: test/sql/copy/parquet/parquet_row_number.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +select min(file_row_number) from parquet_scan('{DATA_DIR}/parquet-testing/lineitem-top10000.gzip.parquet', file_row_number=1); +-- +ok +== +select min(file_row_number), max(file_row_number), avg(file_row_number), count(*) from parquet_scan('{DATA_DIR}/parquet-testing/lineitem-top10000.gzip.parquet', file_row_number=1); +-- +ok +== +select l_orderkey from parquet_scan('{DATA_DIR}/parquet-testing/lineitem-top10000.gzip.parquet', file_row_number=1) where file_row_number=42; +-- +ok +== +select sum(row_number_lag), min(row_number_lag), max(row_number_lag) from (select file_row_number - LAG(file_row_number) OVER (ORDER BY file_row_number) as row_number_lag from parquet_scan('{DATA_DIR}/parquet-testing/lineitem-top10000.gzip.parquet', file_row_number=1)); +-- +ok +== +select min(file_row_number), max(file_row_number), avg(file_row_number), count(*) from parquet_scan('{DATA_DIR}/parquet-testing/manyrowgroups.parquet', file_row_number=1); +-- +ok +== +select sum(row_number_lag), min(row_number_lag), max(row_number_lag) from (select file_row_number - LAG(file_row_number) OVER (ORDER BY file_row_number) as row_number_lag from parquet_scan('{DATA_DIR}/parquet-testing/manyrowgroups.parquet', file_row_number=1)); +-- +ok +== +select row_group_id, row_group_num_rows, stats_min, stats_max from parquet_metadata('{DATA_DIR}/parquet-testing/file_row_number.parquet') order by row_group_id +-- +ok +== +select s.min, s.max, s.has_null, s.has_no_null from (select stats(seq) s from parquet_scan('{DATA_DIR}/parquet-testing/file_row_number.parquet') limit 1) +-- +ok +== +select min(file_row_number), max(file_row_number), count(*) from parquet_scan('{DATA_DIR}/parquet-testing/file_row_number.parquet', file_row_number=1) where seq > 6500; +-- +ok +== +select s.min, s.max, s.has_null, s.has_no_null from (select first(stats(file_row_number)) s from parquet_scan('{DATA_DIR}/parquet-testing/lineitem-top10000.gzip.parquet', file_row_number=1)); +-- +ok +== +PRAGMA explain_output = OPTIMIZED_ONLY; +-- +ok +== +explain select 1 from parquet_scan('{DATA_DIR}/parquet-testing/lineitem-top10000.gzip.parquet', file_row_number=1) where file_row_number > 10000; +-- +ok +== +explain select 1 from parquet_scan('{DATA_DIR}/parquet-testing/lineitem-top10000.gzip.parquet', file_row_number=1) where file_row_number < 0; +-- +ok +== +explain select 1 from parquet_scan('{DATA_DIR}/parquet-testing/lineitem-top10000.gzip.parquet', file_row_number=1) where file_row_number is null; +-- +ok +== diff --git a/parser/testdata/corpus/sql/copy/parquet/parquet_schema_evolution.test b/parser/testdata/corpus/sql/copy/parquet/parquet_schema_evolution.test new file mode 100644 index 0000000..18603b9 --- /dev/null +++ b/parser/testdata/corpus/sql/copy/parquet/parquet_schema_evolution.test @@ -0,0 +1,105 @@ +# source: test/sql/copy/parquet/parquet_schema_evolution.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +COPY (SELECT 42::INT a, 43::INT c) TO '{TEST_DIR}/evolution_1.parquet' (FORMAT PARQUET); +-- +ok +== +COPY (SELECT 88::INT b, 84::INT a) TO '{TEST_DIR}/evolution_2.parquet' (FORMAT PARQUET); +-- +ok +== +SELECT a FROM '{TEST_DIR}/evolution_*.parquet' ORDER BY a +-- +ok +== +SELECT a FROM parquet_scan(['{TEST_DIR}/evolution_2.parquet', '{TEST_DIR}/evolution_1.parquet', '{TEST_DIR}/evolution_*.parquet']) ORDER BY a +-- +ok +== +SELECT b FROM '{TEST_DIR}/evolution_*.parquet' ORDER BY 1 +-- +ok +== +SELECT c FROM '{TEST_DIR}/evolution_*.parquet' ORDER BY 1 +-- +ok +== +CREATE TABLE copy_test(a INT, b INT); +-- +ok +== +COPY copy_test FROM '{TEST_DIR}/evolution_*.parquet' +-- +ok +== +COPY copy_test FROM '{TEST_DIR}/evolution_1.parquet' +-- +ok +== +DROP TABLE copy_test +-- +ok +== +COPY (SELECT 42::INT a, 43::INT b) TO '{TEST_DIR}/evolution_1.parquet' (FORMAT PARQUET); +-- +ok +== +COPY (SELECT 'hello'::VARCHAR b, 84::TINYINT a) TO '{TEST_DIR}/evolution_2.parquet' (FORMAT PARQUET); +-- +ok +== +SELECT a FROM '{TEST_DIR}/evolution_*.parquet' ORDER BY 1 +-- +ok +== +SELECT b FROM parquet_scan(['{TEST_DIR}/evolution_1.parquet', '{TEST_DIR}/evolution_2.parquet']) ORDER BY 1 +-- +ok +== +SELECT b FROM parquet_scan(['{TEST_DIR}/evolution_2.parquet', '{TEST_DIR}/evolution_1.parquet']) ORDER BY 1 +-- +ok +== +COPY (SELECT [42::INT] a, [43::INT] b) TO '{TEST_DIR}/evolution_1.parquet' (FORMAT PARQUET); +-- +ok +== +COPY (SELECT ['hello'::VARCHAR] b, [84::TINYINT] a) TO '{TEST_DIR}/evolution_2.parquet' (FORMAT PARQUET); +-- +ok +== +COPY (SELECT range id, 1::INT a FROM range(10000) UNION ALL SELECT 10000+range id, 2::INT FROM range(10000)) TO '{TEST_DIR}/evolution_1.parquet' (FORMAT PARQUET); +-- +ok +== +COPY (SELECT (20000+range)::BIGINT id, 'hello'::VARCHAR b, 3::BIGINT a FROM range(10000) UNION ALL SELECT (30000+range)::BIGINT id, 'world'::VARCHAR, 4 FROM range(10000)) TO '{TEST_DIR}/evolution_2.parquet' (FORMAT PARQUET); +-- +ok +== +SELECT COUNT(*) FROM '{TEST_DIR}/evolution_*.parquet' WHERE a=2 +-- +ok +== +SELECT COUNT(*) FROM '{TEST_DIR}/evolution_*.parquet' WHERE a>=2 +-- +ok +== +SELECT id, a FROM '{TEST_DIR}/evolution_*.parquet' WHERE id=2 +-- +ok +== +SELECT id, a FROM '{TEST_DIR}/evolution_*.parquet' WHERE id=27777 +-- +ok +== +SELECT id, a FROM '{TEST_DIR}/evolution_*.parquet' WHERE id>=39998 ORDER BY id +-- +ok +== +PRAGMA threads=1 +-- +ok +== diff --git a/parser/testdata/corpus/sql/copy/parquet/parquet_schema_num_children_fix.test b/parser/testdata/corpus/sql/copy/parquet/parquet_schema_num_children_fix.test new file mode 100644 index 0000000..47cdba7 --- /dev/null +++ b/parser/testdata/corpus/sql/copy/parquet/parquet_schema_num_children_fix.test @@ -0,0 +1,81 @@ +# source: test/sql/copy/parquet/parquet_schema_num_children_fix.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +SELECT count(*) FROM parquet_schema('{DATA_DIR}/parquet-testing/empty-group/empty_group_test.parquet'); +-- +ok +== +SELECT name, type, num_children +FROM parquet_schema('{DATA_DIR}/parquet-testing/empty-group/empty_group_test.parquet') +WHERE name = 'inner'; +-- +ok +== +SELECT count(*) FROM '{DATA_DIR}/parquet-testing/issue6990.parquet'; +-- +ok +== +CREATE TABLE test_nested AS SELECT + 1 as id, + {'a': {'b': {'c': 123}}} as deep_nested, + {'x': 1, 'y': 2} as simple_struct; +-- +ok +== +COPY test_nested TO '{TEMP_DIR}/test_nested.parquet' (FORMAT PARQUET); +-- +ok +== +SELECT * FROM '{TEMP_DIR}/test_nested.parquet'; +-- +ok +== +SELECT count(*) > 0 FROM parquet_metadata('{TEMP_DIR}/test_nested.parquet'); +-- +ok +== +CREATE TABLE test_lists AS SELECT + [1, 2, 3] as simple_list, + [{'x': 1}, {'x': 2}] as list_of_structs, + [[1, 2], [3, 4]] as nested_list; +-- +ok +== +COPY test_lists TO '{TEMP_DIR}/test_lists.parquet' (FORMAT PARQUET); +-- +ok +== +SELECT * FROM '{TEMP_DIR}/test_lists.parquet'; +-- +ok +== +CREATE TABLE test_maps AS SELECT + MAP {'a': 1, 'b': 2} as simple_map, + MAP {'nested': {'inner': 123}} as map_of_struct; +-- +ok +== +COPY test_maps TO '{TEMP_DIR}/test_maps.parquet' (FORMAT PARQUET); +-- +ok +== +SELECT * FROM '{TEMP_DIR}/test_maps.parquet'; +-- +ok +== +CREATE TABLE test_nullable AS SELECT + {'a': NULL, 'b': 2} as partial_null, + NULL::STRUCT(x INT, y INT) as full_null; +-- +ok +== +COPY test_nullable TO '{TEMP_DIR}/test_nullable.parquet' (FORMAT PARQUET); +-- +ok +== +SELECT * FROM '{TEMP_DIR}/test_nullable.parquet'; +-- +ok +== diff --git a/parser/testdata/corpus/sql/copy/parquet/parquet_silly.test b/parser/testdata/corpus/sql/copy/parquet/parquet_silly.test new file mode 100644 index 0000000..2f9fe25 --- /dev/null +++ b/parser/testdata/corpus/sql/copy/parquet/parquet_silly.test @@ -0,0 +1,9 @@ +# source: test/sql/copy/parquet/parquet_silly.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +select "önë", "C1", "🦆" from parquet_scan('{DATA_DIR}/parquet-testing/silly-names.parquet') order by 1 +-- +ok +== diff --git a/parser/testdata/corpus/sql/copy/parquet/parquet_sqlnull_write.test b/parser/testdata/corpus/sql/copy/parquet/parquet_sqlnull_write.test new file mode 100644 index 0000000..cfcc390 --- /dev/null +++ b/parser/testdata/corpus/sql/copy/parquet/parquet_sqlnull_write.test @@ -0,0 +1,21 @@ +# source: test/sql/copy/parquet/parquet_sqlnull_write.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +SELECT *, typeof(val) FROM '{DATA_DIR}/parquet-testing/null_type_column.parquet'; +-- +ok +== +SELECT logical_type FROM parquet_schema('{DATA_DIR}/parquet-testing/null_type_column.parquet') WHERE name='val'; +-- +ok +== +COPY (SELECT 1 AS id, 'hello' AS val) TO '{TEST_DIR}/typed_val.parquet' (FORMAT PARQUET); +-- +ok +== +SELECT * FROM read_parquet(['{DATA_DIR}/parquet-testing/null_type_column.parquet', '{TEST_DIR}/typed_val.parquet'], union_by_name=true); +-- +ok +== diff --git a/parser/testdata/corpus/sql/copy/parquet/parquet_stats.test b/parser/testdata/corpus/sql/copy/parquet/parquet_stats.test new file mode 100644 index 0000000..99788ef --- /dev/null +++ b/parser/testdata/corpus/sql/copy/parquet/parquet_stats.test @@ -0,0 +1,125 @@ +# source: test/sql/copy/parquet/parquet_stats.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +select stats_min, stats_max, stats_min_value, stats_max_value from parquet_metadata('{DATA_DIR}/parquet-testing/boolean_stats.parquet'); +-- +ok +== +select stats_min, stats_max, stats_min_value, stats_max_value from parquet_metadata('{DATA_DIR}/parquet-testing/signed_stats.parquet'); +-- +ok +== +select * from '{DATA_DIR}/parquet-testing/signed_stats.parquet'; +-- +ok +== +select stats_min, stats_max, stats_min_value, stats_max_value from parquet_metadata('{DATA_DIR}/parquet-testing/unsigned_stats.parquet'); +-- +ok +== +select * from '{DATA_DIR}/parquet-testing/unsigned_stats.parquet'; +-- +ok +== +select stats_min, stats_max, stats_min_value, stats_max_value from parquet_metadata('{DATA_DIR}/parquet-testing/date_stats.parquet'); +-- +ok +== +select * from '{DATA_DIR}/parquet-testing/date_stats.parquet'; +-- +ok +== +select stats_min, stats_max, stats_min_value, stats_max_value from parquet_metadata('{DATA_DIR}/parquet-testing/varchar_stats.parquet'); +-- +ok +== +select min(str_val), max(str_val), min("hello\x00world"), max("hello\x00world") from '{DATA_DIR}/parquet-testing/varchar_stats.parquet'; +-- +ok +== +select * from '{DATA_DIR}/parquet-testing/varchar_stats.parquet'; +-- +ok +== +select stats_min, stats_max, stats_min_value, stats_max_value from parquet_metadata('{DATA_DIR}/parquet-testing/decimal_stats.parquet'); +-- +ok +== +select * from '{DATA_DIR}/parquet-testing/decimal_stats.parquet'; +-- +ok +== +select stats_min, stats_max, stats_min_value, stats_max_value from parquet_metadata('{DATA_DIR}/parquet-testing/arrow/int32_decimal.parquet'); +-- +ok +== +SELECT * FROM '{DATA_DIR}/parquet-testing/arrow/int32_decimal.parquet' +-- +ok +== +select stats_min, stats_max, stats_min_value, stats_max_value from parquet_metadata('{DATA_DIR}/parquet-testing/arrow/int64_decimal.parquet'); +-- +ok +== +SELECT * FROM '{DATA_DIR}/parquet-testing/arrow/int64_decimal.parquet' +-- +ok +== +SELECT stats_min, stats_max, stats_min_value, stats_max_value FROM parquet_metadata('{DATA_DIR}/parquet-testing/data-types.parquet') +-- +ok +== +SELECT * FROM '{DATA_DIR}/parquet-testing/data-types.parquet' +-- +ok +== +select * from parquet_metadata('{parquet_file}'); +-- +ok +== +copy (select '' i) to '{TEMP_DIR}/test.parquet'; +-- +ok +== +select i is null c0 from '{TEMP_DIR}/test.parquet'; +-- +ok +== +select stats_min_value is null c0, stats_max_value is null c1 from parquet_metadata('{TEMP_DIR}/test.parquet'); +-- +ok +== +select row_group_bytes, row_group_compressed_bytes from parquet_metadata('{TEMP_DIR}/test.parquet'); +-- +ok +== +select row_group_bytes, row_group_compressed_bytes from parquet_metadata('{DATA_DIR}/parquet-testing/varchar_stats.parquet'); +-- +ok +== +COPY (SELECT i::INTEGER AS i FROM range(8192) t(i)) TO '{TEST_DIR}/minmax_cast_stats.parquet' (FORMAT PARQUET, ROW_GROUP_SIZE 2048); +-- +ok +== +SELECT min(i::BIGINT), max(i::BIGINT), typeof(min(i::BIGINT)), typeof(max(i::BIGINT)) +FROM read_parquet('{TEST_DIR}/minmax_cast_stats.parquet'); +-- +ok +== +EXPLAIN ANALYZE SELECT min(i::BIGINT), max(i::BIGINT) +FROM read_parquet('{TEST_DIR}/minmax_cast_stats.parquet'); +-- +ok +== +SELECT min(TRY_CAST(i AS BIGINT)), max(TRY_CAST(i AS BIGINT)), typeof(min(TRY_CAST(i AS BIGINT))), typeof(max(TRY_CAST(i AS BIGINT))) +FROM read_parquet('{TEST_DIR}/minmax_cast_stats.parquet'); +-- +ok +== +EXPLAIN ANALYZE SELECT min(TRY_CAST(i AS BIGINT)), max(TRY_CAST(i AS BIGINT)) +FROM read_parquet('{TEST_DIR}/minmax_cast_stats.parquet'); +-- +ok +== diff --git a/parser/testdata/corpus/sql/copy/parquet/parquet_string_stats.test b/parser/testdata/corpus/sql/copy/parquet/parquet_string_stats.test new file mode 100644 index 0000000..cfb7657 --- /dev/null +++ b/parser/testdata/corpus/sql/copy/parquet/parquet_string_stats.test @@ -0,0 +1,9 @@ +# source: test/sql/copy/parquet/parquet_string_stats.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +select s.min, s.max from (select stats(l_comment) s from 'data/parquet-testing/lineitem-top10000.gzip.parquet') LIMIT 1 +-- +ok +== diff --git a/parser/testdata/corpus/sql/copy/parquet/parquet_union_by_name.test b/parser/testdata/corpus/sql/copy/parquet/parquet_union_by_name.test new file mode 100644 index 0000000..162b776 --- /dev/null +++ b/parser/testdata/corpus/sql/copy/parquet/parquet_union_by_name.test @@ -0,0 +1,89 @@ +# source: test/sql/copy/parquet/parquet_union_by_name.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +CREATE OR REPLACE TABLE ubn1(a BIGINT); +-- +ok +== +CREATE OR REPLACE TABLE ubn2(a INTEGER, b INTEGER); +-- +ok +== +CREATE OR REPLACE TABLE ubn3(a INTEGER, c INTEGER); +-- +ok +== +COPY ubn1 TO '{TEST_DIR}/ubn1.parquet' WITH (FORMAT PARQUET); +-- +ok +== +COPY ubn2 TO '{TEST_DIR}/ubn2.parquet' WITH (FORMAT PARQUET); +-- +ok +== +COPY ubn3 TO '{TEST_DIR}/ubn3.parquet' WITH (FORMAT PARQUET); +-- +ok +== +SELECT a,b,c FROM parquet_scan('{TEST_DIR}/ubn*.parquet') +-- +ok +== +SELECT a,b,c +FROM parquet_scan('{TEST_DIR}/ubn*.parquet', UNION_BY_NAME=TRUE) +ORDER BY a; +-- +ok +== +SELECT a +FROM parquet_scan(['{TEST_DIR}/ubn2.parquet', '{TEST_DIR}/ubn1.parquet', '{TEST_DIR}/ubn3.parquet']) +ORDER BY a; +-- +ok +== +SELECT a +FROM parquet_scan('{TEST_DIR}/ubn*.parquet', UNION_BY_NAME=TRUE) +ORDER BY a; +-- +ok +== +SELECT b +FROM parquet_scan('{TEST_DIR}/ubn*.parquet') +ORDER BY b; +-- +ok +== +SELECT b +FROM parquet_scan('{TEST_DIR}/ubn*.parquet', UNION_BY_NAME=TRUE) +ORDER BY b; +-- +ok +== +SELECT typeof(a), typeof(b), typeof(c) +FROM parquet_scan('{TEST_DIR}/ubn*.parquet', UNION_BY_NAME=TRUE) +LIMIT 1; +-- +ok +== +COPY (SELECT [42::INT] a, [43::INT] b) TO '{TEST_DIR}/listubn1.parquet' (FORMAT PARQUET) +-- +ok +== +COPY (SELECT [44::BIGINT] b, [45::INT] c) TO '{TEST_DIR}/listubn2.parquet' (FORMAT PARQUET) +-- +ok +== +SELECT a,b,c +FROM parquet_scan('{TEST_DIR}/listubn[12].parquet', union_by_name=true) +ORDER BY a; +-- +ok +== +SELECT typeof(a),typeof(b),typeof(c) +FROM parquet_scan('{TEST_DIR}/listubn[12].parquet', union_by_name=true) +LIMIT 1; +-- +ok +== diff --git a/parser/testdata/corpus/sql/copy/parquet/parquet_virtual_columns.test b/parser/testdata/corpus/sql/copy/parquet/parquet_virtual_columns.test new file mode 100644 index 0000000..2db8828 --- /dev/null +++ b/parser/testdata/corpus/sql/copy/parquet/parquet_virtual_columns.test @@ -0,0 +1,35 @@ +# source: test/sql/copy/parquet/parquet_virtual_columns.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +SELECT file_index FROM '{DATA_DIR}/parquet-testing/glob/t1.parquet' +-- +ok +== +SELECT file_index, i, j FROM read_parquet(['{DATA_DIR}/parquet-testing/glob/t1.parquet', '{DATA_DIR}/parquet-testing/glob/t2.parquet', '{DATA_DIR}/parquet-testing/glob2/t1.parquet']) +-- +ok +== +SELECT file_index, i, j +FROM read_parquet(['{DATA_DIR}/parquet-testing/glob/t1.parquet', '{DATA_DIR}/parquet-testing/glob/t2.parquet', '{DATA_DIR}/parquet-testing/glob2/t1.parquet']) +WHERE file_index=1 +-- +ok +== +select filename from '{DATA_DIR}/parquet-testing/glob/t1.parquet' +-- +ok +== +select i, j, parse_path(filename)[-2:] from '{DATA_DIR}/parquet-testing/glob*/t?.parquet' order by i; +-- +ok +== +select * from '{DATA_DIR}/parquet-testing/glob*/t?.parquet' order by i; +-- +ok +== +select i, j, parse_path(filename)[-2:] from '{DATA_DIR}/parquet-testing/glob*/t?.parquet' where filename='{DATA_DIR}/parquet-testing/glob/t1.parquet' +-- +ok +== diff --git a/parser/testdata/corpus/sql/copy/parquet/parquet_virtual_file_row_group_number.test b/parser/testdata/corpus/sql/copy/parquet/parquet_virtual_file_row_group_number.test new file mode 100644 index 0000000..e23931e --- /dev/null +++ b/parser/testdata/corpus/sql/copy/parquet/parquet_virtual_file_row_group_number.test @@ -0,0 +1,114 @@ +# source: test/sql/copy/parquet/parquet_virtual_file_row_group_number.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +copy (select i, i * 2 as j from range(10000) t(i)) to '{TEST_DIR}/rg.parquet' (format parquet, ROW_GROUP_SIZE 2048); +-- +ok +== +select count(distinct row_group_id) from parquet_metadata('{TEST_DIR}/rg.parquet'); +-- +ok +== +select file_row_group_number, count(*), min(i), max(i) from '{TEST_DIR}/rg.parquet' group by file_row_group_number order by file_row_group_number; +-- +ok +== +select count(*) from '{TEST_DIR}/rg.parquet' where file_row_group_number is null; +-- +ok +== +select count(*), min(i), max(i) from '{TEST_DIR}/rg.parquet' where file_row_group_number = 2; +-- +ok +== +select count(*) from '{TEST_DIR}/rg.parquet' where file_row_group_number >= 1 and file_row_group_number <= 3; +-- +ok +== +select count(*), min(i), max(i) from '{TEST_DIR}/rg.parquet' where file_row_group_number in (1, 3); +-- +ok +== +select distinct file_row_group_number from '{TEST_DIR}/rg.parquet' where file_row_group_number in (1, 3) order by file_row_group_number; +-- +ok +== +select count(*) from '{TEST_DIR}/rg.parquet' where file_row_group_number in (1, 3) and i between 4096 and 6143; +-- +ok +== +select count(*) from '{TEST_DIR}/rg.parquet' where file_row_group_number = 100; +-- +ok +== +select i, j, file_row_group_number from '{TEST_DIR}/rg.parquet' where i in (0, 2048, 9999) order by i; +-- +ok +== +set threads=1; +-- +ok +== +PRAGMA enable_profiling = 'json'; +-- +ok +== +PRAGMA profiling_output = '{TEST_DIR}/profiling_output.json'; +-- +error: Parser Error: Profiler file type ({TEST_DIR}/profiling_output.json) must either have the same file extension as the profiling output type (query_tree), or be a '.txt' file. Set "enable_profiling = 'json'" first. +== +SET tracked_metrics = ['operator.row_groups_scanned', 'operator.total_row_groups_to_scan', 'operator.type']; +-- +ok +== +select count(*) from '{TEST_DIR}/rg.parquet' where file_row_group_number = 2; +-- +ok +== +PRAGMA disable_profiling; +-- +ok +== +CREATE VIEW parquet_scan_row_groups AS +WITH RECURSIVE ops(op) AS ( + SELECT unnest(operator)::JSON AS op FROM '{TEST_DIR}/profiling_output.json' + UNION ALL + SELECT unnest((op->'children')::JSON[]) FROM ops WHERE json_array_length(op->'children') > 0 +) +SELECT (op->>'row_groups_scanned')::BIGINT AS scanned, + (op->>'total_row_groups_to_scan')::BIGINT AS total +FROM ops +WHERE op->>'type' = 'TABLE_SCAN'; +-- +ok +== +SELECT scanned, total - scanned AS skipped FROM parquet_scan_row_groups; +-- +ok +== +select count(*) from '{TEST_DIR}/rg.parquet' where file_row_group_number in (1, 3); +-- +ok +== +select sum(j) from '{TEST_DIR}/rg.parquet'; +-- +ok +== +copy (select i from range(5000) t(i)) to '{TEST_DIR}/rg_a.parquet' (format parquet, ROW_GROUP_SIZE 2048); +-- +ok +== +copy (select i from range(3000) t(i)) to '{TEST_DIR}/rg_b.parquet' (format parquet, ROW_GROUP_SIZE 2048); +-- +ok +== +select file_row_group_number, count(*) from read_parquet(['{TEST_DIR}/rg_a.parquet', '{TEST_DIR}/rg_b.parquet']) group by file_row_group_number order by file_row_group_number; +-- +ok +== +select count(*) from read_parquet(['{TEST_DIR}/rg_a.parquet', '{TEST_DIR}/rg_b.parquet']) where file_row_group_number = 2; +-- +ok +== diff --git a/parser/testdata/corpus/sql/copy/parquet/parquet_virtual_file_row_group_number.test.metadata.json b/parser/testdata/corpus/sql/copy/parquet/parquet_virtual_file_row_group_number.test.metadata.json new file mode 100644 index 0000000..d5e4337 --- /dev/null +++ b/parser/testdata/corpus/sql/copy/parquet/parquet_virtual_file_row_group_number.test.metadata.json @@ -0,0 +1,5 @@ +{ + "todo": { + "a2b6a2683cf01059": "transformer-raised parser error: upstream rejects in the transformer, not the grammar; expected to clear as transformers land (milestones 3-5)" + } +} diff --git a/parser/testdata/corpus/sql/copy/parquet/parquet_virtual_file_row_number.test b/parser/testdata/corpus/sql/copy/parquet/parquet_virtual_file_row_number.test new file mode 100644 index 0000000..295611e --- /dev/null +++ b/parser/testdata/corpus/sql/copy/parquet/parquet_virtual_file_row_number.test @@ -0,0 +1,17 @@ +# source: test/sql/copy/parquet/parquet_virtual_file_row_number.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +select file_row_number from '{DATA_DIR}/parquet-testing/glob/t1.parquet' +-- +ok +== +select file_row_number from '{DATA_DIR}/parquet-testing/glob/t1.parquet' where file_row_number=0 +-- +ok +== +select i, j, parse_path(filename)[-2:], file_row_number from '{DATA_DIR}/parquet-testing/glob*/t?.parquet' order by i; +-- +ok +== diff --git a/parser/testdata/corpus/sql/copy/parquet/parquet_write_codecs.test b/parser/testdata/corpus/sql/copy/parquet/parquet_write_codecs.test new file mode 100644 index 0000000..5d84b09 --- /dev/null +++ b/parser/testdata/corpus/sql/copy/parquet/parquet_write_codecs.test @@ -0,0 +1,33 @@ +# source: test/sql/copy/parquet/parquet_write_codecs.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +COPY (SELECT 42, 'hello') TO '{TEMP_DIR}/{codec}.parquet' (FORMAT 'parquet', CODEC '{codec}'); +-- +ok +== +SELECT * FROM parquet_scan('{TEMP_DIR}/{codec}.parquet'); +-- +ok +== +COPY (FROM "{DATA_DIR}/parquet-testing/userdata1.parquet") TO '{TEMP_DIR}/userdata-{codec}.parquet' (FORMAT 'parquet', CODEC '{codec}', ROW_GROUP_SIZE 10); +-- +ok +== +FROM "{TEMP_DIR}/userdata-{codec}.parquet"; +-- +ok +== +COPY (SELECT 42, 'hello') TO '{TEMP_DIR}/gzip.parquet' (FORMAT 'parquet', CODEC 'BLABLABLA'); +-- +ok +== +COPY (SELECT 42, 'hello') TO '{TEMP_DIR}/gzip.parquet' (FORMAT 'parquet', CODEC); +-- +ok +== +COPY (SELECT 42, 'hello') TO '{TEMP_DIR}/gzip.parquet' (FORMAT 'parquet', CODEC 3); +-- +ok +== diff --git a/parser/testdata/corpus/sql/copy/parquet/parquet_write_repeated_lists.test b/parser/testdata/corpus/sql/copy/parquet/parquet_write_repeated_lists.test new file mode 100644 index 0000000..ba0cb91 --- /dev/null +++ b/parser/testdata/corpus/sql/copy/parquet/parquet_write_repeated_lists.test @@ -0,0 +1,17 @@ +# source: test/sql/copy/parquet/parquet_write_repeated_lists.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +COPY ( + SELECT * + FROM (values(['asdf', 'fdsa'])) + JOIN (values(1),(2)) ON TRUE +) to '{TEST_DIR}/lists.parquet'; +-- +ok +== +SELECT * FROM read_parquet('{TEST_DIR}/lists.parquet'); +-- +ok +== diff --git a/parser/testdata/corpus/sql/copy/parquet/parquet_zstd.test b/parser/testdata/corpus/sql/copy/parquet/parquet_zstd.test new file mode 100644 index 0000000..5b9f8a3 --- /dev/null +++ b/parser/testdata/corpus/sql/copy/parquet/parquet_zstd.test @@ -0,0 +1,9 @@ +# source: test/sql/copy/parquet/parquet_zstd.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +select * from parquet_scan('{DATA_DIR}/parquet-testing/zstd.parquet') order by 1 +-- +ok +== diff --git a/parser/testdata/corpus/sql/copy/parquet/partition_by_bind_issues.test b/parser/testdata/corpus/sql/copy/parquet/partition_by_bind_issues.test new file mode 100644 index 0000000..4991c3b --- /dev/null +++ b/parser/testdata/corpus/sql/copy/parquet/partition_by_bind_issues.test @@ -0,0 +1,27 @@ +# source: test/sql/copy/parquet/partition_by_bind_issues.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +CREATE TABLE test AS SELECT + 'test' AS user, + '2025' AS year +-- +ok +== +COPY ( + SELECT + * + FROM + test +) TO '{TEST_DIR}/partition_by_test.parquet' ( + FORMAT PARQUET, + PARTITION_BY user +) +-- +ok +== +select * from '{TEST_DIR}/partition_by_test.parquet' +-- +ok +== diff --git a/parser/testdata/corpus/sql/copy/parquet/read_ahead/readahead_active_jobs_hang.test b/parser/testdata/corpus/sql/copy/parquet/read_ahead/readahead_active_jobs_hang.test new file mode 100644 index 0000000..98aad33 --- /dev/null +++ b/parser/testdata/corpus/sql/copy/parquet/read_ahead/readahead_active_jobs_hang.test @@ -0,0 +1,13 @@ +# source: test/sql/copy/parquet/read_ahead/readahead_active_jobs_hang.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +COPY (SELECT i AS id FROM range(60000) t(i)) TO '{TEST_DIR}/hang.parquet' (FORMAT parquet, ROW_GROUP_SIZE 2048) +-- +ok +== +SELECT id::UTINYINT FROM '{TEST_DIR}/hang.parquet' +-- +ok +== diff --git a/parser/testdata/corpus/sql/copy/parquet/read_ahead/readahead_depth_learning.test b/parser/testdata/corpus/sql/copy/parquet/read_ahead/readahead_depth_learning.test new file mode 100644 index 0000000..a229a9d --- /dev/null +++ b/parser/testdata/corpus/sql/copy/parquet/read_ahead/readahead_depth_learning.test @@ -0,0 +1,35 @@ +# source: test/sql/copy/parquet/read_ahead/readahead_depth_learning.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +SET read_ahead_depth=4 +-- +ok +== +COPY ( + SELECT i AS a, + i + 10 AS b, + CASE + WHEN i % 100 = 50 THEN 51 + ELSE i % 100 + END AS c, + i % 1000 AS g + FROM RANGE(24576) t(i) +) TO '{TEST_DIR}/ra_learn.parquet' (ROW_GROUP_SIZE 2048, WRITE_BLOOM_FILTER FALSE) +-- +ok +== +SELECT sum(a + b + c + g) +FROM read_parquet('{TEST_DIR}/ra_learn.parquet') +WHERE c = 50 +-- +ok +== +SELECT row_group_id, fully_filtered, strategy, prefetch_groups +FROM duckdb_logs_parsed('ParquetPrefetch') +WHERE file_path LIKE '%ra_learn.parquet' +ORDER BY row_group_id +-- +ok +== diff --git a/parser/testdata/corpus/sql/copy/parquet/read_ahead/readahead_depth_setting.test b/parser/testdata/corpus/sql/copy/parquet/read_ahead/readahead_depth_setting.test new file mode 100644 index 0000000..9914c6c --- /dev/null +++ b/parser/testdata/corpus/sql/copy/parquet/read_ahead/readahead_depth_setting.test @@ -0,0 +1,33 @@ +# source: test/sql/copy/parquet/read_ahead/readahead_depth_setting.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +SET read_ahead_depth=-1 +-- +ok +== +SET read_ahead_depth=0 +-- +ok +== +SET read_ahead_depth=1099511627776 +-- +ok +== +SET read_ahead_depth=42 +-- +ok +== +SET read_ahead_depth=-2 +-- +ok +== +SET read_ahead_depth=-1099511627776 +-- +ok +== +SELECT current_setting('read_ahead_depth') +-- +ok +== diff --git a/parser/testdata/corpus/sql/copy/parquet/read_ahead/readahead_io_errors.test b/parser/testdata/corpus/sql/copy/parquet/read_ahead/readahead_io_errors.test new file mode 100644 index 0000000..99e66d0 --- /dev/null +++ b/parser/testdata/corpus/sql/copy/parquet/read_ahead/readahead_io_errors.test @@ -0,0 +1,21 @@ +# source: test/sql/copy/parquet/read_ahead/readahead_io_errors.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +SET read_ahead_depth=8 +-- +ok +== +COPY (SELECT range AS i, md5(range::VARCHAR) AS s FROM range(50000)) TO '{TEST_DIR}/err_io_{i}.parquet' (FORMAT parquet, ROW_GROUP_SIZE 100000) +-- +ok +== +SET memory_limit='4MB' +-- +ok +== +SELECT max(s) FROM '{TEST_DIR}/err_io_*.parquet' +-- +ok +== diff --git a/parser/testdata/corpus/sql/copy/parquet/read_ahead/readahead_limit_slot_leak_hang.test b/parser/testdata/corpus/sql/copy/parquet/read_ahead/readahead_limit_slot_leak_hang.test new file mode 100644 index 0000000..065d7e8 --- /dev/null +++ b/parser/testdata/corpus/sql/copy/parquet/read_ahead/readahead_limit_slot_leak_hang.test @@ -0,0 +1,13 @@ +# source: test/sql/copy/parquet/read_ahead/readahead_limit_slot_leak_hang.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +COPY (SELECT range AS i FROM range(120000)) TO '{TEST_DIR}/limit_slot_leak.parquet' (FORMAT parquet, ROW_GROUP_SIZE 2048) +-- +ok +== +SELECT count(*) FROM (SELECT i FROM '{TEST_DIR}/limit_slot_leak.parquet' WHERE i >= 10 LIMIT 5) +-- +ok +== diff --git a/parser/testdata/corpus/sql/copy/parquet/read_ahead/readahead_order_preservation.test b/parser/testdata/corpus/sql/copy/parquet/read_ahead/readahead_order_preservation.test new file mode 100644 index 0000000..1134ad6 --- /dev/null +++ b/parser/testdata/corpus/sql/copy/parquet/read_ahead/readahead_order_preservation.test @@ -0,0 +1,32 @@ +# source: test/sql/copy/parquet/read_ahead/readahead_order_preservation.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +COPY (SELECT range AS i FROM range(0, 100000)) TO '{TEST_DIR}/ord_0.parquet' (FORMAT parquet, ROW_GROUP_SIZE 2048) +-- +ok +== +COPY (SELECT range AS i FROM range(100000, 200000)) TO '{TEST_DIR}/ord_1.parquet' (FORMAT parquet, ROW_GROUP_SIZE 2048) +-- +ok +== +COPY (SELECT range AS i FROM range(200000, 300000)) TO '{TEST_DIR}/ord_2.parquet' (FORMAT parquet, ROW_GROUP_SIZE 2048) +-- +ok +== +COPY (SELECT range AS i FROM range(300000, 400000)) TO '{TEST_DIR}/ord_3.parquet' (FORMAT parquet, ROW_GROUP_SIZE 2048) +-- +ok +== +SELECT count(*) FROM ( + SELECT i, row_number() OVER () AS rn + FROM read_parquet(['{TEST_DIR}/ord_0.parquet', '{TEST_DIR}/ord_1.parquet', '{TEST_DIR}/ord_2.parquet', '{TEST_DIR}/ord_3.parquet']) +) WHERE i + 1 <> rn +-- +ok +== +SET read_ahead_depth=3 +-- +ok +== diff --git a/parser/testdata/corpus/sql/copy/parquet/read_ahead/readahead_starved_consumers.test b/parser/testdata/corpus/sql/copy/parquet/read_ahead/readahead_starved_consumers.test new file mode 100644 index 0000000..81accc1 --- /dev/null +++ b/parser/testdata/corpus/sql/copy/parquet/read_ahead/readahead_starved_consumers.test @@ -0,0 +1,17 @@ +# source: test/sql/copy/parquet/read_ahead/readahead_starved_consumers.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +COPY (SELECT range AS i FROM range(200000)) TO '{TEST_DIR}/starved.parquet' (FORMAT parquet, ROW_GROUP_SIZE 2048) +-- +ok +== +SELECT count(*), sum(i) FROM '{TEST_DIR}/starved.parquet' +-- +ok +== +SELECT count(*) FROM '{TEST_DIR}/starved.parquet' WHERE i % 10 = 3 +-- +ok +== diff --git a/parser/testdata/corpus/sql/copy/parquet/read_parquet_parameter.test b/parser/testdata/corpus/sql/copy/parquet/read_parquet_parameter.test new file mode 100644 index 0000000..8f4c422 --- /dev/null +++ b/parser/testdata/corpus/sql/copy/parquet/read_parquet_parameter.test @@ -0,0 +1,17 @@ +# source: test/sql/copy/parquet/read_parquet_parameter.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +PREPARE v1 AS SELECT * FROM parquet_scan($1) ORDER BY 1 +-- +ok +== +EXECUTE v1('{DATA_DIR}/parquet-testing/arrow/alltypes_plain.parquet') +-- +ok +== +EXECUTE v1('{DATA_DIR}/parquet-testing/pandas-date.parquet') +-- +ok +== diff --git a/parser/testdata/corpus/sql/copy/parquet/recursive_parquet_union_by_name.test b/parser/testdata/corpus/sql/copy/parquet/recursive_parquet_union_by_name.test new file mode 100644 index 0000000..eb2dd3b --- /dev/null +++ b/parser/testdata/corpus/sql/copy/parquet/recursive_parquet_union_by_name.test @@ -0,0 +1,23 @@ +# source: test/sql/copy/parquet/recursive_parquet_union_by_name.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +create view r AS from read_parquet('{DATA_DIR}/parquet-testing/hive-partitioning/union_by_name/*/*.parquet', hive_partitioning=1, union_by_name=1) +-- +ok +== +WITH RECURSIVE t(it, accum) AS +( + SELECT 1, 0 + UNION ALL + ( + SELECT it + 1, accum + j + FROM t, r + WHERE it <= x + ) +) +SELECT * FROM t ORDER BY it, accum; +-- +ok +== diff --git a/parser/testdata/corpus/sql/copy/parquet/replacement_scan_custom_extension.test b/parser/testdata/corpus/sql/copy/parquet/replacement_scan_custom_extension.test new file mode 100644 index 0000000..fd41e6b --- /dev/null +++ b/parser/testdata/corpus/sql/copy/parquet/replacement_scan_custom_extension.test @@ -0,0 +1,17 @@ +# source: test/sql/copy/parquet/replacement_scan_custom_extension.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +COPY (SELECT 42 a) to '{TEST_DIR}/lists.my_file_extension' (FORMAT PARQUET); +-- +ok +== +FROM '{TEST_DIR}/lists.my_file_extension'; +-- +ok +== +FROM read_parquet('{TEST_DIR}/lists.my_file_extension') +-- +ok +== diff --git a/parser/testdata/corpus/sql/copy/parquet/rle_bool.test b/parser/testdata/corpus/sql/copy/parquet/rle_bool.test new file mode 100644 index 0000000..f8fd9b9 --- /dev/null +++ b/parser/testdata/corpus/sql/copy/parquet/rle_bool.test @@ -0,0 +1,13 @@ +# source: test/sql/copy/parquet/rle_bool.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +SELECT * FROM '{DATA_DIR}/parquet-testing/arrow/datapage_v2.snappy.parquet' +-- +ok +== +SELECT * FROM '{DATA_DIR}/parquet-testing/rle_boolean_encoding.parquet' +-- +ok +== diff --git a/parser/testdata/corpus/sql/copy/parquet/shredded_variant_stats.test b/parser/testdata/corpus/sql/copy/parquet/shredded_variant_stats.test new file mode 100644 index 0000000..272cc1e --- /dev/null +++ b/parser/testdata/corpus/sql/copy/parquet/shredded_variant_stats.test @@ -0,0 +1,192 @@ +# source: test/sql/copy/parquet/shredded_variant_stats.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +COPY (SELECT * from (VALUES + (21::VARIANT), + (42::VARIANT), + ) t(col) +) to '{TEST_DIR}/fully_shredded_primitive.parquet' +-- +ok +== +select s.shredding_state, s.fully_shredded.stats.min, s.fully_shredded.stats.max, s.fully_shredded.stats.has_null, s.fully_shredded.stats.has_no_null FROM (select stats(col) s from '{TEST_DIR}/fully_shredded_primitive.parquet' limit 1); +-- +ok +== +COPY (SELECT * from (VALUES + (NULL::VARIANT), + (21::VARIANT), + (NULL::VARIANT), + (42::VARIANT), + ) t(col) +) to '{TEST_DIR}/fully_shredded_primitive_with_nulls.parquet' +-- +ok +== +select s.shredding_state, s.fully_shredded.stats.min, s.fully_shredded.stats.max, s.fully_shredded.stats.has_null, s.fully_shredded.stats.has_no_null from (select stats(col) s from '{TEST_DIR}/fully_shredded_primitive_with_nulls.parquet' limit 1); +-- +ok +== +COPY (SELECT * from (VALUES + (['test']::VARIANT), + (21::VARIANT), + (42::VARIANT), + ) t(col) +) to '{TEST_DIR}/not_fully_shredded_primitive.parquet' +-- +ok +== +select s.shredding_state, s.partially_shredded.stats.min, s.partially_shredded.stats.max, s.partially_shredded.stats.has_null, s.partially_shredded.stats.has_no_null from (select stats(col) s from '{TEST_DIR}/not_fully_shredded_primitive.parquet' limit 1); +-- +ok +== +COPY (SELECT * from (VALUES + (['test']::VARIANT), + ([21]::VARIANT), + ) t(col) +) to '{TEST_DIR}/fully_shredded_list.parquet' +-- +ok +== +select s.shredding_state, s.has_null, s.has_no_null from (select stats(col) s from '{TEST_DIR}/fully_shredded_list.parquet' limit 1); +-- +ok +== +COPY (SELECT * from (VALUES + (NULL::VARIANT), + (NULL::VARIANT), + (['test']::VARIANT), + ([21]::VARIANT), + (NULL::VARIANT) + ) t(col) +) to '{TEST_DIR}/fully_shredded_list_with_nulls.parquet' +-- +ok +== +select s.shredding_state, s.has_null, s.has_no_null from (select stats(col) s from '{TEST_DIR}/fully_shredded_list_with_nulls.parquet' limit 1); +-- +ok +== +COPY (SELECT * from (VALUES + (NULL::VARIANT), + (NULL::VARIANT), + (['test']::VARIANT), + (['hello', 'world']::VARIANT), + (21::VARIANT), + (NULL::VARIANT) + ) t(col) +) to '{TEST_DIR}/not_fully_shredded_list.parquet' +-- +ok +== +select s.shredding_state, s.has_null, s.has_no_null from (select stats(col) s from '{TEST_DIR}/not_fully_shredded_list.parquet' limit 1); +-- +ok +== +COPY (SELECT * from (VALUES + (['test']::VARIANT), + (['hello']::VARIANT), + ) t(col) +) to '{TEST_DIR}/fully_shredded_list_element.parquet' +-- +ok +== +select s.min, s.max, s.has_null, s.has_no_null from (select stats(col).fully_shredded.child_stats.stats s from '{TEST_DIR}/fully_shredded_list_element.parquet' limit 1); +-- +ok +== +COPY (SELECT * from (VALUES + (['test']::VARIANT), + (['hello', NULL, 'world']::VARIANT), + ) t(col) +) to '{TEST_DIR}/fully_shredded_list_element_with_nulls.parquet' +-- +ok +== +select s.min, s.max, s.has_null, s.has_no_null from (select stats(col).fully_shredded.child_stats.stats s from '{TEST_DIR}/fully_shredded_list_element_with_nulls.parquet' limit 1); +-- +ok +== +COPY (SELECT * from (VALUES + (['test']::VARIANT), + (['hello'::VARIANT, NULL, 21]::VARIANT), + ) t(col) +) to '{TEST_DIR}/not_fully_shredded_list_element.parquet' +-- +ok +== +select s.fully_shredded from (select stats(col) s from '{TEST_DIR}/not_fully_shredded_list_element.parquet' limit 1); +-- +ok +== +COPY (SELECT * from (VALUES + ({'a': 42, 'b': true}::VARIANT), + ({'a': 21, 'c': 'test'}::VARIANT), + ) t(col) +) to '{TEST_DIR}/fully_shredded_object.parquet' +-- +ok +== +select s.fully_shredded.a.stats.min, s.fully_shredded.a.stats.max, s.fully_shredded.c.stats.min from (select stats(col) s from '{TEST_DIR}/fully_shredded_object.parquet' limit 1); +-- +ok +== +COPY (SELECT * from (VALUES + (NULL::VARIANT), + ({'a': 42, 'b': true}::VARIANT), + (NULL::VARIANT), + ({'a': 21, 'c': 'test'}::VARIANT), + ) t(col) +) to '{TEST_DIR}/fully_shredded_object_with_nulls.parquet' +-- +ok +== +select s.fully_shredded.a.stats.min, s.fully_shredded.a.stats.max, s.fully_shredded.c.stats.min from (select stats(col) s from '{TEST_DIR}/fully_shredded_object_with_nulls.parquet' limit 1); +-- +ok +== +COPY (SELECT * from (VALUES + (NULL::VARIANT), + ({'a': 42, 'b': true}::VARIANT), + (NULL::VARIANT), + ({'a': 21, 'c': 'test'}::VARIANT), + (42::VARIANT), + ) t(col) +) to '{TEST_DIR}/not_fully_shredded_object.parquet' +-- +ok +== +select s.fully_shredded from (select stats(col) s from '{TEST_DIR}/not_fully_shredded_object.parquet' limit 1); +-- +ok +== +COPY (SELECT * from (VALUES + (NULL::VARIANT), + ({'a': 42, 'b': true}::VARIANT), + (NULL::VARIANT), + ({'a': 'test', 'c': 'test'}::VARIANT), + ) t(col) +) to '{TEST_DIR}/not_fully_shredded_object_field.parquet' +-- +ok +== +select s.fully_shredded.a, s.fully_shredded.c.stats.min from (select stats(col) s from '{TEST_DIR}/not_fully_shredded_object_field.parquet' limit 1); +-- +ok +== +COPY (SELECT * from (VALUES + (NULL::VARIANT), + ({'a': 42, 'b': true}::VARIANT), + (NULL::VARIANT), + ({'a': NULL, 'c': 'test'}::VARIANT), + ) t(col) +) to '{TEST_DIR}/fully_shredded_object_field_with_nulls.parquet' +-- +ok +== +select s.fully_shredded.a.type, s.fully_shredded.a.stats.min, s.fully_shredded.c.type, s.fully_shredded.c.stats.min from (select stats(col) s from '{TEST_DIR}/fully_shredded_object_field_with_nulls.parquet' limit 1); +-- +ok +== diff --git a/parser/testdata/corpus/sql/copy/parquet/spark_v2.test b/parser/testdata/corpus/sql/copy/parquet/spark_v2.test new file mode 100644 index 0000000..d7064bc --- /dev/null +++ b/parser/testdata/corpus/sql/copy/parquet/spark_v2.test @@ -0,0 +1,17 @@ +# source: test/sql/copy/parquet/spark_v2.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +SELECT count(*) FROM '{DATA_DIR}/parquet-testing/spark-store.parquet' +-- +ok +== +SELECT s_store_sk, s_floor_space, trim(s_street_name) FROM '{DATA_DIR}/parquet-testing/spark-store.parquet' +-- +ok +== +SELECT * FROM '{DATA_DIR}/parquet-testing/spark-ontime.parquet' +-- +ok +== diff --git a/parser/testdata/corpus/sql/copy/parquet/struct_column_reader_skip.test b/parser/testdata/corpus/sql/copy/parquet/struct_column_reader_skip.test new file mode 100644 index 0000000..e68fedf --- /dev/null +++ b/parser/testdata/corpus/sql/copy/parquet/struct_column_reader_skip.test @@ -0,0 +1,9 @@ +# source: test/sql/copy/parquet/struct_column_reader_skip.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +SELECT my_map['A'], * FROM parquet_scan('{DATA_DIR}/parquet-testing/struct_skip_test.parquet') where filter == '0' +-- +ok +== diff --git a/parser/testdata/corpus/sql/copy/parquet/struct_skip_pushdown_null.test b/parser/testdata/corpus/sql/copy/parquet/struct_skip_pushdown_null.test new file mode 100644 index 0000000..dcadd2b --- /dev/null +++ b/parser/testdata/corpus/sql/copy/parquet/struct_skip_pushdown_null.test @@ -0,0 +1,28 @@ +# source: test/sql/copy/parquet/struct_skip_pushdown_null.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +COPY ( + SELECT i AS id, + CASE + WHEN i >= 59392 AND i < 112640 THEN NULL + ELSE {a: 'hello', b: 42.0} + END::STRUCT(a VARCHAR, b DOUBLE) AS col + FROM range(122880) t(i) +) TO '{TEST_DIR}/skip_null_struct.parquet' (FORMAT PARQUET, ROW_GROUP_SIZE 122880) +-- +ok +== +SELECT col IS NULL FROM '{TEST_DIR}/skip_null_struct.parquet' WHERE id = 112640 +-- +ok +== +COPY ( + SELECT col + FROM '{TEST_DIR}/skip_null_struct.parquet' + WHERE id = 112640 +) TO '{TEST_DIR}/skip_null_struct_out.parquet' +-- +ok +== diff --git a/parser/testdata/corpus/sql/copy/parquet/test_aws_files.test b/parser/testdata/corpus/sql/copy/parquet/test_aws_files.test new file mode 100644 index 0000000..cf698fb --- /dev/null +++ b/parser/testdata/corpus/sql/copy/parquet/test_aws_files.test @@ -0,0 +1,9 @@ +# source: test/sql/copy/parquet/test_aws_files.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +SELECT * FROM parquet_scan('{DATA_DIR}/parquet-testing/aws1.snappy.parquet') limit 100 +-- +ok +== diff --git a/parser/testdata/corpus/sql/copy/parquet/test_parallel_many_row_groups.test b/parser/testdata/corpus/sql/copy/parquet/test_parallel_many_row_groups.test new file mode 100644 index 0000000..ac525fc --- /dev/null +++ b/parser/testdata/corpus/sql/copy/parquet/test_parallel_many_row_groups.test @@ -0,0 +1,13 @@ +# source: test/sql/copy/parquet/test_parallel_many_row_groups.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +SELECT COUNT(*), MIN(i), MAX(i), SUM(i) FROM parquet_scan('{DATA_DIR}/parquet-testing/manyrowgroups.parquet') t(i) +-- +ok +== +SELECT COUNT(*), MIN(i), MAX(i), SUM(i) FROM parquet_scan('{DATA_DIR}/parquet-testing/manyrowgroups*') t(i) +-- +ok +== diff --git a/parser/testdata/corpus/sql/copy/parquet/test_parquet_decimal.test b/parser/testdata/corpus/sql/copy/parquet/test_parquet_decimal.test new file mode 100644 index 0000000..8221bca --- /dev/null +++ b/parser/testdata/corpus/sql/copy/parquet/test_parquet_decimal.test @@ -0,0 +1,25 @@ +# source: test/sql/copy/parquet/test_parquet_decimal.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +SELECT * FROM parquet_scan('{DATA_DIR}/parquet-testing/decimal/fixed_length_decimal.parquet') +-- +ok +== +SELECT * FROM parquet_scan('{DATA_DIR}/parquet-testing/decimal/fixed_length_decimal_legacy.parquet') +-- +ok +== +SELECT * FROM parquet_scan('{DATA_DIR}/parquet-testing/decimal/decimal_dc.parquet') limit 10 +-- +ok +== +SELECT * FROM parquet_scan('{DATA_DIR}/parquet-testing/decimal/pandas_decimal.parquet') limit 10 +-- +ok +== +SELECT * FROM parquet_scan('{DATA_DIR}/parquet-testing/decimal/byte_array_decimal_empty_value.parquet') +-- +ok +== diff --git a/parser/testdata/corpus/sql/copy/parquet/test_parquet_duplicate_columns.test b/parser/testdata/corpus/sql/copy/parquet/test_parquet_duplicate_columns.test new file mode 100644 index 0000000..6d83e83 --- /dev/null +++ b/parser/testdata/corpus/sql/copy/parquet/test_parquet_duplicate_columns.test @@ -0,0 +1,25 @@ +# source: test/sql/copy/parquet/test_parquet_duplicate_columns.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +COPY (SELECT 1 as a, 2 as a, 3 as a) TO '{TEST_DIR}/dupe_cols.parquet'; +-- +ok +== +SELECT a, "a_1", "a_2" FROM '{TEST_DIR}/dupe_cols.parquet'; +-- +ok +== +COPY (SELECT 1 as a, 2 as a, 3 as "a_1") TO '{TEST_DIR}/dupe_cols.parquet'; +-- +ok +== +SELECT a, "a_1", "a_1_1" FROM '{TEST_DIR}/dupe_cols.parquet'; +-- +ok +== +COPY (SELECT 1 as a, 3 as "a_1", 2 as a) TO '{TEST_DIR}/dupe_cols.parquet'; +-- +ok +== diff --git a/parser/testdata/corpus/sql/copy/parquet/test_parquet_filter_pushdown.test b/parser/testdata/corpus/sql/copy/parquet/test_parquet_filter_pushdown.test new file mode 100644 index 0000000..687bf93 --- /dev/null +++ b/parser/testdata/corpus/sql/copy/parquet/test_parquet_filter_pushdown.test @@ -0,0 +1,105 @@ +# source: test/sql/copy/parquet/test_parquet_filter_pushdown.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +SELECT COUNT(*) FROM parquet_scan('{DATA_DIR}/parquet-testing/userdata1.parquet') where id > 500 +-- +ok +== +SELECT COUNT(*) FROM parquet_scan('{DATA_DIR}/parquet-testing/userdata1.parquet') where id < 500 +-- +ok +== +SELECT COUNT(*) FROM parquet_scan('{DATA_DIR}/parquet-testing/userdata1.parquet') where id > 100 and id < 900 +-- +ok +== +SELECT COUNT(*) FROM parquet_scan('{DATA_DIR}/parquet-testing/userdata1.parquet') where id between 100 and 900 +-- +ok +== +SELECT registration_dttm, id, first_name, birthdate, salary FROM parquet_scan('{DATA_DIR}/parquet-testing/userdata1.parquet') where id = 42 +-- +ok +== +SELECT COUNT(*) FROM parquet_scan('{DATA_DIR}/parquet-testing/userdata1.parquet') where id = 42 +-- +ok +== +SELECT COUNT(*) FROM parquet_scan('{DATA_DIR}/parquet-testing/userdata1.parquet') where salary < 1000 +-- +ok +== +SELECT first_name, gender FROM parquet_scan('{DATA_DIR}/parquet-testing/userdata1.parquet') where first_name = 'Mark' and gender <> '' +-- +ok +== +SELECT gender, first_name FROM parquet_scan('{DATA_DIR}/parquet-testing/userdata1.parquet') where first_name = 'Mark' and gender <> '' +-- +ok +== +SELECT COUNT(*) FROM parquet_scan('{DATA_DIR}/parquet-testing/userdata1.parquet') where gender = 'Male' and first_name = 'Mark' +-- +ok +== +SELECT last_name FROM parquet_scan('{DATA_DIR}/parquet-testing/userdata1.parquet') where first_name > 'Mark' and country > 'Germany' and salary > 0 order by last_name limit 10 +-- +ok +== +SELECT length(l_comment) FROM parquet_scan('{DATA_DIR}/parquet-testing/lineitem-top10000.gzip.parquet') where l_orderkey = 1 order by l_comment +-- +ok +== +SELECT * FROM parquet_scan('{DATA_DIR}/parquet-testing/date.parquet') where d < cast('1978-01-01' as date) +-- +ok +== +SELECT * FROM parquet_scan('{DATA_DIR}/parquet-testing/date.parquet') where d > cast('1982-01-01' as date) and d < cast('1986-01-01' as date) +-- +ok +== +SELECT * FROM parquet_scan('{DATA_DIR}/parquet-testing/date.parquet') where d >= cast('1990-01-01' as date) +-- +ok +== +SELECT COUNT(*) FROM parquet_scan('{DATA_DIR}/parquet-testing/date.parquet') where d == cast('1970-01-01' as date) +-- +ok +== +SELECT COUNT(*) FROM parquet_scan('{DATA_DIR}/parquet-testing/date.parquet') where d > cast('1970-01-01' as date) +-- +ok +== +SELECT COUNT(*) FROM parquet_scan('{DATA_DIR}/parquet-testing/date.parquet') where d >= cast('1982-01-01' as date) and d < cast('1985-01-01' as date) +-- +ok +== +SELECT COUNT(*) FROM parquet_scan('{DATA_DIR}/parquet-testing/date.parquet') where d < cast('1970-01-01' as date) +-- +ok +== +SELECT COUNT(*) FROM parquet_scan('{DATA_DIR}/parquet-testing/date.parquet') where d between cast('1975-01-01' as date) and cast('1976-01-01' as date) +-- +ok +== +SELECT COUNT(*) FROM parquet_scan('{DATA_DIR}/parquet-testing/date.parquet') where d >= cast('1975-01-01' as date) and d < cast('1976-01-01' as date) +-- +ok +== +SELECT COUNT(*) FROM parquet_scan('{DATA_DIR}/parquet-testing/date.parquet') where d < cast('1975-01-01' as date) and d > cast('1976-01-01' as date) +-- +ok +== +SELECT COUNT(*) FROM parquet_scan('{DATA_DIR}/parquet-testing/date.parquet') where d < cast('1975-01-01' as date) or d > cast('1976-01-01' as date) +-- +ok +== +SELECT COUNT(*) FROM parquet_scan('{DATA_DIR}/parquet-testing/date.parquet') where d < cast('1975-01-01' as date) or d >= cast('1976-01-01' as date) +-- +ok +== +SELECT COUNT(*) FROM parquet_scan('{DATA_DIR}/parquet-testing/date.parquet') where d is null +-- +ok +== diff --git a/parser/testdata/corpus/sql/copy/parquet/test_parquet_gzip.test b/parser/testdata/corpus/sql/copy/parquet/test_parquet_gzip.test new file mode 100644 index 0000000..bd91009 --- /dev/null +++ b/parser/testdata/corpus/sql/copy/parquet/test_parquet_gzip.test @@ -0,0 +1,9 @@ +# source: test/sql/copy/parquet/test_parquet_gzip.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +select * from parquet_scan('{DATA_DIR}/parquet-testing/lineitem-top10000.gzip.parquet') +-- +ok +== diff --git a/parser/testdata/corpus/sql/copy/parquet/test_parquet_nested.test b/parser/testdata/corpus/sql/copy/parquet/test_parquet_nested.test new file mode 100644 index 0000000..a9ae343 --- /dev/null +++ b/parser/testdata/corpus/sql/copy/parquet/test_parquet_nested.test @@ -0,0 +1,41 @@ +# source: test/sql/copy/parquet/test_parquet_nested.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +select * FROM parquet_scan('{DATA_DIR}/parquet-testing/map.parquet') sq limit 3; +-- +ok +== +SELECT * FROM parquet_scan('{DATA_DIR}/parquet-testing/arrow/nested_lists.snappy.parquet') +-- +ok +== +SELECT unnest(a) FROM parquet_scan('{DATA_DIR}/parquet-testing/arrow/nested_lists.snappy.parquet') +-- +ok +== +SELECT * FROM parquet_scan('{DATA_DIR}/parquet-testing/arrow/list_columns.parquet') +-- +ok +== +SELECT id, url FROM parquet_scan('{DATA_DIR}/parquet-testing/apkwan.parquet') limit 10 +-- +ok +== +select * from (SELECT id, unnest(url) u FROM parquet_scan('{DATA_DIR}/parquet-testing/apkwan.parquet')) sq where u is not null limit 10 +-- +ok +== +SELECT id, authors FROM parquet_scan('{DATA_DIR}/parquet-testing/apkwan.parquet') limit 10 +-- +ok +== +SELECT id, unnest(authors) FROM parquet_scan('{DATA_DIR}/parquet-testing/apkwan.parquet') limit 20 +-- +ok +== +SELECT id, struct_extract(unnest(authors), 'name'), struct_extract(unnest(authors), 'id') FROM parquet_scan('{DATA_DIR}/parquet-testing/apkwan.parquet') limit 20 +-- +ok +== diff --git a/parser/testdata/corpus/sql/copy/parquet/test_parquet_null.test b/parser/testdata/corpus/sql/copy/parquet/test_parquet_null.test new file mode 100644 index 0000000..2e99a35 --- /dev/null +++ b/parser/testdata/corpus/sql/copy/parquet/test_parquet_null.test @@ -0,0 +1,9 @@ +# source: test/sql/copy/parquet/test_parquet_null.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +select count(col1) from parquet_scan('{DATA_DIR}/parquet-testing/bug687_nulls.parquet') +-- +ok +== diff --git a/parser/testdata/corpus/sql/copy/parquet/test_parquet_scan.test b/parser/testdata/corpus/sql/copy/parquet/test_parquet_scan.test new file mode 100644 index 0000000..a7e7ab7 --- /dev/null +++ b/parser/testdata/corpus/sql/copy/parquet/test_parquet_scan.test @@ -0,0 +1,161 @@ +# source: test/sql/copy/parquet/test_parquet_scan.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +SELECT * FROM parquet_scan('does_not_exist') +-- +ok +== +SELECT * FROM parquet_scan('{DATA_DIR}/parquet-testing/arrow/alltypes_plain.parquet') +-- +ok +== +SELECT * FROM "{DATA_DIR}/parquet-testing/arrow/alltypes_plain.parquet" +-- +ok +== +SELECT tbl.* FROM "{DATA_DIR}/parquet-testing/arrow/alltypes_plain.parquet" tbl +-- +ok +== +SELECT tbl.a FROM "{DATA_DIR}/parquet-testing/arrow/alltypes_plain.parquet" tbl(a) +-- +ok +== +SELECT * FROM parquet_scan('{DATA_DIR}/parquet-testing/unsigned.parquet') +-- +ok +== +SELECT * FROM parquet_scan('{DATA_DIR}/parquet-testing/arrow/alltypes_plain.snappy.parquet') +-- +ok +== +SELECT * FROM parquet_scan('{DATA_DIR}/parquet-testing/arrow/alltypes_dictionary.parquet') +-- +ok +== +SELECT * FROM parquet_scan('{DATA_DIR}/parquet-testing/data-types.parquet') +-- +ok +== +SELECT COUNT(*) FROM parquet_scan('{DATA_DIR}/parquet-testing/userdata1.parquet') +-- +ok +== +CREATE VIEW userdata1 AS SELECT * FROM parquet_scan('{DATA_DIR}/parquet-testing/userdata1.parquet') +-- +ok +== +SELECT COUNT(*) FROM userdata1 +-- +ok +== +SELECT COUNT(registration_dttm), COUNT(id), COUNT(first_name), COUNT(last_name), COUNT(email), COUNT(gender), COUNT(ip_address), COUNT(cc), COUNT(country), COUNT(birthdate), COUNT(salary), COUNT(title), COUNT(comments) FROM userdata1 +-- +ok +== +SELECT MIN(registration_dttm), MAX(registration_dttm) FROM userdata1 +-- +ok +== +SELECT MIN(id), MAX(id) FROM userdata1 +-- +ok +== +SELECT FIRST(id) OVER w, LAST(id) OVER w FROM userdata1 WINDOW w AS (ORDER BY id RANGE BETWEEN UNBOUNDED PRECEDING AND UNBOUNDED FOLLOWING) LIMIT 1 +-- +ok +== +SELECT MIN(first_name), MAX(first_name) FROM userdata1 +-- +ok +== +SELECT FIRST(first_name) OVER w, LAST(first_name) OVER w FROM userdata1 WINDOW w AS (ORDER BY id RANGE BETWEEN UNBOUNDED PRECEDING AND UNBOUNDED FOLLOWING) LIMIT 1 +-- +ok +== +SELECT MIN(last_name), MAX(last_name) FROM userdata1 +-- +ok +== +SELECT FIRST(last_name) OVER w, LAST(last_name) OVER w FROM userdata1 WINDOW w AS (ORDER BY id RANGE BETWEEN UNBOUNDED PRECEDING AND UNBOUNDED FOLLOWING) LIMIT 1 +-- +ok +== +SELECT MIN(email), MAX(email) FROM userdata1 +-- +ok +== +SELECT FIRST(email) OVER w, LAST(email) OVER w FROM userdata1 WINDOW w AS (ORDER BY id RANGE BETWEEN UNBOUNDED PRECEDING AND UNBOUNDED FOLLOWING) LIMIT 1 +-- +ok +== +SELECT MIN(gender), MAX(gender) FROM userdata1 +-- +ok +== +SELECT FIRST(gender) OVER w, LAST(gender) OVER w FROM userdata1 WINDOW w AS (ORDER BY id RANGE BETWEEN UNBOUNDED PRECEDING AND UNBOUNDED FOLLOWING) LIMIT 1 +-- +ok +== +SELECT MIN(ip_address), MAX(ip_address) FROM userdata1 +-- +ok +== +SELECT FIRST(ip_address) OVER w, LAST(ip_address) OVER w FROM userdata1 WINDOW w AS (ORDER BY id RANGE BETWEEN UNBOUNDED PRECEDING AND UNBOUNDED FOLLOWING) LIMIT 1 +-- +ok +== +SELECT MIN(cc), MAX(cc) FROM userdata1 +-- +ok +== +SELECT FIRST(cc) OVER w, LAST(cc) OVER w FROM userdata1 WINDOW w AS (ORDER BY id RANGE BETWEEN UNBOUNDED PRECEDING AND UNBOUNDED FOLLOWING) LIMIT 1 +-- +ok +== +SELECT MIN(country), MAX(country) FROM userdata1 +-- +ok +== +SELECT FIRST(country) OVER w, LAST(country) OVER w FROM userdata1 WINDOW w AS (ORDER BY id RANGE BETWEEN UNBOUNDED PRECEDING AND UNBOUNDED FOLLOWING) LIMIT 1 +-- +ok +== +SELECT MIN(birthdate), MAX(birthdate) FROM userdata1 +-- +ok +== +SELECT FIRST(birthdate) OVER w, LAST(birthdate) OVER w FROM userdata1 WINDOW w AS (ORDER BY id RANGE BETWEEN UNBOUNDED PRECEDING AND UNBOUNDED FOLLOWING) LIMIT 1 +-- +ok +== +SELECT MIN(salary), MAX(salary) FROM userdata1 +-- +ok +== +SELECT FIRST(salary) OVER w, LAST(salary) OVER w FROM userdata1 WINDOW w AS (ORDER BY id RANGE BETWEEN UNBOUNDED PRECEDING AND UNBOUNDED FOLLOWING) LIMIT 1 +-- +ok +== +SELECT MIN(title), MAX(title) FROM userdata1 +-- +ok +== +SELECT FIRST(title) OVER w, LAST(title) OVER w FROM userdata1 WINDOW w AS (ORDER BY id RANGE BETWEEN UNBOUNDED PRECEDING AND UNBOUNDED FOLLOWING) LIMIT 1 +-- +ok +== +SELECT MIN(comments), MAX(comments) FROM userdata1 +-- +ok +== +SELECT FIRST(comments) OVER w, LAST(comments) OVER w FROM userdata1 WINDOW w AS (ORDER BY id RANGE BETWEEN UNBOUNDED PRECEDING AND UNBOUNDED FOLLOWING) LIMIT 1 +-- +ok +== +SELECT * FROM parquet_scan('{DATA_DIR}/parquet-testing/broken-arrow.parquet') +-- +ok +== diff --git a/parser/testdata/corpus/sql/copy/parquet/test_parquet_stats.test b/parser/testdata/corpus/sql/copy/parquet/test_parquet_stats.test new file mode 100644 index 0000000..5dc57a7 --- /dev/null +++ b/parser/testdata/corpus/sql/copy/parquet/test_parquet_stats.test @@ -0,0 +1,65 @@ +# source: test/sql/copy/parquet/test_parquet_stats.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +PRAGMA explain_output = PHYSICAL_ONLY +-- +ok +== +explain select * from parquet_scan('{DATA_DIR}/parquet-testing/userdata1.parquet') where false; +-- +ok +== +explain select * from parquet_scan('{DATA_DIR}/parquet-testing/userdata1.parquet') where id is null; +-- +ok +== +explain select * from parquet_scan('{DATA_DIR}/parquet-testing/userdata1.parquet') where id < 1; +-- +ok +== +explain select * from parquet_scan('{DATA_DIR}/parquet-testing/userdata1.parquet') where id > 1000; +-- +ok +== +explain select * from parquet_scan('{DATA_DIR}/parquet-testing/userdata1.parquet') where salary < 12380; +-- +ok +== +explain select * from parquet_scan('{DATA_DIR}/parquet-testing/timestamp.parquet') where time < '2020-10-04'; +-- +ok +== +explain select * from parquet_scan('{DATA_DIR}/parquet-testing/timestamp.parquet') where time > '2020-10-06'; +-- +ok +== +explain select * from parquet_scan('{DATA_DIR}/parquet-testing/timestamp-ms.parquet') where time < '2020-10-04'; +-- +ok +== +explain select * from parquet_scan('{DATA_DIR}/parquet-testing/timestamp-ms.parquet') where time > '2020-10-06'; +-- +ok +== +explain select * from parquet_scan('{DATA_DIR}/parquet-testing/data-types.parquet') where timestampval < '2019-11-25'; +-- +ok +== +explain select * from parquet_scan('{DATA_DIR}/parquet-testing/data-types.parquet') where timestampval > '2019-11-27'; +-- +ok +== +explain select time from parquet_scan('{DATA_DIR}/parquet-testing/timestamp*.parquet') where time > '2020-10-06' +-- +ok +== +select time from parquet_scan('{DATA_DIR}/parquet-testing/timestamp*.parquet') where time > '2020-10-06' +-- +ok +== +pragma disable_object_cache +-- +ok +== diff --git a/parser/testdata/corpus/sql/copy/parquet/timestamp_ms_stats.test b/parser/testdata/corpus/sql/copy/parquet/timestamp_ms_stats.test new file mode 100644 index 0000000..cd110ed --- /dev/null +++ b/parser/testdata/corpus/sql/copy/parquet/timestamp_ms_stats.test @@ -0,0 +1,37 @@ +# source: test/sql/copy/parquet/timestamp_ms_stats.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +select timestamp from '{DATA_DIR}/parquet-testing/issue_5533_timestamp_ms_stats.parquet' order by 1; +-- +ok +== +select timestamp from '{DATA_DIR}/parquet-testing/issue_5533_timestamp_ms_stats.parquet' where timestamp >= '2022-11-27 00:00:00' +-- +ok +== +CREATE TABLE timestamp_ms_infinity(ts TIMESTAMP_MS) +-- +ok +== +INSERT INTO timestamp_ms_infinity VALUES ('-infinity'), ('infinity') +-- +ok +== +COPY timestamp_ms_infinity TO '{TEST_DIR}/timestamp_ms_infinity.parquet' (FORMAT parquet) +-- +ok +== +SELECT ts::VARCHAR, isinf(ts) +FROM read_parquet('{TEST_DIR}/timestamp_ms_infinity.parquet') +ORDER BY ts +-- +ok +== +SELECT count(*) +FROM read_parquet('{TEST_DIR}/timestamp_ms_infinity.parquet') +WHERE ts IN ('-infinity'::TIMESTAMP_MS, 'infinity'::TIMESTAMP_MS) +-- +ok +== diff --git a/parser/testdata/corpus/sql/copy/parquet/timestamp_s.test b/parser/testdata/corpus/sql/copy/parquet/timestamp_s.test new file mode 100644 index 0000000..f09f249 --- /dev/null +++ b/parser/testdata/corpus/sql/copy/parquet/timestamp_s.test @@ -0,0 +1,25 @@ +# source: test/sql/copy/parquet/timestamp_s.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +create table t (ts TIMESTAMP_S); +-- +ok +== +insert into t select make_timestamp((1706961600 + (360 * i))::BIGINT * 1000000) from range(10000) range(i); +-- +ok +== +select * from t limit 3; +-- +ok +== +copy (select * from t) to '{TEST_DIR}/t.parquet' (format parquet); +-- +ok +== +select * from '{TEST_DIR}/t.parquet' limit 3; +-- +ok +== diff --git a/parser/testdata/corpus/sql/copy/parquet/timetz_parquet.test b/parser/testdata/corpus/sql/copy/parquet/timetz_parquet.test new file mode 100644 index 0000000..1d17213 --- /dev/null +++ b/parser/testdata/corpus/sql/copy/parquet/timetz_parquet.test @@ -0,0 +1,9 @@ +# source: test/sql/copy/parquet/timetz_parquet.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +select * from '{DATA_DIR}/parquet-testing/timetz_4byte_stats.parquet' order by 1; +-- +ok +== diff --git a/parser/testdata/corpus/sql/copy/parquet/timezone.test b/parser/testdata/corpus/sql/copy/parquet/timezone.test new file mode 100644 index 0000000..33442a3 --- /dev/null +++ b/parser/testdata/corpus/sql/copy/parquet/timezone.test @@ -0,0 +1,17 @@ +# source: test/sql/copy/parquet/timezone.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +select typeof(TimeRecStart) from '{DATA_DIR}/parquet-testing/tz.parquet' limit 1; +-- +ok +== +SET timezone='UTC' +-- +ok +== +select TimeRecStart from '{DATA_DIR}/parquet-testing/tz.parquet'; +-- +ok +== diff --git a/parser/testdata/corpus/sql/copy/parquet/union_by_name_hive_partitioning.test b/parser/testdata/corpus/sql/copy/parquet/union_by_name_hive_partitioning.test new file mode 100644 index 0000000..05991f8 --- /dev/null +++ b/parser/testdata/corpus/sql/copy/parquet/union_by_name_hive_partitioning.test @@ -0,0 +1,94 @@ +# source: test/sql/copy/parquet/union_by_name_hive_partitioning.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +SELECT * FROM read_parquet('{DATA_DIR}/parquet-testing/hive-partitioning/union_by_name/*/*.parquet', hive_partitioning=1) +-- +ok +== +SELECT i, j, k, x +FROM read_parquet('{DATA_DIR}/parquet-testing/hive-partitioning/union_by_name/*/*.parquet', hive_partitioning=0, union_by_name=1) +ORDER BY j, x NULLS LAST +-- +ok +== +SELECT i, j, k, x +FROM read_parquet('{DATA_DIR}/parquet-testing/hive-partitioning/union_by_name/*/*.parquet', hive_partitioning=1, union_by_name=1) +ORDER BY j +-- +ok +== +SELECT i, j, k, x +FROM read_parquet('{DATA_DIR}/parquet-testing/hive-partitioning/union_by_name/*/*.parquet', hive_partitioning=1, union_by_name=1) +WHERE x=2 +ORDER BY j +-- +ok +== +CREATE TABLE selected_values AS SELECT 2 x +-- +ok +== +SELECT i, j, k, x +FROM read_parquet('{DATA_DIR}/parquet-testing/hive-partitioning/union_by_name/*/*.parquet', hive_partitioning=1, union_by_name=1) +WHERE x=(SELECT MAX(x) FROM selected_values) +ORDER BY j +-- +ok +== +SELECT i, j, k, x +FROM read_parquet('{DATA_DIR}/parquet-testing/hive-partitioning/union_by_name/*/f2.parquet', hive_partitioning=1, union_by_name=1) +ORDER BY j +-- +ok +== +SELECT i, j, k, x +FROM read_parquet('{DATA_DIR}/parquet-testing/hive-partitioning/union_by_name/*/f2.parquet', hive_partitioning=1, union_by_name=1) +WHERE k IS NULL +ORDER BY j +-- +ok +== +SELECT i, j, k, x +FROM read_parquet('{DATA_DIR}/parquet-testing/hive-partitioning/union_by_name/*/f2.parquet', hive_partitioning=1, union_by_name=1) +WHERE k IS NOT DISTINCT FROM NULL +ORDER BY j +-- +ok +== +SELECT i, j, k, x +FROM read_parquet('{DATA_DIR}/parquet-testing/hive-partitioning/union_by_name/*/f2.parquet', hive_partitioning=1, union_by_name=1) +WHERE k>0 +ORDER BY j +-- +ok +== +SELECT i, j, k, x, parse_path(filename)[-2] +FROM read_parquet('{DATA_DIR}/parquet-testing/hive-partitioning/union_by_name/*/f2.parquet', hive_partitioning=1, union_by_name=1, filename=1) +WHERE k>0 +ORDER BY j +-- +ok +== +SELECT i, j, k, x, parse_path(filename)[-2] +FROM read_parquet('{DATA_DIR}/parquet-testing/hive-partitioning/union_by_name/*/f2.parquet', hive_partitioning=1, union_by_name=1, filename=1) +WHERE parse_path(filename) >= parse_path('{DATA_DIR}/parquet-testing/hive-partitioning/union_by_name/x=2') +ORDER BY j +-- +ok +== +SELECT i, j, k, x, parse_path(filename)[-2] +FROM read_parquet('{DATA_DIR}/parquet-testing/hive-partitioning/union_by_name/*/f2.parquet', hive_partitioning=1, union_by_name=1, filename=1) +WHERE parse_path(filename) < parse_path('{DATA_DIR}/parquet-testing/hive-partitioning/union_by_name/x=2') +ORDER BY j +-- +ok +== +SELECT i, j, k, x, filename.replace('\', '/').split('/')[-2] +FROM read_parquet('{DATA_DIR}/parquet-testing/hive-partitioning/union_by_name/*/f2.parquet', hive_partitioning=1, union_by_name=1, filename=1) +WHERE parse_path(filename) < parse_path('{DATA_DIR}/parquet-testing/hive-partitioning/union_by_name/x=1') +ORDER BY j +-- +ok +== diff --git a/parser/testdata/corpus/sql/copy/parquet/union_by_name_pushdown.test b/parser/testdata/corpus/sql/copy/parquet/union_by_name_pushdown.test new file mode 100644 index 0000000..6882c5d --- /dev/null +++ b/parser/testdata/corpus/sql/copy/parquet/union_by_name_pushdown.test @@ -0,0 +1,37 @@ +# source: test/sql/copy/parquet/union_by_name_pushdown.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +COPY (SELECT 42 AS i, 84 AS j) TO '{TEST_DIR}/union_by_name_pushdown1.parquet' +-- +ok +== +COPY (SELECT 128 AS j, 33 AS k) TO '{TEST_DIR}/union_by_name_pushdown2.parquet' +-- +ok +== +SELECT * FROM read_parquet(['{TEST_DIR}/union_by_name_pushdown1.parquet', '{TEST_DIR}/union_by_name_pushdown2.parquet'], union_by_name=True) +-- +ok +== +SELECT k FROM read_parquet(['{TEST_DIR}/union_by_name_pushdown1.parquet', '{TEST_DIR}/union_by_name_pushdown2.parquet'], union_by_name=True) +-- +ok +== +SELECT i FROM read_parquet(['{TEST_DIR}/union_by_name_pushdown1.parquet', '{TEST_DIR}/union_by_name_pushdown2.parquet'], union_by_name=True) +-- +ok +== +SELECT * FROM read_parquet(['{TEST_DIR}/union_by_name_pushdown1.parquet', '{TEST_DIR}/union_by_name_pushdown2.parquet'], union_by_name=True) WHERE k>0 +-- +ok +== +SELECT * FROM read_parquet(['{TEST_DIR}/union_by_name_pushdown1.parquet', '{TEST_DIR}/union_by_name_pushdown2.parquet'], union_by_name=True) WHERE k>0 OR k IS NULL +-- +ok +== +SELECT * FROM read_parquet(['{TEST_DIR}/union_by_name_pushdown1.parquet', '{TEST_DIR}/union_by_name_pushdown2.parquet'], union_by_name=True) WHERE i>0 +-- +ok +== diff --git a/parser/testdata/corpus/sql/copy/parquet/union_by_name_struct_filter.test b/parser/testdata/corpus/sql/copy/parquet/union_by_name_struct_filter.test new file mode 100644 index 0000000..b9aa19f --- /dev/null +++ b/parser/testdata/corpus/sql/copy/parquet/union_by_name_struct_filter.test @@ -0,0 +1,17 @@ +# source: test/sql/copy/parquet/union_by_name_struct_filter.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +COPY (SELECT {'a': 1, 'b': 2}::STRUCT(a INT, b INT) AS s, 1 AS id) TO '{TEST_DIR}/f1.parquet' +-- +ok +== +COPY (SELECT 2 AS id) TO '{TEST_DIR}/f2.parquet' +-- +ok +== +SELECT * FROM read_parquet(['{TEST_DIR}/f1.parquet', '{TEST_DIR}/f2.parquet'], union_by_name=true) WHERE s.a = 1 +-- +ok +== diff --git a/parser/testdata/corpus/sql/copy/parquet/union_by_name_struct_projection.test b/parser/testdata/corpus/sql/copy/parquet/union_by_name_struct_projection.test new file mode 100644 index 0000000..f09d0fa --- /dev/null +++ b/parser/testdata/corpus/sql/copy/parquet/union_by_name_struct_projection.test @@ -0,0 +1,35 @@ +# source: test/sql/copy/parquet/union_by_name_struct_projection.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +COPY (SELECT {'a': 1, 'b': 2}::STRUCT(a INT, b INT) AS s, 1 AS id) +TO '{TEST_DIR}/struct.parquet' (FORMAT PARQUET); +-- +ok +== +COPY (SELECT 2 AS id) +TO '{TEST_DIR}/no_struct.parquet' (FORMAT PARQUET); +-- +ok +== +SELECT id, s.a +FROM read_parquet(['{TEST_DIR}/struct.parquet', '{TEST_DIR}/no_struct.parquet'], union_by_name = true) +ORDER BY id; +-- +ok +== +SELECT id +FROM read_parquet(['{TEST_DIR}/struct.parquet', '{TEST_DIR}/no_struct.parquet'], union_by_name = true) +WHERE s.a IS NULL +ORDER BY id; +-- +ok +== +SELECT id +FROM read_parquet(['{TEST_DIR}/struct.parquet', '{TEST_DIR}/no_struct.parquet'], union_by_name = true) +WHERE s.a = 1 +ORDER BY id; +-- +ok +== diff --git a/parser/testdata/corpus/sql/copy/parquet/variant_array_row_group_pruning.test b/parser/testdata/corpus/sql/copy/parquet/variant_array_row_group_pruning.test new file mode 100644 index 0000000..bb3c1fd --- /dev/null +++ b/parser/testdata/corpus/sql/copy/parquet/variant_array_row_group_pruning.test @@ -0,0 +1,24 @@ +# source: test/sql/copy/parquet/variant_array_row_group_pruning.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +COPY ( + SELECT [i::INTEGER]::VARIANT AS v + FROM range(8192) t(i) +) TO '{TEST_DIR}/variant_array_row_group_pruning.parquet' (ROW_GROUP_SIZE 2048) +-- +ok +== +SELECT count(*) +FROM '{TEST_DIR}/variant_array_row_group_pruning.parquet' +WHERE v[1]::INTEGER BETWEEN 4096 AND 4100 +-- +ok +== +EXPLAIN ANALYZE SELECT count(*) +FROM '{TEST_DIR}/variant_array_row_group_pruning.parquet' +WHERE v[1]::INTEGER BETWEEN 4096 AND 4100 +-- +ok +== diff --git a/parser/testdata/corpus/sql/copy/parquet/writer/parquet_dictionary_index_width.test b/parser/testdata/corpus/sql/copy/parquet/writer/parquet_dictionary_index_width.test new file mode 100644 index 0000000..31f228b --- /dev/null +++ b/parser/testdata/corpus/sql/copy/parquet/writer/parquet_dictionary_index_width.test @@ -0,0 +1,101 @@ +# source: test/sql/copy/parquet/writer/parquet_dictionary_index_width.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +COPY ( + SELECT CASE i % 5 + WHEN 0 THEN 'A' + WHEN 1 THEN 'A' + WHEN 2 THEN 'A' + WHEN 3 THEN 'B' + ELSE 'B' + END AS s + FROM range(65536) t(i) +) TO '{TEST_DIR}/dict-two-values.parquet' (FORMAT PARQUET, WRITE_BLOOM_FILTER FALSE); +-- +ok +== +COPY ( + SELECT CASE i % 5 + WHEN 0 THEN 'A' + WHEN 1 THEN 'A' + WHEN 2 THEN 'A' + WHEN 3 THEN 'B' + ELSE 'C' + END AS s + FROM range(65536) t(i) +) TO '{TEST_DIR}/dict-three-values.parquet' (FORMAT PARQUET, WRITE_BLOOM_FILTER FALSE); +-- +ok +== +SELECT encodings, stats_distinct_count +FROM parquet_metadata('{TEST_DIR}/dict-two-values.parquet'); +-- +ok +== +SELECT encodings, stats_distinct_count +FROM parquet_metadata('{TEST_DIR}/dict-three-values.parquet'); +-- +ok +== +WITH two AS ( + SELECT total_uncompressed_size AS sz + FROM parquet_metadata('{TEST_DIR}/dict-two-values.parquet') +), three AS ( + SELECT total_uncompressed_size AS sz + FROM parquet_metadata('{TEST_DIR}/dict-three-values.parquet') +) +SELECT CASE WHEN two.sz * 3 < three.sz * 2 THEN 1 ELSE 0 END +FROM two, three; +-- +ok +== +COPY ( + SELECT CASE i % 5 + WHEN 0 THEN 'A' + WHEN 1 THEN 'A' + WHEN 2 THEN 'A' + WHEN 3 THEN 'B' + ELSE 'B' + END AS s + FROM range(65536) t(i) +) TO '{TEST_DIR}/dict-two-values-v2.parquet' (FORMAT PARQUET, PARQUET_VERSION v2, WRITE_BLOOM_FILTER FALSE); +-- +ok +== +COPY ( + SELECT CASE i % 5 + WHEN 0 THEN 'A' + WHEN 1 THEN 'A' + WHEN 2 THEN 'A' + WHEN 3 THEN 'B' + ELSE 'C' + END AS s + FROM range(65536) t(i) +) TO '{TEST_DIR}/dict-three-values-v2.parquet' (FORMAT PARQUET, PARQUET_VERSION v2, WRITE_BLOOM_FILTER FALSE); +-- +ok +== +SELECT encodings, stats_distinct_count +FROM parquet_metadata('{TEST_DIR}/dict-two-values-v2.parquet'); +-- +ok +== +SELECT encodings, stats_distinct_count +FROM parquet_metadata('{TEST_DIR}/dict-three-values-v2.parquet'); +-- +ok +== +WITH two AS ( + SELECT total_uncompressed_size AS sz + FROM parquet_metadata('{TEST_DIR}/dict-two-values-v2.parquet') +), three AS ( + SELECT total_uncompressed_size AS sz + FROM parquet_metadata('{TEST_DIR}/dict-three-values-v2.parquet') +) +SELECT CASE WHEN two.sz * 3 < three.sz * 2 THEN 1 ELSE 0 END +FROM two, three; +-- +ok +== diff --git a/parser/testdata/corpus/sql/copy/parquet/writer/parquet_empty_struct.test b/parser/testdata/corpus/sql/copy/parquet/writer/parquet_empty_struct.test new file mode 100644 index 0000000..ae21d4a --- /dev/null +++ b/parser/testdata/corpus/sql/copy/parquet/writer/parquet_empty_struct.test @@ -0,0 +1,17 @@ +# source: test/sql/copy/parquet/writer/parquet_empty_struct.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +COPY (SELECT empty_struct FROM test_all_types()) TO '{TEST_DIR}/empty_struct.parquet' (FORMAT PARQUET); +-- +ok +== +COPY (SELECT {'a': empty_struct} AS s FROM test_all_types()) TO '{TEST_DIR}/empty_struct.parquet' (FORMAT PARQUET); +-- +ok +== +COPY (SELECT [empty_struct] AS l FROM test_all_types()) TO '{TEST_DIR}/empty_struct.parquet' (FORMAT PARQUET); +-- +ok +== diff --git a/parser/testdata/corpus/sql/copy/parquet/writer/parquet_test_all_types.test b/parser/testdata/corpus/sql/copy/parquet/writer/parquet_test_all_types.test new file mode 100644 index 0000000..62f8dab --- /dev/null +++ b/parser/testdata/corpus/sql/copy/parquet/writer/parquet_test_all_types.test @@ -0,0 +1,46 @@ +# source: test/sql/copy/parquet/writer/parquet_test_all_types.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +CREATE TABLE all_types AS +SELECT * EXCLUDE (bit, "union", empty_struct, tuple) REPLACE ( + case when extract(month from interval) <> 0 then interval '1 month 1 day 12:13:34.123' else interval end AS interval +) +FROM test_all_types(); +-- +ok +== +COPY all_types TO "{TEST_DIR}/all_types.parquet" (FORMAT PARQUET); +-- +ok +== +SELECT * REPLACE ( + hugeint::DOUBLE AS hugeint, + uhugeint::DOUBLE AS uhugeint, + timezone(interval '0 seconds', time_tz) AS time_tz +) +FROM all_types +-- +ok +== +SELECT * +FROM '{TEST_DIR}/all_types.parquet' +-- +ok +== +explain select "{type}" from '{TEST_DIR}/all_types.parquet' +WHERE "{type}" IN (127); +-- +ok +== +explain select "VARCHAR" from '{TEST_DIR}/all_types.parquet' +WHERE "VARCHAR" IN ('🦆🦆🦆🦆🦆🦆'); +-- +ok +== +explain select "bool" from '{TEST_DIR}/all_types.parquet' +WHERE "bool" IN (true); +-- +ok +== diff --git a/parser/testdata/corpus/sql/copy/parquet/writer/parquet_timetz_metadata.test b/parser/testdata/corpus/sql/copy/parquet/writer/parquet_timetz_metadata.test new file mode 100644 index 0000000..b8d46a8 --- /dev/null +++ b/parser/testdata/corpus/sql/copy/parquet/writer/parquet_timetz_metadata.test @@ -0,0 +1,22 @@ +# source: test/sql/copy/parquet/writer/parquet_timetz_metadata.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +COPY ( + SELECT + CAST(TIMETZ '08:30:00+00' + (i % 5) * INTERVAL 1 MINUTE AS TIME WITH TIME ZONE) AS event_time_tz, + CAST(TIME '08:30:00' + (i % 5) * INTERVAL 1 MINUTE AS TIME) AS event_time, + CAST(TIMESTAMP '2026-01-02 08:30:00+00' + (i % 5) * INTERVAL 1 MINUTE AS TIMESTAMP WITH TIME ZONE) AS ts_tz + FROM range(1000) tbl(i) +) TO '{TEST_DIR}/timetz_metadata.parquet' (FORMAT PARQUET, COMPRESSION ZSTD) +-- +ok +== +SELECT path_in_schema, encodings <> '', stats_min::VARCHAR, stats_max::VARCHAR, + stats_min_value::VARCHAR, stats_max_value::VARCHAR +FROM parquet_metadata('{TEST_DIR}/timetz_metadata.parquet') +ORDER BY column_id +-- +ok +== diff --git a/parser/testdata/corpus/sql/copy/parquet/writer/parquet_timetz_roundtrip.test b/parser/testdata/corpus/sql/copy/parquet/writer/parquet_timetz_roundtrip.test new file mode 100644 index 0000000..f1a3de4 --- /dev/null +++ b/parser/testdata/corpus/sql/copy/parquet/writer/parquet_timetz_roundtrip.test @@ -0,0 +1,22 @@ +# source: test/sql/copy/parquet/writer/parquet_timetz_roundtrip.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +COPY ( + SELECT * + FROM (VALUES + (TIMETZ '12:34:56+02'), + (TIMETZ '01:00:00+02'), + (TIMETZ '23:30:00-02') + ) tbl(x) +) TO '{TEST_DIR}/timetz_roundtrip.parquet' (FORMAT PARQUET) +-- +ok +== +SELECT x::VARCHAR, typeof(x) +FROM read_parquet('{TEST_DIR}/timetz_roundtrip.parquet') +ORDER BY 1 +-- +ok +== diff --git a/parser/testdata/corpus/sql/copy/parquet/writer/parquet_union_list.test b/parser/testdata/corpus/sql/copy/parquet/writer/parquet_union_list.test new file mode 100644 index 0000000..ea14bcd --- /dev/null +++ b/parser/testdata/corpus/sql/copy/parquet/writer/parquet_union_list.test @@ -0,0 +1,219 @@ +# source: test/sql/copy/parquet/writer/parquet_union_list.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +CREATE TABLE origin (id INT, ufield UNION(val VARCHAR[], omitted BOOLEAN)); +-- +ok +== +INSERT INTO origin VALUES +(1, union_value(val := ['a', 'b']::VARCHAR[])), +(2, union_value(val := []::VARCHAR[])), +(3, union_value(val := [NULL, 'x']::VARCHAR[])), +(4, union_value(omitted := true)), +(5, union_value(omitted := false)), +(6, NULL); +-- +ok +== +COPY origin TO '{TEMP_DIR}/u.parquet' (FORMAT PARQUET); +-- +ok +== +SELECT CAST(ufield AS UNION(val VARCHAR[], omitted BOOLEAN)) +FROM read_parquet('{TEMP_DIR}/u.parquet') +ORDER BY id +-- +ok +== +SELECT ufield +FROM read_parquet('{TEMP_DIR}/u.parquet') +ORDER BY id +-- +ok +== +CREATE TABLE origin_int (id INT, ufield UNION(nums INT[], flag BOOLEAN)); +-- +ok +== +INSERT INTO origin_int VALUES +(1, union_value(nums := [1, 2, 3])), +(2, union_value(nums := [])), +(3, union_value(flag := true)); +-- +ok +== +COPY origin_int TO '{TEMP_DIR}/u_int.parquet' (FORMAT PARQUET); +-- +ok +== +SELECT CAST(ufield AS UNION(nums INT[], flag BOOLEAN)) +FROM read_parquet('{TEMP_DIR}/u_int.parquet') +ORDER BY id +-- +ok +== +CREATE TABLE origin_struct (id INT, ufield UNION(items STRUCT(a INT, b VARCHAR)[], other BOOLEAN)); +-- +ok +== +INSERT INTO origin_struct VALUES +(1, union_value(items := [{'a': 1, 'b': 'x'}, {'a': 2, 'b': 'y'}]::STRUCT(a INT, b VARCHAR)[])), +(2, union_value(items := []::STRUCT(a INT, b VARCHAR)[])), +(3, union_value(other := false)); +-- +ok +== +COPY origin_struct TO '{TEMP_DIR}/u_struct.parquet' (FORMAT PARQUET); +-- +ok +== +SELECT CAST(ufield AS UNION(items STRUCT(a INT, b VARCHAR)[], other BOOLEAN)) +FROM read_parquet('{TEMP_DIR}/u_struct.parquet') +ORDER BY id +-- +ok +== +CREATE TABLE origin_list_union (id INT, items UNION(str VARCHAR, num INT)[]); +-- +ok +== +INSERT INTO origin_list_union VALUES +(1, [1::UNION(str VARCHAR, num INT), 'one']), +(2, []::UNION(str VARCHAR, num INT)[]), +(3, NULL); +-- +ok +== +COPY origin_list_union TO '{TEMP_DIR}/list_union.parquet' (FORMAT PARQUET); +-- +ok +== +SELECT items FROM read_parquet('{TEMP_DIR}/list_union.parquet') +ORDER BY id +-- +ok +== +CREATE TABLE origin_nested (id INT, s STRUCT(items UNION(val VARCHAR[], flag BOOLEAN)[], n INT)); +-- +ok +== +INSERT INTO origin_nested VALUES +(1, { + 'items': [ + union_value(val := ['a']::VARCHAR[])::UNION(val VARCHAR[], flag BOOLEAN), + union_value(flag := true)::UNION(val VARCHAR[], flag BOOLEAN) + ], + 'n': 1 +}), +(2, {'items': []::UNION(val VARCHAR[], flag BOOLEAN)[], 'n': 2}); +-- +ok +== +COPY origin_nested TO '{TEMP_DIR}/nested_union_list.parquet' (FORMAT PARQUET); +-- +ok +== +SELECT s FROM read_parquet('{TEMP_DIR}/nested_union_list.parquet') +ORDER BY id +-- +ok +== +CREATE TABLE origin_single (id INT, u UNION(vals INT[])); +-- +ok +== +INSERT INTO origin_single VALUES +(1, union_value(vals := [10, 20])), +(2, NULL); +-- +ok +== +COPY origin_single TO '{TEMP_DIR}/single_union.parquet' (FORMAT PARQUET); +-- +ok +== +SELECT CAST(u AS UNION(vals INT[])) FROM read_parquet('{TEMP_DIR}/single_union.parquet') ORDER BY id +-- +ok +== +CREATE TABLE origin_map (id INT, s STRUCT(m MAP(VARCHAR, INT[]), n INT)); +-- +ok +== +INSERT INTO origin_map VALUES +(1, {'m': map(['a'], [[1, 2]]), 'n': 1}), +(2, {'m': map([], []::INT[][]), 'n': 2}); +-- +ok +== +COPY origin_map TO '{TEMP_DIR}/map_list.parquet' (FORMAT PARQUET); +-- +ok +== +SELECT s FROM read_parquet('{TEMP_DIR}/map_list.parquet') +ORDER BY id +-- +ok +== +CREATE TABLE origin_map_struct (id INT, m MAP(STRUCT(k INT), INT), lst MAP(VARCHAR, INT)[]); +-- +ok +== +INSERT INTO origin_map_struct VALUES +(1, map([{'k': 1}], [10]), [map(['x'], [1]), map(['y'], [2])]), +(2, map([], []::INT[]), []::MAP(VARCHAR, INT)[]); +-- +ok +== +COPY origin_map_struct TO '{TEMP_DIR}/map_struct.parquet' (FORMAT PARQUET); +-- +ok +== +SELECT m, lst FROM read_parquet('{TEMP_DIR}/map_struct.parquet') ORDER BY id +-- +ok +== +COPY (SELECT map(['a'], [1]) AS m) TO '{TEMP_DIR}/map.json' (FORMAT JSON); +-- +ok +== +SELECT m['a'] FROM read_json('{TEMP_DIR}/map.json', columns = {m: 'MAP(VARCHAR, INTEGER)'}); +-- +ok +== +CREATE TABLE source(u UNION(val INTEGER[], omitted BOOLEAN)); +-- +ok +== +INSERT INTO source VALUES (union_value(val := [1, 2])), (union_value(omitted := true)); +-- +ok +== +COPY source TO '{TEMP_DIR}/union_copy.parquet' (FORMAT PARQUET); +-- +ok +== +CREATE TABLE target(u UNION(val INTEGER[], omitted BOOLEAN)); +-- +ok +== +COPY target FROM '{TEMP_DIR}/union_copy.parquet' (FORMAT PARQUET); +-- +ok +== +SELECT u FROM target; +-- +ok +== +COPY (SELECT union_value(element1 := 42)::UNION(element1 INTEGER, other BOOLEAN) AS data) +TO '{TEMP_DIR}/union_element1.json' (FORMAT JSON); +-- +ok +== +SELECT data FROM read_json('{TEMP_DIR}/union_element1.json', + columns = {data: 'UNION(element1 INTEGER, other BOOLEAN)'}); +-- +ok +== diff --git a/parser/testdata/corpus/sql/copy/parquet/writer/parquet_write_booleans.test b/parser/testdata/corpus/sql/copy/parquet/writer/parquet_write_booleans.test new file mode 100644 index 0000000..a7ba174 --- /dev/null +++ b/parser/testdata/corpus/sql/copy/parquet/writer/parquet_write_booleans.test @@ -0,0 +1,31 @@ +# source: test/sql/copy/parquet/writer/parquet_write_booleans.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +CREATE TABLE bools(b BOOL) +-- +ok +== +INSERT INTO bools SELECT CASE WHEN i%2=0 THEN NULL ELSE i%7=0 OR i%3=0 END b FROM range(10000) tbl(i); +-- +ok +== +SELECT COUNT(*), COUNT(b), BOOL_AND(b), BOOL_OR(b), SUM(CASE WHEN b THEN 1 ELSE 0 END) true_count, SUM(CASE WHEN b THEN 0 ELSE 1 END) false_count +FROM bools +-- +ok +== +COPY bools TO '{TEST_DIR}/bools.parquet' (FORMAT 'parquet'); +-- +ok +== +SELECT COUNT(*), COUNT(b), BOOL_AND(b), BOOL_OR(b), SUM(CASE WHEN b THEN 1 ELSE 0 END) true_count, SUM(CASE WHEN b THEN 0 ELSE 1 END) false_count +FROM '{TEST_DIR}/bools.parquet' +-- +ok +== +SELECT typeof(b) FROM '{TEST_DIR}/bools.parquet' LIMIT 1 +-- +ok +== diff --git a/parser/testdata/corpus/sql/copy/parquet/writer/parquet_write_compression_level.test b/parser/testdata/corpus/sql/copy/parquet/writer/parquet_write_compression_level.test new file mode 100644 index 0000000..f631493 --- /dev/null +++ b/parser/testdata/corpus/sql/copy/parquet/writer/parquet_write_compression_level.test @@ -0,0 +1,45 @@ +# source: test/sql/copy/parquet/writer/parquet_write_compression_level.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +CREATE TABLE integers AS FROM range(100) t(i) +-- +ok +== +COPY integers TO '{TEST_DIR}/compress_level.parquet' (FORMAT 'parquet', COMPRESSION_LEVEL 10); +-- +ok +== +COPY integers TO '{TEST_DIR}/compress_level.parquet' (FORMAT 'parquet', CODEC ZSTD, COMPRESSION_LEVEL 0); +-- +ok +== +COPY integers TO '{TEST_DIR}/compress_level.parquet' (FORMAT 'parquet', CODEC ZSTD, COMPRESSION_LEVEL 23); +-- +ok +== +COPY integers TO '{TEST_DIR}/compress_level.parquet' (FORMAT 'parquet', CODEC ZSTD, COMPRESSION_LEVEL -131072); +-- +ok +== +COPY integers TO '{TEST_DIR}/compress_level.parquet' (FORMAT 'parquet', CODEC ZSTD, COMPRESSION_LEVEL -131073); +-- +ok +== +COPY integers TO '{TEST_DIR}/compress_level.parquet' (FORMAT 'parquet', CODEC ZSTD, COMPRESSION_LEVEL 1); +-- +ok +== +COPY integers TO '{TEST_DIR}/compress_level2.parquet' (FORMAT 'parquet', CODEC ZSTD, COMPRESSION_LEVEL 22); +-- +ok +== +SELECT * FROM '{TEST_DIR}/compress_level.parquet' +-- +ok +== +SELECT * FROM '{TEST_DIR}/compress_level2.parquet' +-- +ok +== diff --git a/parser/testdata/corpus/sql/copy/parquet/writer/parquet_write_data_page_size.test b/parser/testdata/corpus/sql/copy/parquet/writer/parquet_write_data_page_size.test new file mode 100644 index 0000000..1e67e66 --- /dev/null +++ b/parser/testdata/corpus/sql/copy/parquet/writer/parquet_write_data_page_size.test @@ -0,0 +1,35 @@ +# source: test/sql/copy/parquet/writer/parquet_write_data_page_size.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +copy (select range i, 'val_' || (range % 400) s from range(100_000)) to '{TEST_DIR}/small_pages.parquet' (format parquet, data_page_size_limit 4096, compression uncompressed); +-- +ok +== +select count(*), sum(i) from '{TEST_DIR}/small_pages.parquet'; +-- +ok +== +select count(*) from '{TEST_DIR}/small_pages.parquet' where s <> 'val_' || (i % 400); +-- +ok +== +copy (select range i, 'val_' || (range % 400) s from range(100_000)) to '{TEST_DIR}/big_pages.parquet' (format parquet, compression uncompressed); +-- +ok +== +select small.total_size > big.total_size +from (select sum(total_compressed_size) total_size from parquet_metadata('{TEST_DIR}/small_pages.parquet')) small, + (select sum(total_compressed_size) total_size from parquet_metadata('{TEST_DIR}/big_pages.parquet')) big; +-- +ok +== +copy (select 42) to '{TEST_DIR}/zero.parquet' (format parquet, data_page_size_limit 0); +-- +ok +== +copy (select 42) to '{TEST_DIR}/too_big.parquet' (format parquet, data_page_size_limit 104857601); +-- +ok +== diff --git a/parser/testdata/corpus/sql/copy/parquet/writer/parquet_write_date.test b/parser/testdata/corpus/sql/copy/parquet/writer/parquet_write_date.test new file mode 100644 index 0000000..f8be00a --- /dev/null +++ b/parser/testdata/corpus/sql/copy/parquet/writer/parquet_write_date.test @@ -0,0 +1,29 @@ +# source: test/sql/copy/parquet/writer/parquet_write_date.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +CREATE TABLE dates(d DATE) +-- +ok +== +INSERT INTO dates VALUES (DATE '1992-01-01'), (DATE '1900-01-01'), (NULL), (DATE '2020-09-27') +-- +ok +== +COPY dates TO '{TEST_DIR}/dates.parquet' (FORMAT 'parquet'); +-- +ok +== +SELECT * FROM '{TEST_DIR}/dates.parquet' +-- +ok +== +SELECT typeof(d) FROM '{TEST_DIR}/dates.parquet' LIMIT 1 +-- +ok +== +SELECT * FROM '{TEST_DIR}/dates.parquet' WHERE d='1992-01-01' +-- +ok +== diff --git a/parser/testdata/corpus/sql/copy/parquet/writer/parquet_write_decimals.test b/parser/testdata/corpus/sql/copy/parquet/writer/parquet_write_decimals.test new file mode 100644 index 0000000..ec5ab75 --- /dev/null +++ b/parser/testdata/corpus/sql/copy/parquet/writer/parquet_write_decimals.test @@ -0,0 +1,72 @@ +# source: test/sql/copy/parquet/writer/parquet_write_decimals.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +CREATE TABLE decimals( + dec4 DECIMAL(4,1), + dec9 DECIMAL(9,2), + dec18 DECIMAL(18,3), + dec38 DECIMAL(38,4) +); +-- +ok +== +INSERT INTO decimals VALUES ( + -999.9, + -9999999.99, + -999999999999999.999, + -999999999999999999999999999999999.9999 +), ( + NULL, NULL, NULL, NULL +), ( + 42, 42, 42, 42 +), ( + -42, -42, -42, -42 +), ( + 0, 0, 0, 0 + ), ( + 999.9, + 9999999.99, + 999999999999999.999, + 999999999999999999999999999999999.9999 +); +-- +ok +== +COPY decimals TO '{TEST_DIR}/decimals.parquet'; +-- +ok +== +SELECT * FROM decimals; +-- +ok +== +SELECT * FROM '{TEST_DIR}/decimals.parquet'; +-- +ok +== +SELECT stats_min, stats_max, stats_min_value, stats_max_value FROM parquet_metadata('{TEST_DIR}/decimals.parquet'); +-- +ok +== +DELETE FROM decimals WHERE dec4<-42 OR dec4>42 +-- +ok +== +SELECT * FROM '{TEST_DIR}/decimals.parquet' WHERE {dec_column}=42 +-- +error: Parser Error: syntax error at or near "}" +== +SELECT * FROM '{TEST_DIR}/decimals.parquet' WHERE {dec_column}=-43 +-- +error: Parser Error: syntax error at or near "}" +== +SELECT * FROM '{TEST_DIR}/decimals.parquet' WHERE {dec_column}=43 +-- +error: Parser Error: syntax error at or near "}" +== +SELECT sdec4.min, sdec4.max, sdec9.min, sdec9.max, sdec18.min, sdec18.max, sdec38.min, sdec38.max FROM (SELECT stats(dec4) sdec4, stats(dec9) sdec9, stats(dec18) sdec18, stats(dec38) sdec38 FROM '{TEST_DIR}/decimals.parquet' LIMIT 1) +-- +ok +== diff --git a/parser/testdata/corpus/sql/copy/parquet/writer/parquet_write_enums.test b/parser/testdata/corpus/sql/copy/parquet/writer/parquet_write_enums.test new file mode 100644 index 0000000..ecbb99f --- /dev/null +++ b/parser/testdata/corpus/sql/copy/parquet/writer/parquet_write_enums.test @@ -0,0 +1,68 @@ +# source: test/sql/copy/parquet/writer/parquet_write_enums.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +CREATE TYPE mood AS ENUM ('joy', 'ok', 'happy'); +-- +ok +== +CREATE TABLE enums(m mood); +-- +ok +== +INSERT INTO enums VALUES + ('happy'), ('happy'), ('joy'), ('joy'), + ('happy'), ('happy'), ('joy'), ('joy'), + ('happy'), ('happy'), ('joy'), ('joy'), + ('happy'), ('happy'), ('joy'), ('joy'), + ('happy'), ('happy'), ('joy'), ('joy'), + ('happy'), ('happy'), ('joy'), ('joy'), + ('happy'), ('happy'), ('joy'), ('joy'), ('joy') +-- +ok +== +COPY enums TO '{TEST_DIR}/enums.parquet' (FORMAT PARQUET); +-- +ok +== +SELECT * FROM '{TEST_DIR}/enums.parquet' +-- +ok +== +UPDATE enums SET m=NULL WHERE m='joy' +-- +ok +== +UPDATE enums SET m=NULL +-- +ok +== +CREATE TYPE myenum AS ENUM ('a', 'b', 'c'); +-- +ok +== +CREATE TABLE t1 AS SELECT 'a'::myenum AS m FROM range(10) t(i); +-- +ok +== +COPY t1 TO '{TEST_DIR}/enum_stats_single_1.parquet' (FORMAT PARQUET); +-- +ok +== +SELECT stats_min, stats_max FROM parquet_metadata('{TEST_DIR}/enum_stats_single_1.parquet') +-- +ok +== +CREATE TABLE t2 AS SELECT 'c'::myenum AS m FROM range(10) t(i); +-- +ok +== +COPY t2 TO '{TEST_DIR}/enum_stats_single_2.parquet' (FORMAT PARQUET); +-- +ok +== +SELECT stats_min, stats_max FROM parquet_metadata('{TEST_DIR}/enum_stats_single_2.parquet') +-- +ok +== diff --git a/parser/testdata/corpus/sql/copy/parquet/writer/parquet_write_field_id.test b/parser/testdata/corpus/sql/copy/parquet/writer/parquet_write_field_id.test new file mode 100644 index 0000000..a9e37cb --- /dev/null +++ b/parser/testdata/corpus/sql/copy/parquet/writer/parquet_write_field_id.test @@ -0,0 +1,197 @@ +# source: test/sql/copy/parquet/writer/parquet_write_field_id.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +copy (select range as i from range(10)) to '{TEST_DIR}/my.parquet' (FIELD_IDS) +-- +ok +== +copy (select range as i from range(10)) to '{TEST_DIR}/my.parquet' (FIELD_IDS {j:42}) +-- +ok +== +copy (select range as i from range(10)) to '{TEST_DIR}/my.parquet' (FIELD_IDS {i:42}) +-- +ok +== +select field_id from parquet_schema('{TEST_DIR}/my.parquet') where name = 'i' +-- +ok +== +copy (select range as i from range(10)) to '{TEST_DIR}/my.parquet' (FIELD_IDS {i:'42'}) +-- +ok +== +copy (select range as i from range(10)) to '{TEST_DIR}/my.parquet' (FIELD_IDS {i:'abc'}) +-- +ok +== +copy (select range as i from range(10)) to '{TEST_DIR}/my.parquet' (FIELD_IDS {i:42::hugeint}) +-- +ok +== +copy (select range as i from range(10)) to '{TEST_DIR}/my.parquet' (FIELD_IDS {i:1024::utinyint}) +-- +ok +== +copy (select range as i from range(10)) to '{TEST_DIR}/my.parquet' (FIELD_IDS {i:i}) +-- +ok +== +copy (select range as i from range(10)) to '{TEST_DIR}/my.parquet' (FIELD_IDS 'oops') +-- +ok +== +copy (select range as i, range as j from range(10)) to '{TEST_DIR}/my.parquet' (FIELD_IDS {i:42,i:43}) +-- +ok +== +copy (select range as i, range as j from range(10)) to '{TEST_DIR}/my.parquet' (FIELD_IDS {i:42,j:41+1}) +-- +ok +== +copy (select range as i, range as j from range(10)) to '{TEST_DIR}/my.parquet' (FIELD_IDS {i:42}) +-- +ok +== +select field_id from parquet_schema('{TEST_DIR}/my.parquet') where name = 'j' +-- +ok +== +copy (select range as i, range as j from range(10)) to '{TEST_DIR}/my.parquet' (FIELD_IDS {i:42,j:43}) +-- +ok +== +copy (select range as i, range as j from range(10)) to '{TEST_DIR}/my.parquet' (FIELD_IDS {i:{__duckdb_field_id:42},j:{__duckdb_field_id:43}}) +-- +ok +== +copy (select range as i, range as j from range(10)) to '{TEST_DIR}/my.parquet' (FIELD_IDS {i:{__duckdb_field_id:42,j:43}}) +-- +ok +== +copy (select range(range, range + 3) as i from range(10)) to '{TEST_DIR}/my.parquet' (FIELD_IDS {i:{__duckdb_field_id:42,element:43}}) +-- +ok +== +select field_id from parquet_schema('{TEST_DIR}/my.parquet') where name = 'element' +-- +ok +== +copy (select range(range, range + 3) as i from range(10)) to '{TEST_DIR}/my.parquet' (FIELD_IDS {i:{element:43}}) +-- +ok +== +copy (select range(range, range + 3) as i from range(10)) to '{TEST_DIR}/my.parquet' (FIELD_IDS {i:{__duckdb_field_id:42,elem:43}}) +-- +ok +== +copy (select {f : range} as i from range(10)) to '{TEST_DIR}/my.parquet' (FIELD_IDS {i:{__duckdb_field_id:42,f:43}}) +-- +ok +== +select field_id from parquet_schema('{TEST_DIR}/my.parquet') where name = 'i' and num_children > 0 +-- +ok +== +select field_id from parquet_schema('{TEST_DIR}/my.parquet') where name = 'f' +-- +ok +== +copy (select {f : range} as i from range(10)) to '{TEST_DIR}/my.parquet' (FIELD_IDS {i:{__duckdb_field_id:42,g:43}}) +-- +ok +== +copy (select map {range : 10 - range} as i from range(10)) to '{TEST_DIR}/my.parquet' (FIELD_IDS {i:{__duckdb_field_id:42,key:43,value:44}}) +-- +ok +== +select field_id from parquet_schema('{TEST_DIR}/my.parquet') where name = 'key' +-- +ok +== +select field_id from parquet_schema('{TEST_DIR}/my.parquet') where name = 'value' +-- +ok +== +copy (select map {range : 10 - range} as i from range(10)) to '{TEST_DIR}/my.parquet' (FIELD_IDS {i:{__duckdb_field_id:42,k:43,v:44}}) +-- +ok +== +copy (select range as i, range as j from range(10)) to '{TEST_DIR}/my.parquet' (FIELD_IDS 'auto') +-- +ok +== +set variable field_id_values={i:{__duckdb_field_id:42,key:43,value:{__duckdb_field_id:44,element:{__duckdb_field_id:45,j:46}}}} +-- +ok +== +copy (select map {'my_key' : [{j : 42}]} as i) to '{TEST_DIR}/my.parquet' (FIELD_IDS getvariable('field_id_values')) +-- +ok +== +select name, field_id from parquet_schema('{TEST_DIR}/my.parquet') where name in ('i', 'key', 'value', 'element', 'j') order by field_id +-- +ok +== +copy (select {f : range} as i from range(10)) to '{TEST_DIR}/my.parquet' (FIELD_IDS {i:{__duckdb_field_id:42}, f:43}) +-- +ok +== +copy (select {f : range} as i from range(10)) to '{TEST_DIR}/my.parquet' (FIELD_IDS {i:{field_id:42, f:43}}) +-- +ok +== +copy (select range(range, range + 3) as i from range(10)) to '{TEST_DIR}/my.parquet' (FIELD_IDS 'auto') +-- +ok +== +copy (select {f : range} as i from range(10)) to '{TEST_DIR}/my.parquet' (FIELD_IDS 'auto') +-- +ok +== +copy (select map {range : 10 - range} as i from range(10)) to '{TEST_DIR}/my.parquet' (FIELD_IDS 'auto') +-- +ok +== +copy (select map {'my_key' : [{j : 42}]} as i) to '{TEST_DIR}/my.parquet' (FIELD_IDS 'auto') +-- +ok +== +copy (select range as __duckdb_field_id from range(10)) to '{TEST_DIR}/my.parquet' (FIELD_IDS {__duckdb_field_id : 42}) +-- +ok +== +copy (select {__duckdb_field_id : range} as __duckdb_field_id from range(10)) to '{TEST_DIR}/my.parquet' (FIELD_IDS {__duckdb_field_id : {__duckdb_field_id : 42}}) +-- +ok +== +copy (select range as i from range(10)) to '{TEST_DIR}/my.parquet' (FIELD_IDS {"I" : 42}) +-- +ok +== +copy (select range as "I" from range(10)) to '{TEST_DIR}/my.parquet' (FIELD_IDS {i : 42}) +-- +ok +== +select field_id from parquet_schema('{TEST_DIR}/my.parquet') where name = 'I' +-- +ok +== +copy (select {f : range} as i from range(10)) to '{TEST_DIR}/my.parquet' (FIELD_IDS {"I" : {__duckdb_field_id: 42, "F": 43}}) +-- +ok +== +copy (select {"F" : range} as "I" from range(10)) to '{TEST_DIR}/my.parquet' (FIELD_IDS {i : {__duckdb_field_id: 42, f: 43}}) +-- +ok +== +select field_id from parquet_schema('{TEST_DIR}/my.parquet') where name = 'I' and num_children > 0 +-- +ok +== +select field_id from parquet_schema('{TEST_DIR}/my.parquet') where name = 'F' +-- +ok +== diff --git a/parser/testdata/corpus/sql/copy/parquet/writer/parquet_write_home_directory.test b/parser/testdata/corpus/sql/copy/parquet/writer/parquet_write_home_directory.test new file mode 100644 index 0000000..c1fb7c8 --- /dev/null +++ b/parser/testdata/corpus/sql/copy/parquet/writer/parquet_write_home_directory.test @@ -0,0 +1,29 @@ +# source: test/sql/copy/parquet/writer/parquet_write_home_directory.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +COPY integers TO '{TEST_DIR}/integers.parquet' (FORMAT PARQUET); +-- +ok +== +SELECT * FROM '~/integers.parquet' +-- +ok +== +COPY integers_load FROM '~/integers.parquet' +-- +ok +== +COPY integers TO '{TEST_DIR}/homedir_integers1.parquet' +-- +ok +== +COPY integers TO '{TEST_DIR}/homedir_integers2.parquet' +-- +ok +== +SELECT COUNT(*) FROM '~/homedir_integers*.parquet' +-- +ok +== diff --git a/parser/testdata/corpus/sql/copy/parquet/writer/parquet_write_hugeint.test b/parser/testdata/corpus/sql/copy/parquet/writer/parquet_write_hugeint.test new file mode 100644 index 0000000..ff88951 --- /dev/null +++ b/parser/testdata/corpus/sql/copy/parquet/writer/parquet_write_hugeint.test @@ -0,0 +1,25 @@ +# source: test/sql/copy/parquet/writer/parquet_write_hugeint.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +CREATE TABLE hugeints(h HUGEINT) +-- +ok +== +INSERT INTO hugeints VALUES (-1180591620717411303424), (0), (NULL), (1180591620717411303424) +-- +ok +== +COPY hugeints TO '{TEST_DIR}/hugeints.parquet' (FORMAT 'parquet'); +-- +ok +== +SELECT * FROM '{TEST_DIR}/hugeints.parquet' +-- +ok +== +SELECT typeof(h) FROM '{TEST_DIR}/hugeints.parquet' LIMIT 1 +-- +ok +== diff --git a/parser/testdata/corpus/sql/copy/parquet/writer/parquet_write_interval.test b/parser/testdata/corpus/sql/copy/parquet/writer/parquet_write_interval.test new file mode 100644 index 0000000..7dc0da1 --- /dev/null +++ b/parser/testdata/corpus/sql/copy/parquet/writer/parquet_write_interval.test @@ -0,0 +1,30 @@ +# source: test/sql/copy/parquet/writer/parquet_write_interval.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +CREATE TABLE IF NOT EXISTS intervals (i interval); +-- +ok +== +INSERT INTO intervals VALUES + (interval '1' day), + (interval '00:00:01'), + (NULL), + (interval '0' month), + (interval '1' month) +-- +ok +== +COPY intervals TO '{TEST_DIR}/intervals.parquet' +-- +ok +== +SELECT * FROM '{TEST_DIR}/intervals.parquet' ORDER BY 1 +-- +ok +== +COPY (SELECT -interval '1 day') TO '{TEST_DIR}/intervals.parquet' +-- +ok +== diff --git a/parser/testdata/corpus/sql/copy/parquet/writer/parquet_write_issue_5779.test b/parser/testdata/corpus/sql/copy/parquet/writer/parquet_write_issue_5779.test new file mode 100644 index 0000000..7688862 --- /dev/null +++ b/parser/testdata/corpus/sql/copy/parquet/writer/parquet_write_issue_5779.test @@ -0,0 +1,53 @@ +# source: test/sql/copy/parquet/writer/parquet_write_issue_5779.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +CREATE TABLE empty_lists(i INTEGER[]); +-- +ok +== +INSERT INTO empty_lists SELECT [] FROM range(10) UNION ALL SELECT [1, 2, 3, 4, 5, 6, 7, 8, 9, 10] +-- +ok +== +COPY (SELECT * FROM empty_lists LIMIT 10) TO '{TEST_DIR}/emptylist_int.parquet'; +-- +ok +== +SELECT * FROM '{TEST_DIR}/emptylist_int.parquet' +-- +ok +== +CREATE TABLE empty_lists_varchar(i VARCHAR[]); +-- +ok +== +INSERT INTO empty_lists_varchar SELECT [] FROM range(10) UNION ALL SELECT ['hello', 'world', 'this', 'is', 'a', 'varchar', 'list'] +-- +ok +== +COPY (SELECT * FROM empty_lists_varchar LIMIT 10) TO '{TEST_DIR}/emptylist_varchar.parquet'; +-- +ok +== +SELECT * FROM '{TEST_DIR}/emptylist_varchar.parquet' +-- +ok +== +CREATE TABLE empty_list_nested(i INT[][]); +-- +ok +== +INSERT INTO empty_list_nested SELECT [] FROM range(10) UNION ALL SELECT [[1, 2, 3], [4, 5], [6, 7, 8]] +-- +ok +== +COPY (SELECT * FROM empty_list_nested LIMIT 10) TO '{TEST_DIR}/empty_list_nested.parquet'; +-- +ok +== +SELECT * FROM '{TEST_DIR}/empty_list_nested.parquet' +-- +ok +== diff --git a/parser/testdata/corpus/sql/copy/parquet/writer/parquet_write_memory_usage.test b/parser/testdata/corpus/sql/copy/parquet/writer/parquet_write_memory_usage.test new file mode 100644 index 0000000..cd45f91 --- /dev/null +++ b/parser/testdata/corpus/sql/copy/parquet/writer/parquet_write_memory_usage.test @@ -0,0 +1,21 @@ +# source: test/sql/copy/parquet/writer/parquet_write_memory_usage.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +set memory_limit='{memory_limit}' +-- +error: Parser Error: Memory must have a number (e.g. 1GB) +== +copy (select * from range(163840)) to '{TEST_DIR}/parquet_write_memory_usage.parquet' (row_group_size {row_group_size}) +-- +error: Parser Error: syntax error at or near "}" +== +set memory_limit='4gb' +-- +ok +== +select sum(range) = (count(*) * (count(*) - 1)) // 2 from '{TEST_DIR}/parquet_write_memory_usage.parquet' +-- +ok +== diff --git a/parser/testdata/corpus/sql/copy/parquet/writer/parquet_write_memory_usage.test.metadata.json b/parser/testdata/corpus/sql/copy/parquet/writer/parquet_write_memory_usage.test.metadata.json new file mode 100644 index 0000000..4308a63 --- /dev/null +++ b/parser/testdata/corpus/sql/copy/parquet/writer/parquet_write_memory_usage.test.metadata.json @@ -0,0 +1,5 @@ +{ + "todo": { + "ff0a57b31734b7cb": "transformer-raised parser error: upstream rejects in the transformer, not the grammar; expected to clear as transformers land (milestones 3-5)" + } +} diff --git a/parser/testdata/corpus/sql/copy/parquet/writer/parquet_write_signed.test b/parser/testdata/corpus/sql/copy/parquet/writer/parquet_write_signed.test new file mode 100644 index 0000000..84fa45f --- /dev/null +++ b/parser/testdata/corpus/sql/copy/parquet/writer/parquet_write_signed.test @@ -0,0 +1,69 @@ +# source: test/sql/copy/parquet/writer/parquet_write_signed.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +CREATE TABLE values_TINYINT AS SELECT d::TINYINT d FROM (VALUES + (-128), (42), (NULL), (127)) tbl (d); +-- +ok +== +CREATE TABLE values_SMALLINT AS SELECT d::SMALLINT d FROM (VALUES + (-32768), (42), (NULL), (32767)) tbl (d); +-- +ok +== +CREATE TABLE values_INTEGER AS SELECT d::INTEGER d FROM (VALUES + (-2147483648), (42), (NULL), (2147483647)) tbl (d); +-- +ok +== +CREATE TABLE values_BIGINT AS SELECT d::BIGINT d FROM (VALUES + (-9223372036854775808), (42), (NULL), (9223372036854775807)) tbl (d); +-- +ok +== +CREATE OR REPLACE TABLE signed(d {type}) +-- +error: Parser Error: syntax error at or near "{" +== +INSERT INTO signed SELECT * FROM values_{type} +-- +error: Parser Error: syntax error at or near "{" +== +COPY signed TO '{TEST_DIR}/signed.parquet' (FORMAT 'parquet'); +-- +ok +== +SELECT * FROM '{TEST_DIR}/signed.parquet' EXCEPT SELECT * FROM signed +-- +ok +== +SELECT * FROM signed EXCEPT SELECT * FROM '{TEST_DIR}/signed.parquet' +-- +ok +== +SELECT * FROM '{TEST_DIR}/signed.parquet' WHERE d=42 +-- +ok +== +SELECT COUNT(*) FROM '{TEST_DIR}/signed.parquet' WHERE d>42 +-- +ok +== +SELECT COUNT(*) FROM '{TEST_DIR}/signed.parquet' WHERE d>=42 +-- +ok +== +SELECT COUNT(*) FROM '{TEST_DIR}/signed.parquet' WHERE d<42 +-- +ok +== +SELECT COUNT(*) FROM '{TEST_DIR}/signed.parquet' WHERE d<=42 +-- +ok +== +SELECT typeof(d)='{type}' FROM '{TEST_DIR}/signed.parquet' LIMIT 1 +-- +ok +== diff --git a/parser/testdata/corpus/sql/copy/parquet/writer/parquet_write_string_distinct.test b/parser/testdata/corpus/sql/copy/parquet/writer/parquet_write_string_distinct.test new file mode 100644 index 0000000..82c130e --- /dev/null +++ b/parser/testdata/corpus/sql/copy/parquet/writer/parquet_write_string_distinct.test @@ -0,0 +1,13 @@ +# source: test/sql/copy/parquet/writer/parquet_write_string_distinct.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +COPY (SELECT 'hello' FROM range(10)) TO '{TEST_DIR}/string_dict.parquet'; +-- +ok +== +SELECT stats_distinct_count FROM parquet_metadata('{TEST_DIR}/string_dict.parquet'); +-- +ok +== diff --git a/parser/testdata/corpus/sql/copy/parquet/writer/parquet_write_strings.test b/parser/testdata/corpus/sql/copy/parquet/writer/parquet_write_strings.test new file mode 100644 index 0000000..686a6db --- /dev/null +++ b/parser/testdata/corpus/sql/copy/parquet/writer/parquet_write_strings.test @@ -0,0 +1,58 @@ +# source: test/sql/copy/parquet/writer/parquet_write_strings.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +INSERT INTO strings VALUES + ('happy'), ('happy'), ('joy'), ('joy'), + ('happy'), ('happy'), ('joy'), ('joy'), + ('happy'), ('happy'), ('joy'), ('joy'), + ('happy'), ('happy'), ('joy'), ('joy'), + ('happy'), ('happy'), ('joy'), ('joy'), + ('happy'), ('happy'), ('joy'), ('joy'), + ('happy'), ('happy'), ('joy'), ('joy'), ('surprise'); +-- +ok +== +COPY strings TO '{TEST_DIR}/strings.parquet' (FORMAT PARQUET, PARQUET_VERSION v2); +-- +ok +== +SELECT encodings FROM parquet_metadata('{TEST_DIR}/strings.parquet') +-- +ok +== +SELECT * FROM '{TEST_DIR}/strings.parquet' +-- +ok +== +SELECT stats_distinct_count FROM parquet_metadata('{TEST_DIR}/strings.parquet') +-- +ok +== +UPDATE strings SET s=NULL WHERE s='joy' +-- +ok +== +COPY strings TO '{TEST_DIR}/strings.parquet' (FORMAT PARQUET); +-- +ok +== +UPDATE strings SET s=NULL +-- +ok +== +INSERT INTO strings VALUES + ('0'), ('1'), ('2'), ('3'), ('4'), ('5'), ('6'), ('7'), ('8'), ('9'), + ('10'), ('11'), ('12'), ('13'), ('14'), ('15'), ('16'), ('17'), ('18'), ('19'), + ('20'), ('21'), ('22'), ('23'), ('24'), ('25'), ('26'), ('27'), ('28'), ('29') +-- +ok +== +INSERT INTO strings VALUES + ('0'), ('1'), ('2'), (NULL), ('4'), ('5'), ('6'), (NULL), ('8'), ('9'), + ('10'), ('11'), ('12'), ('13'), ('14'), ('15'), ('16'), ('17'), ('18'), ('19'), + ('20'), (NULL), ('22'), ('23'), ('24'), ('25'), (NULL), ('27'), ('28'), ('29') +-- +ok +== diff --git a/parser/testdata/corpus/sql/copy/parquet/writer/parquet_write_strings_v1.test b/parser/testdata/corpus/sql/copy/parquet/writer/parquet_write_strings_v1.test new file mode 100644 index 0000000..a551c6a --- /dev/null +++ b/parser/testdata/corpus/sql/copy/parquet/writer/parquet_write_strings_v1.test @@ -0,0 +1,9 @@ +# source: test/sql/copy/parquet/writer/parquet_write_strings_v1.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +COPY strings TO '{TEST_DIR}/strings.parquet' (FORMAT PARQUET, PARQUET_VERSION v1); +-- +ok +== diff --git a/parser/testdata/corpus/sql/copy/parquet/writer/parquet_write_timestamp.test b/parser/testdata/corpus/sql/copy/parquet/writer/parquet_write_timestamp.test new file mode 100644 index 0000000..9012b1f --- /dev/null +++ b/parser/testdata/corpus/sql/copy/parquet/writer/parquet_write_timestamp.test @@ -0,0 +1,125 @@ +# source: test/sql/copy/parquet/writer/parquet_write_timestamp.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +CREATE OR REPLACE TABLE timestamps(d {type}) +-- +error: Parser Error: syntax error at or near "{" +== +INSERT INTO timestamps VALUES + (TIMESTAMP '1992-01-01 12:03:27'), + (TIMESTAMP '1900-01-01 03:08:47'), + (NULL), + (TIMESTAMP '2020-09-27 13:12:01') +-- +ok +== +COPY timestamps TO '{TEST_DIR}/timestamps.parquet' (FORMAT 'parquet'); +-- +ok +== +SELECT * FROM '{TEST_DIR}/timestamps.parquet' +-- +ok +== +SELECT * FROM '{TEST_DIR}/timestamps.parquet' WHERE d='1992-01-01 12:03:27' +-- +ok +== +SELECT typeof(d) FROM '{TEST_DIR}/timestamps.parquet' LIMIT 1 +-- +ok +== +CREATE OR REPLACE TABLE timestamps(d TIMESTAMP_NS) +-- +ok +== +INSERT INTO timestamps VALUES + ('1992-01-01 12:03:27.123456789'), + ('1900-01-01 03:08:47.987654321'), + (NULL), + ('2020-09-27 13:12:01') +-- +ok +== +SELECT * FROM '{TEST_DIR}/timestamps.parquet' WHERE d='1992-01-01 12:03:27.123456789' +-- +ok +== +CREATE OR REPLACE TABLE timestamps_int96( + ts TIMESTAMP, + ts_s TIMESTAMP_S, + ts_ms TIMESTAMP_MS, + ts_ns TIMESTAMP_NS, + ts_tz TIMESTAMPTZ +) +-- +ok +== +INSERT INTO timestamps_int96 VALUES ( + TIMESTAMP '1992-01-01 12:03:27.123456', + TIMESTAMP '1992-01-01 12:03:27', + TIMESTAMP '1992-01-01 12:03:27.123', + TIMESTAMP '1992-01-01 12:03:27.123456789', + TIMESTAMPTZ '1992-01-01 12:03:27.123456+00' +) +-- +ok +== +COPY timestamps_int96 TO '{TEST_DIR}/timestamp_int96.parquet' + (FORMAT 'parquet', write_timestamp_as_int96 true); +-- +ok +== +SELECT COUNT(*) +FROM parquet_schema('{TEST_DIR}/timestamp_int96.parquet') +WHERE name IN ('ts', 'ts_s', 'ts_ms', 'ts_ns', 'ts_tz') + AND type = 'INT96' + AND logical_type IS NULL + AND converted_type IS NULL +-- +ok +== +SELECT ts::VARCHAR, ts_s::VARCHAR, ts_ms::VARCHAR, ts_ns::VARCHAR, ts_tz::VARCHAR +FROM '{TEST_DIR}/timestamp_int96.parquet' +-- +ok +== +INSERT INTO timestamps VALUES ('1992-01-01 12:03:27') +-- +ok +== +COPY timestamps TO '{TEST_DIR}/timestamps_utc_auto_{type}.parquet' + (FORMAT 'parquet', timestamp_is_adjusted_to_utc AUTO); +-- +ok +== +SELECT logical_type LIKE '%isAdjustedToUTC={auto_expected}%' +FROM parquet_schema('{TEST_DIR}/timestamps_utc_auto_{type}.parquet') +WHERE name = 'd' +-- +ok +== +COPY timestamps TO '{TEST_DIR}/timestamps_utc_true_{type}.parquet' + (FORMAT 'parquet', timestamp_is_adjusted_to_utc TRUE); +-- +ok +== +SELECT logical_type LIKE '%isAdjustedToUTC=1%' +FROM parquet_schema('{TEST_DIR}/timestamps_utc_true_{type}.parquet') +WHERE name = 'd' +-- +ok +== +COPY timestamps TO '{TEST_DIR}/timestamps_utc_false_{type}.parquet' + (FORMAT 'parquet', timestamp_is_adjusted_to_utc FALSE); +-- +ok +== +SELECT logical_type LIKE '%isAdjustedToUTC=0%' +FROM parquet_schema('{TEST_DIR}/timestamps_utc_false_{type}.parquet') +WHERE name = 'd' +-- +ok +== diff --git a/parser/testdata/corpus/sql/copy/parquet/writer/parquet_write_uhugeint.test b/parser/testdata/corpus/sql/copy/parquet/writer/parquet_write_uhugeint.test new file mode 100644 index 0000000..886a37b --- /dev/null +++ b/parser/testdata/corpus/sql/copy/parquet/writer/parquet_write_uhugeint.test @@ -0,0 +1,13 @@ +# source: test/sql/copy/parquet/writer/parquet_write_uhugeint.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +CREATE TABLE hugeints(h UHUGEINT) +-- +ok +== +INSERT INTO hugeints VALUES (0), (1), (NULL), (1180591620717411303424) +-- +ok +== diff --git a/parser/testdata/corpus/sql/copy/parquet/writer/parquet_write_unsigned.test b/parser/testdata/corpus/sql/copy/parquet/writer/parquet_write_unsigned.test new file mode 100644 index 0000000..718c6ab --- /dev/null +++ b/parser/testdata/corpus/sql/copy/parquet/writer/parquet_write_unsigned.test @@ -0,0 +1,69 @@ +# source: test/sql/copy/parquet/writer/parquet_write_unsigned.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +CREATE TABLE values_UTINYINT AS SELECT d::UTINYINT d FROM (VALUES + (0), (42), (NULL), (255)) tbl (d); +-- +ok +== +CREATE TABLE values_USMALLINT AS SELECT d::USMALLINT d FROM (VALUES + (0), (42), (NULL), (65535)) tbl (d); +-- +ok +== +CREATE TABLE values_UINTEGER AS SELECT d::UINTEGER d FROM (VALUES + (0), (42), (NULL), (4294967295)) tbl (d); +-- +ok +== +CREATE TABLE values_UBIGINT AS SELECT d::UBIGINT d FROM (VALUES + (0), (42), (NULL), (18446744073709551615)) tbl (d); +-- +ok +== +CREATE OR REPLACE TABLE unsigned(d {type}) +-- +error: Parser Error: syntax error at or near "{" +== +INSERT INTO unsigned SELECT * FROM values_{type} +-- +error: Parser Error: syntax error at or near "{" +== +COPY unsigned TO '{TEST_DIR}/unsigned.parquet' (FORMAT 'parquet'); +-- +ok +== +SELECT * FROM '{TEST_DIR}/unsigned.parquet' EXCEPT SELECT * FROM unsigned +-- +ok +== +SELECT * FROM unsigned EXCEPT SELECT * FROM '{TEST_DIR}/unsigned.parquet' +-- +ok +== +SELECT * FROM '{TEST_DIR}/unsigned.parquet' WHERE d=42 +-- +ok +== +SELECT COUNT(*) FROM '{TEST_DIR}/unsigned.parquet' WHERE d>42 +-- +ok +== +SELECT COUNT(*) FROM '{TEST_DIR}/unsigned.parquet' WHERE d>=42 +-- +ok +== +SELECT COUNT(*) FROM '{TEST_DIR}/unsigned.parquet' WHERE d<42 +-- +ok +== +SELECT COUNT(*) FROM '{TEST_DIR}/unsigned.parquet' WHERE d<=42 +-- +ok +== +SELECT typeof(d)='{type}' FROM '{TEST_DIR}/unsigned.parquet' LIMIT 1 +-- +ok +== diff --git a/parser/testdata/corpus/sql/copy/parquet/writer/parquet_write_uuid.test b/parser/testdata/corpus/sql/copy/parquet/writer/parquet_write_uuid.test new file mode 100644 index 0000000..c66f05a --- /dev/null +++ b/parser/testdata/corpus/sql/copy/parquet/writer/parquet_write_uuid.test @@ -0,0 +1,58 @@ +# source: test/sql/copy/parquet/writer/parquet_write_uuid.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +CREATE TABLE IF NOT EXISTS uuid (u uuid); +-- +ok +== +INSERT INTO uuid VALUES + ('A0EEBC99-9C0B-4EF8-BB6D-6BB9BD380A11'), + (NULL), + ('47183823-2574-4bfd-b411-99ed177d3e43'), + ('{10203040506070800102030405060708}'), + ('A0EEBC99-9C0B-4EF8-BB6D-6BB9BD380A11'), + (NULL), + ('00112233-4455-6677-8899-aabbccddeeff'), + ('47183823-2574-4bfd-b411-99ed177d3e43'), + ('{10203040506070800102030405060708}'), + ('00000000-0000-0000-0000-000000000000'), + ('00000000-0000-0000-0000-000000000001'), + ('00000000-0000-0000-8000-000000000001'), + ('80000000-0000-0000-0000-000000000000'), + ('80000000-0000-0000-8000-000000000000'), + ('80000000-0000-0000-8fff-ffffffffffff'), + ('80000000-0000-0000-ffff-ffffffffffff'), + ('8fffffff-ffff-ffff-0000-000000000000'), + ('8fffffff-ffff-ffff-8000-000000000000'), + ('8fffffff-ffff-ffff-8fff-ffffffffffff'), + ('8fffffff-ffff-ffff-ffff-ffffffffffff'), + ('ffffffff-ffff-ffff-ffff-ffffffffffff'); +-- +ok +== +COPY uuid TO '{TEST_DIR}/uuid.parquet' +-- +ok +== +SELECT * FROM '{TEST_DIR}/uuid.parquet' ORDER BY 1 +-- +ok +== +SELECT stats_min, stats_max, stats_min_value, stats_max_value FROM parquet_metadata('{TEST_DIR}/uuid.parquet') +-- +ok +== +CREATE TABLE uuid2 AS SELECT uuid '47183823-2574-4bfd-b411-99ed177d3e43' uuid_val union all select uuid '00112233-4455-6677-8899-aabbccddeeff'; +-- +ok +== +COPY uuid2 TO '{TEST_DIR}/uuid2.parquet' +-- +ok +== +SELECT stats_min, stats_max, stats_min_value, stats_max_value FROM parquet_metadata('{TEST_DIR}/uuid2.parquet') +-- +ok +== diff --git a/parser/testdata/corpus/sql/copy/parquet/writer/partition_without_hive.test b/parser/testdata/corpus/sql/copy/parquet/writer/partition_without_hive.test new file mode 100644 index 0000000..4059ace --- /dev/null +++ b/parser/testdata/corpus/sql/copy/parquet/writer/partition_without_hive.test @@ -0,0 +1,25 @@ +# source: test/sql/copy/parquet/writer/partition_without_hive.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +CREATE TABLE t1(part_key INT, val INT); +-- +ok +== +INSERT INTO t1 SELECT i%2, i FROM range(10) t(i); +-- +ok +== +COPY t1 TO '{TEST_DIR}/hive_filters' (FORMAT PARQUET, PARTITION_BY part_key, HIVE_FILE_PATTERN false, WRITE_PARTITION_COLUMNS true); +-- +ok +== +SELECT file.replace('{TEST_DIR}', '').replace('\', '/') FROM GLOB('{TEST_DIR}/hive_filters/*.parquet') ORDER BY ALL +-- +ok +== +FROM '{TEST_DIR}/hive_filters/*.parquet' EXCEPT ALL FROM t1 +-- +ok +== diff --git a/parser/testdata/corpus/sql/copy/parquet/writer/row_group_size_bytes.test b/parser/testdata/corpus/sql/copy/parquet/writer/row_group_size_bytes.test new file mode 100644 index 0000000..9fe93d4 --- /dev/null +++ b/parser/testdata/corpus/sql/copy/parquet/writer/row_group_size_bytes.test @@ -0,0 +1,73 @@ +# source: test/sql/copy/parquet/writer/row_group_size_bytes.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +copy (select 42) to '{TEST_DIR}/tbl.parquet' (ROW_GROUP_SIZE_BYTES) +-- +ok +== +copy ( + select range c0, + range c1, + range c2, + range c3, + range c4, + range c5, + range c6, + range c7, + from range(50000) +) to '{TEST_DIR}/tbl.parquet' (ROW_GROUP_SIZE_BYTES '1mb') +-- +ok +== +select max(row_group_num_rows) from parquet_metadata('{TEST_DIR}/tbl.parquet') +-- +ok +== +select min(row_group_bytes) != 0 from parquet_metadata('{TEST_DIR}/tbl.parquet') +-- +ok +== +copy ( + select range c0, + range c1, + range c2, + range c3, + range c4, + range c5, + range c6, + range c7, + from range(50000) +) to '{TEST_DIR}/tbl.parquet' (ROW_GROUP_SIZE_BYTES 500000) +-- +ok +== +copy ( + select range c0, + range c1, + range c2, + range c3, + range c4, + range c5, + range c6, + range c7, + from range(50000) +) to '{TEST_DIR}/tbl.parquet' (ROW_GROUP_SIZE 10000, ROW_GROUP_SIZE_BYTES '1GB') +-- +ok +== +copy ( + select range || repeat('0', 50) c0 + from range(50000) +) to '{TEST_DIR}/tbl.parquet' (ROW_GROUP_SIZE_BYTES 200000) +-- +ok +== +copy ( + select range || repeat('0', 50) c0 + from range(50000) +) to '{TEST_DIR}/tbl.parquet' (ROW_GROUP_SIZE_BYTES 650000) +-- +ok +== diff --git a/parser/testdata/corpus/sql/copy/parquet/writer/skip_empty_write.test b/parser/testdata/corpus/sql/copy/parquet/writer/skip_empty_write.test new file mode 100644 index 0000000..422900a --- /dev/null +++ b/parser/testdata/corpus/sql/copy/parquet/writer/skip_empty_write.test @@ -0,0 +1,61 @@ +# source: test/sql/copy/parquet/writer/skip_empty_write.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +CREATE TABLE empty_tbl(i INT, j VARCHAR); +-- +ok +== +CREATE TABLE tbl AS FROM range(10000) t(i) UNION ALL SELECT 100000 +-- +ok +== +copy (select 42 where 42=84) to '{TEST_DIR}/empty.parquet' (WRITE_EMPTY_FILE false) +-- +ok +== +SELECT COUNT(*) FROM glob('{TEST_DIR}/empty.parquet') +-- +ok +== +SET preserve_insertion_order={preserve_order} +-- +error: Parser Error: syntax error at or near "}" +== +copy (select 42 where 42=84) to '{TEST_DIR}/empty.parquet' (WRITE_EMPTY_FILE false, RETURN_STATS) +-- +ok +== +copy empty_tbl to '{TEST_DIR}/empty.parquet' (WRITE_EMPTY_FILE false, RETURN_STATS) +-- +ok +== +copy empty_tbl to '{TEST_DIR}/empty.parquet' (WRITE_EMPTY_FILE false, RETURN_FILES) +-- +ok +== +copy (from tbl where i = 20000) to '{TEST_DIR}/empty.parquet' (WRITE_EMPTY_FILE false, RETURN_STATS) +-- +ok +== +copy (select 42 where 42=84) to '{TEST_DIR}/empty_file_size_bytes/' (FORMAT PARQUET, WRITE_EMPTY_FILE false, FILENAME_PATTERN '{uuidv7}.parquet', FILE_SIZE_BYTES 128) +-- +ok +== +SELECT COUNT(*) FROM glob('{TEST_DIR}/empty_file_size_bytes/*.parquet') +-- +ok +== +copy tbl to '{TEST_DIR}/empty_row_groups_per_file.parquet' (WRITE_EMPTY_FILE false, ROW_GROUPS_PER_FILE 1) +-- +ok +== +copy empty_tbl to '{TEST_DIR}/empty.parquet' (WRITE_EMPTY_FILE false, PARTITION_BY (i)) +-- +ok +== +copy tbl to '{TEST_DIR}/empty.parquet' (WRITE_EMPTY_FILE false, PER_THREAD_OUTPUT) +-- +ok +== diff --git a/parser/testdata/corpus/sql/copy/parquet/writer/test_copy_overwrite_parquet.test b/parser/testdata/corpus/sql/copy/parquet/writer/test_copy_overwrite_parquet.test new file mode 100644 index 0000000..77249a8 --- /dev/null +++ b/parser/testdata/corpus/sql/copy/parquet/writer/test_copy_overwrite_parquet.test @@ -0,0 +1,29 @@ +# source: test/sql/copy/parquet/writer/test_copy_overwrite_parquet.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +COPY test TO '{TEST_DIR}/overwrite.parquet' (FORMAT PARQUET) +-- +ok +== +COPY (SELECT * FROM test LIMIT 2) TO '{TEST_DIR}/overwrite.parquet' (FORMAT PARQUET); +-- +ok +== +COPY test FROM '{TEST_DIR}/overwrite.parquet' (FORMAT PARQUET); +-- +ok +== +COPY (SELECT i FROM range(1) tbl(i) UNION ALL SELECT concat('hello', i)::INT i FROM range(1) tbl(i)) to '{TEST_DIR}/overwrite.parquet' (FORMAT PARQUET); +-- +ok +== +COPY (SELECT i FROM range(1) tbl(i) UNION ALL SELECT concat('hello', i)::INT i FROM range(1) tbl(i)) to '{TEST_DIR}/overwrite.parquet' (FORMAT PARQUET, USE_TMP_FILE FALSE); +-- +ok +== +SELECT * FROM '{TEST_DIR}/overwrite.parquet'; +-- +ok +== diff --git a/parser/testdata/corpus/sql/copy/parquet/writer/test_parquet_write.test b/parser/testdata/corpus/sql/copy/parquet/writer/test_parquet_write.test new file mode 100644 index 0000000..c0cc9ea --- /dev/null +++ b/parser/testdata/corpus/sql/copy/parquet/writer/test_parquet_write.test @@ -0,0 +1,33 @@ +# source: test/sql/copy/parquet/writer/test_parquet_write.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +COPY (SELECT 42) TO '{TEST_DIR}/scalar.parquet' (FORMAT 'parquet'); +-- +ok +== +SELECT * FROM parquet_scan('{TEST_DIR}/scalar.parquet'); +-- +ok +== +CREATE TABLE empty(i INTEGER) +-- +ok +== +COPY (SELECT * FROM empty) TO '{TEST_DIR}/empty.parquet' (FORMAT 'parquet') +-- +ok +== +SELECT COUNT(*) FROM parquet_scan('{TEST_DIR}/empty.parquet') +-- +ok +== +COPY (SELECT * FROM empty) TO '{TEST_DIR}/empty_multithread' (FORMAT 'parquet', PER_THREAD_OUTPUT True) +-- +ok +== +SELECT COUNT(*) FROM parquet_scan('{TEST_DIR}/empty_multithread/*.parquet') +-- +ok +== diff --git a/parser/testdata/corpus/sql/copy/parquet/writer/test_parquet_write_complex.test b/parser/testdata/corpus/sql/copy/parquet/writer/test_parquet_write_complex.test new file mode 100644 index 0000000..0b11212 --- /dev/null +++ b/parser/testdata/corpus/sql/copy/parquet/writer/test_parquet_write_complex.test @@ -0,0 +1,73 @@ +# source: test/sql/copy/parquet/writer/test_parquet_write_complex.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +SELECT * FROM parquet_scan('{DATA_DIR}/parquet-testing/arrow/alltypes_dictionary.parquet'); +-- +ok +== +COPY (SELECT * FROM parquet_scan('{DATA_DIR}/parquet-testing/arrow/alltypes_dictionary.parquet')) TO '{TEMP_DIR}/alltypes_dictionary.parquet' (FORMAT 'PARQUET') +-- +ok +== +SELECT * FROM parquet_scan('{TEMP_DIR}/alltypes_dictionary.parquet'); +-- +ok +== +SELECT * FROM parquet_scan('{DATA_DIR}/parquet-testing/bug687_nulls.parquet') LIMIT 10; +-- +ok +== +COPY (SELECT * FROM parquet_scan('{DATA_DIR}/parquet-testing/bug687_nulls.parquet')) TO '{TEMP_DIR}/bug687_nulls.parquet' (FORMAT 'PARQUET') +-- +ok +== +SELECT * FROM parquet_scan('{TEMP_DIR}/bug687_nulls.parquet') LIMIT 10; +-- +ok +== +COPY (SELECT true as x UNION ALL SELECT true) TO '{TEMP_DIR}/bug1637_booleans.parquet' (FORMAT 'PARQUET'); +-- +ok +== +SELECT COUNT(*) FROM parquet_scan('{TEMP_DIR}/bug1637_booleans.parquet') WHERE x; +-- +ok +== +SELECT * FROM parquet_scan('{DATA_DIR}/parquet-testing/userdata1.parquet') ORDER BY 1 LIMIT 10; +-- +ok +== +COPY (SELECT * FROM parquet_scan('{DATA_DIR}/parquet-testing/userdata1.parquet')) TO '{TEMP_DIR}/userdata1.parquet' (FORMAT 'PARQUET') +-- +ok +== +SELECT * FROM parquet_scan('{TEMP_DIR}/userdata1.parquet') ORDER BY 1 LIMIT 10; +-- +ok +== +COPY (SELECT * FROM parquet_scan('{DATA_DIR}/parquet-testing/userdata1.parquet')) TO '{TEMP_DIR}/userdata1-gzip.parquet' (FORMAT 'PARQUET', CODEC 'GZIP') +-- +ok +== +SELECT * FROM parquet_scan('{TEMP_DIR}/userdata1-gzip.parquet') ORDER BY 1 LIMIT 10; +-- +ok +== +COPY (SELECT * FROM parquet_scan('{DATA_DIR}/parquet-testing/userdata1.parquet')) TO '{TEMP_DIR}/userdata1-uncompressed.parquet' (FORMAT 'PARQUET', CODEC 'UNCOMPRESSED') +-- +ok +== +SELECT * FROM parquet_scan('{TEMP_DIR}/userdata1-uncompressed.parquet') ORDER BY 1 LIMIT 10; +-- +ok +== +COPY (SELECT * FROM parquet_scan('{DATA_DIR}/parquet-testing/userdata1.parquet')) TO '{TEMP_DIR}/userdata1-zstd.parquet' (FORMAT 'PARQUET', CODEC 'ZSTD') +-- +ok +== +SELECT * FROM parquet_scan('{TEMP_DIR}/userdata1-zstd.parquet') ORDER BY 1 LIMIT 10; +-- +ok +== diff --git a/parser/testdata/corpus/sql/copy/parquet/writer/write_complex_nested.test b/parser/testdata/corpus/sql/copy/parquet/writer/write_complex_nested.test new file mode 100644 index 0000000..c9118a8 --- /dev/null +++ b/parser/testdata/corpus/sql/copy/parquet/writer/write_complex_nested.test @@ -0,0 +1,94 @@ +# source: test/sql/copy/parquet/writer/write_complex_nested.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +CREATE TABLE struct_of_lists AS SELECT * FROM (VALUES + ({'a': [1, 2, 3], 'b': ['hello', 'world']}), + ({'a': [4, NULL, 5], 'b': ['duckduck', 'goose']}), + ({'a': NULL, 'b': ['longlonglonglonglonglong', NULL, NULL]}), + (NULL), + ({'a': [], 'b': []}), + ({'a': [1, 2, 3], 'b': NULL}) +) tbl(i); +-- +ok +== +COPY struct_of_lists TO '{TEST_DIR}/complex_list.parquet' (FORMAT 'parquet'); +-- +ok +== +SELECT i FROM parquet_scan('{TEST_DIR}/complex_list.parquet'); +-- +ok +== +CREATE TABLE list_of_structs AS SELECT * FROM (VALUES + ([{'a': 1, 'b': 100}, NULL, {'a': 2, 'b': 101}]), + (NULL), + ([]), + ([{'a': NULL, 'b': 102}, {'a': 3, 'b': NULL}, NULL]) +) tbl(i); +-- +ok +== +COPY list_of_structs TO '{TEST_DIR}/complex_list.parquet' (FORMAT 'parquet'); +-- +ok +== +CREATE TABLE list_of_struct_of_structs AS SELECT * FROM (VALUES + ([{'a': {'x': 33}, 'b': {'y': 42, 'z': 99}}, NULL, {'a': {'x': NULL}, 'b': {'y': 43, 'z': 100}}]), + (NULL), + ([]), + ([{'a': NULL, 'b': {'y': NULL, 'z': 101}}, {'a': {'x': 34}, 'b': {'y': 43, 'z': NULL}}]), + ([{'a': NULL, 'b': NULL}]) +) tbl(i); +-- +ok +== +COPY list_of_struct_of_structs TO '{TEST_DIR}/complex_list.parquet' (FORMAT 'parquet'); +-- +ok +== +CREATE TABLE list_of_lists_simple AS SELECT * FROM (VALUES + ([[1, 2, 3], [4, 5]]), + ([[6, 7]]), + ([[8, 9, 10], [11, 12]]) +) tbl(i); +-- +ok +== +COPY list_of_lists_simple TO '{TEST_DIR}/complex_list.parquet' (FORMAT 'parquet'); +-- +ok +== +CREATE TABLE list_of_lists AS SELECT * FROM (VALUES + ([[1, 2, 3], [4, 5], [], [6, 7]]), + ([[8, NULL, 10], NULL, []]), + ([]), + (NULL), + ([[11, 12, 13, 14], [], NULL, [], [], [15], [NULL, NULL, NULL]]) +) tbl(i); +-- +ok +== +COPY list_of_lists TO '{TEST_DIR}/complex_list.parquet' (FORMAT 'parquet'); +-- +ok +== +CREATE TABLE list_of_lists_of_lists_of_lists AS + SELECT [LIST(i)] i FROM list_of_lists + UNION ALL + SELECT NULL + UNION ALL + SELECT [NULL] + UNION ALL + SELECT [[], NULL, [], []] + UNION ALL + SELECT [[[NULL, NULL, [NULL]], NULL, [[], [7, 8, 9], [NULL], NULL, []]], [], [NULL]] +-- +ok +== +COPY list_of_lists_of_lists_of_lists TO '{TEST_DIR}/complex_list.parquet' (FORMAT 'parquet'); +-- +ok +== diff --git a/parser/testdata/corpus/sql/copy/parquet/writer/write_list.test b/parser/testdata/corpus/sql/copy/parquet/writer/write_list.test new file mode 100644 index 0000000..e14f2fa --- /dev/null +++ b/parser/testdata/corpus/sql/copy/parquet/writer/write_list.test @@ -0,0 +1,61 @@ +# source: test/sql/copy/parquet/writer/write_list.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +CREATE TABLE list AS SELECT * FROM (VALUES + ([1, 2, 3]), + ([4, 5]), + ([6, 7]), + ([8, 9, 10, 11]) +) tbl(i); +-- +ok +== +COPY list TO '{TEST_DIR}/test_list.parquet' (FORMAT 'parquet'); +-- +ok +== +SELECT i FROM parquet_scan('{TEST_DIR}/test_list.parquet'); +-- +ok +== +CREATE TABLE null_empty_list AS SELECT * FROM (VALUES + ([1, 2, 3]), + ([4, 5]), + ([6, 7]), + ([NULL]), + ([]), + ([]), + ([]), + ([]), + ([8, NULL, 10, 11]), + (NULL) +) tbl(i); +-- +ok +== +COPY null_empty_list TO '{TEST_DIR}/test_list.parquet' (FORMAT 'parquet'); +-- +ok +== +SELECT * FROM parquet_scan('{TEST_DIR}/test_list.parquet'); +-- +ok +== +COPY (SELECT []::INT[]) TO '{TEST_DIR}/test_empty_list.parquet' (FORMAT 'parquet'); +-- +ok +== +SELECT * FROM '{TEST_DIR}/test_empty_list.parquet' +-- +ok +== +COPY (SELECT NULL::INT[]) TO '{TEST_DIR}/test_null_list.parquet' (FORMAT 'parquet'); +-- +ok +== +SELECT * FROM '{TEST_DIR}/test_null_list.parquet' +-- +ok +== diff --git a/parser/testdata/corpus/sql/copy/parquet/writer/write_map.test b/parser/testdata/corpus/sql/copy/parquet/writer/write_map.test new file mode 100644 index 0000000..6ab7989 --- /dev/null +++ b/parser/testdata/corpus/sql/copy/parquet/writer/write_map.test @@ -0,0 +1,90 @@ +# source: test/sql/copy/parquet/writer/write_map.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +CREATE TABLE int_maps(m MAP(INTEGER,INTEGER)); +-- +ok +== +INSERT INTO int_maps VALUES + (MAP([42, 84], [1, 2])), + (MAP([101, 201, 301], [3, NULL, 5])), + (MAP([55, 66, 77], [6, 7, NULL])) +; +-- +ok +== +COPY int_maps TO '{TEST_DIR}/int_map.parquet' (FORMAT PARQUET) +-- +ok +== +SELECT * FROM '{TEST_DIR}/int_map.parquet' +-- +ok +== +INSERT INTO int_maps VALUES + (MAP([NULL], [NULL])) +; +-- +ok +== +COPY string_map TO '{TEST_DIR}/int_maps.parquet' (FORMAT PARQUET) +-- +ok +== +CREATE TABLE string_map(m MAP(VARCHAR,VARCHAR)); +-- +ok +== +INSERT INTO string_map VALUES + (MAP(['key1', 'key2'], ['value1', 'value2'])), + (MAP(['best band', 'best boyband', 'richest person'], ['Tenacious D', 'Backstreet Boys', 'Jon Lajoie'])), + (MAP([], [])), + (NULL), + (MAP(['option'], [NULL])) +; +-- +ok +== +COPY string_map TO '{TEST_DIR}/string_map.parquet' (FORMAT PARQUET) +-- +ok +== +SELECT * FROM '{TEST_DIR}/string_map.parquet' +-- +ok +== +INSERT INTO string_map VALUES + (MAP([NULL], [NULL])) +; +-- +ok +== +CREATE TABLE list_map(m MAP(INT[],INT[])); +-- +ok +== +INSERT INTO list_map VALUES + (MAP([[1, 2, 3], [], [4, 5]], [[6, 7, 8], NULL, [NULL]])), + (MAP([], [])), + (MAP([[1]], [NULL])), + (MAP([[10, 12, 14, 16, 18, 20], []], [[1], [2]])) +; +-- +ok +== +COPY list_map TO '{TEST_DIR}/list_map.parquet' (FORMAT PARQUET) +-- +ok +== +SELECT * FROM '{TEST_DIR}/list_map.parquet' +-- +ok +== +INSERT INTO list_map VALUES + (MAP([NULL], [NULL])) +; +-- +ok +== diff --git a/parser/testdata/corpus/sql/copy/parquet/writer/write_stats_big_string.test b/parser/testdata/corpus/sql/copy/parquet/writer/write_stats_big_string.test new file mode 100644 index 0000000..b7d170b --- /dev/null +++ b/parser/testdata/corpus/sql/copy/parquet/writer/write_stats_big_string.test @@ -0,0 +1,25 @@ +# source: test/sql/copy/parquet/writer/write_stats_big_string.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +CREATE TABLE varchar(v VARCHAR); +-- +ok +== +INSERT INTO varchar VALUES (NULL), ('hello'), (NULL), ('world'), (NULL) +-- +ok +== +COPY varchar TO '{TEST_DIR}/bigvarchar.parquet' +-- +ok +== +SELECT stats_min_value, stats_max_value, stats_min, stats_max, min_is_exact, max_is_exact FROM parquet_metadata('{TEST_DIR}/bigvarchar.parquet') +-- +ok +== +INSERT INTO varchar SELECT repeat('A', 100000) v +-- +ok +== diff --git a/parser/testdata/corpus/sql/copy/parquet/writer/write_stats_null_count.test b/parser/testdata/corpus/sql/copy/parquet/writer/write_stats_null_count.test new file mode 100644 index 0000000..5e14bd9 --- /dev/null +++ b/parser/testdata/corpus/sql/copy/parquet/writer/write_stats_null_count.test @@ -0,0 +1,45 @@ +# source: test/sql/copy/parquet/writer/write_stats_null_count.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +COPY (SELECT 42 i) TO '{TEST_DIR}/stats.parquet' (FORMAT PARQUET); +-- +ok +== +SELECT stats_null_count FROM parquet_metadata('{TEST_DIR}/stats.parquet') +-- +ok +== +EXPLAIN SELECT COUNT(*) FROM '{TEST_DIR}/stats.parquet' WHERE i IS NULL +-- +ok +== +SELECT COUNT(*) FROM '{TEST_DIR}/stats.parquet' WHERE i IS NULL +-- +ok +== +COPY (SELECT NULL i) TO '{TEST_DIR}/stats.parquet' (FORMAT PARQUET); +-- +ok +== +COPY (SELECT * FROM VALUES (42), (NULL) tbl(i)) TO '{TEST_DIR}/stats.parquet' (FORMAT PARQUET); +-- +ok +== +COPY (SELECT [42, NULL, 43] i) TO '{TEST_DIR}/stats.parquet' (FORMAT PARQUET); +-- +ok +== +COPY (SELECT {'a': NULL, 'b': 42} i) TO '{TEST_DIR}/stats.parquet' (FORMAT PARQUET); +-- +ok +== +CREATE TABLE structs AS SELECT {'a': NULL, 'b': 'hello'} i UNION ALL SELECT NULL UNION ALL SELECT {'a': 84, 'b': 'world'}; +-- +ok +== +COPY structs TO '{TEST_DIR}/stats.parquet' (FORMAT PARQUET); +-- +ok +== diff --git a/parser/testdata/corpus/sql/copy/parquet/writer/write_struct.test b/parser/testdata/corpus/sql/copy/parquet/writer/write_struct.test new file mode 100644 index 0000000..97756ab --- /dev/null +++ b/parser/testdata/corpus/sql/copy/parquet/writer/write_struct.test @@ -0,0 +1,121 @@ +# source: test/sql/copy/parquet/writer/write_struct.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +CREATE TABLE struct AS SELECT * FROM (VALUES + ({'a': 42, 'b': 84}), + ({'a': 33, 'b': 32}), + ({'a': 42, 'b': 27}) +) tbl(i); +-- +ok +== +COPY struct TO '{TEST_DIR}/test_struct.parquet' (FORMAT 'parquet'); +-- +ok +== +SELECT * FROM parquet_scan('{TEST_DIR}/test_struct.parquet'); +-- +ok +== +CREATE TABLE struct_nulls AS SELECT * FROM (VALUES + ({'a': 42, 'b': 84}), + ({'a': NULL, 'b': 32}), + (NULL), + ({'a': 42, 'b': NULL}) +) tbl(i); +-- +ok +== +COPY struct_nulls TO '{TEST_DIR}/test_struct_nulls.parquet' (FORMAT 'parquet'); +-- +ok +== +SELECT * FROM parquet_scan('{TEST_DIR}/test_struct_nulls.parquet'); +-- +ok +== +CREATE TABLE struct_nested AS SELECT * FROM (VALUES + ({'a': {'x': 3, 'x1': 22}, 'b': {'y': 27, 'y1': 44}}), + ({'a': {'x': 9, 'x1': 26}, 'b': {'y': 1, 'y1': 999}}), + ({'a': {'x': 17, 'x1': 23}, 'b': {'y': 3, 'y1': 9999}}) +) tbl(i); +-- +ok +== +COPY struct_nested TO '{TEST_DIR}/struct_nested.parquet' (FORMAT 'parquet'); +-- +ok +== +SELECT * FROM parquet_scan('{TEST_DIR}/struct_nested.parquet'); +-- +ok +== +CREATE TABLE struct_nested_null AS SELECT * FROM (VALUES + ({'a': {'x': 3, 'x1': 22}, 'b': {'y': NULL, 'y1': 44}}), + ({'a': {'x': NULL, 'x1': 26}, 'b': {'y': 1, 'y1': NULL}}), + ({'a': {'x': 17, 'x1': NULL}, 'b': {'y': 3, 'y1': 9999}}), + (NULL), + ({'a': NULL, 'b': NULL}) +) tbl(i); +-- +ok +== +COPY struct_nested_null TO '{TEST_DIR}/struct_nested_null.parquet' (FORMAT 'parquet'); +-- +ok +== +SELECT * FROM parquet_scan('{TEST_DIR}/struct_nested_null.parquet'); +-- +ok +== +CREATE TABLE single_struct AS SELECT * FROM (VALUES + ({'a': 42}), + ({'a': 33}), + ({'a': 42}) +) tbl(i); +-- +ok +== +COPY single_struct TO '{TEST_DIR}/single_struct.parquet' (FORMAT 'parquet'); +-- +ok +== +SELECT * FROM parquet_scan('{TEST_DIR}/single_struct.parquet'); +-- +ok +== +CREATE TABLE single_struct_null AS SELECT * FROM (VALUES + ({'a': 42}), + ({'a': NULL}), + (NULL) +) tbl(i); +-- +ok +== +COPY single_struct_null TO '{TEST_DIR}/single_struct_null.parquet' (FORMAT 'parquet'); +-- +ok +== +SELECT * FROM parquet_scan('{TEST_DIR}/single_struct_null.parquet'); +-- +ok +== +CREATE TABLE nested_single_struct AS SELECT * FROM (VALUES + ({'a': {'b': 42}}), + ({'a': {'b': NULL}}), + ({'a': NULL}), + (NULL) +) tbl(i); +-- +ok +== +COPY nested_single_struct TO '{TEST_DIR}/nested_single_struct.parquet' (FORMAT 'parquet'); +-- +ok +== +SELECT * FROM parquet_scan('{TEST_DIR}/nested_single_struct.parquet'); +-- +ok +== diff --git a/parser/testdata/corpus/sql/copy/partitioned/hive_filter_pushdown.test b/parser/testdata/corpus/sql/copy/partitioned/hive_filter_pushdown.test new file mode 100644 index 0000000..e5a33c6 --- /dev/null +++ b/parser/testdata/corpus/sql/copy/partitioned/hive_filter_pushdown.test @@ -0,0 +1,41 @@ +# source: test/sql/copy/partitioned/hive_filter_pushdown.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +COPY (SELECT i::VARCHAR as a, (i*10)::VARCHAR as b, (i*100)::VARCHAR as c from range(0,10) tbl(i)) TO '{TEST_DIR}/hive_pushdown_bug' (FORMAT PARQUET, PARTITION_BY c); +-- +ok +== +explain SELECT * FROM parquet_scan('{TEST_DIR}/hive_pushdown_bug/*/*.parquet', HIVE_PARTITIONING=1) where a > b; +-- +ok +== +explain SELECT * FROM parquet_scan('{TEST_DIR}/hive_pushdown_bug/*/*.parquet') where a > b; +-- +ok +== +explain SELECT * FROM parquet_scan('{TEST_DIR}/hive_pushdown_bug/*/*.parquet', HIVE_PARTITIONING=1) where a::VARCHAR > c::VARCHAR; +-- +ok +== +explain SELECT * FROM parquet_scan('{TEST_DIR}/hive_pushdown_bug/*/*.parquet') where a::VARCHAR > c::VARCHAR; +-- +ok +== +explain SELECT * FROM parquet_scan('{TEST_DIR}/hive_pushdown_bug/*/*.parquet', HIVE_PARTITIONING=1, HIVE_TYPES_AUTOCAST=1) where c=500; +-- +ok +== +explain SELECT * FROM parquet_scan('{TEST_DIR}/hive_pushdown_bug/*/*.parquet', HIVE_PARTITIONING=1, HIVE_TYPES_AUTOCAST=1) where c=500 and b='20'; +-- +ok +== +COPY (SELECT i::VARCHAR as a, (i*10)::VARCHAR as b, (i*100)::VARCHAR as c from range(0,10) tbl(i)) TO '{TEST_DIR}/hive_pushdown_bug_csv' (FORMAT CSV, PARTITION_BY c); +-- +ok +== +explain SELECT * FROM read_csv_auto('{TEST_DIR}/hive_pushdown_bug_csv/*/*.csv', HIVE_PARTITIONING=1, HIVE_TYPES_AUTOCAST=1, names=['a','b','c']) where c=500; +-- +ok +== diff --git a/parser/testdata/corpus/sql/copy/partitioned/hive_partition_append.test b/parser/testdata/corpus/sql/copy/partitioned/hive_partition_append.test new file mode 100644 index 0000000..98427d1 --- /dev/null +++ b/parser/testdata/corpus/sql/copy/partitioned/hive_partition_append.test @@ -0,0 +1,52 @@ +# source: test/sql/copy/partitioned/hive_partition_append.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +CREATE TABLE sensor_data(ts TIMESTAMP, value INT); +-- +ok +== +INSERT INTO sensor_data VALUES + (TIMESTAMP '2000-01-01 01:02:03', 42), + (TIMESTAMP '2000-02-01 01:02:03', 100), + (TIMESTAMP '2000-03-01 12:11:10', 1000) +; +-- +ok +== +COPY (SELECT YEAR(ts) AS year, MONTH(ts) AS month, * FROM sensor_data) +TO '{TEST_DIR}/partitioned_append' (FORMAT PARQUET, PARTITION_BY (year, month), APPEND); +-- +ok +== +SELECT year, month, SUM(value) FROM '{TEST_DIR}/partitioned_append/**/*.parquet' GROUP BY ALL ORDER BY ALL +-- +ok +== +DELETE FROM sensor_data; +-- +ok +== +INSERT INTO sensor_data VALUES + (TIMESTAMP '2000-01-01 02:02:03', 62), + (TIMESTAMP '2000-03-01 13:11:10', 50) +; +-- +ok +== +COPY (SELECT YEAR(ts) AS year, MONTH(ts) AS month, * FROM sensor_data) +TO '{TEST_DIR}/partitioned_append' (FORMAT PARQUET, PARTITION_BY (year, month), APPEND, FILENAME_PATTERN 'my_pattern_{uuid}'); +-- +ok +== +COPY (SELECT YEAR(ts) AS year, MONTH(ts) AS month, * FROM sensor_data) +TO '{TEST_DIR}/partitioned_append' (FORMAT PARQUET, PARTITION_BY (year, month), FILENAME_PATTERN 'my_pattern_{uuid}', APPEND); +-- +ok +== +COPY (SELECT YEAR(ts) AS year, MONTH(ts) AS month, * FROM sensor_data) +TO '{TEST_DIR}/partitioned_append' (FORMAT PARQUET, PARTITION_BY (year, month), APPEND, FILENAME_PATTERN 'my_pattern_without_uuid'); +-- +ok +== diff --git a/parser/testdata/corpus/sql/copy/partitioned/hive_partition_case_insensitive_column.test b/parser/testdata/corpus/sql/copy/partitioned/hive_partition_case_insensitive_column.test new file mode 100644 index 0000000..aa651ae --- /dev/null +++ b/parser/testdata/corpus/sql/copy/partitioned/hive_partition_case_insensitive_column.test @@ -0,0 +1,9 @@ +# source: test/sql/copy/partitioned/hive_partition_case_insensitive_column.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +SELECT * FROM '{DATA_DIR}/parquet-testing/hive-partitioning/ci-column-names/**/*.parquet' ORDER BY ALL +-- +ok +== diff --git a/parser/testdata/corpus/sql/copy/partitioned/hive_partition_compression.test b/parser/testdata/corpus/sql/copy/partitioned/hive_partition_compression.test new file mode 100644 index 0000000..d331763 --- /dev/null +++ b/parser/testdata/corpus/sql/copy/partitioned/hive_partition_compression.test @@ -0,0 +1,14 @@ +# source: test/sql/copy/partitioned/hive_partition_compression.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +COPY (FROM test) TO '{TEST_DIR}/hive_partition_compress' (FORMAT parquet, COMPRESSION 'gzip', PARTITION_BY ('col0', 'col1')); +-- +ok +== +FROM read_parquet('{TEST_DIR}/hive_partition_compress/*/*/*.parquet') +ORDER BY ALL +-- +ok +== diff --git a/parser/testdata/corpus/sql/copy/partitioned/hive_partition_duplicate_name.test b/parser/testdata/corpus/sql/copy/partitioned/hive_partition_duplicate_name.test new file mode 100644 index 0000000..5a9e68c --- /dev/null +++ b/parser/testdata/corpus/sql/copy/partitioned/hive_partition_duplicate_name.test @@ -0,0 +1,11 @@ +# source: test/sql/copy/partitioned/hive_partition_duplicate_name.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +select * +from parquet_scan('{DATA_DIR}/parquet-testing/hive-partitioning/duplicate_names/**/*.parquet') +ORDER BY ALL +-- +ok +== diff --git a/parser/testdata/corpus/sql/copy/partitioned/hive_partition_escape.test b/parser/testdata/corpus/sql/copy/partitioned/hive_partition_escape.test new file mode 100644 index 0000000..81a0406 --- /dev/null +++ b/parser/testdata/corpus/sql/copy/partitioned/hive_partition_escape.test @@ -0,0 +1,51 @@ +# source: test/sql/copy/partitioned/hive_partition_escape.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +CREATE TABLE weird_tbl(id INT DEFAULT nextval('seq'), key VARCHAR) +-- +ok +== +INSERT INTO weird_tbl (key) VALUES + ('/'), + ('\/\/'), + ('==='), + ('value with strings'), + ('?:&'), + ('🦆'), + ('==='), + ('==='); +-- +ok +== +COPY weird_tbl TO '{TEST_DIR}/escaped_partitions' (FORMAT PARQUET, PARTITION_BY(key)) +-- +ok +== +select key, COUNT(*) +from parquet_scan('{TEST_DIR}/escaped_partitions/**/*.parquet') +GROUP BY ALL +ORDER BY ALL +-- +ok +== +ALTER TABLE weird_tbl RENAME COLUMN key TO "=/ \\/" +-- +ok +== +COPY weird_tbl TO '{TEST_DIR}/escaped_partitions_names' (FORMAT PARQUET, PARTITION_BY("=/ \\/")) +-- +ok +== +select "=/ \\/", COUNT(*) +from parquet_scan('{TEST_DIR}/escaped_partitions_names/**/*.parquet') +GROUP BY ALL +ORDER BY ALL +-- +ok +== +COPY weird_tbl TO '{TEST_DIR}/escaped_partitions_names' (FORMAT PARQUET, PARTITION_BY("=/ \\/"), OVERWRITE, WRITE_PARTITION_COLUMNS) +-- +ok +== diff --git a/parser/testdata/corpus/sql/copy/partitioned/hive_partition_join_pushdown.test b/parser/testdata/corpus/sql/copy/partitioned/hive_partition_join_pushdown.test new file mode 100644 index 0000000..68b076e --- /dev/null +++ b/parser/testdata/corpus/sql/copy/partitioned/hive_partition_join_pushdown.test @@ -0,0 +1,68 @@ +# source: test/sql/copy/partitioned/hive_partition_join_pushdown.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +CREATE TABLE tbl AS SELECT i//1000 AS partition, i FROM range(10000) t(i) +-- +ok +== +COPY tbl TO '{TEST_DIR}/partition_join_pushdown' (FORMAT parquet, PARTITION_BY (partition)) +-- +ok +== +EXPLAIN ANALYZE SELECT COUNT(*), MIN(partition), MAX(partition), SUM(i) +FROM '{TEST_DIR}/partition_join_pushdown/**/*.parquet' +-- +ok +== +SELECT COUNT(*), MIN(partition), MAX(partition), SUM(i) +FROM '{TEST_DIR}/partition_join_pushdown/**/*.parquet' +WHERE partition=(SELECT MAX(partition) FROM tbl) +-- +ok +== +EXPLAIN ANALYZE SELECT COUNT(*), MIN(partition), MAX(partition), SUM(i) +FROM '{TEST_DIR}/partition_join_pushdown/**/*.parquet' +WHERE partition=(SELECT MAX(partition) FROM tbl) +-- +ok +== +SELECT COUNT(*), MIN(partition), MAX(partition), SUM(i) +FROM '{TEST_DIR}/partition_join_pushdown/**/*.parquet' +WHERE i>=9980 AND partition=(SELECT MAX(partition) FROM tbl) +-- +ok +== +SELECT COUNT(*), MIN(partition), MAX(partition), SUM(i) +FROM '{TEST_DIR}/partition_join_pushdown/**/*.parquet' +WHERE partition>5 AND partition=(SELECT MAX(partition) FROM tbl) +-- +ok +== +CREATE TABLE tbl2 AS SELECT (date '2000-01-01' + interval (i//2000) years)::DATE AS part1, i%2 AS part2, i FROM range(10000) t(i) +-- +ok +== +COPY tbl2 TO '{TEST_DIR}/partition_join_pushdown_multi' (FORMAT parquet, PARTITION_BY (part1, part2)) +-- +ok +== +SELECT COUNT(*), MIN(part1), MAX(part1), MIN(part2), MAX(part2), SUM(i) +FROM '{TEST_DIR}/partition_join_pushdown_multi/**/*.parquet' +WHERE part1=(SELECT MAX(part1) FROM tbl2) AND part2=(SELECT MAX(part2) FROM tbl2) +-- +ok +== +SELECT COUNT(*), MIN(part2), MAX(part2), MIN(part1), MAX(part1), SUM(i) +FROM '{TEST_DIR}/partition_join_pushdown_multi/**/*.parquet' +WHERE part2=(SELECT MAX(part2) FROM tbl2) AND part1=date '2004-01-01' +-- +ok +== +SELECT COUNT(*) +FROM '{TEST_DIR}/partition_join_pushdown_multi/**/*.parquet' +WHERE part2=(SELECT MAX(part2) FROM tbl2) +-- +ok +== diff --git a/parser/testdata/corpus/sql/copy/partitioned/hive_partition_recursive_cte.test b/parser/testdata/corpus/sql/copy/partitioned/hive_partition_recursive_cte.test new file mode 100644 index 0000000..5d1b5df --- /dev/null +++ b/parser/testdata/corpus/sql/copy/partitioned/hive_partition_recursive_cte.test @@ -0,0 +1,35 @@ +# source: test/sql/copy/partitioned/hive_partition_recursive_cte.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +CREATE TABLE t AS SELECT 2000+i%10 AS year, 1+i%3 AS month, i%4 AS c, i%5 AS d FROM RANGE(0,20) tbl(i); +-- +ok +== +COPY t TO '{TEST_DIR}/partition_rec_cte' (FORMAT PARQUET, PARTITION_BY (year, month)); +-- +ok +== +CREATE VIEW partitioned_tbl AS FROM '{TEST_DIR}/partition_rec_cte/**/*.parquet'; +-- +ok +== +WITH RECURSIVE cte AS ( + SELECT 0 AS count, 1999 AS selected_year + UNION ALL + SELECT COUNT(*) AS count, MAX(partitioned_tbl.year) + FROM partitioned_tbl, (SELECT MAX(selected_year) AS next_year FROM cte) + WHERE partitioned_tbl.year = (SELECT MAX(selected_year) + 1 FROM cte) + HAVING COUNT(*)>0 +) +SELECT SUM(count), MIN(selected_year), MAX(selected_year) +FROM cte +WHERE count>0 +-- +ok +== +CREATE OR REPLACE VIEW partitioned_tbl AS FROM read_parquet('{TEST_DIR}/partition_rec_cte/**/*.parquet', union_by_name=True); +-- +ok +== diff --git a/parser/testdata/corpus/sql/copy/partitioned/hive_partitioned_delayed_flush.test b/parser/testdata/corpus/sql/copy/partitioned/hive_partitioned_delayed_flush.test new file mode 100644 index 0000000..cc66edb --- /dev/null +++ b/parser/testdata/corpus/sql/copy/partitioned/hive_partitioned_delayed_flush.test @@ -0,0 +1,125 @@ +# source: test/sql/copy/partitioned/hive_partitioned_delayed_flush.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +SET partitioned_write_flush_threshold=64; +-- +ok +== +CREATE TABLE delayed_skew AS +SELECT + CASE WHEN i % 17 = 0 THEN ((i / 17) % 64) + 1 ELSE 0 END::INTEGER AS p, + i::INTEGER AS v +FROM range(0, 20000) tbl(i); +-- +ok +== +COPY delayed_skew +TO '{TEST_DIR}/delayed_skew' +(FORMAT PARQUET, PARTITION_BY (p), ROW_GROUP_SIZE 64); +-- +ok +== +SELECT count(*) +FROM read_parquet('{TEST_DIR}/delayed_skew/**/*.parquet', hive_partitioning = true); +-- +ok +== +WITH files AS ( + SELECT p, count(DISTINCT filename) AS file_count + FROM read_parquet( + '{TEST_DIR}/delayed_skew/**/*.parquet', + filename = true, + hive_partitioning = true + ) + GROUP BY p +) +SELECT max(file_count) +FROM files +WHERE p <> 0; +-- +ok +== +SET partitioned_write_flush_threshold=32; +-- +ok +== +CREATE TABLE delayed_ordered AS +SELECT + CASE WHEN i % 9 = 0 THEN ((i / 9) % 4) + 1 ELSE 0 END::INTEGER AS p, + (100000 - i)::INTEGER AS v +FROM range(0, 8192) tbl(i); +-- +ok +== +COPY (SELECT p, v FROM delayed_ordered ORDER BY v DESC) +TO '{TEST_DIR}/delayed_ordered' +(FORMAT PARQUET, PARTITION_BY (p), ORDER_BY (v ASC), ROW_GROUP_SIZE 32); +-- +ok +== +SELECT count(*) +FROM read_parquet('{TEST_DIR}/delayed_ordered/**/*.parquet', hive_partitioning = true); +-- +ok +== +WITH per_file AS ( + SELECT + filename, + v, + lag(v) OVER (PARTITION BY filename ORDER BY file_row_number) AS prev_v + FROM read_parquet( + '{TEST_DIR}/delayed_ordered/**/*.parquet', + filename = true, + file_row_number = true, + hive_partitioning = true + ) +) +SELECT count(*) +FROM per_file +WHERE prev_v IS NOT NULL AND prev_v > v; +-- +ok +== +SET partitioned_write_flush_threshold=128; +-- +ok +== +SET partitioned_write_max_open_files=1; +-- +ok +== +CREATE TABLE delayed_open_file_pressure AS +SELECT + (i % 96)::INTEGER AS p, + i::INTEGER AS v +FROM range(0, 6144) tbl(i); +-- +ok +== +COPY delayed_open_file_pressure +TO '{TEST_DIR}/delayed_open_file_pressure' +(FORMAT PARQUET, PARTITION_BY (p), ROW_GROUP_SIZE 64); +-- +ok +== +SELECT count(*), count(DISTINCT p) +FROM read_parquet('{TEST_DIR}/delayed_open_file_pressure/**/*.parquet', hive_partitioning = true); +-- +ok +== +WITH files AS ( + SELECT p, count(DISTINCT filename) AS file_count + FROM read_parquet( + '{TEST_DIR}/delayed_open_file_pressure/**/*.parquet', + filename = true, + hive_partitioning = true + ) + GROUP BY p +) +SELECT max(file_count) +FROM files; +-- +ok +== diff --git a/parser/testdata/corpus/sql/copy/partitioned/hive_partitioned_write.test b/parser/testdata/corpus/sql/copy/partitioned/hive_partitioned_write.test new file mode 100644 index 0000000..e610a5a --- /dev/null +++ b/parser/testdata/corpus/sql/copy/partitioned/hive_partitioned_write.test @@ -0,0 +1,110 @@ +# source: test/sql/copy/partitioned/hive_partitioned_write.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +CREATE TABLE test as SELECT i%2 as part_col, (i+1)%5 as value_col, i as value2_col from range(0,10) tbl(i); +-- +ok +== +COPY test TO '{TEST_DIR}/partitioned1' (FORMAT PARQUET, PARTITION_BY (part_col)); +-- +ok +== +SELECT part_col, value_col, value2_col FROM '{TEST_DIR}/partitioned1/part_col=0/*.parquet' ORDER BY value2_col; +-- +ok +== +SELECT part_col, value_col, value2_col FROM '{TEST_DIR}/partitioned1/part_col=1/*.parquet' ORDER BY value2_col; +-- +ok +== +COPY (SELECT * EXCLUDE (part_col), 'prefix-'::VARCHAR || part_col::VARCHAR as part_col FROM test) TO '{TEST_DIR}/partitioned2' (FORMAT PARQUET, PARTITION_BY (part_col)); +-- +ok +== +SELECT part_col, value_col, value2_col FROM '{TEST_DIR}/partitioned2/part_col=prefix-0/*.parquet' ORDER BY value2_col; +-- +ok +== +SELECT part_col, value_col, value2_col FROM '{TEST_DIR}/partitioned2/part_col=prefix-1/*.parquet' ORDER BY value2_col; +-- +ok +== +COPY test TO '{TEST_DIR}/partitioned3' (FORMAT PARQUET, PARTITION_BY '*', WRITE_PARTITION_COLUMNS); +-- +ok +== +SELECT min(value2_col) as min_val +FROM parquet_scan('{TEST_DIR}/partitioned3/part_col=*/value_col=*/value2_col=*/*.parquet', FILENAME=1) +GROUP BY filename +ORDER BY min_val +-- +ok +== +COPY test TO '{TEST_DIR}/partitioned4' (FORMAT PARQUET, PARTITION_BY part_col); +-- +ok +== +SELECT part_col, value_col, value2_col FROM parquet_scan('{TEST_DIR}/partitioned4/part_col=*/*.parquet', HIVE_PARTITIONING=1) WHERE part_col=0 ORDER BY value2_col; +-- +ok +== +COPY test TO '{TEST_DIR}/partitioned5/' (FORMAT PARQUET, PARTITION_BY part_col); +-- +ok +== +SELECT part_col, value_col, value2_col FROM '{TEST_DIR}/partitioned5/part_col=0/*.parquet' ORDER BY value2_col; +-- +ok +== +COPY test TO '{TEST_DIR}/partitioned6' (FORMAT PARQUET, PARTITION_BY part_col, USE_TMP_FILE TRUE); +-- +ok +== +COPY test TO '{TEST_DIR}/partitioned6' (FORMAT PARQUET, PARTITION_BY part_col, PER_THREAD_OUTPUT TRUE); +-- +ok +== +COPY test TO '{TEST_DIR}/partitioned7' (FORMAT CSV, PARTITION_BY part_col); +-- +ok +== +SELECT part_col, value_col, value2_col FROM '{TEST_DIR}/partitioned7/part_col=0/*.csv' ORDER BY value2_col; +-- +ok +== +SELECT part_col, value_col, value2_col FROM '{TEST_DIR}/partitioned7/part_col=1/*.csv' ORDER BY value2_col; +-- +ok +== +COPY test TO '{TEST_DIR}/partitioned8' (FORMAT PARQUET, PARTITION_BY pArt_cOl); +-- +ok +== +SELECT part_col, value_col, value2_col FROM '{TEST_DIR}/partitioned8/part_col=0/*.parquet' ORDER BY value2_cOl; +-- +ok +== +COPY test TO '{TEST_DIR}/partitioned9' (FORMAT PARQUET, PARTITION_BY (part_col, value_col)); +-- +ok +== +SELECT min(value2_col) as min_val +FROM parquet_scan('{TEST_DIR}/partitioned9/part_col=*/value_col=*/*.parquet', FILENAME=1) +GROUP BY filename +ORDER BY min_val +-- +ok +== +COPY test TO '{TEST_DIR}/partitioned10' (FORMAT PARQUET, PARTITION_BY (value_col, part_col)); +-- +ok +== +SELECT min(value2_col) as min_val +FROM parquet_scan('{TEST_DIR}/partitioned10/value_col=*/part_col=*/*.parquet', FILENAME=1) +GROUP BY filename +ORDER BY min_val +-- +ok +== diff --git a/parser/testdata/corpus/sql/copy/partitioned/hive_partitioning_overwrite.test b/parser/testdata/corpus/sql/copy/partitioned/hive_partitioning_overwrite.test new file mode 100644 index 0000000..2f30e89 --- /dev/null +++ b/parser/testdata/corpus/sql/copy/partitioned/hive_partitioning_overwrite.test @@ -0,0 +1,41 @@ +# source: test/sql/copy/partitioned/hive_partitioning_overwrite.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +COPY (SELECT 42 AS part_col, 43 AS value_col) TO '{TEST_DIR}/overwrite_test' (FORMAT PARQUET, PARTITION_BY (part_col)); +-- +ok +== +COPY (SELECT 84 AS part_col, 85 AS value_col) TO '{TEST_DIR}/overwrite_test' (FORMAT PARQUET, PARTITION_BY (part_col)); +-- +ok +== +COPY (SELECT 84 AS part_col, 85 AS value_col) TO '{TEST_DIR}/overwrite_test' (FORMAT PARQUET, PARTITION_BY (part_col), OVERWRITE 1); +-- +ok +== +SELECT * FROM '{TEST_DIR}/overwrite_test/**/*.parquet' +-- +ok +== +COPY (SELECT 42 AS part_col) TO '{TEST_DIR}/overwrite_test2' (FORMAT PARQUET); +-- +ok +== +COPY (SELECT 84 AS part_col, 85 AS value_col) TO '{TEST_DIR}/overwrite_test2' (FORMAT PARQUET, PARTITION_BY (part_col)); +-- +ok +== +COPY (SELECT 84 AS part_col, 85 AS value_col) TO '{TEST_DIR}/overwrite_test2' (FORMAT PARQUET, PARTITION_BY (part_col), OVERWRITE 1); +-- +ok +== +SELECT * FROM '{TEST_DIR}/overwrite_test2/**/*.parquet' +-- +ok +== +COPY (SELECT 84 AS part_col) TO '{TEST_DIR}/overwrite_test' (FORMAT PARQUET, PARTITION_BY (part_col), OVERWRITE 1, OVERWRITE_OR_IGNORE 1); +-- +ok +== diff --git a/parser/testdata/corpus/sql/copy/partitioned/order_by_without_partition.test b/parser/testdata/corpus/sql/copy/partitioned/order_by_without_partition.test new file mode 100644 index 0000000..e6f6dc2 --- /dev/null +++ b/parser/testdata/corpus/sql/copy/partitioned/order_by_without_partition.test @@ -0,0 +1,188 @@ +# source: test/sql/copy/partitioned/order_by_without_partition.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +SET partitioned_write_flush_threshold=2048; +-- +ok +== +CREATE TABLE ordered_only_source AS +SELECT + i::INTEGER AS id, + CASE WHEN i % 97 = 0 THEN NULL ELSE ((i * 15485863) % 32768)::INTEGER END AS v +FROM range(16384) tbl(i); +-- +ok +== +COPY ordered_only_source +TO '{TEST_DIR}/ordered_only_asc' +(FORMAT PARQUET, ORDER_BY (v ASC NULLS LAST), ROW_GROUP_SIZE 2048); +-- +ok +== +SELECT count(*) > 1 +FROM glob('{TEST_DIR}/ordered_only_asc/*.parquet'); +-- +ok +== +SELECT count(*) +FROM read_parquet('{TEST_DIR}/ordered_only_asc/*.parquet'); +-- +ok +== +WITH per_file AS ( + SELECT + file_row_number, + v, + lag(v) OVER (PARTITION BY filename ORDER BY file_row_number) AS prev_v + FROM read_parquet( + '{TEST_DIR}/ordered_only_asc/*.parquet', + filename = true, + file_row_number = true + ) +) +SELECT count(*) +FROM per_file +WHERE file_row_number > 0 + AND ((prev_v IS NULL AND v IS NOT NULL) OR (prev_v IS NOT NULL AND v IS NOT NULL AND prev_v > v)); +-- +ok +== +SET partitioned_write_flush_threshold=1000000; +-- +ok +== +WITH stats AS ( + COPY ordered_only_source + TO '{TEST_DIR}/ordered_only_desc' + (FORMAT PARQUET, ORDER_BY (v DESC NULLS FIRST), ROW_GROUP_SIZE 2048, ROW_GROUPS_PER_FILE 1, + FILENAME_PATTERN 'sorted_{i}', RETURN_STATS) +) +SELECT count(*) > 1, bool_and(partition_keys IS NULL) +FROM stats; +-- +ok +== +SELECT count(*) = count(DISTINCT file) +FROM glob('{TEST_DIR}/ordered_only_desc/sorted_*.parquet'); +-- +ok +== +WITH per_file AS ( + SELECT + file_row_number, + v, + lag(v) OVER (PARTITION BY filename ORDER BY file_row_number) AS prev_v + FROM read_parquet( + '{TEST_DIR}/ordered_only_desc/sorted_*.parquet', + filename = true, + file_row_number = true + ) +) +SELECT count(*) +FROM per_file +WHERE file_row_number > 0 + AND ((prev_v IS NOT NULL AND v IS NULL) OR (prev_v IS NOT NULL AND v IS NOT NULL AND prev_v < v)); +-- +ok +== +COPY ordered_only_source +TO '{TEST_DIR}/ordered_only_parallel' +(FORMAT PARQUET, ORDER_BY (id DESC), ROW_GROUP_SIZE 2048); +-- +ok +== +SELECT count(*) +FROM read_parquet('{TEST_DIR}/ordered_only_parallel/*.parquet'); +-- +ok +== +WITH per_file AS ( + SELECT + file_row_number, + id, + lag(id) OVER (PARTITION BY filename ORDER BY file_row_number) AS prev_id + FROM read_parquet( + '{TEST_DIR}/ordered_only_parallel/*.parquet', + filename = true, + file_row_number = true + ) +) +SELECT count(*) +FROM per_file +WHERE file_row_number > 0 AND prev_id < id; +-- +ok +== +COPY (SELECT * FROM ordered_only_source LIMIT 0) +TO '{TEST_DIR}/ordered_only_empty' +(FORMAT PARQUET, ORDER_BY (v)); +-- +ok +== +SELECT count(*) +FROM glob('{TEST_DIR}/ordered_only_empty/*.parquet'); +-- +ok +== +COPY ordered_only_source +TO '{TEST_DIR}/ordered_only_tmp' +(FORMAT PARQUET, ORDER_BY (v), USE_TMP_FILE false); +-- +ok +== +COPY ordered_only_source +TO '{TEST_DIR}/ordered_only_per_thread' +(FORMAT PARQUET, ORDER_BY (v), PER_THREAD_OUTPUT); +-- +ok +== +COPY ordered_only_source +TO '{TEST_DIR}/ordered_only_skip_empty' +(FORMAT PARQUET, ORDER_BY (v), WRITE_EMPTY_FILE false); +-- +ok +== +COPY ordered_only_source +TO '{TEST_DIR}/ordered_only_preserve' +(FORMAT PARQUET, ORDER_BY (v), PRESERVE_ORDER); +-- +ok +== +COPY ordered_only_source +TO '{TEST_DIR}/ordered_only_csv' +(FORMAT CSV, HEADER, ORDER_BY (v ASC NULLS LAST)); +-- +ok +== +SELECT count(*) +FROM read_csv('{TEST_DIR}/ordered_only_csv/*.csv', HEADER = true, AUTO_DETECT = true); +-- +ok +== +COPY (SELECT * FROM ordered_only_source ORDER BY v ASC NULLS LAST) +TO '{TEST_DIR}/ordered_single_file.parquet' +(FORMAT PARQUET); +-- +ok +== +SELECT count(*) +FROM glob('{TEST_DIR}/ordered_single_file.parquet'); +-- +ok +== +WITH ordered_file AS ( + SELECT + file_row_number, + v, + lag(v) OVER (ORDER BY file_row_number) AS prev_v + FROM read_parquet('{TEST_DIR}/ordered_single_file.parquet', file_row_number = true) +) +SELECT count(*) +FROM ordered_file +WHERE file_row_number > 0 + AND ((prev_v IS NULL AND v IS NOT NULL) OR (prev_v IS NOT NULL AND v IS NOT NULL AND prev_v > v)); +-- +ok +== diff --git a/parser/testdata/corpus/sql/copy/partitioned/partition_by_syntax.test b/parser/testdata/corpus/sql/copy/partitioned/partition_by_syntax.test new file mode 100644 index 0000000..a9fc029 --- /dev/null +++ b/parser/testdata/corpus/sql/copy/partitioned/partition_by_syntax.test @@ -0,0 +1,49 @@ +# source: test/sql/copy/partitioned/partition_by_syntax.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +COPY (SELECT 1 AS a, 2 AS payload) TO '{TEST_DIR}/single_partition' PARTITION BY a, HEADER; +-- +ok +== +COPY (SELECT 1 AS a, 2 AS b, 3 AS c) TO '{TEST_DIR}/multiple_partitions' PARTITION BY (a, b), HEADER; +-- +ok +== +COPY (SELECT 1 AS a, 2 AS b, 3 AS c) TO '{TEST_DIR}/unparenthesized_partitions' PARTITION BY a, b, HEADER; +-- +error: Parser Error: syntax error at or near "b" +== +COPY (SELECT 1 AS a, 2 AS b) TO '{TEST_DIR}/partitioned_by' PARTITIONED BY a, HEADER; +-- +ok +== +COPY (SELECT 1 AS a, 'hello' AS payload) TO '{TEST_DIR}/parenthesized_partition_by' (FORMAT CSV, PARTITION BY a, HEADER, OVERWRITE); +-- +ok +== +SELECT payload FROM read_csv('{TEST_DIR}/parenthesized_partition_by/a=1/*.csv', HEADER = true) +-- +ok +== +COPY (SELECT 1 AS a, 2 AS b) TO '{TEST_DIR}/partitioned_by_order_modifier' (FORMAT CSV, PARTITIONED BY (a DESC)); +-- +error: Parser Error: ORDER BY modifiers are only supported in the ORDER BY option +== +COPY (SELECT * FROM VALUES (1, 1), (1, 3), (1, 2) t(a, b)) TO '{TEST_DIR}/spaced_options' (FORMAT CSV, PARTITIONED BY (a), ORDER BY (b DESC), HEADER); +-- +ok +== +SELECT b FROM read_csv('{TEST_DIR}/spaced_options/a=1/*.csv', HEADER = true) +-- +ok +== +COPY (SELECT * FROM VALUES (1, 1), (1, 2) t(a, payload)) TO '{TEST_DIR}/partitioned_by_compatibility' (FORMAT CSV, PARTITIONED_BY (a), ORDER_BY (payload DESC), HEADER); +-- +ok +== +SELECT payload FROM read_csv('{TEST_DIR}/partitioned_by_compatibility/a=1/*.csv', HEADER = true) +-- +ok +== diff --git a/parser/testdata/corpus/sql/copy/partitioned/partition_by_syntax.test.metadata.json b/parser/testdata/corpus/sql/copy/partitioned/partition_by_syntax.test.metadata.json new file mode 100644 index 0000000..3506cf7 --- /dev/null +++ b/parser/testdata/corpus/sql/copy/partitioned/partition_by_syntax.test.metadata.json @@ -0,0 +1,5 @@ +{ + "todo": { + "5ff20aa75bc2bb59": "transformer-raised parser error: upstream rejects in the transformer, not the grammar; expected to clear as transformers land (milestones 3-5)" + } +} diff --git a/parser/testdata/corpus/sql/copy/partitioned/partition_issue_6304.test b/parser/testdata/corpus/sql/copy/partitioned/partition_issue_6304.test new file mode 100644 index 0000000..60ff11b --- /dev/null +++ b/parser/testdata/corpus/sql/copy/partitioned/partition_issue_6304.test @@ -0,0 +1,21 @@ +# source: test/sql/copy/partitioned/partition_issue_6304.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +copy (select NULL as i, NULL as j from range(100000)) to '{TEST_DIR}/issue6304_null' (format parquet, partition_by(i), overwrite_or_ignore); +-- +ok +== +copy (select 1 as i, 2 as j from range(100000)) to '{TEST_DIR}/issue6304_constant' (format parquet, partition_by(i), overwrite_or_ignore); +-- +ok +== +copy (select NULL as i from range(100000)) to '{TEST_DIR}/issue6304_null' (format parquet, partition_by(i), overwrite_or_ignore, write_partition_columns); +-- +ok +== +copy (select 1 as i from range(100000)) to '{TEST_DIR}/issue6304_constant' (format parquet, partition_by(i), overwrite_or_ignore, write_partition_columns); +-- +ok +== diff --git a/parser/testdata/corpus/sql/copy/partitioned/partitioned_early_finalize.test b/parser/testdata/corpus/sql/copy/partitioned/partitioned_early_finalize.test new file mode 100644 index 0000000..1ba0086 --- /dev/null +++ b/parser/testdata/corpus/sql/copy/partitioned/partitioned_early_finalize.test @@ -0,0 +1,149 @@ +# source: test/sql/copy/partitioned/partitioned_early_finalize.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +SET partitioned_write_max_open_files=1024; +-- +ok +== +CREATE TABLE partitioned_early_finalize_source AS +SELECT + (i % 32)::INTEGER AS p, + i::INTEGER AS v, + repeat('payload-', 4) || i::VARCHAR AS payload +FROM range(0, 8192) tbl(i); +-- +ok +== +COPY partitioned_early_finalize_source +TO '{TEST_DIR}/partitioned_early_finalize' +(FORMAT PARQUET, PARTITION_BY (p), ROW_GROUP_SIZE 64); +-- +ok +== +SELECT count(*), sum(v) +FROM read_parquet('{TEST_DIR}/partitioned_early_finalize/**/*.parquet', hive_partitioning = true); +-- +ok +== +WITH files AS ( + SELECT p, count(DISTINCT filename) AS file_count + FROM read_parquet( + '{TEST_DIR}/partitioned_early_finalize/**/*.parquet', + filename = true, + hive_partitioning = true + ) + GROUP BY p +) +SELECT max(file_count) +FROM files; +-- +ok +== +CREATE TABLE partitioned_early_finalize_delayed AS +SELECT + CASE WHEN i % 13 = 0 THEN ((i / 13) % 16) + 1 ELSE 0 END::INTEGER AS p, + i::INTEGER AS v +FROM range(0, 12288) tbl(i); +-- +ok +== +COPY partitioned_early_finalize_delayed +TO '{TEST_DIR}/partitioned_early_finalize_delayed' +(FORMAT PARQUET, PARTITION_BY (p), ROW_GROUP_SIZE 64); +-- +ok +== +SELECT count(*), count(DISTINCT p) +FROM read_parquet('{TEST_DIR}/partitioned_early_finalize_delayed/**/*.parquet', hive_partitioning = true); +-- +ok +== +WITH files AS ( + SELECT p, count(DISTINCT filename) AS file_count + FROM read_parquet( + '{TEST_DIR}/partitioned_early_finalize_delayed/**/*.parquet', + filename = true, + hive_partitioning = true + ) + GROUP BY p +) +SELECT max(file_count) +FROM files +WHERE p <> 0; +-- +ok +== +CREATE TABLE partitioned_early_finalize_serialized AS +SELECT + (i % 8)::INTEGER AS p, + ((i * 131) % 4096)::INTEGER AS v, + i::INTEGER AS payload +FROM range(0, 4096) tbl(i); +-- +ok +== +COPY (SELECT p, v, payload FROM partitioned_early_finalize_serialized ORDER BY v DESC, p DESC) +TO '{TEST_DIR}/partitioned_early_finalize_ordered' +(FORMAT PARQUET, PARTITION_BY (p), ORDER_BY (v), ROW_GROUP_SIZE 64); +-- +ok +== +SELECT count(*), count(DISTINCT p) +FROM read_parquet('{TEST_DIR}/partitioned_early_finalize_ordered/**/*.parquet', hive_partitioning = true); +-- +ok +== +WITH per_file AS ( + SELECT + filename, + v, + lag(v) OVER (PARTITION BY filename ORDER BY file_row_number) AS prev_v + FROM read_parquet( + '{TEST_DIR}/partitioned_early_finalize_ordered/**/*.parquet', + filename = true, + file_row_number = true, + hive_partitioning = true + ) +) +SELECT count(*) +FROM per_file +WHERE prev_v IS NOT NULL AND prev_v > v; +-- +ok +== +CREATE TABLE partitioned_early_finalize_rotation_source AS +SELECT + (i % 4)::INTEGER AS p, + ((i * 17) % 32768)::INTEGER AS v, + hash(i)::DOUBLE AS payload +FROM range(0, 32768) tbl(i); +-- +ok +== +COPY partitioned_early_finalize_rotation_source +TO '{TEST_DIR}/partitioned_early_finalize_rotation' +(FORMAT PARQUET, PARTITION_BY (p), ROW_GROUP_SIZE 1024, ROW_GROUPS_PER_FILE 1); +-- +ok +== +SELECT count(*) +FROM read_parquet('{TEST_DIR}/partitioned_early_finalize_rotation/**/*.parquet', hive_partitioning = true); +-- +ok +== +WITH files AS ( + SELECT p, count(DISTINCT filename) AS file_count + FROM read_parquet( + '{TEST_DIR}/partitioned_early_finalize_rotation/**/*.parquet', + filename = true, + hive_partitioning = true + ) + GROUP BY p +) +SELECT min(file_count) > 1 +FROM files; +-- +ok +== diff --git a/parser/testdata/corpus/sql/copy/partitioned/partitioned_file_rotation.test b/parser/testdata/corpus/sql/copy/partitioned/partitioned_file_rotation.test new file mode 100644 index 0000000..5f15d97 --- /dev/null +++ b/parser/testdata/corpus/sql/copy/partitioned/partitioned_file_rotation.test @@ -0,0 +1,132 @@ +# source: test/sql/copy/partitioned/partitioned_file_rotation.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +CREATE TABLE partitioned_rotation_source AS +SELECT + (i % 4)::INTEGER AS p, + ((i * 17) % 32768)::INTEGER AS v, + hash(i)::DOUBLE AS payload +FROM range(32768) tbl(i); +-- +ok +== +COPY partitioned_rotation_source +TO '{TEST_DIR}/partitioned_rotation_size' +(FORMAT PARQUET, PARTITION_BY (p), ROW_GROUP_SIZE 1024, FILE_SIZE_BYTES '1kb'); +-- +ok +== +SELECT count(*) +FROM read_parquet('{TEST_DIR}/partitioned_rotation_size/**/*.parquet', hive_partitioning = true); +-- +ok +== +WITH files AS ( + SELECT p, count(DISTINCT filename) file_count + FROM read_parquet( + '{TEST_DIR}/partitioned_rotation_size/**/*.parquet', + filename = true, + hive_partitioning = true + ) + GROUP BY p +) +SELECT min(file_count) > 1 +FROM files; +-- +ok +== +SELECT count(*) = count(DISTINCT file) +FROM glob('{TEST_DIR}/partitioned_rotation_size/**/*.parquet'); +-- +ok +== +COPY partitioned_rotation_source +TO '{TEST_DIR}/partitioned_rotation_row_groups' +(FORMAT PARQUET, PARTITION_BY (p), ROW_GROUP_SIZE 1024, ROW_GROUPS_PER_FILE 1); +-- +ok +== +SELECT count(*) +FROM read_parquet('{TEST_DIR}/partitioned_rotation_row_groups/**/*.parquet', hive_partitioning = true); +-- +ok +== +WITH files AS ( + SELECT p, count(DISTINCT filename) file_count + FROM read_parquet( + '{TEST_DIR}/partitioned_rotation_row_groups/**/*.parquet', + filename = true, + hive_partitioning = true + ) + GROUP BY p +) +SELECT min(file_count) > 1 +FROM files; +-- +ok +== +COPY (SELECT p, v, payload FROM partitioned_rotation_source ORDER BY v DESC, p DESC) +TO '{TEST_DIR}/partitioned_rotation_ordered' +(FORMAT PARQUET, PARTITION_BY (p), ORDER_BY (v), ROW_GROUP_SIZE 1024, ROW_GROUPS_PER_FILE 1); +-- +ok +== +SELECT count(*) +FROM read_parquet('{TEST_DIR}/partitioned_rotation_ordered/**/*.parquet', hive_partitioning = true); +-- +ok +== +WITH files AS ( + SELECT p, count(DISTINCT filename) file_count + FROM read_parquet( + '{TEST_DIR}/partitioned_rotation_ordered/**/*.parquet', + filename = true, + hive_partitioning = true + ) + GROUP BY p +) +SELECT min(file_count) > 1 +FROM files; +-- +ok +== +WITH per_file AS ( + SELECT + filename, + v, + lag(v) OVER (PARTITION BY filename ORDER BY file_row_number) AS prev_v + FROM read_parquet( + '{TEST_DIR}/partitioned_rotation_ordered/**/*.parquet', + filename = true, + file_row_number = true, + hive_partitioning = true + ) +) +SELECT count(*) +FROM per_file +WHERE prev_v IS NOT NULL AND prev_v > v; +-- +ok +== +CREATE TABLE partitioned_rotation_metadata_source AS +SELECT + (i % 2)::INTEGER AS p, + i::INTEGER AS v +FROM range(16384) tbl(i); +-- +ok +== +COPY partitioned_rotation_metadata_source +TO '{TEST_DIR}/partitioned_rotation_return_files' +(FORMAT PARQUET, PARTITION_BY (p), ROW_GROUP_SIZE 1024, ROW_GROUPS_PER_FILE 1, RETURN_FILES); +-- +ok +== +COPY partitioned_rotation_metadata_source +TO '{TEST_DIR}/partitioned_rotation_return_stats' +(FORMAT PARQUET, PARTITION_BY (p), ROW_GROUP_SIZE 1024, ROW_GROUPS_PER_FILE 1, RETURN_STATS); +-- +ok +== diff --git a/parser/testdata/corpus/sql/copy/partitioned/partitioned_group_by.test b/parser/testdata/corpus/sql/copy/partitioned/partitioned_group_by.test new file mode 100644 index 0000000..c2c54b8 --- /dev/null +++ b/parser/testdata/corpus/sql/copy/partitioned/partitioned_group_by.test @@ -0,0 +1,123 @@ +# source: test/sql/copy/partitioned/partitioned_group_by.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +CREATE TABLE partitioned_tbl AS SELECT i%2 AS partition, i col1, i // 7 col2, (i%3)::VARCHAR col3 FROM range(10000) t(i) +-- +ok +== +COPY partitioned_tbl TO '{TEST_DIR}/partition_group_by' (FORMAT parquet, PARTITION_BY (partition)) +-- +ok +== +DROP TABLE partitioned_tbl +-- +ok +== +CREATE VIEW partitioned_tbl AS FROM '{TEST_DIR}/partition_group_by/**/*.parquet' +-- +ok +== +SELECT partition, SUM(col1) +FROM partitioned_tbl +GROUP BY partition +ORDER BY ALL +-- +ok +== +EXPLAIN SELECT partition, SUM(col1) +FROM partitioned_tbl +GROUP BY partition +ORDER BY ALL +-- +ok +== +SELECT partition, COUNT(DISTINCT col2) +FROM partitioned_tbl +GROUP BY partition +ORDER BY ALL +-- +ok +== +SELECT partition, SUM(col1) +FROM partitioned_tbl +GROUP BY GROUPING SETS ((), (partition)) +ORDER BY ALL +-- +ok +== +SELECT partition, SUM(col1) FILTER (col2%7>2) +FROM partitioned_tbl +GROUP BY partition +ORDER BY ALL +-- +ok +== +SELECT SUM(col1), partition +FROM partitioned_tbl +GROUP BY partition +ORDER BY ALL +-- +ok +== +SELECT partition, SUM(col1) +FROM partitioned_tbl +WHERE col2 > 100 +GROUP BY partition +ORDER BY ALL +-- +ok +== +CREATE TABLE partitioned_tbl2 AS SELECT i%2 AS partition1, i%3 AS partition2, i col1, i + 1 col2 FROM range(10000) t(i) +-- +ok +== +COPY partitioned_tbl2 TO '{TEST_DIR}/partition_group_by_multiple' (FORMAT parquet, PARTITION_BY (partition1, partition2)) +-- +ok +== +DROP TABLE partitioned_tbl2 +-- +ok +== +CREATE VIEW partitioned_tbl2 AS FROM '{TEST_DIR}/partition_group_by_multiple/**/*.parquet' +-- +ok +== +SELECT partition1, partition2, SUM(col1) +FROM partitioned_tbl2 +GROUP BY partition1, partition2 +ORDER BY ALL +-- +ok +== +SELECT partition1, SUM(col1) +FROM partitioned_tbl2 +GROUP BY partition1 +ORDER BY ALL +-- +ok +== +SELECT partition2, SUM(col1) +FROM partitioned_tbl2 +GROUP BY partition2 +ORDER BY ALL +-- +ok +== +SELECT partition1, SUM(col1) +FROM partitioned_tbl2 +WHERE partition2=0 +GROUP BY partition1 +ORDER BY ALL +-- +ok +== +SELECT partition1, partition2, SUM(col1) +FROM partitioned_tbl2 +GROUP BY GROUPING SETS ((partition1), (partition2)) +ORDER BY ALL +-- +ok +== diff --git a/parser/testdata/corpus/sql/copy/partitioned/partitioned_order_by.test b/parser/testdata/corpus/sql/copy/partitioned/partitioned_order_by.test new file mode 100644 index 0000000..c80e8d4 --- /dev/null +++ b/parser/testdata/corpus/sql/copy/partitioned/partitioned_order_by.test @@ -0,0 +1,156 @@ +# source: test/sql/copy/partitioned/partitioned_order_by.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +CREATE TABLE ordered_source AS +SELECT 0 AS p, i::INTEGER AS v +FROM range(16384) tbl(i); +-- +ok +== +COPY (SELECT p, v FROM ordered_source ORDER BY v DESC) +TO '{TEST_DIR}/ordered_partitioned_default_asc' +(FORMAT PARQUET, PARTITION_BY (p), ORDER_BY (v)); +-- +ok +== +WITH per_file AS ( + SELECT + filename, + v, + lag(v) OVER (PARTITION BY filename ORDER BY file_row_number) AS prev_v + FROM read_parquet( + '{TEST_DIR}/ordered_partitioned_default_asc/**/*.parquet', + filename = true, + file_row_number = true, + hive_partitioning = true + ) +) +SELECT count(*) FROM per_file WHERE prev_v IS NOT NULL AND prev_v > v; +-- +ok +== +COPY (SELECT p, v FROM ordered_source ORDER BY v) +TO '{TEST_DIR}/ordered_partitioned' +(FORMAT PARQUET, PARTITION_BY (p), ORDER_BY (v DESC)); +-- +ok +== +SELECT count(*) > 1 FROM glob('{TEST_DIR}/ordered_partitioned/p=0/*.parquet'); +-- +ok +== +SELECT count(*) FROM glob('{TEST_DIR}/ordered_partitioned/p=0/data_1.parquet'); +-- +ok +== +WITH per_file AS ( + SELECT + filename, + v, + lag(v) OVER (PARTITION BY filename ORDER BY file_row_number) AS prev_v + FROM read_parquet( + '{TEST_DIR}/ordered_partitioned/**/*.parquet', + filename = true, + file_row_number = true, + hive_partitioning = true + ) +) +SELECT count(*) FROM per_file WHERE prev_v IS NOT NULL AND prev_v < v; +-- +ok +== +SELECT count(*) +FROM read_parquet('{TEST_DIR}/ordered_partitioned/**/*.parquet', hive_partitioning = true); +-- +ok +== +COPY (SELECT p, v FROM ordered_source ORDER BY v) +TO '{TEST_DIR}/unordered_partitioned' +(FORMAT PARQUET, PARTITION_BY (p)); +-- +ok +== +SELECT count(*) FROM glob('{TEST_DIR}/unordered_partitioned/p=0/*.parquet'); +-- +ok +== +COPY (SELECT p, v FROM ordered_source ORDER BY v) +TO '{TEST_DIR}/ordered_partitioned_non_hive' +(FORMAT PARQUET, PARTITION_BY (p), ORDER_BY (v DESC), HIVE_FILE_PATTERN false); +-- +ok +== +SELECT count(*) > 1 FROM glob('{TEST_DIR}/ordered_partitioned_non_hive/*.parquet'); +-- +ok +== +WITH per_file AS ( + SELECT + filename, + v, + lag(v) OVER (PARTITION BY filename ORDER BY file_row_number) AS prev_v + FROM read_parquet( + '{TEST_DIR}/ordered_partitioned_non_hive/*.parquet', + filename = true, + file_row_number = true + ) +) +SELECT count(*) FROM per_file WHERE prev_v IS NOT NULL AND prev_v < v; +-- +ok +== +COPY (SELECT p, v FROM ordered_source ORDER BY v) +TO '{TEST_DIR}/ordered_partitioned_return_files' +(FORMAT PARQUET, PARTITION_BY (p), ORDER_BY (v DESC), RETURN_FILES); +-- +ok +== +set threads=4 +-- +ok +== +CREATE TABLE large_ordered_source AS +SELECT + (i % 16)::INTEGER AS p, + ((i * 17) % 65536)::INTEGER AS v +FROM range(524288) tbl(i); +-- +ok +== +COPY (SELECT p, v FROM large_ordered_source ORDER BY v DESC, p DESC) +TO '{TEST_DIR}/large_ordered_partitioned' +(FORMAT PARQUET, PARTITION_BY (p), ORDER_BY (p, v), ROW_GROUP_SIZE 2048); +-- +ok +== +SELECT count(*) > 16 FROM glob('{TEST_DIR}/large_ordered_partitioned/p=*/*.parquet'); +-- +ok +== +WITH per_file AS ( + SELECT + filename, + p, + v, + lag(p) OVER (PARTITION BY filename ORDER BY file_row_number) AS prev_p, + lag(v) OVER (PARTITION BY filename ORDER BY file_row_number) AS prev_v + FROM read_parquet( + '{TEST_DIR}/large_ordered_partitioned/**/*.parquet', + filename = true, + file_row_number = true, + hive_partitioning = true + ) +) +SELECT count(*) +FROM per_file +WHERE prev_p > p OR (prev_p = p AND prev_v > v); +-- +ok +== +SELECT count(*) +FROM read_parquet('{TEST_DIR}/large_ordered_partitioned/**/*.parquet', hive_partitioning = true); +-- +ok +== diff --git a/parser/testdata/corpus/sql/copy/partitioned/partitioned_order_by_flush_race.test b/parser/testdata/corpus/sql/copy/partitioned/partitioned_order_by_flush_race.test new file mode 100644 index 0000000..16f3f42 --- /dev/null +++ b/parser/testdata/corpus/sql/copy/partitioned/partitioned_order_by_flush_race.test @@ -0,0 +1,28 @@ +# source: test/sql/copy/partitioned/partitioned_order_by_flush_race.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +PRAGMA threads=6; +-- +ok +== +CREATE OR REPLACE TABLE large_ordered_source AS +SELECT + (i % 16)::INTEGER AS p, + ((i * 17) % 65536)::INTEGER AS v +FROM range(524288) tbl(i); +-- +ok +== +COPY (SELECT p, v FROM large_ordered_source ORDER BY v DESC, p DESC) +TO '{TEST_DIR}/large_ordered_partitioned_{i}' +(FORMAT PARQUET, PARTITION_BY (p), ORDER_BY (p, v), ROW_GROUP_SIZE 2048); +-- +ok +== +SELECT count(*) +FROM read_parquet('{TEST_DIR}/large_ordered_partitioned_{i}/**/*.parquet', hive_partitioning = true); +-- +ok +== diff --git a/parser/testdata/corpus/sql/copy/partitioned/partitioned_window.test b/parser/testdata/corpus/sql/copy/partitioned/partitioned_window.test new file mode 100644 index 0000000..a3c04a9 --- /dev/null +++ b/parser/testdata/corpus/sql/copy/partitioned/partitioned_window.test @@ -0,0 +1,79 @@ +# source: test/sql/copy/partitioned/partitioned_window.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +CREATE TABLE partitioned_tbl AS + SELECT + i%2 AS partition, + i col1, + i // 7 col2, + (i%3)::VARCHAR col3 + FROM range(10000) t(i) +-- +ok +== +COPY partitioned_tbl TO '{TEST_DIR}/partition_window' (FORMAT parquet, PARTITION_BY (partition)) +-- +ok +== +CREATE VIEW partitioned_tbl AS FROM '{TEST_DIR}/partition_window/**/*.parquet' +-- +ok +== +SELECT partition, LAG(col1) OVER w AS prev +FROM partitioned_tbl +WINDOW w AS (PARTITION BY partition ORDER BY col1) +QUALIFY (col1 - prev) <> 2 +-- +ok +== +CREATE TABLE partitioned_tbl2 AS + SELECT + i%2 AS partition1, + i%3 AS partition2, + i col1, + i + 1 col2 + FROM range(10000) t(i) +-- +ok +== +SELECT partition1, partition2, LAG(col1) OVER w AS prev +FROM partitioned_tbl2 +WINDOW w AS (PARTITION BY partition1, partition2 ORDER BY col1) +QUALIFY (col1 - prev) <> 6 +-- +ok +== +SELECT count(*) +FROM ( + SELECT partition1, partition2, lag(col1) OVER w AS prev + FROM partitioned_tbl2 + WINDOW w AS (PARTITION BY partition1 ORDER BY col1) + QUALIFY col1 - prev <> 2 +) +-- +ok +== +SELECT count(*) +FROM ( + SELECT partition1, partition2, lag(col1) OVER w AS prev + FROM partitioned_tbl2 + WINDOW w AS (PARTITION BY partition2 ORDER BY col1) + QUALIFY col1 - prev <> 3 +) +-- +ok +== +SELECT count(*) +FROM ( + SELECT + lag(col1) OVER (PARTITION BY partition2 ORDER BY col1) AS prev_p2, + lag(col1) OVER (PARTITION BY partition1 ORDER BY col1) AS prev_p1, + col1 + FROM partitioned_tbl2 +) t +WHERE col1 - prev_p1 <> 2 +-- +ok +== diff --git a/parser/testdata/corpus/sql/copy/partitioned/skip_partition_column_writes.test b/parser/testdata/corpus/sql/copy/partitioned/skip_partition_column_writes.test new file mode 100644 index 0000000..b7cd264 --- /dev/null +++ b/parser/testdata/corpus/sql/copy/partitioned/skip_partition_column_writes.test @@ -0,0 +1,189 @@ +# source: test/sql/copy/partitioned/skip_partition_column_writes.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +COPY test TO '{TEST_DIR}/no-part-cols' (FORMAT PARQUET, PARTITION_BY (part_col)); +-- +ok +== +SELECT part_col, value_col, value2_col FROM '{TEST_DIR}/no-part-cols/part_col=0/*.parquet' ORDER BY value2_col; +-- +ok +== +COPY test TO '{TEST_DIR}/no-part-cols-explicit' (FORMAT PARQUET, PARTITION_BY (part_col), WRITE_PARTITION_COLUMNS false); +-- +ok +== +SELECT part_col, value_col, value2_col FROM '{TEST_DIR}/no-part-cols-explicit/part_col=0/*.parquet' ORDER BY value2_col; +-- +ok +== +COPY test TO '{TEST_DIR}/no-part-cols2' (FORMAT PARQUET, PARTITION_BY (part_col, value_col)); +-- +ok +== +SELECT part_col, value_col, value2_col FROM '{TEST_DIR}/no-part-cols2/part_col=0/value_col=*/*.parquet' ORDER BY value2_col; +-- +ok +== +COPY (SELECT * EXCLUDE (part_col), 'prefix-'::VARCHAR || part_col::VARCHAR as part_col FROM test) TO '{TEST_DIR}/no-part-cols3' (FORMAT PARQUET, PARTITION_BY (part_col)); +-- +ok +== +SELECT part_col, value_col, value2_col FROM '{TEST_DIR}/no-part-cols3/part_col=prefix-0/*.parquet' ORDER BY value2_col; +-- +ok +== +COPY (SELECT 1 AS part_col, 2 AS value_col, 3 AS value2_col, 4 AS value3_col, 5 AS value4_col, 6 AS value5_col, 7 AS value6_col, 8 AS value7_col, 9 AS value8_col, 10 AS value9_col) TO '{TEST_DIR}/no-part-cols4' (FORMAT PARQUET, PARTITION_BY (part_col)); +-- +ok +== +SELECT part_col, value_col, value2_col, value3_col, value4_col, value5_col, value6_col, value7_col, value8_col, value9_col FROM '{TEST_DIR}/no-part-cols4/part_col=1/*.parquet' ORDER BY 1; +-- +ok +== +COPY (SELECT 1 AS part_col, 2 AS value_col, 3 AS value2_col, 4 AS value3_col, 5 AS value4_col, 6 AS value5_col, 7 AS value6_col, 8 AS value7_col, 9 AS value8_col, 10 AS value9_col) TO '{TEST_DIR}/no-part-cols5' (FORMAT PARQUET, PARTITION_BY (value9_col)); +-- +ok +== +SELECT part_col, value_col, value2_col, value3_col, value4_col, value5_col, value6_col, value7_col, value8_col, value9_col FROM '{TEST_DIR}/no-part-cols5/value9_col=*/*.parquet' ORDER BY 1; +-- +ok +== +COPY (SELECT 1 AS part_col, 2 AS value_col, 3 AS value2_col, 4 AS value3_col, 5 AS value4_col, 6 AS value5_col, 7 AS value6_col, 8 AS value7_col, 9 AS value8_col, 10 AS value9_col) TO '{TEST_DIR}/no-part-cols6' (FORMAT PARQUET, PARTITION_BY (value8_col, value9_col)); +-- +ok +== +SELECT part_col, value_col, value2_col, value3_col, value4_col, value5_col, value6_col, value7_col, value8_col, value9_col FROM '{TEST_DIR}/no-part-cols6/value8_col=*/value9_col=*/*.parquet' ORDER BY 1; +-- +ok +== +COPY (SELECT 1 AS part_col, 2 AS value_col, 3 AS value2_col, 4 AS value3_col, 5 AS value4_col, 6 AS value5_col, 7 AS value6_col, 8 AS value7_col, 9 AS value8_col, 10 AS value9_col) TO '{TEST_DIR}/no-part-cols7' (FORMAT PARQUET, PARTITION_BY (value9_col, value8_col, value7_col)); +-- +ok +== +SELECT part_col, value_col, value2_col, value3_col, value4_col, value5_col, value6_col, value7_col, value8_col, value9_col FROM '{TEST_DIR}/no-part-cols7/value9_col=*/value8_col=*/value7_col=*/*.parquet' ORDER BY 1; +-- +ok +== +COPY test TO '{TEST_DIR}/no-part-cols8' (FORMAT PARQUET, PARTITION_BY (part_col, value_col, value2_col)); +-- +ok +== +COPY test TO '{TEST_DIR}/no-part-cols8' (FORMAT PARQUET, OVERWRITE, PARTITION_BY (part_col, value_col, value2_col), WRITE_PARTITION_COLUMNS); +-- +ok +== +SELECT part_col, value_col, value2_col FROM '{TEST_DIR}/no-part-cols8/part_col=0/value_col=*/value2_col=*/*.parquet' ORDER BY value2_col; +-- +ok +== +COPY test TO '{TEST_DIR}/no-part-cols9' (FORMAT PARQUET, PARTITION_BY '*'); +-- +ok +== +COPY test TO '{TEST_DIR}/no-part-cols9' (FORMAT PARQUET, PARTITION_BY '*', OVERWRITE, WRITE_PARTITION_COLUMNS); +-- +ok +== +SELECT part_col, value_col, value2_col FROM '{TEST_DIR}/no-part-cols9/part_col=0/value_col=*/value2_col=*/*.parquet' ORDER BY value2_col; +-- +ok +== +COPY test TO '{TEST_DIR}/no-part-cols9' (FORMAT PARQUET, PARTITION_BY '*', WRITE_PARTITION_COLUMNS false); +-- +ok +== +COPY test TO '{TEST_DIR}/csv-no-part-cols' (FORMAT CSV, PARTITION_BY (part_col)); +-- +ok +== +SELECT part_col, value_col, value2_col FROM '{TEST_DIR}/csv-no-part-cols/part_col=0/*.csv' ORDER BY value2_col; +-- +ok +== +COPY test TO '{TEST_DIR}/csv-no-part-cols-explicit' (FORMAT CSV, PARTITION_BY (part_col), WRITE_PARTITION_COLUMNS false); +-- +ok +== +SELECT part_col, value_col, value2_col FROM '{TEST_DIR}/csv-no-part-cols-explicit/part_col=0/*.csv' ORDER BY value2_col; +-- +ok +== +COPY test TO '{TEST_DIR}/csv-no-part-cols2' (FORMAT CSV, PARTITION_BY (part_col, value_col)); +-- +ok +== +SELECT part_col, value_col, value2_col FROM '{TEST_DIR}/csv-no-part-cols2/part_col=0/value_col=*/*.csv' ORDER BY value2_col; +-- +ok +== +COPY (SELECT * EXCLUDE (part_col), 'prefix-'::VARCHAR || part_col::VARCHAR as part_col FROM test) TO '{TEST_DIR}/csv-no-part-cols3' (FORMAT CSV, PARTITION_BY (part_col)); +-- +ok +== +SELECT part_col, value_col, value2_col FROM '{TEST_DIR}/csv-no-part-cols3/part_col=prefix-0/*.csv' ORDER BY value2_col; +-- +ok +== +COPY (SELECT 1 AS part_col, 2 AS value_col, 3 AS value2_col, 4 AS value3_col, 5 AS value4_col, 6 AS value5_col, 7 AS value6_col, 8 AS value7_col, 9 AS value8_col, 10 AS value9_col) TO '{TEST_DIR}/csv-no-part-cols4' (FORMAT CSV, PARTITION_BY (part_col)); +-- +ok +== +SELECT part_col, value_col, value2_col, value3_col, value4_col, value5_col, value6_col, value7_col, value8_col, value9_col FROM '{TEST_DIR}/csv-no-part-cols4/part_col=1/*.csv' ORDER BY 1; +-- +ok +== +COPY (SELECT 1 AS part_col, 2 AS value_col, 3 AS value2_col, 4 AS value3_col, 5 AS value4_col, 6 AS value5_col, 7 AS value6_col, 8 AS value7_col, 9 AS value8_col, 10 AS value9_col) TO '{TEST_DIR}/csv-no-part-cols5' (FORMAT CSV, PARTITION_BY (value9_col)); +-- +ok +== +SELECT part_col, value_col, value2_col, value3_col, value4_col, value5_col, value6_col, value7_col, value8_col, value9_col FROM '{TEST_DIR}/csv-no-part-cols5/value9_col=*/*.csv' ORDER BY 1; +-- +ok +== +COPY (SELECT 1 AS part_col, 2 AS value_col, 3 AS value2_col, 4 AS value3_col, 5 AS value4_col, 6 AS value5_col, 7 AS value6_col, 8 AS value7_col, 9 AS value8_col, 10 AS value9_col) TO '{TEST_DIR}/csv-no-part-cols6' (FORMAT CSV, PARTITION_BY (value8_col, value9_col)); +-- +ok +== +SELECT part_col, value_col, value2_col, value3_col, value4_col, value5_col, value6_col, value7_col, value8_col, value9_col FROM '{TEST_DIR}/csv-no-part-cols6/value8_col=*/value9_col=*/*.csv' ORDER BY 1; +-- +ok +== +COPY (SELECT 1 AS part_col, 2 AS value_col, 3 AS value2_col, 4 AS value3_col, 5 AS value4_col, 6 AS value5_col, 7 AS value6_col, 8 AS value7_col, 9 AS value8_col, 10 AS value9_col) TO '{TEST_DIR}/csv-no-part-cols7' (FORMAT CSV, PARTITION_BY (value9_col, value8_col, value7_col)); +-- +ok +== +SELECT part_col, value_col, value2_col, value3_col, value4_col, value5_col, value6_col, value7_col, value8_col, value9_col FROM '{TEST_DIR}/csv-no-part-cols7/value9_col=*/value8_col=*/value7_col=*/*.csv' ORDER BY 1; +-- +ok +== +COPY test TO '{TEST_DIR}/csv-no-part-cols8' (FORMAT CSV, PARTITION_BY (part_col, value_col, value2_col)); +-- +ok +== +COPY test TO '{TEST_DIR}/csv-no-part-cols8' (FORMAT CSV, PARTITION_BY (part_col, value_col, value2_col), OVERWRITE, WRITE_PARTITION_COLUMNS); +-- +ok +== +SELECT part_col, value_col, value2_col FROM '{TEST_DIR}/csv-no-part-cols8/part_col=0/value_col=*/value2_col=*/*.csv' ORDER BY value2_col; +-- +ok +== +COPY test TO '{TEST_DIR}/csv-no-part-cols9' (FORMAT CSV, PARTITION_BY '*'); +-- +ok +== +COPY test TO '{TEST_DIR}/csv-no-part-cols9' (FORMAT CSV, PARTITION_BY '*', OVERWRITE, WRITE_PARTITION_COLUMNS); +-- +ok +== +SELECT part_col, value_col, value2_col FROM '{TEST_DIR}/csv-no-part-cols9/part_col=0/value_col=*/value2_col=*/*.csv' ORDER BY value2_col; +-- +ok +== +COPY test TO '{TEST_DIR}/csv-no-part-cols9' (FORMAT CSV, PARTITION_BY '*', WRITE_PARTITION_COLUMNS false); +-- +ok +== diff --git a/parser/testdata/corpus/sql/copy/per_thread_output.test b/parser/testdata/corpus/sql/copy/per_thread_output.test new file mode 100644 index 0000000..928312d --- /dev/null +++ b/parser/testdata/corpus/sql/copy/per_thread_output.test @@ -0,0 +1,45 @@ +# source: test/sql/copy/per_thread_output.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +CREATE TABLE bigdata AS SELECT i AS col_a, i AS col_b FROM range(0,10000) tbl(i); +-- +ok +== +COPY (FROM bigdata UNION ALL FROM bigdata) TO '{TEST_DIR}/per_thread_output' (FORMAT PARQUET, PER_THREAD_OUTPUT TRUE); +-- +ok +== +SELECT COUNT(*) FROM PARQUET_SCAN('{TEST_DIR}/per_thread_output/*.parquet') +-- +ok +== +SELECT COUNT(*) > 1 f FROM GLOB('{TEST_DIR}/per_thread_output/data_*.parquet') ORDER BY f +-- +ok +== +COPY (FROM bigdata UNION ALL FROM bigdata) TO '{TEST_DIR}/per_thread_output_csv' (FORMAT CSV, PER_THREAD_OUTPUT TRUE); +-- +ok +== +SELECT COUNT(*) FROM read_csv('{TEST_DIR}/per_thread_output_csv/*.csv', columns={'col_a': 'INT', 'col_b' : 'INT'}); +-- +ok +== +SELECT COUNT(*) >= 2 f FROM GLOB('{TEST_DIR}/per_thread_output_csv/data_*.csv') ORDER BY f +-- +ok +== +COPY (FROM bigdata) TO '{TEST_DIR}/per_thread_output2/' (FORMAT PARQUET, PER_THREAD_OUTPUT TRUE); +-- +ok +== +SELECT COUNT(*) FROM PARQUET_SCAN('{TEST_DIR}/per_thread_output2/*.parquet') +-- +ok +== +COPY (FROM bigdata) TO '{TEST_DIR}/per_thread_output3' (FORMAT PARQUET, PER_THREAD_OUTPUT TRUE, USE_TMP_FILE TRUE); +-- +ok +== diff --git a/parser/testdata/corpus/sql/copy/return_files.test b/parser/testdata/corpus/sql/copy/return_files.test new file mode 100644 index 0000000..0ee259d --- /dev/null +++ b/parser/testdata/corpus/sql/copy/return_files.test @@ -0,0 +1,45 @@ +# source: test/sql/copy/return_files.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +CREATE TABLE integers AS SELECT range i FROM range(200000); +-- +ok +== +SET preserve_insertion_order=false; +-- +ok +== +COPY integers TO '{TEST_DIR}/test_copy_to_file.parquet' (RETURN_FILES); +-- +ok +== +SET preserve_insertion_order=true; +-- +ok +== +COPY integers TO '{TEST_DIR}/test_batch_copy_to_file.parquet' (RETURN_FILES TRUE); +-- +ok +== +COPY integers TO '{TEST_DIR}/test_return_files_stats_conflict.parquet' (RETURN_FILES, RETURN_STATS); +-- +ok +== +SET threads=2; +-- +ok +== +COPY integers TO '{TEST_DIR}/test_per_thread_output' (RETURN_FILES, PER_THREAD_OUTPUT); +-- +ok +== +CREATE TABLE integers2 AS SELECT range i, range % 4 j FROM range(200000); +-- +ok +== +COPY integers2 TO '{TEST_DIR}/test_partition_by' (RETURN_FILES TRUE, PARTITION_BY j); +-- +ok +== diff --git a/parser/testdata/corpus/sql/copy/return_stats.test b/parser/testdata/corpus/sql/copy/return_stats.test new file mode 100644 index 0000000..ff7ec9c --- /dev/null +++ b/parser/testdata/corpus/sql/copy/return_stats.test @@ -0,0 +1,229 @@ +# source: test/sql/copy/return_stats.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +CREATE TABLE bools AS SELECT i::bool i FROM range(2) i(i); +-- +ok +== +CREATE TABLE multi_column_test AS SELECT range i, range%10 j, case when range%2=0 then null else range end k FROM range(2500); +-- +ok +== +CREATE TABLE floating_point_test AS SELECT case when i%10=0 then null else i/10.0 end as fp FROM range(2500) t(i) +-- +ok +== +CREATE TABLE floating_point_nan AS SELECT case when i%10=0 then 'nan'::double when i%4=0 then null else i/10.0 end as fp FROM range(2500) t(i) +-- +ok +== +CREATE TABLE fp_nan_only AS SELECT 'nan'::float as float_val +-- +ok +== +CREATE TABLE string_test AS SELECT concat('thisisalongstring_', range) s FROM range(2500); +-- +ok +== +CREATE TABLE date_test AS +SELECT (TIMESTAMP '2000-01-01' + interval (range) day)::DATE dt, + TIMESTAMP '2000-01-01 12:12:12.123456' + interval (range) day ts, + (TIMESTAMP '2000-01-01 12:12:12' + interval (range) day)::TIMESTAMP_S ts_s, + (TIMESTAMP '2000-01-01 12:12:12.123' + interval (range) day)::TIMESTAMP_MS ts_ms, + concat((TIMESTAMP '2000-01-01 12:12:12.123456' + interval (range) day)::VARCHAR, '789')::TIMESTAMP_NS ts_ns, + TIME '00:00:00' + interval (10 * range) second t +FROM range(2500); +-- +ok +== +CREATE TABLE empty_test AS FROM range(2500) LIMIT 0; +-- +ok +== +CREATE TABLE blob_test AS SELECT ''::BLOB AS bl UNION ALL SELECT '\x80\x00\x80'::BLOB +-- +ok +== +CREATE TABLE decimal_test AS +SELECT 25.3::DECIMAL(4,1) AS dec_i16, + 123456.789::DECIMAL(9,3) AS dec_i32, + 123456789123.456::DECIMAL(18,3) AS dec_i64, + 12345678912345678912345678912345678.912::DECIMAL(38,3) AS dec_i128 +UNION ALL +SELECT 1.1::DECIMAL(4,1), + 2.123::DECIMAL(9,3), + 3.456::DECIMAL(18,3), + 4.567::DECIMAL(38,3) +-- +ok +== +CREATE TABLE struct_test AS SELECT case when i%10=0 then null else {'x': i, 'y': case when i%2=0 then 100 + i else null end} end struct_val FROM range(2500) t(i) +-- +ok +== +CREATE TABLE list_test AS SELECT [i] l1, case when i%10=0 then null else [case when i%2=0 then 100 + i else null end] end l2 FROM range(2500) t(i) +-- +ok +== +CREATE TABLE medium_list_test AS SELECT + [i, i, i] l1, + case when i%10=0 + then + null + else + [case when i%2=0 then 100 + i else null end, null, case when i%2=0 then null else 100 + i end] + end l2 +FROM range(2500) t(i) +-- +ok +== +CREATE TABLE nested_struct_test AS SELECT {'s1': {'x': i}, 's2': {'s3': {'y': i}, 'l': [i]}} n FROM range(2500) t(i) +-- +ok +== +CREATE TABLE funky_names AS SELECT {'quoted ''"field name"': 42} """quoted col name""" +-- +ok +== +CREATE TABLE map_test AS SELECT MAP {'key'||i: i} AS map_val FROM range(2500) t(i) +-- +ok +== +CREATE TABLE array_test AS SELECT [i, i + 1, i + 2]::INT[3] AS array_val FROM range(2500) t(i) +-- +ok +== +CREATE TABLE partitioned_test AS SELECT range%2 as partition_key, range val FROM range(2500) +-- +ok +== +CREATE TABLE multi_partitioned_test AS SELECT range%2 as partition_key, range % 3 as partition_key2, range val FROM range(2500) +-- +ok +== +CREATE TABLE large_string AS SELECT repeat('A', 254) || '🦆' AS val UNION ALL SELECT repeat('Z', 254) || '🦆' +-- +ok +== +CREATE TABLE large_blob AS SELECT repeat('\x81', 4000)::BLOB AS val UNION ALL SELECT repeat('\x80', 4000)::BLOB +-- +ok +== +CREATE TABLE uuids AS SELECT uuid '47183823-2574-4bfd-b411-99ed177d3e43' uuid_val union all select uuid '00112233-4455-6677-8899-aabbccddeeff'; +-- +ok +== +SET preserve_insertion_order={PRESERVE_INSERTION_ORDER}; +-- +error: Parser Error: syntax error at or near "}" +== +COPY integers TO '{TEST_DIR}/test_copy_to_file.parquet' (RETURN_STATS); +-- +ok +== +COPY bools TO '{TEST_DIR}/test_copy_to_file.parquet' (RETURN_STATS); +-- +ok +== +COPY multi_column_test TO '{TEST_DIR}/multi_column_copy.parquet' (RETURN_STATS); +-- +ok +== +COPY string_test TO '{TEST_DIR}/string_test.parquet' (RETURN_STATS); +-- +ok +== +COPY date_test TO '{TEST_DIR}/date_test.parquet' (RETURN_STATS); +-- +ok +== +COPY empty_test TO '{TEST_DIR}/empty_test.parquet' (RETURN_STATS); +-- +ok +== +COPY blob_test TO '{TEST_DIR}/blob_test.parquet' (RETURN_STATS); +-- +ok +== +COPY decimal_test TO '{TEST_DIR}/decimal_test.parquet' (RETURN_STATS); +-- +ok +== +COPY floating_point_test TO '{TEST_DIR}/fp.parquet' (RETURN_STATS); +-- +ok +== +COPY floating_point_nan TO '{TEST_DIR}/fp_nan.parquet' (RETURN_STATS); +-- +ok +== +COPY fp_nan_only TO '{TEST_DIR}/fp_nan_only.parquet' (RETURN_STATS); +-- +ok +== +COPY large_string TO '{TEST_DIR}/test_large_string.parquet' (RETURN_STATS); +-- +ok +== +COPY large_blob TO '{TEST_DIR}/test_large_blob.parquet' (RETURN_STATS); +-- +ok +== +COPY uuids TO '{TEST_DIR}/test_uuids.parquet' (RETURN_STATS); +-- +ok +== +COPY struct_test TO '{TEST_DIR}/struct_test.parquet' (RETURN_STATS); +-- +ok +== +COPY list_test TO '{TEST_DIR}/list_test.parquet' (RETURN_STATS); +-- +ok +== +COPY medium_list_test TO '{TEST_DIR}/medium_list_test.parquet' (RETURN_STATS); +-- +ok +== +COPY nested_struct_test TO '{TEST_DIR}/nested_struct_test.parquet' (RETURN_STATS); +-- +ok +== +COPY funky_names TO '{TEST_DIR}/funky_names.parquet' (RETURN_STATS); +-- +ok +== +COPY map_test TO '{TEST_DIR}/map_test.parquet' (RETURN_STATS); +-- +ok +== +COPY array_test TO '{TEST_DIR}/array_test.parquet' (RETURN_STATS); +-- +ok +== +COPY partitioned_test TO '{TEST_DIR}/partitioned_test' (FORMAT PARQUET, PARTITION_BY (partition_key), RETURN_STATS, OVERWRITE); +-- +ok +== +COPY multi_partitioned_test TO '{TEST_DIR}/multi_partitioned_test' (FORMAT PARQUET, PARTITION_BY (partition_key, partition_key2), RETURN_STATS, OVERWRITE); +-- +ok +== +COPY (SELECT * EXCLUDE (empty_struct) FROM test_all_types()) TO '{TEST_DIR}/test_all_types.parquet' (RETURN_STATS); +-- +ok +== +COPY integers TO '{TEST_DIR}/test_copy_to_file.csv' (RETURN_STATS); +-- +ok +== +CREATE TABLE decimal128_multi_rg AS SELECT CASE WHEN i < 2048 THEN 126619 ELSE 19308 END::DECIMAL(38,0) AS c FROM range(4096) t(i); +-- +ok +== +COPY decimal128_multi_rg TO '{TEST_DIR}/decimal128_multi_rg.parquet' (FORMAT PARQUET, ROW_GROUP_SIZE 2048, RETURN_STATS); +-- +ok +== diff --git a/parser/testdata/corpus/sql/copy/return_stats_extra_info.test b/parser/testdata/corpus/sql/copy/return_stats_extra_info.test new file mode 100644 index 0000000..af9f8f5 --- /dev/null +++ b/parser/testdata/corpus/sql/copy/return_stats_extra_info.test @@ -0,0 +1,37 @@ +# source: test/sql/copy/return_stats_extra_info.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +CREATE TABLE integers AS SELECT range i FROM range(10000); +-- +ok +== +CREATE TABLE empty_test AS FROM integers LIMIT 0; +-- +ok +== +CREATE TABLE partitioned_test AS SELECT range%2 AS partition_key, range val FROM range(10000); +-- +ok +== +COPY integers TO '{TEST_DIR}/rg_count_single.parquet' (RETURN_STATS); +-- +ok +== +COPY integers TO '{TEST_DIR}/rg_count_multi.parquet' (RETURN_STATS, ROW_GROUP_SIZE 2048); +-- +ok +== +SELECT count(*) FROM parquet_metadata('{TEST_DIR}/rg_count_multi.parquet'); +-- +ok +== +COPY empty_test TO '{TEST_DIR}/rg_count_empty.parquet' (RETURN_STATS); +-- +ok +== +COPY partitioned_test TO '{TEST_DIR}/rg_count_partitioned' (FORMAT PARQUET, PARTITION_BY (partition_key), ROW_GROUP_SIZE 2048, RETURN_STATS, OVERWRITE); +-- +ok +== diff --git a/parser/testdata/corpus/sql/copy/return_stats_truncate.test b/parser/testdata/corpus/sql/copy/return_stats_truncate.test new file mode 100644 index 0000000..685abed --- /dev/null +++ b/parser/testdata/corpus/sql/copy/return_stats_truncate.test @@ -0,0 +1,29 @@ +# source: test/sql/copy/return_stats_truncate.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +COPY (SELECT repeat('\xFF', 300)::BLOB as blob) TO '{TEST_DIR}/test_truncate_blob.parquet' (RETURN_STATS); +-- +ok +== +SELECT min_is_exact, max_is_exact FROM parquet_metadata('{TEST_DIR}/test_truncate_blob.parquet'); +-- +ok +== +COPY (SELECT ('\xFE' || repeat('\xFF', 300))::BLOB as blob) TO '{TEST_DIR}/test_truncate_blob.parquet' (RETURN_STATS); +-- +ok +== +COPY (SELECT repeat('🦆', 300) as str) TO '{TEST_DIR}/test_truncate_string.parquet' (RETURN_STATS); +-- +ok +== +SELECT min_is_exact, max_is_exact FROM parquet_metadata('{TEST_DIR}/test_truncate_string.parquet'); +-- +ok +== +COPY (SELECT 'B' || repeat('🦆', 300) as str) TO '{TEST_DIR}/test_truncate_string.parquet' (RETURN_STATS); +-- +ok +== diff --git a/parser/testdata/corpus/sql/copy/row_groups_per_file.test b/parser/testdata/corpus/sql/copy/row_groups_per_file.test new file mode 100644 index 0000000..90269b8 --- /dev/null +++ b/parser/testdata/corpus/sql/copy/row_groups_per_file.test @@ -0,0 +1,151 @@ +# source: test/sql/copy/row_groups_per_file.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +COPY bigdata TO '{TEST_DIR}/row_groups_per_file1' (FORMAT PARQUET, ROW_GROUP_SIZE 2000, ROW_GROUPS_PER_FILE 1) +-- +ok +== +SELECT count(*) FROM '{TEST_DIR}/row_groups_per_file1/*.parquet' +-- +ok +== +SELECT count(*) FROM glob('{TEST_DIR}/row_groups_per_file1/*.parquet') +-- +ok +== +COPY bigdata TO '{TEST_DIR}/row_groups_per_file2' (FORMAT PARQUET, ROW_GROUP_SIZE 4000, ROW_GROUPS_PER_FILE 1) +-- +ok +== +SELECT count(*) FROM '{TEST_DIR}/row_groups_per_file2/*.parquet' +-- +ok +== +SELECT count(*) FROM glob('{TEST_DIR}/row_groups_per_file2/*.parquet') +-- +ok +== +COPY bigdata TO '{TEST_DIR}/row_groups_per_file3' (FORMAT PARQUET, ROW_GROUP_SIZE 2000, ROW_GROUPS_PER_FILE 2) +-- +ok +== +SELECT count(*) FROM '{TEST_DIR}/row_groups_per_file3/*.parquet' +-- +ok +== +SELECT count(*) FROM glob('{TEST_DIR}/row_groups_per_file3/*.parquet') +-- +ok +== +COPY bigdata TO '{TEST_DIR}/row_groups_per_file_stats/' (FORMAT PARQUET, WRITE_EMPTY_FILE false, FILENAME_PATTERN '{uuid}', ROW_GROUP_SIZE 3000, ROW_GROUPS_PER_FILE 2, RETURN_STATS); +-- +ok +== +COPY bigdata TO '{TEST_DIR}/row_groups_per_file4' (FORMAT PARQUET, ROW_GROUP_SIZE 2000, ROW_GROUPS_PER_FILE 1) +-- +ok +== +SELECT count(*) FROM '{TEST_DIR}/row_groups_per_file4/*.parquet' +-- +ok +== +SELECT count(*) BETWEEN 1 and 10 FROM glob('{TEST_DIR}/row_groups_per_file4/*.parquet') +-- +ok +== +COPY bigdata TO '{TEST_DIR}/row_groups_per_file5' (FORMAT PARQUET, ROW_GROUP_SIZE 4000, ROW_GROUPS_PER_FILE 1) +-- +ok +== +SELECT count(*) FROM '{TEST_DIR}/row_groups_per_file5/*.parquet' +-- +ok +== +SELECT count(*) BETWEEN 1 and 10 FROM glob('{TEST_DIR}/row_groups_per_file5/*.parquet') +-- +ok +== +COPY bigdata TO '{TEST_DIR}/row_groups_per_file6' (FORMAT PARQUET, ROW_GROUP_SIZE 2000, ROW_GROUPS_PER_FILE 2) +-- +ok +== +SELECT count(*) FROM '{TEST_DIR}/row_groups_per_file6/*.parquet' +-- +ok +== +SELECT count(*) BETWEEN 1 and 10 FROM glob('{TEST_DIR}/row_groups_per_file6/*.parquet') +-- +ok +== +COPY bigdata TO '{TEST_DIR}/row_groups_per_file7' (FORMAT PARQUET, PER_THREAD_OUTPUT TRUE, ROW_GROUP_SIZE 2000, ROW_GROUPS_PER_FILE 1) +-- +ok +== +SELECT count(*) FROM '{TEST_DIR}/row_groups_per_file7/*.parquet' +-- +ok +== +SELECT count(*) BETWEEN 1 AND 10 FROM glob('{TEST_DIR}/row_groups_per_file7/*.parquet') +-- +ok +== +COPY bigdata TO '{TEST_DIR}/row_groups_per_file8' (FORMAT PARQUET, PER_THREAD_OUTPUT TRUE, ROW_GROUP_SIZE 4000, ROW_GROUPS_PER_FILE 1) +-- +ok +== +SELECT count(*) FROM '{TEST_DIR}/row_groups_per_file8/*.parquet' +-- +ok +== +SELECT count(*) BETWEEN 1 AND 10 FROM glob('{TEST_DIR}/row_groups_per_file8/*.parquet') +-- +ok +== +COPY bigdata TO '{TEST_DIR}/row_groups_per_file9' (FORMAT PARQUET, PER_THREAD_OUTPUT TRUE, ROW_GROUP_SIZE 2000, ROW_GROUPS_PER_FILE 2) +-- +ok +== +SELECT count(*) FROM '{TEST_DIR}/row_groups_per_file9/*.parquet' +-- +ok +== +SELECT count(*) BETWEEN 1 AND 10 FROM glob('{TEST_DIR}/row_groups_per_file9/*.parquet') +-- +ok +== +COPY bigdata TO '{TEST_DIR}/row_groups_per_file_error' (FORMAT PARQUET, ROW_GROUPS_PER_FILE 1, USE_TMP_FILE TRUE); +-- +ok +== +CREATE TABLE partitioned_bigdata AS +SELECT col_a % 4 AS part, col_a, col_b FROM bigdata; +-- +ok +== +COPY partitioned_bigdata +TO '{TEST_DIR}/row_groups_per_file_partitioned' +(FORMAT PARQUET, ROW_GROUP_SIZE 1000, ROW_GROUPS_PER_FILE 1, PARTITION_BY part); +-- +ok +== +SELECT count(*) +FROM read_parquet('{TEST_DIR}/row_groups_per_file_partitioned/**/*.parquet', hive_partitioning = true); +-- +ok +== +WITH files AS ( + SELECT part, count(DISTINCT filename) file_count + FROM read_parquet( + '{TEST_DIR}/row_groups_per_file_partitioned/**/*.parquet', + filename = true, + hive_partitioning = true + ) + GROUP BY part +) +SELECT min(file_count) > 1 +FROM files; +-- +ok +== diff --git a/parser/testdata/corpus/sql/copy/tmp_file.test b/parser/testdata/corpus/sql/copy/tmp_file.test new file mode 100644 index 0000000..840ec4f --- /dev/null +++ b/parser/testdata/corpus/sql/copy/tmp_file.test @@ -0,0 +1,29 @@ +# source: test/sql/copy/tmp_file.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +copy (select 42 as x) to '{TEST_DIR}/foo'; +-- +ok +== +COPY (SELECT 36) TO '{TEST_DIR}/.a.b'; +-- +ok +== +COPY (SELECT 37 as x) TO '{TEST_DIR}/.a.b'; +-- +ok +== +FROM read_csv('{TEST_DIR}/.a.b'); +-- +ok +== +COPY (SELECT 50) TO '{TEST_DIR}/.a.b.c.d.e..'; +-- +ok +== +COPY (SELECT 51) TO '{TEST_DIR}/.a.b.c.d.e..'; +-- +ok +== diff --git a/parser/testdata/corpus/sql/copy_database/copy_database_different_types.test b/parser/testdata/corpus/sql/copy_database/copy_database_different_types.test new file mode 100644 index 0000000..a19ad56 --- /dev/null +++ b/parser/testdata/corpus/sql/copy_database/copy_database_different_types.test @@ -0,0 +1,65 @@ +# source: test/sql/copy_database/copy_database_different_types.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +ATTACH '{TEST_DIR}/copy_database_different_types.db' AS db1 +-- +ok +== +CREATE TABLE test(a INTEGER, b INTEGER, c VARCHAR(10)); +-- +ok +== +INSERT INTO test VALUES (42, 88, 'hello'); +-- +ok +== +CREATE UNIQUE INDEX i_unique ON test(a); +-- +ok +== +CREATE VIEW v1 AS FROM test; +-- +ok +== +CREATE TYPE mood AS ENUM('ok', 'sad', 'happy'); +-- +ok +== +CREATE TABLE enums(i mood) +-- +ok +== +INSERT INTO enums VALUES ('ok'), ('sad'), (NULL) +-- +ok +== +select * from db1.enums +-- +ok +== +CREATE FUNCTION my_add(a, b) AS a + b +-- +ok +== +ATTACH '{TEST_DIR}/other_copy_database_different_types.db' AS db2; +-- +ok +== +COPY FROM DATABASE db1 TO db2 +-- +ok +== +SELECT * FROM enums; +-- +ok +== +INSERT INTO test VALUES (43, 88, 'hello'); +-- +ok +== +SELECT my_add(1, 2) +-- +ok +== diff --git a/parser/testdata/corpus/sql/copy_database/copy_database_errors.test b/parser/testdata/corpus/sql/copy_database/copy_database_errors.test new file mode 100644 index 0000000..18a461a --- /dev/null +++ b/parser/testdata/corpus/sql/copy_database/copy_database_errors.test @@ -0,0 +1,41 @@ +# source: test/sql/copy_database/copy_database_errors.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +CREATE TABLE db1.test(a INTEGER, b INTEGER, c VARCHAR); +-- +ok +== +INSERT INTO db1.test VALUES (42, 84, 'hello') +-- +ok +== +COPY FROM DATABASE db1 TO db1 +-- +ok +== +ATTACH DATABASE '{TEST_DIR}/read_only.db' AS read_only +-- +ok +== +CREATE TABLE read_only.t(i INT); +-- +ok +== +DETACH read_only +-- +ok +== +ATTACH DATABASE '{TEST_DIR}/read_only.db' AS read_only (READ_ONLY) +-- +ok +== +COPY FROM DATABASE db1 TO read_only +-- +ok +== +COPY FROM DATABASE read_only TO db1 +-- +ok +== diff --git a/parser/testdata/corpus/sql/copy_database/copy_database_fk.test b/parser/testdata/corpus/sql/copy_database/copy_database_fk.test new file mode 100644 index 0000000..f4ed0c5 --- /dev/null +++ b/parser/testdata/corpus/sql/copy_database/copy_database_fk.test @@ -0,0 +1,9 @@ +# source: test/sql/copy_database/copy_database_fk.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +COPY FROM DATABASE memory TO db1 +-- +ok +== diff --git a/parser/testdata/corpus/sql/copy_database/copy_database_gen_col.test b/parser/testdata/corpus/sql/copy_database/copy_database_gen_col.test new file mode 100644 index 0000000..b5c9b48 --- /dev/null +++ b/parser/testdata/corpus/sql/copy_database/copy_database_gen_col.test @@ -0,0 +1,25 @@ +# source: test/sql/copy_database/copy_database_gen_col.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +insert into test VALUES (42); +-- +ok +== +FROM test; +-- +ok +== +ATTACH '{TEST_DIR}/myotherdb.db'; +-- +ok +== +COPY FROM DATABASE mydb TO myotherdb; +-- +ok +== +select * from myotherdb.test; +-- +ok +== diff --git a/parser/testdata/corpus/sql/copy_database/copy_database_index.test b/parser/testdata/corpus/sql/copy_database/copy_database_index.test new file mode 100644 index 0000000..fcecd76 --- /dev/null +++ b/parser/testdata/corpus/sql/copy_database/copy_database_index.test @@ -0,0 +1,41 @@ +# source: test/sql/copy_database/copy_database_index.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +ATTACH '{TEST_DIR}/copy_database_index.db' AS db1; +-- +ok +== +CREATE INDEX i_index ON test(a); +-- +ok +== +INSERT INTO test SELECT range, 88, 'hello' FROM range(10000); +-- +ok +== +EXPLAIN ANALYZE SELECT a, b, c FROM db1.test WHERE a = 42; +-- +ok +== +SELECT a, b, c FROM db1.test WHERE a = 42; +-- +ok +== +ATTACH '{TEST_DIR}/other_copy_database_index.db' AS db2; +-- +ok +== +SELECT * FROM test WHERE a = 42; +-- +ok +== +EXPLAIN ANALYZE SELECT * FROM test WHERE a = 42; +-- +ok +== +DROP INDEX i_index; +-- +ok +== diff --git a/parser/testdata/corpus/sql/copy_database/copy_database_multiple.test b/parser/testdata/corpus/sql/copy_database/copy_database_multiple.test new file mode 100644 index 0000000..5899d44 --- /dev/null +++ b/parser/testdata/corpus/sql/copy_database/copy_database_multiple.test @@ -0,0 +1,17 @@ +# source: test/sql/copy_database/copy_database_multiple.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +CREATE TABLE db1.tbl1 AS FROM range(3) r(i); +-- +ok +== +COPY FROM DATABASE db1 TO db2; +-- +ok +== +FROM db2.tbl1 +-- +ok +== diff --git a/parser/testdata/corpus/sql/copy_database/copy_database_simple.test b/parser/testdata/corpus/sql/copy_database/copy_database_simple.test new file mode 100644 index 0000000..ab66c80 --- /dev/null +++ b/parser/testdata/corpus/sql/copy_database/copy_database_simple.test @@ -0,0 +1,29 @@ +# source: test/sql/copy_database/copy_database_simple.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +ATTACH '{TEST_DIR}/copy_database_simple.db' AS db1 +-- +ok +== +INSERT INTO db1.test VALUES (42, 88, 'hello'); +-- +ok +== +ATTACH '{TEST_DIR}/other_copy_database_simple.db' AS db2; +-- +ok +== +SELECT * FROM db2.test; +-- +ok +== +COPY FROM DATABASE dbxx TO memory +-- +ok +== +COPY FROM DATABASE db1 TO dbxx +-- +ok +== diff --git a/parser/testdata/corpus/sql/copy_database/copy_database_with_index.test b/parser/testdata/corpus/sql/copy_database/copy_database_with_index.test new file mode 100644 index 0000000..dad300e --- /dev/null +++ b/parser/testdata/corpus/sql/copy_database/copy_database_with_index.test @@ -0,0 +1,26 @@ +# source: test/sql/copy_database/copy_database_with_index.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +CREATE TABLE data AS +SELECT i, hash(i)::VARCHAR AS value FROM generate_series(1, 10000) s(i); +-- +ok +== +ALTER TABLE data ALTER COLUMN value SET NOT NULL; +-- +ok +== +CREATE INDEX data_value ON data(value); +-- +ok +== +SELECT database_name, table_name, index_name FROM duckdb_indexes ORDER BY ALL; +-- +ok +== +SELECT database_name, table_name, index_count FROM duckdb_tables ORDER BY ALL; +-- +ok +== diff --git a/parser/testdata/corpus/sql/copy_database/copy_database_with_unique_index.test b/parser/testdata/corpus/sql/copy_database/copy_database_with_unique_index.test new file mode 100644 index 0000000..1b648a2 --- /dev/null +++ b/parser/testdata/corpus/sql/copy_database/copy_database_with_unique_index.test @@ -0,0 +1,49 @@ +# source: test/sql/copy_database/copy_database_with_unique_index.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +ATTACH '{TEST_DIR}/copy_db_old.db' AS old; +-- +ok +== +CREATE TABLE old.items (id INT, uniq INT UNIQUE); +-- +ok +== +INSERT INTO old.items VALUES (1, 1), (2, 2), (3, 3); +-- +ok +== +CREATE UNIQUE INDEX idx_id ON old.items(id); +-- +ok +== +ATTACH '{TEST_DIR}/copy_db_new1.db' AS new1; +-- +ok +== +COPY FROM DATABASE old TO new1 (SCHEMA); +-- +ok +== +COPY FROM DATABASE old TO new1 (DATA); +-- +ok +== +SELECT id, uniq FROM new1.items ORDER BY ALL; +-- +ok +== +INSERT INTO new1.items VALUES (1, 4); +-- +ok +== +INSERT INTO new1.items VALUES (4, 1); +-- +ok +== +DETACH new1; +-- +ok +== diff --git a/parser/testdata/corpus/sql/copy_database/copy_table_with_sequence.test b/parser/testdata/corpus/sql/copy_database/copy_table_with_sequence.test new file mode 100644 index 0000000..cb8849f --- /dev/null +++ b/parser/testdata/corpus/sql/copy_database/copy_table_with_sequence.test @@ -0,0 +1,94 @@ +# source: test/sql/copy_database/copy_table_with_sequence.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +attach '{TEST_DIR}/backup.db'; +-- +ok +== +create sequence seq start 1; +-- +ok +== +create table tbl ( + id int default nextval('seq') +); +-- +ok +== +insert into tbl values (DEFAULT); +insert into tbl values (DEFAULT); +-- +ok +== +copy from database memory to backup; +-- +ok +== +drop sequence seq cascade; +-- +ok +== +select * from backup.tbl; +-- +ok +== +select currval('backup.main.seq'); +-- +ok +== +drop sequence backup.main.seq cascade; +-- +ok +== +create sequence my_schema.seq start 1; +-- +ok +== +create table tbl ( + id int default nextval('my_schema.seq') +); +-- +ok +== +drop sequence my_schema.seq cascade; +-- +ok +== +drop sequence backup.my_schema.seq cascade; +-- +ok +== +create schema backup; +-- +ok +== +create sequence memory.backup.seq start 1; +-- +ok +== +create table tbl ( + id int default nextval('backup.seq') +); +-- +ok +== +drop schema backup cascade; +-- +ok +== +create table tbl ( + id int default nextval('memory.backup.seq') +); +-- +ok +== +drop sequence memory.backup.seq cascade; +-- +ok +== +from duckdb_sequences() +-- +ok +== diff --git a/parser/testdata/corpus/sql/create/create_as.test b/parser/testdata/corpus/sql/create/create_as.test new file mode 100644 index 0000000..64c2b24 --- /dev/null +++ b/parser/testdata/corpus/sql/create/create_as.test @@ -0,0 +1,105 @@ +# source: test/sql/create/create_as.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +CREATE TABLE tbl1 AS SELECT 1; +-- +ok +== +SELECT * FROM tbl1; +-- +ok +== +CREATE TABLE tbl2 AS SELECT 2 AS f; +-- +ok +== +SELECT * FROM tbl2; +-- +ok +== +CREATE OR REPLACE TABLE tbl3 AS SELECT 3; +-- +ok +== +SELECT * FROM tbl3; +-- +ok +== +CREATE TABLE tbl1 AS SELECT 3; +-- +ok +== +CREATE OR REPLACE TABLE tbl1 AS SELECT 4; +-- +ok +== +CREATE OR REPLACE TABLE tbl1 AS SELECT 'hello' UNION ALL SELECT 'world'; +-- +ok +== +CREATE OR REPLACE TABLE tbl1 AS SELECT 5 WHERE false; +-- +ok +== +CREATE TABLE tbl4 IF NOT EXISTS AS SELECT 4; +-- +error: Parser Error: syntax error at or near "IF" +== +CREATE OR REPLACE TABLE tbl4 IF NOT EXISTS AS SELECT 4; +-- +error: Parser Error: syntax error at or near "IF" +== +CREATE TABLE tbl4(col1, col2) AS SELECT 1, 'hello'; +-- +ok +== +SELECT * FROM tbl4; +-- +ok +== +CREATE OR REPLACE TABLE tbl4(col1, col2) AS SELECT 2, 'duck'; +-- +ok +== +CREATE TABLE IF NOT EXISTS tbl5(col1, col2) AS SELECT 3, 'database'; +-- +ok +== +SELECT * FROM tbl5; +-- +ok +== +CREATE OR REPLACE TABLE tbl5(col1, "col need ' quote") AS SELECT 3.5, 'quote'; +-- +ok +== +CREATE TABLE tbl6(col1) AS SELECT 4 ,'mismatch'; +-- +ok +== +SELECT * FROM tbl6; +-- +ok +== +CREATE TABLE tbl7(col1, col2) AS SELECT 5; +-- +ok +== +CREATE TABLE tbl8 AS SELECT 42 WITH NO DATA +-- +ok +== +SELECT COUNT(*) FROM tbl8; +-- +ok +== +CREATE TABLE tbl9 AS SELECT 42 WITH DATA +-- +ok +== +SELECT COUNT(*) FROM tbl9; +-- +ok +== diff --git a/parser/testdata/corpus/sql/create/create_as_issue_11968.test b/parser/testdata/corpus/sql/create/create_as_issue_11968.test new file mode 100644 index 0000000..1270174 --- /dev/null +++ b/parser/testdata/corpus/sql/create/create_as_issue_11968.test @@ -0,0 +1,17 @@ +# source: test/sql/create/create_as_issue_11968.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +CREATE TABLE test (x INTEGER[]); +-- +ok +== +INSERT INTO test SELECT CASE WHEN x <= 520 THEN [0, 0] ELSE [0] END FROM generate_series(1, 2048) s(x); +-- +ok +== +CREATE TABLE test2 AS SELECT x FROM test; +-- +ok +== diff --git a/parser/testdata/corpus/sql/create/create_as_partition_sorted_options.test b/parser/testdata/corpus/sql/create/create_as_partition_sorted_options.test new file mode 100644 index 0000000..91b0a47 --- /dev/null +++ b/parser/testdata/corpus/sql/create/create_as_partition_sorted_options.test @@ -0,0 +1,133 @@ +# source: test/sql/create/create_as_partition_sorted_options.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +CREATE TABLE integers PARTITIONED BY (i) as select range i from range(10); +-- +ok +== +CREATE TABLE integers SORTED BY (i) as select range i from range(10); +-- +ok +== +CREATE TABLE integers PARTITIONED BY (i) SORTED BY (i) as select range i from range(10); +-- +ok +== +CREATE TABLE iceberg_table +WITH ( + 'location' = 's3://amzn-s3-demo-bucket/iceberg-folder', + 'table_type'='ICEBERG', + 'format'='parquet' +) as select range i from range(10); +-- +ok +== +CREATE TABLE iceberg_table +PARTITIONED BY (id) +SORTED BY (date) +WITH ( + location='s3://amzn-s3-demo-bucket/iceberg-folder', + table_type='ICEBERG', + format='parquet' +) +as select range i, range::DATE date from range(10); +-- +ok +== +CREATE TABLE iceberg_table +SORTED BY (date) +WITH ( + location='s3://amzn-s3-demo-bucket/iceberg-folder', + table_type='ICEBERG', + format='parquet' +) +as select range i, range::DATE date from range(10); +-- +ok +== +CREATE TABLE iceberg_table +WITH ( + location='s3://amzn-s3-demo-bucket/iceberg-folder', + table_type='ICEBERG', + format='parquet' +) +as select range i, range::DATE date from range(10); +-- +ok +== +CREATE TABLE iceberg_table +SORTED BY (date) +PARTITIONED BY (id) +WITH ( + location='s3://amzn-s3-demo-bucket/iceberg-folder', + table_type='ICEBERG', + format='parquet' +) +as select range id, range::DATE date from range(10); +-- +ok +== +CREATE TABLE iceberg_table +WITH ( + location='s3://amzn-s3-demo-bucket/iceberg-folder', + table_type='ICEBERG', + format='parquet' +) +SORTED BY (date) +PARTITIONED BY (id) +as select range id, range::DATE date from range(10); +-- +error: Parser Error: syntax error at or near "SORTED" +== +SET VARIABLE location_var='boop' +-- +ok +== +CREATE TABLE iceberg_table +Partitioned by (getvariable('location_var')) +as select range id, range::DATE date from range(10); +-- +ok +== +CREATE TABLE iceberg_table +WITH ( + location=getvariable('location_var'), + table_type='ICEBERG', + format='parquet' +) +as select range id, range::DATE date from range(10); +-- +ok +== +CREATE TABLE iceberg_table +WITH ( + 'location'=getvariable('location_var'), + 'table_type'='ICEBERG', + 'format'='parquet' +) +as select range id, range::DATE date from range(10); +-- +ok +== +CREATE TABLE iceberg_table +WITH ( + 'location', + 'table_type', + 'format' +) +as select range id, range::DATE date from range(10); +-- +ok +== +CREATE TABLE iceberg_table +WITH ( + location, + table_type, + format +) +as select range id, range::DATE date from range(10); +-- +ok +== diff --git a/parser/testdata/corpus/sql/create/create_database.test b/parser/testdata/corpus/sql/create/create_database.test new file mode 100644 index 0000000..1635aa9 --- /dev/null +++ b/parser/testdata/corpus/sql/create/create_database.test @@ -0,0 +1,17 @@ +# source: test/sql/create/create_database.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +CREATE DATABASE mydb; +-- +error: Parser Error: syntax error at or near "DATABASE" +== +CREATE DATABASE mydb FROM './path'; +-- +error: Parser Error: syntax error at or near "DATABASE" +== +DROP DATABASE mydb +-- +error: Parser Error: syntax error at or near "DATABASE" +== diff --git a/parser/testdata/corpus/sql/create/create_index_on_issue_13643.test b/parser/testdata/corpus/sql/create/create_index_on_issue_13643.test new file mode 100644 index 0000000..2ccfe75 --- /dev/null +++ b/parser/testdata/corpus/sql/create/create_index_on_issue_13643.test @@ -0,0 +1,29 @@ +# source: test/sql/create/create_index_on_issue_13643.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +CREATE SCHEMA db0; +-- +ok +== +USE db0; +-- +ok +== +CREATE TABLE t0 (a BIGINT PRIMARY KEY, b INT, c INT); +-- +ok +== +CREATE INDEX t0_idx ON t0 (b); +-- +ok +== +CREATE UNIQUE INDEX t0_uidx ON t0 (c); +-- +ok +== +CREATE UNIQUE INDEX t0_uidx2 ON db0.t0 (c); +-- +ok +== diff --git a/parser/testdata/corpus/sql/create/create_objects_readonly.test b/parser/testdata/corpus/sql/create/create_objects_readonly.test new file mode 100644 index 0000000..1eab297 --- /dev/null +++ b/parser/testdata/corpus/sql/create/create_objects_readonly.test @@ -0,0 +1,29 @@ +# source: test/sql/create/create_objects_readonly.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +create table t1 as select 'c1' as c1 +-- +ok +== +CREATE schema s2; +-- +ok +== +CREATE view v1 AS SELECT * FROM range(10) t(i); +-- +ok +== +CREATE macro add(a, b) AS a + b; +-- +ok +== +CREATE TYPE mood AS ENUM ('happy', 'sad', 'curious'); +-- +ok +== +CREATE SEQUENCE serial START 101; +-- +ok +== diff --git a/parser/testdata/corpus/sql/create/create_or_replace.test b/parser/testdata/corpus/sql/create/create_or_replace.test new file mode 100644 index 0000000..a31c00f --- /dev/null +++ b/parser/testdata/corpus/sql/create/create_or_replace.test @@ -0,0 +1,29 @@ +# source: test/sql/create/create_or_replace.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +CREATE OR REPLACE TABLE integers(i INTEGER, j INTEGER) +-- +ok +== +CREATE VIEW integers2 AS SELECT 42 +-- +ok +== +CREATE OR REPLACE TABLE integers2(i INTEGER) +-- +ok +== +CREATE TABLE IF NOT EXISTS integers(i INTEGER) +-- +ok +== +INSERT INTO integers VALUES (1, 2); +-- +ok +== +CREATE OR REPLACE TABLE IF NOT EXISTS integers(i INTEGER) +-- +error: Parser Error: Cannot specify both OR REPLACE and IF NOT EXISTS within single create statement +== diff --git a/parser/testdata/corpus/sql/create/create_or_replace.test.metadata.json b/parser/testdata/corpus/sql/create/create_or_replace.test.metadata.json new file mode 100644 index 0000000..89f2d46 --- /dev/null +++ b/parser/testdata/corpus/sql/create/create_or_replace.test.metadata.json @@ -0,0 +1,5 @@ +{ + "todo": { + "bc94bef0d55f8b17": "transformer-raised parser error: upstream rejects in the transformer, not the grammar; expected to clear as transformers land (milestones 3-5)" + } +} diff --git a/parser/testdata/corpus/sql/create/create_table_as_duplicate_names.test b/parser/testdata/corpus/sql/create/create_table_as_duplicate_names.test new file mode 100644 index 0000000..97edf8c --- /dev/null +++ b/parser/testdata/corpus/sql/create/create_table_as_duplicate_names.test @@ -0,0 +1,53 @@ +# source: test/sql/create/create_table_as_duplicate_names.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +SELECT * FROM range(5) tbl1(i) JOIN range(5) tbl2(i) ON tbl1.i=tbl2.i; +-- +ok +== +SELECT i, i FROM range(5) tbl(i) +-- +ok +== +SELECT * FROM (SELECT i, i FROM range(5) tbl(i)) tbl; +-- +ok +== +SELECT * FROM (SELECT i, i, i, i FROM range(5) tbl(i)) tbl; +-- +ok +== +CREATE TABLE t1 AS SELECT i, i FROM range(5) tbl(i) +-- +ok +== +SELECT * FROM t1; +-- +ok +== +CREATE TABLE t2 AS SELECT i, i, i, i FROM range(5) tbl(i) +-- +ok +== +SELECT * FROM (SELECT * FROM range(5) tbl1(i) JOIN range(5) tbl2(i) ON tbl1.i=tbl2.i) tbl; +-- +ok +== +CREATE TABLE t3 AS SELECT tbl1.i, tbl2.i FROM range(5) tbl1(i) JOIN range(5) tbl2(i) ON tbl1.i=tbl2.i; +-- +ok +== +SELECT * FROM t3 +-- +ok +== +CREATE TABLE t4 AS SELECT * FROM range(5) tbl1(i) JOIN range(5) tbl2(i) ON tbl1.i=tbl2.i; +-- +ok +== +SELECT * FROM t4 +-- +ok +== diff --git a/parser/testdata/corpus/sql/create/create_table_as_error.test b/parser/testdata/corpus/sql/create/create_table_as_error.test new file mode 100644 index 0000000..15e91b4 --- /dev/null +++ b/parser/testdata/corpus/sql/create/create_table_as_error.test @@ -0,0 +1,9 @@ +# source: test/sql/create/create_table_as_error.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +CREATE TABLE tbl AS EXECUTE tbl; +-- +error: Parser Error: CREATE TABLE AS requires a SELECT clause +== diff --git a/parser/testdata/corpus/sql/create/create_table_as_error.test.metadata.json b/parser/testdata/corpus/sql/create/create_table_as_error.test.metadata.json new file mode 100644 index 0000000..c4c860e --- /dev/null +++ b/parser/testdata/corpus/sql/create/create_table_as_error.test.metadata.json @@ -0,0 +1,5 @@ +{ + "todo": { + "d611cbbbda4a5820": "transformer-raised parser error: upstream rejects in the transformer, not the grammar; expected to clear as transformers land (milestones 3-5)" + } +} diff --git a/parser/testdata/corpus/sql/create/create_table_compression.test b/parser/testdata/corpus/sql/create/create_table_compression.test new file mode 100644 index 0000000..7ca8ca0 --- /dev/null +++ b/parser/testdata/corpus/sql/create/create_table_compression.test @@ -0,0 +1,93 @@ +# source: test/sql/create/create_table_compression.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +CREATE TABLE T (a INTEGER USING COMPRESSION RLE) +-- +ok +== +DROP TABLE T +-- +ok +== +CREATE TABLE T (a INTEGER USING COMPRESSION 'bla') +-- +ok +== +CREATE TABLE T (a INTEGER USING COMPRESSION ) +-- +error: Parser Error: syntax error at or near ")" +== +CREATE TABLE T (a INTEGER NOT NULL USING COMPRESSION ) +-- +error: Parser Error: syntax error at or near ")" +== +CREATE TABLE T (a INTEGER USING COMPRESSION bla) +-- +ok +== +CREATE TABLE T (a INTEGER NOT NULL USING COMPRESSION RLE) +-- +ok +== +CREATE TABLE T (a INTEGER USING COMPRESSION RLE, b VARCHAR ) +-- +ok +== +CREATE TABLE T (a INTEGER USING COMPRESSION RLE, b INTEGER USING COMPRESSION BITPACKING, C INTEGER USING COMPRESSION UNCOMPRESSED) +-- +ok +== +INSERT INTO T VALUES (1,1,1), (1,1,1), (1,1,1), (2,2,2), (2,2,2), (3,3,3) +-- +ok +== +SELECT * FROM T +-- +ok +== +SELECT compression FROM pragma_storage_info('T') WHERE segment_type ILIKE 'INTEGER' LIMIT 3 +-- +ok +== +ALTER TABLE T RENAME COLUMN a TO a_1 +-- +ok +== +ALTER TABLE T RENAME COLUMN b TO b_1 +-- +ok +== +ALTER TABLE T RENAME COLUMN c TO c_1 +-- +ok +== +ALTER TABLE T RENAME TO T_1 +-- +ok +== +SELECT * FROM T_1 +-- +ok +== +SELECT compression FROM pragma_storage_info('T_1') WHERE segment_type ILIKE 'INTEGER' LIMIT 3 +-- +ok +== +ALTER TABLE T_1 DROP COLUMN c_1 +-- +ok +== +ALTER TABLE T_1 DROP COLUMN b_1 +-- +ok +== +SELECT compression FROM pragma_storage_info('T_1') WHERE segment_type ILIKE 'INTEGER' LIMIT 2 +-- +ok +== +ALTER TABLE T_1 ADD COLUMN b INTEGER DEFAULT 2 +-- +ok +== diff --git a/parser/testdata/corpus/sql/create/create_table_empty_name.test b/parser/testdata/corpus/sql/create/create_table_empty_name.test new file mode 100644 index 0000000..bc64903 --- /dev/null +++ b/parser/testdata/corpus/sql/create/create_table_empty_name.test @@ -0,0 +1,13 @@ +# source: test/sql/create/create_table_empty_name.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +CREATE TABLE '' AS SELECT 42; +-- +error: Parser Error: Empty table name not supported +== +CREATE TABLE s1.""(i INTEGER); +-- +error: Parser Error: zero-length delimited identifier +== diff --git a/parser/testdata/corpus/sql/create/create_table_empty_name.test.metadata.json b/parser/testdata/corpus/sql/create/create_table_empty_name.test.metadata.json new file mode 100644 index 0000000..e58eca0 --- /dev/null +++ b/parser/testdata/corpus/sql/create/create_table_empty_name.test.metadata.json @@ -0,0 +1,5 @@ +{ + "todo": { + "6d38638491130c28": "transformer-raised parser error: upstream rejects in the transformer, not the grammar; expected to clear as transformers land (milestones 3-5)" + } +} diff --git a/parser/testdata/corpus/sql/create/create_table_extra_options.test b/parser/testdata/corpus/sql/create/create_table_extra_options.test new file mode 100644 index 0000000..c8938a3 --- /dev/null +++ b/parser/testdata/corpus/sql/create/create_table_extra_options.test @@ -0,0 +1,164 @@ +# source: test/sql/create/create_table_extra_options.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +CREATE TABLE integers(i INTEGER) PARTITIONED BY (i); +-- +ok +== +CREATE TABLE integers(i INTEGER) SORTED BY (i); +-- +ok +== +CREATE TABLE integers(i INTEGER) PARTITIONED BY (i) SORTED BY (i); +-- +ok +== +CREATE TABLE iceberg_table ( + id int, + data string, + category string) +WITH ( + 'location' = 's3://amzn-s3-demo-bucket/iceberg-folder', + 'table_type'='ICEBERG', + 'format'='parquet' +); +-- +ok +== +CREATE TABLE iceberg_table ( + id int, + data string, + category string) +WITH ( + location = 's3://amzn-s3-demo-bucket/iceberg-folder', + table_type = 'ICEBERG', + format = 'parquet' +); +-- +ok +== +CREATE TABLE iceberg_table ( + id int, + data string, + category string) +PARTITIONED BY (id) +SORTED BY (date) +WITH ( + location='s3://amzn-s3-demo-bucket/iceberg-folder', + table_type='ICEBERG', + format='parquet' +); +-- +ok +== +CREATE TABLE iceberg_table ( + id int, + data string, + category string) +SORTED BY (date) +WITH ( + location='s3://amzn-s3-demo-bucket/iceberg-folder', + table_type='ICEBERG', + format='parquet' +); +-- +ok +== +CREATE TABLE iceberg_table ( + id int, + data string, + category string) +WITH ( + location='s3://amzn-s3-demo-bucket/iceberg-folder', + table_type='ICEBERG', + format='parquet' +); +-- +ok +== +CREATE TABLE iceberg_table ( + id int, + data string, + category string) +SORTED BY (date) +PARTITIONED BY (id) +WITH ( + location='s3://amzn-s3-demo-bucket/iceberg-folder', + table_type='ICEBERG', + format='parquet' +); +-- +ok +== +CREATE TABLE iceberg_table ( + id int, + data string, + category string) +WITH ( + location='s3://amzn-s3-demo-bucket/iceberg-folder', + table_type='ICEBERG', + format='parquet' +) +SORTED BY (date) +PARTITIONED BY (id); +-- +error: Parser Error: syntax error at or near "SORTED" +== +CREATE TABLE iceberg_table ( + id int, + data string, + category string) +Partitioned by (getvariable('location_var')); +-- +ok +== +CREATE TABLE iceberg_table ( + id int, + data string, + category string) +WITH ( + location=getvariable('location_var'), + table_type='ICEBERG', + format='parquet' +) +-- +ok +== +CREATE TABLE iceberg_table ( + id int, + data string, + category string) +WITH ( + 'location'=getvariable('location_var'), + 'table_type'='ICEBERG', + 'format'='parquet' +) +-- +ok +== +CREATE TABLE iceberg_table ( + id int, + data string, + category string) +WITH ( + 'location', + 'table_type', + 'format' +) +-- +ok +== +CREATE TABLE iceberg_table ( + id int, + data string, + category string) +WITH ( + location, + table_type, + format +) +-- +ok +== diff --git a/parser/testdata/corpus/sql/create/create_table_with_arraybounds.test b/parser/testdata/corpus/sql/create/create_table_with_arraybounds.test new file mode 100644 index 0000000..6bf40ed --- /dev/null +++ b/parser/testdata/corpus/sql/create/create_table_with_arraybounds.test @@ -0,0 +1,59 @@ +# source: test/sql/create/create_table_with_arraybounds.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +create table T ( + vis enum ('hide', 'visible')[] +); +-- +ok +== +select column_type from (describe T); +-- +ok +== +create schema schema2; +-- +ok +== +create schema db2.schema3; +-- +ok +== +create type schema2.foo as VARCHAR; +-- +ok +== +create type db2.schema3.bar as BOOL; +-- +ok +== +create table B ( + vis schema2.foo[] +); +-- +ok +== +insert into b values (['foo', 'bar']); +-- +ok +== +from b; +-- +ok +== +create table C ( + vis db2.schema3.bar[] +); +-- +ok +== +insert into C values ([true]); +-- +ok +== +select typeof(vis) from C; +-- +ok +== diff --git a/parser/testdata/corpus/sql/create/create_using_index.test b/parser/testdata/corpus/sql/create/create_using_index.test new file mode 100644 index 0000000..559fd80 --- /dev/null +++ b/parser/testdata/corpus/sql/create/create_using_index.test @@ -0,0 +1,9 @@ +# source: test/sql/create/create_using_index.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +CREATE TABLE t0 (i INT, CONSTRAINT any_constraint UNIQUE USING INDEX any_non_existed_index); +-- +error: Parser Error: syntax error at or near "USING" +== diff --git a/parser/testdata/corpus/sql/cte/cte_bc.test b/parser/testdata/corpus/sql/cte/cte_bc.test new file mode 100644 index 0000000..c1db848 --- /dev/null +++ b/parser/testdata/corpus/sql/cte/cte_bc.test @@ -0,0 +1,25 @@ +# source: test/sql/cte/cte_bc.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +ATTACH '{TEST_DIR}/cte_v1.db' (READ_ONLY) +-- +ok +== +ATTACH '{TEST_DIR}/cte_v1_4.db' (READ_ONLY) +-- +ok +== +FROM {cte_db}.v1 +-- +error: Parser Error: syntax error at or near "{" +== +FROM {cte_db}.v2 +-- +error: Parser Error: syntax error at or near "{" +== +FROM {cte_db}.v3 +-- +error: Parser Error: syntax error at or near "{" +== diff --git a/parser/testdata/corpus/sql/cte/cte_colname_issue_10074.test b/parser/testdata/corpus/sql/cte/cte_colname_issue_10074.test new file mode 100644 index 0000000..bc723aa --- /dev/null +++ b/parser/testdata/corpus/sql/cte/cte_colname_issue_10074.test @@ -0,0 +1,15 @@ +# source: test/sql/cte/cte_colname_issue_10074.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +create table t as with q(id,s) as (values(1,42)), +a(s)as materialized(select 42) +select id from q join a on q.s=a.s +-- +ok +== +select id from t +-- +ok +== diff --git a/parser/testdata/corpus/sql/cte/cte_describe.test b/parser/testdata/corpus/sql/cte/cte_describe.test new file mode 100644 index 0000000..5a868c0 --- /dev/null +++ b/parser/testdata/corpus/sql/cte/cte_describe.test @@ -0,0 +1,29 @@ +# source: test/sql/cte/cte_describe.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +DESCRIBE select 42 AS a +-- +ok +== +with cte as (select 42 AS a) FROM (DESCRIBE TABLE cte) +-- +ok +== +SUMMARIZE select 42 AS a +-- +ok +== +with cte as (select 42 AS a) FROM (SUMMARIZE TABLE cte) +-- +ok +== +with cte as (select 42 AS a) (DESCRIBE TABLE cte) +-- +error: Parser Error: DESCRIBE with CTE not allowed - wrap the statement in a subquery instead +== +(DESCRIBE TABLE cte) ORDER BY 1 +-- +error: Parser Error: DESCRIBE with ORDER BY not allowed - wrap the statement in a subquery instead +== diff --git a/parser/testdata/corpus/sql/cte/cte_describe.test.metadata.json b/parser/testdata/corpus/sql/cte/cte_describe.test.metadata.json new file mode 100644 index 0000000..4866695 --- /dev/null +++ b/parser/testdata/corpus/sql/cte/cte_describe.test.metadata.json @@ -0,0 +1,6 @@ +{ + "todo": { + "03100e0115b4a66b": "transformer-raised parser error: upstream rejects in the transformer, not the grammar; expected to clear as transformers land (milestones 3-5)", + "e993403701548ead": "transformer-raised parser error: upstream rejects in the transformer, not the grammar; expected to clear as transformers land (milestones 3-5)" + } +} diff --git a/parser/testdata/corpus/sql/cte/cte_issue_17311.test b/parser/testdata/corpus/sql/cte/cte_issue_17311.test new file mode 100644 index 0000000..15bfaa3 --- /dev/null +++ b/parser/testdata/corpus/sql/cte/cte_issue_17311.test @@ -0,0 +1,16 @@ +# source: test/sql/cte/cte_issue_17311.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +CREATE RECURSIVE VIEW nums (n) AS + VALUES (1) +UNION ALL + SELECT n+1 FROM nums WHERE n < 5; +-- +ok +== +FROM nums +-- +ok +== diff --git a/parser/testdata/corpus/sql/cte/cte_null_values.test b/parser/testdata/corpus/sql/cte/cte_null_values.test new file mode 100644 index 0000000..2baa311 --- /dev/null +++ b/parser/testdata/corpus/sql/cte/cte_null_values.test @@ -0,0 +1,12 @@ +# source: test/sql/cte/cte_null_values.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +WITH + cte1 AS (SELECT NULL AS y), + cte1_filter AS (SELECT y FROM cte1 WHERE y < '2025-12-01'::TIMESTAMPTZ) +SELECT * FROM cte1_filter; +-- +ok +== diff --git a/parser/testdata/corpus/sql/cte/cte_on_conflict_issue.test b/parser/testdata/corpus/sql/cte/cte_on_conflict_issue.test new file mode 100644 index 0000000..fd6d493 --- /dev/null +++ b/parser/testdata/corpus/sql/cte/cte_on_conflict_issue.test @@ -0,0 +1,32 @@ +# source: test/sql/cte/cte_on_conflict_issue.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +CREATE TABLE t1 ( + t1c1 BIGINT, + t1c2 BIGINT, + PRIMARY KEY (t1c1, t1c2) +); +-- +ok +== +CREATE TABLE t2 ( + t2c1 BIGINT +); +-- +ok +== +WITH +cte1 AS ( + SELECT 42 AS cte1c1, [84] AS cte1c2 +), +cte2 AS ( + SELECT * + FROM t2 s +) +INSERT OR REPLACE INTO t1 +SELECT * FROM cte2; +-- +ok +== diff --git a/parser/testdata/corpus/sql/cte/cte_schema.test b/parser/testdata/corpus/sql/cte/cte_schema.test new file mode 100644 index 0000000..5fa5188 --- /dev/null +++ b/parser/testdata/corpus/sql/cte/cte_schema.test @@ -0,0 +1,18 @@ +# source: test/sql/cte/cte_schema.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +create table s1.tbl(a varchar); +-- +ok +== +insert into s1.tbl values ('hello'); +-- +ok +== +with tbl as (select 'world' b) +select * from s1.tbl, tbl; +-- +ok +== diff --git a/parser/testdata/corpus/sql/cte/cte_with_replacement_scan.test b/parser/testdata/corpus/sql/cte/cte_with_replacement_scan.test new file mode 100644 index 0000000..f34c800 --- /dev/null +++ b/parser/testdata/corpus/sql/cte/cte_with_replacement_scan.test @@ -0,0 +1,16 @@ +# source: test/sql/cte/cte_with_replacement_scan.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +copy (select 42 as answer) to '{TEST_DIR}/df.parquet'; +-- +ok +== +WITH '{TEST_DIR}/df.parquet' AS ( + SELECT answer FROM '{TEST_DIR}/df.parquet' +) +SELECT * FROM '{TEST_DIR}/df.parquet'; +-- +ok +== diff --git a/parser/testdata/corpus/sql/cte/dml_cte.test b/parser/testdata/corpus/sql/cte/dml_cte.test new file mode 100644 index 0000000..2d218f4 --- /dev/null +++ b/parser/testdata/corpus/sql/cte/dml_cte.test @@ -0,0 +1,706 @@ +# source: test/sql/cte/dml_cte.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +CREATE TABLE t (i INTEGER, j INTEGER); +-- +ok +== +CREATE TABLE dml_exchange_t (i INTEGER); +-- +ok +== +WITH ins AS MATERIALIZED ( + INSERT INTO dml_exchange_t SELECT i::INTEGER FROM range(10000) tbl(i) RETURNING i +) +SELECT * FROM ins LIMIT 5; +-- +ok +== +SELECT count(*) FROM dml_exchange_t; +-- +ok +== +EXPLAIN WITH ins AS MATERIALIZED ( + INSERT INTO dml_exchange_t SELECT i::INTEGER FROM range(3) tbl(i) RETURNING i +) +SELECT * FROM ins LIMIT 1; +-- +ok +== +TRUNCATE dml_exchange_t; +-- +ok +== +WITH ins AS MATERIALIZED ( + INSERT INTO dml_exchange_t SELECT i::INTEGER FROM range(10000) tbl(i) RETURNING i +) +SELECT (SELECT count(*) FROM (SELECT * FROM ins LIMIT 1)), + (SELECT count(*) FROM (SELECT * FROM ins LIMIT 1)); +-- +ok +== +WITH ins AS ( + INSERT INTO t VALUES (1, 10), (2, 20) RETURNING i +) +SELECT * FROM ins; +-- +ok +== +SELECT * FROM t; +-- +ok +== +WITH del AS ( + DELETE FROM t WHERE i = 1 RETURNING i +) +SELECT * FROM del; +-- +ok +== +WITH upd AS ( + UPDATE t SET j = 99 WHERE i = 2 RETURNING i, j +) +SELECT * FROM upd; +-- +ok +== +INSERT INTO t VALUES (10, 100); +-- +ok +== +WITH ins AS ( + INSERT INTO t VALUES (20, 200) RETURNING i, j +) +SELECT t.i, t.j FROM t; +-- +ok +== +INSERT INTO t VALUES (1, 1), (2, 2), (3, 3); +-- +ok +== +WITH + del AS (DELETE FROM t WHERE i = 1 RETURNING i), + remaining AS (SELECT i FROM t) +SELECT * FROM remaining; +-- +ok +== +WITH ins AS ( + INSERT INTO t VALUES (42, 42) RETURNING i +) +SELECT * FROM ins; +-- +ok +== +WITH ins AS (INSERT INTO t VALUES (99, 99)) +SELECT 1; +-- +ok +== +SELECT * FROM t WHERE i = 99; +-- +ok +== +INSERT INTO t VALUES (77, 77); +-- +ok +== +WITH del AS (DELETE FROM t WHERE i = 77) +SELECT 1; +-- +ok +== +SELECT count(*) FROM t WHERE i = 77; +-- +ok +== +WITH ins AS (INSERT INTO t VALUES (55, 55)) +SELECT 1 AS x FROM ins; +-- +ok +== +SELECT * FROM t WHERE i = 55; +-- +ok +== +CREATE TABLE multiplier (k INTEGER); +-- +ok +== +INSERT INTO multiplier VALUES (10); +-- +ok +== +WITH m AS (INSERT INTO multiplier VALUES (20) RETURNING k) +UPDATE t SET j = t.i * m.k FROM m WHERE t.i <= 2 +RETURNING i, j; +-- +ok +== +SELECT * FROM multiplier; +-- +ok +== +INSERT INTO t VALUES (1, 10), (2, 20), (3, 30); +-- +ok +== +CREATE TABLE to_delete (v INTEGER); +-- +ok +== +INSERT INTO to_delete VALUES (2); +-- +ok +== +WITH extra AS (INSERT INTO to_delete VALUES (3) RETURNING v) +DELETE FROM t WHERE i IN (SELECT v FROM extra) +RETURNING i; +-- +ok +== +PREPARE dml_prepared AS + WITH ins AS (INSERT INTO t VALUES ($1, $2) RETURNING i) + SELECT * FROM ins; +-- +ok +== +EXECUTE dml_prepared(7, 77); +-- +ok +== +SELECT * FROM t WHERE i = 7; +-- +ok +== +CREATE TABLE src (v INTEGER); +-- +ok +== +INSERT INTO src VALUES (100), (200); +-- +ok +== +WITH ins AS ( + INSERT INTO t SELECT v, v * 2 FROM src RETURNING i +) +SELECT * FROM ins; +-- +ok +== +WITH cte AS (CREATE TABLE forbidden (i INT)) SELECT 1; +-- +error: Parser Error: A CTE body must be a SELECT, INSERT, UPDATE, DELETE, or COPY TO statement +== +WITH cte AS (DROP TABLE forbidden) SELECT 1; +-- +error: Parser Error: A CTE body must be a SELECT, INSERT, UPDATE, DELETE, or COPY TO statement +== +WITH cte AS (ALTER TABLE t ADD COLUMN x INT) SELECT 1; +-- +error: Parser Error: A CTE body must be a SELECT, INSERT, UPDATE, DELETE, or COPY TO statement +== +WITH RECURSIVE ins AS (INSERT INTO t VALUES (1, 2) RETURNING i) SELECT * FROM ins; +-- +error: Parser Error: Recursive CTEs with DML statements are not supported +== +WITH RECURSIVE upd AS (UPDATE t SET j = 0 RETURNING i) SELECT * FROM upd; +-- +error: Parser Error: Recursive CTEs with DML statements are not supported +== +WITH RECURSIVE del AS (DELETE FROM t RETURNING i) SELECT * FROM del; +-- +error: Parser Error: Recursive CTEs with DML statements are not supported +== +CREATE TABLE t1 (i INTEGER, j INTEGER); +-- +ok +== +CREATE TABLE t_aux (i INTEGER, j INTEGER); +-- +ok +== +WITH ins1 AS (INSERT INTO t1 VALUES (1, 10) RETURNING i), + ins2 AS (INSERT INTO t_aux VALUES (2, 20) RETURNING i) +SELECT * FROM ins1 +UNION ALL +SELECT * FROM ins2; +-- +ok +== +SELECT * FROM t_aux; +-- +ok +== +TRUNCATE t_aux; +-- +ok +== +INSERT INTO t1 VALUES (1, 10), (2, 20), (3, 30); +-- +ok +== +WITH ins AS (INSERT INTO t_aux VALUES (99, 99) RETURNING i), + del AS (DELETE FROM t1 WHERE i <= 2 RETURNING i) +SELECT * FROM del; +-- +ok +== +INSERT INTO t1 VALUES (1, 10), (2, 20); +-- +ok +== +WITH ins AS (INSERT INTO t_aux VALUES (5, 50) RETURNING i), + upd AS (UPDATE t1 SET j = j * 10 RETURNING i) +SELECT * FROM ins; +-- +ok +== +INSERT INTO t_aux VALUES (10, 100), (20, 200); +-- +ok +== +WITH upd AS (UPDATE t1 SET j = 0 RETURNING i), + del AS (DELETE FROM t_aux WHERE i = 10 RETURNING i) +SELECT * FROM del; +-- +ok +== +CREATE TABLE t3 (i INTEGER); +-- +ok +== +WITH ins1 AS (INSERT INTO t1 VALUES (1, 10) RETURNING i), + ins2 AS (INSERT INTO t_aux VALUES (2, 20) RETURNING i), + ins3 AS (INSERT INTO t3 VALUES (3) RETURNING i) +SELECT * FROM ins1 +UNION ALL SELECT * FROM ins2 +UNION ALL SELECT * FROM ins3; +-- +ok +== +INSERT INTO t_aux VALUES (1, 10), (2, 20), (3, 30); +-- +ok +== +WITH ins AS (INSERT INTO t1 VALUES (1, 100), (2, 200) RETURNING i), + del AS (DELETE FROM t_aux WHERE i IN (SELECT i FROM ins) RETURNING i) +SELECT * FROM del; +-- +ok +== +WITH ins AS (INSERT INTO t1 VALUES (1, 10)), + del AS (DELETE FROM t_aux) +SELECT 1; +-- +ok +== +SELECT count(*) FROM t_aux; +-- +ok +== +INSERT INTO t1 VALUES (10, 100); +-- +ok +== +WITH ins AS (INSERT INTO t1 VALUES (1, 10) RETURNING i), + del AS (DELETE FROM t1 WHERE i = 1 RETURNING i) +SELECT 1; +-- +ok +== +WITH ins1 AS (INSERT INTO t1 VALUES (1, 10) RETURNING i), + ins2 AS (INSERT INTO t1 VALUES (2, 20) RETURNING i) +SELECT * FROM ins1 UNION ALL SELECT * FROM ins2; +-- +ok +== +WITH ins AS (INSERT INTO t1 VALUES (1, 10), (2, 20) RETURNING i), + sel AS (SELECT * FROM t1) +SELECT sel.* FROM sel; +-- +ok +== +WITH ins AS (INSERT INTO t1 VALUES (1, 10), (2, 20) RETURNING i), + sel AS MATERIALIZED (SELECT * FROM t1) +SELECT count(*) FROM sel; +-- +ok +== +WITH ins AS (INSERT INTO t1 VALUES (1, 10), (2, 20)), + upd AS (UPDATE t1 SET j = j + 1) +SELECT 1; +-- +ok +== +SELECT i, j FROM t1; +-- +ok +== +WITH ins1 AS (INSERT INTO t1 VALUES (1, 10)), + ins2 AS (INSERT INTO t_aux VALUES (2, 20)) +SELECT 42; +-- +ok +== +WITH ins1 AS (INSERT INTO t1 VALUES (1, 10) RETURNING i), + ins2 AS (INSERT INTO t_aux VALUES (2, 20)) +SELECT * FROM ins1; +-- +ok +== +WITH ins1 AS (INSERT INTO t1 VALUES (1, 10)), + ins2 AS (INSERT INTO t_aux VALUES (2, 20)) +SELECT 1; +-- +ok +== +SELECT count(*) FROM t1; +-- +ok +== +CREATE TABLE t_unique (i INTEGER UNIQUE); +-- +ok +== +INSERT INTO t_unique VALUES (1); +-- +ok +== +WITH ins1 AS (INSERT INTO t1 VALUES (1, 10)), + ins2 AS (INSERT INTO t_unique VALUES (1)) +SELECT 1; +-- +ok +== +DROP TABLE t_unique; +-- +ok +== +PREPARE multi_dml AS + WITH ins1 AS (INSERT INTO t1 VALUES ($1, $2) RETURNING i), + ins2 AS (INSERT INTO t_aux VALUES ($3, $4) RETURNING i) + SELECT * FROM ins1 UNION ALL SELECT * FROM ins2; +-- +ok +== +EXECUTE multi_dml(1, 10, 2, 20); +-- +ok +== +DEALLOCATE multi_dml; +-- +ok +== +WITH ins1 AS MATERIALIZED (INSERT INTO t1 VALUES (1, 10) RETURNING i), + ins2 AS MATERIALIZED (INSERT INTO t_aux VALUES (2, 20) RETURNING i) +SELECT * FROM ins1 UNION ALL SELECT * FROM ins2; +-- +ok +== +INSERT INTO t_aux VALUES (100, 1000); +-- +ok +== +WITH ins AS (INSERT INTO t_aux VALUES (200, 2000) RETURNING i), + del AS (DELETE FROM t1 WHERE i = 1 RETURNING i) +UPDATE t1 SET j = j + 1 WHERE i = 2 RETURNING *; +-- +ok +== +INSERT INTO t_aux VALUES (5, 50); +-- +ok +== +WITH sel AS (SELECT * FROM t_aux), + ins1 AS (INSERT INTO t1 VALUES (1, 10) RETURNING i), + ins2 AS (INSERT INTO t1 VALUES (2, 20) RETURNING i) +SELECT * FROM ins1 UNION ALL SELECT * FROM ins2; +-- +ok +== +INSERT INTO t1 VALUES (1, 10), (2, 20), (3, 30), (4, 40); +-- +ok +== +WITH upd1 AS (UPDATE t1 SET j = j + 1 WHERE i <= 2 RETURNING i, j), + upd2 AS (UPDATE t1 SET j = j * 2 WHERE i <= 2 RETURNING i, j) +SELECT 'upd1', i, j FROM upd1 +UNION ALL +SELECT 'upd2', i, j FROM upd2; +-- +ok +== +WITH del1 AS (DELETE FROM t1 WHERE i <= 2 RETURNING i, j), + del2 AS (DELETE FROM t1 WHERE i <= 2 RETURNING i, j) +SELECT 'del1', i, j FROM del1 +UNION ALL +SELECT 'del2', i, j FROM del2; +-- +ok +== +WITH upd_even AS (UPDATE t1 SET j = j + 100 WHERE i % 2 = 0 RETURNING i, j), + del_odd AS (DELETE FROM t1 WHERE i % 2 = 1 RETURNING i, j) +SELECT * FROM upd_even UNION ALL SELECT * FROM del_odd; +-- +ok +== +WITH ins AS (INSERT INTO t1 VALUES (1, 10), (2, 20) RETURNING i, j), + upd AS (UPDATE t1 SET j = j + 1 RETURNING i, j) +SELECT * FROM ins; +-- +ok +== +WITH ins AS (INSERT INTO t1 VALUES (1, 10), (2, 20) RETURNING i, j), + upd AS (UPDATE t1 SET j = j + 1 RETURNING i, j), + del AS (DELETE FROM t1 WHERE i = 1 RETURNING i, j) +SELECT * FROM ins; +-- +ok +== +WITH ins AS (INSERT INTO t1 VALUES (1, 10), (2, 20)), + upd1 AS (UPDATE t1 SET j = j + 1), + upd2 AS (UPDATE t1 SET j = j * 2) +SELECT 1; +-- +ok +== +WITH ins1 AS (INSERT INTO t1 VALUES (1, 10) RETURNING i), + ins2 AS (INSERT INTO t1 VALUES (2, 20) RETURNING i), + del AS (DELETE FROM t1 RETURNING i) +SELECT 1; +-- +ok +== +CREATE TABLE upsert_t (i INTEGER PRIMARY KEY, j INTEGER); +-- +ok +== +INSERT INTO upsert_t VALUES (1, 10), (2, 20); +-- +ok +== +WITH ups AS ( + INSERT INTO upsert_t VALUES (2, 99), (3, 30) + ON CONFLICT (i) DO UPDATE SET j = excluded.j + RETURNING i, j +) +SELECT * FROM ups; +-- +ok +== +SELECT * FROM upsert_t; +-- +ok +== +TRUNCATE upsert_t; +-- +ok +== +INSERT INTO upsert_t VALUES (1, 10); +-- +ok +== +WITH ups AS ( + INSERT INTO upsert_t VALUES (2, 20) ON CONFLICT (i) DO NOTHING +) +SELECT 1; +-- +ok +== +WITH ups AS ( + INSERT INTO upsert_t VALUES (1, 99), (2, 20) + ON CONFLICT (i) DO UPDATE SET j = excluded.j + RETURNING i, j +) +SELECT * FROM upsert_t; +-- +ok +== +DROP TABLE upsert_t; +-- +ok +== +DROP TABLE t_aux; +-- +ok +== +SELECT (WITH ins AS (INSERT INTO t VALUES (1, 2) RETURNING i) SELECT * FROM ins) AS x; +-- +ok +== +SELECT * FROM (WITH ins AS (INSERT INTO t VALUES (1, 2) RETURNING i) SELECT * FROM ins) AS sub; +-- +ok +== +SELECT * FROM t WHERE i IN (WITH del AS (DELETE FROM t WHERE i = 1 RETURNING i) SELECT i FROM del); +-- +ok +== +CREATE TABLE t2 (i INTEGER, j INTEGER); +-- +ok +== +WITH ins AS MATERIALIZED ( + INSERT INTO t2 VALUES (1, 10), (2, 20) RETURNING i, j +), sel AS MATERIALIZED (SELECT * FROM t2) +SELECT ins.i, sel.i FROM ins, sel; +-- +ok +== +CREATE TABLE base (i INTEGER); +-- +ok +== +INSERT INTO base VALUES (10), (20), (30); +-- +ok +== +CREATE VIEW base_view AS SELECT * FROM base WHERE i >= 20; +-- +ok +== +WITH ins AS ( + INSERT INTO base SELECT i + 1 FROM base_view RETURNING i +) +SELECT * FROM ins; +-- +ok +== +SELECT * FROM base; +-- +ok +== +WITH upd AS ( + UPDATE base SET i = i * 2 WHERE i IN (SELECT i FROM base_view) RETURNING i, i / 2 +) +SELECT * FROM upd; +-- +ok +== +TRUNCATE base; +-- +ok +== +INSERT INTO base VALUES (1), (2), (3), (4), (5); +-- +ok +== +CREATE VIEW small_base AS SELECT * FROM base WHERE i <= 3; +-- +ok +== +WITH del AS ( + DELETE FROM base WHERE i IN (SELECT i FROM small_base) RETURNING i +) +SELECT * FROM del; +-- +ok +== +WITH outer_del AS ( + DELETE FROM t WHERE i = 1 RETURNING i +) +SELECT * FROM ( + WITH inner_ins AS (INSERT INTO t VALUES (99, 99) RETURNING i) + SELECT * FROM inner_ins +) sub; +-- +ok +== +INSERT INTO t VALUES (1, 1); +-- +ok +== +WITH ins AS (INSERT INTO t VALUES (42, 42) RETURNING i) +SELECT * FROM ins; +-- +ok +== +CREATE VIEW v_bad AS WITH ins AS (INSERT INTO t VALUES (1, 2) RETURNING i) SELECT * FROM ins; +-- +ok +== +CREATE VIEW v_bad AS WITH upd AS (UPDATE t SET j = 0 RETURNING i) SELECT * FROM upd; +-- +ok +== +CREATE VIEW v_bad AS WITH del AS (DELETE FROM t RETURNING i) SELECT * FROM del; +-- +ok +== +CREATE TABLE cso_t (i INTEGER); +-- +ok +== +WITH cte AS ( + INSERT INTO cso_t SELECT COUNT(i) FROM cso_t RETURNING i +) SELECT COUNT(i) FROM cso_t; +-- +ok +== +DROP TABLE cso_t; +-- +ok +== +CREATE TABLE stats_t (i INTEGER); +-- +ok +== +WITH ins AS (INSERT INTO stats_t VALUES (1), (2), (3) RETURNING i) +SELECT * FROM stats_t WHERE i = 2; +-- +ok +== +DROP TABLE stats_t; +-- +ok +== +CREATE TABLE cte_inline_t (i INTEGER); +-- +ok +== +WITH ins AS (INSERT INTO cte_inline_t VALUES (42) RETURNING i) +SELECT COUNT(*) FROM cte_inline_t; +-- +ok +== +DROP TABLE cte_inline_t; +-- +ok +== +CREATE TABLE empty_consumer_t (i INTEGER); +-- +ok +== +WITH ins AS (INSERT INTO empty_consumer_t VALUES (42) RETURNING i) +SELECT 42 WHERE false; +-- +ok +== +SELECT * FROM empty_consumer_t; +-- +ok +== +DROP TABLE empty_consumer_t; +-- +ok +== +CREATE TABLE persist_t (i INTEGER); +-- +ok +== +INSERT INTO persist_t VALUES (1), (2), (3); +-- +ok +== +CREATE VIEW persist_v AS WITH cte AS (SELECT i * 10 AS j FROM persist_t) SELECT j FROM cte WHERE j > 10; +-- +ok +== +FROM persist_v; +-- +ok +== diff --git a/parser/testdata/corpus/sql/cte/dml_cte.test.metadata.json b/parser/testdata/corpus/sql/cte/dml_cte.test.metadata.json new file mode 100644 index 0000000..2823742 --- /dev/null +++ b/parser/testdata/corpus/sql/cte/dml_cte.test.metadata.json @@ -0,0 +1,10 @@ +{ + "todo": { + "2c71a76a1b25a2f6": "transformer-raised parser error: upstream rejects in the transformer, not the grammar; expected to clear as transformers land (milestones 3-5)", + "6f9e83f76d8baaf5": "transformer-raised parser error: upstream rejects in the transformer, not the grammar; expected to clear as transformers land (milestones 3-5)", + "7d4c81fff04c9127": "transformer-raised parser error: upstream rejects in the transformer, not the grammar; expected to clear as transformers land (milestones 3-5)", + "7da2a7c8da13c934": "transformer-raised parser error: upstream rejects in the transformer, not the grammar; expected to clear as transformers land (milestones 3-5)", + "7eed85fe16a65e3a": "transformer-raised parser error: upstream rejects in the transformer, not the grammar; expected to clear as transformers land (milestones 3-5)", + "840ee49106690f16": "transformer-raised parser error: upstream rejects in the transformer, not the grammar; expected to clear as transformers land (milestones 3-5)" + } +} diff --git a/parser/testdata/corpus/sql/cte/incorrect_recursive_cte.test b/parser/testdata/corpus/sql/cte/incorrect_recursive_cte.test new file mode 100644 index 0000000..ceafb15 --- /dev/null +++ b/parser/testdata/corpus/sql/cte/incorrect_recursive_cte.test @@ -0,0 +1,17 @@ +# source: test/sql/cte/incorrect_recursive_cte.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +WITH RECURSIVE cte AS (SELECT 42) SELECT * FROM cte; +-- +ok +== +with recursive t as (select 1 as x intersect select x+1 from t where x < 3) select * from t order by x +-- +ok +== +with recursive t as (select 1 as x except select x+1 from t where x < 3) select * from t order by x +-- +ok +== diff --git a/parser/testdata/corpus/sql/cte/insert_cte_bug_3417.test b/parser/testdata/corpus/sql/cte/insert_cte_bug_3417.test new file mode 100644 index 0000000..498cce4 --- /dev/null +++ b/parser/testdata/corpus/sql/cte/insert_cte_bug_3417.test @@ -0,0 +1,29 @@ +# source: test/sql/cte/insert_cte_bug_3417.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +CREATE TABLE table1 (id INTEGER, a INTEGER); +-- +ok +== +CREATE TABLE table2 (table1_id INTEGER); +-- +ok +== +INSERT INTO table2 WITH cte AS (INSERT INTO table1 SELECT 1, 2 RETURNING id) SELECT id FROM cte; +-- +ok +== +WITH cte AS (INSERT INTO table1 SELECT 1, 2 RETURNING id) INSERT INTO table2 SELECT id FROM cte; +-- +ok +== +SELECT * FROM table1; +-- +ok +== +SELECT * FROM table2; +-- +ok +== diff --git a/parser/testdata/corpus/sql/cte/lazy_cte_bind.test b/parser/testdata/corpus/sql/cte/lazy_cte_bind.test new file mode 100644 index 0000000..37cb2ba --- /dev/null +++ b/parser/testdata/corpus/sql/cte/lazy_cte_bind.test @@ -0,0 +1,10 @@ +# source: test/sql/cte/lazy_cte_bind.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +with cte as (select * from read_parquet('does/not/exist/file.parquet')) +select 42 +-- +ok +== diff --git a/parser/testdata/corpus/sql/cte/lazy_cte_bind_correlated.test b/parser/testdata/corpus/sql/cte/lazy_cte_bind_correlated.test new file mode 100644 index 0000000..0a08a5b --- /dev/null +++ b/parser/testdata/corpus/sql/cte/lazy_cte_bind_correlated.test @@ -0,0 +1,15 @@ +# source: test/sql/cte/lazy_cte_bind_correlated.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +SELECT query, + (WITH t AS (SELECT query) + SELECT x FROM (VALUES ('cat')) AS _(x) + WHERE x IN (SELECT query)) AS broken +FROM (VALUES ('cat'), + ('dog'), + ('duck')) AS queries(query) +-- +ok +== diff --git a/parser/testdata/corpus/sql/cte/materialized/annotated_and_auto_materialized.test b/parser/testdata/corpus/sql/cte/materialized/annotated_and_auto_materialized.test new file mode 100644 index 0000000..6515b44 --- /dev/null +++ b/parser/testdata/corpus/sql/cte/materialized/annotated_and_auto_materialized.test @@ -0,0 +1,44 @@ +# source: test/sql/cte/materialized/annotated_and_auto_materialized.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +create table batch ( + entity text, + start_ts timestamp, + duration interval +); +-- +ok +== +create table active_events ( + entity text, + start_ts timestamp, + end_ts timestamp +); +-- +ok +== +explain create table new_active_events as +with + new_events as materialized ( -- Does not make much sense in this example, but my original query was a union of a bunch of things + select * from batch + ), combined_deduplicated_events as ( + select + entity, + min(start_ts) as start_ts, + max(end_ts) as end_ts + from + active_events + group by + entity + ), all_events as ( + select * from combined_deduplicated_events + ) +select + * +from + new_events; +-- +ok +== diff --git a/parser/testdata/corpus/sql/cte/materialized/cte_filter_pusher.test b/parser/testdata/corpus/sql/cte/materialized/cte_filter_pusher.test new file mode 100644 index 0000000..3c10ed8 --- /dev/null +++ b/parser/testdata/corpus/sql/cte/materialized/cte_filter_pusher.test @@ -0,0 +1,109 @@ +# source: test/sql/cte/materialized/cte_filter_pusher.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +WITH + a(x) AS MATERIALIZED ( + SELECT * + FROM generate_series(1, 10) + ), + b(x) AS MATERIALIZED ( + SELECT * + FROM a + WHERE x < 8 + ) +SELECT * +FROM b +WHERE x % 3 = 1 +ORDER BY x; +-- +ok +== +EXPLAIN WITH cte AS MATERIALIZED ( + SELECT i, md5(i::VARCHAR) AS digest + FROM range(100) t(i) +) +SELECT count(*) FROM cte WHERE digest < '4' +UNION ALL +SELECT count(*) FROM cte WHERE digest > 'c'; +-- +ok +== +WITH cte AS MATERIALIZED ( + SELECT i, md5(i::VARCHAR) AS digest + FROM range(100) t(i) +) +SELECT count(*) FROM cte WHERE digest < '4' +UNION ALL +SELECT count(*) FROM cte WHERE digest > 'c'; +-- +ok +== +CREATE TABLE cte_filter_pushdown_source AS SELECT i FROM range(100) t(i); +-- +ok +== +EXPLAIN WITH cte AS MATERIALIZED ( + SELECT i AS alias + FROM cte_filter_pushdown_source +) +SELECT * FROM cte WHERE alias = 42; +-- +ok +== +WITH cte AS MATERIALIZED ( + SELECT i AS alias + FROM cte_filter_pushdown_source +) +SELECT * FROM cte WHERE alias = 42; +-- +ok +== +EXPLAIN WITH cte AS MATERIALIZED ( + SELECT i + 1 AS x, md5(i::VARCHAR) AS payload + FROM range(100) t(i) +) +SELECT sum(length(payload)) +FROM cte +WHERE x < 10; +-- +ok +== +WITH cte AS MATERIALIZED ( + SELECT i + 1 AS x, md5(i::VARCHAR) AS payload + FROM range(100) t(i) +) +SELECT sum(length(payload)) +FROM cte +WHERE x < 10; +-- +ok +== +EXPLAIN SELECT sum(length(payload)) +FROM ( + SELECT i + 1 AS x, md5(i::VARCHAR) AS payload + FROM range(100) t(i) +) sq +WHERE x < 10; +-- +ok +== +CREATE TABLE cte_projection_split_source(i INTEGER, payload VARCHAR); +-- +ok +== +INSERT INTO cte_projection_split_source VALUES (1, 'a'), (1, 'b'), (NULL, 'c'), (2, NULL); +-- +ok +== +WITH cte AS MATERIALIZED ( + SELECT i + 1 AS x, upper(payload) AS payload + FROM cte_projection_split_source +) +SELECT coalesce(x, -1), coalesce(payload, 'NULL') +FROM cte +WHERE x = 2 OR x IS NULL; +-- +ok +== diff --git a/parser/testdata/corpus/sql/cte/materialized/dml_materialized_cte.test b/parser/testdata/corpus/sql/cte/materialized/dml_materialized_cte.test new file mode 100644 index 0000000..498961f --- /dev/null +++ b/parser/testdata/corpus/sql/cte/materialized/dml_materialized_cte.test @@ -0,0 +1,68 @@ +# source: test/sql/cte/materialized/dml_materialized_cte.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +create table a(i integer); +-- +ok +== +insert into a values (42); +-- +ok +== +WITH t(x) AS MATERIALIZED (VALUES (42)) +INSERT INTO a (SELECT * FROM t); +-- +ok +== +WITH t(x) AS MATERIALIZED (VALUES (42)) +DELETE FROM a WHERE a.i IN (SELECT * FROM t); +-- +ok +== +WITH t(x) AS MATERIALIZED (VALUES (42)) +UPDATE a SET i = 0 WHERE a.i IN (SELECT * FROM t); +-- +ok +== +FROM a +-- +ok +== +insert into a values (2); +-- +ok +== +WITH t(x) AS MATERIALIZED (SELECT 1), + u(x) AS MATERIALIZED (SELECT 2 UNION ALL SELECT * FROM t) +DELETE FROM a WHERE a.i IN (SELECT * FROM u); +-- +ok +== +WITH t(x) AS MATERIALIZED (SELECT 1), + u(x) AS MATERIALIZED (SELECT 2 UNION ALL SELECT * FROM t) +UPDATE a SET i = 99 WHERE a.i IN (SELECT * FROM u); +-- +ok +== +FROM a ORDER BY 1 +-- +ok +== +WITH t(x) AS MATERIALIZED (SELECT 1), + u(x) AS MATERIALIZED (SELECT 2 UNION ALL SELECT * FROM t) +INSERT INTO a (SELECT * FROM u); +-- +ok +== +WITH t(x) AS MATERIALIZED (SELECT 1) +DELETE FROM a WHERE i IN (WITH s(x) AS MATERIALIZED (SELECT x + 41 FROM t) SELECT * FROM t); +-- +ok +== +WITH t(x) AS MATERIALIZED (SELECT 1) +DELETE FROM a WHERE i IN (WITH s(x) AS MATERIALIZED (SELECT x + 41 FROM t) SELECT * FROM s); +-- +ok +== diff --git a/parser/testdata/corpus/sql/cte/materialized/incorrect_recursive_cte_materialized.test b/parser/testdata/corpus/sql/cte/materialized/incorrect_recursive_cte_materialized.test new file mode 100644 index 0000000..ccef574 --- /dev/null +++ b/parser/testdata/corpus/sql/cte/materialized/incorrect_recursive_cte_materialized.test @@ -0,0 +1,17 @@ +# source: test/sql/cte/materialized/incorrect_recursive_cte_materialized.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +WITH RECURSIVE cte AS MATERIALIZED (SELECT 42) SELECT * FROM cte; +-- +ok +== +with recursive t as MATERIALIZED (select 1 as x intersect select x+1 from t where x < 3) select * from t order by x +-- +ok +== +with recursive t as MATERIALIZED (select 1 as x except select x+1 from t where x < 3) select * from t order by x +-- +ok +== diff --git a/parser/testdata/corpus/sql/cte/materialized/internal_3004.test b/parser/testdata/corpus/sql/cte/materialized/internal_3004.test new file mode 100644 index 0000000..76903fd --- /dev/null +++ b/parser/testdata/corpus/sql/cte/materialized/internal_3004.test @@ -0,0 +1,34 @@ +# source: test/sql/cte/materialized/internal_3004.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +with + system_types as ( + select distinct + type_name as label, + 'type' as type_label, + 1000 as priority, + null as context + from duckdb_types() + where database_name = 'system' + ), + custom_types as ( + select distinct + type_name as label, + 'type' as type_label, + 1000 as priority, + schema_name as context + from duckdb_types() + where + database_name not in ('system', 'temp') + and type_name not in (select label from system_types) + ) +select * +from system_types +union all +select * +from custom_types +-- +ok +== diff --git a/parser/testdata/corpus/sql/cte/materialized/materialized_cte_modifiers.test b/parser/testdata/corpus/sql/cte/materialized/materialized_cte_modifiers.test new file mode 100644 index 0000000..d874321 --- /dev/null +++ b/parser/testdata/corpus/sql/cte/materialized/materialized_cte_modifiers.test @@ -0,0 +1,36 @@ +# source: test/sql/cte/materialized/materialized_cte_modifiers.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +call dsdgen(sf=0) +-- +ok +== +explain +WITH customer_total_return AS + (SELECT sr_customer_sk AS ctr_customer_sk, + sr_store_sk AS ctr_store_sk, + sum(sr_return_amt) AS ctr_total_return + FROM store_returns, + date_dim + WHERE sr_returned_date_sk = d_date_sk + AND d_year = 2000 + GROUP BY sr_customer_sk, + sr_store_sk) +SELECT c_customer_id +FROM customer_total_return ctr1, + store, + customer +WHERE ctr1.ctr_total_return > + (SELECT avg(ctr_total_return)*1.2 + FROM customer_total_return ctr2 + WHERE ctr1.ctr_store_sk = ctr2.ctr_store_sk) + AND s_store_sk = ctr1.ctr_store_sk + AND s_state = 'TN' + AND ctr1.ctr_customer_sk = c_customer_sk +ORDER BY c_customer_id +LIMIT 100; +-- +ok +== diff --git a/parser/testdata/corpus/sql/cte/materialized/materialized_cte_order_preservation.test b/parser/testdata/corpus/sql/cte/materialized/materialized_cte_order_preservation.test new file mode 100644 index 0000000..38fccce --- /dev/null +++ b/parser/testdata/corpus/sql/cte/materialized/materialized_cte_order_preservation.test @@ -0,0 +1,188 @@ +# source: test/sql/cte/materialized/materialized_cte_order_preservation.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +CREATE TABLE cte_order_batch AS SELECT i FROM range(1000000) tbl(i); +-- +ok +== +EXPLAIN ANALYZE +WITH t(i) AS MATERIALIZED ( + SELECT i FROM cte_order_batch +) +SELECT i FROM t LIMIT 5 OFFSET 500000; +-- +ok +== +EXPLAIN ANALYZE +CREATE TABLE cte_order_direct AS +WITH t(i) AS MATERIALIZED ( + SELECT i FROM cte_order_batch +) +SELECT i FROM t; +-- +ok +== +SELECT count(*), min(i), max(i) FROM cte_order_direct; +-- +ok +== +WITH t(i) AS MATERIALIZED ( + SELECT i FROM cte_order_batch +) +SELECT i FROM t LIMIT 5 OFFSET 500000; +-- +ok +== +WITH t(i) AS MATERIALIZED ( + SELECT i FROM cte_order_batch +) +SELECT i FROM t WHERE i % 100000 = 0; +-- +ok +== +CREATE TABLE cte_order_sparse AS +WITH t(i) AS MATERIALIZED ( + SELECT i FROM cte_order_batch WHERE i % 100000 = 0 +) +SELECT i FROM t; +-- +ok +== +SELECT count(*), min(i), max(i) FROM cte_order_sparse; +-- +ok +== +CREATE TABLE cte_order_empty AS +WITH t(i) AS MATERIALIZED ( + SELECT i FROM cte_order_batch WHERE false +) +SELECT i FROM t; +-- +ok +== +SELECT count(*) FROM cte_order_empty; +-- +ok +== +WITH t(i) AS MATERIALIZED ( + SELECT i FROM range(1000000) tbl(i) +) +SELECT (SELECT i FROM t LIMIT 1 OFFSET 500000), (SELECT sum(i) FROM t); +-- +ok +== +WITH t(i) AS MATERIALIZED ( + SELECT i FROM range(1000000) tbl(i) +) +SELECT (SELECT i FROM t LIMIT 1 OFFSET 100000), (SELECT i FROM t LIMIT 1 OFFSET 900000); +-- +ok +== +WITH t(i) AS MATERIALIZED ( + SELECT i FROM range(200000) tbl(i) + UNION ALL + SELECT i + 200000 FROM range(200000) tbl(i) +) +SELECT i FROM t LIMIT 5 OFFSET 250000; +-- +ok +== +CREATE TABLE cte_order_left AS SELECT i FROM range(4000) tbl(i); +-- +ok +== +CREATE TABLE cte_order_right AS SELECT i + 4000 AS i FROM range(4000) tbl(i); +-- +ok +== +EXPLAIN ANALYZE +CREATE TABLE cte_order_union_copy AS +WITH t AS MATERIALIZED ( + SELECT * FROM cte_order_left + UNION ALL + SELECT * FROM cte_order_right +) +SELECT i FROM t; +-- +ok +== +WITH t AS MATERIALIZED ( + SELECT * FROM cte_order_left + UNION ALL + SELECT * FROM cte_order_right +) +SELECT i FROM t LIMIT 5 OFFSET 5000; +-- +ok +== +PREPARE ordered_cte AS +WITH t(i) AS MATERIALIZED ( + SELECT i FROM range(500000) tbl(i) +) +SELECT i FROM t LIMIT 1 OFFSET 300000; +-- +ok +== +EXECUTE ordered_cte; +-- +ok +== +WITH t(i) AS MATERIALIZED ( + SELECT i + FROM range(10000) tbl(i) + ORDER BY i DESC +) +SELECT i FROM t LIMIT 5; +-- +ok +== +CREATE TABLE cte_order_sorted_copy AS +WITH t(i) AS MATERIALIZED ( + SELECT i + FROM range(10000) tbl(i) + ORDER BY i DESC +) +SELECT i FROM t; +-- +ok +== +SELECT i FROM cte_order_sorted_copy LIMIT 5; +-- +ok +== +WITH t(i) AS MATERIALIZED ( + SELECT i + FROM range(10000) tbl(i) + ORDER BY i DESC +) +SELECT (SELECT i FROM t LIMIT 1), (SELECT i FROM t LIMIT 1); +-- +ok +== +WITH t(i, j) AS MATERIALIZED ( + SELECT i, i + 1 + FROM range(10000) tbl(i) + ORDER BY i DESC +) +SELECT j FROM t LIMIT 5; +-- +ok +== +WITH t(i, j) AS MATERIALIZED ( + SELECT i, i + 1 + FROM range(10000) tbl(i) + ORDER BY i DESC +) +SELECT count(*) FROM t; +-- +ok +== +WITH t(i) AS MATERIALIZED ( + VALUES (1), (2), (3), (4), (5) +) +SELECT i FROM t LIMIT 3 OFFSET 1; +-- +ok +== diff --git a/parser/testdata/corpus/sql/cte/materialized/materialized_cte_parallel_buffered.test b/parser/testdata/corpus/sql/cte/materialized/materialized_cte_parallel_buffered.test new file mode 100644 index 0000000..285e827 --- /dev/null +++ b/parser/testdata/corpus/sql/cte/materialized/materialized_cte_parallel_buffered.test @@ -0,0 +1,172 @@ +# source: test/sql/cte/materialized/materialized_cte_parallel_buffered.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +CREATE TABLE cte_parallel_left AS SELECT i FROM range(600000) tbl(i); +-- +ok +== +CREATE TABLE cte_parallel_right AS SELECT i + 600000 AS i FROM range(600000) tbl(i); +-- +ok +== +EXPLAIN ANALYZE +CREATE TABLE cte_parallel_plan AS +WITH t AS MATERIALIZED ( + SELECT * FROM cte_parallel_left + UNION ALL + SELECT * FROM cte_parallel_right +) +SELECT i FROM t; +-- +ok +== +CREATE OR REPLACE TABLE cte_parallel_copy AS +WITH t AS MATERIALIZED ( + SELECT * FROM cte_parallel_left + UNION ALL + SELECT * FROM cte_parallel_right +) +SELECT i, i % 97 AS bucket FROM t; +-- +ok +== +SELECT count(*), min(i), max(i) FROM cte_parallel_copy; +-- +ok +== +SELECT count(*) +FROM cte_parallel_copy +WHERE i != rowid; +-- +ok +== +CREATE TABLE cte_parallel_short AS +WITH t AS MATERIALIZED ( + SELECT i FROM range(1000) tbl(i) + UNION ALL + SELECT i + 1000 AS i FROM range(1000) tbl(i) +) +SELECT i FROM t; +-- +ok +== +SELECT count(*) FROM cte_parallel_short WHERE i != rowid; +-- +ok +== +PREPARE cte_parallel_prepared AS +WITH t AS MATERIALIZED ( + SELECT * FROM cte_parallel_left + UNION ALL + SELECT * FROM cte_parallel_right +) +SELECT i FROM t LIMIT 1 OFFSET 750000; +-- +ok +== +EXECUTE cte_parallel_prepared; +-- +ok +== +CREATE TABLE cte_parallel_limit AS +WITH t AS MATERIALIZED ( + SELECT * FROM cte_parallel_left + UNION ALL + SELECT * FROM cte_parallel_right +) +SELECT i FROM t LIMIT 250000; +-- +ok +== +SELECT count(*), min(i), max(i) FROM cte_parallel_limit; +-- +ok +== +CREATE TABLE cte_parallel_nested AS +WITH first AS MATERIALIZED ( + SELECT * FROM cte_parallel_left + UNION ALL + SELECT * FROM cte_parallel_right +), second AS MATERIALIZED ( + SELECT i FROM first +) +SELECT i FROM second LIMIT 750000; +-- +ok +== +SELECT count(*), min(i), max(i) FROM cte_parallel_nested; +-- +ok +== +SELECT count(*) +FROM cte_parallel_nested +WHERE i != rowid; +-- +ok +== +CREATE TABLE cte_parallel_mixed AS +WITH t AS MATERIALIZED ( + SELECT * FROM cte_parallel_left + UNION ALL + SELECT * FROM cte_parallel_right +) +SELECT i, (SELECT count(*) FROM t) AS total FROM t LIMIT 250000; +-- +ok +== +SELECT count(*), min(i), max(i), min(total) FROM cte_parallel_mixed; +-- +ok +== +CREATE TABLE cte_parallel_sparse AS +WITH t AS MATERIALIZED ( + SELECT i FROM cte_parallel_left WHERE i % 7 != 0 + UNION ALL + SELECT i FROM cte_parallel_right WHERE i % 11 != 0 +) +SELECT i FROM t; +-- +ok +== +SELECT count(*) +FROM cte_parallel_sparse current_row +JOIN cte_parallel_sparse previous_row + ON current_row.rowid = previous_row.rowid + 1 +WHERE current_row.i <= previous_row.i; +-- +ok +== +CREATE TABLE cte_parallel_empty AS +WITH t AS MATERIALIZED ( + SELECT i FROM cte_parallel_left WHERE false + UNION ALL + SELECT i FROM cte_parallel_right WHERE false +) +SELECT i FROM t; +-- +ok +== +SELECT count(*) FROM cte_parallel_empty; +-- +ok +== +CREATE TABLE cte_single_thread AS +WITH t AS MATERIALIZED ( + SELECT * FROM cte_parallel_left + UNION ALL + SELECT * FROM cte_parallel_right +) +SELECT i FROM t; +-- +ok +== +SELECT count(*), min(i), max(i) FROM cte_single_thread; +-- +ok +== +SELECT count(*) FROM cte_single_thread WHERE i != rowid; +-- +ok +== diff --git a/parser/testdata/corpus/sql/cte/materialized/materialized_cte_prepared.test b/parser/testdata/corpus/sql/cte/materialized/materialized_cte_prepared.test new file mode 100644 index 0000000..2598aae --- /dev/null +++ b/parser/testdata/corpus/sql/cte/materialized/materialized_cte_prepared.test @@ -0,0 +1,85 @@ +# source: test/sql/cte/materialized/materialized_cte_prepared.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +PREPARE direct_fanout_cte AS +WITH c AS MATERIALIZED (SELECT i FROM range(1000) t(i)) +SELECT count(*) FROM c; +-- +ok +== +EXECUTE direct_fanout_cte +-- +ok +== +SET memory_limit='128MB' +-- +ok +== +PREPARE buffered_fanout_cte AS +WITH c AS MATERIALIZED ( + SELECT i, repeat('x', 512) AS payload + FROM range(150000) t(i) +) +SELECT (SELECT sum(length(payload)) FROM c), + (SELECT length(payload) FROM c LIMIT 1), + (SELECT length(payload) FROM c LIMIT 1 OFFSET 100000); +-- +ok +== +EXECUTE buffered_fanout_cte +-- +ok +== +SELECT memory_usage_bytes, tag +FROM duckdb_memory() +WHERE tag IN ('ALLOCATOR', 'IN_MEMORY_TABLE') +-- +ok +== +CREATE TABLE prepared_batch_source AS SELECT i FROM range(100000) t(i); +-- +ok +== +CREATE TABLE prepared_batch_target(i BIGINT); +-- +ok +== +PREPARE direct_batch_cte AS +INSERT INTO prepared_batch_target +WITH c AS MATERIALIZED (SELECT i FROM prepared_batch_source) +SELECT i FROM c; +-- +ok +== +EXECUTE direct_batch_cte +-- +ok +== +SELECT count(*), min(i), max(i) FROM prepared_batch_target; +-- +ok +== +insert into a values (1), (2), (3), (NULL), (42), (84); +-- +ok +== +PREPARE v1 AS WITH t(x) AS MATERIALIZED (VALUES ($1)) +DELETE FROM a WHERE i IN (FROM t); +-- +ok +== +EXECUTE v1(42) +-- +ok +== +PREPARE v2 AS WITH t(x) AS MATERIALIZED (VALUES ($1)) +DELETE FROM a WHERE (i + $2) IN (FROM t); +-- +ok +== +EXECUTE v2(5, 2) +-- +ok +== diff --git a/parser/testdata/corpus/sql/cte/materialized/recursive_array_slice_materialized.test b/parser/testdata/corpus/sql/cte/materialized/recursive_array_slice_materialized.test new file mode 100644 index 0000000..ea21839 --- /dev/null +++ b/parser/testdata/corpus/sql/cte/materialized/recursive_array_slice_materialized.test @@ -0,0 +1,59 @@ +# source: test/sql/cte/materialized/recursive_array_slice_materialized.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +CREATE TABLE p(loc int8); +-- +ok +== +INSERT INTO p VALUES (1); +-- +ok +== +WITH RECURSIVE t(y, arr) AS MATERIALIZED +( + SELECT 1, array[1,2,3,4,5,6] + UNION ALL + SELECT y+1, arr[:loc] + FROM t, p + WHERE y < 10 +) SELECT * FROM t; +-- +ok +== +WITH RECURSIVE t(y, arr) AS MATERIALIZED +( + SELECT 1, array[1,2,3,4,5,6] + UNION ALL + SELECT y+1, arr + FROM t, p + WHERE y < 10 + AND y = loc +) SELECT * FROM t; +-- +ok +== +WITH RECURSIVE t(y, arr) AS MATERIALIZED +( + SELECT 1, array[1,2,3,4,5,6] + UNION ALL + SELECT y+1, arr[:loc] + FROM t, p + WHERE y < 10 + AND y = loc +) SELECT * FROM t; +-- +ok +== +WITH RECURSIVE t(arr) AS MATERIALIZED +( + SELECT array[1,2,3,4,5,6] + UNION ALL + SELECT arr[arr[1]+1:6] + FROM t + WHERE arr[1] < 6 +) SELECT * FROM t; +-- +ok +== diff --git a/parser/testdata/corpus/sql/cte/materialized/recursive_cte_complex_pipelines.test b/parser/testdata/corpus/sql/cte/materialized/recursive_cte_complex_pipelines.test new file mode 100644 index 0000000..92c5236 --- /dev/null +++ b/parser/testdata/corpus/sql/cte/materialized/recursive_cte_complex_pipelines.test @@ -0,0 +1,94 @@ +# source: test/sql/cte/materialized/recursive_cte_complex_pipelines.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +WITH RECURSIVE t AS MATERIALIZED +( + SELECT 1 AS x +UNION + SELECT t1.x + t2.x + t3.x AS x + FROM t t1, t t2, t t3 + WHERE t1.x < 100 +) +SELECT * FROM t ORDER BY 1; +-- +ok +== +WITH RECURSIVE t AS MATERIALIZED +( + SELECT 1 AS x +UNION + SELECT (t1.x + t2.x + t3.x)::HUGEINT AS x + FROM t t1, t t2, t t3 + WHERE t1.x < 100 +) +SELECT * FROM t ORDER BY 1; +-- +ok +== +CREATE TABLE a AS SELECT * FROM range(100) t1(i) +-- +ok +== +WITH RECURSIVE t AS MATERIALIZED +( + SELECT 1 AS x +UNION + SELECT SUM(x) AS x + FROM t, a + WHERE x < 1000000 +) +SELECT * FROM t ORDER BY 1 NULLS LAST; +-- +ok +== +WITH RECURSIVE t AS MATERIALIZED +( + SELECT 1 AS x +UNION + SELECT SUM(x) AS x + FROM t, a + WHERE x < 1000000 AND t.x=a.i +) +SELECT * FROM t ORDER BY 1 NULLS LAST; +-- +ok +== +WITH RECURSIVE t AS MATERIALIZED +( + SELECT 1 AS x +UNION + SELECT SUM(x) + FROM + (SELECT SUM(x) FROM t) t1(x), a + WHERE x < 1000 +) +SELECT * FROM t ORDER BY 1 NULLS LAST; +-- +ok +== +WITH RECURSIVE t AS MATERIALIZED +( + SELECT 1 AS x +UNION + SELECT (SELECT x + 1 FROM t) AS x + FROM t + WHERE x < 5 +) +SELECT * FROM t ORDER BY 1 NULLS LAST; +-- +ok +== +WITH RECURSIVE t AS MATERIALIZED +( + SELECT 1 AS x +UNION + SELECT (SELECT t.x+t2.x FROM t t2 LIMIT 1) AS x + FROM t + WHERE x < 10 +) +SELECT * FROM t ORDER BY 1 NULLS LAST; +-- +ok +== diff --git a/parser/testdata/corpus/sql/cte/materialized/recursive_cte_error_materialized.test b/parser/testdata/corpus/sql/cte/materialized/recursive_cte_error_materialized.test new file mode 100644 index 0000000..876a8a5 --- /dev/null +++ b/parser/testdata/corpus/sql/cte/materialized/recursive_cte_error_materialized.test @@ -0,0 +1,32 @@ +# source: test/sql/cte/materialized/recursive_cte_error_materialized.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +CREATE TABLE tag(id int, name string, subclassof int); +-- +ok +== +INSERT INTO tag VALUES + (7, 'Music', 9), + (8, 'Movies', 9), + (9, 'Art', NULL) +; +-- +ok +== +WITH RECURSIVE tag_hierarchy(id, source, path, target) AS materialized ( + SELECT id, name, name AS path, NULL::INTEGER AS target -- this should be '' for correct behaviour + FROM tag + WHERE subclassof IS NULL + UNION ALL + SELECT tag.id, tag.name, tag_hierarchy.path || ' <- ' || tag.name, tag.name AS target + FROM tag, tag_hierarchy + WHERE tag.subclassof = tag_hierarchy.id +) +SELECT source, path, target +FROM tag_hierarchy +; +-- +ok +== diff --git a/parser/testdata/corpus/sql/cte/materialized/recursive_hang_2745_materialized.test b/parser/testdata/corpus/sql/cte/materialized/recursive_hang_2745_materialized.test new file mode 100644 index 0000000..69f3073 --- /dev/null +++ b/parser/testdata/corpus/sql/cte/materialized/recursive_hang_2745_materialized.test @@ -0,0 +1,64 @@ +# source: test/sql/cte/materialized/recursive_hang_2745_materialized.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +with RECURSIVE parents_tab (id , value , parent ) +as MATERIALIZED (values (1, 1, 2), (2, 2, 4), (3, 1, 4), (4, 2, -1), (5, 1, 2), (6, 2, 7), (7, 1, -1) +), +parents_tab2(id , value , parent ) +as MATERIALIZED (values (1, 1, 2), (2, 2, 4), (3, 1, 4), (4, 2, -1), (5, 1, 2), (6, 2, 7), (7, 1, -1) +), +parents as MATERIALIZED ( + select * from parents_tab + union all + select id, value+2, parent from parents_tab2 +) +select * from parents ORDER BY id, value, parent; +-- +ok +== +with RECURSIVE parents_tab (id , value , parent ) +as MATERIALIZED (values (1, 1, 2), (2, 2, 4), (3, 1, 4), (4, 2, -1), (5, 1, 2), (6, 2, 7), (7, 1, -1) +), +parents_tab2(id , value , parent ) +as MATERIALIZED (values (1, 1, 2), (2, 2, 4), (3, 1, 4), (4, 2, -1), (5, 1, 2), (6, 2, 7), (7, 1, -1) +) +select * from parents_tab +union all +select id, value+2, parent from parents_tab2 ORDER BY id, value, parent; +-- +ok +== +with parents_tab (id , value , parent ) +as MATERIALIZED (values (1, 1, 2), (2, 2, 4), (3, 1, 4), (4, 2, -1), (5, 1, 2), (6, 2, 7), (7, 1, -1) +), +parents_tab2(id , value , parent ) +as MATERIALIZED (values (1, 1, 2), (2, 2, 4), (3, 1, 4), (4, 2, -1), (5, 1, 2), (6, 2, 7), (7, 1, -1) +), +parents as MATERIALIZED ( + select * from parents_tab + union all + select id, value+2, parent from parents_tab2 +) +select * from parents ORDER BY id, value, parent; +-- +ok +== +create view vparents as +with RECURSIVE parents_tab (id , value , parent ) +as MATERIALIZED (values (1, 1, 2), (2, 2, 4), (3, 1, 4), (4, 2, -1), (5, 1, 2), (6, 2, 7), (7, 1, -1) +), +parents_tab2 (id , value , parent ) +as MATERIALIZED (values (1, 1, 2), (2, 2, 4), (3, 1, 4), (4, 2, -1), (5, 1, 2), (6, 2, 7), (7, 1, -1) +) +select * from parents_tab +union all +select id, value+2, parent from parents_tab2; +-- +ok +== +select * from vparents ORDER BY id, value, parent; +-- +ok +== diff --git a/parser/testdata/corpus/sql/cte/materialized/test_bug_922_materialized.test b/parser/testdata/corpus/sql/cte/materialized/test_bug_922_materialized.test new file mode 100644 index 0000000..1863c13 --- /dev/null +++ b/parser/testdata/corpus/sql/cte/materialized/test_bug_922_materialized.test @@ -0,0 +1,10 @@ +# source: test/sql/cte/materialized/test_bug_922_materialized.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +WITH my_list(value) AS MATERIALIZED (VALUES (1), (2), (3)) + SELECT * FROM my_list LIMIT 0 OFFSET 1 +-- +ok +== diff --git a/parser/testdata/corpus/sql/cte/materialized/test_correlated_recursive_cte_materialized.test b/parser/testdata/corpus/sql/cte/materialized/test_correlated_recursive_cte_materialized.test new file mode 100644 index 0000000..bf51618 --- /dev/null +++ b/parser/testdata/corpus/sql/cte/materialized/test_correlated_recursive_cte_materialized.test @@ -0,0 +1,175 @@ +# source: test/sql/cte/materialized/test_correlated_recursive_cte_materialized.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +SELECT x, y +FROM generate_series(1,4) AS _(x), LATERAL +(WITH RECURSIVE t(y) AS MATERIALIZED ( + SELECT _.x + UNION ALL + SELECT y + 1 + FROM t + WHERE y < 3 +) +SELECT * FROM t) AS t +ORDER BY x, y; +-- +ok +== +SELECT x, y +FROM generate_series(1,4) AS _(x), LATERAL +(WITH RECURSIVE t(y) AS MATERIALIZED ( + SELECT 1 + UNION ALL + SELECT y + _.x + FROM t + WHERE y < 3 +) +SELECT * FROM t) AS t +ORDER BY x, y; +-- +ok +== +SELECT x, y +FROM generate_series(1,4) AS _(x), LATERAL +(WITH RECURSIVE t(y) AS MATERIALIZED ( + SELECT _.x + UNION ALL + SELECT y + _.x + FROM t + WHERE y < 3 +) +SELECT * FROM t) AS t +ORDER BY x, y; +-- +ok +== +SELECT x, y +FROM generate_series(1,4) AS _(x), LATERAL +(WITH RECURSIVE t(y) AS MATERIALIZED ( + SELECT _.x + UNION ALL + SELECT t1.y + t2.y + _.x + FROM t AS t1, t AS t2 + WHERE t1.y < 3 +) +SELECT * FROM t) AS t +ORDER BY x, y; +-- +ok +== +SELECT x, y, (WITH RECURSIVE t(z) AS MATERIALIZED ( + SELECT x + y + UNION ALL + SELECT z + 1 + FROM t + WHERE z < 3 +) SELECT sum(z) FROM t) AS z +FROM generate_series(1,2) AS _(x), generate_series(1,2) AS __(y) order by all; +-- +ok +== +SELECT x, y, (WITH RECURSIVE t(z) AS MATERIALIZED ( + SELECT x + y + UNION ALL + SELECT z + 1 + FROM (WITH RECURSIVE g(a) AS MATERIALIZED ( + SELECT t.z + FROM t + UNION ALL + SELECT g.a + (x + y) / 2 + FROM g + WHERE g.a < 3) + SELECT * FROM g) AS t(z) + WHERE z < 5 +) SELECT sum(z) FROM t) AS z +FROM generate_series(1,2) AS _(x), generate_series(1,2) AS __(y) order by all; +-- +ok +== +SELECT x, y +FROM generate_series(1,4) AS _(x), LATERAL +(WITH RECURSIVE t(y) AS MATERIALIZED ( + SELECT _.x + UNION + SELECT y + 1 + FROM t + WHERE y < 3 +) +SELECT * FROM t) AS t +ORDER BY x, y; +-- +ok +== +SELECT x, y +FROM generate_series(1,4) AS _(x), LATERAL +(WITH RECURSIVE t(y) AS MATERIALIZED ( + SELECT 1 + UNION + SELECT y + _.x + FROM t + WHERE y < 3 +) +SELECT * FROM t) AS t +ORDER BY x, y; +-- +ok +== +SELECT x, y +FROM generate_series(1,4) AS _(x), LATERAL +(WITH RECURSIVE t(y) AS MATERIALIZED ( + SELECT _.x + UNION + SELECT y + _.x + FROM t + WHERE y < 3 +) +SELECT * FROM t) AS t +ORDER BY x, y; +-- +ok +== +SELECT x, y +FROM generate_series(1,4) AS _(x), LATERAL +(WITH RECURSIVE t(y) AS MATERIALIZED ( + SELECT _.x + UNION + SELECT t1.y + t2.y + _.x + FROM t AS t1, t AS t2 + WHERE t1.y < 3 +) +SELECT * FROM t) AS t +ORDER BY x, y; +-- +ok +== +SELECT x, y, (WITH RECURSIVE t(z) AS MATERIALIZED ( + SELECT x + y + UNION + SELECT z + 1 + FROM t + WHERE z < 3 +) SELECT sum(z) FROM t) AS z +FROM generate_series(1,2) AS _(x), generate_series(1,2) AS __(y) order by all; +-- +ok +== +SELECT x, y, (WITH RECURSIVE t(z) AS MATERIALIZED ( + SELECT x + y + UNION + SELECT z + 1 + FROM (WITH RECURSIVE g(a) AS MATERIALIZED ( + SELECT t.z + FROM t + UNION + SELECT g.a + (x + y) / 2 + FROM g + WHERE g.a < 3) + SELECT * FROM g) AS t(z) + WHERE z < 5 +) SELECT sum(z) FROM t) AS z +FROM generate_series(1,2) AS _(x), generate_series(1,2) AS __(y) order by all; +-- +ok +== diff --git a/parser/testdata/corpus/sql/cte/materialized/test_cte_hash_join_exchange.test b/parser/testdata/corpus/sql/cte/materialized/test_cte_hash_join_exchange.test new file mode 100644 index 0000000..b9b7b2f --- /dev/null +++ b/parser/testdata/corpus/sql/cte/materialized/test_cte_hash_join_exchange.test @@ -0,0 +1,319 @@ +# source: test/sql/cte/materialized/test_cte_hash_join_exchange.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +SET disabled_optimizers='join_order,build_side_probe_side'; +-- +ok +== +WITH c AS MATERIALIZED (SELECT i FROM range(10000) t(i)) +SELECT count(*) FROM range(10000) l(i) JOIN c ON l.i=c.i; +-- +ok +== +EXPLAIN ANALYZE WITH c AS MATERIALIZED (SELECT i FROM range(10000) t(i)) +SELECT count(*) FROM range(10000) l(i) JOIN c ON l.i=c.i; +-- +ok +== +WITH c AS MATERIALIZED (SELECT i FROM range(10000) t(i)) +SELECT count(*) FROM c JOIN range(10000) r(i) ON c.i=r.i; +-- +ok +== +EXPLAIN ANALYZE WITH c AS MATERIALIZED (SELECT i FROM range(10000) t(i)) +SELECT count(*) FROM c JOIN range(10000) r(i) ON c.i=r.i; +-- +ok +== +WITH c AS MATERIALIZED (SELECT i FROM range(10000) t(i)) +SELECT count(*) FROM c l JOIN c r USING (i); +-- +ok +== +EXPLAIN ANALYZE WITH c AS MATERIALIZED (SELECT i FROM range(10000) t(i)) +SELECT count(*) FROM c l JOIN c r USING (i); +-- +ok +== +WITH c AS MATERIALIZED (SELECT i FROM range(10000) t(i)) +SELECT (SELECT i FROM c ORDER BY i LIMIT 1), + (SELECT count(*) FROM c JOIN range(10000) r(i) USING (i)), + (SELECT count(*) FROM c JOIN range(10000) r(i) USING (i)); +-- +ok +== +EXPLAIN ANALYZE +WITH c AS MATERIALIZED (SELECT i FROM range(10000) t(i)) +SELECT (SELECT i FROM c ORDER BY i LIMIT 1), + (SELECT count(*) FROM c JOIN range(10000) r(i) USING (i)), + (SELECT count(*) FROM c JOIN range(10000) r(i) USING (i)); +-- +ok +== +WITH c AS MATERIALIZED (SELECT i FROM range(10000) t(i)) +SELECT (SELECT sum(i) FROM c), + (SELECT count(*) FROM c JOIN range(10000) r(i) USING (i)); +-- +ok +== +EXPLAIN ANALYZE +WITH c AS MATERIALIZED (SELECT i FROM range(10000) t(i)) +SELECT (SELECT sum(i) FROM c), + (SELECT count(*) FROM c JOIN range(10000) r(i) USING (i)); +-- +ok +== +WITH c(i) AS MATERIALIZED (VALUES (1), (2), (2), (NULL)), b(i) AS (VALUES (2), (3), (NULL)) +SELECT count(*) FROM c INNER JOIN b ON c.i=b.i; +-- +ok +== +WITH c(i) AS MATERIALIZED (VALUES (1), (2), (2), (NULL)), b(i) AS (VALUES (2), (3), (NULL)) +SELECT count(*) FROM c LEFT JOIN b ON c.i=b.i; +-- +ok +== +WITH c(i) AS MATERIALIZED (VALUES (1), (2), (2), (NULL)), b(i) AS (VALUES (2), (3), (NULL)) +SELECT count(*) FROM c RIGHT JOIN b ON c.i=b.i; +-- +ok +== +WITH c(i) AS MATERIALIZED (VALUES (1), (2), (2), (NULL)), b(i) AS (VALUES (2), (3), (NULL)) +SELECT count(*) FROM c FULL JOIN b ON c.i=b.i; +-- +ok +== +EXPLAIN ANALYZE +WITH c(i) AS MATERIALIZED (VALUES (1), (2), (2), (NULL)), b(i) AS (VALUES (2), (3), (NULL)) +SELECT count(*) FROM c FULL JOIN b ON c.i=b.i; +-- +ok +== +WITH c(i) AS MATERIALIZED (VALUES (1), (2), (2), (NULL)), b(i) AS (VALUES (2), (3), (NULL)) +SELECT count(*) FROM c SEMI JOIN b ON c.i=b.i; +-- +ok +== +WITH c(i) AS MATERIALIZED (VALUES (1), (2), (2), (NULL)), b(i) AS (VALUES (2), (3), (NULL)) +SELECT count(*) FROM c ANTI JOIN b ON c.i=b.i; +-- +ok +== +WITH c AS MATERIALIZED (SELECT i FROM range(0) t(i)) +SELECT count(*) FROM range(10) l(i) LEFT JOIN c ON l.i=c.i; +-- +ok +== +WITH c AS MATERIALIZED ( + SELECT i FROM range(1000) t(i) + UNION ALL + SELECT i + 1000 FROM range(1000) t(i) +) +SELECT count(*) FROM range(2000) l(i) JOIN c ON l.i=c.i; +-- +ok +== +WITH a AS MATERIALIZED (SELECT i FROM range(10000) t(i)), + b AS MATERIALIZED (SELECT i FROM a) +SELECT count(*) FROM range(10000) r(i) JOIN b ON r.i=b.i; +-- +ok +== +WITH l AS MATERIALIZED (SELECT i FROM range(10000) t(i)), + r AS MATERIALIZED (SELECT i FROM range(10000) t(i)) +SELECT count(*) FROM ( + SELECT l.i FROM l JOIN r USING (i) + UNION ALL + SELECT l.i FROM l JOIN r USING (i) +); +-- +ok +== +EXPLAIN ANALYZE +WITH l AS MATERIALIZED (SELECT i FROM range(10000) t(i)), + r AS MATERIALIZED (SELECT i FROM range(10000) t(i)) +SELECT count(*) FROM ( + SELECT l.i FROM l JOIN r USING (i) + UNION ALL + SELECT l.i FROM l JOIN r USING (i) +); +-- +ok +== +WITH l AS MATERIALIZED (SELECT i FROM range(10000) t(i)), + r AS MATERIALIZED (SELECT i FROM range(10000) t(i)) +SELECT count(*) FROM ( + SELECT l.i FROM l JOIN r USING (i) + UNION ALL + SELECT l.i FROM r JOIN l USING (i) +); +-- +ok +== +EXPLAIN ANALYZE +WITH l AS MATERIALIZED (SELECT i FROM range(10000) t(i)), + r AS MATERIALIZED (SELECT i FROM range(10000) t(i)) +SELECT count(*) FROM ( + SELECT l.i FROM l JOIN r USING (i) + UNION ALL + SELECT l.i FROM r JOIN l USING (i) +); +-- +ok +== +WITH c(i) AS MATERIALIZED (VALUES (1), (2), (NULL)) +SELECT count(*) FILTER (WHERE marker IS TRUE), + count(*) FILTER (WHERE marker IS FALSE), + count(*) FILTER (WHERE marker IS NULL) +FROM ( + SELECT i IN (SELECT i FROM c) marker + FROM (VALUES (1), (3), (NULL)) o(i) +); +-- +ok +== +EXPLAIN ANALYZE +WITH c(i) AS MATERIALIZED (VALUES (1), (2), (NULL)) +SELECT count(*) FILTER (WHERE marker IS TRUE) +FROM ( + SELECT i IN (SELECT i FROM c) marker + FROM (VALUES (1), (3), (NULL)) o(i) +); +-- +ok +== +WITH c(i) AS MATERIALIZED (VALUES (1), (2), (NULL)) +SELECT sum((SELECT i FROM c WHERE c.i=o.i)) +FROM (VALUES (1), (3)) o(i); +-- +ok +== +EXPLAIN ANALYZE +WITH c(i) AS MATERIALIZED (VALUES (1), (2), (NULL)) +SELECT sum((SELECT i FROM c WHERE c.i=o.i)) +FROM (VALUES (1), (3)) o(i); +-- +ok +== +CREATE SEQUENCE cte_hash_sequence; +-- +ok +== +WITH c AS MATERIALIZED ( + SELECT nextval('cte_hash_sequence') AS i FROM range(3) +) +SELECT count(*) FROM c JOIN range(1, 4) r(i) ON c.i=r.i; +-- +ok +== +SELECT currval('cte_hash_sequence'); +-- +ok +== +PREPARE cte_hash_join AS +WITH c AS MATERIALIZED (SELECT i FROM range(1000) t(i)) +SELECT count(*) FROM c JOIN range(1000) r(i) ON c.i=r.i; +-- +ok +== +EXECUTE cte_hash_join; +-- +ok +== +SET memory_limit='64MB'; +-- +ok +== +SET operator_memory_limit='256KB'; +-- +ok +== +EXPLAIN ANALYZE +WITH c AS MATERIALIZED ( + SELECT i, repeat('x', 32) payload FROM range(10000) t(i) +) +SELECT (SELECT sum(length(payload)) FROM c), + (SELECT count(*) FROM c JOIN range(10000) r(i) USING (i)); +-- +ok +== +EXPLAIN ANALYZE +WITH c AS MATERIALIZED ( + SELECT i, repeat('x', 32) payload FROM range(10000) t(i) +) +SELECT count(*), sum(length(l.payload)) +FROM c l JOIN c r USING (i); +-- +ok +== +EXPLAIN ANALYZE +WITH c AS MATERIALIZED ( + SELECT i, repeat('x', 32) payload FROM range(10000) t(i) +) +SELECT (SELECT sum(length(l.payload)) FROM c l JOIN c r USING (i)), + (SELECT sum(length(c.payload)) FROM range(10000) x(i) JOIN c USING (i)); +-- +ok +== +WITH c AS MATERIALIZED ( + SELECT i, repeat('x', 32) payload FROM range(10000) t(i) +) +SELECT branch, count(*), sum(v) +FROM ( + SELECT 1 branch, length(c.payload) v FROM c JOIN range(10000) r(i) USING (i) + UNION ALL + SELECT 2 branch, length(c.payload) v FROM c JOIN range(10000) r(i) USING (i) +) +GROUP BY branch +ORDER BY branch; +-- +ok +== +EXPLAIN ANALYZE +WITH c AS MATERIALIZED ( + SELECT i, repeat('x', 32) payload FROM range(10000) t(i) +) +SELECT count(*) +FROM ( + SELECT c.i FROM c JOIN range(10000) r(i) USING (i) + UNION ALL + SELECT c.i FROM c JOIN range(10000) r(i) USING (i) +); +-- +ok +== +CREATE TABLE cte_empty_stats AS SELECT i FROM range(1000) t(i); +-- +ok +== +DELETE FROM cte_empty_stats; +-- +ok +== +EXPLAIN ANALYZE +WITH huge AS MATERIALIZED ( + SELECT h.i FROM range(9223372036854775807) h(i), cte_empty_stats e +), +large AS MATERIALIZED ( + SELECT h.i FROM range(2000000) h(i), cte_empty_stats e +) +SELECT (SELECT count(*) FROM huge l JOIN huge r USING (i)), + (SELECT count(*) FROM large l JOIN large r USING (i)); +-- +ok +== +RESET operator_memory_limit; +-- +ok +== +WITH c AS MATERIALIZED (SELECT i FROM range(1000) t(i)) +SELECT count(*) FROM c l JOIN c r USING (i); +-- +ok +== +RESET disabled_optimizers; +-- +ok +== diff --git a/parser/testdata/corpus/sql/cte/materialized/test_cte_in_cte_materialized.test b/parser/testdata/corpus/sql/cte/materialized/test_cte_in_cte_materialized.test new file mode 100644 index 0000000..84da086 --- /dev/null +++ b/parser/testdata/corpus/sql/cte/materialized/test_cte_in_cte_materialized.test @@ -0,0 +1,45 @@ +# source: test/sql/cte/materialized/test_cte_in_cte_materialized.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +with cte1 as MATERIALIZED (Select i as j from a) select * from cte1; +-- +ok +== +with cte1 as MATERIALIZED (with b as MATERIALIZED (Select i as j from a) Select j from b) select x from cte1 t1(x); +-- +ok +== +with cte1(xxx) as MATERIALIZED (with ncte(yyy) as MATERIALIZED (Select i as j from a) Select yyy from ncte) select xxx from cte1; +-- +ok +== +with cte1 as MATERIALIZED (with b as MATERIALIZED (Select i as j from a) select j from b), cte2 as MATERIALIZED (with c as MATERIALIZED (select ref.j+1 as k from cte1 as ref) select k from c) select * from cte1 , cte2; +-- +ok +== +with cte1 as MATERIALIZED (select 42), cte1 as MATERIALIZED (select 42) select * FROM cte1; +-- +error: Parser Error: Duplicate CTE name "cte1" +== +with cte1 as MATERIALIZED (Select i as j from a) select * from (with cte2 as MATERIALIZED (select max(j) as j from cte1) select * from cte2) f +-- +ok +== +with cte1 as MATERIALIZED (Select i as j from a) select * from cte1 where j = (with cte2 as MATERIALIZED (select max(j) as j from cte1) select j from cte2); +-- +ok +== +with cte as materialized (Select i as j from a) select * from cte where j = (with cte as (select max(j) as j from cte) select j from cte); +-- +ok +== +with cte as MATERIALIZED (Select i as j from a) select * from cte where j = (with cte as MATERIALIZED (select max(j) as j from cte) select j from cte); +-- +ok +== +with cte as MATERIALIZED (select * from cte) select * from cte +-- +ok +== diff --git a/parser/testdata/corpus/sql/cte/materialized/test_cte_in_cte_materialized.test.metadata.json b/parser/testdata/corpus/sql/cte/materialized/test_cte_in_cte_materialized.test.metadata.json new file mode 100644 index 0000000..42eca95 --- /dev/null +++ b/parser/testdata/corpus/sql/cte/materialized/test_cte_in_cte_materialized.test.metadata.json @@ -0,0 +1,5 @@ +{ + "todo": { + "2ff0e65fff596023": "transformer-raised parser error: upstream rejects in the transformer, not the grammar; expected to clear as transformers land (milestones 3-5)" + } +} diff --git a/parser/testdata/corpus/sql/cte/materialized/test_cte_materialized.test b/parser/testdata/corpus/sql/cte/materialized/test_cte_materialized.test new file mode 100644 index 0000000..0674477 --- /dev/null +++ b/parser/testdata/corpus/sql/cte/materialized/test_cte_materialized.test @@ -0,0 +1,105 @@ +# source: test/sql/cte/materialized/test_cte_materialized.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +with cte1 as MATERIALIZED (Select i as j from a) select x from cte1 t1(x); +-- +ok +== +with cte1(xxx) as MATERIALIZED (Select i as j from a) select xxx from cte1; +-- +ok +== +with cte1(xxx) as MATERIALIZED (Select i as j from a) select x from cte1 t1(x); +-- +ok +== +with cte1 as MATERIALIZED (Select i as j from a), cte2 as MATERIALIZED (select ref.j as k from cte1 as ref), cte3 as MATERIALIZED (select ref2.j+1 as i from cte1 as ref2) select * from cte2 , cte3; +-- +ok +== +with cte1 as MATERIALIZED (select i as j from a), cte2 as MATERIALIZED (select ref.j as k from cte1 as ref), cte3 as MATERIALIZED (select ref2.j+1 as i from cte1 as ref2) select * from cte2 union all select * FROM cte3; +-- +ok +== +with cte3 as MATERIALIZED (select ref2.j as i from cte1 as ref2), cte1 as MATERIALIZED (Select i as j from a), cte2 as MATERIALIZED (select ref.j+1 as k from cte1 as ref) select * from cte2 union all select * FROM cte3; +-- +ok +== +with cte1 as MATERIALIZED (Select i as j from a) select * from cte1 cte11, cte1 cte12; +-- +ok +== +with cte1 as MATERIALIZED (Select i as j from a) select * from cte1 where j = (select max(j) from cte1 as cte2); +-- +ok +== +with cte1(x, y) as MATERIALIZED (select 42 a, 84 b) select zzz, y from cte1 t1(zzz); +-- +ok +== +create view va AS (with cte as MATERIALIZED (Select i as j from a) select * from cte); +-- +ok +== +select * from va +-- +ok +== +with cte AS MATERIALIZED (SELECT * FROM va) SELECT * FROM cte; +-- +ok +== +create view vb AS (with cte1 as MATERIALIZED (Select i as j from a), cte2 as MATERIALIZED (select ref.j+1 as k from cte1 as ref) select * from cte2); +-- +ok +== +select * from vb +-- +ok +== +SELECT 1 UNION ALL (WITH cte AS MATERIALIZED (SELECT 42) SELECT * FROM cte); +-- +ok +== +WITH RECURSIVE cte(d) AS MATERIALIZED ( + SELECT 1 + UNION ALL + (WITH c(d) AS (SELECT * FROM cte) + SELECT d + 1 + FROM c + WHERE FALSE + ) +) +SELECT max(d) FROM cte; +-- +ok +== +with cte (a) as MATERIALIZED ( + select 1 +) +select + a as alias1, + alias1 as alias2 +from cte +where alias2 > 0; +-- +ok +== +WITH RECURSIVE t(x,v) AS ( + SELECT 1, ARRAY[] :: int[] + UNION ALL + (WITH u(x) AS MATERIALIZED (SELECT 1) + SELECT f.x, (SELECT array_agg(x) FROM u) + FROM t, LATERAL (SELECT t.x + 1) AS f(x) + WHERE t.x < 5 + ) +) SELECT * FROM t ORDER BY x; +-- +ok +== +SELECT * FROM (WITH t(x) AS MATERIALIZED (SELECT * FROM generate_series(1,10) LIMIT 75%) SELECT * FROM t LIMIT 80%) AS _(x) ORDER BY x LIMIT 50%; +-- +ok +== diff --git a/parser/testdata/corpus/sql/cte/materialized/test_cte_overflow_materialized.test b/parser/testdata/corpus/sql/cte/materialized/test_cte_overflow_materialized.test new file mode 100644 index 0000000..7e99eae --- /dev/null +++ b/parser/testdata/corpus/sql/cte/materialized/test_cte_overflow_materialized.test @@ -0,0 +1,21 @@ +# source: test/sql/cte/materialized/test_cte_overflow_materialized.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +create table a (id integer) +-- +ok +== +insert into a values (1729) +-- +ok +== +create view va as (with v as MATERIALIZED (select * from a) select * from v) +-- +ok +== +with a as MATERIALIZED (select * from va) select * from a +-- +ok +== diff --git a/parser/testdata/corpus/sql/cte/materialized/test_issue_10260.test b/parser/testdata/corpus/sql/cte/materialized/test_issue_10260.test new file mode 100644 index 0000000..10fac4d --- /dev/null +++ b/parser/testdata/corpus/sql/cte/materialized/test_issue_10260.test @@ -0,0 +1,30 @@ +# source: test/sql/cte/materialized/test_issue_10260.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +CREATE TABLE T0(C1 INT); +-- +ok +== +CREATE TABLE T1(C1 INT); +-- +ok +== +INSERT INTO T0(C1) VALUES (1); +-- +ok +== +INSERT INTO T1(C1) VALUES (1); +-- +ok +== +WITH CTE AS MATERIALIZED ( +SELECT A1, * FROM T0 + LEFT JOIN ( + SELECT C1 AS A1 FROM T1 + ) ON T0.C1 = A1 +) SELECT A1 FROM CTE; +-- +ok +== diff --git a/parser/testdata/corpus/sql/cte/materialized/test_materialized_cte.test b/parser/testdata/corpus/sql/cte/materialized/test_materialized_cte.test new file mode 100644 index 0000000..6aad163 --- /dev/null +++ b/parser/testdata/corpus/sql/cte/materialized/test_materialized_cte.test @@ -0,0 +1,214 @@ +# source: test/sql/cte/materialized/test_materialized_cte.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +WITH t(x) AS MATERIALIZED (SELECT 1) SELECT * FROM t; +-- +ok +== +EXPLAIN WITH t AS MATERIALIZED (SELECT i FROM range(3) tbl(i)) +SELECT * FROM t LIMIT 1; +-- +ok +== +EXPLAIN ANALYZE WITH d AS (SELECT i AS a, i AS b FROM range(10) tbl(i)) +SELECT (SELECT sum(a) FROM d), (SELECT sum(b) FROM d); +-- +ok +== +EXPLAIN ANALYZE WITH d AS MATERIALIZED (SELECT i FROM range(10000) tbl(i)) +SELECT sum(i) FROM d; +-- +ok +== +EXPLAIN ANALYZE WITH d AS MATERIALIZED (SELECT i FROM range(10) tbl(i)) +SELECT * FROM d ORDER BY i LIMIT 3; +-- +ok +== +EXPLAIN ANALYZE WITH d AS (SELECT i AS a FROM range(10) tbl(i)) +SELECT * FROM (SELECT sum(a) FROM d), (SELECT a FROM d ORDER BY a LIMIT 1); +-- +ok +== +EXPLAIN ANALYZE WITH d AS (SELECT i AS a FROM range(10) tbl(i)) +SELECT * FROM (SELECT sum(a) FROM d), (SELECT a FROM d LIMIT 1); +-- +ok +== +WITH t(x) AS MATERIALIZED (SELECT t FROM generate_series(1,3) AS _(t)) SELECT t1.x,1 as y FROM t AS t1 ORDER BY x; +-- +ok +== +WITH t(x) AS MATERIALIZED (SELECT t FROM generate_series(1,3) AS _(t)) SELECT t1.x, t1.x FROM t AS t1 ORDER BY x; +-- +ok +== +WITH t(x) AS MATERIALIZED (SELECT t FROM generate_series(1,3) AS _(t)) SELECT t1.x, t2.x FROM t AS t1, t AS t2 ORDER BY t1.x, t2.x; +-- +ok +== +WITH t AS MATERIALIZED (SELECT i FROM range(3) tbl(i)) +SELECT sum(a.i + b.i) FROM t a, t b; +-- +ok +== +WITH t AS MATERIALIZED ( + SELECT CASE WHEN i > 5000000 THEN error('cte should not fully materialize') ELSE i END AS i + FROM range(10000000) tbl(i) +) +SELECT * FROM t LIMIT 5; +-- +ok +== +WITH d AS MATERIALIZED ( + SELECT + CASE WHEN i > 80000 THEN error('cte limit should stop producer') ELSE i END AS c00, + i AS c01, i AS c02, i AS c03, i AS c04, i AS c05, i AS c06, i AS c07, + i AS c08, i AS c09, i AS c10, i AS c11, i AS c12, i AS c13, i AS c14, i AS c15, + i AS c16, i AS c17, i AS c18, i AS c19, i AS c20, i AS c21, i AS c22, i AS c23, + i AS c24, i AS c25, i AS c26, i AS c27, i AS c28, i AS c29, i AS c30, i AS c31, + i AS c32, i AS c33, i AS c34, i AS c35, i AS c36, i AS c37, i AS c38, i AS c39, + i AS c40, i AS c41, i AS c42, i AS c43, i AS c44, i AS c45, i AS c46, i AS c47, + i AS c48, i AS c49, i AS c50, i AS c51, i AS c52, i AS c53, i AS c54, i AS c55, + i AS c56, i AS c57, i AS c58, i AS c59, i AS c60, i AS c61, i AS c62, i AS c63 + FROM range(1000000) tbl(i) +) +SELECT sum(c00 + c01 + c02 + c03 + c04 + c05 + c06 + c07 + + c08 + c09 + c10 + c11 + c12 + c13 + c14 + c15 + + c16 + c17 + c18 + c19 + c20 + c21 + c22 + c23 + + c24 + c25 + c26 + c27 + c28 + c29 + c30 + c31 + + c32 + c33 + c34 + c35 + c36 + c37 + c38 + c39 + + c40 + c41 + c42 + c43 + c44 + c45 + c46 + c47 + + c48 + c49 + c50 + c51 + c52 + c53 + c54 + c55 + + c56 + c57 + c58 + c59 + c60 + c61 + c62 + c63) +FROM (SELECT * FROM d LIMIT 10); +-- +ok +== +WITH d AS MATERIALIZED ( + SELECT + i AS c00, + i AS c01, i AS c02, i AS c03, i AS c04, i AS c05, i AS c06, i AS c07, + i AS c08, i AS c09, i AS c10, i AS c11, i AS c12, i AS c13, i AS c14, i AS c15 + FROM range(300000) tbl(i) +) +SELECT (SELECT sum(c00 + c01 + c02 + c03 + c04 + c05 + c06 + c07 + + c08 + c09 + c10 + c11 + c12 + c13 + c14 + c15) + FROM (SELECT * FROM d LIMIT 10)), + (SELECT sum(c00 + c01 + c02 + c03 + c04 + c05 + c06 + c07 + + c08 + c09 + c10 + c11 + c12 + c13 + c14 + c15) + FROM (SELECT * FROM d LIMIT 10)); +-- +ok +== +WITH d AS ( + SELECT + i AS c00, i + 1 AS c01, i + 2 AS c02, i + 3 AS c03, i + 4 AS c04, + i + 5 AS c05, i + 6 AS c06, i + 7 AS c07, i + 8 AS c08, i + 9 AS c09, + i + 10 AS c10, i + 11 AS c11, i + 12 AS c12, i + 13 AS c13, i + 14 AS c14, + i + 15 AS c15, i + 16 AS c16, i + 17 AS c17, i + 18 AS c18, i + 19 AS c19 + FROM range(220000) tbl(i) + GROUP BY ALL +) +SELECT (SELECT count(c00) FROM d), (SELECT count(c01) FROM d); +-- +ok +== +WITH d AS MATERIALIZED ( + SELECT i, i AS q + FROM range(256) tbl(i) +) +SELECT count(*) +FROM d lhs +WHERE q < (SELECT avg(q) + 1 FROM d rhs WHERE rhs.i = lhs.i); +-- +ok +== +EXPLAIN ANALYZE WITH d AS MATERIALIZED ( + SELECT i % 8 AS k, i AS v + FROM range(64) tbl(i) +) +SELECT count(*) +FROM d lhs +WHERE v < (SELECT avg(v) + 1 FROM d rhs WHERE rhs.k = lhs.k); +-- +ok +== +WITH d AS ( + SELECT i::INTEGER AS c0, CASE WHEN i % 4 = 0 THEN NULL ELSE i::INTEGER END AS c1 + FROM range(16) tbl(i) +) +SELECT (SELECT sum(c0) FROM d), (SELECT sum(c1) FROM d), (SELECT count(c0) FROM d), (SELECT count(c1) FROM d); +-- +ok +== +WITH d AS ( + SELECT + i AS c00, i + 1 AS c01, i + 2 AS c02, i + 3 AS c03, i + 4 AS c04, + i + 5 AS c05, i + 6 AS c06, i + 7 AS c07, i + 8 AS c08, i + 9 AS c09, + i + 10 AS c10, i + 11 AS c11, i + 12 AS c12, i + 13 AS c13, i + 14 AS c14, + i + 15 AS c15, i + 16 AS c16, i + 17 AS c17, i + 18 AS c18, i + 19 AS c19, + i + 20 AS c20, i + 21 AS c21, i + 22 AS c22, i + 23 AS c23, i + 24 AS c24, + i + 25 AS c25, i + 26 AS c26, i + 27 AS c27, i + 28 AS c28, i + 29 AS c29, + i + 30 AS c30, i + 31 AS c31, i + 32 AS c32, i + 33 AS c33, i + 34 AS c34, + i + 35 AS c35, i + 36 AS c36, i + 37 AS c37, i + 38 AS c38, i + 39 AS c39, + i + 40 AS c40, i + 41 AS c41, i + 42 AS c42, i + 43 AS c43, i + 44 AS c44, + i + 45 AS c45, i + 46 AS c46, i + 47 AS c47, i + 48 AS c48, i + 49 AS c49, + i + 50 AS c50, i + 51 AS c51, i + 52 AS c52, i + 53 AS c53, i + 54 AS c54, + i + 55 AS c55, i + 56 AS c56, i + 57 AS c57, i + 58 AS c58, i + 59 AS c59, + i + 60 AS c60, i + 61 AS c61, i + 62 AS c62, i + 63 AS c63 + FROM range(70000) tbl(i) +) +SELECT (SELECT sum(c00) FROM d), + (SELECT sum(c00 + c01 + c02 + c03 + c04 + c05 + c06 + c07 + + c08 + c09 + c10 + c11 + c12 + c13 + c14 + c15 + + c16 + c17 + c18 + c19 + c20 + c21 + c22 + c23 + + c24 + c25 + c26 + c27 + c28 + c29 + c30 + c31 + + c32 + c33 + c34 + c35 + c36 + c37 + c38 + c39 + + c40 + c41 + c42 + c43 + c44 + c45 + c46 + c47 + + c48 + c49 + c50 + c51 + c52 + c53 + c54 + c55 + + c56 + c57 + c58 + c59 + c60 + c61 + c62 + c63) + FROM (SELECT * FROM d ORDER BY c00 DESC LIMIT 10)); +-- +ok +== +WITH t(x) AS MATERIALIZED (SELECT 1), + u(x) AS MATERIALIZED (SELECT 2) + SELECT * + FROM u FULL OUTER JOIN t ON TRUE; +-- +ok +== +WITH t(x) AS MATERIALIZED (SELECT x FROM generate_series(1,10) AS _(x) limit 4) SELECT DISTINCT x FROM t order by x desc; +-- +ok +== +WITH t(x) AS MATERIALIZED (SELECT x FROM generate_series(1,10) AS _(x) limit 4) SELECT DISTINCT x FROM t order by x desc LIMIT 2; +-- +ok +== +WITH t(x) AS MATERIALIZED ( + WITH u(x) AS MATERIALIZED ( + SELECT 42 + ) SELECT * FROM u +) SELECT * FROM t; +-- +ok +== +WITH t(x) AS MATERIALIZED (SELECT 1), + u(x) AS MATERIALIZED (SELECT x+1 FROM t) + TABLE u UNION ALL TABLE t; +-- +ok +== +WITH t0(x) AS MATERIALIZED ( + SELECT x FROM t1 +), t1(x) AS MATERIALIZED ( + SELECT 1 +) +SELECT * FROM t0; +-- +ok +== diff --git a/parser/testdata/corpus/sql/cte/materialized/test_nested_recursive_cte_materialized.test b/parser/testdata/corpus/sql/cte/materialized/test_nested_recursive_cte_materialized.test new file mode 100644 index 0000000..77436e6 --- /dev/null +++ b/parser/testdata/corpus/sql/cte/materialized/test_nested_recursive_cte_materialized.test @@ -0,0 +1,43 @@ +# source: test/sql/cte/materialized/test_nested_recursive_cte_materialized.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +WITH RECURSIVE t(x) AS MATERIALIZED +( + SELECT 1 + UNION ALL + SELECT x+1 + FROM t + WHERE x < 4 +), +u(x) AS MATERIALIZED +( + SELECT * + FROM t + UNION ALL + SELECT u.x * 2 + t.x + FROM u, t + WHERE u.x < 32 +) +SELECT * +FROM u +ORDER BY x +LIMIT 5; +-- +ok +== +WITH RECURSIVE collatz(x, t, steps) AS MATERIALIZED +( + SELECT x, x, 0 + FROM (WITH RECURSIVE n(t) AS (SELECT 1 UNION ALL SELECT t+1 FROM n WHERE t < 10) SELECT * FROM n) AS _(x) + UNION ALL + (SELECT x, CASE WHEN t%2 = 1 THEN t * 3 + p ELSE t / 2 END, steps + p + FROM collatz, (WITH RECURSIVE n(t) AS (SELECT 1 UNION ALL SELECT t+1 FROM n WHERE t < 1) SELECT * FROM n) AS _(p) + WHERE t <> 1) +) +SELECT * FROM collatz WHERE t = 1 +ORDER BY x; +-- +ok +== diff --git a/parser/testdata/corpus/sql/cte/materialized/test_outer_joins_recursive_cte_materialized.test b/parser/testdata/corpus/sql/cte/materialized/test_outer_joins_recursive_cte_materialized.test new file mode 100644 index 0000000..4330e66 --- /dev/null +++ b/parser/testdata/corpus/sql/cte/materialized/test_outer_joins_recursive_cte_materialized.test @@ -0,0 +1,37 @@ +# source: test/sql/cte/materialized/test_outer_joins_recursive_cte_materialized.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +CREATE TABLE v(x INT); +-- +ok +== +INSERT INTO v +VALUES +(1),(2),(3); +-- +ok +== +WITH RECURSIVE t(x) AS MATERIALIZED +( + SELECT 1 + UNION ALL + SELECT x + 1 + FROM (SELECT t.x+1 FROM v AS _(p) FULL OUTER JOIN t ON t.x = p) AS _(x) + WHERE x < 10 +) SELECT * FROM v AS _(p) RIGHT OUTER JOIN t ON t.x = p ORDER BY p, x NULLS LAST; +-- +ok +== +WITH RECURSIVE t(x) AS MATERIALIZED +( + SELECT 1 + UNION ALL + SELECT COALESCE(t.x, p) + 1 + FROM (VALUES (NULL::INTEGER)) AS v(p) FULL OUTER JOIN t ON t.x <= p + WHERE COALESCE(t.x, p) < 3 +) SELECT * FROM t ORDER BY x; +-- +ok +== diff --git a/parser/testdata/corpus/sql/cte/materialized/test_recursive_cte_tutorial_materialized.test b/parser/testdata/corpus/sql/cte/materialized/test_recursive_cte_tutorial_materialized.test new file mode 100644 index 0000000..0b9aebc --- /dev/null +++ b/parser/testdata/corpus/sql/cte/materialized/test_recursive_cte_tutorial_materialized.test @@ -0,0 +1,111 @@ +# source: test/sql/cte/materialized/test_recursive_cte_tutorial_materialized.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +CREATE TABLE emp (empno INTEGER PRIMARY KEY, + ename VARCHAR, + job VARCHAR, + mgr INTEGER, + hiredate DATE, + sal DOUBLE, + comm DOUBLE, + deptno INTEGER); +-- +ok +== +INSERT INTO emp VALUES (7839, 'KING', 'PRESIDENT', NULL, DATE '1981-11-17', 5000.00, NULL, 10); +INSERT INTO emp VALUES (7698, 'BLAKE', 'MANAGER', 7839, DATE '1981-05-01', 2850.00, NULL, 30); +INSERT INTO emp VALUES (7782, 'CLARK', 'MANAGER', 7839, DATE '1981-06-09', 2450.00, NULL, 10); +INSERT INTO emp VALUES (7566, 'JONES', 'MANAGER', 7839, DATE '1981-04-02', 2975.00, NULL, 20); +INSERT INTO emp VALUES (7902, 'FORD', 'ANALYST', 7566, DATE '1981-12-03', 3000.00, NULL, 20); +INSERT INTO emp VALUES (7369, 'SMITH', 'CLERK', 7902, DATE '1980-12-17', 800.00, NULL, 20); +INSERT INTO emp VALUES (7499, 'ALLEN', 'SALESMAN', 7698, DATE '1981-02-20', 1600.00, 300.00, 30); +INSERT INTO emp VALUES (7521, 'WARD', 'SALESMAN', 7698, DATE '1981-02-22', 1250.00, 500.00, 30); +INSERT INTO emp VALUES (7654, 'MARTIN', 'SALESMAN', 7698, DATE '1981-09-28', 1250.00, 1400.00, 30); +INSERT INTO emp VALUES (7844, 'TURNER', 'SALESMAN', 7698, DATE '1981-09-08', 1500.00, 0.00, 30); +INSERT INTO emp VALUES (7900, 'JAMES', 'CLERK', 7698, DATE '1981-12-03', 950.00, NULL, 30); +INSERT INTO emp VALUES (7934, 'MILLER', 'CLERK', 7782, DATE '1982-01-23', 1300.00, NULL, 10); +-- +ok +== +WITH RECURSIVE ctename AS MATERIALIZED ( + SELECT empno, ename + FROM emp + WHERE empno = 7566 + UNION ALL + SELECT emp.empno, emp.ename + FROM emp + JOIN ctename ON emp.mgr = ctename.empno +) +SELECT * FROM ctename; +-- +ok +== +WITH RECURSIVE ctename AS MATERIALIZED ( + SELECT empno, ename, + 0 AS level + FROM emp + WHERE empno = 7566 + UNION ALL + SELECT emp.empno, emp.ename, + ctename.level + 1 + FROM emp + JOIN ctename ON emp.mgr = ctename.empno +) +SELECT * FROM ctename; +-- +ok +== +WITH RECURSIVE ctename AS MATERIALIZED ( + SELECT empno, ename, + ename AS path + FROM emp + WHERE empno = 7566 + UNION ALL + SELECT emp.empno, emp.ename, + ctename.path || ' -> ' || emp.ename + FROM emp + JOIN ctename ON emp.mgr = ctename.empno +) +SELECT * FROM ctename; +-- +ok +== +CREATE VIEW ctenames AS ( + WITH RECURSIVE ctename AS MATERIALIZED ( + SELECT empno, ename, + ename AS path + FROM emp + WHERE empno = 7566 + UNION ALL + SELECT emp.empno, emp.ename, + ctename.path || ' -> ' || emp.ename + FROM emp + JOIN ctename ON emp.mgr = ctename.empno + ) + SELECT * FROM ctename +); +-- +ok +== +SELECT * FROM ctenames; +-- +ok +== +WITH RECURSIVE fib AS MATERIALIZED ( + SELECT 1 AS n, + 1::bigint AS "fibₙ", + 1::bigint AS "fibₙ₊₁" + UNION ALL + SELECT n+1, + "fibₙ₊₁", + "fibₙ" + "fibₙ₊₁" + FROM fib + WHERE n <= 20 +) +SELECT n, "fibₙ" FROM fib +LIMIT 20; +-- +ok +== diff --git a/parser/testdata/corpus/sql/cte/materialized/test_recursive_cte_union_all_materialized.test b/parser/testdata/corpus/sql/cte/materialized/test_recursive_cte_union_all_materialized.test new file mode 100644 index 0000000..f5efd98 --- /dev/null +++ b/parser/testdata/corpus/sql/cte/materialized/test_recursive_cte_union_all_materialized.test @@ -0,0 +1,68 @@ +# source: test/sql/cte/materialized/test_recursive_cte_union_all_materialized.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +with recursive t as MATERIALIZED (select 1 as x union all select x+1 from t where x < 3) select * from t +-- +ok +== +with recursive t as MATERIALIZED (select 1 as x union all select x+1 from t as m where m.x < 3) select * from t +-- +ok +== +with recursive t as MATERIALIZED (select 1 as x union all select m.x+f.x from t as m, t as f where m.x < 3) select * from t +-- +ok +== +with recursive t as MATERIALIZED (select 1 as x, 'hello' as y union all select x+1, y || '-' || 'hello' from t where x < 3) select * from t; +-- +ok +== +with recursive t as MATERIALIZED (select 1 as x union all select x+1 from t where x < 3) select min(a1.x) from t a1, t a2; +-- +ok +== +with recursive t as MATERIALIZED (select 1 as x union all select x+(SELECT 1) from t where x < 3) select * from t; +-- +ok +== +create table integers as with recursive t as MATERIALIZED (select 1 as x union all select x+1 from t where x < 3) select * from t; +-- +ok +== +with recursive t as MATERIALIZED (select (select min(x) from integers) as x union all select x+1 from t where x < 3) select * from t; +-- +ok +== +with recursive t as MATERIALIZED (select 1 as x union all select sum(x+1) AS x from t where x < 3 group by x) select * from t +-- +ok +== +WITH RECURSIVE t AS MATERIALIZED ( + SELECT 1 AS i + UNION ALL + SELECT j + FROM t, generate_series(0, 10, 1) series(j) + WHERE j=i+1 +) +SELECT * FROM t; +-- +ok +== +with recursive t as MATERIALIZED (select 1 as x union all select x+1 from t where x < 3 order by x) select * from t +-- +error: Parser Error: ORDER BY in a recursive query is not allowed +== +with recursive t as MATERIALIZED (select 1 as x union all select x+1 from t where x < 3 LIMIT 1) select * from t +-- +error: Parser Error: LIMIT or OFFSET in a recursive query is not allowed +== +with recursive t as MATERIALIZED (select 1 as x union all select x+1 from t where x < 3 OFFSET 1) select * from t +-- +error: Parser Error: LIMIT or OFFSET in a recursive query is not allowed +== +with recursive t as MATERIALIZED (select 1 as x union all select x+1 from t where x < 3 LIMIT 1 OFFSET 1) select * from t +-- +error: Parser Error: LIMIT or OFFSET in a recursive query is not allowed +== diff --git a/parser/testdata/corpus/sql/cte/materialized/test_recursive_cte_union_all_materialized.test.metadata.json b/parser/testdata/corpus/sql/cte/materialized/test_recursive_cte_union_all_materialized.test.metadata.json new file mode 100644 index 0000000..28bd9e0 --- /dev/null +++ b/parser/testdata/corpus/sql/cte/materialized/test_recursive_cte_union_all_materialized.test.metadata.json @@ -0,0 +1,8 @@ +{ + "todo": { + "5cadd1690fbb969b": "transformer-raised parser error: upstream rejects in the transformer, not the grammar; expected to clear as transformers land (milestones 3-5)", + "a2a5280d2fbd16ba": "transformer-raised parser error: upstream rejects in the transformer, not the grammar; expected to clear as transformers land (milestones 3-5)", + "b3331f3032bac086": "transformer-raised parser error: upstream rejects in the transformer, not the grammar; expected to clear as transformers land (milestones 3-5)", + "b98b306ae5af8006": "transformer-raised parser error: upstream rejects in the transformer, not the grammar; expected to clear as transformers land (milestones 3-5)" + } +} diff --git a/parser/testdata/corpus/sql/cte/materialized/test_recursive_cte_union_materialized.test b/parser/testdata/corpus/sql/cte/materialized/test_recursive_cte_union_materialized.test new file mode 100644 index 0000000..cb3ef13 --- /dev/null +++ b/parser/testdata/corpus/sql/cte/materialized/test_recursive_cte_union_materialized.test @@ -0,0 +1,85 @@ +# source: test/sql/cte/materialized/test_recursive_cte_union_materialized.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +with recursive t as MATERIALIZED (select 1 as x union select x+1 from t where x < 3) select * from t order by x +-- +ok +== +with recursive t(x) as MATERIALIZED (select 1 union select x+1 from t where x < 3) select * from t order by x +-- +ok +== +with recursive t(x) as MATERIALIZED (select 1 union select x+1 from t where x < 3) select zz from t t1(zz) order by zz +-- +ok +== +with recursive t(x) as MATERIALIZED (select 1 union select zzz+1 from t t1(zzz) where zzz < 3) select zz from t t1(zz) order by zz +-- +ok +== +with recursive t as MATERIALIZED (select 1 as x union select x from t) select * from t +-- +ok +== +with recursive t as MATERIALIZED (select 1 as x union select x+1 from t as m where m.x < 3) select * from t order by x +-- +ok +== +with recursive t as MATERIALIZED (select 1 as x union select m.x+f.x from t as m, t as f where m.x < 3) select * from t order by x +-- +ok +== +with recursive t as MATERIALIZED (select 1 as x, 'hello' as y union select x+1, y || '-' || 'hello' from t where x < 3) select * from t order by x; +-- +ok +== +with recursive t as MATERIALIZED (select 1 as x union select x+1 from t where x < 3) select min(a1.x) from t a1, t a2; +-- +ok +== +with recursive t as MATERIALIZED (select 1 as x union select x+(SELECT 1) from t where x < 3) select * from t order by x; +-- +ok +== +with recursive t as MATERIALIZED (select 1 as x union select x+(SELECT 1+t.x) from t where x < 5) select * from t order by x; +-- +ok +== +create table integers as with recursive t as MATERIALIZED (select 1 as x union select x+1 from t where x < 3) select * from t; +-- +ok +== +with recursive t as MATERIALIZED (select (select min(x) from integers) as x union select x+1 from t where x < 3) select * from t order by x; +-- +ok +== +with recursive t as MATERIALIZED (select 1 as x union select sum(x+1) from t where x < 3) select * from t order by 1 nulls last +-- +ok +== +with recursive t as MATERIALIZED (select 1 as x union select sum(x+1) from t where x < 3 order by x) select * from t +-- +error: Parser Error: ORDER BY in a recursive query is not allowed +== +with recursive t as MATERIALIZED (select 1 as x union select sum(x+1) from t where x < 3 LIMIT 1) select * from t +-- +error: Parser Error: LIMIT or OFFSET in a recursive query is not allowed +== +with recursive t as MATERIALIZED (select 1 as x union select sum(x+1) from t where x < 3 OFFSET 1) select * from t +-- +error: Parser Error: LIMIT or OFFSET in a recursive query is not allowed +== +with recursive t as MATERIALIZED (select 1 as x union select sum(x+1) from t where x < 3 LIMIT 1 OFFSET 1) select * from t +-- +error: Parser Error: LIMIT or OFFSET in a recursive query is not allowed +== +create view vr as (with recursive t(x) as MATERIALIZED (select 1 union select x+1 from t where x < 3) select * from t order by x) +-- +ok +== +select * from vr +-- +ok +== diff --git a/parser/testdata/corpus/sql/cte/materialized/test_recursive_cte_union_materialized.test.metadata.json b/parser/testdata/corpus/sql/cte/materialized/test_recursive_cte_union_materialized.test.metadata.json new file mode 100644 index 0000000..13c3460 --- /dev/null +++ b/parser/testdata/corpus/sql/cte/materialized/test_recursive_cte_union_materialized.test.metadata.json @@ -0,0 +1,8 @@ +{ + "todo": { + "08a4f1886d350a18": "transformer-raised parser error: upstream rejects in the transformer, not the grammar; expected to clear as transformers land (milestones 3-5)", + "3c0f6a66b5b3f8dd": "transformer-raised parser error: upstream rejects in the transformer, not the grammar; expected to clear as transformers land (milestones 3-5)", + "501d01b30d4755ab": "transformer-raised parser error: upstream rejects in the transformer, not the grammar; expected to clear as transformers land (milestones 3-5)", + "818a825b6c349c9a": "transformer-raised parser error: upstream rejects in the transformer, not the grammar; expected to clear as transformers land (milestones 3-5)" + } +} diff --git a/parser/testdata/corpus/sql/cte/recursive_array_slice.test b/parser/testdata/corpus/sql/cte/recursive_array_slice.test new file mode 100644 index 0000000..3ace958 --- /dev/null +++ b/parser/testdata/corpus/sql/cte/recursive_array_slice.test @@ -0,0 +1,51 @@ +# source: test/sql/cte/recursive_array_slice.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +WITH RECURSIVE t(y, arr) AS +( + SELECT 1, array[1,2,3,4,5,6] + UNION ALL + SELECT y+1, arr[:loc] + FROM t, p + WHERE y < 10 +) SELECT * FROM t; +-- +ok +== +WITH RECURSIVE t(y, arr) AS +( + SELECT 1, array[1,2,3,4,5,6] + UNION ALL + SELECT y+1, arr + FROM t, p + WHERE y < 10 + AND y = loc +) SELECT * FROM t; +-- +ok +== +WITH RECURSIVE t(y, arr) AS +( + SELECT 1, array[1,2,3,4,5,6] + UNION ALL + SELECT y+1, arr[:loc] + FROM t, p + WHERE y < 10 + AND y = loc +) SELECT * FROM t; +-- +ok +== +WITH RECURSIVE t(arr) AS +( + SELECT array[1,2,3,4,5,6] + UNION ALL + SELECT arr[arr[1]+1:6] + FROM t + WHERE arr[1] < 6 +) SELECT * FROM t; +-- +ok +== diff --git a/parser/testdata/corpus/sql/cte/recursive_cte_batch_index.test b/parser/testdata/corpus/sql/cte/recursive_cte_batch_index.test new file mode 100644 index 0000000..1d38fa3 --- /dev/null +++ b/parser/testdata/corpus/sql/cte/recursive_cte_batch_index.test @@ -0,0 +1,59 @@ +# source: test/sql/cte/recursive_cte_batch_index.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +WITH RECURSIVE +df(a) AS MATERIALIZED (VALUES (1), (2), (3)), +RecursiveCTE AS ( + SELECT Number FROM df t(Number) + UNION ALL + SELECT Number + (SELECT a FROM df OFFSET 2 LIMIT 1) + 1 AS new + FROM RecursiveCTE + WHERE new < 10 +) +SELECT * FROM RecursiveCTE; +-- +ok +== +WITH RECURSIVE r(x) AS ( + VALUES (1), (2), (3) + UNION ALL + SELECT x + (SELECT a FROM (VALUES (1), (2), (3)) df(a) LIMIT 1) + FROM r + WHERE x < 4 +) +SELECT * FROM r; +-- +ok +== +SET enable_caching_operators=false; +-- +ok +== +RESET enable_caching_operators; +-- +ok +== +WITH RECURSIVE r(x) AS ( + VALUES (1), (2), (3) + UNION + SELECT x + (SELECT a FROM (VALUES (1), (2), (3)) df(a) LIMIT 1) + FROM r + WHERE x < 4 +) +SELECT * FROM r; +-- +ok +== +WITH RECURSIVE r(x) AS ( + SELECT i FROM range(4096) t(i) + UNION ALL + SELECT x + (SELECT a FROM (VALUES (1), (2), (3)) df(a) LIMIT 1) + FROM r + WHERE x < 3 +) +SELECT count(*), sum(x) FROM r; +-- +ok +== diff --git a/parser/testdata/corpus/sql/cte/recursive_cte_column_pruning.test b/parser/testdata/corpus/sql/cte/recursive_cte_column_pruning.test new file mode 100644 index 0000000..072aba5 --- /dev/null +++ b/parser/testdata/corpus/sql/cte/recursive_cte_column_pruning.test @@ -0,0 +1,173 @@ +# source: test/sql/cte/recursive_cte_column_pruning.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +EXPLAIN WITH RECURSIVE t(i, unused) AS ( + SELECT 1, repeat('x', 1000) + UNION ALL + SELECT i + 1, unused || 'y' FROM t WHERE i < 3 +) +SELECT i FROM t; +-- +ok +== +EXPLAIN WITH RECURSIVE r(a, b, c) AS ( + SELECT 1, 2, repeat('x', 1000) + UNION ALL + SELECT a + 1, b + 1, c FROM r WHERE a < 3 +) +SELECT a FROM r; +-- +ok +== +PRAGMA explain_output='all'; +-- +ok +== +WITH RECURSIVE t(i, unused) AS ( + SELECT 1, repeat('x', 1000) + UNION ALL + SELECT i + 1, unused || 'y' FROM t WHERE i < 3 +) +SELECT i FROM t ORDER BY i; +-- +ok +== +WITH RECURSIVE r(a, b, c) AS ( + SELECT 1, 2, repeat('x', 1000) + UNION ALL + SELECT a + 1, b + 1, c FROM r WHERE a < 3 +) +SELECT a FROM r ORDER BY a; +-- +ok +== +WITH RECURSIVE t(a, b, c, level, d) AS ( + SELECT 1, 2, 3, 0, repeat('x', 1000) + UNION ALL + SELECT c, a, b, level + 1, d || 'y' FROM t WHERE level < 3 +) +SELECT a, b, c, level FROM t ORDER BY level; +-- +ok +== +WITH RECURSIVE t(a, b, c, level) AS ( + SELECT 1, 2, 3, 0 + UNION ALL + SELECT c, a, b, level + 1 FROM t WHERE level < 3 +) +SELECT a FROM t ORDER BY level; +-- +ok +== +WITH RECURSIVE t(i, payload, unused) AS ( + SELECT 1, 10, repeat('x', 1000) + UNION ALL + SELECT n.i + 1, r.payload + 10, n.unused || 'y' + FROM t n + JOIN recurring.t r ON r.i = n.i + WHERE n.i < 3 +) +SELECT payload FROM t ORDER BY i; +-- +ok +== +WITH RECURSIVE t(i, identity_payload) AS ( + SELECT 1, 0 + UNION + SELECT i, identity_payload + 1 FROM t WHERE identity_payload < 3 +) +SELECT count(i) FROM t; +-- +ok +== +WITH RECURSIVE t(i, payload) USING KEY (i) AS ( + SELECT 1, 10 + UNION ALL + SELECT i, payload + 1 FROM t WHERE payload < 12 +) +SELECT i, payload FROM t; +-- +ok +== +CREATE SEQUENCE recursive_anchor_pruning_sequence START 1; +-- +ok +== +WITH RECURSIVE t(i, unused) AS ( + SELECT 1, nextval('recursive_anchor_pruning_sequence') + UNION ALL + SELECT i + 1, unused FROM t WHERE i < 3 +) +SELECT max(i), currval('recursive_anchor_pruning_sequence') FROM t; +-- +ok +== +CREATE SEQUENCE recursive_member_pruning_sequence START 1; +-- +ok +== +WITH RECURSIVE t(i, unused) AS ( + VALUES (1, 0::BIGINT) + UNION ALL + SELECT i + 1, nextval('recursive_member_pruning_sequence') FROM t WHERE i < 3 +) +SELECT max(i), currval('recursive_member_pruning_sequence') FROM t; +-- +ok +== +EXPLAIN WITH RECURSIVE t(i, payload, unused) AS ( + SELECT 1, 10, repeat('x', 1000) + UNION ALL + ( + WITH materialized_state AS MATERIALIZED ( + SELECT i, payload, unused FROM t + ), + union_state AS ( + SELECT * FROM materialized_state + UNION ALL + SELECT * FROM materialized_state WHERE false + ) + SELECT max(i) + 1, max(payload) + 10, max(unused) || 'y' + FROM union_state + HAVING max(i) < 3 + ) +) +SELECT payload FROM t; +-- +ok +== +WITH RECURSIVE t(i, payload, unused) AS ( + SELECT 1, 10, repeat('x', 1000) + UNION ALL + ( + WITH materialized_state AS MATERIALIZED ( + SELECT i, payload, unused FROM t + ), + union_state AS ( + SELECT * FROM materialized_state + UNION ALL + SELECT * FROM materialized_state WHERE false + ) + SELECT max(i) + 1, max(payload) + 10, max(unused) || 'y' + FROM union_state + HAVING max(i) < 3 + ) +) +SELECT i, payload FROM t ORDER BY i; +-- +ok +== +WITH RECURSIVE t(i, payload) AS ( + SELECT 1, 'x' + UNION ALL + SELECT i + length(payload), columns.column_type + FROM t + CROSS JOIN (SHOW SELECT 42::INTEGER AS value) columns + WHERE i < 3 +) +SELECT i FROM t ORDER BY i; +-- +ok +== diff --git a/parser/testdata/corpus/sql/cte/recursive_cte_complex_pipelines.test b/parser/testdata/corpus/sql/cte/recursive_cte_complex_pipelines.test new file mode 100644 index 0000000..1eadac4 --- /dev/null +++ b/parser/testdata/corpus/sql/cte/recursive_cte_complex_pipelines.test @@ -0,0 +1,169 @@ +# source: test/sql/cte/recursive_cte_complex_pipelines.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +WITH RECURSIVE t AS +( + SELECT 1 AS x +UNION + SELECT t1.x + t2.x + t3.x AS x + FROM t t1, t t2, t t3 + WHERE t1.x < 100 +) +SELECT * FROM t ORDER BY 1; +-- +ok +== +WITH RECURSIVE t AS +( + SELECT 1 AS x +UNION + SELECT (t1.x + t2.x + t3.x)::HUGEINT AS x + FROM t t1, t t2, t t3 + WHERE t1.x < 100 +) +SELECT * FROM t ORDER BY 1; +-- +ok +== +WITH RECURSIVE t AS +( + SELECT 1 AS x +UNION + SELECT SUM(x) AS x + FROM t, a + WHERE x < 1000000 +) +SELECT * FROM t ORDER BY 1 NULLS LAST; +-- +ok +== +WITH RECURSIVE t AS +( + SELECT 1 AS x +UNION + SELECT SUM(x) AS x + FROM t, a + WHERE x < 1000000 AND t.x=a.i +) +SELECT * FROM t ORDER BY 1 NULLS LAST; +-- +ok +== +WITH RECURSIVE t AS +( + SELECT 1 AS x +UNION + SELECT SUM(x) + FROM + (SELECT SUM(x) FROM t) t1(x), a + WHERE x < 1000 +) +SELECT * FROM t ORDER BY 1 NULLS LAST; +-- +ok +== +WITH RECURSIVE t AS +( + SELECT 1 AS x +UNION + SELECT (SELECT x + 1 FROM t) AS x + FROM t + WHERE x < 5 +) +SELECT * FROM t ORDER BY 1 NULLS LAST; +-- +ok +== +WITH RECURSIVE t AS +( + SELECT 1 AS x +UNION + SELECT (SELECT t.x+t2.x FROM t t2 LIMIT 1) AS x + FROM t + WHERE x < 10 +) +SELECT * FROM t ORDER BY 1 NULLS LAST; +-- +ok +== +SELECT 1 +FROM (VALUES (1::INT4)) a(v), +LATERAL ( + WITH RECURSIVE + b AS ( + SELECT 0::INT4 AS i + WHERE a.v IS NOT NULL + ), + c AS ( + SELECT 0::INT8 AS i + UNION ALL + SELECT d.i + 1::INT8 + FROM c d, + LATERAL ( + SELECT 1 + FROM b e + WHERE e.i = d.i + ) f + ) + SELECT * FROM c +) g +LIMIT 1; +-- +ok +== +SET max_execution_time=5000 +-- +ok +== +WITH RECURSIVE t(step, r, v) AS ( + VALUES (0, 'x', 1) + UNION ALL ( + WITH tmp AS (SELECT * FROM t), + next(step, r, v) AS MATERIALIZED ( + SELECT step, 'z', v FROM tmp WHERE r = 'x' + UNION ALL + SELECT * FROM tmp WHERE r <> 'z' + ) + SELECT step + 1, r, v + FROM next + WHERE EXISTS ( + SELECT * + FROM next n + LEFT JOIN tmp p ON n.r = p.r + WHERE p.v IS DISTINCT FROM n.v + ) + ) +) +SELECT max(step), count(*) FROM t; +-- +ok +== +WITH RECURSIVE t(step, r, v) AS ( + VALUES (0, 'x', 1) + UNION ALL ( + WITH tmp AS (SELECT * FROM t), + next(step, r, v) AS NOT MATERIALIZED ( + SELECT step, 'z', v FROM tmp WHERE r = 'x' + UNION ALL + SELECT * FROM tmp WHERE r <> 'z' + ) + SELECT step + 1, r, v + FROM next + WHERE EXISTS ( + SELECT * + FROM next n + LEFT JOIN tmp p ON n.r = p.r + WHERE p.v IS DISTINCT FROM n.v + ) + ) +) +SELECT max(step), count(*) FROM t; +-- +ok +== +RESET max_execution_time +-- +ok +== diff --git a/parser/testdata/corpus/sql/cte/recursive_cte_correlated_complex.test b/parser/testdata/corpus/sql/cte/recursive_cte_correlated_complex.test new file mode 100644 index 0000000..b5ffa48 --- /dev/null +++ b/parser/testdata/corpus/sql/cte/recursive_cte_correlated_complex.test @@ -0,0 +1,101 @@ +# source: test/sql/cte/recursive_cte_correlated_complex.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +SELECT s.s_name, COUNT(*) AS numwait +FROM supplier AS s, nation AS n, (SELECT * + FROM orders + WHERE o_orderstatus = 'F' + ORDER BY o_orderkey) AS o +WHERE o.o_orderstatus = 'F' +AND s.s_nationkey = n.n_nationkey +AND +(WITH RECURSIVE "@loop" ("$label", "$output", "0", "1") AS ( + (SELECT CAST('$' AS VARCHAR) AS "$label", CAST(NULL AS BOOLEAN) AS "$output", CAST(o.o_orderkey AS BIGINT) AS "0", CAST(s.s_suppkey AS BIGINT) AS "1") + UNION ALL + (WITH "0" (suppkey, orderkey) AS (SELECT "@loop"."1" AS suppkey, "@loop"."0" AS orderkey FROM "@loop" WHERE ("@loop"."$label" IS NOT DISTINCT FROM '$')), + "1" (orderkey, suppkey, found) AS (SELECT "0".orderkey AS orderkey, "0".suppkey AS suppkey, CAST(NULL AS BOOLEAN) AS found FROM "0" AS "0"(suppkey, orderkey)), + "2" (suppkey, orderkey, lis) AS (SELECT "1".suppkey AS suppkey, "1".orderkey AS orderkey, CAST(NULL AS BIGINT[]) AS lis FROM "1" AS "1"(orderkey, suppkey, found)), + "3" (orderkey, suppkey, li) AS (SELECT "2".orderkey AS orderkey, "2".suppkey AS suppkey, CAST(NULL AS BIGINT) AS li FROM "2" AS "2"(suppkey, orderkey, lis)), + "4" (suppkey, orderkey, blame) AS (SELECT "3".suppkey AS suppkey, "3".orderkey AS orderkey, CAST('f' AS BOOLEAN) AS blame FROM "3" AS "3"(orderkey, suppkey, li)), + "5" (orderkey, blame, suppkey, multi) AS (SELECT "4".orderkey AS orderkey, "4".blame AS blame, "4".suppkey AS suppkey, CAST('f' AS BOOLEAN) AS multi FROM "4" AS "4"(suppkey, orderkey, blame)), + "6" (suppkey, multi, blame, lis) AS (SELECT "5".suppkey AS suppkey, "5".multi AS multi, "5".blame AS blame, (SELECT CAST((SELECT * FROM (SELECT array_agg(l.l_suppkey) FROM lineitem AS l WHERE (l.l_orderkey = "5".orderkey)) AS subquery LIMIT 1) AS BIGINT[])) AS lis FROM "5" AS "5"(orderkey, blame, suppkey, multi)), + "7" (blame, multi) AS (SELECT "6".blame AS blame, (SELECT CAST((SELECT ("6".multi OR (("6".lis[1]) != "6".suppkey))) AS BOOLEAN)) AS multi FROM "6" AS "6"(suppkey, multi, blame, lis)), + "8" (return_value) AS (SELECT ("7".multi AND "7".blame) AS return_value FROM "7" AS "7"(blame, multi)), + "9" ("$output") AS (SELECT "8".return_value AS "$output" FROM "8" AS "8"(return_value)) + SELECT CAST(NULL AS VARCHAR) AS "$label", CAST("9"."$output" AS BOOLEAN) AS "$output", CAST(NULL AS BIGINT) AS "0", CAST(NULL AS BIGINT) AS "1" FROM "9" AS "9"("$output"))) + SELECT "@loop"."$output" FROM "@loop" AS "@loop"("$label", "$output", "0", "1") WHERE ("@loop"."$label" IS NULL) +) +GROUP BY s.s_name +ORDER BY numwait DESC, s_name; +-- +ok +== +CREATE TYPE supplier_change AS struct( + part BIGINT, -- part for which supplier changed + old BIGINT, -- old supplier + new BIGINT -- new supplier +); +-- +ok +== +CREATE TYPE savings AS struct( + savings numeric, -- saved supply cost (in %) + supplier_changes supplier_change[] -- supplier changes required to achieve savings +); +-- +ok +== +SELECT * +FROM (SELECT 0) AS "input"(orderkey), +(WITH RECURSIVE "@loop" ("$label", "$output", "0", "1", "2", "3", "4") AS ( + (SELECT CAST('$' AS VARCHAR) AS "$label", + CAST(NULL AS savings) AS "$output", + CAST(NULL AS DECIMAL(15,2)) AS "0", + CAST(NULL AS DECIMAL(15,2)) AS "1", + CAST(NULL AS supplier_change[]) AS "2", + CAST("input".orderkey AS BIGINT) AS "3", + CAST(NULL AS BIGINT) AS "4") + UNION ALL + (WITH + "0" (orderkey) AS (SELECT "@loop"."3" AS orderkey FROM "@loop" WHERE ("@loop"."$label" IS NOT DISTINCT FROM '$')), + "1" (orderkey, found) AS (SELECT "0".orderkey AS orderkey, (SELECT CAST(NULL AS BOOLEAN)) AS found FROM "0" AS "0"(orderkey)), + "2" (orderkey, "order") AS (SELECT "1".orderkey AS orderkey, (SELECT NULL) AS "order" FROM "1" AS "1"(orderkey, found)), + "3" (orderkey, items) AS (SELECT "2".orderkey AS orderkey, (SELECT CAST(NULL AS BIGINT)) AS items FROM "2" AS "2"(orderkey, "order")), + "4" (orderkey, lineitem) AS (SELECT "3".orderkey AS orderkey, (SELECT NULL) AS lineitem FROM "3" AS "3"(orderkey, items)), + "5" (orderkey, partsupp) AS (SELECT "4".orderkey AS orderkey, (SELECT NULL) AS partsupp FROM "4" AS "4"(orderkey, lineitem)), + "6" (orderkey, min_supplycost) AS (SELECT "5".orderkey AS orderkey, (SELECT CAST(NULL AS DECIMAL(15, 2))) AS min_supplycost FROM "5" AS "5"(orderkey, partsupp)), + "7" (orderkey, new_supplier) AS (SELECT "6".orderkey AS orderkey, (SELECT CAST(NULL AS BIGINT)) AS new_supplier FROM "6" AS "6"(orderkey, min_supplycost)), + "8" (orderkey, new_suppliers) AS (SELECT "7".orderkey AS orderkey, (SELECT CAST(NULL AS STRUCT(part BIGINT, "old" BIGINT, "new" BIGINT)[])) AS new_suppliers FROM "7" AS "7"(orderkey, new_supplier)), + "9" (orderkey, total_supplycost) AS (SELECT "8".orderkey AS orderkey, (SELECT CAST(NULL AS DECIMAL(15, 2))) AS total_supplycost FROM "8" AS "8"(orderkey, new_suppliers)), + "10" (orderkey, new_supplycost) AS (SELECT "9".orderkey AS orderkey, (SELECT CAST(NULL AS DECIMAL(15, 2))) AS new_supplycost FROM "9" AS "9"(orderkey, total_supplycost)), + "11" (orderkey, item) AS (SELECT "10".orderkey AS orderkey, (SELECT NULL) AS item FROM "10" AS "10"(orderkey, new_supplycost)), + "12" (orderkey, "order") AS (SELECT "11".orderkey AS orderkey, (SELECT * FROM (SELECT o FROM orders AS o WHERE (o.o_orderkey = "11".orderkey)) AS subquery LIMIT 1) AS "order" FROM "11" AS "11"(orderkey, item)), + "13" (orderkey, "$cond0") AS (SELECT "12".orderkey AS orderkey, (SELECT ("12"."order" IS NULL)) AS "$cond0" FROM "12" AS "12"(orderkey, "order")), + "14" AS (SELECT NULL AS "$output" FROM "13" AS "13"(orderkey, "$cond0") WHERE "13"."$cond0"), + "15" (orderkey) AS (SELECT "13".orderkey AS orderkey FROM "13" AS "13"(orderkey, "$cond0") WHERE ("13"."$cond0" IS DISTINCT FROM true)), + "16" (return_value) AS (SELECT (SELECT NULL) AS return_value FROM "14" AS "14"), + "17" ("$output") AS (SELECT "16".return_value AS "$output" FROM "16" AS "16"(return_value)), + "18" (items) AS (SELECT (SELECT CAST((SELECT * FROM (SELECT count_star() FROM lineitem AS l WHERE (l.l_orderkey = "15".orderkey)) AS subquery LIMIT 1) AS BIGINT)) AS items FROM "15" AS "15"(orderkey)), + "19" (items, total_supplycost) AS (SELECT "18".items AS items, (SELECT CAST((SELECT 0.0) AS DECIMAL(15, 2))) AS total_supplycost FROM "18" AS "18"(items)), + "20" (items, total_supplycost, new_supplycost) AS (SELECT "19".items AS items, "19".total_supplycost AS total_supplycost, (SELECT CAST((SELECT 0.0) AS DECIMAL(15, 2))) AS new_supplycost FROM "19" AS "19"(items, total_supplycost)), + "21" (total_supplycost, new_supplycost, items, new_suppliers) AS (SELECT "20".total_supplycost AS total_supplycost, "20".new_supplycost AS new_supplycost, "20".items AS items, (SELECT CAST((SELECT CAST((ARRAY[]) AS "supplier_change"[])) AS STRUCT(part BIGINT, "old" BIGINT, "new" BIGINT)[])) AS new_suppliers FROM "20" AS "20"(items, total_supplycost, new_supplycost)), + "22" (items, new_supplycost, total_supplycost, new_suppliers, item) AS (SELECT "21".items AS items, "21".new_supplycost AS new_supplycost, "21".total_supplycost AS total_supplycost, "21".new_suppliers AS new_suppliers, (SELECT 1) AS item FROM "21" AS "21"(total_supplycost, new_supplycost, items, new_suppliers)), + "23" (new_suppliers, item, total_supplycost, new_supplycost, fori_end) AS (SELECT "22".new_suppliers AS new_suppliers, "22".item AS item, "22".total_supplycost AS total_supplycost, "22".new_supplycost AS new_supplycost, (SELECT "22".items) AS fori_end FROM "22" AS "22"(items, new_supplycost, total_supplycost, new_suppliers, item)), + "24" (total_supplycost, new_supplycost, fori_end, new_suppliers, item) AS (SELECT "@loop"."0" AS total_supplycost, "@loop"."1" AS new_supplycost, "@loop"."4" AS fori_end, "@loop"."2" AS new_suppliers, "@loop"."3" AS item FROM "@loop" WHERE ("@loop"."$label" IS NOT DISTINCT FROM '$loop1')), + "25" (item, new_suppliers, fori_end, new_supplycost, total_supplycost) AS ((SELECT "23".item AS item, "23".new_suppliers AS new_suppliers, "23".fori_end AS fori_end, "23".new_supplycost AS new_supplycost, "23".total_supplycost AS total_supplycost FROM "23" AS "23"(new_suppliers, item, total_supplycost, new_supplycost, fori_end)) UNION ALL (SELECT "24".item AS item, "24".new_suppliers AS new_suppliers, "24".fori_end AS fori_end, "24".new_supplycost AS new_supplycost, "24".total_supplycost AS total_supplycost FROM "24" AS "24"(total_supplycost, new_supplycost, fori_end, new_suppliers, item))), + "26" (new_suppliers, total_supplycost, new_supplycost, "$cond2") AS (SELECT "25".new_suppliers AS new_suppliers, "25".total_supplycost AS total_supplycost, "25".new_supplycost AS new_supplycost, (SELECT ("25".item > "25".fori_end)) AS "$cond2" FROM "25" AS "25"(item, new_suppliers, fori_end, new_supplycost, total_supplycost)), + "27" (new_supplycost, total_supplycost, new_suppliers) AS (SELECT "26".new_supplycost AS new_supplycost, "26".total_supplycost AS total_supplycost, "26".new_suppliers AS new_suppliers FROM "26" AS "26"(new_suppliers, total_supplycost, new_supplycost, "$cond2") WHERE "26"."$cond2"), + "28" (new_supplycost, total_supplycost, new_suppliers) AS (SELECT "26".new_supplycost AS new_supplycost, "26".total_supplycost AS total_supplycost, "26".new_suppliers AS new_suppliers FROM "26" AS "26"(new_suppliers, total_supplycost, new_supplycost, "$cond2") WHERE ("26"."$cond2" IS DISTINCT FROM true)), + "29" (new_suppliers, total_supplycost, new_supplycost) AS ((SELECT "27".new_suppliers AS new_suppliers, "27".total_supplycost AS total_supplycost, "27".new_supplycost AS new_supplycost FROM "27" AS "27"(new_supplycost, total_supplycost, new_suppliers)) UNION ALL (SELECT "28".new_suppliers AS new_suppliers, "28".total_supplycost AS total_supplycost, "28".new_supplycost AS new_supplycost FROM "28" AS "28"(new_supplycost, total_supplycost, new_suppliers))), + "30" (return_value) AS (SELECT (SELECT CAST(main."row"(((1.0 - ("29".new_supplycost / "29".total_supplycost)) * 100.0), "29".new_suppliers) AS "savings")) AS return_value FROM "29" AS "29"(new_suppliers, total_supplycost, new_supplycost)), + "31" ("$output") AS (SELECT "30".return_value AS "$output" FROM "30" AS "30"(return_value)) + (SELECT CAST(NULL AS VARCHAR) AS "$label", CAST("17"."$output" AS STRUCT(savings DECIMAL(18,3), supplier_changes STRUCT(part BIGINT, "old" BIGINT, "new" BIGINT)[])) AS "$output", CAST(NULL AS DECIMAL(15,2)) AS "0", CAST(NULL AS DECIMAL(15,2)) AS "1", CAST(NULL AS STRUCT(part BIGINT, "old" BIGINT, "new" BIGINT)[]) AS "2", CAST(NULL AS BIGINT) AS "3", CAST(NULL AS BIGINT) AS "4" FROM "17" AS "17"("$output")) + UNION ALL + (SELECT CAST(NULL AS VARCHAR) AS "$label", CAST("31"."$output" AS STRUCT(savings DECIMAL(18,3), supplier_changes STRUCT(part BIGINT, "old" BIGINT, "new" BIGINT)[])) AS "$output", CAST(NULL AS DECIMAL(15,2)) AS "0", CAST(NULL AS DECIMAL(15,2)) AS "1", CAST(NULL AS STRUCT(part BIGINT, "old" BIGINT, "new" BIGINT)[]) AS "2", CAST(NULL AS BIGINT) AS "3", CAST(NULL AS BIGINT) AS "4" FROM "31" AS "31"("$output")))) + SELECT "@loop"."$output" FROM "@loop" AS "@loop"("$label", "$output", "0", "1", "2", "3", "4") WHERE ("@loop"."$label" IS NULL) + ) AS output; +-- +ok +== diff --git a/parser/testdata/corpus/sql/cte/recursive_cte_error.test b/parser/testdata/corpus/sql/cte/recursive_cte_error.test new file mode 100644 index 0000000..000690c --- /dev/null +++ b/parser/testdata/corpus/sql/cte/recursive_cte_error.test @@ -0,0 +1,20 @@ +# source: test/sql/cte/recursive_cte_error.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +WITH RECURSIVE tag_hierarchy(id, source, path, target) AS ( + SELECT id, name, name AS path, NULL::INTEGER AS target -- this should be '' for correct behaviour + FROM tag + WHERE subclassof IS NULL + UNION ALL + SELECT tag.id, tag.name, tag_hierarchy.path || ' <- ' || tag.name, tag.name AS target + FROM tag, tag_hierarchy + WHERE tag.subclassof = tag_hierarchy.id +) +SELECT source, path, target +FROM tag_hierarchy +; +-- +ok +== diff --git a/parser/testdata/corpus/sql/cte/recursive_cte_invariant_build.test b/parser/testdata/corpus/sql/cte/recursive_cte_invariant_build.test new file mode 100644 index 0000000..48b8d68 --- /dev/null +++ b/parser/testdata/corpus/sql/cte/recursive_cte_invariant_build.test @@ -0,0 +1,85 @@ +# source: test/sql/cte/recursive_cte_invariant_build.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +SET enable_caching_operators=true +-- +ok +== +CREATE SEQUENCE hash_build_sequence START 1 +-- +ok +== +WITH RECURSIVE r(i, x) AS ( + SELECT 0, NULL::BIGINT + UNION ALL + SELECT r.i + 1, build.x + FROM r + JOIN ( + SELECT i AS k, nextval('hash_build_sequence') AS x + FROM range(100) t(i) + ) build ON build.k = r.i % 100 + WHERE r.i < 3 +) +SELECT list(x ORDER BY i), currval('hash_build_sequence') FROM r; +-- +ok +== +CREATE SEQUENCE cross_build_sequence START 1 +-- +ok +== +WITH RECURSIVE r(i, x) AS ( + SELECT 0, NULL::BIGINT + UNION ALL + SELECT r.i + 1, build.x + FROM r + CROSS JOIN (SELECT nextval('cross_build_sequence') AS x) build + WHERE r.i < 3 +) +SELECT list(x ORDER BY i), currval('cross_build_sequence') FROM r; +-- +ok +== +CREATE SEQUENCE nested_build_sequence START 1 +-- +ok +== +WITH RECURSIVE r(i, x) AS ( + SELECT 0, NULL::BIGINT + UNION ALL + SELECT r.i + 1, build.x + FROM r + JOIN ( + WITH values_with_sequence AS MATERIALIZED ( + SELECT i AS k, nextval('nested_build_sequence') AS x + FROM range(4) t(i) + ) + SELECT * FROM values_with_sequence + ) build ON build.k = r.i % 4 + WHERE r.i < 3 +) +SELECT list(x ORDER BY i), currval('nested_build_sequence') FROM r; +-- +ok +== +CREATE SEQUENCE parallel_build_sequence START 1 +-- +ok +== +WITH RECURSIVE r(i, x) AS ( + SELECT 0, NULL::BIGINT + UNION ALL + SELECT r.i + 1, build.x + FROM r + JOIN ( + SELECT i AS k, nextval('parallel_build_sequence') AS x + FROM range(8192) t(i) + ) build ON build.k = r.i % 8192 + WHERE r.i < 3 +) +SELECT count(*), currval('parallel_build_sequence') FROM r; +-- +ok +== diff --git a/parser/testdata/corpus/sql/cte/recursive_cte_invariant_build_logging.test b/parser/testdata/corpus/sql/cte/recursive_cte_invariant_build_logging.test new file mode 100644 index 0000000..a49da15 --- /dev/null +++ b/parser/testdata/corpus/sql/cte/recursive_cte_invariant_build_logging.test @@ -0,0 +1,138 @@ +# source: test/sql/cte/recursive_cte_invariant_build_logging.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +CALL enable_logging('PhysicalOperator'); +-- +ok +== +CALL truncate_duckdb_logs(); +-- +ok +== +WITH RECURSIVE r(i, sampled) AS ( + VALUES (0, 0::BIGINT) + UNION ALL + SELECT r.i + 1, build.sampled + FROM r + CROSS JOIN ( + SELECT count(*) AS sampled + FROM range(1000) USING SAMPLE 50% (bernoulli) + ) build + WHERE r.i < 3 +) +SELECT count(*) FROM r; +-- +ok +== +CALL disable_logging(); +-- +ok +== +SELECT info.retained_build_executions::UBIGINT +FROM duckdb_logs_parsed('PhysicalOperator') +WHERE class = 'PhysicalRecursiveCTE' AND event = 'RuntimeMetrics'; +-- +ok +== +SELECT info.recursive_pipeline_execute_work_ns::UBIGINT > 0, + info.invariant_build_execute_work_ns::UBIGINT = 0, + info.invariant_cte_materialization_execute_work_ns::UBIGINT = 0 +FROM duckdb_logs_parsed('PhysicalOperator') +WHERE class = 'PhysicalRecursiveCTE' AND event = 'EpochSummary'; +-- +ok +== +CREATE TABLE repeatability_sample AS SELECT i FROM range(1000) t(i); +-- +ok +== +WITH RECURSIVE r(i, sampled) AS ( + VALUES (0, 0::BIGINT) + UNION ALL + SELECT r.i + 1, build.sampled + FROM r + CROSS JOIN ( + SELECT count(*) AS sampled + FROM repeatability_sample USING SAMPLE 50% (system) + ) build + WHERE r.i < 3 +) +SELECT count(*) FROM r; +-- +ok +== +WITH RECURSIVE r(i, sampled) AS ( + VALUES (0, 0::BIGINT) + UNION ALL + SELECT r.i + 1, build.sampled + FROM r + CROSS JOIN ( + SELECT count(*) AS sampled + FROM range(1000) USING SAMPLE 50% (bernoulli, 42) + ) build + WHERE r.i < 3 +) +SELECT count(*) FROM r; +-- +ok +== +SELECT info.retained_build_executions::UBIGINT >= 1 +FROM duckdb_logs_parsed('PhysicalOperator') +WHERE class = 'PhysicalRecursiveCTE' AND event = 'RuntimeMetrics'; +-- +ok +== +SELECT info.recursive_pipeline_execute_work_ns::UBIGINT > 0, + info.invariant_build_execute_work_ns::UBIGINT > 0 +FROM duckdb_logs_parsed('PhysicalOperator') +WHERE class = 'PhysicalRecursiveCTE' AND event = 'EpochSummary'; +-- +ok +== +WITH RECURSIVE r(i, outgoing) AS ( + VALUES (0, 0::BIGINT) + UNION ALL + SELECT r.i + 1, build.outgoing + FROM r + JOIN ( + SELECT i AS k, count(*) OVER (PARTITION BY i % 10) AS outgoing + FROM range(10000) t(i) + ) build ON build.k = r.i + WHERE r.i < 3 +) +SELECT max(i), max(outgoing) FROM r; +-- +ok +== +WITH RECURSIVE r(i, x) AS ( + SELECT 0, 0::BIGINT + UNION ALL + ( + WITH invariant AS MATERIALIZED (SELECT i AS k FROM range(10000) t(i)) + SELECT r.i + 1, a.k + FROM invariant a + JOIN r ON a.k = 0 + JOIN invariant b ON b.k = a.k + WHERE r.i < 3 + ) +) +SELECT list(x ORDER BY i) FROM r; +-- +ok +== +SELECT info.retained_cte_materializations::UBIGINT, + info.retained_cte_reuses::UBIGINT >= 2 +FROM duckdb_logs_parsed('PhysicalOperator') +WHERE class = 'PhysicalRecursiveCTE' AND event = 'RuntimeMetrics'; +-- +ok +== +SELECT info.recursive_pipeline_execute_work_ns::UBIGINT > 0, + info.invariant_cte_materialization_execute_work_ns::UBIGINT > 0 +FROM duckdb_logs_parsed('PhysicalOperator') +WHERE class = 'PhysicalRecursiveCTE' AND event = 'EpochSummary'; +-- +ok +== diff --git a/parser/testdata/corpus/sql/cte/recursive_cte_key_aggregation.test b/parser/testdata/corpus/sql/cte/recursive_cte_key_aggregation.test new file mode 100644 index 0000000..7eacbda --- /dev/null +++ b/parser/testdata/corpus/sql/cte/recursive_cte_key_aggregation.test @@ -0,0 +1,464 @@ +# source: test/sql/cte/recursive_cte_key_aggregation.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +WITH RECURSIVE tbl(a, b) USING KEY (a , max(b)) AS ( + SELECT 1, 5 + UNION + SELECT a, b - 1 + FROM tbl + WHERE b > 0) +TABLE tbl; +-- +ok +== +WITH RECURSIVE tbl(a, b) USING KEY (a , avg(b)) AS ( + SELECT 1, 5 + UNION + SELECT a, b - 1 + FROM tbl + WHERE b > 0) +TABLE tbl; +-- +ok +== +WITH RECURSIVE tbl(a, b, c) USING KEY (a , avg(b), list(c)) AS ( + SELECT 1, 5, NULL :: DOUBLE + UNION + SELECT tbl.a, tbl.b - 1, rec.b + FROM tbl, recurring.tbl AS rec + WHERE tbl.b > 0) +TABLE tbl; +-- +ok +== +CREATE TABLE knows(person1id INT, person2id INT); +-- +ok +== +INSERT INTO knows VALUES (1, 2), (2, 3), (1, 3); +-- +ok +== +WITH RECURSIVE dvr(here, there, via, len) USING KEY (here, there , arg_min(via, len), min(len)) AS ( + SELECT n.person1id AS here, n.person2id AS there, n.person2id AS via, 1 AS len + FROM knows AS n + UNION + SELECT n.person1id AS here, dvr.there, dvr.here AS via, 1 + dvr.len AS len + FROM dvr + JOIN knows AS n ON + (n.person2id = dvr.here AND n.person1id <> dvr.there)) +TABLE dvr +ORDER BY here, there; +-- +ok +== +SELECT * +FROM range(1, 4) AS _(l), + LATERAL ( + WITH RECURSIVE cte(a, b, c) USING KEY (a , list(b)) AS ( + SELECT 1, l, 3 + union + SELECT a, l + 1, c - 1 + FROM recurring.cte + WHERE c > 0) + TABLE cte) ORDER BY l; +-- +ok +== +WITH RECURSIVE tbl(a,b,c) USING KEY (a, b , list(c), max(c)) AS ( + SELECT 1, 1, NULL + UNION + SELECT tbl.a, tbl.b - 1, a.b + FROM tbl, recurring.tbl AS a + WHERE tbl.b > 0) +SELECT * FROM tbl; +-- +ok +== +WITH RECURSIVE tbl(a,b,c) USING KEY (a, c , list(b), max(c)) AS ( + SELECT 1, 1, NULL + UNION + SELECT tbl.a, tbl.b - 1, a.b + FROM tbl, recurring.tbl AS a + WHERE tbl.b > 0) +SELECT * FROM tbl; +-- +ok +== +WITH RECURSIVE tbl(a,b,c) USING KEY (list(c)) AS ( + SELECT 1, 4, NULL + UNION + SELECT a, b - 1, b + FROM tbl + WHERE tbl.b > 0) +SELECT * FROM tbl; +-- +ok +== +WITH RECURSIVE tbl(a,b,c) USING KEY (a, a , list(b)) AS ( + SELECT 1, 1, NULL :: INT[] + UNION + SELECT tbl.a, tbl.b - 1, a.b + FROM tbl, recurring.tbl AS a + WHERE tbl.b > 0) +SELECT * FROM tbl; +-- +ok +== +WITH RECURSIVE tbl(a,b) USING KEY (a , string_agg(':a') AS b) AS ( + VALUES (1,2), (1,3) + UNION + SELECT a, b + 1 + FROM tbl + WHERE b < 4) +SELECT * FROM tbl; +-- +ok +== +WITH RECURSIVE tbl(a,b) USING KEY (a , string_agg(b, ', ') ) AS ( + SELECT 1, 5 + UNION + SELECT tbl.a, tbl.b - 1 + FROM tbl + WHERE tbl.b > 0) +TABLE tbl; +-- +ok +== +WITH RECURSIVE tbl(a,b) USING KEY (a , any_value(b)) AS ( + SELECT 1, 5 + UNION + SELECT tbl.a, tbl.b - 1 + FROM tbl + WHERE tbl.b > 0) +TABLE tbl; +-- +ok +== +WITH RECURSIVE tbl(a,b) USING KEY (a , arbitrary(b)) AS ( + SELECT 1, 5 + UNION + SELECT tbl.a, tbl.b - 1 + FROM tbl + WHERE tbl.b > 0) +TABLE tbl; +-- +ok +== +WITH RECURSIVE tbl(key,b,c) USING KEY (key, arg_max(c, b) AS c) AS ( + SELECT 1, 5, 5/5 + UNION + SELECT key, b - 1, 5 / b + FROM tbl + WHERE b > 0 +) TABLE tbl; +-- +ok +== +WITH RECURSIVE tbl(key,b) USING KEY (key , bit_or(b)) AS ( + SELECT 1, '0001' :: BIT + UNION + SELECT key, b << 1 + FROM tbl + WHERE b < '1000' :: BIT +) TABLE tbl; +-- +ok +== +WITH RECURSIVE tbl(key,b) USING KEY (key, bit_and(b)) AS ( + SELECT 1, '1111' :: BIT + UNION + SELECT key, b << 1 + FROM tbl + WHERE b > '0000' :: BIT +) TABLE tbl; +-- +ok +== +WITH RECURSIVE tbl(key,b) USING KEY (key , bit_xor(b)) AS ( + SELECT 1, '1111' :: BIT + UNION + SELECT key, b << 1 + FROM tbl + WHERE b > '0000' :: BIT +) TABLE tbl; +-- +ok +== +CREATE TABLE tinyints(c TINYINT, d TINYINT); +-- +ok +== +INSERT INTO tinyints VALUES(1, 1), (2, 8), (3, 3), (4, 12), (5, 7), (6, 1), (7, 2), (8, 8); +-- +ok +== +WITH RECURSIVE tbl(key, iter, acc) USING KEY (key, bitstring_agg(acc, 1, 12)) AS ( + SELECT c, 1, d + FROM tinyints + WHERE c = 1 + UNION + SELECT key, iter + 1, d + FROM tbl, tinyints AS t(c,d) + WHERE c = iter AND iter < 8 +) SELECT acc FROM tbl; +-- +ok +== +WITH RECURSIVE tbl(key, iter, b, c) USING KEY (key, bool_and(b), bool_or(c)) AS ( + SELECT 1, 1, TRUE, TRUE + UNION + SELECT key, iter + 1, NOT b, NOT c + FROM tbl + WHERE iter < 8 +) TABLE tbl; +-- +ok +== +WITH RECURSIVE tbl(key, iter, c) USING KEY (key, count() AS iter, count(c)) AS ( + SELECT 1, 1, 1 + UNION + SELECT key, iter + 1, c + FROM tbl + WHERE iter < 8 +) TABLE tbl; +-- +ok +== +WITH RECURSIVE tbl(key,b) USING KEY (key, countif(b % 2 = 0) AS b) AS ( + SELECT 1, 0 + UNION + SELECT key, b + 1 + FROM tbl + WHERE b < 10) +TABLE tbl; +-- +ok +== +WITH RECURSIVE tbl(key,b) USING KEY (key, histogram(b, [0, 1, 10]) AS b) AS ( + SELECT 1, 0 :: DOUBLE + UNION + SELECT key, tbl.b + 0.5 + FROM tbl + WHERE tbl.b < 10) + SELECT b FROM tbl; +-- +ok +== +WITH RECURSIVE tbl(key,b) USING KEY (key, min(b, 3) AS b) AS ( + SELECT 1, 5 + UNION + SELECT key, b - 1 + FROM tbl + WHERE b > 0) +TABLE tbl; +-- +ok +== +WITH RECURSIVE tbl(key, b) USING KEY (key, product(b)) AS ( + SELECT 1, 5 + UNION + SELECT key, b - 1 + FROM tbl + WHERE b > 1) +TABLE tbl; +-- +ok +== +WITH RECURSIVE tbl(key, iter, b) USING KEY (key, approx_quantile(b, [0.5, 0.4, 0.1]) AS b) AS ( + SELECT 1, 1, 0 + UNION + SELECT key, iter + 1, iter + FROM tbl, VALUES (2, 1), (3, 2), (4, 10) AS tab(id, col) + WHERE iter + 1 = id) +SELECT b FROM tbl; +-- +ok +== +CREATE TABLE alternating_sequences(it, i) AS SELECT 1, 0 FROM range(10000) UNION ALL SELECT 2, 1 FROM range(100000) UNION ALL SELECT 3, 2 FROM range(10); +-- +ok +== +WITH RECURSIVE tbl(key, iter, i) USING KEY (key, approx_top_k(i, 3) AS i) AS ( + SELECT 1, 0, 0 + UNION + SELECT key, iter + 1, i + FROM tbl, alternating_sequences AS a + WHERE iter + 1 = a.it) +SELECT approx_top_k(i, 3) FROM alternating_sequences; +-- +ok +== +CREATE TABLE aggr(it int, k int, v decimal(10,2), v2 decimal(10, 2)); +-- +ok +== +INSERT INTO aggr values(1, 1, 10, null),(1, 2, 10, 11), (2, 2, 20, 22), (3, 2, 25, null), (4, 2, 30, 35); +-- +ok +== +WITH RECURSIVE tbl(iter, k, v, v2) USING KEY (k, corr(v, v2) AS v2) AS ( + SELECT it, k, v, v2 + FROM aggr + WHERE it = 1 + UNION + SELECT tbl.iter + 1, tbl.k, a.v, a.v2 + FROM tbl, aggr AS a + WHERE tbl.iter + 1 = a.it AND tbl.k = a.k +) SELECT k, v2 FROM tbl; +-- +ok +== +CREATE TABLE integers(iter INTEGER, x INTEGER, y INTEGER); +-- +ok +== +INSERT INTO integers VALUES (1, 10,NULL), (2, 10,11), (3, 20,22), (4, 25,NULL), (5, 30,35); +-- +ok +== +WITH RECURSIVE tbl(key, iter, x, y) USING KEY (key, covar_samp(x,y) AS x, covar_pop(x, y) AS y) AS ( + SELECT 1, iter, x, y + FROM integers + WHERE iter = 1 + UNION + SELECT tbl.key, tbl.iter + 1, a.x, a.y + FROM tbl, integers AS a + WHERE tbl.iter + 1 = a.iter +) SELECT x, y FROM tbl; +-- +ok +== +CREATE TABLE names (it int, name string) +-- +ok +== +INSERT INTO names VALUES (1, 'pedro'), (2, 'pedro'), (3, 'pedro'),(4, 'hannes'),(5, 'hannes'),(6, 'mark'),(7, null); +-- +ok +== +WITH RECURSIVE tbl (key, iter, name) USING KEY (key, entropy(name) AS name) AS ( + SELECT 1, it, name + FROM names + WHERE it = 1 + UNION + SELECT tbl.key, tbl.iter + 1, n.name + FROM tbl, names AS n + WHERE tbl.iter + 1 = n.it) +SELECT name FROM tbl; +-- +ok +== +create table kur(it int, k int, v int, v2 int); +-- +ok +== +insert into kur values + (1, 1, 10, null), + (2, 2, 10, 11), + (3, 2, 10, 15), + (4, 2, 10, 18), + (5, 2, 20, 22), + (6, 2, 20, 25), + (7, 2, 25, null), + (8, 2, 30, 35), + (9, 2, 30, 40), + (10, 2, 30, 50), + (11, 2, 30, 51); +-- +ok +== +WITH RECURSIVE tbl(key, iter, k, v, v2) USING KEY (key, kurtosis(k) AS k, kurtosis(v) AS v, kurtosis(v2) AS v2) AS ( + SELECT 1, it, k, v, v2 + FROM kur + WHERE it = 1 + UNION + SELECT 1, tbl.iter + 1, a.k, a.v, a.v2 + FROM tbl, kur AS a + WHERE tbl.iter + 1 = a.it +) SELECT k, v, v2 FROM tbl; +-- +ok +== +WITH RECURSIVE tbl (a,b) USING KEY (a, b+1) AS ( + SELECT 1, 1 + UNION + SELECT a, b + 1 + FROM tbl + WHERE b < 5) +TABLE tbl; +-- +ok +== +WITH RECURSIVE tbl (a,b) USING KEY (a, avg(b) :: INT) AS ( + SELECT 1, 1 + UNION + SELECT a, b + 1 + FROM tbl + WHERE b < 5) +TABLE tbl; +-- +ok +== +WITH RECURSIVE tbl (a,b) USING KEY (a, sum(b) OVER ()) AS ( + SELECT 1, 1 + UNION + SELECT a, b + 1 + FROM tbl + WHERE b < 5) +TABLE tbl; +-- +ok +== +WITH RECURSIVE tbl(a, b) USING KEY (a, avg(*)) AS ( + SELECT 1, 1 + UNION + SELECT a, b + 1 + FROM tbl + WHERE b < 5) +TABLE tbl; +-- +ok +== +WITH RECURSIVE tbl(a, b) USING KEY (a, avg(*) AS b) AS ( + SELECT 1, 1 + UNION + SELECT a, b + 1 + FROM tbl + WHERE b < 5) +TABLE tbl; +-- +ok +== +WITH RECURSIVE tbl(a, b) USING KEY (a, avg(* :: Int) AS b) AS ( + SELECT 1, 1 + UNION + SELECT a, b + 1 + FROM tbl + WHERE b < 5) +TABLE tbl; +-- +ok +== +WITH RECURSIVE tbl(a, b) USING KEY (a AS b, sum(b) AS b) AS ( + SELECT 1, 1 + UNION + SELECT a, b + 1 + FROM tbl + WHERE b < 5) +TABLE tbl; +-- +ok +== +WITH RECURSIVE tbl(a, b) USING KEY (a AS b, max(b)) AS ( + SELECT 1, 5 + UNION + SELECT a, b - 1 + FROM tbl + WHERE b > 0) +TABLE tbl; +-- +ok +== diff --git a/parser/testdata/corpus/sql/cte/recursive_cte_key_final_drain.test b/parser/testdata/corpus/sql/cte/recursive_cte_key_final_drain.test new file mode 100644 index 0000000..04f430f --- /dev/null +++ b/parser/testdata/corpus/sql/cte/recursive_cte_key_final_drain.test @@ -0,0 +1,64 @@ +# source: test/sql/cte/recursive_cte_key_final_drain.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +SET enable_caching_operators=true; +-- +ok +== +CREATE SEQUENCE keyed_drain_sequence START 1; +-- +ok +== +WITH RECURSIVE t(k, v, x) USING KEY (k) AS ( + SELECT i, 0, NULL::BIGINT FROM range(5000) r(i) + UNION ALL + SELECT n.k, n.v + 1, build.x + FROM t n + JOIN ( + SELECT i AS k, nextval('keyed_drain_sequence') AS x + FROM range(5000) r(i) + ) build USING (k) + WHERE n.v < 0 +) +SELECT count(*), min(v), max(v), currval('keyed_drain_sequence') FROM t; +-- +ok +== +WITH RECURSIVE t(k, v) USING KEY (k) AS ( + SELECT i, 0 FROM range(1) r(i) + UNION ALL + SELECT k, v + 1 FROM t WHERE v < 0 +) +SELECT count(*), min(k), max(k) FROM t; +-- +ok +== +WITH RECURSIVE t(k, v) USING KEY (k) AS ( + SELECT i, 0 FROM range(2048) r(i) + UNION ALL + SELECT k, v + 1 FROM t WHERE v < 0 +) +SELECT count(*), min(k), max(k) FROM t; +-- +ok +== +WITH RECURSIVE t(k, v) USING KEY (k) AS ( + SELECT i, 0 FROM range(2049) r(i) + UNION ALL + SELECT k, v + 1 FROM t WHERE v < 0 +) +SELECT count(*), min(k), max(k) FROM t; +-- +ok +== +WITH RECURSIVE t(k, v) USING KEY (k) AS ( + SELECT i, 0 FROM range(0) r(i) + UNION ALL + SELECT k, v + 1 FROM t WHERE v < 0 +) +SELECT count(*) FROM t; +-- +ok +== diff --git a/parser/testdata/corpus/sql/cte/recursive_cte_key_hll_aggregation.test b/parser/testdata/corpus/sql/cte/recursive_cte_key_hll_aggregation.test new file mode 100644 index 0000000..3016057 --- /dev/null +++ b/parser/testdata/corpus/sql/cte/recursive_cte_key_hll_aggregation.test @@ -0,0 +1,25 @@ +# source: test/sql/cte/recursive_cte_key_hll_aggregation.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +create table customers (id integer, cname varchar); +-- +ok +== +insert into customers values (1, 'Customer#000000001'), (2, 'Customer#000000002'), (3, 'Customer#000000003'), (4, 'Customer#000000004'); +-- +ok +== +WITH RECURSIVE tbl(key, id, acc) USING KEY (key, approx_count_distinct(acc)) AS ( + SELECT 1, id, cname + FROM customers + WHERE id = 1 + UNION + SELECT key, tbl.id + 1, cname + FROM tbl + JOIN customers AS c ON c.id = tbl.id + 1) +select acc from tbl; +-- +ok +== diff --git a/parser/testdata/corpus/sql/cte/recursive_cte_key_probe.test b/parser/testdata/corpus/sql/cte/recursive_cte_key_probe.test new file mode 100644 index 0000000..d9b3a38 --- /dev/null +++ b/parser/testdata/corpus/sql/cte/recursive_cte_key_probe.test @@ -0,0 +1,516 @@ +# source: test/sql/cte/recursive_cte_key_probe.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +PRAGMA explain_output='physical_only'; +-- +ok +== +EXPLAIN WITH RECURSIVE t(k, v) USING KEY (k) AS ( + SELECT i, 0 FROM range(100) r(i) + UNION ALL + SELECT n.k, r.v + 1 + FROM t n JOIN recurring.t r USING (k) + WHERE n.v < 3 +) +SELECT * FROM t; +-- +ok +== +WITH RECURSIVE t(k, v) USING KEY (k) AS ( + SELECT i, 0 FROM range(8192) r(i) + UNION ALL + SELECT n.k, r.v + 1 + FROM t n JOIN recurring.t r USING (k) + WHERE n.v < 3 +) +SELECT count(*), min(v), max(v), sum(v) FROM t; +-- +ok +== +WITH RECURSIVE t(k, v) USING KEY (k) AS ( + SELECT i, 0 FROM range(8192) r(i) + UNION ALL + SELECT n.k, r.v + 1 + FROM recurring.t r JOIN t n USING (k) + WHERE n.v < 3 +) +SELECT count(*), min(v), max(v), sum(v) FROM t; +-- +ok +== +WITH RECURSIVE t(k1, k2, v) USING KEY (k1, k2) AS ( + SELECT i, i % 7, 0 FROM range(4096) r(i) + UNION ALL + SELECT n.k1, n.k2, r.v + 1 + FROM t n JOIN recurring.t r USING (k2, k1) + WHERE n.v < 2 +) +SELECT count(*), min(v), max(v), sum(v) FROM t; +-- +ok +== +WITH RECURSIVE t(k, v) USING KEY (k) AS ( + VALUES ('alpha', 0), ('beta', 0) + UNION ALL + SELECT n.k, r.v + 1 + FROM t n JOIN recurring.t r USING (k) + WHERE n.v < 2 +) +SELECT k, v FROM t; +-- +ok +== +WITH RECURSIVE t(k, v) USING KEY (k, sum(v) AS v) AS ( + VALUES (1, 0) + UNION ALL + SELECT n.k, r.v + 1 + FROM t n + CROSS JOIN (VALUES (1), (2)) duplicates(i) + JOIN recurring.t r USING (k) + WHERE n.v < 1 +) +SELECT k, v FROM t; +-- +ok +== +WITH RECURSIVE t(k, v) USING KEY (k) AS ( + VALUES (-0e0::DOUBLE, 0) + UNION ALL + SELECT r.k, r.v + 1 + FROM (SELECT 0e0::DOUBLE AS lookup_k, v FROM t) n + JOIN recurring.t r ON r.k = n.lookup_k + WHERE n.v < 1 +) +SELECT signbit(k), v FROM t; +-- +ok +== +WITH RECURSIVE t(k, v) USING KEY (k) AS ( + VALUES (NULL::INTEGER, 0), (1, 0) + UNION ALL + SELECT n.k, r.v + 1 + FROM t n JOIN recurring.t r ON r.k = n.k + WHERE n.v < 1 +) +SELECT k, v FROM t; +-- +ok +== +WITH RECURSIVE t(k, v) USING KEY (k) AS ( + VALUES (1, 0), (2, 0) + UNION ALL + SELECT n.k, r.v + 1 + FROM t n + JOIN (VALUES (1, 1), (2, 999)) p(k, lookup_key) ON n.k = p.k + JOIN recurring.t r ON r.k = p.lookup_key + WHERE n.v < 1 +) +SELECT k, v FROM t; +-- +ok +== +WITH RECURSIVE t(k, v) USING KEY (k) AS ( + SELECT i, 0 FROM range(10000) r(i) + UNION ALL + SELECT n.k, r.v + 1 + FROM (SELECT k, v, k + 10000 AS lookup_key FROM t) n + JOIN recurring.t r ON r.k = n.lookup_key + WHERE n.v < 1 +) +SELECT count(*), min(v), max(v), sum(v) FROM t; +-- +ok +== +WITH RECURSIVE t(k, v) USING KEY (k) AS ( + SELECT i, 0 FROM range(50000) r(i) + UNION ALL + SELECT n.k, r.v + 1 + FROM ( + SELECT k, v, + CASE WHEN length(md5(md5(md5(md5(k::VARCHAR))))) = 32 THEN k END AS lookup_key + FROM t + ) n + JOIN recurring.t r ON r.k = n.lookup_key + WHERE n.v < 4 +) +SELECT count(*), min(v), max(v), sum(v) FROM t; +-- +ok +== +WITH RECURSIVE t(k, v) USING KEY (k, max(v) AS v) AS ( + VALUES (1, 0) + UNION ALL + SELECT n.k, r.v + 1 + FROM t n JOIN recurring.t r USING (k) + WHERE n.v < 3 +) +SELECT k, v FROM t; +-- +ok +== +WITH RECURSIVE t(k, v) USING KEY (k) AS ( + VALUES (1, 0) + UNION ALL + SELECT n.k, r.v + 1 + FROM t n JOIN recurring.t r USING (k) + WHERE n.v < 2 +) +SELECT k, v FROM t; +-- +ok +== +WITH RECURSIVE outer_cte(a, b) AS ( + SELECT 1, 1 + UNION + ( + WITH RECURSIVE inner_cte(k, v) USING KEY (k) AS ( + SELECT a, 0 FROM outer_cte WHERE b < 4 + UNION ALL + SELECT n.k, r.v + 1 + FROM inner_cte n + JOIN recurring.inner_cte r USING (k) + WHERE n.v < 1 + ) + SELECT k, b + 1 + FROM inner_cte, outer_cte + WHERE v = 1 AND b < 4 + ) +) +SELECT * FROM outer_cte; +-- +ok +== +WITH RECURSIVE outer_cte(a, b) AS ( + SELECT 1, 1 + UNION + ( + WITH RECURSIVE inner_cte(k1, k2, v) USING KEY (k1, k2) AS ( + SELECT a, 10, 0 FROM outer_cte WHERE b < 4 + UNION ALL + SELECT n.k1, n.k2, r.v + 1 + FROM inner_cte n + JOIN recurring.inner_cte r ON r.k1 = n.k1 + WHERE n.v < 1 + ) + SELECT k1, b + 1 + FROM inner_cte, outer_cte + WHERE v = 1 AND b < 4 + ) +) +SELECT * FROM outer_cte; +-- +ok +== +EXPLAIN WITH RECURSIVE t(k1, k2, v) USING KEY (k1, k2) AS ( + VALUES (1, 1, 0) + UNION ALL + SELECT n.k1, n.k2, r.v + 1 + FROM t n JOIN recurring.t r ON r.k1 = n.k1 + WHERE n.v < 1 +) +SELECT * FROM t; +-- +ok +== +WITH RECURSIVE t(k1, k2, v) USING KEY (k1, k2) AS ( + VALUES (1, 10, 0), (2, 10, 0), (NULL, 10, 0), (1, NULL, 0) + UNION ALL + SELECT n.k1, n.k2, r.v + 1 + FROM t n JOIN recurring.t r ON r.k2 = n.k2 + WHERE n.v < 1 +) +SELECT k1, k2, v FROM t; +-- +ok +== +WITH RECURSIVE t(k1, k2, k3, v) USING KEY (k1, k2, k3) AS ( + VALUES (1, 10, 'a', 0), (1, 20, 'a', 0), (1, 30, 'b', 0) + UNION ALL + SELECT n.k1, n.k2, n.k3, r.v + 1 + FROM t n JOIN recurring.t r ON r.k3 = n.k3 AND r.k1 = n.k1 + WHERE n.v < 1 +) +SELECT * FROM t; +-- +ok +== +WITH RECURSIVE t(k1, k2, v) USING KEY (k1, k2, sum(v) AS v) AS ( + VALUES (1, 1, 0), (1, 2, 0) + UNION ALL + SELECT n.k1, n.k2, r.v + 1 + FROM t n JOIN recurring.t r ON r.k1 = n.k1 + WHERE n.v = 0 +) +SELECT * FROM t; +-- +ok +== +WITH RECURSIVE t(k1, k2, v) USING KEY (k1, k2) AS ( + VALUES (1, -0e0::DOUBLE, 0) + UNION ALL + SELECT n.k1, r.k2, r.v + 1 + FROM (SELECT k1, 0e0::DOUBLE AS lookup_k, v FROM t) n + JOIN recurring.t r ON r.k1 = n.k1 + WHERE n.v < 1 +) +SELECT signbit(k2), v FROM t; +-- +ok +== +WITH RECURSIVE t(k1, k2, v) USING KEY (k1, k2, sum(v) AS v) AS ( + SELECT 1, i::INTEGER, 0::BIGINT FROM range(3000) r(i) + UNION ALL + SELECT n.k1, n.k2, r.v + 1 + FROM t n JOIN recurring.t r ON r.k1 = n.k1 + WHERE n.k2 = 0 AND n.v = 0 +) +SELECT count(*), sum(v), max(v) FROM t; +-- +ok +== +WITH RECURSIVE t(k1, k2, v) USING KEY (k1, k2, max(v) AS v) AS ( + SELECT i % 1000, i, 0 FROM range(10000) r(i) + UNION ALL + SELECT n.k1, n.k2, r.v + 1 + FROM t n JOIN recurring.t r ON r.k1 = n.k1 + WHERE n.v < 1 +) +SELECT count(*), sum(v), max(v) FROM t; +-- +ok +== +WITH RECURSIVE t(k1, k2, v) USING KEY (k1, k2) AS ( + VALUES (1, 10, 0), (1, 20, 0), (2, 10, 0), (2, 20, 0) + UNION ALL + ( + SELECT n.k1, n.k2, r.v + 1 + FROM t n JOIN recurring.t r ON r.k1 = n.k1 + WHERE n.v < 1 + UNION ALL + SELECT n.k1, n.k2, r.v + 1 + FROM t n JOIN recurring.t r ON r.k2 = n.k2 + WHERE n.v < 1 + ) +) +SELECT * FROM t; +-- +ok +== +WITH RECURSIVE +fast(k1, k2, v) USING KEY (k1, k2) AS ( + SELECT i % 10, i, 0 FROM range(100) r(i) + UNION ALL + SELECT n.k1, n.k2, r.v + 1 + FROM fast n JOIN recurring.fast r ON r.k1 = n.k1 + WHERE n.v < 2 +), +fallback(k1, k2, v) USING KEY (k1, k2) AS ( + SELECT i % 10, i, 0 FROM range(100) r(i) + UNION ALL + SELECT n.k1, n.k2, r.v + 1 + FROM fallback n + JOIN (SELECT * FROM recurring.fallback WHERE v >= 0) r ON r.k1 = n.k1 + WHERE n.v < 2 +) +SELECT count(*) FROM ( + (SELECT * FROM fast EXCEPT ALL SELECT * FROM fallback) + UNION ALL + (SELECT * FROM fallback EXCEPT ALL SELECT * FROM fast) +); +-- +ok +== +WITH RECURSIVE t(k1, k2, v) USING KEY (k1, k2) AS ( + VALUES (1, 1, 0), (1, 2, 0), (2, 1, 0) + UNION ALL + SELECT n.k1, n.k2, r.v + 1 + FROM recurring.t r JOIN t n ON r.k1 = n.k1 + WHERE n.v < 1 +) +SELECT * FROM t; +-- +ok +== +WITH RECURSIVE t(k1, k2, v) USING KEY (k1, k2) AS ( + VALUES (1, 0, 0) + UNION ALL + SELECT n.k1, r.k2 + 1, n.v + 1 + FROM t n JOIN recurring.t r ON r.k1 = n.k1 + WHERE n.v < 2 AND r.k2 < 2 +) +SELECT * FROM t; +-- +ok +== +WITH RECURSIVE +fast(bucket, item, level) USING KEY (bucket, item) AS ( + VALUES (0::BIGINT, 0::BIGINT, 0) + UNION ALL + SELECT frontier.bucket + 1, + CASE WHEN frontier.level = 0 THEN generated.i ELSE state.item END, + frontier.level + 1 + FROM fast frontier + JOIN recurring.fast state ON state.bucket = frontier.bucket + CROSS JOIN LATERAL range(CASE WHEN frontier.level = 0 THEN 10000 ELSE 1 END) generated(i) + WHERE frontier.level < 2 AND frontier.item = 0 +), +fallback(bucket, item, level) USING KEY (bucket, item) AS ( + VALUES (0::BIGINT, 0::BIGINT, 0) + UNION ALL + SELECT frontier.bucket + 1, + CASE WHEN frontier.level = 0 THEN generated.i ELSE state.item END, + frontier.level + 1 + FROM fallback frontier + JOIN recurring.fallback state ON state.bucket::HUGEINT = frontier.bucket::HUGEINT + CROSS JOIN LATERAL range(CASE WHEN frontier.level = 0 THEN 10000 ELSE 1 END) generated(i) + WHERE frontier.level < 2 AND frontier.item = 0 +) +SELECT (SELECT count(*) FROM fast), + (SELECT max(level) FROM fast), + (SELECT sum(item) FROM fast), + (SELECT count(*) FROM ( + (SELECT * FROM fast EXCEPT ALL SELECT * FROM fallback) + UNION ALL + (SELECT * FROM fallback EXCEPT ALL SELECT * FROM fast) + )); +-- +ok +== +WITH RECURSIVE t(k1, k2, v) USING KEY (k1, k2) AS ( + VALUES (1, 1, 0), (1, 2, 0) + UNION ALL + SELECT n.k1, n.k2, r.v + 1 + FROM t n JOIN recurring.t r ON r.k1 = n.k1 + WHERE n.v < 1 +) +SELECT * FROM t; +-- +ok +== +WITH RECURSIVE t(k, v, i) USING KEY (k) AS ( + VALUES (1, 0, 0) + UNION ALL + SELECT n.k, d.v + 1, n.i + 1 + FROM t n + JOIN ( + SELECT r.k, r.v + FROM (VALUES (1)) p(k) + JOIN recurring.t r USING (k) + ) d USING (k) + WHERE n.i < 3 +) +SELECT * FROM t; +-- +ok +== +EXPLAIN WITH RECURSIVE t(k, v) USING KEY (k) AS ( + VALUES ({'x': 1}, 0) + UNION ALL + SELECT n.k, r.v + 1 + FROM t n JOIN recurring.t r USING (k) + WHERE n.v < 1 +) +SELECT * FROM t; +-- +ok +== +WITH RECURSIVE t(k, level, v) +USING KEY (k, max(level) AS level, approx_quantile(v, 0.5) AS v) AS ( + SELECT i, 0, i::DOUBLE + FROM range(512) r(i) + UNION ALL + ( + SELECT n.k, 1, r.v + FROM t n + JOIN (SELECT k, v FROM recurring.t WHERE v >= 0) r USING (k) + WHERE n.level = 0 + UNION ALL + SELECT n.k, 1, r.v + FROM t n + JOIN (SELECT k, v FROM recurring.t WHERE v >= 0) r USING (k) + WHERE n.level = 0 + ) +) +SELECT count(*), sum(v) FROM t; +-- +ok +== +EXPLAIN WITH RECURSIVE t(k1, k2, v) USING KEY (k1, k2) AS ( + VALUES (1, 1, 0) + UNION ALL + SELECT n.k1, n.k2, r.v + 1 + FROM t n JOIN recurring.t r ON r.k1::BIGINT = n.k1::BIGINT + WHERE n.v < 1 +) +SELECT * FROM t; +-- +ok +== +EXPLAIN WITH RECURSIVE t(k, v) USING KEY (k) AS ( + VALUES (1, 0) + UNION ALL + SELECT n.k, r.v + 1 + FROM t n JOIN recurring.t r ON r.k = n.k AND r.v = n.v + WHERE n.v < 1 +) +SELECT * FROM t; +-- +ok +== +EXPLAIN WITH RECURSIVE t(k, v) USING KEY (k) AS ( + VALUES (1, 0) + UNION ALL + SELECT n.k, coalesce(r.v, 0) + 1 + FROM t n LEFT JOIN recurring.t r USING (k) + WHERE n.v < 1 +) +SELECT * FROM t; +-- +ok +== +EXPLAIN WITH RECURSIVE +edges(src, dst) AS ( + VALUES (0, 1), (1, 2), (2, 3) +), +bfs(node) USING KEY (node) AS ( + VALUES (0) + UNION ALL + SELECT edge.dst + FROM bfs frontier + JOIN edges edge ON frontier.node = edge.src + LEFT JOIN recurring.bfs state ON edge.dst = state.node + WHERE state.node IS NULL +) +SELECT * FROM bfs; +-- +ok +== +EXPLAIN WITH RECURSIVE +edges(src, dst) AS ( + VALUES (0, 1), (1, 2), (2, 3) +), +bfs(node) USING KEY (node) AS ( + VALUES (0) + UNION ALL + SELECT edge.dst + FROM bfs frontier + JOIN edges edge ON frontier.node = edge.src + SEMI JOIN recurring.bfs state ON edge.dst = state.node +) +SELECT * FROM bfs; +-- +ok +== +EXPLAIN WITH RECURSIVE t(k, v) USING KEY (k) AS ( + VALUES (1, 0) + UNION ALL + SELECT n.k, r.v + 1 + FROM t n JOIN (SELECT * FROM recurring.t WHERE v >= 0) r USING (k) + WHERE n.v < 1 +) +SELECT * FROM t; +-- +ok +== diff --git a/parser/testdata/corpus/sql/cte/recursive_cte_key_snapshot.test b/parser/testdata/corpus/sql/cte/recursive_cte_key_snapshot.test new file mode 100644 index 0000000..63dde0e --- /dev/null +++ b/parser/testdata/corpus/sql/cte/recursive_cte_key_snapshot.test @@ -0,0 +1,63 @@ +# source: test/sql/cte/recursive_cte_key_snapshot.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +WITH RECURSIVE t(k, v) USING KEY (k) AS ( + SELECT 1, 0 + UNION ALL + SELECT n.k, r.v + 1 + FROM t n + JOIN recurring.t r USING (k) + WHERE n.v < 3 +) +SELECT k, v FROM t; +-- +ok +== +WITH RECURSIVE t(k, v) USING KEY (k) AS ( + SELECT i, 0 FROM range(8192) r(i) + UNION ALL + SELECT n.k, r.v + 1 + FROM t n + JOIN recurring.t r USING (k) + WHERE n.v < 3 +) +SELECT count(*), min(v), max(v), sum(v) FROM t; +-- +ok +== +WITH RECURSIVE t(k, v) USING KEY (k) AS ( + SELECT NULL::INTEGER, 10 + UNION ALL + SELECT r.k, r.v + 1 FROM t n, recurring.t r WHERE false +) +SELECT k, v FROM t; +-- +ok +== +WITH RECURSIVE t(k, v) USING KEY (k) AS ( + SELECT 1, 10 + UNION ALL + SELECT k, v + 1 FROM t WHERE false +) +SELECT k, v FROM t; +-- +ok +== +SELECT i, result_v +FROM range(1, 4) outer_q(i), LATERAL ( + WITH RECURSIVE t(k, v) USING KEY (k) AS ( + SELECT i, 0 + UNION ALL + SELECT n.k, r.v + 1 + FROM t n + JOIN recurring.t r USING (k) + WHERE n.v < i + ) + SELECT v AS result_v FROM t +) q +ORDER BY i; +-- +ok +== diff --git a/parser/testdata/corpus/sql/cte/recursive_cte_limit.test b/parser/testdata/corpus/sql/cte/recursive_cte_limit.test new file mode 100644 index 0000000..e5b83a6 --- /dev/null +++ b/parser/testdata/corpus/sql/cte/recursive_cte_limit.test @@ -0,0 +1,50 @@ +# source: test/sql/cte/recursive_cte_limit.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +WITH RECURSIVE t(i) AS ( + SELECT 0 + UNION ALL + SELECT i + 1 FROM t +) +SELECT i FROM t WHERE i % 2000 = 0 LIMIT 10; +-- +ok +== +WITH RECURSIVE + "@loop" ("$label", "$output", "0") AS ( + (SELECT '$'::VARCHAR AS "$label", NULL::BIGINT AS "$output", NULL::BIGINT AS "0") + UNION ALL + (WITH + "0" AS (SELECT NULL FROM "@loop" WHERE "$label" IS NOT DISTINCT FROM '$'), + "1" (i) AS (SELECT 0 AS i FROM "0"), + "2" (i) AS (SELECT "0" AS i FROM "@loop" WHERE "$label" IS NOT DISTINCT FROM '$loop0'), + "3" (i) AS ( + SELECT i FROM "1" + UNION ALL + SELECT i FROM "2" + ), + "4" (i) AS (SELECT (i + 1) % 1000 AS i FROM "3"), + "5" ("$output") AS (SELECT i FROM "4"), + "6" ("$label", i) AS (SELECT '$loop0', i FROM "4") + SELECT NULL::VARCHAR, "$output"::BIGINT, NULL::BIGINT FROM "5" + UNION ALL + SELECT "$label"::VARCHAR, NULL::BIGINT, i::BIGINT FROM "6" + ) + ) +SELECT "$output" FROM "@loop" WHERE "$label" IS NULL LIMIT 10; +-- +ok +== +SELECT count(*) FROM ( + WITH RECURSIVE t(i) AS ( + SELECT 0 + UNION ALL + SELECT i + 1 FROM t + ) + SELECT i FROM t LIMIT 2048 +); +-- +ok +== diff --git a/parser/testdata/corpus/sql/cte/recursive_cte_logging.test b/parser/testdata/corpus/sql/cte/recursive_cte_logging.test new file mode 100644 index 0000000..ce53974 --- /dev/null +++ b/parser/testdata/corpus/sql/cte/recursive_cte_logging.test @@ -0,0 +1,380 @@ +# source: test/sql/cte/recursive_cte_logging.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +WITH RECURSIVE t(i) AS ( + SELECT 1 + UNION ALL + SELECT i + 1 FROM t WHERE i < 10 +) +SELECT max(i) FROM t; +-- +ok +== +SELECT count(*) FROM duckdb_logs_parsed('PhysicalOperator') +WHERE class = 'PhysicalRecursiveCTE'; +-- +ok +== +WITH RECURSIVE t(i, level) AS ( + VALUES (1, 0), (2, 0) + UNION ALL + SELECT a.i, a.level + 1 + FROM t a + JOIN t b USING (i) + WHERE a.level < 1 AND b.level < 1 +) +SELECT count(*), max(level) FROM t; +-- +ok +== +SELECT info.frontier_rows::UBIGINT = 4, + info.frontier_chunks::UBIGINT = 2, + info.scheduler_input_rows::UBIGINT = 8 +FROM duckdb_logs_parsed('PhysicalOperator') +WHERE class = 'PhysicalRecursiveCTE' AND event = 'RuntimeMetrics'; +-- +ok +== +SELECT info.epochs::UBIGINT = 2, + info.frontier_rows_p50_upper_bound::UBIGINT = 3, + info.frontier_rows_max::UBIGINT = 2, + info.workers_p50_upper_bound::UBIGINT <= info.workers_max::UBIGINT * 2, + info.workers_max::UBIGINT >= 1, + info.tasks_p50_upper_bound::UBIGINT <= info.tasks_max::UBIGINT * 2, + info.tasks_max::UBIGINT >= 1, + info.elapsed_us_p50_upper_bound::UBIGINT <= info.elapsed_us_max::UBIGINT * 2, + info.frontier_storage_byte_epochs::UBIGINT >= info.peak_frontier_storage_bytes::UBIGINT, + info.peak_frontier_storage_bytes::UBIGINT > 0, + info.frontier_allocation_byte_epochs::UBIGINT >= info.peak_frontier_allocation_bytes::UBIGINT, + info.peak_frontier_allocation_bytes::UBIGINT > 0 +FROM duckdb_logs_parsed('PhysicalOperator') +WHERE class = 'PhysicalRecursiveCTE' AND event = 'EpochSummary'; +-- +ok +== +SELECT parameters['CTE Name'], + min(info.invocation_id::UBIGINT) = 1, + count(*) = count(DISTINCT info.invocation_id::UBIGINT), + max(info.invocation_id::UBIGINT) = count(*), + count(*) >= CASE parameters['CTE Name'] WHEN 'inner_cte' THEN 3 ELSE 1 END +FROM duckdb_logs_parsed('PhysicalOperator') +WHERE class = 'PhysicalRecursiveCTE' AND event = 'RuntimeMetrics' +GROUP BY parameters['CTE Name']; +-- +ok +== +SELECT count(*) = (SELECT count(*) + FROM duckdb_logs_parsed('PhysicalOperator') + WHERE class = 'PhysicalRecursiveCTE' AND event = 'RuntimeMetrics') +FROM duckdb_logs_parsed('PhysicalOperator') runtime +JOIN duckdb_logs_parsed('PhysicalOperator') summary + ON runtime.parameters['Table Index'] = summary.parameters['Table Index'] + AND runtime.info.invocation_id = summary.info.invocation_id +WHERE runtime.class = 'PhysicalRecursiveCTE' AND runtime.event = 'RuntimeMetrics' + AND summary.class = 'PhysicalRecursiveCTE' AND summary.event = 'EpochSummary'; +-- +ok +== +WITH RECURSIVE t(i, digest, level) AS ( + SELECT i, md5(i::VARCHAR), 0 + FROM range(current_setting('standard_vector_size')::BIGINT * 24) r(i) + UNION + SELECT i, md5(md5(md5(md5(digest)))), level + 1 FROM t WHERE level < 7 +) +SELECT count(*) = current_setting('standard_vector_size')::BIGINT * 24 * 8, max(level) FROM t; +-- +ok +== +SELECT count(*) FROM duckdb_logs_parsed('PhysicalOperator') +WHERE class = 'PhysicalRecursiveCTE' AND event = 'RuntimeMetrics'; +-- +ok +== +SELECT info.epochs::UBIGINT > 0, + info.scheduled_workers::UBIGINT > info.epochs::UBIGINT, + info.scheduled_tasks::UBIGINT >= info.epochs::UBIGINT, + info.hash_rows::UBIGINT >= current_setting('standard_vector_size')::UBIGINT * 24 * 8 +FROM duckdb_logs_parsed('PhysicalOperator') +WHERE class = 'PhysicalRecursiveCTE' AND event = 'RuntimeMetrics'; +-- +ok +== +SELECT count(*) = 1 FROM duckdb_logs_parsed('PhysicalOperator') +WHERE class = 'PhysicalRecursiveCTE' AND event = 'DistinctPromoted' + AND info.partitions::UBIGINT BETWEEN 2 AND 4 + AND info.migrated_rows::UBIGINT > 0; +-- +ok +== +SELECT info.distinct_grouping_work_ns::UBIGINT > 0, + info.distinct_candidate_rows::UBIGINT = current_setting('standard_vector_size')::UBIGINT * 24 * 8, + info.distinct_inserted_rows::UBIGINT = current_setting('standard_vector_size')::UBIGINT * 24 * 8, + info.distinct_duplicate_rows::UBIGINT = 0, + info.recursive_pipeline_execute_work_ns::UBIGINT > 0 +FROM duckdb_logs_parsed('PhysicalOperator') +WHERE class = 'PhysicalRecursiveCTE' AND event = 'EpochSummary'; +-- +ok +== +WITH RECURSIVE t(i) AS ( + VALUES (1) + UNION + ( + SELECT i + 1 FROM t WHERE i < 4 + UNION ALL + SELECT i + 1 FROM t WHERE i < 4 + ) +) +SELECT count(*), max(i) FROM t; +-- +ok +== +SELECT info.distinct_grouping_work_ns::UBIGINT > 0, + info.distinct_candidate_rows::UBIGINT = 7, + info.distinct_inserted_rows::UBIGINT = 4, + info.distinct_duplicate_rows::UBIGINT = 3 +FROM duckdb_logs_parsed('PhysicalOperator') +WHERE class = 'PhysicalRecursiveCTE' AND event = 'EpochSummary'; +-- +ok +== +WITH RECURSIVE t(i, digest, level) AS ( + SELECT i, md5(i::VARCHAR), 0 FROM range(50000) r(i) + UNION ALL + SELECT i, md5(md5(md5(md5(digest)))), level + 1 FROM t WHERE level < 7 +) +SELECT count(*), max(level), sum(length(digest)) FROM t; +-- +ok +== +SELECT info.scheduled_workers::UBIGINT > info.epochs::UBIGINT +FROM duckdb_logs_parsed('PhysicalOperator') +WHERE class = 'PhysicalRecursiveCTE' AND event = 'RuntimeMetrics'; +-- +ok +== +WITH RECURSIVE t(i, level) AS ( + SELECT i, 0 FROM range(current_setting('standard_vector_size')::BIGINT * 2) values(i) + UNION ALL + SELECT i, level + 1 FROM t WHERE level < 3 +) +SELECT count(*) = current_setting('standard_vector_size')::BIGINT * 8, max(level) FROM t; +-- +ok +== +SELECT info.scheduled_workers::UBIGINT = info.epochs::UBIGINT +FROM duckdb_logs_parsed('PhysicalOperator') +WHERE class = 'PhysicalRecursiveCTE' AND event = 'RuntimeMetrics'; +-- +ok +== +WITH RECURSIVE t(i, digest, level) AS ( + SELECT i, md5(i::VARCHAR), 0 + FROM range(current_setting('standard_vector_size')::BIGINT * 2) values(i) + UNION ALL + ( + WITH state AS MATERIALIZED ( + SELECT i, md5(md5(md5(digest))) AS digest, level + 1 AS level + FROM t + WHERE level < 3 + ) + SELECT * FROM state WHERE i % 6 = 0 + UNION ALL + SELECT * FROM state WHERE i % 6 = 1 + UNION ALL + SELECT * FROM state WHERE i % 6 = 2 + UNION ALL + SELECT * FROM state WHERE i % 6 = 3 + UNION ALL + SELECT * FROM state WHERE i % 6 = 4 + UNION ALL + SELECT * FROM state WHERE i % 6 = 5 + ) +) +SELECT count(*) = current_setting('standard_vector_size')::BIGINT * 8, + max(level), + sum(length(digest)) = current_setting('standard_vector_size')::BIGINT * 8 * 32 +FROM t; +-- +ok +== +WITH RECURSIVE t(i, level, rn) AS ( + SELECT i, 0, 0::BIGINT + FROM range(current_setting('standard_vector_size')::BIGINT * 2) values(i) + UNION ALL + ( + WITH tmp AS MATERIALIZED (SELECT * FROM t), + ranked AS ( + SELECT a.i, + a.level, + row_number() OVER (PARTITION BY a.i ORDER BY b.i DESC) AS rn + FROM tmp a + JOIN tmp b + ON a.i % greatest(current_setting('standard_vector_size')::BIGINT / 64, 1) + = b.i % greatest(current_setting('standard_vector_size')::BIGINT / 64, 1) + ) + SELECT i, level + 1, rn + FROM ranked + WHERE rn = 1 AND level < 2 + ) +) +SELECT count(*) = current_setting('standard_vector_size')::BIGINT * 6, + max(level) = 2, + sum(rn) = current_setting('standard_vector_size')::BIGINT * 4 +FROM t; +-- +ok +== +WITH RECURSIVE t(i, level) AS ( + VALUES (0::BIGINT, 0) + UNION ALL + SELECT i * 2 + branch, level + 1 + FROM t, range(2) branches(branch) + WHERE level < 17 +) +SELECT count(*), max(level) FROM t; +-- +ok +== +WITH RECURSIVE t(k, v) USING KEY (k) AS ( + SELECT i, 0 FROM range(4096) r(i) + UNION ALL + SELECT n.k, r.v + 1 + FROM t n JOIN recurring.t r USING (k) + WHERE n.v < 2 +) +SELECT count(*), max(v) FROM t; +-- +ok +== +SELECT info.direct_probe_rows::UBIGINT > 0, + info.recurring_scan_rows::UBIGINT = 0 +FROM duckdb_logs_parsed('PhysicalOperator') +WHERE class = 'PhysicalRecursiveCTE' AND event = 'RuntimeMetrics'; +-- +ok +== +SELECT info.direct_probe_lookup_work_ns::UBIGINT > 0, + info.direct_probe_key_gather_work_ns::UBIGINT > 0, + info.direct_probe_payload_finalize_work_ns::UBIGINT > 0, + info.keyed_hash_commit_work_ns::UBIGINT > 0, + info.partial_index_maintenance_work_ns::UBIGINT = 0, + info.recurring_scan_work_ns::UBIGINT = 0, + info.final_state_drain_work_ns::UBIGINT > 0 +FROM duckdb_logs_parsed('PhysicalOperator') +WHERE class = 'PhysicalRecursiveCTE' AND event = 'EpochSummary'; +-- +ok +== +WITH RECURSIVE t(k1, k2, v) USING KEY (k1, k2) AS ( + SELECT k1, k2, CASE WHEN k1 = 0 THEN 0 ELSE 10 END + FROM range(100) keys(k1), range(10) items(k2) + UNION ALL + SELECT n.k1 + 1, r.k2, n.v + 1 + FROM t n JOIN recurring.t r ON r.k1 = n.k1 + WHERE n.k2 = 0 AND n.v < 3 +) +SELECT count(*), sum(v)::BIGINT, max(v) FROM t; +-- +ok +== +SELECT info.partial_index_rows::UBIGINT = 1000, + info.partial_index_bytes::UBIGINT > 0, + info.partial_probe_chain_visits::UBIGINT >= info.direct_probe_matches::UBIGINT, + info.recurring_scan_rows::UBIGINT = 0 +FROM duckdb_logs_parsed('PhysicalOperator') +WHERE class = 'PhysicalRecursiveCTE' AND event = 'RuntimeMetrics'; +-- +ok +== +SELECT info.direct_probe_lookup_work_ns::UBIGINT > 0, + info.direct_probe_key_gather_work_ns::UBIGINT > 0, + info.direct_probe_payload_finalize_work_ns::UBIGINT > 0, + info.keyed_hash_commit_work_ns::UBIGINT > 0, + info.partial_index_maintenance_work_ns::UBIGINT > 0 +FROM duckdb_logs_parsed('PhysicalOperator') +WHERE class = 'PhysicalRecursiveCTE' AND event = 'EpochSummary'; +-- +ok +== +WITH RECURSIVE t(k, v) USING KEY (k) AS ( + SELECT i, + CASE WHEN i < greatest(current_setting('standard_vector_size')::BIGINT / 4, 1) THEN 0 ELSE 100 END + FROM range(current_setting('standard_vector_size')::BIGINT * 16) r(i) + UNION ALL + SELECT n.k, r.v + 1 + FROM t n + JOIN recurring.t r USING (k) + WHERE n.v < 4 +) +SELECT count(*) = current_setting('standard_vector_size')::BIGINT * 16, min(v) FROM t; +-- +ok +== +SELECT info.scheduled_workers::UBIGINT = info.epochs::UBIGINT + 7, + info.recurring_scan_rows::UBIGINT = 0 +FROM duckdb_logs_parsed('PhysicalOperator') +WHERE class = 'PhysicalRecursiveCTE' AND event = 'RuntimeMetrics'; +-- +ok +== +WITH RECURSIVE t(bucket, item, level) USING KEY (bucket, item) AS ( + SELECT bucket, item, CASE WHEN bucket = 0 THEN 0 ELSE 100 END + FROM range(current_setting('standard_vector_size')::BIGINT * 4) b(bucket), range(8) i(item) + UNION ALL + SELECT n.bucket + 1, r.item, n.level + 1 + FROM t n + JOIN recurring.t r ON r.bucket = n.bucket + WHERE n.item = 0 AND n.level < 4 +) +SELECT count(*) = current_setting('standard_vector_size')::BIGINT * 4 * 8, + (SELECT level FROM t WHERE bucket = 4 AND item = 0) +FROM t; +-- +ok +== +SELECT info.scheduled_workers::UBIGINT > info.epochs::UBIGINT, + info.scheduled_workers::UBIGINT < info.epochs::UBIGINT * 8, + info.partial_probe_chain_visits::UBIGINT > info.direct_probe_rows::UBIGINT +FROM duckdb_logs_parsed('PhysicalOperator') +WHERE class = 'PhysicalRecursiveCTE' AND event = 'RuntimeMetrics'; +-- +ok +== +WITH RECURSIVE t(k, v) USING KEY (k) AS ( + SELECT i, 0 + FROM range(current_setting('standard_vector_size')::BIGINT * 4) r(i) + UNION ALL + SELECT r.k, r.v + 1 + FROM range(current_setting('standard_vector_size')::BIGINT * 4) n(i) + JOIN (SELECT * FROM recurring.t WHERE v < 2) r ON r.k = n.i +) +SELECT count(*) = current_setting('standard_vector_size')::BIGINT * 4, max(v) FROM t; +-- +ok +== +SELECT info.scheduled_workers::UBIGINT > info.epochs::UBIGINT, + info.direct_probe_rows::UBIGINT = 0, + info.recurring_scan_rows::UBIGINT > 0 +FROM duckdb_logs_parsed('PhysicalOperator') +WHERE class = 'PhysicalRecursiveCTE' AND event = 'RuntimeMetrics'; +-- +ok +== +SELECT info.direct_probe_lookup_work_ns::UBIGINT = 0, + info.direct_probe_key_gather_work_ns::UBIGINT = 0, + info.direct_probe_payload_finalize_work_ns::UBIGINT = 0 +FROM duckdb_logs_parsed('PhysicalOperator') +WHERE class = 'PhysicalRecursiveCTE' AND event = 'EpochSummary'; +-- +ok +== +SELECT info.recurring_scan_work_ns::UBIGINT > 0, + info.final_state_drain_work_ns::UBIGINT > 0 +FROM duckdb_logs_parsed('PhysicalOperator') +WHERE class = 'PhysicalRecursiveCTE' AND event = 'EpochSummary'; +-- +ok +== diff --git a/parser/testdata/corpus/sql/cte/recursive_cte_parallel_union_all_sink.test b/parser/testdata/corpus/sql/cte/recursive_cte_parallel_union_all_sink.test new file mode 100644 index 0000000..305494d --- /dev/null +++ b/parser/testdata/corpus/sql/cte/recursive_cte_parallel_union_all_sink.test @@ -0,0 +1,75 @@ +# source: test/sql/cte/recursive_cte_parallel_union_all_sink.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +WITH RECURSIVE t(i, level) AS ( + SELECT i, 0 FROM range(8192) r(i) + UNION ALL + SELECT i, level + 1 FROM t WHERE level < 3 +) +SELECT count(*), sum(i), sum(level) FROM t; +-- +ok +== +WITH RECURSIVE t(i) AS ( + SELECT i FROM range(8192) r(i) + UNION ALL + SELECT i FROM t WHERE false +) +SELECT count(*), sum(i) FROM t; +-- +ok +== +WITH RECURSIVE t(i, level) AS ( + SELECT i, 0 FROM range(8192) r(i) WHERE i % 2 = 0 + UNION ALL + SELECT i, level + 1 FROM t WHERE level < 2 +) +SELECT count(*), sum(i) FROM t; +-- +ok +== +WITH RECURSIVE t(i, level) AS ( + VALUES (0::BIGINT, 0) + UNION ALL + SELECT next.i, t.level + 1 + FROM t + CROSS JOIN LATERAL range( + CASE + WHEN t.level = 0 THEN 50000 + ELSE 1 + END + ) next(i) + WHERE t.level = 0 OR (t.level = 1 AND t.i = 0) +) +SELECT count(*), sum(i), max(level) FROM t; +-- +ok +== +SET temp_directory=''; +-- +ok +== +WITH RECURSIVE t(i) AS ( + VALUES (0::BIGINT) + UNION ALL + SELECT i + 1 FROM t WHERE i < 4999 +) +SELECT count(*) FROM t; +-- +ok +== +RESET temp_directory; +-- +ok +== +WITH RECURSIVE t(i) AS ( + SELECT i FROM range(8192) r(i) + UNION ALL + SELECT i + 1 FROM t WHERE i < 0 +) +SELECT count(*) FROM t; +-- +ok +== diff --git a/parser/testdata/corpus/sql/cte/recursive_cte_parallel_union_distinct_sink.test b/parser/testdata/corpus/sql/cte/recursive_cte_parallel_union_distinct_sink.test new file mode 100644 index 0000000..1d7c821 --- /dev/null +++ b/parser/testdata/corpus/sql/cte/recursive_cte_parallel_union_distinct_sink.test @@ -0,0 +1,60 @@ +# source: test/sql/cte/recursive_cte_parallel_union_distinct_sink.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +WITH RECURSIVE t(i, digest, level) AS ( + SELECT i, md5(i::VARCHAR), 0 FROM range(50000) r(i) + UNION + SELECT i, md5(md5(md5(md5(digest)))), level + 1 FROM t WHERE level < 7 +) +SELECT count(*), min(i), max(i), max(level) FROM t; +-- +ok +== +WITH RECURSIVE t(i) AS ( + SELECT i FROM range(1024) r(i) + UNION + SELECT (i * 8 + d) % 16384 + FROM t, range(8) r(d) +) +SELECT count(*), min(i), max(i), sum(i) FROM t; +-- +ok +== +WITH RECURSIVE t(i, level) AS ( + SELECT * FROM (VALUES (NULL::INTEGER, 0), (NULL, 0), (1, 0), (1, 0)) + UNION + SELECT i, level + 1 FROM t WHERE level < 2 +) +SELECT i, level FROM t; +-- +ok +== +WITH RECURSIVE t(i, level) AS ( + SELECT i, 0 FROM range(4096) r(i) WHERE i % 2 = 0 + UNION + SELECT i + 1, level + 1 FROM t WHERE level < 3 AND i % 2 = 0 +) +SELECT count(*), min(i), max(i) FROM t; +-- +ok +== +WITH RECURSIVE t(i) AS ( + SELECT 1 + UNION + SELECT i + 1 FROM t WHERE i < 1000 +) +SELECT sum(i) FROM t; +-- +ok +== +WITH RECURSIVE t(i, level) AS ( + SELECT i, 0 FROM range(4096) r(i) + UNION + SELECT i, level + 1 FROM t WHERE level < 4 +) +SELECT count(*), max(level) FROM t; +-- +ok +== diff --git a/parser/testdata/corpus/sql/cte/recursive_hang_2745.test b/parser/testdata/corpus/sql/cte/recursive_hang_2745.test new file mode 100644 index 0000000..f839051 --- /dev/null +++ b/parser/testdata/corpus/sql/cte/recursive_hang_2745.test @@ -0,0 +1,64 @@ +# source: test/sql/cte/recursive_hang_2745.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +with RECURSIVE parents_tab (id , value , parent ) +as (values (1, 1, 2), (2, 2, 4), (3, 1, 4), (4, 2, -1), (5, 1, 2), (6, 2, 7), (7, 1, -1) +), +parents_tab2(id , value , parent ) +as (values (1, 1, 2), (2, 2, 4), (3, 1, 4), (4, 2, -1), (5, 1, 2), (6, 2, 7), (7, 1, -1) +), +parents as ( + select * from parents_tab + union all + select id, value+2, parent from parents_tab2 +) +select * from parents order by id, value, parent; +-- +ok +== +with RECURSIVE parents_tab (id , value , parent ) +as (values (1, 1, 2), (2, 2, 4), (3, 1, 4), (4, 2, -1), (5, 1, 2), (6, 2, 7), (7, 1, -1) +), +parents_tab2(id , value , parent ) +as (values (1, 1, 2), (2, 2, 4), (3, 1, 4), (4, 2, -1), (5, 1, 2), (6, 2, 7), (7, 1, -1) +) +select * from parents_tab +union all +select id, value+2, parent from parents_tab2 ORDER BY id, value, parent; +-- +ok +== +with parents_tab (id , value , parent ) +as (values (1, 1, 2), (2, 2, 4), (3, 1, 4), (4, 2, -1), (5, 1, 2), (6, 2, 7), (7, 1, -1) +), +parents_tab2(id , value , parent ) +as (values (1, 1, 2), (2, 2, 4), (3, 1, 4), (4, 2, -1), (5, 1, 2), (6, 2, 7), (7, 1, -1) +), +parents as ( + select * from parents_tab + union all + select id, value+2, parent from parents_tab2 +) +select * from parents ORDER BY id, value, parent; +-- +ok +== +create view vparents as +with RECURSIVE parents_tab (id , value , parent ) +as (values (1, 1, 2), (2, 2, 4), (3, 1, 4), (4, 2, -1), (5, 1, 2), (6, 2, 7), (7, 1, -1) +), +parents_tab2(id , value , parent ) +as (values (1, 1, 2), (2, 2, 4), (3, 1, 4), (4, 2, -1), (5, 1, 2), (6, 2, 7), (7, 1, -1) +) +select * from parents_tab +union all +select id, value+2, parent from parents_tab2; +-- +ok +== +select * from vparents; +-- +ok +== diff --git a/parser/testdata/corpus/sql/cte/test_bug_922.test b/parser/testdata/corpus/sql/cte/test_bug_922.test new file mode 100644 index 0000000..448ea26 --- /dev/null +++ b/parser/testdata/corpus/sql/cte/test_bug_922.test @@ -0,0 +1,10 @@ +# source: test/sql/cte/test_bug_922.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +WITH my_list(value) AS (VALUES (1), (2), (3)) + SELECT * FROM my_list LIMIT 0 OFFSET 1 +-- +ok +== diff --git a/parser/testdata/corpus/sql/cte/test_cte.test b/parser/testdata/corpus/sql/cte/test_cte.test new file mode 100644 index 0000000..c5f305a --- /dev/null +++ b/parser/testdata/corpus/sql/cte/test_cte.test @@ -0,0 +1,169 @@ +# source: test/sql/cte/test_cte.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +with cte1 as (Select i as j from a) select * from cte1; +-- +ok +== +with cte1 as (Select i as j from a) select x from cte1 t1(x); +-- +ok +== +with cte1(xxx) as (Select i as j from a) select xxx from cte1; +-- +ok +== +with cte1(xxx) as (Select i as j from a) select x from cte1 t1(x); +-- +ok +== +with cte1 as (Select i as j from a), cte2 as (select ref.j as k from cte1 as ref), cte3 as (select ref2.j+1 as i from cte1 as ref2) select * from cte2 , cte3; +-- +ok +== +with cte1 as (select i as j from a), cte2 as (select ref.j as k from cte1 as ref), cte3 as (select ref2.j+1 as i from cte1 as ref2) select * from cte2 union all select * FROM cte3; +-- +ok +== +with cte1 as (select 42), cte1 as (select 42) select * FROM cte1; +-- +error: Parser Error: Duplicate CTE name "cte1" +== +with cte1 as (Select i as j from a) select * from cte1 cte11, cte1 cte12; +-- +ok +== +with cte1 as (Select i as j from a) select * from cte1 where j = (select max(j) from cte1 as cte2); +-- +ok +== +with cte1(x, y) as (select 42 a, 84 b) select zzz, y from cte1 t1(zzz); +-- +ok +== +create view va AS (with cte as (Select i as j from a) select * from cte); +-- +ok +== +with cte AS (SELECT * FROM va) SELECT * FROM cte; +-- +ok +== +create view vb AS (with cte1 as (Select i as j from a), cte2 as (select ref.j+1 as k from cte1 as ref) select * from cte2); +-- +ok +== +SELECT 1 UNION ALL (WITH cte AS (SELECT 42) SELECT * FROM cte); +-- +ok +== +SELECT 1 UNION ALL (WITH cte AS (SELECT 42) SELECT * FROM cte UNION ALL SELECT * FROM cte); +-- +ok +== +WITH RECURSIVE cte(d) AS ( + SELECT 1 + UNION ALL + (WITH c(d) AS (SELECT * FROM cte) + SELECT d + 1 + FROM c + WHERE FALSE + ) +) +SELECT max(d) FROM cte; +-- +ok +== +with cte (a) as ( + select 1 +) +select + a as alias1, + alias1 as alias2 +from cte +where alias2 > 0; +-- +ok +== +WITH RECURSIVE t AS ( + SELECT 1 AS a + UNION ALL + SELECT a+1 + FROM t + WHERE a < 10 +), s AS ( + (VALUES (5), (6), (7), (8), (9), (10), (11), (12), (13), (42)) + EXCEPT + TABLE t +) +SELECT * FROM s AS _(x) ORDER BY x; +-- +ok +== +WITH RECURSIVE t AS ( + select 1 as a + union all + (select a+1 + from t + where a < 10 + except + SELECT 4) +), s AS ( + (values (5), (6), (7)) + except + table t +) +SELECT * FROM s AS _(x) ORDER BY x; +-- +ok +== +WITH RECURSIVE + t(b) AS MATERIALIZED ( + (WITH helper(c) AS ( + SELECT 5 + ), h1 AS + (SELECT * FROM helper h + UNION + SELECT 7 FROM helper h) + SELECT * FROM h1) + ) +SELECT * FROM t ORDER BY b; +-- +ok +== +WITH RECURSIVE + t(b) AS MATERIALIZED ( + (WITH helper(c) AS ( + SELECT 5 + ) + SELECT * FROM helper h + UNION + SELECT 7 + ) + ) +SELECT * FROM t ORDER BY b; +-- +ok +== +with cte3 as (select ref2.j as i from cte1 as ref2), cte1 as (Select i as j from a), cte2 as (select ref.j+1 as k from cte1 as ref) select * from cte2 union all select * FROM cte3; +-- +ok +== +WITH t(x) AS (SELECT x) +SELECT * +FROM range(10) AS _(x), LATERAL (SELECT * FROM t); +-- +ok +== +WITH cte AS (SELECT x) +SELECT b.x +FROM (SELECT 1) _(x), LATERAL (SELECT * FROM cte) b(x) +-- +ok +== +WITH RECURSIVE rec(a, b, c) AS (select a,b,c from (values(1,2,3),(1,2,3)) s(a,b,c) union select 1,2,3) select * from rec; +-- +ok +== diff --git a/parser/testdata/corpus/sql/cte/test_cte.test.metadata.json b/parser/testdata/corpus/sql/cte/test_cte.test.metadata.json new file mode 100644 index 0000000..91f227f --- /dev/null +++ b/parser/testdata/corpus/sql/cte/test_cte.test.metadata.json @@ -0,0 +1,5 @@ +{ + "todo": { + "2184b745d9f86eaa": "transformer-raised parser error: upstream rejects in the transformer, not the grammar; expected to clear as transformers land (milestones 3-5)" + } +} diff --git a/parser/testdata/corpus/sql/cte/test_cte_in_cte.test b/parser/testdata/corpus/sql/cte/test_cte_in_cte.test new file mode 100644 index 0000000..fc54482 --- /dev/null +++ b/parser/testdata/corpus/sql/cte/test_cte_in_cte.test @@ -0,0 +1,33 @@ +# source: test/sql/cte/test_cte_in_cte.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +with cte1 as (with b as (Select i as j from a) Select j from b) select x from cte1 t1(x); +-- +ok +== +with cte1(xxx) as (with ncte(yyy) as (Select i as j from a) Select yyy from ncte) select xxx from cte1; +-- +ok +== +with cte1 as (with b as (Select i as j from a) select j from b), cte2 as (with c as (select ref.j+1 as k from cte1 as ref) select k from c) select * from cte1 , cte2; +-- +ok +== +with cte1 as (Select i as j from a) select * from (with cte2 as (select max(j) as j from cte1) select * from cte2) f +-- +ok +== +with cte1 as (Select i as j from a) select * from cte1 where j = (with cte2 as (select max(j) as j from cte1) select j from cte2); +-- +ok +== +with cte as (Select i as j from a) select * from cte where j = (with cte as (select max(j) as j from cte) select j from cte); +-- +ok +== +with cte as (select * from cte) select * from cte +-- +ok +== diff --git a/parser/testdata/corpus/sql/cte/test_cte_overflow.test b/parser/testdata/corpus/sql/cte/test_cte_overflow.test new file mode 100644 index 0000000..eddada5 --- /dev/null +++ b/parser/testdata/corpus/sql/cte/test_cte_overflow.test @@ -0,0 +1,13 @@ +# source: test/sql/cte/test_cte_overflow.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +create view va as (with v as (select * from a) select * from v) +-- +ok +== +with a as (select * from va) select * from a +-- +ok +== diff --git a/parser/testdata/corpus/sql/cte/test_issue_5673.test b/parser/testdata/corpus/sql/cte/test_issue_5673.test new file mode 100644 index 0000000..07599e9 --- /dev/null +++ b/parser/testdata/corpus/sql/cte/test_issue_5673.test @@ -0,0 +1,34 @@ +# source: test/sql/cte/test_issue_5673.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +create or replace table orders(ordered_at int); +-- +ok +== +create or replace table stg_orders(ordered_at int); +-- +ok +== +insert into orders values (1); +-- +ok +== +insert into stg_orders values (1); +-- +ok +== +with +orders as ( + select * from main.stg_orders + where ordered_at >= (select max(ordered_at) from main.orders) +), +some_more_logic as ( + select * + from orders +) +select * from some_more_logic; +-- +ok +== diff --git a/parser/testdata/corpus/sql/cte/test_moderate_union_all.test b/parser/testdata/corpus/sql/cte/test_moderate_union_all.test new file mode 100644 index 0000000..4f0a298 --- /dev/null +++ b/parser/testdata/corpus/sql/cte/test_moderate_union_all.test @@ -0,0 +1,112 @@ +# source: test/sql/cte/test_moderate_union_all.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +CREATE VIEW union_view AS +SELECT 0 i +UNION ALL +SELECT 1 +UNION ALL +SELECT 2 +UNION ALL +SELECT 3 +UNION ALL +SELECT 4 +UNION ALL +SELECT 5 +UNION ALL +SELECT 6 +UNION ALL +SELECT 7 +UNION ALL +SELECT 8 +UNION ALL +SELECT 9 +UNION ALL +SELECT 10 +UNION ALL +SELECT 11 +UNION ALL +SELECT 12 +UNION ALL +SELECT 13 +UNION ALL +SELECT 14 +UNION ALL +SELECT 15 +UNION ALL +SELECT 16 +UNION ALL +SELECT 17 +UNION ALL +SELECT 18 +UNION ALL +SELECT 19 +UNION ALL +SELECT 20 +UNION ALL +SELECT 21 +UNION ALL +SELECT 22 +UNION ALL +SELECT 23 +UNION ALL +SELECT 24 +UNION ALL +SELECT 25 +UNION ALL +SELECT 26 +UNION ALL +SELECT 27 +UNION ALL +SELECT 28 +UNION ALL +SELECT 29 +UNION ALL +SELECT 30 +UNION ALL +SELECT 31 +UNION ALL +SELECT 32 +UNION ALL +SELECT 33 +UNION ALL +SELECT 34 +UNION ALL +SELECT 35 +UNION ALL +SELECT 36 +UNION ALL +SELECT 37 +UNION ALL +SELECT 38 +UNION ALL +SELECT 39 +UNION ALL +SELECT 40 +UNION ALL +SELECT 41 +UNION ALL +SELECT 42 +UNION ALL +SELECT 43 +UNION ALL +SELECT 44 +UNION ALL +SELECT 45 +UNION ALL +SELECT 46 +UNION ALL +SELECT 47 +UNION ALL +SELECT 48 +UNION ALL +SELECT 49 +-- +ok +== +SELECT COUNT(*), MIN(i), MAX(i), AVG(i) FROM union_view +-- +ok +== diff --git a/parser/testdata/corpus/sql/cte/test_nested_recursive_cte.test b/parser/testdata/corpus/sql/cte/test_nested_recursive_cte.test new file mode 100644 index 0000000..bbd76c4 --- /dev/null +++ b/parser/testdata/corpus/sql/cte/test_nested_recursive_cte.test @@ -0,0 +1,43 @@ +# source: test/sql/cte/test_nested_recursive_cte.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +WITH RECURSIVE t(x) AS +( + SELECT 1 + UNION ALL + SELECT x+1 + FROM t + WHERE x < 4 +), +u(x) AS +( + SELECT * + FROM t + UNION ALL + SELECT u.x * 2 + t.x + FROM u, t + WHERE u.x < 32 +) +SELECT * +FROM u +ORDER BY x +LIMIT 5; +-- +ok +== +WITH RECURSIVE collatz(x, t, steps) AS +( + SELECT x, x, 0 + FROM (WITH RECURSIVE n(t) AS (SELECT 1 UNION ALL SELECT t+1 FROM n WHERE t < 10) SELECT * FROM n) AS _(x) + UNION ALL + (SELECT x, CASE WHEN t%2 = 1 THEN t * 3 + p ELSE t / 2 END, steps + p + FROM collatz, (WITH RECURSIVE n(t) AS (SELECT 1 UNION ALL SELECT t+1 FROM n WHERE t < 1) SELECT * FROM n) AS _(p) + WHERE t <> 1) +) +SELECT * FROM collatz WHERE t = 1 +ORDER BY x; +-- +ok +== diff --git a/parser/testdata/corpus/sql/cte/test_outer_joins_recursive_cte.test b/parser/testdata/corpus/sql/cte/test_outer_joins_recursive_cte.test new file mode 100644 index 0000000..c83030a --- /dev/null +++ b/parser/testdata/corpus/sql/cte/test_outer_joins_recursive_cte.test @@ -0,0 +1,82 @@ +# source: test/sql/cte/test_outer_joins_recursive_cte.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +WITH RECURSIVE t(x) AS +( + SELECT 1 + UNION ALL + SELECT x + 1 + FROM (SELECT t.x+1 FROM v AS _(p) FULL OUTER JOIN t ON t.x = p) AS _(x) + WHERE x < 10 +) SELECT * FROM v AS _(p) RIGHT OUTER JOIN t ON t.x = p ORDER BY p, t NULLS LAST; +-- +ok +== +WITH RECURSIVE t(x) AS +( + SELECT 1 + UNION ALL + SELECT x + 1 + FROM (SELECT t.x+1 FROM v AS _(p) FULL OUTER JOIN t ON t.x <= p) AS _(x) + WHERE x < 10 +) SELECT * FROM v AS _(p) RIGHT OUTER JOIN t ON t.x = p ORDER BY p, t NULLS LAST; +-- +ok +== +WITH RECURSIVE t(x) AS +( + SELECT 1 + UNION ALL + SELECT COALESCE(t.x, p) + 1 + FROM (VALUES (NULL::INTEGER)) AS v(p) FULL OUTER JOIN t ON t.x <= p + WHERE COALESCE(t.x, p) < 3 +) SELECT * FROM t ORDER BY x; +-- +ok +== +EXPLAIN WITH RECURSIVE t(x) AS +( + SELECT 1 + UNION ALL + SELECT COALESCE(t.x, p) + 1 + FROM (VALUES (NULL::INTEGER)) AS v(p) FULL OUTER JOIN t ON t.x <= p + WHERE COALESCE(t.x, p) < 3 +) SELECT * FROM t; +-- +ok +== +EXPLAIN WITH RECURSIVE t(x) AS +( + SELECT 1 + UNION ALL + SELECT t.x + 1 + FROM (VALUES (3)) AS v(p) FULL OUTER JOIN t ON t.x = p + WHERE t.x < 3 +) SELECT * FROM t; +-- +ok +== +WITH RECURSIVE t(x) AS +( + SELECT 1 + UNION ALL + SELECT t.x + 1 + FROM (VALUES (3)) AS v(p) INNER JOIN t ON t.x < p + WHERE t.x < 3 +) SELECT * FROM t ORDER BY x; +-- +ok +== +WITH RECURSIVE t(x) AS +( + SELECT 1 + UNION ALL + SELECT t.x + 1 + FROM (VALUES (NULL::INTEGER)) AS v(p) RIGHT OUTER JOIN t ON t.x <= p + WHERE t.x < 3 +) SELECT * FROM t ORDER BY x; +-- +ok +== diff --git a/parser/testdata/corpus/sql/cte/test_recursive_cte_recurring.test b/parser/testdata/corpus/sql/cte/test_recursive_cte_recurring.test new file mode 100644 index 0000000..5d083b0 --- /dev/null +++ b/parser/testdata/corpus/sql/cte/test_recursive_cte_recurring.test @@ -0,0 +1,94 @@ +# source: test/sql/cte/test_recursive_cte_recurring.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +WITH RECURSIVE deduction AS ( + -- P, (not P or Q), (not Q) + SELECT clause FROM (VALUES ([1]), ([-1, 2]), ([-2])) AS kb(clause) + UNION + SELECT + -- Create new clause by merging and removing resolved literals + list_distinct( + list_concat( + list_filter(p_new.clause, lambda x: x <> lit), + list_filter(p_old.clause, lambda x: x <> -lit) + ) + ) AS new_clause + FROM deduction p_new -- Newly added clauses + CROSS JOIN UNNEST(p_new.clause) AS t_lit(lit) + -- We join with the UNION table to find the negation of that literal + JOIN recurring.deduction p_old ON list_contains(p_old.clause, -lit) + WHERE + -- A resolution step is only useful if it doesn't create a tautology (like [P, not P]). + NOT EXISTS ( + SELECT 1 FROM ( + -- Check all literals in the potential new clause + SELECT UNNEST(list_concat( + list_filter(p_new.clause, lambda x: x <> lit), + list_filter(p_old.clause, lambda x: x <> -lit) + )) AS l + ) + GROUP BY abs(l) + HAVING count(distinct l) > 1 -- Found both X and -X + ) +) +-- If we deduced an empty clause [], it means the input was contradictory. +SELECT CASE WHEN EXISTS (SELECT 1 FROM deduction WHERE len(clause) = 0) + THEN 'CONTRADICTION FOUND' + ELSE 'LOGICALLY CONSISTENT' + END AS result, + (SELECT list(clause ORDER BY clause) FROM deduction) AS all_deduced_clauses; +-- +ok +== +WITH RECURSIVE +"primary"(c,p) AS ( + VALUES ('c1', 'c2'), + ('c3', 'c4'), + ('c4', 'c6') +), +secondary(c,s) AS ( + VALUES ('c1', 'c3'), + ('c3', 'c5'), + ('c4', 'c7') +), +broken(c) AS ( + VALUES ('c2'), + ('c4'), + ('c5') +), +fail(c) AS ( + SELECT b.c + FROM broken AS b + UNION + SELECT p.c + FROM "primary" AS p, secondary AS s, recurring.fail AS f1, recurring.fail AS f2 + WHERE f1.c = p.p + AND f2.c = s.s + AND p.c = s.c +) +TABLE fail +ORDER BY c; +-- +ok +== +WITH RECURSIVE +parent(p,c) AS ( + VALUES ('c1','c2'), + ('c1','c3'), + ('c3','c4'), + ('c3','c5'), + ('c4','c6'), + ('c4','c7') +), +ancestor(a,c) AS ( + FROM parent + UNION + SELECT a1.x, a2.y + FROM recurring.ancestor AS a1(x,z) NATURAL JOIN recurring.ancestor AS a2(z,y) +) +FROM ancestor ORDER BY ALL; +-- +ok +== diff --git a/parser/testdata/corpus/sql/cte/test_recursive_cte_tutorial.test b/parser/testdata/corpus/sql/cte/test_recursive_cte_tutorial.test new file mode 100644 index 0000000..aac04f4 --- /dev/null +++ b/parser/testdata/corpus/sql/cte/test_recursive_cte_tutorial.test @@ -0,0 +1,80 @@ +# source: test/sql/cte/test_recursive_cte_tutorial.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +WITH RECURSIVE ctename AS ( + SELECT empno, ename + FROM emp + WHERE empno = 7566 + UNION ALL + SELECT emp.empno, emp.ename + FROM emp + JOIN ctename ON emp.mgr = ctename.empno +) +SELECT * FROM ctename; +-- +ok +== +WITH RECURSIVE ctename AS ( + SELECT empno, ename, + 0 AS level + FROM emp + WHERE empno = 7566 + UNION ALL + SELECT emp.empno, emp.ename, + ctename.level + 1 + FROM emp + JOIN ctename ON emp.mgr = ctename.empno +) +SELECT * FROM ctename; +-- +ok +== +WITH RECURSIVE ctename AS ( + SELECT empno, ename, + ename AS path + FROM emp + WHERE empno = 7566 + UNION ALL + SELECT emp.empno, emp.ename, + ctename.path || ' -> ' || emp.ename + FROM emp + JOIN ctename ON emp.mgr = ctename.empno +) +SELECT * FROM ctename; +-- +ok +== +CREATE VIEW ctenames AS ( + WITH RECURSIVE ctename AS ( + SELECT empno, ename, + ename AS path + FROM emp + WHERE empno = 7566 + UNION ALL + SELECT emp.empno, emp.ename, + ctename.path || ' -> ' || emp.ename + FROM emp + JOIN ctename ON emp.mgr = ctename.empno + ) + SELECT * FROM ctename +); +-- +ok +== +WITH RECURSIVE fib AS ( + SELECT 1 AS n, + 1::bigint AS "fibₙ", + 1::bigint AS "fibₙ₊₁" + UNION ALL + SELECT n+1, + "fibₙ₊₁", + "fibₙ" + "fibₙ₊₁" + FROM fib +) +SELECT n, "fibₙ" FROM fib +LIMIT 20; +-- +ok +== diff --git a/parser/testdata/corpus/sql/cte/test_recursive_cte_union.test b/parser/testdata/corpus/sql/cte/test_recursive_cte_union.test new file mode 100644 index 0000000..8e506a7 --- /dev/null +++ b/parser/testdata/corpus/sql/cte/test_recursive_cte_union.test @@ -0,0 +1,97 @@ +# source: test/sql/cte/test_recursive_cte_union.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +with recursive t as (select 1 as x union select x+1 from t where x < 3) select * from t order by x +-- +ok +== +with recursive t(x) as (select 1 union select x+1 from t where x < 3) select * from t order by x +-- +ok +== +with recursive t(x) as (select 1 union select x+1 from t where x < 3) select zz from t t1(zz) order by zz +-- +ok +== +with recursive t(x) as (select 1 union select zzz+1 from t t1(zzz) where zzz < 3) select zz from t t1(zz) order by zz +-- +ok +== +with recursive t as (select 1 as x union select x from t) select * from t +-- +ok +== +with recursive t as (select 1 as x union select x+1 from t as m where m.x < 3) select * from t order by x +-- +ok +== +with recursive t as (select 1 as x union select m.x+f.x from t as m, t as f where m.x < 3) select * from t order by x +-- +ok +== +with recursive t as (select 1 as x, 'hello' as y union select x+1, y || '-' || 'hello' from t where x < 3) select * from t order by x; +-- +ok +== +with recursive t as (select 1 as x union select x+1 from t where x < 3) select min(a1.x) from t a1, t a2; +-- +ok +== +with recursive t as (select 1 as x union select x+(SELECT 1) from t where x < 3) select * from t order by x; +-- +ok +== +with recursive t as (select 1 as x union all select * from (select x from t where x < 5) tbl(i) join (select 1) tbl2(i) using (i)) select * from t limit 3; +-- +ok +== +with recursive t as (select 1 as x union all select * from (select 1) tbl2(i) join (select x from t where x < 5) tbl(i) using (i)) select * from t limit 3; +-- +ok +== +with recursive t as (select 1 as x union all select * from (select x from t where x < 5) tbl(i) join (select first(i) from (values (1)) tbl3(i) limit 1) tbl2(i) using (i)) select * from t limit 3; +-- +ok +== +with recursive t as (select 1 as x union all select * from (select first(i) from (values (1)) tbl3(i) limit 1) tbl2(i) join (select x from t where x < 5) tbl(i) using (i)) select * from t limit 3; +-- +ok +== +with recursive t as (select 1 as x union select x+(SELECT 1+t.x) from t where x < 5) select * from t order by x; +-- +ok +== +create table integers as with recursive t as (select 1 as x union select x+1 from t where x < 3) select * from t; +-- +ok +== +with recursive t as (select (select min(x) from integers) as x union select x+1 from t where x < 3) select * from t order by x; +-- +ok +== +with recursive t as (select 1 as x union select sum(x+1) from t where x < 3) select * from t order by 1 nulls last +-- +ok +== +with recursive t as (select 1 as x union select sum(x+1) from t where x < 3 order by x) select * from t +-- +error: Parser Error: ORDER BY in a recursive query is not allowed +== +with recursive t as (select 1 as x union select sum(x+1) from t where x < 3 LIMIT 1) select * from t +-- +error: Parser Error: LIMIT or OFFSET in a recursive query is not allowed +== +with recursive t as (select 1 as x union select sum(x+1) from t where x < 3 OFFSET 1) select * from t +-- +error: Parser Error: LIMIT or OFFSET in a recursive query is not allowed +== +with recursive t as (select 1 as x union select sum(x+1) from t where x < 3 LIMIT 1 OFFSET 1) select * from t +-- +error: Parser Error: LIMIT or OFFSET in a recursive query is not allowed +== +create view vr as (with recursive t(x) as (select 1 union select x+1 from t where x < 3) select * from t order by x) +-- +ok +== diff --git a/parser/testdata/corpus/sql/cte/test_recursive_cte_union.test.metadata.json b/parser/testdata/corpus/sql/cte/test_recursive_cte_union.test.metadata.json new file mode 100644 index 0000000..3817b94 --- /dev/null +++ b/parser/testdata/corpus/sql/cte/test_recursive_cte_union.test.metadata.json @@ -0,0 +1,8 @@ +{ + "todo": { + "58ed9aa2c0f4d4eb": "transformer-raised parser error: upstream rejects in the transformer, not the grammar; expected to clear as transformers land (milestones 3-5)", + "65625a060134bdc4": "transformer-raised parser error: upstream rejects in the transformer, not the grammar; expected to clear as transformers land (milestones 3-5)", + "87bd2077e6146fce": "transformer-raised parser error: upstream rejects in the transformer, not the grammar; expected to clear as transformers land (milestones 3-5)", + "c9d8ae7b511982b7": "transformer-raised parser error: upstream rejects in the transformer, not the grammar; expected to clear as transformers land (milestones 3-5)" + } +} diff --git a/parser/testdata/corpus/sql/cte/test_recursive_cte_union_all.test b/parser/testdata/corpus/sql/cte/test_recursive_cte_union_all.test new file mode 100644 index 0000000..3d439ae --- /dev/null +++ b/parser/testdata/corpus/sql/cte/test_recursive_cte_union_all.test @@ -0,0 +1,73 @@ +# source: test/sql/cte/test_recursive_cte_union_all.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +with recursive t as (select 1 as x union all select x+1 from t where x < 3) select * from t +-- +ok +== +with recursive t as (select 1 as x union all select x+1 from t as m where m.x < 3) select * from t +-- +ok +== +with recursive t as (select 1 as x union all select m.x+f.x from t as m, t as f where m.x < 3) select * from t +-- +ok +== +with recursive t as (select 1 as x, 'hello' as y union all select x+1, y || '-' || 'hello' from t where x < 3) select * from t; +-- +ok +== +with recursive t as (select 1 as x union all select x+1 from t where x < 3) select min(a1.x) from t a1, t a2; +-- +ok +== +with recursive t as (select 1 as x union all select x+(SELECT 1) from t where x < 3) select * from t; +-- +ok +== +create table integers as with recursive t as (select 1 as x union all select x+1 from t where x < 3) select * from t; +-- +ok +== +with recursive t as (select (select min(x) from integers) as x union all select x+1 from t where x < 3) select * from t; +-- +ok +== +with recursive t as (select 1 as x union all select sum(x+1) AS x from t where x < 3 group by x) select * from t +-- +ok +== +with recursive t as (select 1 as x union all select sum(x+1) AS x from t where x < 3) +select * from (select * from t limit 10) t1(x) order by x nulls last +-- +ok +== +WITH RECURSIVE t AS ( + SELECT 1 AS i + UNION ALL + SELECT j + FROM t, generate_series(0, 10, 1) series(j) + WHERE j=i+1 +) +SELECT * FROM t; +-- +ok +== +with recursive t as (select 1 as x union all select x+1 from t where x < 3 order by x) select * from t +-- +error: Parser Error: ORDER BY in a recursive query is not allowed +== +with recursive t as (select 1 as x union all select x+1 from t where x < 3 LIMIT 1) select * from t +-- +error: Parser Error: LIMIT or OFFSET in a recursive query is not allowed +== +with recursive t as (select 1 as x union all select x+1 from t where x < 3 OFFSET 1) select * from t +-- +error: Parser Error: LIMIT or OFFSET in a recursive query is not allowed +== +with recursive t as (select 1 as x union all select x+1 from t where x < 3 LIMIT 1 OFFSET 1) select * from t +-- +error: Parser Error: LIMIT or OFFSET in a recursive query is not allowed +== diff --git a/parser/testdata/corpus/sql/cte/test_recursive_cte_union_all.test.metadata.json b/parser/testdata/corpus/sql/cte/test_recursive_cte_union_all.test.metadata.json new file mode 100644 index 0000000..296d847 --- /dev/null +++ b/parser/testdata/corpus/sql/cte/test_recursive_cte_union_all.test.metadata.json @@ -0,0 +1,8 @@ +{ + "todo": { + "1f6365b8300078fe": "transformer-raised parser error: upstream rejects in the transformer, not the grammar; expected to clear as transformers land (milestones 3-5)", + "2921959446915b6e": "transformer-raised parser error: upstream rejects in the transformer, not the grammar; expected to clear as transformers land (milestones 3-5)", + "2d17eaa5e84d5941": "transformer-raised parser error: upstream rejects in the transformer, not the grammar; expected to clear as transformers land (milestones 3-5)", + "a9c8ac4a5bcf2b6c": "transformer-raised parser error: upstream rejects in the transformer, not the grammar; expected to clear as transformers land (milestones 3-5)" + } +} diff --git a/parser/testdata/corpus/sql/cte/warn_deprecated_union_in_using_key.test b/parser/testdata/corpus/sql/cte/warn_deprecated_union_in_using_key.test new file mode 100644 index 0000000..ead4018 --- /dev/null +++ b/parser/testdata/corpus/sql/cte/warn_deprecated_union_in_using_key.test @@ -0,0 +1,31 @@ +# source: test/sql/cte/warn_deprecated_union_in_using_key.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +CALL enable_logging(level='error'); +-- +ok +== +WITH RECURSIVE cte(x,y) USING KEY (x) AS ( + SELECT 1, 0 + UNION + SELECT x, y+1 + FROM cte + WHERE y < 10 +) TABLE cte; +-- +ok +== +SELECT log_level, message[0:42] FROM duckdb_logs +-- +ok +== +CALL enable_logging(level='warning'); +-- +ok +== +SET deprecated_using_key_syntax='UNION_AS_UNION_ALL'; +-- +ok +== diff --git a/parser/testdata/corpus/sql/delete/bulk_delete_version_info_memory.test b/parser/testdata/corpus/sql/delete/bulk_delete_version_info_memory.test new file mode 100644 index 0000000..0d946a2 --- /dev/null +++ b/parser/testdata/corpus/sql/delete/bulk_delete_version_info_memory.test @@ -0,0 +1,17 @@ +# source: test/sql/delete/bulk_delete_version_info_memory.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +CREATE TABLE a AS SELECT i FROM range(1228800) t(i) +-- +ok +== +SELECT memory_usage_bytes < 1000000 FROM duckdb_memory() WHERE tag='BASE_TABLE' +-- +ok +== +SELECT COUNT(*) FROM a +-- +ok +== diff --git a/parser/testdata/corpus/sql/delete/cleanup_delete_on_conflict.test b/parser/testdata/corpus/sql/delete/cleanup_delete_on_conflict.test new file mode 100644 index 0000000..36af479 --- /dev/null +++ b/parser/testdata/corpus/sql/delete/cleanup_delete_on_conflict.test @@ -0,0 +1,17 @@ +# source: test/sql/delete/cleanup_delete_on_conflict.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +INSERT INTO tbl FROM range(1000) t(i); +-- +ok +== +DELETE FROM tbl WHERE i BETWEEN 200 AND 300 +-- +ok +== +DELETE FROM tbl WHERE i <= 500 +-- +ok +== diff --git a/parser/testdata/corpus/sql/delete/delete_compression_after_restart.test b/parser/testdata/corpus/sql/delete/delete_compression_after_restart.test new file mode 100644 index 0000000..f8076bf --- /dev/null +++ b/parser/testdata/corpus/sql/delete/delete_compression_after_restart.test @@ -0,0 +1,29 @@ +# source: test/sql/delete/delete_compression_after_restart.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +CREATE TABLE tbl AS SELECT i FROM range(122880) t(i); +-- +ok +== +DELETE FROM tbl WHERE i % 2048 <> 0 AND i % 2 = 0 +-- +ok +== +DELETE FROM tbl WHERE i % 2 = 1 +-- +ok +== +SELECT COUNT(*), MIN(i), MAX(i) FROM tbl +-- +ok +== +DELETE FROM tbl WHERE i % 2048 = 0 +-- +ok +== +SELECT COUNT(*) FROM tbl +-- +ok +== diff --git a/parser/testdata/corpus/sql/delete/delete_compression_blocked_by_old_snapshot.test b/parser/testdata/corpus/sql/delete/delete_compression_blocked_by_old_snapshot.test new file mode 100644 index 0000000..19d76f3 --- /dev/null +++ b/parser/testdata/corpus/sql/delete/delete_compression_blocked_by_old_snapshot.test @@ -0,0 +1,37 @@ +# source: test/sql/delete/delete_compression_blocked_by_old_snapshot.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +SET debug_skip_checkpoint_on_commit=true +-- +ok +== +SET VARIABLE base_mem = (SELECT memory_usage_bytes FROM duckdb_memory() WHERE tag='BASE_TABLE') +-- +ok +== +DELETE FROM tbl WHERE i >= 2048 AND i % 2 = 0 +-- +ok +== +DELETE FROM tbl WHERE i >= 2048 AND i % 2 = 1 +-- +ok +== +SELECT memory_usage_bytes > getvariable('base_mem') + 900000 FROM duckdb_memory() WHERE tag='BASE_TABLE' +-- +ok +== +CREATE TABLE other AS SELECT 1 AS i +-- +ok +== +SELECT memory_usage_bytes < getvariable('base_mem') + 300000 FROM duckdb_memory() WHERE tag='BASE_TABLE' +-- +ok +== +SELECT COUNT(*), MAX(i) FROM tbl +-- +ok +== diff --git a/parser/testdata/corpus/sql/delete/delete_query_node.test b/parser/testdata/corpus/sql/delete/delete_query_node.test new file mode 100644 index 0000000..224462a --- /dev/null +++ b/parser/testdata/corpus/sql/delete/delete_query_node.test @@ -0,0 +1,78 @@ +# source: test/sql/delete/delete_query_node.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +CREATE TABLE t(a INT, b TEXT, c DOUBLE); +-- +ok +== +INSERT INTO t VALUES (1, 'hello', 1.5), (2, 'world', 2.5), (3, 'foo', 3.5); +-- +ok +== +DELETE FROM t WHERE a = 1; +-- +ok +== +SELECT * FROM t ORDER BY a; +-- +ok +== +DELETE FROM t WHERE a = 2 RETURNING a, b, c; +-- +ok +== +INSERT INTO t VALUES (1, 'hello', 1.5), (2, 'world', 2.5); +-- +ok +== +CREATE TABLE to_delete(id INT); +-- +ok +== +INSERT INTO to_delete VALUES (1); +-- +ok +== +DELETE FROM t USING to_delete WHERE t.a = to_delete.id; +-- +ok +== +INSERT INTO t VALUES (10, 'ten', 10.5); +-- +ok +== +WITH targets AS (SELECT 10 AS target_a) +DELETE FROM t WHERE a IN (SELECT target_a FROM targets) RETURNING a; +-- +ok +== +DELETE FROM t; +-- +ok +== +SELECT count(*) FROM t; +-- +ok +== +CREATE SCHEMA myschema; +-- +ok +== +CREATE TABLE myschema.t2(x INT); +-- +ok +== +INSERT INTO myschema.t2 VALUES (1), (2), (3); +-- +ok +== +DELETE FROM myschema.t2 WHERE x > 1; +-- +ok +== +SELECT * FROM myschema.t2; +-- +ok +== diff --git a/parser/testdata/corpus/sql/delete/full_vector_delete_conflict.test b/parser/testdata/corpus/sql/delete/full_vector_delete_conflict.test new file mode 100644 index 0000000..aee6adc --- /dev/null +++ b/parser/testdata/corpus/sql/delete/full_vector_delete_conflict.test @@ -0,0 +1,29 @@ +# source: test/sql/delete/full_vector_delete_conflict.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +CREATE TABLE tbl AS SELECT i FROM range(4096) t(i); +-- +ok +== +DELETE FROM tbl +-- +ok +== +CREATE TABLE tbl2 AS SELECT i FROM range(4096) t(i); +-- +ok +== +DELETE FROM tbl2 WHERE i < 100 +-- +ok +== +DELETE FROM tbl2 +-- +ok +== +SELECT COUNT(*) FROM tbl2 +-- +ok +== diff --git a/parser/testdata/corpus/sql/delete/full_vector_delete_rollback.test b/parser/testdata/corpus/sql/delete/full_vector_delete_rollback.test new file mode 100644 index 0000000..227242e --- /dev/null +++ b/parser/testdata/corpus/sql/delete/full_vector_delete_rollback.test @@ -0,0 +1,13 @@ +# source: test/sql/delete/full_vector_delete_rollback.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +DELETE FROM tbl WHERE i < 100 +-- +ok +== +DELETE FROM tbl WHERE i < 2048 +-- +ok +== diff --git a/parser/testdata/corpus/sql/delete/large_deletes_transactions.test b/parser/testdata/corpus/sql/delete/large_deletes_transactions.test new file mode 100644 index 0000000..7dad7f1 --- /dev/null +++ b/parser/testdata/corpus/sql/delete/large_deletes_transactions.test @@ -0,0 +1,13 @@ +# source: test/sql/delete/large_deletes_transactions.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +CREATE TABLE a AS SELECT * FROM range(1000000) t1(i); +-- +ok +== +DELETE FROM a WHERE i%2=0 +-- +ok +== diff --git a/parser/testdata/corpus/sql/delete/list_delete.test b/parser/testdata/corpus/sql/delete/list_delete.test new file mode 100644 index 0000000..7f4caf9 --- /dev/null +++ b/parser/testdata/corpus/sql/delete/list_delete.test @@ -0,0 +1,25 @@ +# source: test/sql/delete/list_delete.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +CREATE TABLE aggr (k int[]); +-- +ok +== +INSERT INTO aggr VALUES ([0, 1, 1, 1, 4, 0, 3, 3, 2, 2, 4, 4, 2, 4, 0, 0, 0, 1, 2, 3, 4, 2, 3, 3, 1]); +-- +ok +== +INSERT INTO aggr VALUES ([]), ([NULL]), (NULL), ([0, 1, 1, 1, 4, NULL, 0, 3, 3, 2, NULL, 2, 4, 4, 2, 4, 0, 0, 0, 1, NULL, 2, 3, 4, 2, 3, 3, 1]); +-- +ok +== +SELECT COUNT(k) FROM aggr +-- +ok +== +DELETE FROM aggr; +-- +ok +== diff --git a/parser/testdata/corpus/sql/delete/masked_vector_further_delete.test b/parser/testdata/corpus/sql/delete/masked_vector_further_delete.test new file mode 100644 index 0000000..882172f --- /dev/null +++ b/parser/testdata/corpus/sql/delete/masked_vector_further_delete.test @@ -0,0 +1,25 @@ +# source: test/sql/delete/masked_vector_further_delete.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +CREATE TABLE t AS SELECT i FROM range(4096) t(i) +-- +ok +== +DELETE FROM t WHERE i % 2 = 0 +-- +ok +== +SELECT COUNT(*) FROM t +-- +ok +== +DELETE FROM t WHERE i % 4 = 1 +-- +ok +== +SELECT COUNT(*), MIN(i) FROM t +-- +ok +== diff --git a/parser/testdata/corpus/sql/delete/masked_vector_rollback.test b/parser/testdata/corpus/sql/delete/masked_vector_rollback.test new file mode 100644 index 0000000..8376840 --- /dev/null +++ b/parser/testdata/corpus/sql/delete/masked_vector_rollback.test @@ -0,0 +1,25 @@ +# source: test/sql/delete/masked_vector_rollback.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +CREATE TABLE r AS SELECT i FROM range(4096) t(i) +-- +ok +== +DELETE FROM r WHERE i % 2 = 0 +-- +ok +== +SELECT COUNT(*) FROM r +-- +ok +== +DELETE FROM r WHERE i % 4 = 1 +-- +ok +== +SELECT COUNT(*) FILTER (WHERE i % 2 = 0) FROM r +-- +ok +== diff --git a/parser/testdata/corpus/sql/delete/partial_delete_version_info_memory.test b/parser/testdata/corpus/sql/delete/partial_delete_version_info_memory.test new file mode 100644 index 0000000..30f8091 --- /dev/null +++ b/parser/testdata/corpus/sql/delete/partial_delete_version_info_memory.test @@ -0,0 +1,21 @@ +# source: test/sql/delete/partial_delete_version_info_memory.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +DELETE FROM a WHERE i % 2 = 0 +-- +ok +== +SELECT COUNT(*), MIN(i), MAX(i) FROM a +-- +ok +== +SELECT COUNT(*) FILTER (WHERE i % 2 = 0) FROM a +-- +ok +== +SELECT COALESCE(SUM(memory_usage_bytes), 0) < 2000000 FROM duckdb_memory() WHERE tag='BASE_TABLE' +-- +ok +== diff --git a/parser/testdata/corpus/sql/delete/test_delete.test b/parser/testdata/corpus/sql/delete/test_delete.test new file mode 100644 index 0000000..5dcbb0e --- /dev/null +++ b/parser/testdata/corpus/sql/delete/test_delete.test @@ -0,0 +1,21 @@ +# source: test/sql/delete/test_delete.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +CREATE TABLE a(i INTEGER); +-- +ok +== +INSERT INTO a VALUES (42); +-- +ok +== +SELECT COUNT(*) FROM a; +-- +ok +== +DELETE FROM a; +-- +ok +== diff --git a/parser/testdata/corpus/sql/delete/test_delete_indexed.test b/parser/testdata/corpus/sql/delete/test_delete_indexed.test new file mode 100644 index 0000000..76baded --- /dev/null +++ b/parser/testdata/corpus/sql/delete/test_delete_indexed.test @@ -0,0 +1,118 @@ +# source: test/sql/delete/test_delete_indexed.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +CREATE TABLE t (id INT PRIMARY KEY, s TEXT, j BIGINT); +-- +ok +== +CREATE INDEX idx ON t(j); +-- +ok +== +INSERT INTO t VALUES (1, 'a', 10), (2, 'b', 20), (3, 'c', 30); +-- +ok +== +SELECT * FROM t ORDER BY id; +-- +ok +== +DELETE FROM t WHERE id = 2; +-- +ok +== +DELETE FROM t WHERE j = 30; +-- +ok +== +INSERT INTO t VALUES (4, 'd', 40), (5, 'e', 50); +-- +ok +== +DELETE FROM t WHERE j > 10; +-- +ok +== +SELECT COUNT(*) FROM t; +-- +ok +== +DELETE FROM t WHERE j >= 20; +-- +ok +== +INSERT INTO t VALUES (2, 'new_20', 20), (3, 'new_30', 30); +-- +ok +== +SELECT * FROM t WHERE j = 20; +-- +ok +== +SELECT * FROM t WHERE j = 30; +-- +ok +== +INSERT INTO t VALUES (2, 'tmp_20', 20), (3, 'tmp_30', 30); +-- +ok +== +SELECT * FROM t WHERE j >= 20 ORDER BY j; +-- +ok +== +CREATE TABLE source (id INT, s TEXT, j BIGINT); +-- +ok +== +INSERT INTO source VALUES (2, 'x', 200), (3, 'y', 300); +-- +ok +== +MERGE INTO t USING source ON t.id = source.id +WHEN MATCHED THEN DELETE; +-- +ok +== +INSERT INTO t VALUES (2, 'new_b', 25), (3, 'new_c', 35); +-- +ok +== +SELECT * FROM t WHERE j = 25; +-- +ok +== +DELETE FROM source; +-- +ok +== +INSERT INTO t VALUES (2, 'merge_20', 20), (3, 'merge_30', 30); +-- +ok +== +DROP TABLE source; +-- +ok +== +CREATE TABLE delete_using_indexed(id INTEGER PRIMARY KEY, payload VARCHAR); +-- +ok +== +INSERT INTO delete_using_indexed SELECT range, range::VARCHAR FROM range(10); +-- +ok +== +DELETE FROM delete_using_indexed USING range(100) source(i) WHERE source.i = 0; +-- +ok +== +SELECT count(*) FROM delete_using_indexed; +-- +ok +== +DELETE FROM delete_using_indexed USING range(100) source(i) WHERE source.i = 0 RETURNING id; +-- +ok +== diff --git a/parser/testdata/corpus/sql/delete/test_large_delete.test b/parser/testdata/corpus/sql/delete/test_large_delete.test new file mode 100644 index 0000000..f3e97cc --- /dev/null +++ b/parser/testdata/corpus/sql/delete/test_large_delete.test @@ -0,0 +1,17 @@ +# source: test/sql/delete/test_large_delete.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +CREATE TABLE a AS SELECT * FROM range(0, 10000, 1) t1(i); +-- +ok +== +SELECT COUNT(*) FROM a WHERE i >= 2000 AND i < 5000; +-- +ok +== +DELETE FROM a WHERE i >= 2000 AND i < 5000; +-- +ok +== diff --git a/parser/testdata/corpus/sql/delete/test_segment_deletes.test b/parser/testdata/corpus/sql/delete/test_segment_deletes.test new file mode 100644 index 0000000..5ec16ad --- /dev/null +++ b/parser/testdata/corpus/sql/delete/test_segment_deletes.test @@ -0,0 +1,45 @@ +# source: test/sql/delete/test_segment_deletes.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +INSERT INTO a SELECT * FROM range(0, 1024, 1); +-- +ok +== +BEGIN TRANSACTION; +DELETE FROM a WHERE i=0; +-- +ok +== +BEGIN TRANSACTION; +DELETE FROM a WHERE i=1; +-- +ok +== +BEGIN TRANSACTION; +DELETE FROM a WHERE i=1022; +-- +ok +== +BEGIN TRANSACTION; +DELETE FROM a WHERE i=1023; +-- +ok +== +DELETE FROM a WHERE i=0; +-- +ok +== +DELETE FROM a WHERE i=1; +-- +ok +== +DELETE FROM a WHERE i=1022; +-- +ok +== +DELETE FROM a WHERE i=1023; +-- +ok +== diff --git a/parser/testdata/corpus/sql/delete/test_truncate.test b/parser/testdata/corpus/sql/delete/test_truncate.test new file mode 100644 index 0000000..1775dcc --- /dev/null +++ b/parser/testdata/corpus/sql/delete/test_truncate.test @@ -0,0 +1,13 @@ +# source: test/sql/delete/test_truncate.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +TRUNCATE TABLE a +-- +ok +== +TRUNCATE a +-- +ok +== diff --git a/parser/testdata/corpus/sql/delete/test_using_delete.test b/parser/testdata/corpus/sql/delete/test_using_delete.test new file mode 100644 index 0000000..8d35365 --- /dev/null +++ b/parser/testdata/corpus/sql/delete/test_using_delete.test @@ -0,0 +1,41 @@ +# source: test/sql/delete/test_using_delete.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +INSERT INTO a VALUES (1), (2), (3); +-- +ok +== +DELETE FROM a USING (values (1)) tbl(i) WHERE a.i=tbl.i; +-- +ok +== +SELECT * FROM a; +-- +ok +== +DELETE FROM a USING (values (1)) tbl(i); +-- +ok +== +DELETE FROM a USING (values (1)) tbl(i), (values (1), (2)) tbl2(i) WHERE a.i=tbl.i AND a.i=tbl2.i; +-- +ok +== +DELETE FROM a USING (values (4)) tbl(i) WHERE a.i=tbl.i; +-- +ok +== +DELETE FROM a USING a a2(i) WHERE a.i>a2.i; +-- +ok +== +DELETE FROM a USING b WHERE a.i=b.i; +-- +ok +== +DELETE FROM a USING a b WHERE a.i=b.j; +-- +ok +== diff --git a/parser/testdata/corpus/sql/delete/test_using_delete_duplicates.test b/parser/testdata/corpus/sql/delete/test_using_delete_duplicates.test new file mode 100644 index 0000000..7c28970 --- /dev/null +++ b/parser/testdata/corpus/sql/delete/test_using_delete_duplicates.test @@ -0,0 +1,97 @@ +# source: test/sql/delete/test_using_delete_duplicates.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +create table integers as select * from generate_series(0, 9, 1); +-- +ok +== +create table integers2 as select * from generate_series(0, 9, 1); +-- +ok +== +DELETE FROM integers USING integers2; +-- +ok +== +SELECT COUNT(*) FROM integers +-- +ok +== +DROP TABLE integers2 +-- +ok +== +BEGIN transaction +-- +ok +== +CREATE or replace TABLE integers AS FROM range(10); +-- +ok +== +create table integers_copy as select * from integers; +-- +ok +== +DELETE FROM integers USING range(100) RETURNING *; +-- +ok +== +select * from integers_copy; +-- +ok +== +create or replace table t1 as select range%10 a from range(1000); +-- +ok +== +create or replace table t2 as select range b from range(10); +-- +ok +== +create or replace table t2_copy as select * from t2; +-- +ok +== +delete from t2 using t1 where a=b returning *; +-- +ok +== +select * from t2_copy; +-- +ok +== +create or replace table t1 as select range%10 a from range(100); +-- +ok +== +insert into t2 select 12 from range(5); +-- +ok +== +insert into t1 select 12 from range(10); +-- +ok +== +select * from t2_copy +-- +ok +== +create or replace table t1 as select range%1000 a from range(100_000); +-- +ok +== +create or replace table t2 as select range b from range(100); +-- +ok +== +insert into t2 select 100_050 from range(50); +-- +ok +== +insert into t1 select 100_050 from range(50); +-- +ok +== diff --git a/parser/testdata/corpus/sql/detailed_profiler/test_detailed_profiler.test b/parser/testdata/corpus/sql/detailed_profiler/test_detailed_profiler.test new file mode 100644 index 0000000..5a2dd56 --- /dev/null +++ b/parser/testdata/corpus/sql/detailed_profiler/test_detailed_profiler.test @@ -0,0 +1,15 @@ +# source: test/sql/detailed_profiler/test_detailed_profiler.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +PRAGMA enable_profiling='json' +-- +ok +== +SELECT COUNT(*) > 0 +FROM read_csv('{TEST_DIR}/test.txt', columns={'c': 'VARCHAR'}, delim=NULL, header=0, quote=NULL, escape=NULL, auto_detect = false) +WHERE contains(c, 'optimizer'); +-- +ok +== diff --git a/parser/testdata/corpus/sql/error/aggregate_order_by.test b/parser/testdata/corpus/sql/error/aggregate_order_by.test new file mode 100644 index 0000000..bb97d15 --- /dev/null +++ b/parser/testdata/corpus/sql/error/aggregate_order_by.test @@ -0,0 +1,17 @@ +# source: test/sql/error/aggregate_order_by.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +CREATE TABLE lists_tbl AS SELECT i%20 as groups, i AS l FROM range(1000) tmp(i); +-- +ok +== +SELECT COUNT(DISTINCT l) FROM lists_tbl group by groups order by l limit 10; +-- +ok +== +SELECT DISTINCT ON(l) COUNT(DISTINCT l) FROM lists_tbl group by groups; +-- +ok +== diff --git a/parser/testdata/corpus/sql/error/correlated_at_clause.test b/parser/testdata/corpus/sql/error/correlated_at_clause.test new file mode 100644 index 0000000..60bddbf --- /dev/null +++ b/parser/testdata/corpus/sql/error/correlated_at_clause.test @@ -0,0 +1,13 @@ +# source: test/sql/error/correlated_at_clause.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +CREATE TABLE t (i VARCHAR) +-- +ok +== +FROM t, t AT (VERSION => i) +-- +ok +== diff --git a/parser/testdata/corpus/sql/error/error_location_multicaret.test b/parser/testdata/corpus/sql/error/error_location_multicaret.test new file mode 100644 index 0000000..b24a971 --- /dev/null +++ b/parser/testdata/corpus/sql/error/error_location_multicaret.test @@ -0,0 +1,25 @@ +# source: test/sql/error/error_location_multicaret.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +SELECT foo_bar_col FROM (SELECT 1 AS a) +-- +ok +== +SELECT xyz.abc FROM range(3) t(a) +-- +ok +== +SELECT 1 WHERE zzz LAUNCH +-- +error: Parser Error: syntax error at or near "LAUNCH" +== +SELECT 12345::utinyint +-- +ok +== +SELECT q FROM (SELECT 1 AS a) +-- +ok +== diff --git a/parser/testdata/corpus/sql/error/error_location_not_duplicated.test b/parser/testdata/corpus/sql/error/error_location_not_duplicated.test new file mode 100644 index 0000000..115ef85 --- /dev/null +++ b/parser/testdata/corpus/sql/error/error_location_not_duplicated.test @@ -0,0 +1,9 @@ +# source: test/sql/error/error_location_not_duplicated.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +SELECT 1 AS foo frommmm b; +-- +error: Parser Error: syntax error at or near "frommmm" +== diff --git a/parser/testdata/corpus/sql/error/error_position.test b/parser/testdata/corpus/sql/error/error_position.test new file mode 100644 index 0000000..d85ea9d --- /dev/null +++ b/parser/testdata/corpus/sql/error/error_position.test @@ -0,0 +1,13 @@ +# source: test/sql/error/error_position.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +set errors_as_json=true; +-- +ok +== +create macro checksum(x) as table SELECT bit_xor(md5_number(CAST(COLUMNS(*) AS VARCHAR))) FROM query_table(table_name); +-- +ok +== diff --git a/parser/testdata/corpus/sql/error/error_position_json_execute.test b/parser/testdata/corpus/sql/error/error_position_json_execute.test new file mode 100644 index 0000000..cfaefcd --- /dev/null +++ b/parser/testdata/corpus/sql/error/error_position_json_execute.test @@ -0,0 +1,13 @@ +# source: test/sql/error/error_position_json_execute.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +SELECT 1, 2 FROM json_execute_serialized_sql(json_serialize_sql('SELECT * FROM no_such_tbl')); +-- +ok +== +SELECT 1, 2 FROM json_execute_serialized_sql(json_serialize_sql('SELECT 1,2,3,4,5,6,7,8,* FROM no_such_tbl')); +-- +ok +== diff --git a/parser/testdata/corpus/sql/error/escape_percent_sign.test b/parser/testdata/corpus/sql/error/escape_percent_sign.test new file mode 100644 index 0000000..6fbeca7 --- /dev/null +++ b/parser/testdata/corpus/sql/error/escape_percent_sign.test @@ -0,0 +1,14 @@ +# source: test/sql/error/escape_percent_sign.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +CREATE VIEW list_int AS +SELECT case when i%2 <> 0 then [1] else NULL end FROM range(10000) tbl(i); +-- +ok +== +select count(*) from list_int where l is distinct from NULL; +-- +ok +== diff --git a/parser/testdata/corpus/sql/error/extension_function_error.test b/parser/testdata/corpus/sql/error/extension_function_error.test new file mode 100644 index 0000000..c9c4b59 --- /dev/null +++ b/parser/testdata/corpus/sql/error/extension_function_error.test @@ -0,0 +1,41 @@ +# source: test/sql/error/extension_function_error.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +SELECT dbgen(); +-- +ok +== +SELECT DBGEN(); +-- +ok +== +SELECT * FROM dbgen(); +-- +ok +== +CALL dbgen(sf=0.1); +-- +ok +== +SELECT * FROM dbgen +-- +ok +== +SELECT * FROM TimeZone +-- +ok +== +SELECT dbgen() +-- +ok +== +CALL dbge() +-- +ok +== +SET TimeZon='UTC' +-- +ok +== diff --git a/parser/testdata/corpus/sql/error/incorrect_sql.test b/parser/testdata/corpus/sql/error/incorrect_sql.test new file mode 100644 index 0000000..9b2f101 --- /dev/null +++ b/parser/testdata/corpus/sql/error/incorrect_sql.test @@ -0,0 +1,163 @@ +# source: test/sql/error/incorrect_sql.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +SELEC 42; +-- +error: Parser Error: syntax error at or near "42" +== +SELEC 42, 'thisisareallylongstringloremipsumblablathisisareallylongstringloremipsumblablalthisisareallylongstringloremipsumblablalthisisareallylongstringloremipsumblablal'; +-- +error: Parser Error: syntax error at or near "42" +== +SELEC 42, '🦆🦆🦆🦆🦆🦆🦆🦆🦆🦆🦆🦆🦆🦆🦆🦆🦆🦆🦆🦆🦆🦆🦆🦆🦆🦆🦆🦆🦆🦆🦆🦆🦆🦆🦆🦆🦆🦆🦆🦆🦆🦆🦆🦆🦆🦆🦆🦆🦆🦆🦆🦆🦆🦆🦆🦆🦆🦆🦆🦆🦆🦆🦆🦆'; +-- +error: Parser Error: syntax error at or near "42" +== +SELECT '🦆🦆🦆🦆🦆🦆🦆🦆🦆🦆🦆🦆🦆🦆🦆🦆🦆🦆🦆🦆🦆🦆🦆🦆🦆🦆🦆🦆🦆🦆🦆🦆🦆🦆🦆🦆🦆🦆🦆🦆🦆🦆🦆🦆🦆🦆🦆🦆🦆🦆🦆🦆🦆🦆🦆🦆🦆🦆🦆🦆🦆🦆🦆🦆', x, '🦆🦆🦆🦆🦆🦆🦆🦆🦆🦆🦆🦆🦆🦆🦆🦆🦆🦆🦆🦆🦆🦆🦆🦆🦆🦆🦆🦆🦆🦆🦆🦆🦆🦆🦆🦆🦆🦆🦆🦆🦆🦆🦆🦆🦆🦆🦆🦆🦆🦆🦆🦆🦆🦆🦆🦆🦆🦆🦆🦆🦆🦆🦆🦆'; +-- +ok +== +SELECT FUNFUNFUN(); +-- +ok +== +CREATE VIEW v1 +AS SELECT FUNFUNFUN(); +-- +ok +== +SELECT SUM(42, 84, 11, 'hello') +-- +ok +== +SELECT cos(0, 1, 2, 3); +-- +ok +== +SELECT * FROM RANG(); +-- +ok +== +SELECT * FROM RANGE(1, hello=3); +-- +ok +== +SELECT * FROM READ_CSV('x', hello=3); +-- +ok +== +SELECT 42 WHERE 1=1 WHERE 1=0; +-- +error: Parser Error: syntax error at or near "WHERE" +== +SELECT 42 +SELECT 42; +-- +error: Parser Error: syntax error at or near "SELECT" +== +SELECT 42; SELEC 42; +-- +error: Parser Error: syntax error at or near "42" +== +SELECT * FROM integers2; +-- +ok +== +SELECT * FROM bla.integers2; +-- +ok +== +CREATE VIEW v1 AS SELECT * FROM integers2; +-- +ok +== +with cte1 as (select 42 as j), cte2 as (select ref.j as k from cte1 as ref), cte3 as (select ref2.j+1 as i from cte1 as ref2) SELECT * FROM integers9; +-- +ok +== +with cte1 as (select 42 as j), cte2 as (select ref.j as k from cte1 as ref), cte3 as (select ref2.j+1 as i from cte1 as ref2) SELECT * FROM integers9 where x=3 order by x+1+1+1+1+1+1+1+1+1+1+1; +-- +ok +== +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 <= CAST('1998-09-02' AS date) +GROUP BY + l_returnflag, + l_linestatus +ORDER BY + l_returnflag, + l_linestatus; +-- +ok +== +select 🦆🍞 from 🦆🍞; +-- +ok +== +with 🍞🍞 as (select 'bread' as 🍞), 🦆🦆 as (select ref.🍞 as "🍞" from 🍞🍞 as ref) SELECT * FROM integers9 where x LIKE '🦆🦆🦆🦆🦆🦆🦆🦆🦆🦆🦆🦆🦆🦆🦆🦆' order by x+1+1+1+1+1+1+1+1+1+1+1; +-- +ok +== +CREATE TABLE integers(integ INTEGER); +-- +ok +== +CREATE TABLE strings(str VARCHAR); +-- +ok +== +CREATE TABLE chickens(feather INTEGER, beak INTEGER); +-- +ok +== +SELECT * FROM integres; +-- +ok +== +SELECT feathe FROM chickens; +-- +ok +== +SELECT feathe FROM chickens, integers, strings; +-- +ok +== +SELECT st FROM chickens, integers, strings; +-- +ok +== +SELECT chicken.feather FROM chickens +-- +ok +== +SELECT chicken.st FROM chickens, integers, strings; +-- +ok +== +CREATE TABLE 🦆🍞(🦆🦆🦆 INTEGER, 🍞🍞🍞 INTEGER); +-- +ok +== +SELECT 🦆.🦆🦆🦆 FROM 🦆🍞 +-- +ok +== +SELECT 🦆🦆 FROM 🦆🍞, chickens +-- +ok +== diff --git a/parser/testdata/corpus/sql/error/lineitem_errors.test b/parser/testdata/corpus/sql/error/lineitem_errors.test new file mode 100644 index 0000000..94d492a --- /dev/null +++ b/parser/testdata/corpus/sql/error/lineitem_errors.test @@ -0,0 +1,73 @@ +# source: test/sql/error/lineitem_errors.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +CREATE TABLE lineitem(l_orderkey BIGINT NOT NULL, l_partkey BIGINT NOT NULL, l_suppkey BIGINT NOT NULL, l_linenumber BIGINT NOT NULL, l_quantity DECIMAL(15,2) NOT NULL, l_extendedprice DECIMAL(15,2) NOT NULL, l_discount DECIMAL(15,2) NOT NULL, l_tax DECIMAL(15,2) NOT NULL, l_returnflag VARCHAR NOT NULL, l_linestatus VARCHAR NOT NULL, l_shipdate DATE NOT NULL, l_commitdate DATE NOT NULL, l_receiptdate DATE NOT NULL, l_shipinstruct VARCHAR NOT NULL, l_shipmode VARCHAR NOT NULL, l_comment VARCHAR NOT NULL); +-- +ok +== +select * from lineitem where l_extendedpric=5; +-- +ok +== +select * from lineitem, lineitem l2 where l_extendedpric=5; +-- +ok +== +select * from lineitem where lineitem.l_extendedpric=5; +-- +ok +== +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 <= CAST('1998-09-02' AS date) + timestamp '2020-01-01' + GROUP BY + l_returnflag, + l_linestatus + ORDER BY + l_returnflag, + l_linestatus; +-- +ok +== +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 <= CAST('1998-09-02' AS date) + timestamp '2020-01-01' -- this has a really long comment that ends up requiring truncation in the error message + GROUP BY + l_returnflag, + l_linestatus + ORDER BY + l_returnflag, + l_linestatus; +-- +ok +== +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 <= CAST('1998-09-02' AS date) + timestamp '2020-01-01' GROUP BY l_returnflag, l_linestatus ORDER BY l_returnflag, l_linestatus; +-- +ok +== diff --git a/parser/testdata/corpus/sql/error/missing_type.test b/parser/testdata/corpus/sql/error/missing_type.test new file mode 100644 index 0000000..8734a91 --- /dev/null +++ b/parser/testdata/corpus/sql/error/missing_type.test @@ -0,0 +1,9 @@ +# source: test/sql/error/missing_type.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +SELECT ''::blobb +-- +ok +== diff --git a/parser/testdata/corpus/sql/error/mix_aggregate_and_non_aggregate.test b/parser/testdata/corpus/sql/error/mix_aggregate_and_non_aggregate.test new file mode 100644 index 0000000..b34c81e --- /dev/null +++ b/parser/testdata/corpus/sql/error/mix_aggregate_and_non_aggregate.test @@ -0,0 +1,21 @@ +# source: test/sql/error/mix_aggregate_and_non_aggregate.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +CREATE TABLE tbl(name VARCHAR, style VARCHAR, brewery_id INTEGER, abv DOUBLE, ibu INTEGER); +-- +ok +== +SELECT FIRST(name), FIRST(abv) +FROM tbl +GROUP BY style +ORDER BY abv DESC; +-- +ok +== +SELECT FIRST(name)||abv +FROM tbl +-- +ok +== diff --git a/parser/testdata/corpus/sql/error/qualified_column_error.test b/parser/testdata/corpus/sql/error/qualified_column_error.test new file mode 100644 index 0000000..5740c59 --- /dev/null +++ b/parser/testdata/corpus/sql/error/qualified_column_error.test @@ -0,0 +1,49 @@ +# source: test/sql/error/qualified_column_error.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +create schema "dbt_temp" +-- +ok +== +create or replace table "dbt_temp"."foo_2" as (select 42 as num_2); +-- +ok +== +select "dbt_temp"."foo_2".num_3 FROM "dbt_temp"."foo_2" +-- +ok +== +select "dbt_temp"."foo_1".num_2 FROM "dbt_temp"."foo_2" +-- +ok +== +attach ':memory:' as cat +-- +ok +== +create schema cat.schema +-- +ok +== +create table cat.schema.tbl(col struct(v1 int)); +-- +ok +== +select cat.schema.tbl.col.v2 from cat.schema.tbl +-- +ok +== +select cat.schema.tbl.cxl.v1 from cat.schema.tbl +-- +ok +== +select cat.schema.txl.col.v1 from cat.schema.tbl +-- +ok +== +select cat.schxma.tbl.col.v1 from cat.schema.tbl +-- +ok +== diff --git a/parser/testdata/corpus/sql/error/subquery_single_column.test b/parser/testdata/corpus/sql/error/subquery_single_column.test new file mode 100644 index 0000000..827d04f --- /dev/null +++ b/parser/testdata/corpus/sql/error/subquery_single_column.test @@ -0,0 +1,9 @@ +# source: test/sql/error/subquery_single_column.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +SELECT (SELECT 42, 84) +-- +ok +== diff --git a/parser/testdata/corpus/sql/error/table_function_as_scalar_function.test b/parser/testdata/corpus/sql/error/table_function_as_scalar_function.test new file mode 100644 index 0000000..b1dcc72 --- /dev/null +++ b/parser/testdata/corpus/sql/error/table_function_as_scalar_function.test @@ -0,0 +1,9 @@ +# source: test/sql/error/table_function_as_scalar_function.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +SELECT read_csv('test.csv') +-- +ok +== diff --git a/parser/testdata/corpus/sql/error/unknown_window_function.test b/parser/testdata/corpus/sql/error/unknown_window_function.test new file mode 100644 index 0000000..becd1fa --- /dev/null +++ b/parser/testdata/corpus/sql/error/unknown_window_function.test @@ -0,0 +1,9 @@ +# source: test/sql/error/unknown_window_function.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +SELECT substr('hello', 3, 2) OVER (); +-- +ok +== diff --git a/parser/testdata/corpus/sql/explain/explain_all_statements.test b/parser/testdata/corpus/sql/explain/explain_all_statements.test new file mode 100644 index 0000000..23e0c25 --- /dev/null +++ b/parser/testdata/corpus/sql/explain/explain_all_statements.test @@ -0,0 +1,101 @@ +# source: test/sql/explain/explain_all_statements.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +explain PRAGMA enable_checkpoint_on_shutdown +-- +ok +== +explain CREATE TABLE integers(i INTEGER); +-- +ok +== +explain SELECT * FROM integers; +-- +ok +== +explain INSERT INTO integers VALUES (1); +-- +ok +== +explain DELETE FROM integers WHERE i=1 +-- +ok +== +explain UPDATE integers SET i=i+1 +-- +ok +== +explain CREATE INDEX i_index ON integers(i) +-- +ok +== +explain ALTER TABLE integers RENAME TO integers2 +-- +ok +== +explain ALTER TABLE integers ADD COLUMN j INTEGER +-- +ok +== +explain ALTER TABLE integers RENAME i TO k +-- +ok +== +explain PREPARE v1 AS SELECT * FROM integers WHERE i=? +-- +ok +== +PREPARE v1 AS SELECT * FROM integers WHERE i=? +-- +ok +== +explain EXECUTE v1(1); +-- +ok +== +explain DEALLOCATE v1 +-- +ok +== +explain VACUUM +-- +ok +== +explain CREATE SEQUENCE seq +-- +ok +== +explain CREATE VIEW v1 AS SELECT * FROM integers +-- +ok +== +explain DROP TABLE integers +-- +ok +== +explain CHECKPOINT +-- +ok +== +explain BEGIN TRANSACTION +-- +ok +== +explain SET memory_limit='1GB' +-- +ok +== +explain CREATE MACRO f(x) AS x+1 +-- +ok +== +SELECT f(1) +-- +ok +== +CREATE MACRO f(x) AS x+1 +-- +ok +== diff --git a/parser/testdata/corpus/sql/explain/explain_execute.test b/parser/testdata/corpus/sql/explain/explain_execute.test new file mode 100644 index 0000000..ef18213 --- /dev/null +++ b/parser/testdata/corpus/sql/explain/explain_execute.test @@ -0,0 +1,21 @@ +# source: test/sql/explain/explain_execute.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +CREATE TABLE integers(i INTEGER, j INTEGER) +-- +ok +== +INSERT INTO integers VALUES (1, 1), (2, 2), (3, 3), (NULL, NULL) +-- +ok +== +PREPARE query AS SELECT * FROM integers +-- +ok +== +EXPLAIN EXECUTE query +-- +ok +== diff --git a/parser/testdata/corpus/sql/explain/explain_formats.test b/parser/testdata/corpus/sql/explain/explain_formats.test new file mode 100644 index 0000000..0e20762 --- /dev/null +++ b/parser/testdata/corpus/sql/explain/explain_formats.test @@ -0,0 +1,131 @@ +# source: test/sql/explain/explain_formats.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +CREATE TABLE renderer_t AS SELECT i AS i, i % 7 AS g, 'v' || (i % 3)::VARCHAR AS s FROM range(200) t(i) +-- +ok +== +CREATE VIEW renderer_plan AS +SELECT a.g, count(*) AS c, sum(sum(a.i)) OVER () AS w +FROM renderer_t a JOIN renderer_t b ON a.i = b.i +WHERE a.i > 2 AND b.s <> 'v9' +GROUP BY a.g +ORDER BY a.g +LIMIT 3 +-- +ok +== +EXPLAIN (FORMAT text) SELECT * FROM renderer_plan +-- +ok +== +EXPLAIN (FORMAT json) SELECT * FROM renderer_plan +-- +ok +== +EXPLAIN (FORMAT yaml) SELECT * FROM renderer_plan +-- +ok +== +EXPLAIN (FORMAT html) SELECT * FROM renderer_plan +-- +ok +== +EXPLAIN (FORMAT graphviz) SELECT * FROM renderer_plan +-- +ok +== +EXPLAIN (FORMAT mermaid) SELECT * FROM renderer_plan +-- +ok +== +EXPLAIN (FORMAT default) SELECT * FROM renderer_plan +-- +ok +== +EXPLAIN (FORMAT query_tree) SELECT * FROM renderer_plan +-- +ok +== +EXPLAIN (FORMAT query_tree_optimizer) SELECT * FROM renderer_plan +-- +ok +== +EXPLAIN (FORMAT no_output) SELECT * FROM renderer_plan +-- +ok +== +EXPLAIN (FORMAT JSON) SELECT 42 +-- +ok +== +EXPLAIN (FORMAT 'graphviz') SELECT 42 +-- +ok +== +EXPLAIN ANALYZE (FORMAT json) SELECT * FROM renderer_plan +-- +ok +== +EXPLAIN ANALYZE (FORMAT graphviz) SELECT * FROM renderer_plan +-- +ok +== +EXPLAIN ANALYZE (FORMAT yaml) SELECT * FROM renderer_plan +-- +ok +== +EXPLAIN ANALYZE (FORMAT mermaid) SELECT * FROM renderer_plan +-- +ok +== +EXPLAIN ANALYZE (FORMAT html) SELECT * FROM renderer_plan +-- +ok +== +EXPLAIN (FORMAT graphviz) SELECT 1 +-- +ok +== +EXPLAIN (FORMAT mermaid) SELECT 1 +-- +ok +== +CREATE TABLE renderer_escapes("werd ""col""" VARCHAR) +-- +ok +== +EXPLAIN (FORMAT html) SELECT "werd ""col""" FROM renderer_escapes +-- +ok +== +EXPLAIN (FORMAT json) SELECT "werd ""col""" FROM renderer_escapes +-- +ok +== +EXPLAIN (FORMAT bogus) SELECT 42 +-- +ok +== +EXPLAIN (FORMAT json, FORMAT yaml) SELECT 42 +-- +ok +== +EXPLAIN (WHATEVER) SELECT 42 +-- +ok +== +EXPLAIN (FORMAT) SELECT 42 +-- +ok +== +EXPLAIN (FORMAT 1 + 1) SELECT 42 +-- +ok +== +EXPLAIN (ANALYZE, FORMAT x^x) SELECT 42 +-- +ok +== diff --git a/parser/testdata/corpus/sql/explain/order_by_topn_explain_fqn.test b/parser/testdata/corpus/sql/explain/order_by_topn_explain_fqn.test new file mode 100644 index 0000000..732be36 --- /dev/null +++ b/parser/testdata/corpus/sql/explain/order_by_topn_explain_fqn.test @@ -0,0 +1,48 @@ +# source: test/sql/explain/order_by_topn_explain_fqn.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +CREATE TABLE date_table (d DATE); +-- +ok +== +INSERT INTO date_table (d) +SELECT + DATE '2025-01-01' + CAST(RANDOM() * 364 AS INT) +FROM generate_series(1, 2500); +-- +ok +== +EXPLAIN SELECT * from date_table ORDER BY d; +-- +ok +== +EXPLAIN SELECT * from date_table ORDER BY d LIMIT 10; +-- +ok +== +EXPLAIN SELECT * from date_table dt ORDER BY d; +-- +ok +== +EXPLAIN SELECT * from date_table dt ORDER BY d LIMIT 10; +-- +ok +== +EXPLAIN SELECT * from date_table dt ORDER BY dt.d; +-- +ok +== +EXPLAIN SELECT * from date_table ORDER BY date_table.d; +-- +ok +== +EXPLAIN SELECT d dc from date_table dt ORDER BY dc; +-- +ok +== +EXPLAIN SELECT dayofweek(d) dw from date_table ORDER BY dw; +-- +ok +== diff --git a/parser/testdata/corpus/sql/explain/test_explain.test b/parser/testdata/corpus/sql/explain/test_explain.test new file mode 100644 index 0000000..0c78ef3 --- /dev/null +++ b/parser/testdata/corpus/sql/explain/test_explain.test @@ -0,0 +1,49 @@ +# source: test/sql/explain/test_explain.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +EXPLAIN SELECT * FROM integers +-- +ok +== +EXPLAIN select sum(i), j, sum(i), j from integers group by j having j < 10; +-- +ok +== +EXPLAIN update integers set i=i+1; +-- +ok +== +EXPLAIN delete from integers where i=1; +-- +ok +== +pragma explain_output='optimized_only' +-- +ok +== +EXPLAIN (FORMAT JSON) SELECT SUM(i) FROM (SELECT * FROM integers i1, integers i2 UNION ALL SELECT * FROM integers i1, integers i2); +-- +ok +== +EXPLAIN (FORMAT HTML) SELECT SUM(i) FROM (SELECT * FROM integers i1, integers i2 UNION ALL SELECT * FROM integers i1, integers i2); +-- +ok +== +EXPLAIN (FORMAT GRAPHVIZ) SELECT SUM(i) FROM (SELECT * FROM integers i1, integers i2 UNION ALL SELECT * FROM integers i1, integers i2); +-- +ok +== +EXPLAIN (FORMAT YAML) SELECT SUM(i) FROM (SELECT * FROM integers i1, integers i2 UNION ALL SELECT * FROM integers i1, integers i2); +-- +ok +== +EXPLAIN (FORMAT MERMAID) SELECT SUM(i) FROM (SELECT * FROM integers i1, integers i2 UNION ALL SELECT * FROM integers i1, integers i2); +-- +ok +== +EXPLAIN (SELECT 42) INTERSECT (SELECT 42) +-- +ok +== diff --git a/parser/testdata/corpus/sql/explain/test_explain_analyze.test b/parser/testdata/corpus/sql/explain/test_explain_analyze.test new file mode 100644 index 0000000..d70d0c1 --- /dev/null +++ b/parser/testdata/corpus/sql/explain/test_explain_analyze.test @@ -0,0 +1,73 @@ +# source: test/sql/explain/test_explain_analyze.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +CREATE TABLE integers AS SELECT * FROM range(100) tbl(i); +-- +ok +== +EXPLAIN ANALYZE SELECT SUM(i) FROM integers +-- +ok +== +EXPLAIN ANALYSE SELECT SUM(i) FROM integers +-- +ok +== +EXPLAIN (ANALYZE) SELECT SUM(i) FROM (SELECT * FROM integers i1, integers i2 UNION ALL SELECT * FROM integers i1, integers i2); +-- +ok +== +EXPLAIN (ANALYSE) SELECT SUM(i) FROM (SELECT * FROM integers i1, integers i2 UNION ALL SELECT * FROM integers i1, integers i2); +-- +ok +== +EXPLAIN ANALYZE SELECT SUM(i) FROM (SELECT * FROM integers i1, integers i2 UNION ALL SELECT * FROM integers i1, integers i2); +-- +ok +== +PRAGMA disable_profiling +-- +ok +== +EXPLAIN (ANALYZE, FORMAT JSON) SELECT SUM(i) FROM (SELECT * FROM integers i1, integers i2 UNION ALL SELECT * FROM integers i1, integers i2); +-- +ok +== +EXPLAIN (ANALYZE, FORMAT JSON) SELECT SUM(i) FROM integers; +-- +ok +== +PRAGMA profiling_output='{TEST_DIR}/test.json' +-- +error: Parser Error: Profiler file type ({TEST_DIR}/test.json) must either have the same file extension as the profiling output type (query_tree), or be a '.txt' file. Set "enable_profiling = 'json'" first. +== +SELECT * FROM read_csv('{TEST_DIR}/test.json', columns={'json': 'VARCHAR'}, sep='🦆'); +-- +ok +== +PRAGMA profiling_output='{TEST_DIR}/test_2.json' +-- +error: Parser Error: Profiler file type ({TEST_DIR}/test_2.json) must either have the same file extension as the profiling output type (query_tree), or be a '.txt' file. Set "enable_profiling = 'json'" first. +== +EXPLAIN (ANALYZE, FORMAT graphviz) SELECT SUM(i) FROM integers +-- +ok +== +EXPLAIN (ANALYZE, FORMAT html) SELECT SUM(i) FROM integers +-- +ok +== +EXPLAIN (ANALYZE, FORMAT mermaid) SELECT SUM(i) FROM integers +-- +ok +== +PRAGMA enable_profiling = 'no_output'; +-- +ok +== +EXPLAIN ANALYZE SELECT 42; +-- +ok +== diff --git a/parser/testdata/corpus/sql/explain/test_explain_analyze.test.metadata.json b/parser/testdata/corpus/sql/explain/test_explain_analyze.test.metadata.json new file mode 100644 index 0000000..f3fac1d --- /dev/null +++ b/parser/testdata/corpus/sql/explain/test_explain_analyze.test.metadata.json @@ -0,0 +1,6 @@ +{ + "todo": { + "193c1f87938969e8": "transformer-raised parser error: upstream rejects in the transformer, not the grammar; expected to clear as transformers land (milestones 3-5)", + "ee40e452918b70e4": "transformer-raised parser error: upstream rejects in the transformer, not the grammar; expected to clear as transformers land (milestones 3-5)" + } +} diff --git a/parser/testdata/corpus/sql/explain/test_explain_limit.test b/parser/testdata/corpus/sql/explain/test_explain_limit.test new file mode 100644 index 0000000..edf29d5 --- /dev/null +++ b/parser/testdata/corpus/sql/explain/test_explain_limit.test @@ -0,0 +1,21 @@ +# source: test/sql/explain/test_explain_limit.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +CREATE TABLE integers AS SELECT * FROM range(100) tbl(i) +-- +ok +== +EXPLAIN (FORMAT JSON) SELECT * FROM integers LIMIT 10 +-- +ok +== +EXPLAIN (FORMAT JSON) SELECT * FROM integers LIMIT 10 OFFSET 5 +-- +ok +== +EXPLAIN (FORMAT JSON) SELECT * FROM integers LIMIT 10% +-- +ok +== diff --git a/parser/testdata/corpus/sql/export/empty_export.test b/parser/testdata/corpus/sql/export/empty_export.test new file mode 100644 index 0000000..353818f --- /dev/null +++ b/parser/testdata/corpus/sql/export/empty_export.test @@ -0,0 +1,9 @@ +# source: test/sql/export/empty_export.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +EXPORT DATABASE '{TEST_DIR}/empty_export' (FORMAT CSV) +-- +ok +== diff --git a/parser/testdata/corpus/sql/export/export_compression_level.test b/parser/testdata/corpus/sql/export/export_compression_level.test new file mode 100644 index 0000000..3c62e75 --- /dev/null +++ b/parser/testdata/corpus/sql/export/export_compression_level.test @@ -0,0 +1,38 @@ +# source: test/sql/export/export_compression_level.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +CREATE TABLE test_table ( + id INTEGER, + name VARCHAR, + value DOUBLE, + created_at TIMESTAMP +); +-- +ok +== +INSERT INTO test_table VALUES + (1, 'Alice', 123.45, '2024-01-01 10:00:00'), + (2, 'Bob', 67.89, '2024-01-02 11:30:00'), + (3, 'Charlie', 234.56, '2024-01-03 14:15:00'); +-- +ok +== +EXPORT DATABASE '{TEST_DIR}/my_duckdb' ( + FORMAT parquet, + COMPRESSION zstd, + COMPRESSION_LEVEL 12, + ROW_GROUP_SIZE 100_000 +); +-- +ok +== +IMPORT DATABASE '{TEST_DIR}/my_duckdb'; +-- +ok +== +FROM test_table; +-- +ok +== diff --git a/parser/testdata/corpus/sql/export/export_database.test b/parser/testdata/corpus/sql/export/export_database.test new file mode 100644 index 0000000..b71114b --- /dev/null +++ b/parser/testdata/corpus/sql/export/export_database.test @@ -0,0 +1,161 @@ +# source: test/sql/export/export_database.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +EXPORT DATABASE '' (FORMAT X!); +-- +error: Parser Error: Unsupported parameter type for FORMAT: expected e.g. FORMAT 'csv', 'parquet' +== +EXPORT DATABASE '' (FORMAT x); +-- +ok +== +EXPORT DATABASE '' (FORMAT); +-- +error: Parser Error: FORMAT requires a parameter, e.g. FORMAT 'csv' or FORMAT 'parquet' +== +EXPORT DATABASE '' (FORMAT lower('csv')); +-- +error: Parser Error: Unsupported parameter type for FORMAT: expected e.g. FORMAT 'csv', 'parquet' +== +CREATE TABLE integers(i INTEGER, j INTEGER, CHECK(i+j<10)) +-- +ok +== +CREATE TABLE strings(v VARCHAR, d DATE, PRIMARY KEY(d)) +-- +ok +== +CREATE TYPE mood AS ENUM ('sad', 'ok', 'happy'); +-- +ok +== +CREATE TABLE enums(current_mood mood) +-- +ok +== +INSERT INTO integers VALUES (1, 3), (4, 2), (NULL, 1) +-- +ok +== +INSERT INTO strings VALUES ('NULL', DATE '1992-01-01'), (NULL, DATE '1993-01-01'); +-- +ok +== +INSERT INTO enums VALUES ('sad'),('ok'),('sad'),('happy') +-- +ok +== +CREATE TABLE "table.with-symbols"(i INTEGER) +-- +ok +== +INSERT INTO "table.with-symbols" VALUES (1), (4), (NULL) +-- +ok +== +CREATE TABLE "SAME_NAME"(i INTEGER, j INTEGER); +-- +ok +== +CREATE TABLE "same_name"(i INTEGER, j INTEGER); +-- +ok +== +INSERT INTO "SAME_NAME" VALUES (1, 1), (2, 2) +-- +ok +== +CREATE VIEW v1 AS SELECT * FROM integers WHERE i>3; -- +CREATE VIEW v2 AS SELECT * FROM integers WHERE i < 3; +CREATE VIEW "view.with-symbols" AS SELECT * FROM "table.with-symbols" WHERE i < 3; +CREATE VIEW "view ""." AS SELECT * FROM "table.with-symbols" WHERE i < 3; +-- +ok +== +CREATE VIEW v3 AS SELECT * FROM integers WHERE i IS NULL -- +-- +ok +== +SELECT * FROM v2 ORDER BY 1 +-- +ok +== +SELECT * FROM integers ORDER BY 1 +-- +ok +== +SELECT * FROM enums ORDER BY 1 +-- +ok +== +SELECT * FROM strings ORDER BY 1 +-- +ok +== +SELECT * FROM v1 ORDER BY 1 +-- +ok +== +SELECT * FROM v3 ORDER BY 1 +-- +ok +== +SELECT * FROM "table.with-symbols" ORDER BY 1 +-- +ok +== +SELECT * FROM "view.with-symbols" ORDER BY 1 +-- +ok +== +SELECT * FROM "view ""." ORDER BY 1 +-- +ok +== +SELECT * FROM "SAME_NAME" ORDER BY i +-- +ok +== +CREATE SCHEMA s1; +CREATE SCHEMA s2; +-- +ok +== +CREATE TABLE table01(i INTEGER, j INTEGER); +CREATE TABLE s1.table01(i INTEGER, j INTEGER); +CREATE TABLE s2.table01(i INTEGER, j INTEGER); +-- +ok +== +INSERT INTO table01 VALUES (1, 1), (2, 2); +INSERT INTO s1.table01 VALUES (3, 3), (4, 4); +INSERT INTO s2.table01 VALUES (5, 5), (6, 6); +-- +ok +== +SELECT * FROM table01 ORDER BY i; +-- +ok +== +SELECT * FROM s1.table01 ORDER BY i; +-- +ok +== +SELECT * FROM s2.table01 ORDER BY i; +-- +ok +== +EXPORT DATABASE '{TEST_DIR}/export_test' (FORMAT CSV) +-- +ok +== +INSERT INTO integers VALUES (5, 6) +-- +ok +== +INSERT INTO strings VALUES(NULL, NULL) +-- +ok +== diff --git a/parser/testdata/corpus/sql/export/export_database.test.metadata.json b/parser/testdata/corpus/sql/export/export_database.test.metadata.json new file mode 100644 index 0000000..d6a82d6 --- /dev/null +++ b/parser/testdata/corpus/sql/export/export_database.test.metadata.json @@ -0,0 +1,7 @@ +{ + "todo": { + "ae490c2eef80be6c": "transformer-raised parser error: upstream rejects in the transformer, not the grammar; expected to clear as transformers land (milestones 3-5)", + "bb2ff7e267ffe77d": "transformer-raised parser error: upstream rejects in the transformer, not the grammar; expected to clear as transformers land (milestones 3-5)", + "dbb1889bcce104a4": "transformer-raised parser error: upstream rejects in the transformer, not the grammar; expected to clear as transformers land (milestones 3-5)" + } +} diff --git a/parser/testdata/corpus/sql/export/export_external_access.test b/parser/testdata/corpus/sql/export/export_external_access.test new file mode 100644 index 0000000..f7b7bec --- /dev/null +++ b/parser/testdata/corpus/sql/export/export_external_access.test @@ -0,0 +1,17 @@ +# source: test/sql/export/export_external_access.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +EXPORT DATABASE '{TEST_DIR}/export_permissions_test' (FORMAT CSV) +-- +ok +== +IMPORT DATABASE '{TEST_DIR}/export_permissions_test' +-- +ok +== +EXPORT DATABASE '{TEST_DIR}/export_permissions_test2' (FORMAT CSV) +-- +ok +== diff --git a/parser/testdata/corpus/sql/export/export_functions.test b/parser/testdata/corpus/sql/export/export_functions.test new file mode 100644 index 0000000..d57c8f8 --- /dev/null +++ b/parser/testdata/corpus/sql/export/export_functions.test @@ -0,0 +1,26 @@ +# source: test/sql/export/export_functions.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +CREATE TABLE tbl( + d DATE DEFAULT CURRENT_DATE, + t TIME WITH TIME ZONE DEFAULT CURRENT_TIME, + ts TIMESTAMP DEFAULT CURRENT_TIMESTAMP, + cur_user VARCHAR DEFAULT CURRENT_USER, + "user" VARCHAR DEFAULT USER, + sess_user VARCHAR DEFAULT SESSION_USER, + cur_catalog VARCHAR DEFAULT CURRENT_CATALOG, + cur_schema VARCHAR DEFAULT CURRENT_SCHEMA +); +-- +ok +== +EXPORT DATABASE '{TEST_DIR}/export_special_functions' (FORMAT CSV) +-- +ok +== +IMPORT DATABASE '{TEST_DIR}/export_special_functions' +-- +ok +== diff --git a/parser/testdata/corpus/sql/export/export_generated_columns.test b/parser/testdata/corpus/sql/export/export_generated_columns.test new file mode 100644 index 0000000..8271cd3 --- /dev/null +++ b/parser/testdata/corpus/sql/export/export_generated_columns.test @@ -0,0 +1,44 @@ +# source: test/sql/export/export_generated_columns.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +pragma storage_compatibility_version='v1.2.0' +-- +ok +== +CREATE MACRO my_macro(b) AS b + 5; +-- +ok +== +CREATE TABLE tbl ( + x INTEGER, + gen_x AS (my_macro(x)) +); +-- +ok +== +INSERT INTO tbl VALUES(5); +-- +ok +== +INSERT INTO tbl VALUES(2,3) +-- +ok +== +ALTER TABLE tbl DROP COLUMN x; +-- +ok +== +EXPORT DATABASE '{TEST_DIR}/export_generated_columns' (FORMAT CSV); +-- +ok +== +IMPORT DATABASE '{TEST_DIR}/export_generated_columns' +-- +ok +== +drop macro my_macro; +-- +ok +== diff --git a/parser/testdata/corpus/sql/export/export_hive_path.test b/parser/testdata/corpus/sql/export/export_hive_path.test new file mode 100644 index 0000000..719c3ef --- /dev/null +++ b/parser/testdata/corpus/sql/export/export_hive_path.test @@ -0,0 +1,17 @@ +# source: test/sql/export/export_hive_path.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +INSERT INTO integers VALUES (42); +-- +ok +== +EXPORT DATABASE '{TEST_DIR}/d=1992-01-01' +-- +ok +== +IMPORT DATABASE '{TEST_DIR}/d=1992-01-01' +-- +ok +== diff --git a/parser/testdata/corpus/sql/export/export_indexes.test b/parser/testdata/corpus/sql/export/export_indexes.test new file mode 100644 index 0000000..2437cc4 --- /dev/null +++ b/parser/testdata/corpus/sql/export/export_indexes.test @@ -0,0 +1,41 @@ +# source: test/sql/export/export_indexes.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +CREATE MACRO elaborate_macro(x, y := 7) AS x + y; +-- +ok +== +CREATE TABLE tbl (x integer, y varchar); +-- +ok +== +CREATE UNIQUE INDEX my_index on tbl (elaborate_macro(tbl.x)); +-- +ok +== +select index_name from duckdb_indexes(); +-- +ok +== +EXPORT DATABASE '{TEST_DIR}/export_macros' (FORMAT CSV); +-- +ok +== +IMPORT DATABASE '{TEST_DIR}/export_macros' +-- +ok +== +SELECT elaborate_macro(28, y := 5) +-- +ok +== +insert into tbl VALUES (10, 'hello'); +-- +ok +== +insert into tbl VALUES (10, 'world'); +-- +ok +== diff --git a/parser/testdata/corpus/sql/export/export_macros.test b/parser/testdata/corpus/sql/export/export_macros.test new file mode 100644 index 0000000..060ff99 --- /dev/null +++ b/parser/testdata/corpus/sql/export/export_macros.test @@ -0,0 +1,33 @@ +# source: test/sql/export/export_macros.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +set enable_macro_dependencies=true; +-- +ok +== +CREATE MACRO my_schema.my_range(x, y := 7) AS TABLE SELECT range + x i FROM range(y) +-- +ok +== +CREATE MACRO my_schema.elaborate_macro(x, y := 7) AS x + y + (SELECT max(i) FROM my_schema.my_range(0, y := 10)) +-- +ok +== +CREATE MACRO my_schema.my_other_range(x) AS TABLE SELECT * FROM my_schema.my_range(x, y := 3) +-- +ok +== +SELECT my_schema.elaborate_macro(28, y := 5) +-- +ok +== +SELECT max(i) FROM my_schema.my_range(33, y := 10) +-- +ok +== +SELECT max(i) FROM my_schema.my_other_range(40) +-- +ok +== diff --git a/parser/testdata/corpus/sql/export/export_quoted_enum.test b/parser/testdata/corpus/sql/export/export_quoted_enum.test new file mode 100644 index 0000000..c5e97a5 --- /dev/null +++ b/parser/testdata/corpus/sql/export/export_quoted_enum.test @@ -0,0 +1,37 @@ +# source: test/sql/export/export_quoted_enum.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +CREATE TYPE "group" AS ENUM ( 'one', 'two'); +-- +ok +== +CREATE TYPE quoted_enum AS ENUM ('a''b', 'x,y', 'semi;'); +-- +ok +== +CREATE TABLE table1(col1 "group"); +-- +ok +== +CREATE TABLE table2(col1 quoted_enum); +-- +ok +== +INSERT INTO table2 VALUES ('a''b'), ('x,y'), ('semi;'); +-- +ok +== +EXPORT DATABASE '{TEST_DIR}/export_enum' (FORMAT CSV); +-- +ok +== +IMPORT DATABASE '{TEST_DIR}/export_enum' +-- +ok +== +SELECT col1::VARCHAR FROM table2 ORDER BY col1::VARCHAR +-- +ok +== diff --git a/parser/testdata/corpus/sql/export/export_quoted_structs.test b/parser/testdata/corpus/sql/export/export_quoted_structs.test new file mode 100644 index 0000000..c381ef7 --- /dev/null +++ b/parser/testdata/corpus/sql/export/export_quoted_structs.test @@ -0,0 +1,17 @@ +# source: test/sql/export/export_quoted_structs.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +create table a (s STRUCT("end" VARCHAR)); +-- +ok +== +insert into a values ({"end":'hello'}); +-- +ok +== +select * from a +-- +ok +== diff --git a/parser/testdata/corpus/sql/export/export_quoted_union.test b/parser/testdata/corpus/sql/export/export_quoted_union.test new file mode 100644 index 0000000..51eecce --- /dev/null +++ b/parser/testdata/corpus/sql/export/export_quoted_union.test @@ -0,0 +1,24 @@ +# source: test/sql/export/export_quoted_union.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +create table a ( + u UNION( + "member name 1" VARCHAR, + "member name 2" BOOL + ) +); +-- +ok +== +insert into a values ( + union_value("member name 1" := 'hello') +); +-- +ok +== +select union_tag(COLUMNS(*)) from a; +-- +ok +== diff --git a/parser/testdata/corpus/sql/export/export_temp_tables.test b/parser/testdata/corpus/sql/export/export_temp_tables.test new file mode 100644 index 0000000..a7d69c6 --- /dev/null +++ b/parser/testdata/corpus/sql/export/export_temp_tables.test @@ -0,0 +1,17 @@ +# source: test/sql/export/export_temp_tables.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +CREATE TEMP TABLE temp_only AS SELECT 42 AS i +-- +ok +== +EXPORT DATABASE '{TEST_DIR}/export_temp_only' (FORMAT CSV) +-- +ok +== +SELECT count(*) FROM read_text('{TEST_DIR}/export_temp_only/load.sql') WHERE content LIKE '%temp_only%' +-- +ok +== diff --git a/parser/testdata/corpus/sql/export/export_types.test b/parser/testdata/corpus/sql/export/export_types.test new file mode 100644 index 0000000..a4a9db3 --- /dev/null +++ b/parser/testdata/corpus/sql/export/export_types.test @@ -0,0 +1,49 @@ +# source: test/sql/export/export_types.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +CREATE TYPE doom as mood; +-- +ok +== +create table tbl1 (a mood, b doom); +-- +ok +== +create table tbl2 (my_struct STRUCT(a mood, b doom)); +-- +ok +== +CREATE TYPE doom_mood as STRUCT(a mood, b doom); +-- +ok +== +CREATE TYPE mood_list as mood[]; +-- +ok +== +CREATE TYPE my_union as UNION(a doom, b mood); +-- +ok +== +CREATE TYPE mood_map as MAP(doom, mood); +-- +ok +== +CREATE TYPE my_special_type as VARCHAR; +-- +ok +== +CREATE TABLE tbl3 (my_struct doom_mood); +-- +ok +== +EXPORT DATABASE '{TEST_DIR}/export_types' (FORMAT CSV); +-- +ok +== +IMPORT DATABASE '{TEST_DIR}/export_types' +-- +ok +== diff --git a/parser/testdata/corpus/sql/export/parquet/export_parquet_bit.test b/parser/testdata/corpus/sql/export/parquet/export_parquet_bit.test new file mode 100644 index 0000000..19e825f --- /dev/null +++ b/parser/testdata/corpus/sql/export/parquet/export_parquet_bit.test @@ -0,0 +1,13 @@ +# source: test/sql/export/parquet/export_parquet_bit.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +create table tbl as select "bit" from test_all_types(), range(3); +-- +ok +== +EXPORT DATABASE '{TEST_DIR}/export_test' (FORMAT PARQUET) +-- +ok +== diff --git a/parser/testdata/corpus/sql/export/parquet/export_parquet_enum.test b/parser/testdata/corpus/sql/export/parquet/export_parquet_enum.test new file mode 100644 index 0000000..27b6897 --- /dev/null +++ b/parser/testdata/corpus/sql/export/parquet/export_parquet_enum.test @@ -0,0 +1,24 @@ +# source: test/sql/export/parquet/export_parquet_enum.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +create type my_enum as enum ('1', '2', '3') +-- +ok +== +create table tbl (a my_enum); +-- +ok +== +create table tbl2 as select 'hello''world'::enum('hello''world'); +-- +ok +== +insert into tbl VALUES + ('1'), + (NULL), + ('3'); +-- +ok +== diff --git a/parser/testdata/corpus/sql/export/parquet/export_parquet_hugeint.test b/parser/testdata/corpus/sql/export/parquet/export_parquet_hugeint.test new file mode 100644 index 0000000..7df57f7 --- /dev/null +++ b/parser/testdata/corpus/sql/export/parquet/export_parquet_hugeint.test @@ -0,0 +1,9 @@ +# source: test/sql/export/parquet/export_parquet_hugeint.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +create table tbl as select "hugeint" from test_all_types(), range(3); +-- +ok +== diff --git a/parser/testdata/corpus/sql/export/parquet/export_parquet_json.test b/parser/testdata/corpus/sql/export/parquet/export_parquet_json.test new file mode 100644 index 0000000..6531126 --- /dev/null +++ b/parser/testdata/corpus/sql/export/parquet/export_parquet_json.test @@ -0,0 +1,9 @@ +# source: test/sql/export/parquet/export_parquet_json.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +create table tbl as select val from ( select json_structure('{"a": 42}') val), range(3); +-- +ok +== diff --git a/parser/testdata/corpus/sql/export/parquet/export_parquet_list.test b/parser/testdata/corpus/sql/export/parquet/export_parquet_list.test new file mode 100644 index 0000000..6c84eb9 --- /dev/null +++ b/parser/testdata/corpus/sql/export/parquet/export_parquet_list.test @@ -0,0 +1,11 @@ +# source: test/sql/export/parquet/export_parquet_list.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +create table tbl as select val from ( + select ['01010101'::BIT, '01011101001'::BIT] val +), range(3); +-- +ok +== diff --git a/parser/testdata/corpus/sql/export/parquet/export_parquet_map.test b/parser/testdata/corpus/sql/export/parquet/export_parquet_map.test new file mode 100644 index 0000000..c83f9e0 --- /dev/null +++ b/parser/testdata/corpus/sql/export/parquet/export_parquet_map.test @@ -0,0 +1,31 @@ +# source: test/sql/export/parquet/export_parquet_map.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +create table unsupported_key as select val from ( + select MAP { + 'hello': '01010101000'::BIT, + 'HELLO': NULL::BIT + } val +), range(3); +-- +ok +== +create table unsupported_value as select val from ( + select MAP { + '01010101000'::BIT: 'hello', + '11110111101'::BIT: 'world' + } val +), range(3); +-- +ok +== +select * from unsupported_key; +-- +ok +== +select * from unsupported_value; +-- +ok +== diff --git a/parser/testdata/corpus/sql/export/parquet/export_parquet_struct.test b/parser/testdata/corpus/sql/export/parquet/export_parquet_struct.test new file mode 100644 index 0000000..6cb6eeb --- /dev/null +++ b/parser/testdata/corpus/sql/export/parquet/export_parquet_struct.test @@ -0,0 +1,15 @@ +# source: test/sql/export/parquet/export_parquet_struct.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +create table tbl as select val from ( + select { + 'a': '01010101000'::BIT, + 'b': true, + 'c': NULL + } val +), range(3); +-- +ok +== diff --git a/parser/testdata/corpus/sql/export/parquet/export_parquet_union.test b/parser/testdata/corpus/sql/export/parquet/export_parquet_union.test new file mode 100644 index 0000000..c1f5672 --- /dev/null +++ b/parser/testdata/corpus/sql/export/parquet/export_parquet_union.test @@ -0,0 +1,17 @@ +# source: test/sql/export/parquet/export_parquet_union.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +create table tbl as select "union" from test_all_types(), range(3); +-- +ok +== +create table tbl2 (a UNION(a bit, b bool)); +-- +ok +== +insert into tbl2 VALUES ('00101010'::BIT), (True::BOOL), (NULL::BIT); +-- +ok +== diff --git a/parser/testdata/corpus/sql/export/parquet_export.test b/parser/testdata/corpus/sql/export/parquet_export.test new file mode 100644 index 0000000..cf1b797 --- /dev/null +++ b/parser/testdata/corpus/sql/export/parquet_export.test @@ -0,0 +1,29 @@ +# source: test/sql/export/parquet_export.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +CREATE TABLE integers(i INTEGER NOT NULL, j INTEGER) +-- +ok +== +INSERT INTO integers SELECT i, i+1 FROM range(0, 1000) tbl(i) +-- +ok +== +SELECT SUM(i), SUM(j) FROM integers +-- +ok +== +INSERT INTO integers VALUES (NULL, NULL) +-- +ok +== +EXPORT DATABASE '{TEST_DIR}/export_test' (FORMAT PARQUET, CODEC 'SNAPPY') +-- +ok +== +EXPORT DATABASE '{TEST_DIR}/export_test' (FORMAT PARQUET, COMPRESSION ZSTD, ROW_GROUP_SIZE 100000); +-- +ok +== diff --git a/parser/testdata/corpus/sql/extensions/aliasing.test b/parser/testdata/corpus/sql/extensions/aliasing.test new file mode 100644 index 0000000..673b260 --- /dev/null +++ b/parser/testdata/corpus/sql/extensions/aliasing.test @@ -0,0 +1,49 @@ +# source: test/sql/extensions/aliasing.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +LOAD '{BUILD_DIRECTORY}/test/extension/loadable_extension_demo.duckdb_extension' AS demo +-- +ok +== +select extension_name, loaded from duckdb_extensions() where extension_name = 'demo'; +-- +ok +== +LOAD '{BUILD_DIRECTORY}/test/extension/loadable_extension_demo.duckdb_extension' AS demo2 +-- +ok +== +SELECT bounded_max(1::BOUNDED(10)) +-- +ok +== +LOAD '{BUILD_DIRECTORY}/test/extension/loadable_extension_demo_double.duckdb_extension' AS double +-- +ok +== +LOAD '{BUILD_DIRECTORY}/test/extension/loadable_extension_demo_double.duckdb_extension' AS second +-- +ok +== +select extension_name, loaded from duckdb_extensions() where extension_name = 'demo' or extension_name = 'double' or extension_name = 'second'; +-- +ok +== +LOAD '{BUILD_DIRECTORY}/test/extension/loadable_extension_demo.duckdb_extension' +-- +ok +== +LOAD '{BUILD_DIRECTORY}/test/extension/explicit_extension_schema_alias.duckdb_extension' AS dedicated_schema +-- +ok +== +SELECT dedicated_schema.dedicated_schema_function_alias(); +-- +ok +== +SELECT dedicated_schema_function_alias(); +-- +ok +== diff --git a/parser/testdata/corpus/sql/extensions/allowed_directories_install.test b/parser/testdata/corpus/sql/extensions/allowed_directories_install.test new file mode 100644 index 0000000..bca559c --- /dev/null +++ b/parser/testdata/corpus/sql/extensions/allowed_directories_install.test @@ -0,0 +1,21 @@ +# source: test/sql/extensions/allowed_directories_install.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +set extension_directory='{TEST_DIR}/extension_dir' +-- +ok +== +SET allowed_directories=['{TEST_DIR}', 'http://foo.com/bar', 'https://foo.com/baz']; +-- +ok +== +INSTALL bogus FROM 'http://example.com'; +-- +ok +== +set extension_directory='/tmp' +-- +ok +== diff --git a/parser/testdata/corpus/sql/extensions/attach_type_alias_conflict.test b/parser/testdata/corpus/sql/extensions/attach_type_alias_conflict.test new file mode 100644 index 0000000..36eb34c --- /dev/null +++ b/parser/testdata/corpus/sql/extensions/attach_type_alias_conflict.test @@ -0,0 +1,33 @@ +# source: test/sql/extensions/attach_type_alias_conflict.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +SET autoinstall_known_extensions=true; +-- +ok +== +SET autoload_known_extensions=true; +-- +ok +== +ATTACH '{TEST_DIR}/foo.db' AS d (TYPE sqlite); +-- +ok +== +CREATE OR REPLACE TABLE d.t(x INTEGER); +-- +ok +== +INSERT INTO d.t VALUES (1); +-- +ok +== +SELECT count(*) FROM d.t; +-- +ok +== +ATTACH OR REPLACE '{TEST_DIR}/foo.db' AS d (TYPE sqlite3); +-- +ok +== diff --git a/parser/testdata/corpus/sql/extensions/checked_load.test b/parser/testdata/corpus/sql/extensions/checked_load.test new file mode 100644 index 0000000..14ded89 --- /dev/null +++ b/parser/testdata/corpus/sql/extensions/checked_load.test @@ -0,0 +1,21 @@ +# source: test/sql/extensions/checked_load.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +LOAD 'README.md'; +-- +ok +== +SET allow_extensions_metadata_mismatch=true; +-- +ok +== +LOAD '{DATA_DIR}/csv/no_opt.csv'; +-- +ok +== +SET allow_unsigned_extensions=false; +-- +ok +== diff --git a/parser/testdata/corpus/sql/extensions/load_arbitrary_path.test b/parser/testdata/corpus/sql/extensions/load_arbitrary_path.test new file mode 100644 index 0000000..227174b --- /dev/null +++ b/parser/testdata/corpus/sql/extensions/load_arbitrary_path.test @@ -0,0 +1,9 @@ +# source: test/sql/extensions/load_arbitrary_path.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +LOAD 'folder/a.csv'; +-- +ok +== diff --git a/parser/testdata/corpus/sql/extensions/load_use_extension_one_query.test b/parser/testdata/corpus/sql/extensions/load_use_extension_one_query.test new file mode 100644 index 0000000..c0f8daa --- /dev/null +++ b/parser/testdata/corpus/sql/extensions/load_use_extension_one_query.test @@ -0,0 +1,13 @@ +# source: test/sql/extensions/load_use_extension_one_query.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +LOAD '{BUILD_DIRECTORY}/test/extension/loadable_extension_demo.duckdb_extension'; quack quack quack; +-- +ok +== +LOAD '{BUILD_DIRECTORY}/test/extension/loadable_extension_demo.duckdb_extension'; QUACK quack quack; +-- +ok +== diff --git a/parser/testdata/corpus/sql/extensions/load_use_extension_one_query.test.metadata.json b/parser/testdata/corpus/sql/extensions/load_use_extension_one_query.test.metadata.json new file mode 100644 index 0000000..078284f --- /dev/null +++ b/parser/testdata/corpus/sql/extensions/load_use_extension_one_query.test.metadata.json @@ -0,0 +1,6 @@ +{ + "skip": { + "ebfd6859ee8afabf": "multi-statement record loading a parser extension; the CLI aborts at the failed LOAD before parsing the extension syntax, darkwing parses the whole record", + "ecb70280dc8efbc2": "multi-statement record loading a parser extension; the CLI aborts at the failed LOAD before parsing the extension syntax, darkwing parses the whole record" + } +} diff --git a/parser/testdata/corpus/sql/extensions/permissions_duckdb_extension.test b/parser/testdata/corpus/sql/extensions/permissions_duckdb_extension.test new file mode 100644 index 0000000..ad2524d --- /dev/null +++ b/parser/testdata/corpus/sql/extensions/permissions_duckdb_extension.test @@ -0,0 +1,33 @@ +# source: test/sql/extensions/permissions_duckdb_extension.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +COPY (SELECT 42) TO '{TEMP_DIR}/name.duckdb_extension'; +-- +ok +== +COPY (SELECT 42) TO '{TEMP_DIR}/name_duckdb_extension'; +-- +ok +== +COPY (SELECT NULL::BLOB) TO '{TEMP_DIR}/name.duckdb_extension' (FORMAT BLOB); +-- +ok +== +COPY (SELECT NULL::BLOB) TO '{TEMP_DIR}/name.duckdb_extensionz' (FORMAT BLOB); +-- +ok +== +ATTACH '{TEMP_DIR}/my_name.duckdb_extension' +-- +ok +== +ATTACH '{TEMP_DIR}/my_name_duckdb_extension' +-- +ok +== +FROM read_blob('build/*/repository/*/*/parquet.duckdb_extension'); +-- +ok +== diff --git a/parser/testdata/corpus/sql/extensions/quack_peeling.test b/parser/testdata/corpus/sql/extensions/quack_peeling.test new file mode 100644 index 0000000..4f2f2c5 --- /dev/null +++ b/parser/testdata/corpus/sql/extensions/quack_peeling.test @@ -0,0 +1,49 @@ +# source: test/sql/extensions/quack_peeling.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +LOAD '{BUILD_DIRECTORY}/test/extension/loadable_extension_demo.duckdb_extension'; +-- +ok +== +quack quack quack; +-- +error: Parser Error: syntax error at or near "quack" +== +QUACK quack QuAcK; +-- +error: Parser Error: syntax error at or near "quack" +== +quack quack quack; SELECT 42; +-- +error: Parser Error: syntax error at or near "quack" +== +SELECT 1; quack quack quack; +-- +error: Parser Error: syntax error at or near "quack" +== +quack quack quack quack quack quack; +-- +error: Parser Error: syntax error at or near "quack" +== +SELECT 1; quack quack quack; SELECT 42; +-- +error: Parser Error: syntax error at or near "quack" +== +quack quack QUACK quaCK; +-- +error: Parser Error: syntax error at or near "quack" +== +quack quack QUACK quaCK; SELECT 42; +-- +error: Parser Error: syntax error at or near "quack" +== +quack quack QUACK quaCK SELECT 42; +-- +error: Parser Error: syntax error at or near "quack" +== +quak SELECT 32; +-- +error: Parser Error: syntax error at or near "SELECT" +== diff --git a/parser/testdata/corpus/sql/extensions/quack_peeling.test.metadata.json b/parser/testdata/corpus/sql/extensions/quack_peeling.test.metadata.json new file mode 100644 index 0000000..2495843 --- /dev/null +++ b/parser/testdata/corpus/sql/extensions/quack_peeling.test.metadata.json @@ -0,0 +1,9 @@ +{ + "skip": { + "20921c3fc370a089": "multi-statement record loading a parser extension; the CLI aborts at the failed LOAD before parsing the extension syntax, darkwing parses the whole record", + "346a063d5eead477": "multi-statement record loading a parser extension; the CLI aborts at the failed LOAD before parsing the extension syntax, darkwing parses the whole record", + "a5be0997f9c9da57": "multi-statement record loading a parser extension; the CLI aborts at the failed LOAD before parsing the extension syntax, darkwing parses the whole record", + "e456e604971185ae": "multi-statement record loading a parser extension; the CLI aborts at the failed LOAD before parsing the extension syntax, darkwing parses the whole record", + "f6ce9ff6a0e3657a": "multi-statement record loading a parser extension; the CLI aborts at the failed LOAD before parsing the extension syntax, darkwing parses the whole record" + } +} diff --git a/parser/testdata/corpus/sql/extensions/sqlite_alter_table_add_pk.test b/parser/testdata/corpus/sql/extensions/sqlite_alter_table_add_pk.test new file mode 100644 index 0000000..2f2bc9a --- /dev/null +++ b/parser/testdata/corpus/sql/extensions/sqlite_alter_table_add_pk.test @@ -0,0 +1,21 @@ +# source: test/sql/extensions/sqlite_alter_table_add_pk.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +ATTACH '{TEST_DIR}/my_sqlite' AS sqlite_db (TYPE SQLITE); +-- +ok +== +CREATE TABLE sqlite_db.main.tbl (i INT); +-- +ok +== +INSERT INTO sqlite_db.main.tbl VALUES (1); +-- +ok +== +ALTER TABLE sqlite_db.main.tbl ADD PRIMARY KEY (i); +-- +ok +== diff --git a/parser/testdata/corpus/sql/extensions/version_is_valid_sqlite.test b/parser/testdata/corpus/sql/extensions/version_is_valid_sqlite.test new file mode 100644 index 0000000..2f574d3 --- /dev/null +++ b/parser/testdata/corpus/sql/extensions/version_is_valid_sqlite.test @@ -0,0 +1,13 @@ +# source: test/sql/extensions/version_is_valid_sqlite.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +SET GLOBAL sqlite_all_varchar = true; +-- +ok +== +SELECT count(*) FROM duckdb_extensions() WHERE extension_version != '' AND extension_name == 'sqlite_scanner'; +-- +ok +== diff --git a/parser/testdata/corpus/sql/filter/filter_cache.test b/parser/testdata/corpus/sql/filter/filter_cache.test new file mode 100644 index 0000000..094d8fe --- /dev/null +++ b/parser/testdata/corpus/sql/filter/filter_cache.test @@ -0,0 +1,21 @@ +# source: test/sql/filter/filter_cache.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +CREATE TABLE integers AS SELECT a FROM generate_series(0, 9999, 1) tbl(a), generate_series(0, 9, 1) tbl2(b); +-- +ok +== +SELECT COUNT(*) FROM integers WHERE a<5; +-- +ok +== +SELECT COUNT(*) FROM (SELECT * FROM integers WHERE (a>1 AND a<10) OR a>9995) tbl(a) WHERE a<5; +-- +ok +== +SELECT COUNT(*) FROM (SELECT * FROM (SELECT * FROM integers WHERE (a <> 3 AND a<50) OR (a > 9995)) WHERE a>1 AND a<20) tbl(a) WHERE a<5; +-- +ok +== diff --git a/parser/testdata/corpus/sql/filter/filter_cache_dictionary.test b/parser/testdata/corpus/sql/filter/filter_cache_dictionary.test new file mode 100644 index 0000000..5afff9f --- /dev/null +++ b/parser/testdata/corpus/sql/filter/filter_cache_dictionary.test @@ -0,0 +1,62 @@ +# source: test/sql/filter/filter_cache_dictionary.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +PRAGMA force_compression='dictionary' +-- +ok +== +SET disabled_optimizers='filter_pushdown,compressed_materialization' +-- +ok +== +CREATE TABLE t (id INTEGER, s VARCHAR) +-- +ok +== +INSERT INTO t SELECT i, 'val_' || (i % 1000) FROM range(300000) tbl(i) +-- +ok +== +SELECT DISTINCT compression FROM pragma_storage_info('t') +WHERE segment_type ILIKE 'VARCHAR' AND compression NOT IN ('Dictionary', 'Uncompressed') +-- +ok +== +SELECT s FROM t WHERE id % 64 = 0 ORDER BY id LIMIT 6 +-- +ok +== +SELECT count(*) FROM t WHERE id % 64 = 0 +-- +ok +== +SELECT s, count(*) FROM t WHERE id % 100 = 7 GROUP BY s ORDER BY s LIMIT 5 +-- +ok +== +SELECT count(*), count(DISTINCT s) FROM t WHERE id % 100 = 7 +-- +ok +== +SELECT id, s FROM t WHERE id % 100 = 7 ORDER BY id LIMIT 5 +-- +ok +== +SELECT count(*) FROM ( + SELECT id, s FROM t WHERE id % 100 = 7 + EXCEPT + SELECT id, s FROM t WHERE id % 100 = 7 +) +-- +ok +== +SELECT count(*), sum(id) FROM t WHERE id % 100 = 7 +-- +ok +== +SET disabled_optimizers='' +-- +ok +== diff --git a/parser/testdata/corpus/sql/filter/test_alias_filter.test b/parser/testdata/corpus/sql/filter/test_alias_filter.test new file mode 100644 index 0000000..7384b55 --- /dev/null +++ b/parser/testdata/corpus/sql/filter/test_alias_filter.test @@ -0,0 +1,29 @@ +# source: test/sql/filter/test_alias_filter.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +SELECT i % 2 AS k FROM integers WHERE k<>0; +-- +ok +== +SELECT i % 2 AS k FROM integers WHERE integers.k<>0; +-- +ok +== +SELECT i % 2 AS i FROM integers WHERE i<>0; +-- +ok +== +SELECT i % 2 AS k FROM integers WHERE integers.i<>0; +-- +ok +== +SELECT i % 2 AS k FROM integers WHERE k=k; +-- +ok +== +SELECT i % 2 AS o, COUNT(i) AS c FROM integers WHERE c = 0 GROUP BY o; +-- +ok +== diff --git a/parser/testdata/corpus/sql/filter/test_constant_comparisons.test b/parser/testdata/corpus/sql/filter/test_constant_comparisons.test new file mode 100644 index 0000000..7271a14 --- /dev/null +++ b/parser/testdata/corpus/sql/filter/test_constant_comparisons.test @@ -0,0 +1,97 @@ +# source: test/sql/filter/test_constant_comparisons.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +CREATE TABLE integers(a INTEGER, b INTEGER) +-- +ok +== +INSERT INTO integers VALUES (2, 12) +-- +ok +== +SELECT * FROM integers WHERE 2=2 +-- +ok +== +SELECT * FROM integers WHERE 2=3 +-- +ok +== +SELECT * FROM integers WHERE 2<>3 +-- +ok +== +SELECT * FROM integers WHERE 2<>2 +-- +ok +== +SELECT * FROM integers WHERE 2>1 +-- +ok +== +SELECT * FROM integers WHERE 2>2 +-- +ok +== +SELECT * FROM integers WHERE 2>=2 +-- +ok +== +SELECT * FROM integers WHERE 2>=3 +-- +ok +== +SELECT * FROM integers WHERE 2<3 +-- +ok +== +SELECT * FROM integers WHERE 2<2 +-- +ok +== +SELECT * FROM integers WHERE 2<=2 +-- +ok +== +SELECT * FROM integers WHERE 2<=1 +-- +ok +== +SELECT a=NULL FROM integers +-- +ok +== +SELECT NULL=a FROM integers +-- +ok +== +SELECT * FROM integers WHERE 2 IN (2, 3, 4, 5) +-- +ok +== +SELECT * FROM integers WHERE 2 NOT IN (2, 3, 4, 5) +-- +ok +== +SELECT * FROM integers WHERE 2 IN (((1*2)+(1*0))*1, 3, 4, 5) +-- +ok +== +SELECT * FROM integers WHERE 2 IN ((1+1)*2, 3, 4, 5) +-- +ok +== +SELECT CASE WHEN 1 THEN 13 ELSE 12 END; +-- +ok +== +SELECT * FROM integers WHERE CASE WHEN 2=2 THEN true ELSE false END; +-- +ok +== +SELECT * FROM integers WHERE CASE WHEN 2=3 THEN true ELSE false END; +-- +ok +== diff --git a/parser/testdata/corpus/sql/filter/test_expression_executor_select.test b/parser/testdata/corpus/sql/filter/test_expression_executor_select.test new file mode 100644 index 0000000..99efafb --- /dev/null +++ b/parser/testdata/corpus/sql/filter/test_expression_executor_select.test @@ -0,0 +1,91 @@ +# source: test/sql/filter/test_expression_executor_select.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +PREPARE const_eq AS +SELECT count(*) FROM range(6) tbl(i) WHERE ?::INTEGER = ?::INTEGER; +-- +ok +== +EXECUTE const_eq(1, 1) +-- +ok +== +EXECUTE const_eq(1, 2) +-- +ok +== +PREPARE const_is_not_distinct AS +SELECT count(*) FROM range(6) tbl(i) WHERE ?::INTEGER IS NOT DISTINCT FROM ?::INTEGER; +-- +ok +== +EXECUTE const_is_not_distinct(NULL, NULL) +-- +ok +== +EXECUTE const_is_not_distinct(1, NULL) +-- +ok +== +CREATE TABLE dict_select( + id INTEGER, + s VARCHAR +); +-- +ok +== +PRAGMA debug_verify_vector='dictionary_expression' +-- +ok +== +INSERT INTO dict_select VALUES + (1, 'duck'), + (2, 'goose'), + (3, NULL), + (4, 'duck'), + (5, 'swan'), + (6, 'duck'); +-- +ok +== +PREPARE dict_eq AS +SELECT id FROM dict_select WHERE s = ?::VARCHAR ORDER BY id; +-- +ok +== +EXECUTE dict_eq('duck') +-- +ok +== +EXECUTE dict_eq('goose') +-- +ok +== +PREPARE dict_is_not_distinct AS +SELECT id FROM dict_select WHERE s IS NOT DISTINCT FROM ?::VARCHAR ORDER BY id; +-- +ok +== +EXECUTE dict_is_not_distinct(NULL) +-- +ok +== +EXECUTE dict_is_not_distinct('duck') +-- +ok +== +PREPARE dict_between AS +SELECT id FROM dict_select WHERE s BETWEEN ?::VARCHAR AND ?::VARCHAR ORDER BY id; +-- +ok +== +EXECUTE dict_between('duck', 'goose') +-- +ok +== +PRAGMA debug_verify_vector='none' +-- +ok +== diff --git a/parser/testdata/corpus/sql/filter/test_illegal_filters.test b/parser/testdata/corpus/sql/filter/test_illegal_filters.test new file mode 100644 index 0000000..53b2164 --- /dev/null +++ b/parser/testdata/corpus/sql/filter/test_illegal_filters.test @@ -0,0 +1,9 @@ +# source: test/sql/filter/test_illegal_filters.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +SELECT * FROM integers WHERE SUM(a)>10 +-- +ok +== diff --git a/parser/testdata/corpus/sql/filter/test_last_option_corruption.test b/parser/testdata/corpus/sql/filter/test_last_option_corruption.test new file mode 100644 index 0000000..29259b3 --- /dev/null +++ b/parser/testdata/corpus/sql/filter/test_last_option_corruption.test @@ -0,0 +1,9 @@ +# source: test/sql/filter/test_last_option_corruption.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +SELECT current_setting('binary_as_string')::BOOLEAN; +-- +ok +== diff --git a/parser/testdata/corpus/sql/filter/test_obsolete_filters.test b/parser/testdata/corpus/sql/filter/test_obsolete_filters.test new file mode 100644 index 0000000..25112d5 --- /dev/null +++ b/parser/testdata/corpus/sql/filter/test_obsolete_filters.test @@ -0,0 +1,229 @@ +# source: test/sql/filter/test_obsolete_filters.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +INSERT INTO integers VALUES (1, 10), (2, 12), (3, 14), (4, 16), (5, NULL), (NULL, NULL) +-- +ok +== +SELECT * FROM integers WHERE TRUE ORDER BY 1 +-- +ok +== +SELECT * FROM integers WHERE FALSE ORDER BY 1 +-- +ok +== +SELECT * FROM integers WHERE NULL ORDER BY 1 +-- +ok +== +SELECT * FROM integers WHERE a=2 AND a=2 +-- +ok +== +SELECT * FROM integers WHERE a=2 AND a>0 +-- +ok +== +SELECT * FROM integers WHERE a>0 AND a=2 +-- +ok +== +SELECT * FROM integers WHERE a=2 AND a<4 +-- +ok +== +SELECT * FROM integers WHERE a<4 AND a=2 +-- +ok +== +SELECT * FROM integers WHERE a=2 AND a<=2 +-- +ok +== +SELECT * FROM integers WHERE a=2 AND a>=2 +-- +ok +== +SELECT * FROM integers WHERE a>2 AND a>4 +-- +ok +== +SELECT * FROM integers WHERE a>4 AND a>2 +-- +ok +== +SELECT * FROM integers WHERE a>4 AND a>=4 +-- +ok +== +SELECT * FROM integers WHERE a>=4 AND a>4 +-- +ok +== +SELECT * FROM integers WHERE a<2 AND a<4 +-- +ok +== +SELECT * FROM integers WHERE a<4 AND a<2 +-- +ok +== +SELECT * FROM integers WHERE a<2 AND a<=2 +-- +ok +== +SELECT * FROM integers WHERE a<=2 AND a<2 +-- +ok +== +SELECT * FROM integers WHERE a<2 AND a<>3 +-- +ok +== +SELECT * FROM integers WHERE a<=1 AND a<>3 +-- +ok +== +SELECT * FROM integers WHERE a>4 AND a<>2 +-- +ok +== +SELECT * FROM integers WHERE a>=5 AND a<>2 +-- +ok +== +SELECT * FROM integers WHERE a>=4 AND a<>4 AND a<>4 +-- +ok +== +SELECT * FROM integers WHERE a<3 AND a<4 AND a<5 AND a<10 AND a<2 AND a<20 +-- +ok +== +SELECT * FROM integers WHERE a=2 AND a=4 +-- +ok +== +SELECT * FROM integers WHERE a=2 AND a>4 +-- +ok +== +SELECT * FROM integers WHERE a>4 AND a=2 +-- +ok +== +SELECT * FROM integers WHERE a=2 AND a>2 +-- +ok +== +SELECT * FROM integers WHERE a>=4 AND a=2 +-- +ok +== +SELECT * FROM integers WHERE a=4 AND a<2 +-- +ok +== +SELECT * FROM integers WHERE a<2 AND a=4 +-- +ok +== +SELECT * FROM integers WHERE a=2 AND a<2 +-- +ok +== +SELECT * FROM integers WHERE a<=2 AND a=4 +-- +ok +== +SELECT * FROM integers WHERE a<2 AND a>4 +-- +ok +== +SELECT * FROM integers WHERE a=2 AND a<>2 +-- +ok +== +SELECT * FROM integers WHERE a<>2 AND a=2 +-- +ok +== +SELECT * FROM integers WHERE 0 +-- +ok +== +SELECT * FROM integers WHERE a<2 AND 0 +-- +ok +== +INSERT INTO strings VALUES ('hello'), ('world'), (NULL) +-- +ok +== +SELECT * FROM strings WHERE s='hello' AND s='hello' +-- +ok +== +SELECT * FROM strings WHERE s='hello' AND s='world' +-- +ok +== +SELECT * FROM strings WHERE s='hello' AND s<>'hello' +-- +ok +== +SELECT * FROM strings WHERE s='hello' AND s<>'world' +-- +ok +== +SELECT * FROM strings WHERE s='hello' AND s>'a' +-- +ok +== +SELECT * FROM strings WHERE s='hello' AND s>='hello' +-- +ok +== +SELECT * FROM strings WHERE s='hello' AND s<='hello' +-- +ok +== +SELECT * FROM strings WHERE s='hello' AND s<'z' +-- +ok +== +SELECT * FROM strings WHERE s='hello' AND s<='a' +-- +ok +== +SELECT * FROM strings WHERE s='hello' AND s<'hello' +-- +ok +== +SELECT * FROM strings WHERE s='hello' AND s>'hello' +-- +ok +== +SELECT * FROM strings WHERE s='hello' AND s>='z' +-- +ok +== +SELECT * FROM strings WHERE s<>'hello' AND s<='a' +-- +ok +== +SELECT * FROM strings WHERE s<>'hello' AND s<'hello' +-- +ok +== +SELECT * FROM strings WHERE s<>'hello' AND s>'hello' +-- +ok +== +SELECT * FROM strings WHERE s<>'world' AND s>='hello' +-- +ok +== diff --git a/parser/testdata/corpus/sql/filter/test_or_pushdown.test b/parser/testdata/corpus/sql/filter/test_or_pushdown.test new file mode 100644 index 0000000..335f566 --- /dev/null +++ b/parser/testdata/corpus/sql/filter/test_or_pushdown.test @@ -0,0 +1,69 @@ +# source: test/sql/filter/test_or_pushdown.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +PRAGMA explain_output = PHYSICAL_ONLY; +-- +ok +== +create table t1 as select range a, 'foo' || (range%100)::VARCHAR b, 100000-range c, timestamp '1992-01-01' + interval (range * 20) minute d from range(900000); +-- +ok +== +select count(*) from t1 where a < 5 or b = 'foo8'; +-- +ok +== +explain select * from t1 where a<5 or b = 'foo8'; +-- +ok +== +explain select * from t1 where a<5 or c>8000; +-- +ok +== +select a from t1 where a=5 or a=899999; +-- +ok +== +explain select * from t1 where a<5 or a>10; +-- +ok +== +explain select * from t1 where 5>a or 10=a or 10<=a; +-- +ok +== +explain select * from t1 where a in (1, 5, 10); +-- +ok +== +explain select * from t1 where a = 1 or a = 5 or a = 10; +-- +ok +== +explain select * from t1 where a in (1, 2, 3); +-- +ok +== +explain select * from t1 where a in (1); +-- +ok +== +explain select b from t1 where b = 'foo9' or b = 'foo10'; +-- +ok +== +select a from t1 where d=timestamp '1992-01-01 01:40:00' or d=timestamp '2026-03-22 23:40:00' +-- +ok +== +explain select a from t1 where d=timestamp '1992-01-01 01:40:00' or d=timestamp '2026-03-22 23:40:00' +-- +ok +== diff --git a/parser/testdata/corpus/sql/filter/test_struct_pushdown.test b/parser/testdata/corpus/sql/filter/test_struct_pushdown.test new file mode 100644 index 0000000..eb03ab1 --- /dev/null +++ b/parser/testdata/corpus/sql/filter/test_struct_pushdown.test @@ -0,0 +1,190 @@ +# source: test/sql/filter/test_struct_pushdown.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +CREATE TABLE test_structs(i STRUCT(a integer, b bool)); +-- +ok +== +INSERT INTO test_structs VALUES ({'a': 1, 'b': true}), ({'a': 2, 'b': false}), (NULL), ({'a': 3, 'b': true}), ({'a': NULL, 'b': NULL}); +-- +ok +== +EXPLAIN SELECT * FROM test_structs WHERE i.a < 2; +-- +ok +== +SELECT * FROM test_structs WHERE i.a < 2; +-- +ok +== +EXPLAIN SELECT * FROM test_structs WHERE i.a > 2; +-- +ok +== +SELECT * FROM test_structs WHERE i.a > 2; +-- +ok +== +EXPLAIN SELECT * FROM test_structs WHERE i.A < 2; +-- +ok +== +SELECT * FROM test_structs WHERE i.A < 2; +-- +ok +== +EXPLAIN SELECT * FROM test_structs WHERE i.a IS NULL; +-- +ok +== +SELECT * FROM test_structs WHERE i.a IS NULL; +-- +ok +== +EXPLAIN SELECT * FROM test_structs WHERE i.a = 2 OR i.a IS NULL; +-- +ok +== +SELECT * FROM test_structs WHERE i.a = 2 OR i.a IS NULL ORDER BY 1 DESC NULLS FIRST; +-- +ok +== +CREATE TABLE string_structs(s STRUCT(a varchar, b varchar)); +-- +ok +== +INSERT INTO string_structs VALUES ({'a': 'foo', 'b': 'bar'}), ({'a': 'baz', 'b': 'qux'}), (NULL), ({'a': 'foo', 'b': NULL}); +-- +ok +== +EXPLAIN SELECT * FROM string_structs WHERE s.a = 'foo'; +-- +ok +== +SELECT * FROM string_structs WHERE s.a = 'foo'; +-- +ok +== +CREATE TABLE large_structs(i STRUCT(a integer, b bool)); +-- +ok +== +INSERT INTO large_structs SELECT {'a': n, 'b': n % 2 = 0} FROM generate_series(200000) as t(n); +-- +ok +== +EXPLAIN SELECT * FROM large_structs WHERE i.a > 150000; +-- +ok +== +EXPLAIN SELECT MIN(i.a), MAX(i.a), COUNT(*) FROM large_structs WHERE i.a > 150000; +-- +ok +== +SELECT MIN(i.a), MAX(i.a), COUNT(*) FROM large_structs WHERE i.a > 150000; +-- +ok +== +CREATE TABLE nested_structs(s STRUCT(a STRUCT(b integer, c bool), d STRUCT(e integer, f varchar))); +-- +ok +== +INSERT INTO nested_structs VALUES + ({'a': {'b': 1, 'c': false}, 'd': {'e': 2, 'f': 'foo'}}), + (NULL), + ({'a': {'b': 3, 'c': true}, 'd': {'e': 4, 'f': 'bar'}}), + ({'a': {'b': NULL, 'c': true}, 'd': {'e': 5, 'f': 'qux'}}), + ({'a': NULL, 'd': NULL}); +-- +ok +== +EXPLAIN SELECT * FROM nested_structs WHERE s.a.b < 2; +-- +ok +== +SELECT * FROM nested_structs WHERE s.a.b < 2; +-- +ok +== +EXPLAIN SELECT * FROM nested_structs WHERE s.a.c = true AND s.d.e = 5; +-- +ok +== +SELECT * FROM nested_structs WHERE s.a.c = true AND s.d.e = 5; +-- +ok +== +EXPLAIN SELECT * FROM nested_structs WHERE s.d.f = 'bar'; +-- +ok +== +SELECT * FROM nested_structs WHERE s.d.f = 'bar'; +-- +ok +== +COPY (FROM test_structs) TO '{TEST_DIR}/test_structs.parquet' (FORMAT PARQUET); +-- +ok +== +EXPLAIN SELECT * FROM read_parquet('{TEST_DIR}/test_structs.parquet') WHERE i.a < 2; +-- +ok +== +SELECT * FROM read_parquet('{TEST_DIR}/test_structs.parquet') WHERE i.a < 2; +-- +ok +== +EXPLAIN SELECT * FROM read_parquet('{TEST_DIR}/test_structs.parquet') WHERE i.b = true or i.a IS NULL; +-- +ok +== +SELECT * FROM read_parquet('{TEST_DIR}/test_structs.parquet') WHERE i.b = true or i.a IS NULL ORDER BY ALL; +-- +ok +== +COPY (FROM string_structs) TO '{TEST_DIR}/string_structs.parquet' (FORMAT PARQUET); +-- +ok +== +EXPLAIN SELECT * FROM read_parquet('{TEST_DIR}/string_structs.parquet') WHERE s.a = 'foo'; +-- +ok +== +SELECT * FROM read_parquet('{TEST_DIR}/string_structs.parquet') WHERE s.a = 'foo'; +-- +ok +== +COPY (FROM nested_structs) TO '{TEST_DIR}/nested_structs.parquet' (FORMAT PARQUET); +-- +ok +== +EXPLAIN SELECT * FROM read_parquet('{TEST_DIR}/nested_structs.parquet') WHERE s.a.b < 2; +-- +ok +== +SELECT * FROM read_parquet('{TEST_DIR}/nested_structs.parquet') WHERE s.a.b < 2; +-- +ok +== +EXPLAIN SELECT * FROM read_parquet('{TEST_DIR}/nested_structs.parquet') WHERE s.a.c = true AND s.d.e = 5; +-- +ok +== +SELECT * FROM read_parquet('{TEST_DIR}/nested_structs.parquet') WHERE s.a.c = true AND s.d.e = 5; +-- +ok +== +COPY (SELECT {'i': n} as s FROM generate_series(100000) as t(n)) TO '{TEST_DIR}/large.parquet' (FORMAT 'parquet', ROW_GROUP_SIZE 3000); +-- +ok +== +EXPLAIN SELECT * FROM read_parquet('{TEST_DIR}/large.parquet') WHERE s.i >= 500 AND s.i < 5000; +-- +ok +== +SELECT min(s.i), max(s.i) FROM read_parquet('{TEST_DIR}/large.parquet') WHERE s.i >= 500 AND s.i < 5000; +-- +ok +== diff --git a/parser/testdata/corpus/sql/filter/test_transitive_filters.test b/parser/testdata/corpus/sql/filter/test_transitive_filters.test new file mode 100644 index 0000000..fc79b82 --- /dev/null +++ b/parser/testdata/corpus/sql/filter/test_transitive_filters.test @@ -0,0 +1,202 @@ +# source: test/sql/filter/test_transitive_filters.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +CREATE TABLE vals1 AS SELECT i AS i, i AS j FROM range(0, 11, 1) t1(i) +-- +ok +== +INSERT INTO vals1 SELECT i, i+1 FROM vals1 +-- +ok +== +INSERT INTO vals1 SELECT DISTINCT(i), i-1 FROM vals1 ORDER by i +-- +ok +== +SELECT * FROM vals1 WHERE i=5 AND j>=i +-- +ok +== +SELECT * FROM vals1 WHERE i>9 AND j>=i +-- +ok +== +SELECT * FROM vals1 WHERE i>=10 AND j>=i +-- +ok +== +SELECT * FROM vals1 WHERE i<1 AND j>=i +-- +ok +== +SELECT * FROM vals1 WHERE i<=0 AND j>=i +-- +ok +== +SELECT * FROM vals1 WHERE i=5 AND j<=i +-- +ok +== +SELECT * FROM vals1 WHERE i>9 AND j<=i +-- +ok +== +SELECT * FROM vals1 WHERE i>=10 AND j<=i +-- +ok +== +SELECT * FROM vals1 WHERE i<1 AND j<=i +-- +ok +== +SELECT * FROM vals1 WHERE i<=0 AND j<=i +-- +ok +== +SELECT * FROM vals1 WHERE i=5 AND j>i +-- +ok +== +SELECT * FROM vals1 WHERE i>9 AND j>i +-- +ok +== +SELECT * FROM vals1 WHERE i>=10 AND j>i +-- +ok +== +SELECT * FROM vals1 WHERE i<1 AND j>i +-- +ok +== +SELECT * FROM vals1 WHERE i<=0 AND j>i +-- +ok +== +SELECT * FROM vals1 WHERE i=5 AND j9 AND j=10 AND j=i AND i=5 +-- +ok +== +SELECT * FROM vals1 WHERE j>=i AND i>9 +-- +ok +== +SELECT * FROM vals1 WHERE j>=i AND i>=10 +-- +ok +== +SELECT * FROM vals1 WHERE j>=i AND i<1 +-- +ok +== +SELECT * FROM vals1 WHERE j>=i AND i<=0 +-- +ok +== +SELECT * FROM vals1 WHERE j<=i AND i=5 +-- +ok +== +SELECT * FROM vals1 WHERE j<=i AND i>9 +-- +ok +== +SELECT * FROM vals1 WHERE j<=i AND i>=10 +-- +ok +== +SELECT * FROM vals1 WHERE j<=i AND i<1 +-- +ok +== +SELECT * FROM vals1 WHERE j<=i AND i<=0 +-- +ok +== +SELECT * FROM vals1 WHERE j>i AND i=5 +-- +ok +== +SELECT * FROM vals1 WHERE j>i AND i>9 +-- +ok +== +SELECT * FROM vals1 WHERE j>i AND i>=10 +-- +ok +== +SELECT * FROM vals1 WHERE j>i AND i<1 +-- +ok +== +SELECT * FROM vals1 WHERE j>i AND i<=0 +-- +ok +== +SELECT * FROM vals1 WHERE j9 +-- +ok +== +SELECT * FROM vals1 WHERE j=10 +-- +ok +== +SELECT * FROM vals1 WHERE j9 AND j<=l AND k>=i AND l<11 +ORDER BY 2 DESC, 4 DESC +-- +ok +== +SELECT * FROM vals1, vals2 WHERE i>9 AND j>=i AND k>=j ORDER by l +-- +ok +== +SELECT * FROM vals1, vals2 WHERE i>9 AND k>=j AND j>=i AND l>=k +-- +ok +== +SELECT * FROM vals1, vals2 WHERE i<1 AND k<=j AND j<=i AND l<=k +-- +ok +== diff --git a/parser/testdata/corpus/sql/filter/test_try_filter_doesnt_mutate_columns.test b/parser/testdata/corpus/sql/filter/test_try_filter_doesnt_mutate_columns.test new file mode 100644 index 0000000..f51450d --- /dev/null +++ b/parser/testdata/corpus/sql/filter/test_try_filter_doesnt_mutate_columns.test @@ -0,0 +1,150 @@ +# source: test/sql/filter/test_try_filter_doesnt_mutate_columns.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +CREATE TABLE t0(c0 INT, c1 INT); +-- +ok +== +INSERT INTO t0(c0, c1) VALUES (1819832341, -2039202523); +-- +ok +== +INSERT INTO t0(c0) VALUES (517438920); +-- +ok +== +SELECT t0.c1, t0.c0 +FROM t0 +WHERE TRY(t0.c1 - t0.c0) IS NULL +ORDER BY t0.c0; +-- +ok +== +CREATE TABLE t1(c0 INT, c1 INT); +-- +ok +== +INSERT INTO t1 VALUES (10, 5); +-- +ok +== +INSERT INTO t1 VALUES (NULL, 3); +-- +ok +== +INSERT INTO t1 VALUES (20, NULL); +-- +ok +== +INSERT INTO t1 VALUES (30, 1000000000); +-- +ok +== +SELECT c0, c1 +FROM t1 +WHERE TRY(c1 - c0) IS NULL +ORDER BY c0 NULLS LAST; +-- +ok +== +SELECT c0, c1, TRY(c1 - c0) +FROM t1 +WHERE TRY(c1 - c0) IS NOT NULL +ORDER BY c0; +-- +ok +== +CREATE TABLE t_big(c0 BIGINT, c1 BIGINT); +-- +ok +== +INSERT INTO t_big VALUES (9223372036854775807, -1); +-- +ok +== +INSERT INTO t_big VALUES (NULL, 5); +-- +ok +== +INSERT INTO t_big VALUES (10, NULL); +-- +ok +== +SELECT c0, c1 +FROM t_big +WHERE TRY(c1 - c0) IS NULL +ORDER BY c0 NULLS LAST; +-- +ok +== +CREATE TABLE t_double(c0 DOUBLE, c1 DOUBLE); +-- +ok +== +INSERT INTO t_double VALUES (1.5, 2.5); +-- +ok +== +INSERT INTO t_double VALUES (NULL, 3.0); +-- +ok +== +INSERT INTO t_double VALUES (4.0, NULL); +-- +ok +== +SELECT c0, c1 +FROM t_double +WHERE TRY(c1 - c0) IS NULL +ORDER BY c0 NULLS LAST; +-- +ok +== +CREATE TABLE t_decimal(c0 DECIMAL(10,2), c1 DECIMAL(10,2)); +-- +ok +== +INSERT INTO t_decimal VALUES (1.00, 2.00); +-- +ok +== +INSERT INTO t_decimal VALUES (0.00, 5.00); +-- +ok +== +INSERT INTO t_decimal VALUES (NULL, 7.00); +-- +ok +== +SELECT c0, c1 +FROM t_decimal +WHERE TRY(c1 / c0) IS NULL +ORDER BY c0 NULLS LAST; +-- +ok +== +CREATE TABLE t_varchar(c0 VARCHAR, c1 VARCHAR); +-- +ok +== +INSERT INTO t_varchar VALUES ('10', '5'); +-- +ok +== +INSERT INTO t_varchar VALUES ('abc', '3'); +-- +ok +== +INSERT INTO t_varchar VALUES (NULL, '7'); +-- +ok +== +SELECT c0, c1 +FROM t_varchar +WHERE TRY(c1::INTEGER - c0::INTEGER) IS NULL +ORDER BY c0 NULLS LAST; +-- +ok +== diff --git a/parser/testdata/corpus/sql/filter/test_variant_filter.test b/parser/testdata/corpus/sql/filter/test_variant_filter.test new file mode 100644 index 0000000..c55e41b --- /dev/null +++ b/parser/testdata/corpus/sql/filter/test_variant_filter.test @@ -0,0 +1,75 @@ +# source: test/sql/filter/test_variant_filter.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +WITH cte as ( + select '12'::VARIANT a +) +select IF(a == 12, 1, 0) from cte +-- +ok +== +WITH cte as ( + select '12'::VARIANT a +) +select IF(a == [1,2,3], 1, 0) from cte +-- +ok +== +WITH cte as ( + select '[1,2,3]'::VARIANT a +) +select IF(a == [1,2,3], 1, 0) from cte +-- +ok +== +WITH cte as ( + select [1,2,3]::VARIANT a +) +select IF(a == [3, 2, 1], 1, 0) from cte +-- +ok +== +WITH cte as ( + select [1,2,3]::VARIANT a +) +select IF(a == [1,2,3], 1, 0) from cte +-- +ok +== +WITH cte as ( + select [1::VARIANT,'2',3]::VARIANT a +) +select IF(a == [1,2,3], 1, 0) from cte +-- +ok +== +WITH cte as ( + select {a: 21, b: [1,2,3]}::VARIANT a +) +select IF(a == [1,2,3], 1, 0) from cte +-- +ok +== +WITH cte as ( + select {a: 21, b: [1,2,3]}::VARIANT a +) +select IF(a == {b: [1,2,3], a: 21}, 1, 0) from cte +-- +ok +== +WITH cte as ( + select {a: 21, b: [1,2,3]}::VARIANT a +) +select IF(a < [1,2,3], 1, 0) from cte +-- +ok +== +WITH cte as ( + select {a: 21, b: [1,2,3]}::VARIANT a +) +select IF(a > [1,2,3], 1, 0) from cte +-- +ok +== diff --git a/parser/testdata/corpus/sql/filter/test_zonemap_segment.test b/parser/testdata/corpus/sql/filter/test_zonemap_segment.test new file mode 100644 index 0000000..a5f4f27 --- /dev/null +++ b/parser/testdata/corpus/sql/filter/test_zonemap_segment.test @@ -0,0 +1,49 @@ +# source: test/sql/filter/test_zonemap_segment.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +INSERT INTO integers SELECT 1 FROM range(65534); +-- +ok +== +INSERT INTO integers SELECT 2 FROM range(65534); +-- +ok +== +INSERT INTO integers SELECT 3 FROM range(65534); +-- +ok +== +SELECT SUM(i) FROM integers WHERE i=1 +-- +ok +== +SELECT SUM(i) FROM integers WHERE i=2 +-- +ok +== +SELECT SUM(i) FROM integers WHERE i=3 +-- +ok +== +SELECT SUM(i) FROM integers WHERE i=4 +-- +ok +== +INSERT INTO integers SELECT 4 FROM range(65534); +-- +ok +== +INSERT INTO integers SELECT 5 FROM range(65534); +-- +ok +== +SELECT SUM(i) FROM integers WHERE i=5 +-- +ok +== +SELECT SUM(i) FROM integers WHERE i=6 +-- +ok +== diff --git a/parser/testdata/corpus/sql/function/array/array_and_map.test b/parser/testdata/corpus/sql/function/array/array_and_map.test new file mode 100644 index 0000000..58a7b7f --- /dev/null +++ b/parser/testdata/corpus/sql/function/array/array_and_map.test @@ -0,0 +1,17 @@ +# source: test/sql/function/array/array_and_map.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +SELECT MAP([MAP([ARRAY_VALUE('1', NULL), ARRAY_VALUE(NULL, '2')], [1, 2])], [1]); +-- +ok +== +SELECT MAP([2], [{'key1': MAP([ARRAY_VALUE('1', NULL), ARRAY_VALUE(NULL, '2')], [1, 2])}]); +-- +ok +== +SELECT [MAP([2], [{'key1': MAP([ARRAY_VALUE('1', NULL), ARRAY_VALUE(NULL, '2')], [1, 2]), 'key2': 2}])]; +-- +ok +== diff --git a/parser/testdata/corpus/sql/function/array/array_cosine_distance.test b/parser/testdata/corpus/sql/function/array/array_cosine_distance.test new file mode 100644 index 0000000..ff5dc86 --- /dev/null +++ b/parser/testdata/corpus/sql/function/array/array_cosine_distance.test @@ -0,0 +1,37 @@ +# source: test/sql/function/array/array_cosine_distance.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +SELECT array_cosine_distance([1, 2, 3]::{type}[3], [1, 2, 3]::{type}[3]); +-- +error: Parser Error: syntax error at or near "{" +== +SELECT array_cosine_distance([2, 2, 2]::{type}[3], [-2, -2, -2]::{type}[3]); +-- +error: Parser Error: syntax error at or near "{" +== +CREATE OR REPLACE TABLE arrays (l {type}[3]); +-- +error: Parser Error: syntax error at or near "{" +== +INSERT INTO arrays VALUES ([1, 2, 3]), ([4, 5, 6]), ([7, 8, 9]), ([-1, -2, -3]), (NULL); +-- +ok +== +SELECT array_cosine_distance(l, [1, 2, 3]::{type}[3]) FROM arrays; +-- +error: Parser Error: syntax error at or near "{" +== +SELECT array_cosine_distance([1, NULL, 3]::{type}[3], [1, 2, 3]::{type}[3]); +-- +error: Parser Error: syntax error at or near "{" +== +SELECT array_cosine_distance([1, 2, 3]::{type}[3], [1, NULL, 3]::{type}[3]); +-- +error: Parser Error: syntax error at or near "{" +== +SELECT array_cosine_distance([1, 2, 3]::{type}[3], [1, 2, 3, 4]::{type}[4]); +-- +error: Parser Error: syntax error at or near "{" +== diff --git a/parser/testdata/corpus/sql/function/array/array_cosine_similarity.test b/parser/testdata/corpus/sql/function/array/array_cosine_similarity.test new file mode 100644 index 0000000..cbc42ce --- /dev/null +++ b/parser/testdata/corpus/sql/function/array/array_cosine_similarity.test @@ -0,0 +1,25 @@ +# source: test/sql/function/array/array_cosine_similarity.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +SELECT array_cosine_similarity([1, 2, 3]::{type}[3], [1, 2, 3]::{type}[3]); +-- +error: Parser Error: syntax error at or near "{" +== +SELECT array_cosine_similarity(l, [1, 2, 3]::{type}[3]) FROM arrays; +-- +error: Parser Error: syntax error at or near "{" +== +SELECT array_cosine_similarity([1, NULL, 3]::{type}[3], [1, 2, 3]::{type}[3]); +-- +error: Parser Error: syntax error at or near "{" +== +SELECT array_cosine_similarity([1, 2, 3]::{type}[3], [1, NULL, 3]::{type}[3]); +-- +error: Parser Error: syntax error at or near "{" +== +SELECT array_cosine_similarity([1, 2, 3]::{type}[3], [1, 2, 3, 4]::{type}[4]); +-- +error: Parser Error: syntax error at or near "{" +== diff --git a/parser/testdata/corpus/sql/function/array/array_cross_product.test b/parser/testdata/corpus/sql/function/array/array_cross_product.test new file mode 100644 index 0000000..fa90bf2 --- /dev/null +++ b/parser/testdata/corpus/sql/function/array/array_cross_product.test @@ -0,0 +1,35 @@ +# source: test/sql/function/array/array_cross_product.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +SELECT array_cross_product(l, r) FROM (VALUES + ([-1, -2, 3]::{TYPE}[3], [4, 0, -8]::{TYPE}[3]), + ([1,2,3]::{TYPE}[3], [1,5,7]::{TYPE}[3]), + ([1,2,3]::{TYPE}[3], NULL::{TYPE}[3]), + (NULL::{TYPE}[3], [1,5,7]::{TYPE}[3]), + (NULL::{TYPE}[3], NULL::{TYPE}[3]) +) as t(l,r); +-- +error: Parser Error: syntax error at or near "{" +== +SELECT array_cross_product([1,2,3]::{TYPE}[3], [1,5,7]::{TYPE}[3]); +-- +error: Parser Error: syntax error at or near "{" +== +SELECT array_cross_product([1,2,3]::{TYPE}[3], NULL::{TYPE}[3]); +-- +error: Parser Error: syntax error at or near "{" +== +SELECT array_cross_product([1,NULL,3]::{TYPE}[3], [1,5,7]::{TYPE}[3]); +-- +error: Parser Error: syntax error at or near "{" +== +SELECT array_cross_product([1,5,7]::{TYPE}[3], [1,NULL,3]::{TYPE}[3]); +-- +error: Parser Error: syntax error at or near "{" +== +SELECT array_cross_product(array_value(1,2,3), array_value(1.0,5.0,7.0)::{TYPE}[3]); +-- +error: Parser Error: syntax error at or near "{" +== diff --git a/parser/testdata/corpus/sql/function/array/array_distance.test b/parser/testdata/corpus/sql/function/array/array_distance.test new file mode 100644 index 0000000..3ea9e3c --- /dev/null +++ b/parser/testdata/corpus/sql/function/array/array_distance.test @@ -0,0 +1,29 @@ +# source: test/sql/function/array/array_distance.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +SELECT array_distance([1, 2, 3]::{type}[3], [1, 2, 3]::{type}[3]); +-- +error: Parser Error: syntax error at or near "{" +== +INSERT INTO arrays VALUES ([1, 2, 3]), ([1, 2, 4]), ([7, 8, 9]), ([-1, -2, -3]), (NULL); +-- +ok +== +SELECT array_distance(l, [1, 2, 3]::{type}[3]) FROM arrays; +-- +error: Parser Error: syntax error at or near "{" +== +SELECT array_distance([1, NULL, 3]::{type}[3], [1, 2, 3]::{type}[3]); +-- +error: Parser Error: syntax error at or near "{" +== +SELECT array_distance([1, 2, 3]::{type}[3], [1, NULL, 3]::{type}[3]); +-- +error: Parser Error: syntax error at or near "{" +== +SELECT array_distance([1, 2, 3]::{type}[3], [1, 2, 3, 4]::{type}[4]); +-- +error: Parser Error: syntax error at or near "{" +== diff --git a/parser/testdata/corpus/sql/function/array/array_flatten.test b/parser/testdata/corpus/sql/function/array/array_flatten.test new file mode 100644 index 0000000..c88de75 --- /dev/null +++ b/parser/testdata/corpus/sql/function/array/array_flatten.test @@ -0,0 +1,13 @@ +# source: test/sql/function/array/array_flatten.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +select flatten(['a', 'b', 'c']::varchar[3]); +-- +ok +== +select flatten([['a'], ['b'], ['c']]::varchar[1][3]); +-- +ok +== diff --git a/parser/testdata/corpus/sql/function/array/array_inner_product.test b/parser/testdata/corpus/sql/function/array/array_inner_product.test new file mode 100644 index 0000000..09890ec --- /dev/null +++ b/parser/testdata/corpus/sql/function/array/array_inner_product.test @@ -0,0 +1,37 @@ +# source: test/sql/function/array/array_inner_product.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +SELECT array_inner_product('foo', 'bar'); +-- +ok +== +SELECT array_inner_product([1,2,3]::INT[3], ['a','b','c']::VARCHAR[3]); +-- +ok +== +SELECT array_distance(['a','b']::VARCHAR[2],['foo','bar']::VARCHAR[2]); +-- +ok +== +SELECT array_inner_product([1, 1, 1]::{type}[3], [1, 1, 1]::{type}[3]); +-- +error: Parser Error: syntax error at or near "{" +== +SELECT array_inner_product(l, [1, 2, 3]::{type}[3]) FROM arrays; +-- +error: Parser Error: syntax error at or near "{" +== +SELECT array_inner_product([1, NULL, 3]::{type}[3], [1, 2, 3]::{type}[3]); +-- +error: Parser Error: syntax error at or near "{" +== +SELECT array_inner_product([1, 2, 3]::{type}[3], [1, NULL, 3]::{type}[3]); +-- +error: Parser Error: syntax error at or near "{" +== +SELECT array_inner_product([1, 2, 3]::{type}[3], [1, 2, 3, 4]::{type}[4]); +-- +error: Parser Error: syntax error at or near "{" +== diff --git a/parser/testdata/corpus/sql/function/array/array_length.test b/parser/testdata/corpus/sql/function/array/array_length.test new file mode 100644 index 0000000..af2c7e7 --- /dev/null +++ b/parser/testdata/corpus/sql/function/array/array_length.test @@ -0,0 +1,45 @@ +# source: test/sql/function/array/array_length.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +SELECT length(array_value(1, 2, 3)); +-- +ok +== +create table arrays(a int[3]); +-- +ok +== +insert into arrays values ([1, 2, 3]), ([4, 5, 6]) +-- +ok +== +select length(a) from arrays; +-- +ok +== +select length(NULL::int[3]) from arrays; +-- +ok +== +insert into arrays values (NULL); +-- +ok +== +SELECT array_length(array_value(array_value(1, 2, 2), array_value(3, 4, 3)), 1); +-- +ok +== +SELECT array_length(array_value(array_value(1, 2, 2), array_value(3, 4, 3)), 2); +-- +ok +== +SELECT array_length(array_value(array_value(1, 2, 2), array_value(3, 4, 3)), 3); +-- +ok +== +SELECT array_length(array_value(array_value(1, 2, 2), array_value(3, 4, 3)), 0); +-- +ok +== diff --git a/parser/testdata/corpus/sql/function/array/array_list_functions.test b/parser/testdata/corpus/sql/function/array/array_list_functions.test new file mode 100644 index 0000000..3d0eda7 --- /dev/null +++ b/parser/testdata/corpus/sql/function/array/array_list_functions.test @@ -0,0 +1,69 @@ +# source: test/sql/function/array/array_list_functions.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +SELECT list_distinct(array_value(1,1,2,3,3)) = list_distinct([1,1,2,3,3]); +-- +ok +== +SELECT list_sort(array_value(3,2,1)) = list_sort([3,2,1]); +-- +ok +== +SELECT list_slice(array_value(1,2,3,4,5), 1, 3) = list_slice([1,2,3,4,5], 1, 3); +-- +ok +== +SELECT list_transform(array_value(3,2,1), lambda x: x + 1) = list_transform([3,2,1], lambda x: x + 1); +-- +ok +== +SELECT list_filter(array_value(3,2,1), lambda x: x > 1) = list_filter([3,2,1], lambda x: x > 1); +-- +ok +== +SELECT list_concat(array_value(1,2,3), array_value(4,5,6)); +-- +ok +== +SELECT list_concat(array_value(1,2,3), NULL), list_concat(NULL, array_value(4,5,6)); +-- +ok +== +SELECT list_resize(array_value(1,2), 3); +-- +ok +== +SELECT list_resize(array_value(1,2), 1); +-- +ok +== +SELECT list_resize(array_value(1,2), 0); +-- +ok +== +SELECT list_position(array_value(1,2,3), 2); +-- +ok +== +SELECT list_position(array_value(1,2,3), 4); +-- +ok +== +SELECT list_contains(array_value(1,2,3), 2); +-- +ok +== +SELECT list_contains(array_value(1,2,3), 4); +-- +ok +== +SELECT list_extract(array_value(4,5,6), 2); +-- +ok +== +SELECT list_extract(array_value(4,5,6), 4); +-- +ok +== diff --git a/parser/testdata/corpus/sql/function/autocomplete/alter_table.test b/parser/testdata/corpus/sql/function/autocomplete/alter_table.test new file mode 100644 index 0000000..73c3035 --- /dev/null +++ b/parser/testdata/corpus/sql/function/autocomplete/alter_table.test @@ -0,0 +1,21 @@ +# source: test/sql/function/autocomplete/alter_table.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +CREATE TABLE my_table(first_column bigint); +-- +ok +== +SELECT suggestion, suggestion_start FROM sql_auto_complete('ALTER TABLE my_table DROP COLUMN fi') LIMIT 1; +-- +ok +== +SELECT suggestion, suggestion_start FROM sql_auto_complete('ALTER TABLE my_table ALTER COLUMN fi') LIMIT 1; +-- +ok +== +SELECT suggestion, suggestion_start FROM sql_auto_complete('ALTER TABLE my_table RENAME COLUMN fi') LIMIT 1; +-- +ok +== diff --git a/parser/testdata/corpus/sql/function/autocomplete/copy.test b/parser/testdata/corpus/sql/function/autocomplete/copy.test new file mode 100644 index 0000000..4e9adf5 --- /dev/null +++ b/parser/testdata/corpus/sql/function/autocomplete/copy.test @@ -0,0 +1,25 @@ +# source: test/sql/function/autocomplete/copy.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +SELECT suggestion, suggestion_start FROM sql_auto_complete('COP') LIMIT 1; +-- +ok +== +SELECT suggestion, suggestion_start FROM sql_auto_complete('COPY tbl FRO') LIMIT 1; +-- +ok +== +SELECT suggestion, suggestion_start FROM sql_auto_complete('COPY tbl FROM ''file.csv'' HEAD') LIMIT 1; +-- +ok +== +CREATE TABLE my_table(my_column INTEGER); +-- +ok +== +SELECT suggestion, suggestion_start FROM sql_auto_complete('COPY my_') LIMIT 1; +-- +ok +== diff --git a/parser/testdata/corpus/sql/function/autocomplete/create_function.test b/parser/testdata/corpus/sql/function/autocomplete/create_function.test new file mode 100644 index 0000000..7d73c70 --- /dev/null +++ b/parser/testdata/corpus/sql/function/autocomplete/create_function.test @@ -0,0 +1,29 @@ +# source: test/sql/function/autocomplete/create_function.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +SELECT suggestion, suggestion_start FROM sql_auto_complete('CREATE MA') LIMIT 1; +-- +ok +== +SELECT suggestion, suggestion_start FROM sql_auto_complete('CREATE F') LIMIT 1; +-- +ok +== +SELECT suggestion, suggestion_start FROM sql_auto_complete('CREATE MACRO name(a) A') LIMIT 1; +-- +ok +== +SELECT suggestion, suggestion_start FROM sql_auto_complete('CREATE MACRO name(a) AS a+1, (b) A') LIMIT 1; +-- +ok +== +SELECT suggestion, suggestion_start FROM sql_auto_complete('CREATE MACRO name (a) AS TA') LIMIT 1; +-- +ok +== +SELECT suggestion, suggestion_start FROM sql_auto_complete('CREATE MACRO name (a) AS TABLE SEL') LIMIT 1; +-- +ok +== diff --git a/parser/testdata/corpus/sql/function/autocomplete/create_schema.test b/parser/testdata/corpus/sql/function/autocomplete/create_schema.test new file mode 100644 index 0000000..63750b6 --- /dev/null +++ b/parser/testdata/corpus/sql/function/autocomplete/create_schema.test @@ -0,0 +1,29 @@ +# source: test/sql/function/autocomplete/create_schema.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +SELECT suggestion, suggestion_start, suggestion_type FROM sql_auto_complete('CREATE SCH') LIMIT 1; +-- +ok +== +SELECT suggestion, suggestion_start FROM sql_auto_complete('CREATE SCHEMA I') LIMIT 1; +-- +ok +== +SELECT suggestion, suggestion_start FROM sql_auto_complete('CREATE SCHEMA IF NO') LIMIT 1; +-- +ok +== +SELECT suggestion, suggestion_start FROM sql_auto_complete('CREATE SCHEMA IF NOT EX') LIMIT 1; +-- +ok +== +ATTACH ':memory:' AS attached_in_memory; +-- +ok +== +SELECT suggestion, suggestion_start FROM sql_auto_complete('CREATE SCHEMA attac') LIMIT 1; +-- +ok +== diff --git a/parser/testdata/corpus/sql/function/autocomplete/create_sequence.test b/parser/testdata/corpus/sql/function/autocomplete/create_sequence.test new file mode 100644 index 0000000..cfe3ea7 --- /dev/null +++ b/parser/testdata/corpus/sql/function/autocomplete/create_sequence.test @@ -0,0 +1,17 @@ +# source: test/sql/function/autocomplete/create_sequence.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +SELECT suggestion, suggestion_start FROM sql_auto_complete('CREATE SEQ') LIMIT 1; +-- +ok +== +SELECT suggestion, suggestion_start FROM sql_auto_complete('CREATE SEQUENCE seq CYC') LIMIT 1; +-- +ok +== +SELECT suggestion, suggestion_start FROM sql_auto_complete('CREATE SEQUENCE seq INC') LIMIT 1; +-- +ok +== diff --git a/parser/testdata/corpus/sql/function/autocomplete/create_table.test b/parser/testdata/corpus/sql/function/autocomplete/create_table.test new file mode 100644 index 0000000..2df8463 --- /dev/null +++ b/parser/testdata/corpus/sql/function/autocomplete/create_table.test @@ -0,0 +1,97 @@ +# source: test/sql/function/autocomplete/create_table.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +SELECT suggestion, suggestion_start FROM sql_auto_complete('CR') LIMIT 1; +-- +ok +== +SELECT suggestion, suggestion_start FROM sql_auto_complete('cr') LIMIT 1; +-- +ok +== +SELECT suggestion, suggestion_start FROM sql_auto_complete('CREATE TA') LIMIT 1; +-- +ok +== +SELECT suggestion, suggestion_start FROM sql_auto_complete('CREATE T') LIMIT 1; +-- +ok +== +SELECT suggestion, suggestion_start FROM sql_auto_complete('CREATE OR RE') LIMIT 1; +-- +ok +== +SELECT suggestion, suggestion_start FROM sql_auto_complete('create ta') LIMIT 1; +-- +ok +== +SELECT suggestion, suggestion_start FROM sql_auto_complete('create table tbl(i INTE') LIMIT 1; +-- +ok +== +SELECT suggestion, suggestion_start FROM sql_auto_complete('create table tbl(i INTEGER, j INTE') LIMIT 1; +-- +ok +== +SELECT suggestion, suggestion_start FROM sql_auto_complete('create table tbl(i INTEGER PRI') LIMIT 1; +-- +ok +== +SELECT suggestion, suggestion_start FROM sql_auto_complete('create table tbl(i INTEGER PRIMARY KE') LIMIT 1; +-- +ok +== +SELECT suggestion, suggestion_start FROM sql_auto_complete('create table tbl(i INTEGER UNIQ') LIMIT 1; +-- +ok +== +SELECT suggestion, suggestion_start FROM sql_auto_complete('create table tbl(i INTEGER UNIQUE NO') LIMIT 1; +-- +ok +== +SELECT suggestion, suggestion_start FROM sql_auto_complete('create table tbl(i INTEGER UNIQUE NOT N') LIMIT 1; +-- +ok +== +SELECT suggestion, suggestion_start FROM sql_auto_complete('create table tbl(i INTEGER, PRI') LIMIT 1; +-- +ok +== +CREATE SCHEMA abcdefgh; +-- +ok +== +SELECT suggestion, suggestion_start FROM sql_auto_complete('CREATE TABLE abcd') LIMIT 1; +-- +ok +== +SELECT suggestion, suggestion_start FROM sql_auto_complete('CREATE TABLE abcdefgh.') LIMIT 1; +-- +ok +== +SELECT suggestion, suggestion_start FROM sql_auto_complete('CREATE TABLE ABCD') LIMIT 1; +-- +ok +== +CREATE SCHEMA "SCHEMA"; +-- +ok +== +SELECT suggestion, suggestion_start FROM sql_auto_complete('CREATE TABLE SC') LIMIT 1; +-- +ok +== +SELECT suggestion, suggestion_start FROM sql_auto_complete('CREATE TABLE attac') LIMIT 1; +-- +ok +== +SELECT suggestion, suggestion_start FROM sql_auto_complete('CREATE TABLE attached_in_memory.a') LIMIT 1; +-- +ok +== +FROM sql_auto_complete(NULL); +-- +ok +== diff --git a/parser/testdata/corpus/sql/function/autocomplete/create_type.test b/parser/testdata/corpus/sql/function/autocomplete/create_type.test new file mode 100644 index 0000000..53be38b --- /dev/null +++ b/parser/testdata/corpus/sql/function/autocomplete/create_type.test @@ -0,0 +1,21 @@ +# source: test/sql/function/autocomplete/create_type.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +SELECT suggestion, suggestion_start FROM sql_auto_complete('CREATE TY') LIMIT 1; +-- +ok +== +SELECT suggestion, suggestion_start FROM sql_auto_complete('CREATE TYPE my_type AS ENU') LIMIT 1; +-- +ok +== +SELECT suggestion, suggestion_start FROM sql_auto_complete('CREATE TYPE my_type AS TIME WITH TI') LIMIT 1; +-- +ok +== +SELECT suggestion, suggestion_start FROM sql_auto_complete('CREATE TYPE my_type AS ROW(ts TIMESTAMP WITH TIME ZON') LIMIT 1; +-- +ok +== diff --git a/parser/testdata/corpus/sql/function/autocomplete/drop.test b/parser/testdata/corpus/sql/function/autocomplete/drop.test new file mode 100644 index 0000000..2299a46 --- /dev/null +++ b/parser/testdata/corpus/sql/function/autocomplete/drop.test @@ -0,0 +1,45 @@ +# source: test/sql/function/autocomplete/drop.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +SELECT suggestion, suggestion_start FROM sql_auto_complete('DRO') LIMIT 1; +-- +ok +== +SELECT suggestion, suggestion_start FROM sql_auto_complete('DROP TA') LIMIT 1; +-- +ok +== +SELECT suggestion, suggestion_start FROM sql_auto_complete('DROP VI') LIMIT 1; +-- +ok +== +SELECT suggestion, suggestion_start FROM sql_auto_complete('DROP TABLE IF EX') LIMIT 1; +-- +ok +== +SELECT suggestion, suggestion_start FROM sql_auto_complete('DROP TABLE tbl CAS') LIMIT 1; +-- +ok +== +SELECT suggestion, suggestion_start FROM sql_auto_complete('DROP TABLE my_') LIMIT 1; +-- +ok +== +CREATE SCHEMA my_schema; +-- +ok +== +CREATE TABLE my_schema.table_in_schema(my_column INTEGER) +-- +ok +== +SELECT suggestion, suggestion_start FROM sql_auto_complete('DROP TABLE my_s') LIMIT 1; +-- +ok +== +SELECT suggestion, suggestion_start FROM sql_auto_complete('DROP TABLE my_schema.t') LIMIT 1; +-- +ok +== diff --git a/parser/testdata/corpus/sql/function/autocomplete/expressions.test b/parser/testdata/corpus/sql/function/autocomplete/expressions.test new file mode 100644 index 0000000..7528012 --- /dev/null +++ b/parser/testdata/corpus/sql/function/autocomplete/expressions.test @@ -0,0 +1,73 @@ +# source: test/sql/function/autocomplete/expressions.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +SELECT suggestion, suggestion_start FROM sql_auto_complete('SELECT NULL FR') LIMIT 1; +-- +ok +== +SELECT suggestion, suggestion_start FROM sql_auto_complete('SELECT CAST(a AS INTE') LIMIT 1; +-- +ok +== +SELECT suggestion, suggestion_start FROM sql_auto_complete('SELECT a::INTE') LIMIT 1; +-- +ok +== +SELECT suggestion, suggestion_start FROM sql_auto_complete('SELECT col IS DIST') LIMIT 1; +-- +ok +== +SELECT suggestion, suggestion_start FROM sql_auto_complete('SELECT col IS DISTINCT FRO') LIMIT 1; +-- +ok +== +SELECT suggestion, suggestion_start FROM sql_auto_complete('SELECT col COLL') LIMIT 1; +-- +ok +== +SELECT suggestion, suggestion_start FROM sql_auto_complete('SELECT col BETW') LIMIT 1; +-- +ok +== +SELECT suggestion, suggestion_start FROM sql_auto_complete('SELECT CASE WH') LIMIT 1; +-- +ok +== +SELECT suggestion, suggestion_start FROM sql_auto_complete('SELECT sum(42) IS NOT NUL') LIMIT 1; +-- +ok +== +SELECT suggestion, suggestion_start FROM sql_auto_complete('SELECT sum(disti') LIMIT 1; +-- +ok +== +SELECT suggestion, suggestion_start FROM sql_auto_complete('SELECT sum(a, b orde') LIMIT 1; +-- +ok +== +SELECT suggestion, suggestion_start FROM sql_auto_complete('SELECT sum(a) filt') LIMIT 1; +-- +ok +== +SELECT suggestion, suggestion_start FROM sql_auto_complete('SELECT CASE WHEN a=1 THEN 1 WHEN a=2 THEN 2 WHEN a=3 THEN 3 END FR') LIMIT 1; +-- +ok +== +SELECT suggestion, suggestion_start FROM sql_auto_complete('SELECT col[1:2] FR') LIMIT 1; +-- +ok +== +SELECT suggestion, suggestion_start FROM sql_auto_complete('SELECT col BETWEEN 1 AND 2, col > col2, col AND (col2 OR col3), col4 IS NOT DISTINCT FROM col5, col6 IN (SELECT * FROM tbl) FR') LIMIT 1; +-- +ok +== +SELECT suggestion, suggestion_start FROM sql_auto_complete('SELECT 42, 83.5, -125, 1.25e375, [1, 2, 3, 4], {''name'': 42}, ARRAY[col, col2 + 1] FR') LIMIT 1; +-- +ok +== +SELECT suggestion, suggestion_start FROM sql_auto_complete('SELECT a::DECIMAL(42), b::INT[3], []::INT[][][], d::ROW(i INT[], c ROW(d INTE') LIMIT 1; +-- +ok +== diff --git a/parser/testdata/corpus/sql/function/autocomplete/identical_schema_table.test b/parser/testdata/corpus/sql/function/autocomplete/identical_schema_table.test new file mode 100644 index 0000000..b00434d --- /dev/null +++ b/parser/testdata/corpus/sql/function/autocomplete/identical_schema_table.test @@ -0,0 +1,17 @@ +# source: test/sql/function/autocomplete/identical_schema_table.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +CREATE SCHEMA my_catalog_entry; +-- +ok +== +CREATE TABLE my_catalog_entry(i INT); +-- +ok +== +SELECT suggestion, suggestion_start FROM sql_auto_complete('FROM my_c') LIMIT 1; +-- +ok +== diff --git a/parser/testdata/corpus/sql/function/autocomplete/insert_into.test b/parser/testdata/corpus/sql/function/autocomplete/insert_into.test new file mode 100644 index 0000000..737ef95 --- /dev/null +++ b/parser/testdata/corpus/sql/function/autocomplete/insert_into.test @@ -0,0 +1,33 @@ +# source: test/sql/function/autocomplete/insert_into.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +SELECT suggestion, suggestion_start FROM sql_auto_complete('INS') LIMIT 1; +-- +ok +== +SELECT suggestion, suggestion_start FROM sql_auto_complete('INSERT IN') LIMIT 1; +-- +ok +== +SELECT suggestion, suggestion_start FROM sql_auto_complete('INSERT INTO tbl VAL') LIMIT 1; +-- +ok +== +SELECT suggestion, suggestion_start FROM sql_auto_complete('INSERT INTO tbl(c1, c2) VAL') LIMIT 1; +-- +ok +== +SELECT suggestion, suggestion_start FROM sql_auto_complete('INSERT INTO tbl(c1, c2) SEL') LIMIT 1; +-- +ok +== +SELECT suggestion, suggestion_start FROM sql_auto_complete('INSERT OR IG') LIMIT 1; +-- +ok +== +SELECT suggestion, suggestion_start FROM sql_auto_complete('INSERT OR REP') LIMIT 1; +-- +ok +== diff --git a/parser/testdata/corpus/sql/function/autocomplete/pragma.test b/parser/testdata/corpus/sql/function/autocomplete/pragma.test new file mode 100644 index 0000000..559af57 --- /dev/null +++ b/parser/testdata/corpus/sql/function/autocomplete/pragma.test @@ -0,0 +1,21 @@ +# source: test/sql/function/autocomplete/pragma.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +SELECT suggestion, suggestion_start FROM sql_auto_complete('PRAGMA show_t') LIMIT 1; +-- +ok +== +SELECT suggestion, suggestion_start FROM sql_auto_complete('PRAGMA enable_che') LIMIT 1; +-- +ok +== +SELECT suggestion, suggestion_start FROM sql_auto_complete('PRAGMA disable_che') LIMIT 1; +-- +ok +== +SELECT suggestion, suggestion_start FROM sql_auto_complete('PRAGMA thre') LIMIT 1; +-- +ok +== diff --git a/parser/testdata/corpus/sql/function/autocomplete/scalar_functions.test b/parser/testdata/corpus/sql/function/autocomplete/scalar_functions.test new file mode 100644 index 0000000..dd22f9a --- /dev/null +++ b/parser/testdata/corpus/sql/function/autocomplete/scalar_functions.test @@ -0,0 +1,17 @@ +# source: test/sql/function/autocomplete/scalar_functions.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +SELECT suggestion, suggestion_start FROM sql_auto_complete('select gam') LIMIT 1; +-- +ok +== +SELECT suggestion, suggestion_start FROM sql_auto_complete('select nexta') LIMIT 1; +-- +ok +== +SELECT suggestion, suggestion_start FROM sql_auto_complete('select bit_l') LIMIT 1; +-- +ok +== diff --git a/parser/testdata/corpus/sql/function/autocomplete/select.test b/parser/testdata/corpus/sql/function/autocomplete/select.test new file mode 100644 index 0000000..cc7e1cf --- /dev/null +++ b/parser/testdata/corpus/sql/function/autocomplete/select.test @@ -0,0 +1,201 @@ +# source: test/sql/function/autocomplete/select.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +SELECT suggestion, suggestion_start FROM sql_auto_complete('SEL') LIMIT 1; +-- +ok +== +SELECT suggestion, suggestion_start FROM sql_auto_complete('WI') LIMIT 1; +-- +ok +== +SELECT suggestion, suggestion_start FROM sql_auto_complete('SELECT * FR') LIMIT 1; +-- +ok +== +SELECT suggestion, suggestion_start FROM sql_auto_complete('SELECT * FROM tbl WH') LIMIT 1; +-- +ok +== +SELECT suggestion, suggestion_start FROM sql_auto_complete('SELECT * FROM tbl AN') LIMIT 1; +-- +ok +== +SELECT suggestion, suggestion_start FROM sql_auto_complete('SELECT * FROM tbl OR') LIMIT 1; +-- +ok +== +SELECT suggestion, suggestion_start FROM sql_auto_complete('SELECT * FROM tbl ORDER B') LIMIT 1; +-- +ok +== +SELECT suggestion, suggestion_start FROM sql_auto_complete('SELECT * FROM tbl ORDER BY AL') LIMIT 1; +-- +ok +== +SELECT suggestion, suggestion_start FROM sql_auto_complete('SELECT * FROM tbl GR') LIMIT 1; +-- +ok +== +SELECT suggestion, suggestion_start FROM sql_auto_complete('SELECT * FROM tbl GROUP B') LIMIT 1; +-- +ok +== +SELECT suggestion, suggestion_start FROM sql_auto_complete('SELECT * FROM tbl GROUP BY AL') LIMIT 1; +-- +ok +== +SELECT suggestion, suggestion_start FROM sql_auto_complete('SELECT * FROM tbl GROUP BY ALL HAV') LIMIT 1; +-- +ok +== +SELECT suggestion, suggestion_start FROM sql_auto_complete('SELECT * FROM tbl LIM') LIMIT 1; +-- +ok +== +SELECT suggestion, suggestion_start FROM sql_auto_complete('SELECT * FROM tbl LIMIT 5 OF') LIMIT 1; +-- +ok +== +SELECT suggestion, suggestion_start FROM sql_auto_complete('SELECT * FROM tbl INN') LIMIT 1; +-- +ok +== +SELECT suggestion, suggestion_start FROM sql_auto_complete('SELECT * FROM tbl INNER JO') LIMIT 1; +-- +ok +== +SELECT suggestion, suggestion_start FROM sql_auto_complete('SELECT * FROM tbl JOIN tbl2 USING (i) WH') LIMIT 1; +-- +ok +== +SELECT suggestion, suggestion_start FROM sql_auto_complete('SELECT * FROM tbl LEF') LIMIT 1; +-- +ok +== +SELECT suggestion, suggestion_start FROM sql_auto_complete('SELECT * FROM tbl LEFT OUT') LIMIT 1; +-- +ok +== +SELECT suggestion, suggestion_start FROM sql_auto_complete('SELECT * FROM tbl NAT') LIMIT 1; +-- +ok +== +SELECT suggestion, suggestion_start FROM sql_auto_complete('SELECT * FROM tbl NATURAL FU') LIMIT 1; +-- +ok +== +SELECT suggestion, suggestion_start FROM sql_auto_complete('SELECT * FROM tbl NATURAL FULL OUT') LIMIT 1; +-- +ok +== +SELECT suggestion, suggestion_start FROM sql_auto_complete('SELECT * FROM tbl POS') LIMIT 1; +-- +ok +== +SELECT suggestion, suggestion_start FROM sql_auto_complete('SELECT * FROM tbl NATURAL JOIN tbl2 WH') LIMIT 1; +-- +ok +== +SELECT suggestion, suggestion_start FROM sql_auto_complete('SELECT * FROM tbl NATURAL JOIN tbl2 NAT') LIMIT 1; +-- +ok +== +SELECT suggestion, suggestion_start FROM sql_auto_complete('SELECT * FROM tbl JOIN tbl2 US') LIMIT 1; +-- +ok +== +SELECT suggestion, suggestion_start FROM sql_auto_complete('SELECT * FROM tbl, tbl2 WH') LIMIT 1; +-- +ok +== +SELECT suggestion, suggestion_start FROM sql_auto_complete('SELECT * FROM tbl, tbl2 LEFT OUT') LIMIT 1; +-- +ok +== +SELECT suggestion, suggestion_start FROM sql_auto_complete('FR') LIMIT 1; +-- +ok +== +SELECT suggestion, suggestion_start FROM sql_auto_complete('FROM tbl SEL') LIMIT 1; +-- +ok +== +SELECT suggestion, suggestion_start FROM sql_auto_complete('FROM tbl OR') LIMIT 1; +-- +ok +== +SELECT suggestion, suggestion_start FROM sql_auto_complete('SELECT * FROM tbl UN') LIMIT 1; +-- +ok +== +SELECT suggestion, suggestion_start FROM sql_auto_complete('SELECT * FROM tbl UNION AL') LIMIT 1; +-- +ok +== +SELECT suggestion, suggestion_start FROM sql_auto_complete('SELECT * FROM tbl EX') LIMIT 1; +-- +ok +== +SELECT suggestion, suggestion_start FROM sql_auto_complete('SELECT * FROM tbl INT') LIMIT 1; +-- +ok +== +SELECT suggestion, suggestion_start FROM sql_auto_complete('SELECT * FROM tbl UNION ALL SEL') LIMIT 1; +-- +ok +== +SELECT suggestion, suggestion_start FROM sql_auto_complete('SELECT * FROM tbl QUAL') LIMIT 1; +-- +ok +== +SELECT suggestion, suggestion_start FROM sql_auto_complete('SELECT * FROM tbl QUALIFY row_number() OVER () ORD') LIMIT 1; +-- +ok +== +SELECT suggestion, suggestion_start FROM sql_auto_complete('SELECT col=''world'' FR') LIMIT 1; +-- +ok +== +SELECT suggestion, suggestion_start FROM sql_auto_complete('SELECT col="quoted col2" FR') LIMIT 1; +-- +ok +== +SELECT suggestion, suggestion_start FROM sql_auto_complete('SELECT "quoted col1"="quoted col2" + "quoted col3" FR') LIMIT 1; +-- +ok +== +SELECT suggestion, suggestion_start FROM sql_auto_complete('SELECT ''ORDER'' "WHERE" FR') LIMIT 1; +-- +ok +== +SELECT suggestion, suggestion_start FROM sql_auto_complete('SELECT ''OR''''DER'' "WHE""RE" FR') LIMIT 1; +-- +ok +== +SELECT suggestion, suggestion_start FROM sql_auto_complete('SELECT my_') LIMIT 1; +-- +ok +== +SELECT suggestion, suggestion_start FROM sql_auto_complete('UP') LIMIT 1; +-- +ok +== +SELECT suggestion, suggestion_start FROM sql_auto_complete('UPDATE my_table SET m') LIMIT 1; +-- +ok +== +CREATE TABLE MyTable(MyColumn Varchar); +-- +ok +== +SELECT suggestion, suggestion_start FROM sql_auto_complete('SELECT My') LIMIT 1; +-- +ok +== +SELECT suggestion, suggestion_start FROM sql_auto_complete('SELECT 42; SEL') LIMIT 1; +-- +ok +== diff --git a/parser/testdata/corpus/sql/function/autocomplete/setting.test b/parser/testdata/corpus/sql/function/autocomplete/setting.test new file mode 100644 index 0000000..8396d3d --- /dev/null +++ b/parser/testdata/corpus/sql/function/autocomplete/setting.test @@ -0,0 +1,25 @@ +# source: test/sql/function/autocomplete/setting.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +SELECT suggestion, suggestion_start FROM sql_auto_complete('SET e_directory') LIMIT 1; +-- +ok +== +SELECT suggestion, suggestion_start FROM sql_auto_complete('SET timez') LIMIT 1; +-- +ok +== +SELECT suggestion, suggestion_start FROM sql_auto_complete('SET memory') LIMIT 1; +-- +ok +== +SELECT suggestion, suggestion_start FROM sql_auto_complete('set thr') LIMIT 1; +-- +ok +== +SELECT suggestion, suggestion_start FROM sql_auto_complete('set allowed_p') LIMIT 1; +-- +ok +== diff --git a/parser/testdata/corpus/sql/function/autocomplete/show.test b/parser/testdata/corpus/sql/function/autocomplete/show.test new file mode 100644 index 0000000..2b84458 --- /dev/null +++ b/parser/testdata/corpus/sql/function/autocomplete/show.test @@ -0,0 +1,21 @@ +# source: test/sql/function/autocomplete/show.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +SELECT suggestion, suggestion_start FROM sql_auto_complete('DESCR') LIMIT 1; +-- +ok +== +SELECT suggestion, suggestion_start FROM sql_auto_complete('SHOW my_') LIMIT 1; +-- +ok +== +SELECT suggestion, suggestion_start FROM sql_auto_complete('SHOW my_s') LIMIT 1; +-- +ok +== +SELECT suggestion, suggestion_start FROM sql_auto_complete('DESCRIBE my_schema.t') LIMIT 1; +-- +ok +== diff --git a/parser/testdata/corpus/sql/function/autocomplete/sql_format.test b/parser/testdata/corpus/sql/function/autocomplete/sql_format.test new file mode 100644 index 0000000..00ff7b1 --- /dev/null +++ b/parser/testdata/corpus/sql/function/autocomplete/sql_format.test @@ -0,0 +1,712 @@ +# source: test/sql/function/autocomplete/sql_format.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +SELECT duckdb_format_sql('select a,b,c from t where x=1 and y=2 group by a,b order by a desc limit 10') = $$SELECT a, b, c +FROM t +WHERE x = 1 AND y = 2 +GROUP BY a, b +ORDER BY a DESC +LIMIT 10$$ +-- +ok +== +SELECT duckdb_format_sql('select 1') = $$SELECT 1$$ +-- +ok +== +SELECT duckdb_format_sql('select a from t; select b from u') = $$SELECT a +FROM t; +SELECT b +FROM u$$ +-- +ok +== +SELECT duckdb_format_sql('select a from t1 inner join t2 on t1.id = t2.id where t1.active = true') = $$SELECT a +FROM t1 +INNER JOIN t2 ON t1.id = t2.id +WHERE t1.active = TRUE$$ +-- +ok +== +SELECT duckdb_format_sql('select a from t1 left join t2 on t1.id = t2.id') = $$SELECT a +FROM t1 +LEFT JOIN t2 ON t1.id = t2.id$$ +-- +ok +== +SELECT duckdb_format_sql('WITH cte AS (SELECT id FROM users WHERE active = 1) SELECT id FROM cte GROUP BY id HAVING count(*) > 5') = $$WITH cte AS ( + SELECT id + FROM users + WHERE active = 1 + ) +SELECT id +FROM cte +GROUP BY id +HAVING count(*) > 5$$ +-- +ok +== +SELECT duckdb_format_sql('select id from orders where customer_id in (select id from customers where active = 1) and amount > 100') = $$SELECT id +FROM orders +WHERE + customer_id IN ( + SELECT id + FROM customers + WHERE active = 1 + ) + AND amount > 100$$ +-- +ok +== +SELECT duckdb_format_sql('select a from t1 union all select a from t2') = $$SELECT a +FROM t1 +UNION ALL +SELECT a +FROM t2$$ +-- +ok +== +SELECT duckdb_format_sql('select case when x > 0 then ''pos'' else ''neg'' end as sign from t') = $$SELECT CASE WHEN x > 0 THEN 'pos' ELSE 'neg' END AS sign +FROM t$$ +-- +ok +== +SELECT duckdb_format_sql('INSERT INTO t (a, b) VALUES (1, 2)') = $$INSERT INTO t(a, b) +VALUES (1, 2)$$ +-- +ok +== +SELECT duckdb_format_sql('update t set a = 1, b = 2 where id = 3') = $$UPDATE t +SET a = 1, b = 2 +WHERE id = 3$$ +-- +ok +== +SELECT duckdb_format_sql('delete from t where id = 1') = $$DELETE FROM t +WHERE id = 1$$ +-- +ok +== +SELECT duckdb_format_sql('select 1 from t where a = 1 and b = 2 or c = 3') = $$SELECT 1 +FROM t +WHERE a = 1 AND b = 2 OR c = 3$$ +-- +ok +== +SELECT duckdb_format_sql('select 1 from t where some_long_column_name = 1 and another_long_column = 2 or yet_another_column = 3') = $$SELECT 1 +FROM t +WHERE some_long_column_name = 1 AND another_long_column = 2 OR yet_another_column = 3$$ +-- +ok +== +SELECT duckdb_format_sql('select a from t where x = 1', MAP {'inline_threshold': '0'}) = $$SELECT + a +FROM + t +WHERE + x = 1$$ +-- +ok +== +SELECT duckdb_format_sql('select a from t where x = 1', MAP {'inline_threshold': '0', 'indent_size': '2'}) = $$SELECT + a +FROM + t +WHERE + x = 1$$ +-- +ok +== +SELECT duckdb_format_sql('select a, b, c from long_table_name', MAP {'inline_threshold': '10'}) = $$SELECT + a, + b, + c +FROM long_table_name$$ +-- +ok +== +SELECT duckdb_format_sql('SELECT a FROM t WHERE x = 1', MAP {'keyword_case': 'lower'}) = $$select a +from t +where x = 1$$ +-- +ok +== +SELECT duckdb_format_sql('Select A From T Where X = 1', MAP {'keyword_case': 'preserve'}) = $$Select A +From T +Where X = 1$$ +-- +ok +== +SELECT duckdb_format_sql('select a from t where x = 1', MAP {'keyword_case': 'upper'}) = $$SELECT a +FROM t +WHERE x = 1$$ +-- +ok +== +SELECT duckdb_format_sql('select 1', MAP {'keyword_case': 'mixed'}) +-- +ok +== +SELECT duckdb_format_sql('select 1', MAP {'bad_key': 'x'}) +-- +ok +== +SELECT duckdb_format_sql('CREATE TABLE t (id INTEGER PRIMARY KEY)') = $$CREATE TABLE t(id INTEGER PRIMARY KEY)$$ +-- +ok +== +SELECT duckdb_format_sql('CREATE TABLE orders (id INTEGER PRIMARY KEY, customer_id INTEGER NOT NULL REFERENCES customers(id), amount DECIMAL(10,2) DEFAULT 0, status VARCHAR(20))') = $$CREATE TABLE orders( + id INTEGER PRIMARY KEY, + customer_id INTEGER NOT NULL REFERENCES customers(id), + amount DECIMAL(10, 2) DEFAULT 0, + status VARCHAR(20) +)$$ +-- +ok +== +SELECT duckdb_format_sql('CREATE TABLE t (a INTEGER, b INTEGER, PRIMARY KEY (a, b), FOREIGN KEY (b) REFERENCES other(id))') = $$CREATE TABLE t( + a INTEGER, + b INTEGER, + PRIMARY KEY (a, b), + FOREIGN KEY (b) REFERENCES other(id) +)$$ +-- +ok +== +SELECT duckdb_format_sql('CREATE TABLE t (id INTEGER, name VARCHAR(100) NOT NULL UNIQUE, created_at TIMESTAMP DEFAULT current_timestamp, PRIMARY KEY (id))') = $$CREATE TABLE t( + id INTEGER, + name VARCHAR(100) NOT NULL UNIQUE, + created_at TIMESTAMP DEFAULT current_timestamp, + PRIMARY KEY (id) +)$$ +-- +ok +== +SELECT duckdb_format_sql('CREATE TABLE IF NOT EXISTS t (id INTEGER)') = $$CREATE TABLE IF NOT EXISTS t(id INTEGER)$$ +-- +ok +== +SELECT duckdb_format_sql('CREATE TEMP TABLE t (id INTEGER, name VARCHAR)') = $$CREATE TEMP TABLE t( + id INTEGER, + name VARCHAR +)$$ +-- +ok +== +SELECT duckdb_format_sql('CREATE OR REPLACE TABLE t (id INTEGER)') = $$CREATE OR REPLACE TABLE t(id INTEGER)$$ +-- +ok +== +SELECT duckdb_format_sql('CREATE VIEW active_users AS SELECT id, name FROM users WHERE active = true') = $$CREATE VIEW active_users AS +SELECT id, name +FROM users +WHERE active = TRUE$$ +-- +ok +== +SELECT duckdb_format_sql('CREATE VIEW long_schema_name.long_view_name AS SELECT id, name FROM users WHERE active = true') = $$CREATE VIEW long_schema_name.long_view_name AS +SELECT id, name +FROM users +WHERE active = TRUE$$ +-- +ok +== +SELECT duckdb_format_sql('CREATE VIEW a_very_long_schema_name.a_very_long_view_name_here AS SELECT id FROM t') = $$CREATE VIEW a_very_long_schema_name.a_very_long_view_name_here AS +SELECT id +FROM t$$ +-- +ok +== +SELECT duckdb_format_sql('CREATE OR REPLACE VIEW analytics.monthly_summary AS SELECT region, sum(amount) AS total FROM orders GROUP BY region') = $$CREATE OR REPLACE VIEW analytics.monthly_summary AS +SELECT region, sum(amount) AS total +FROM orders +GROUP BY region$$ +-- +ok +== +SELECT duckdb_format_sql('CREATE TEMP VIEW v AS SELECT id FROM t') = $$CREATE TEMP VIEW v AS +SELECT id +FROM t$$ +-- +ok +== +SELECT duckdb_format_sql('CREATE INDEX idx_name ON orders (customer_id)') = $$CREATE INDEX idx_name ON orders(customer_id)$$ +-- +ok +== +SELECT duckdb_format_sql('CREATE UNIQUE INDEX idx_email ON users (email)') = $$CREATE UNIQUE INDEX idx_email ON users(email)$$ +-- +ok +== +SELECT duckdb_format_sql('CREATE SCHEMA analytics') = $$CREATE SCHEMA analytics$$ +-- +ok +== +SELECT duckdb_format_sql('CREATE SEQUENCE seq_id START 1 INCREMENT 1') = $$CREATE SEQUENCE seq_id START 1 INCREMENT 1$$ +-- +ok +== +SELECT duckdb_format_sql('CREATE MACRO increment(x) AS x + 1') = $$CREATE MACRO increment (x) AS x + 1$$ +-- +ok +== +SELECT duckdb_format_sql('CREATE OR REPLACE MACRO clamp(x, lo, hi) AS CASE WHEN x < lo THEN lo WHEN x > hi THEN hi ELSE x END') = $$CREATE OR REPLACE MACRO clamp(x, lo, hi) AS CASE WHEN x < lo THEN lo WHEN x > hi THEN hi ELSE x END$$ +-- +ok +== +SELECT duckdb_format_sql('CREATE MACRO range_rows(lo, hi) AS TABLE SELECT * FROM t WHERE id BETWEEN lo AND hi') = $$CREATE MACRO range_rows(lo, hi) AS TABLE +SELECT * +FROM t +WHERE id BETWEEN lo AND hi$$ +-- +ok +== +SELECT duckdb_format_sql('CREATE TYPE mood AS ENUM (''happy'', ''sad'', ''neutral'')') = $$CREATE TYPE mood AS ENUM ('happy', 'sad', 'neutral')$$ +-- +ok +== +SELECT duckdb_format_sql('ALTER TABLE t ADD COLUMN email VARCHAR(100) NOT NULL') = $$ALTER TABLE t ADD COLUMN email VARCHAR(100) NOT NULL$$ +-- +ok +== +SELECT duckdb_format_sql('ALTER TABLE orders ADD CONSTRAINT pk PRIMARY KEY (id)') = $$ALTER TABLE orders ADD CONSTRAINT pk PRIMARY KEY (id)$$ +-- +ok +== +SELECT duckdb_format_sql('ALTER TABLE t DROP COLUMN old_col') = $$ALTER TABLE t +DROP COLUMN old_col$$ +-- +ok +== +SELECT duckdb_format_sql('select ''🦆'', ''🏴‍☠️'' from t') = $$SELECT '🦆', '🏴‍☠️' +FROM t$$ +-- +ok +== +SELECT duckdb_format_sql('select ''🏴‍☠️'' from t', MAP {'inline_threshold': '15'}) = $$SELECT '🏴‍☠️' +FROM t$$ +-- +ok +== +SELECT duckdb_format_sql('') +-- +ok +== +SELECT duckdb_format_sql(NULL) +-- +ok +== +SELECT duckdb_format_sql('WITH cte1 AS (SELECT id, name FROM users WHERE active = 1), cte2 AS (SELECT user_id, sum(amount) as total FROM orders GROUP BY user_id) SELECT cte1.name, cte2.total FROM cte1 JOIN cte2 ON cte1.id = cte2.user_id') = $$WITH cte1 AS ( + SELECT id, name + FROM users + WHERE active = 1 + ), + cte2 AS ( + SELECT user_id, sum(amount) AS total + FROM orders + GROUP BY user_id + ) +SELECT cte1.name, cte2.total +FROM cte1 +JOIN cte2 ON cte1.id = cte2.user_id$$ +-- +ok +== +SELECT duckdb_format_sql('WITH a AS (SELECT 1), b AS (SELECT 2), c AS (SELECT * FROM a UNION ALL SELECT * FROM b) SELECT * FROM c') = $$WITH a AS ( + SELECT 1 + ), + b AS ( + SELECT 2 + ), + c AS ( + SELECT * + FROM a + UNION ALL + SELECT * + FROM b + ) +SELECT * +FROM c$$ +-- +ok +== +SELECT duckdb_format_sql('WITH RECURSIVE tree AS (SELECT id, parent_id, name, 0 as depth FROM nodes WHERE parent_id IS NULL UNION ALL SELECT n.id, n.parent_id, n.name, t.depth + 1 FROM nodes n INNER JOIN tree t ON n.parent_id = t.id) SELECT * FROM tree ORDER BY depth, name') = $$WITH RECURSIVE tree AS ( + SELECT id, parent_id, name, 0 AS depth + FROM nodes + WHERE parent_id IS NULL + UNION ALL + SELECT n.id, n.parent_id, n.name, t.depth + 1 + FROM nodes n + INNER JOIN tree t ON n.parent_id = t.id + ) +SELECT * +FROM tree +ORDER BY depth, name$$ +-- +ok +== +SELECT duckdb_format_sql('SELECT ''hello +world'' FROM t') = $$SELECT 'hello +world' +FROM t$$ +-- +ok +== +SELECT duckdb_format_sql('SELECT ''line1 +line2 +line3'', 42 FROM t') = $$SELECT 'line1 +line2 +line3', + 42 +FROM t$$ +-- +ok +== +SELECT duckdb_format_sql('SELECT ''it''''s a test'' FROM t') = $$SELECT 'it''s a test' +FROM t$$ +-- +ok +== +SELECT duckdb_format_sql('SELECT a, b, c, d, e, f, g, h, i, j, k, l, m, n, coalesce(x, y, z) AS val, case when a > 1 then ''yes'' when a > 0 then ''maybe'' else ''no'' end as result FROM very_long_table_name_here WHERE some_column_name = 1 AND another_column > 2 AND yet_another_column < 100 ORDER BY a, b, c, d') = $$SELECT + a, + b, + c, + d, + e, + f, + g, + h, + i, + j, + k, + l, + m, + n, + coalesce(x, y, z) AS val, + CASE WHEN a > 1 THEN 'yes' WHEN a > 0 THEN 'maybe' ELSE 'no' END AS result +FROM very_long_table_name_here +WHERE some_column_name = 1 AND another_column > 2 AND yet_another_column < 100 +ORDER BY a, b, c, d$$ +-- +ok +== +SELECT duckdb_format_sql('SELECT a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q FROM very_long_table_name WHERE x = 1') = $$SELECT a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q +FROM very_long_table_name +WHERE x = 1$$ +-- +ok +== +SELECT duckdb_format_sql('SELECT a + b * c - d / e + f % g + h * (i + j) - k * l + m * n * o + p - q + r * s FROM t') = $$SELECT a + b * c - d / e + f % g + h *(i + j) - k * l + m * n * o + p - q + r * s +FROM t$$ +-- +ok +== +SELECT duckdb_format_sql('SELECT a, b, very_long_column_name_1, very_long_column_name_2, very_long_column_name_3, very_long_column_name_4 FROM t WHERE very_long_column_name_1 > 100 AND very_long_column_name_2 < 200 AND very_long_column_name_3 = ''test'' AND very_long_column_name_4 IS NOT NULL GROUP BY ALL ORDER BY ALL') = $$SELECT + a, + b, + very_long_column_name_1, + very_long_column_name_2, + very_long_column_name_3, + very_long_column_name_4 +FROM t +WHERE very_long_column_name_1 > 100 + AND very_long_column_name_2 < 200 + AND very_long_column_name_3 = 'test' + AND very_long_column_name_4 IS NOT NULL +GROUP BY ALL +ORDER BY ALL$$ +-- +ok +== +SELECT duckdb_format_sql('SELECT a FROM mydb.myschema.mytable WHERE mydb.myschema.mytable.id = 1') = $$SELECT a +FROM mydb.myschema.mytable +WHERE mydb.myschema.mytable.id = 1$$ +-- +ok +== +SELECT duckdb_format_sql('SELECT a FROM catalog1.schema1.table1 t1 INNER JOIN catalog2.schema2.table2 t2 ON t1.id = t2.id WHERE catalog1.schema1.table1.status = ''active''') = $$SELECT a +FROM catalog1.schema1.table1 t1 +INNER JOIN catalog2.schema2.table2 t2 ON t1.id = t2.id +WHERE catalog1.schema1.table1.status = 'active'$$ +-- +ok +== +SELECT duckdb_format_sql('SELECT s.id, s.name FROM mydb.information_schema.tables s WHERE s.table_schema = ''main''') = $$SELECT s.id, s.name +FROM mydb.information_schema.tables s +WHERE s.table_schema = 'main'$$ +-- +ok +== +SELECT duckdb_format_sql('CREATE TABLE mydb.myschema.mytable (id INTEGER PRIMARY KEY, name VARCHAR)') = $$CREATE TABLE mydb.myschema.mytable( + id INTEGER PRIMARY KEY, + name VARCHAR +)$$ +-- +ok +== +SELECT duckdb_format_sql('SELECT name, count(*) FROM users GROUP BY ALL ORDER BY ALL') = $$SELECT name, count(*) +FROM users +GROUP BY ALL +ORDER BY ALL$$ +-- +ok +== +SELECT duckdb_format_sql('SELECT region, product, sum(amount), count(*) FROM sales GROUP BY ALL ORDER BY ALL LIMIT 100') = $$SELECT region, product, sum(amount), count(*) +FROM sales +GROUP BY ALL +ORDER BY ALL +LIMIT 100$$ +-- +ok +== +SELECT duckdb_format_sql('SELECT list_transform([1, 2, 3], x -> x + 1)') = $$SELECT list_transform([1, 2, 3], x -> x + 1)$$ +-- +ok +== +SELECT duckdb_format_sql('SELECT list_apply(list_filter([1,2,3,4,5], x -> x > 2), y -> y * 10)') = $$SELECT list_apply(list_filter([1, 2, 3, 4, 5], x -> x > 2), y -> y * 10)$$ +-- +ok +== +SELECT duckdb_format_sql('SELECT [1, 2, 3].list_transform(x -> x + 1)') = $$SELECT [1, 2, 3].list_transform(x -> x + 1)$$ +-- +ok +== +SELECT duckdb_format_sql('SELECT ''hello +world''.upper()') = $$SELECT 'hello +world'.upper()$$ +-- +ok +== +SELECT duckdb_format_sql('SELECT struct_pack(a := 1, b := ''hello'').a') = $$SELECT struct_pack(a := 1, b := 'hello').a$$ +-- +ok +== +SELECT duckdb_format_sql('SELECT id6, v3, row_number() OVER (PARTITION BY id6 ORDER BY v3 DESC) AS order_v3 FROM x_group WHERE v3 IS NOT NULL') = $$SELECT + id6, + v3, + row_number() OVER ( + PARTITION BY id6 + ORDER BY v3 DESC + ) AS order_v3 +FROM x_group +WHERE v3 IS NOT NULL$$ +-- +ok +== +SELECT duckdb_format_sql('SELECT sum(amount) OVER (PARTITION BY region, year ORDER BY month) FROM sales') = $$SELECT + sum(amount) OVER ( + PARTITION BY region, year + ORDER BY month + ) +FROM sales$$ +-- +ok +== +SELECT duckdb_format_sql('SELECT avg(salary) OVER (PARTITION BY department) FROM employees') = $$SELECT + avg(salary) OVER ( + PARTITION BY department + ) +FROM employees$$ +-- +ok +== +SELECT duckdb_format_sql('CREATE TEMP TABLE ans AS SELECT id2, id4, pow(corr(v1, v2), 2) AS r2 FROM x_group GROUP BY id2, id4') = $$CREATE TEMP TABLE ans AS +SELECT id2, id4, pow(corr(v1, v2), 2) AS r2 +FROM x_group +GROUP BY id2, id4$$ +-- +ok +== +SELECT duckdb_format_sql('CREATE TABLE t AS SELECT a, b FROM s') = $$CREATE TABLE t AS +SELECT a, b +FROM s$$ +-- +ok +== +SELECT duckdb_format_sql('CREATE OR REPLACE TABLE t AS SELECT a, b FROM s') = $$CREATE OR REPLACE TABLE t AS +SELECT a, b +FROM s$$ +-- +ok +== +SELECT duckdb_format_sql('SELECT a FROM t WHERE k.keyword IN (''superhero'', ''marvel-comics'', ''based-on-comic'', ''tv-special'', ''fight'', ''violence'', ''magnet'', ''web'', ''claw'', ''laser'') AND kt.kind = ''movie''') = $$SELECT a +FROM t +WHERE + k.keyword IN ( + 'superhero', + 'marvel-comics', + 'based-on-comic', + 'tv-special', + 'fight', + 'violence', + 'magnet', + 'web', + 'claw', + 'laser') + AND kt.kind = 'movie'$$ +-- +ok +== +SELECT duckdb_format_sql('SELECT a FROM t WHERE x IN (1, 2, 3)') = $$SELECT a +FROM t +WHERE x IN (1, 2, 3)$$ +-- +ok +== +SELECT duckdb_format_sql('SELECT a FROM t WHERE cn1.country_code = ''[us]'' AND it1.info = ''rating'' AND t2.production_year BETWEEN 2005 AND 2008 AND lt.id = ml.link_type_id') = $$SELECT a +FROM t +WHERE cn1.country_code = '[us]' + AND it1.info = 'rating' + AND t2.production_year BETWEEN 2005 AND 2008 + AND lt.id = ml.link_type_id$$ +-- +ok +== +SELECT duckdb_format_sql('SELECT a FROM t WHERE x BETWEEN 1 AND 10') = $$SELECT a +FROM t +WHERE x BETWEEN 1 AND 10$$ +-- +ok +== +SELECT duckdb_format_sql('CREATE FUNCTION V29(x) AS LAST_VALUE(x IGNORE NULLS) OVER (ORDER BY x NULLS LAST); FORCE CHECKPOINT') = $$CREATE FUNCTION V29(x) AS LAST_VALUE(x IGNORE NULLS) OVER ( + ORDER BY x NULLS LAST + ); +FORCE CHECKPOINT$$ +-- +ok +== +SELECT duckdb_format_sql('SELECT bt.k, (k = 3 AND k + 1 = 4) OR (k = 2 AND k + 1 = 3) FROM base_table bt(k)') = $$SELECT bt.k, (k = 3 AND k + 1 = 4) OR (k = 2 AND k + 1 = 3) +FROM base_table bt(k)$$ +-- +ok +== +SELECT duckdb_format_sql('SELECT [1, 2, 3] FROM base_table bt(k)') = $$SELECT [1, 2, 3] +FROM base_table bt(k)$$ +-- +ok +== +SELECT duckdb_format_sql('CREATE TABLE strings AS SELECT ((i * 9582398353) % 1000)::VARCHAR AS s1 FROM RANGE(0, 10000000) tbl(i)') = $$CREATE TABLE strings AS +SELECT ((i * 9582398353) % 1000)::VARCHAR AS s1 +FROM RANGE (0, 10000000) tbl(i)$$ +-- +ok +== +SELECT duckdb_format_sql('SELECT a::INTEGER, b::VARCHAR(100) FROM t') = $$SELECT a::INTEGER, b::VARCHAR(100) +FROM t$$ +-- +ok +== +SELECT duckdb_format_sql('SELECT * REPLACE (make_date(EventDate) AS EventDate, epoch_ms(EventTime * 1000) AS EventTime, epoch_ms(ClientEventTime * 1000) AS ClientEventTime, epoch_ms(LocalEventTime * 1000) AS LocalEventTime) FROM t') = $$SELECT * REPLACE ( + make_date(EventDate) AS EventDate, + epoch_ms(EventTime * 1000) AS EventTime, + epoch_ms(ClientEventTime * 1000) AS ClientEventTime, + epoch_ms(LocalEventTime * 1000) AS LocalEventTime) +FROM t$$ +-- +ok +== +SELECT duckdb_format_sql('SELECT pow(corr(v1, v2), 2) FROM t') = $$SELECT pow(corr(v1, v2), 2) +FROM t$$ +-- +ok +== +SELECT duckdb_format_sql('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 t') = $$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 t$$ +-- +ok +== +SELECT duckdb_format_sql('SELECT * FROM read_csv_auto(''https://github.com/duckdb/duckdb-data/releases/download/v1.0/J1_1e7_NA_0_0.csv.gz'')') = $$SELECT * +FROM read_csv_auto('https://github.com/duckdb/duckdb-data/releases/download/v1.0/J1_1e7_NA_0_0.csv.gz')$$ +-- +ok +== +SELECT duckdb_format_sql('SELECT 1;' || chr(10) || chr(10) || 'SELECT 2;' || chr(10) || 'SELECT 3') = ('SELECT 1;' || chr(10) || chr(10) || 'SELECT 2;' || chr(10) || 'SELECT 3') +-- +ok +== +SELECT duckdb_format_sql('/* hello */ SELECT 42') = $$/* hello */ +SELECT 42$$ +-- +ok +== +SELECT duckdb_format_sql('/* Q6. Most authoritative users +\set tag ''Arnold_Schwarzenegger'' + */ +SELECT 42') = $$/* Q6. Most authoritative users +\set tag 'Arnold_Schwarzenegger' + */ +SELECT 42$$ +-- +ok +== +SELECT duckdb_format_sql('CREATE FUNCTION DeltaPhi(p1, p2) AS (CASE WHEN FMod2Pi(p1[''phi''] - p2[''phi'']) < -Pi() THEN FMod2Pi(p1[''phi''] - p2[''phi'']) + 2 * Pi() WHEN FMod2Pi(p1[''phi''] - p2[''phi'']) > Pi() THEN FMod2Pi(p1[''phi''] - p2[''phi'']) - 2 * Pi() ELSE FMod2Pi(p1[''phi''] - p2[''phi'']) END)') = $$CREATE FUNCTION DeltaPhi(p1, p2) AS ( + CASE + WHEN FMod2Pi(p1 ['phi'] - p2 ['phi']) < - Pi() THEN FMod2Pi(p1 ['phi'] - p2 ['phi']) + 2 * Pi() + WHEN FMod2Pi(p1 ['phi'] - p2 ['phi']) > Pi() THEN FMod2Pi(p1 ['phi'] - p2 ['phi']) - 2 * Pi() + ELSE FMod2Pi(p1 ['phi'] - p2 ['phi']) + END)$$ +-- +ok +== +SELECT duckdb_format_sql('CREATE OR REPLACE TABLE lineitem_sf100_random AS (SELECT * FROM lineitem ORDER BY hash(rowid + 42))') = $$CREATE OR REPLACE TABLE lineitem_sf100_random AS ( + SELECT * + FROM lineitem + ORDER BY hash(rowid + 42) + )$$ +-- +ok +== +SELECT duckdb_format_sql('SELECT {''key'': ''value'', ''key2'': ''value2'', ''key3'': ''value3''}') = $$SELECT { 'key': 'value', 'key2': 'value2', 'key3': 'value3' }$$ +-- +ok +== +SELECT duckdb_format_sql('SELECT {''l_orderkey'': 1, ''l_partkey'': 155190, ''l_suppkey'': 7706, ''l_linenumber'': 1, ''l_quantity'': 17.00, ''l_extendedprice'': 21168.23, ''l_discount'': 0.04, ''l_tax'': 0.02, ''l_returnflag'': ''N'', ''l_linestatus'': ''O'', ''l_shipdate'': ''1996-03-13'', ''l_commitdate'': ''1996-02-12'', ''l_receiptdate'': ''1996-03-22'', ''l_shipinstruct'': ''DELIVER IN PERSON'', ''l_shipmode'': ''TRUCK'', ''l_comment'': ''to beans x-ray carefull''}') = $$SELECT + { + 'l_orderkey': 1, + 'l_partkey': 155190, + 'l_suppkey': 7706, + 'l_linenumber': 1, + 'l_quantity': 17.00, + 'l_extendedprice': 21168.23, + 'l_discount': 0.04, + 'l_tax': 0.02, + 'l_returnflag': 'N', + 'l_linestatus': 'O', + 'l_shipdate': '1996-03-13', + 'l_commitdate': '1996-02-12', + 'l_receiptdate': '1996-03-22', + 'l_shipinstruct': 'DELIVER IN PERSON', + 'l_shipmode': 'TRUCK', + 'l_comment': 'to beans x-ray carefull' + }$$ +-- +ok +== +SELECT duckdb_format_sql('SELECT MAP {''l_orderkey'': ''1'', ''l_partkey'': ''155190'', ''l_suppkey'': ''7706'', ''l_linenumber'': ''1'', ''l_quantity'': ''17.00'', ''l_extendedprice'': ''21168.23'', ''l_discount'': ''0.04'', ''l_tax'': ''0.02'', ''l_returnflag'': ''N'', ''l_linestatus'': ''O'', ''l_shipdate'': ''1996-03-13'', ''l_commitdate'': ''1996-02-12'', ''l_receiptdate'': ''1996-03-22'', ''l_shipinstruct'': ''DELIVER IN PERSON'', ''l_shipmode'': ''TRUCK'', ''l_comment'': ''to beans x-ray carefull''}') = $$SELECT + MAP { + 'l_orderkey': '1', + 'l_partkey': '155190', + 'l_suppkey': '7706', + 'l_linenumber': '1', + 'l_quantity': '17.00', + 'l_extendedprice': '21168.23', + 'l_discount': '0.04', + 'l_tax': '0.02', + 'l_returnflag': 'N', + 'l_linestatus': 'O', + 'l_shipdate': '1996-03-13', + 'l_commitdate': '1996-02-12', + 'l_receiptdate': '1996-03-22', + 'l_shipinstruct': 'DELIVER IN PERSON', + 'l_shipmode': 'TRUCK', + 'l_comment': 'to beans x-ray carefull' + }$$ +-- +ok +== diff --git a/parser/testdata/corpus/sql/function/autocomplete/suggest_file.test b/parser/testdata/corpus/sql/function/autocomplete/suggest_file.test new file mode 100644 index 0000000..3af48d0 --- /dev/null +++ b/parser/testdata/corpus/sql/function/autocomplete/suggest_file.test @@ -0,0 +1,13 @@ +# source: test/sql/function/autocomplete/suggest_file.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +SELECT suggestion FROM sql_auto_complete('COPY tbl FROM ''{DATA_DIR}/parq') LIMIT 1; +-- +ok +== +SELECT suggestion FROM sql_auto_complete('COPY tbl FROM ''{DATA_DIR}/csv/all_quote') LIMIT 1; +-- +ok +== diff --git a/parser/testdata/corpus/sql/function/autocomplete/table_functions.test b/parser/testdata/corpus/sql/function/autocomplete/table_functions.test new file mode 100644 index 0000000..da0bae6 --- /dev/null +++ b/parser/testdata/corpus/sql/function/autocomplete/table_functions.test @@ -0,0 +1,41 @@ +# source: test/sql/function/autocomplete/table_functions.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +SELECT suggestion, suggestion_start FROM sql_auto_complete('call histo') LIMIT 1; +-- +ok +== +SELECT suggestion, suggestion_start FROM sql_auto_complete('call histogram_') LIMIT 1; +-- +ok +== +SELECT suggestion, suggestion_start FROM sql_auto_complete('call duckdb_ty') LIMIT 1; +-- +ok +== +SELECT suggestion, suggestion_start FROM sql_auto_complete('FROM duckdb_c') LIMIT 1; +-- +ok +== +SELECT suggestion, suggestion_start FROM sql_auto_complete('call read_cs') LIMIT 1; +-- +ok +== +SELECT suggestion, suggestion_start FROM sql_auto_complete('FROM read_csv_a') LIMIT 1; +-- +ok +== +SELECT suggestion, suggestion_start FROM sql_auto_complete('call unnes') LIMIT 1; +-- +ok +== +SELECT suggestion, suggestion_start FROM sql_auto_complete('CALL glo') LIMIT 1; +-- +ok +== +SELECT suggestion, suggestion_start FROM sql_auto_complete('from ran') LIMIT 1; +-- +ok +== diff --git a/parser/testdata/corpus/sql/function/autocomplete/tpch.test b/parser/testdata/corpus/sql/function/autocomplete/tpch.test new file mode 100644 index 0000000..80025dd --- /dev/null +++ b/parser/testdata/corpus/sql/function/autocomplete/tpch.test @@ -0,0 +1,130 @@ +# source: test/sql/function/autocomplete/tpch.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +SELECT suggestion, suggestion_start FROM sql_auto_complete('SELECT l_ord') LIMIT 1; +-- +ok +== +SELECT suggestion, suggestion_start FROM sql_auto_complete('SELECT 1 + l_ord') LIMIT 1; +-- +ok +== +SELECT suggestion, suggestion_start FROM sql_auto_complete('SELECT min(l_ord') LIMIT 1; +-- +ok +== +SELECT suggestion, suggestion_start FROM sql_auto_complete('SELECT min(42, l_ord') LIMIT 1; +-- +ok +== +SELECT suggestion, suggestion_start FROM sql_auto_complete('SELECT ''test_string'' LIKE l_c') LIMIT 1; +-- +ok +== +SELECT suggestion, suggestion_start FROM sql_auto_complete('SELECT l_orderkey FROM lin') LIMIT 1; +-- +ok +== +SELECT suggestion, suggestion_start FROM sql_auto_complete('SELECT l_orderkey FROM lineitem, ord') LIMIT 1; +-- +ok +== +SELECT suggestion, suggestion_start FROM sql_auto_complete('SELECT l_orderkey FROM lineitem JOIN ord') LIMIT 1; +-- +ok +== +SELECT suggestion, suggestion_start FROM sql_auto_complete('SELECT (SELECT SUM(l_orderkey) FROM lineit') LIMIT 1; +-- +ok +== +SELECT suggestion, suggestion_start FROM sql_auto_complete('SELECT * FROM (FROM lineit') LIMIT 1; +-- +ok +== +SELECT suggestion, suggestion_start FROM sql_auto_complete('INSERT INTO lin') LIMIT 1; +-- +ok +== +SELECT suggestion, suggestion_start FROM sql_auto_complete('DROP TABLE lin') LIMIT 1; +-- +ok +== +SELECT suggestion, suggestion_start FROM sql_auto_complete('COPY lin') LIMIT 1; +-- +ok +== +SELECT suggestion, suggestion_start FROM sql_auto_complete('DROP TABLE na') LIMIT 1; +-- +ok +== +SELECT suggestion, suggestion_start, suggestion_type FROM sql_auto_complete('SELECT * FROM partsupp JOIN supplier USING (ps_su') LIMIT 1; +-- +ok +== +SELECT suggestion, suggestion_start FROM sql_auto_complete($$ +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_nat$$) LIMIT 1; +-- +ok +== +SELECT suggestion, suggestion_start FROM sql_auto_complete($$ +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 <= CAST('1998-09-02' AS date) +GROUP BY + l_ret$$) LIMIT 1; +-- +ok +== +SELECT suggestion, suggestion_start FROM sql_auto_complete($$ +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, + line$$) LIMIT 1; +-- +ok +== diff --git a/parser/testdata/corpus/sql/function/autocomplete/views.test b/parser/testdata/corpus/sql/function/autocomplete/views.test new file mode 100644 index 0000000..94708a2 --- /dev/null +++ b/parser/testdata/corpus/sql/function/autocomplete/views.test @@ -0,0 +1,21 @@ +# source: test/sql/function/autocomplete/views.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +CREATE VIEW v1 AS SELECT 42 my_column_name +-- +ok +== +SELECT suggestion, suggestion_start FROM sql_auto_complete('SELECT my_col') LIMIT 1; +-- +ok +== +CREATE VIEW v2(alias_name) AS SELECT 42 alias +-- +ok +== +SELECT suggestion, suggestion_start FROM sql_auto_complete('SELECT alias') LIMIT 1; +-- +ok +== diff --git a/parser/testdata/corpus/sql/function/autocomplete/window.test b/parser/testdata/corpus/sql/function/autocomplete/window.test new file mode 100644 index 0000000..80e4e5c --- /dev/null +++ b/parser/testdata/corpus/sql/function/autocomplete/window.test @@ -0,0 +1,45 @@ +# source: test/sql/function/autocomplete/window.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +SELECT suggestion, suggestion_start FROM sql_auto_complete('SELECT row_number() OVER (RANG') LIMIT 1; +-- +ok +== +SELECT suggestion, suggestion_start FROM sql_auto_complete('SELECT row_number() OVER (RANGE BETWE') LIMIT 1; +-- +ok +== +SELECT suggestion, suggestion_start FROM sql_auto_complete('SELECT row_number() OVER (RANGE BETWEEN UNBOU') LIMIT 1; +-- +ok +== +SELECT suggestion, suggestion_start FROM sql_auto_complete('SELECT row_number() OVER (RANGE BETWEEN UNBOUNDED PREC') LIMIT 1; +-- +ok +== +SELECT suggestion, suggestion_start FROM sql_auto_complete('SELECT row_number() OVER (RANGE BETWEEN CURRENT ROW AND 5 PREC') LIMIT 1; +-- +ok +== +SELECT suggestion, suggestion_start FROM sql_auto_complete('SELECT row_number() OVER (PART') LIMIT 1; +-- +ok +== +SELECT suggestion, suggestion_start FROM sql_auto_complete('SELECT lag(col1) OVER (PARTITION BY col1, col2 ORD') LIMIT 1; +-- +ok +== +SELECT suggestion, suggestion_start FROM sql_auto_complete('SELECT sum(42) OVER (PARTITION BY col1, col2 ORDER BY col3 ROW') LIMIT 1; +-- +ok +== +SELECT suggestion, suggestion_start FROM sql_auto_complete('SELECT lead(l_orderkey) OVER win FR') LIMIT 1; +-- +ok +== +SELECT suggestion, suggestion_start FROM sql_auto_complete('SELECT lead(l_orderkey) OVER (win) FROM tbl WINDOW win AS (PART') LIMIT 1; +-- +ok +== diff --git a/parser/testdata/corpus/sql/function/blob/base64.test b/parser/testdata/corpus/sql/function/blob/base64.test new file mode 100644 index 0000000..7196e9d --- /dev/null +++ b/parser/testdata/corpus/sql/function/blob/base64.test @@ -0,0 +1,73 @@ +# source: test/sql/function/blob/base64.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +SELECT base64(encode('')) +-- +ok +== +SELECT base64(encode('a')) +-- +ok +== +SELECT base64(encode('ab')) +-- +ok +== +SELECT base64(encode('abc')) +-- +ok +== +SELECT base64(encode('üäabcdef')) +-- +ok +== +SELECT base64(encode('iJWERiuhjruhwuiehr8493231')) +-- +ok +== +SELECT base64(encode('abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ1234567890')) +-- +ok +== +SELECT to_base64(encode('base64 encoded string')); +-- +ok +== +SELECT from_base64(base64(encode(''))) +-- +ok +== +SELECT from_base64(base64(encode('a'))) +-- +ok +== +SELECT from_base64(base64(encode('ab'))) +-- +ok +== +SELECT from_base64(base64(encode('abc'))) +-- +ok +== +SELECT from_base64(base64(encode('iJWERiuhjruhwuiehr8493231'))) +-- +ok +== +SELECT from_base64(base64(encode('abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ1234567890'))) +-- +ok +== +select from_base64('AAAA'); +-- +ok +== +SELECT from_base64('ab'); +-- +ok +== +SELECT from_base64('üab'); +-- +ok +== diff --git a/parser/testdata/corpus/sql/function/blob/create_sort_key.test b/parser/testdata/corpus/sql/function/blob/create_sort_key.test new file mode 100644 index 0000000..12cfee4 --- /dev/null +++ b/parser/testdata/corpus/sql/function/blob/create_sort_key.test @@ -0,0 +1,181 @@ +# source: test/sql/function/blob/create_sort_key.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +SELECT * FROM integers ORDER BY create_sort_key(i, 'ASC NULLS LAST') +-- +ok +== +SELECT * FROM integers ORDER BY create_sort_key(i, 'ASC NULLS FIRST') +-- +ok +== +SELECT * FROM integers ORDER BY create_sort_key(i, 'DESC NULLS LAST') +-- +ok +== +SELECT * FROM integers ORDER BY create_sort_key(i, 'DESC NULLS FIRST') +-- +ok +== +INSERT INTO varchars VALUES ('hello'), ('hello' || chr(0) || chr(0)), ('world'), (''), (NULL) +-- +ok +== +SELECT * FROM varchars ORDER BY create_sort_key(v, 'ASC NULLS LAST') +-- +ok +== +SELECT * FROM varchars ORDER BY create_sort_key(v, 'ASC NULLS FIRST') +-- +ok +== +SELECT * FROM varchars ORDER BY create_sort_key(v, 'DESC NULLS LAST') +-- +ok +== +SELECT * FROM varchars ORDER BY create_sort_key(v, 'DESC NULLS FIRST') +-- +ok +== +CREATE TABLE int_list(l INT[]); +-- +ok +== +INSERT INTO int_list VALUES ([1, 2, 3]), ([]), ([1]), ([2]), ([NULL]), (NULL); +-- +ok +== +SELECT l FROM int_list ORDER BY create_sort_key(l, 'ASC NULLS LAST') +-- +ok +== +SELECT l FROM int_list ORDER BY create_sort_key(l, 'DESC NULLS LAST') +-- +ok +== +SELECT l FROM int_list ORDER BY create_sort_key(l, 'ASC NULLS FIRST') +-- +ok +== +SELECT l FROM int_list ORDER BY create_sort_key(l, 'DESC NULLS FIRST') +-- +ok +== +CREATE TABLE structs(s ROW(i INT, v VARCHAR)); +-- +ok +== +INSERT INTO structs VALUES ({'i': 42, v: 'hello'}), ({'i': 42, v: 'hello' || chr(0)}), ({'i': 43, v: ''}), (NULL), ({'i': 42, v: NULL}), ({'i': NULL, v: ''}) +-- +ok +== +SELECT * FROM structs ORDER BY create_sort_key(s, 'ASC NULLS LAST') +-- +ok +== +SELECT s.i, s.v FROM structs ORDER BY create_sort_key(s.i, 'ASC NULLS LAST', s.v, 'ASC NULLS LAST') +-- +ok +== +SELECT * FROM structs ORDER BY create_sort_key(s, 'DESC NULLS FIRST') +-- +ok +== +SELECT s.i, s.v FROM structs ORDER BY create_sort_key(s.i, 'DESC NULLS FIRST', s.v, 'DESC NULLS FIRST') +-- +ok +== +CREATE TABLE list_of_structs(s ROW(i INT, v VARCHAR)[]); +-- +ok +== +INSERT INTO list_of_structs VALUES +([{'i': 42, v: 'hello'}]), +([]), +([{'i': 42, v: 'hello'}, {'i': 84, v: ''}]), +([{'i': 43, v: ''}]), +(NULL), +([NULL]), +([{'i': 42, v: NULL}]), +([{'i': NULL, v: ''}]), +([{'i': 42, v: 'hello'}, {'i': 84, v: chr(0)}]), +([{'i': 42, v: 'hello'}, NULL, {'i': 84, v: ''}]) +-- +ok +== +SELECT * FROM list_of_structs ORDER BY create_sort_key(s, 'ASC NULLS LAST') +-- +ok +== +SELECT * FROM list_of_structs ORDER BY create_sort_key(s, 'DESC NULLS FIRST') +-- +ok +== +CREATE TABLE nested_lists(s INT[][]); +-- +ok +== +INSERT INTO nested_lists VALUES +([]), +([[], []]), +(NULL), +([NULL]), +([[NULL]]), +([[42, 84]]), +([[42], [84]]), +([[42], NULL, [84]]), +([[42], [NULL], [84]]), +([[1, 2, 3, 4, 5, 6, 7, 8, 9]]) +-- +ok +== +SELECT * FROM nested_lists ORDER BY create_sort_key(s, 'ASC NULLS LAST') +-- +ok +== +SELECT * FROM nested_lists ORDER BY create_sort_key(s, 'DESC NULLS FIRST') +-- +ok +== +CREATE TABLE blobs(b BLOB, c BLOB); +-- +ok +== +INSERT INTO blobs VALUES (NULL, NULL), ('hello\x00\x00\x00\x00\x00', NULL), ('hello', 'world'), ('hello\x01\x01\x01', 'world'), ('', ''), ('hello\x00\x00\x00\x00\x00', 'world'), ('hello\x00', NULL) +-- +ok +== +SELECT b FROM blobs ORDER BY create_sort_key(b, 'ASC NULLS LAST') +-- +ok +== +SELECT b FROM blobs ORDER BY create_sort_key(b, 'DESC NULLS FIRST') +-- +ok +== +SELECT * FROM blobs ORDER BY create_sort_key(b, 'ASC NULLS LAST', c, 'ASC NULLS LAST') +-- +ok +== +SELECT * FROM blobs ORDER BY create_sort_key(b, 'DESC NULLS FIRST', c, 'DESC NULLS FIRST') +-- +ok +== +CREATE TABLE arrays(l INT[3]); +-- +ok +== +INSERT INTO arrays VALUES ([1, 2, 3]), (NULL), ([NULL, NULL, NULL]), ([1, NULL, 3]), ([2, 3, 4]); +-- +ok +== +SELECT l FROM arrays ORDER BY create_sort_key(l, 'ASC NULLS LAST') +-- +ok +== +SELECT l FROM arrays ORDER BY create_sort_key(l, 'DESC NULLS FIRST') +-- +ok +== diff --git a/parser/testdata/corpus/sql/function/blob/create_sort_key_blob_escapes.test b/parser/testdata/corpus/sql/function/blob/create_sort_key_blob_escapes.test new file mode 100644 index 0000000..9afc9aa --- /dev/null +++ b/parser/testdata/corpus/sql/function/blob/create_sort_key_blob_escapes.test @@ -0,0 +1,89 @@ +# source: test/sql/function/blob/create_sort_key_blob_escapes.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +SELECT hex(create_sort_key('\xAA\x00\xBB\x01\xCC'::BLOB, 'ASC NULLS LAST')) +-- +ok +== +SELECT hex(create_sort_key('\xAA\x00\xBB\x01\xCC'::BLOB, 'DESC NULLS LAST')) +-- +ok +== +CREATE TABLE sweep AS +SELECT len, pos, esc, + CASE WHEN pos >= len THEN repeat('\xAA'::BLOB, len) + ELSE repeat('\xAA'::BLOB, pos) || esc || repeat('\xAA'::BLOB, len - pos - 1) + END AS b +FROM range(0, 81) l(len), range(0, 81) p(pos), + (VALUES ('\x00'::BLOB), ('\x01'::BLOB), ('\x02'::BLOB)) e(esc) +WHERE pos <= len; +-- +ok +== +SELECT count(*) FROM sweep +WHERE octet_length(create_sort_key(b, 'ASC NULLS LAST')) <> + octet_length(b) + CASE WHEN pos < len AND esc <= '\x01'::BLOB THEN 1 ELSE 0 END + 2; +-- +ok +== +SELECT count(*) FROM ( + SELECT row_number() OVER (ORDER BY b ASC, len, pos, esc) AS by_blob, + row_number() OVER (ORDER BY create_sort_key(b, 'ASC NULLS LAST') ASC, len, pos, esc) AS by_key + FROM sweep +) WHERE by_blob <> by_key; +-- +ok +== +SELECT count(*) FROM ( + SELECT row_number() OVER (ORDER BY b DESC, len, pos, esc) AS by_blob, + row_number() OVER (ORDER BY create_sort_key(b, 'DESC NULLS LAST') ASC, len, pos, esc) AS by_key + FROM sweep +) WHERE by_blob <> by_key; +-- +ok +== +CREATE TABLE sweep_pairs AS +SELECT len, pos, repeat('\xAA'::BLOB, pos) || '\x01\x00'::BLOB || repeat('\xAA'::BLOB, len - pos - 2) AS b +FROM range(2, 81) l(len), range(0, 81) p(pos) +WHERE pos + 2 <= len; +-- +ok +== +SELECT count(*) FROM sweep_pairs +WHERE octet_length(create_sort_key(b, 'DESC NULLS FIRST')) <> octet_length(b) + 4; +-- +ok +== +SELECT count(*) FROM ( + SELECT row_number() OVER (ORDER BY b ASC, len, pos) AS by_blob, + row_number() OVER (ORDER BY create_sort_key(b, 'ASC NULLS FIRST') ASC, len, pos) AS by_key + FROM sweep_pairs +) WHERE by_blob <> by_key; +-- +ok +== +SELECT count(*) FROM range(0, 81) l(len) +WHERE octet_length(create_sort_key(repeat('\x00\x01'::BLOB, len), 'ASC NULLS LAST')) <> 4 * len + 2; +-- +ok +== +CREATE TABLE strings AS +SELECT len, repeat(chr(255), len) || repeat('a', len) AS s FROM range(0, 81) l(len); +-- +ok +== +SELECT count(*) FROM strings +WHERE octet_length(create_sort_key(s, 'ASC NULLS LAST')) <> octet_length(encode(s)) + 2; +-- +ok +== +SELECT count(*) FROM ( + SELECT row_number() OVER (ORDER BY s ASC, len) AS by_string, + row_number() OVER (ORDER BY create_sort_key(s, 'ASC NULLS LAST') ASC, len) AS by_key + FROM strings +) WHERE by_string <> by_key; +-- +ok +== diff --git a/parser/testdata/corpus/sql/function/blob/encode.test b/parser/testdata/corpus/sql/function/blob/encode.test new file mode 100644 index 0000000..c81faeb --- /dev/null +++ b/parser/testdata/corpus/sql/function/blob/encode.test @@ -0,0 +1,45 @@ +# source: test/sql/function/blob/encode.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +SELECT encode('ü') +-- +ok +== +SELECT decode(encode('ü')) +-- +ok +== +SELECT decode('\xF0\x9F\xA6\x86'::BLOB) +-- +ok +== +SELECT decode('\x00'::BLOB) +-- +ok +== +SELECT decode('\xFF'::BLOB) +-- +ok +== +SELECT decode(encode(a)) || a from (values ('hello'), ('world')) tbl(a); +-- +ok +== +CREATE TABLE invalid_blob(b BLOB); +-- +ok +== +INSERT INTO invalid_blob VALUES ('AAAAAAAAAAAAAAAAAAAA\xC0'::BLOB); +-- +ok +== +SELECT decode(b, 'replace') FROM invalid_blob; +-- +ok +== +SELECT hex(b) FROM invalid_blob; +-- +ok +== diff --git a/parser/testdata/corpus/sql/function/blob/test_blob_array_slice.test b/parser/testdata/corpus/sql/function/blob/test_blob_array_slice.test new file mode 100644 index 0000000..9ac174e --- /dev/null +++ b/parser/testdata/corpus/sql/function/blob/test_blob_array_slice.test @@ -0,0 +1,49 @@ +# source: test/sql/function/blob/test_blob_array_slice.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +select array_slice(blob '\x00\x01\x02\x03\x04\x05', 2, 4) +-- +ok +== +select array_slice(blob '\x00\x01\x02\x03\x04\x05', 0, 2) +-- +ok +== +select (blob '\x00\x01\x02\x03\x04\x05'::BLOB)[2:4] +-- +ok +== +select array_slice(blob '\x00\x01\x02\x03\x04\x05', 4, 10) +-- +ok +== +select octet_length(array_slice(blob '\x00\x01\x02\x03\x04\x05', 4, 3)) +-- +ok +== +select array_slice(blob '\x00\x01\x02\x03\x04\x05', 2,-2) +-- +ok +== +select array_slice(blob '\x00\x01\x02\x03\x04\x05', -4, -2) +-- +ok +== +select array_slice(blob '\x00\xF0\x9F\xA6\x86\x00', 2, 3) +-- +ok +== +select array_slice(blob '\x00\xF0\x9F\xA6\x86\x00', 4, 6) +-- +ok +== +select array_slice(NULL::BLOB, 4, 6) +-- +ok +== +select array_slice('hello world', 1, 8, 2); +-- +ok +== diff --git a/parser/testdata/corpus/sql/function/blob/test_concat_blob.test b/parser/testdata/corpus/sql/function/blob/test_concat_blob.test new file mode 100644 index 0000000..7dc92a7 --- /dev/null +++ b/parser/testdata/corpus/sql/function/blob/test_concat_blob.test @@ -0,0 +1,21 @@ +# source: test/sql/function/blob/test_concat_blob.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +SELECT blob 'aaa\x80' || blob 'aaa\x80' +-- +ok +== +SELECT typeof(blob 'aaa\x80' || blob 'aaa\x80') +-- +ok +== +SELECT concat(blob 'aaa\x80', blob 'aaa\x80') +-- +ok +== +SELECT typeof(concat(blob 'aaa\x80', blob 'aaa\x80')) +-- +ok +== diff --git a/parser/testdata/corpus/sql/function/date/date_add.test b/parser/testdata/corpus/sql/function/date/date_add.test new file mode 100644 index 0000000..522c410 --- /dev/null +++ b/parser/testdata/corpus/sql/function/date/date_add.test @@ -0,0 +1,17 @@ +# source: test/sql/function/date/date_add.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +INSERT INTO dates VALUES (DATE '1992-01-01') +-- +ok +== +SELECT DATE_ADD(DATE '2008-12-25', INTERVAL 5 DAY) AS five_days_later; +-- +ok +== +SELECT DATE_ADD(TIMESTAMP '2008-12-25 00:00:00', INTERVAL 5 DAY) AS five_days_later; +-- +ok +== diff --git a/parser/testdata/corpus/sql/function/date/date_diff_extreme_dates.test b/parser/testdata/corpus/sql/function/date/date_diff_extreme_dates.test new file mode 100644 index 0000000..baa9970 --- /dev/null +++ b/parser/testdata/corpus/sql/function/date/date_diff_extreme_dates.test @@ -0,0 +1,33 @@ +# source: test/sql/function/date/date_diff_extreme_dates.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +SELECT datediff('week', DATE '-5877641-06-25', DATE '5881580-07-10'); +-- +ok +== +SELECT datediff('day', DATE '-5877641-06-25', DATE '5881580-07-10'); +-- +ok +== +SELECT datediff('day', DATE '-5877641-06-25', DATE '5881580-07-10') / 7; +-- +ok +== +SELECT datediff('week', DATE '5881580-07-10', DATE '-5877641-06-25'); +-- +ok +== +SELECT datediff('microsecond', DATE '-290000-01-01', DATE '290000-01-01'); +-- +ok +== +SELECT datediff('microsecond', DATE '2000-01-01', DATE '2000-01-02'); +-- +ok +== +SELECT datediff('microsecond', DATE '2000-01-02', DATE '2000-01-01'); +-- +ok +== diff --git a/parser/testdata/corpus/sql/function/date/date_part_stats.test b/parser/testdata/corpus/sql/function/date/date_part_stats.test new file mode 100644 index 0000000..9f701ea --- /dev/null +++ b/parser/testdata/corpus/sql/function/date/date_part_stats.test @@ -0,0 +1,149 @@ +# source: test/sql/function/date/date_part_stats.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +SELECT EXTRACT(year FROM d) FROM dates; +-- +ok +== +SELECT EXTRACT(month FROM d) FROM dates; +-- +ok +== +SELECT EXTRACT(day FROM d) FROM dates; +-- +ok +== +SELECT EXTRACT(decade FROM d) FROM dates; +-- +ok +== +SELECT EXTRACT(century FROM d) FROM dates; +-- +ok +== +SELECT EXTRACT(millennium FROM d) FROM dates; +-- +ok +== +SELECT EXTRACT(microseconds FROM d) FROM dates; +-- +ok +== +SELECT EXTRACT(milliseconds FROM d) FROM dates; +-- +ok +== +SELECT EXTRACT(second FROM d) FROM dates; +-- +ok +== +SELECT EXTRACT(minute FROM d) FROM dates; +-- +ok +== +SELECT EXTRACT(hour FROM d) FROM dates; +-- +ok +== +SELECT EXTRACT(epoch FROM d) FROM dates; +-- +ok +== +SELECT EXTRACT(dow FROM d) FROM dates; +-- +ok +== +SELECT EXTRACT(isodow FROM d) FROM dates; +-- +ok +== +SELECT EXTRACT(week FROM d) FROM dates; +-- +ok +== +SELECT EXTRACT(doy FROM d) FROM dates; +-- +ok +== +SELECT EXTRACT(quarter FROM d) FROM dates; +-- +ok +== +SELECT YEARWEEK(d) FROM dates; +-- +ok +== +SELECT DAYOFMONTH(d) FROM dates; +-- +ok +== +SELECT WEEKDAY(d) FROM dates; +-- +ok +== +SELECT WEEKOFYEAR(d) FROM dates; +-- +ok +== +INSERT INTO dates VALUES (DATE '1992-01-01'), (DATE '2000-12-31'); +-- +ok +== +CREATE TABLE expected_result AS FROM (VALUES + ('year', 1992, 2000), + ('month', 1, 12), + ('day', 1, 31), + ('decade', 199, 200), + ('century', 20, 20), + ('millenium', 2, 2), + ('microseconds', 0, 59999999), + ('milliseconds', 0, 59999), + ('second', 0, 59), + ('minute', 0, 59), + ('hour', 0, 24), + ('dow', 0, 6), + ('week', 1, 53), + ('doy', 1, 366), + ('quarter', 1, 4), + ('yearweek', 199201, 200052), + ('dayofmonth', 1, 31), + ('weekday', 0, 6), + ('weekofyear', 1, 53) + ) t(component, min, max) +-- +ok +== +SELECT + CASE WHEN stats.min = expected_result.min AND stats.max = expected_result.max THEN NULL ELSE {'stats': stats, 'expected_result': expected_result} END +FROM ( + SELECT STATS(EXTRACT({component} FROM d)) AS stats, (SELECT expected_result FROM expected_result WHERE component = '{component}') expected_result FROM dates LIMIT 1 +) +-- +error: Parser Error: syntax error at or near "{" +== +CREATE TABLE t0(c0 {type}); +-- +error: Parser Error: syntax error at or near "{" +== +INSERT INTO t0(c0) VALUES ('-infinity'), ('infinity'); +-- +ok +== +SELECT (t0.c0), WEEKOFYEAR(t0.c0), WEEKOFYEAR(t0.c0) IS NULL FROM t0 ORDER BY c0; +-- +ok +== +SELECT (t0.c0), WEEKDAY(t0.c0), WEEKDAY(t0.c0) IS NULL FROM t0 ORDER BY c0; +-- +ok +== +SELECT (t0.c0), DAYOFMONTH(t0.c0), DAYOFMONTH(t0.c0) IS NULL FROM t0 ORDER BY c0; +-- +ok +== +SELECT WEEKOFYEAR(t0.c0) IS NOT NULL FROM t0; +-- +ok +== diff --git a/parser/testdata/corpus/sql/function/date/date_trunc_4202.test b/parser/testdata/corpus/sql/function/date/date_trunc_4202.test new file mode 100644 index 0000000..56c8e86 --- /dev/null +++ b/parser/testdata/corpus/sql/function/date/date_trunc_4202.test @@ -0,0 +1,29 @@ +# source: test/sql/function/date/date_trunc_4202.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +create table t1 (date timestamp); +-- +ok +== +insert into t1 values ('2016-12-16T00:00:00.000Z'); +-- +ok +== +insert into t1 values ('2020-02-17T23:59:59.998Z'); +-- +ok +== +insert into t1 values ('2020-02-17T23:59:59.999Z'); +-- +ok +== +insert into t1 values ('2020-02-18T00:00:00.000Z'); +-- +ok +== +select * from t1 WHERE (date_trunc('DAY', T1.date) < ('2020-02-17T23:59:59.999Z'::timestamp)) ORDER BY 1; +-- +ok +== diff --git a/parser/testdata/corpus/sql/function/date/date_trunc_stats.test b/parser/testdata/corpus/sql/function/date/date_trunc_stats.test new file mode 100644 index 0000000..7c7ea3c --- /dev/null +++ b/parser/testdata/corpus/sql/function/date/date_trunc_stats.test @@ -0,0 +1,44 @@ +# source: test/sql/function/date/date_trunc_stats.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +CREATE table T1(A0 TIMESTAMP) +-- +ok +== +SELECT date_trunc('DAY', A0) FROM T1 +-- +ok +== +SELECT datetrunc('milliseconds', DATE '-2005205-7-28'); +-- +ok +== +CREATE TABLE events as FROM (VALUES + (TIMESTAMP '1992-09-20 20:38:40', 'Event A'), + (TIMESTAMP '1992-09-20 21:45:15', 'Event B'), + (TIMESTAMP '1992-09-20 22:15:30', 'Event C')) t(event_time, event_name); +-- +ok +== +CREATE TABLE users as FROM (VALUES + (1, TIMESTAMP '1992-09-20 20:00:00'), + (2, TIMESTAMP '1992-09-20 22:05:00')) t(user_id, created_at); +-- +ok +== +SELECT + u.user_id, + date_trunc('minute', e.event_time) AS truncated_minute +FROM + users u +LEFT JOIN + events e +ON + u.user_id = 1 +ORDER BY + e.event_time ASC; +-- +ok +== diff --git a/parser/testdata/corpus/sql/function/date/test_date_part.test b/parser/testdata/corpus/sql/function/date/test_date_part.test new file mode 100644 index 0000000..df27e33 --- /dev/null +++ b/parser/testdata/corpus/sql/function/date/test_date_part.test @@ -0,0 +1,264 @@ +# source: test/sql/function/date/test_date_part.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +CREATE TABLE dates(d DATE, s VARCHAR); +-- +ok +== +INSERT INTO dates VALUES + ('1992-01-01', 'year'), + ('1992-03-03', 'month'), + ('1992-05-05', 'day'), + ('2022-01-01', 'isoyear'), + ('044-03-15 (BC)', 'millennium'), + ('infinity', 'century'), + ('-infinity', 'decade'), + (NULL, 'weekday'), +; +-- +ok +== +CREATE TABLE specifiers (specifier VARCHAR); +-- +ok +== +INSERT INTO specifiers VALUES ('{partcode}'); +-- +ok +== +SELECT date_part(NULL::VARCHAR, NULL::TIMESTAMP) FROM dates; +-- +ok +== +SELECT date_part(s, NULL::TIMESTAMP) FROM dates; +-- +ok +== +SELECT date_part(NULL, d) FROM dates; +-- +ok +== +SELECT date_part(s, DATE '1992-01-01') FROM dates; +-- +ok +== +SELECT date_part('year', d) FROM dates; +-- +ok +== +SELECT date_part('isoyear', d) FROM dates; +-- +ok +== +SELECT date_part(s, d) FROM dates; +-- +ok +== +SELECT date_part('era', d) FROM dates; +-- +ok +== +SELECT date_part('julian', d) FROM dates; +-- +ok +== +SELECT date_part('timezone', d) FROM dates; +-- +ok +== +SELECT date_part('timezone_hour', d) FROM dates; +-- +ok +== +SELECT date_part('timezone_minute', d) FROM dates; +-- +ok +== +SELECT date_part(NULL, d::TIMESTAMP) FROM dates; +-- +ok +== +SELECT date_part(s, TIMESTAMP '1992-01-01') FROM dates; +-- +ok +== +SELECT date_part('year', d::TIMESTAMP) FROM dates; +-- +ok +== +SELECT date_part('isoyear', d::TIMESTAMP) FROM dates; +-- +ok +== +SELECT date_part(s, d::TIMESTAMP) FROM dates; +-- +ok +== +SELECT date_part('era', d::TIMESTAMP) FROM dates; +-- +ok +== +SELECT date_part('timezone', d::TIMESTAMP) FROM dates; +-- +ok +== +SELECT date_part('timezone_hour', d::TIMESTAMP) FROM dates; +-- +ok +== +SELECT date_part('timezone_minute', d::TIMESTAMP) FROM dates; +-- +ok +== +select date_part('year', dt::DATE) * 10, +from generate_series('2050-01-01'::date,'2051-12-31'::date,interval 1 day) t(dt) +where dt = '2050-12-31'; +-- +ok +== +select timezone(interval '4 minute', '12:15:37.123456-08'::TIMETZ); +-- +ok +== +SELECT LAST_DAY(DATE '1900-02-12'), LAST_DAY(DATE '1992-02-12'), LAST_DAY(DATE '2000-02-12'); +-- +ok +== +SELECT LAST_DAY(d) FROM dates; +-- +ok +== +SELECT LAST_DAY(d::timestamp) FROM dates; +-- +ok +== +SELECT MONTHNAME(d) FROM dates; +-- +ok +== +SELECT DAYNAME(d) FROM dates; +-- +ok +== +SELECT JULIAN(d) FROM dates; +-- +ok +== +select +date_part('quarter', DATE '1992-01-20'), +date_part('quarter', DATE '1992-02-20'), +date_part('quarter', DATE '1992-03-20'), +date_part('quarter', DATE '1992-04-20'), +date_part('quarter', DATE '1992-05-20'), +date_part('quarter', DATE '1992-06-20'), +date_part('quarter', DATE '1992-07-20'), +date_part('quarter', DATE '1992-08-20'), +date_part('quarter', DATE '1992-09-20'), +date_part('quarter', DATE '1992-10-20'), +date_part('quarter', DATE '1992-11-20'), +date_part('quarter', DATE '1992-12-20') +-- +ok +== +SELECT d, DATE_PART('{partcode}', d) AS p, {partcode}(d) AS f +FROM dates +WHERE p IS DISTINCT FROM f; +-- +error: Parser Error: syntax error at or near "}" +== +SELECT d, epoch_ns(d) +FROM dates +WHERE d != '0044-03-15 (BC)' OR d IS NULL +ORDER BY ALL; +-- +ok +== +SELECT d, epoch_us(d) FROM dates ORDER BY ALL; +-- +ok +== +SELECT d, epoch_ms(d) FROM dates ORDER BY ALL; +-- +ok +== +SELECT d, nanosecond(d) FROM dates ORDER BY ALL; +-- +ok +== +SELECT d, DATE_PART('{partcode}', d) AS p, DATE_PART(['{partcode}'], d) AS st +FROM dates +WHERE p IS DISTINCT FROM st['{partcode}']; +-- +ok +== +SELECT d, DATE_PART(['year', 'month', 'day', 'epoch'], d) AS parts +FROM dates +ORDER BY 1; +-- +ok +== +SELECT d, DATE_PART(['era', 'millennium', 'century', 'decade', 'quarter'], d) AS parts +FROM dates +ORDER BY 1; +-- +ok +== +SELECT d, DATE_PART(['weekday', 'isodow', 'doy', 'julian'], d) AS parts +FROM dates +ORDER BY 1; +-- +ok +== +SELECT DATE_PART(['weekday', 'isodow', 'doy', 'julian'], '2022-01-01'::DATE) AS parts +-- +ok +== +SELECT d, DATE_PART(['isoyear', 'week', 'yearweek'], d) AS parts +FROM dates +ORDER BY 1; +-- +ok +== +SELECT d, DATE_PART(['year', 'month', 'day'], d) AS parts +FROM dates +WHERE s = 'day' +ORDER BY 1; +-- +ok +== +SELECT d, DATE_PART(['{datepart}'], d) AS parts +FROM dates +WHERE parts['{datepart}'] <> 0 +ORDER BY 1; +-- +ok +== +SELECT DATE_PART(['hour', 'minute'], '2023-09-17'::DATE) AS parts +-- +ok +== +SELECT DATE_PART(specifier, '{special}'::{datatype}) AS result +FROM specifiers +WHERE result IS NOT NULL +-- +error: Parser Error: syntax error at or near "{" +== +SELECT {unary}('{special}'::{datatype}); +-- +error: Parser Error: syntax error at or near "}" +== +SELECT DATE_PART(['year', 'month', 'day', 'epoch'], '{special}'::{datatype}) AS parts +-- +error: Parser Error: syntax error at or near "{" +== +WITH cte AS ( + SELECT NULL::VARCHAR part + FROM range(1) +) +SELECT date_part(part, TIMESTAMP '2019-01-06 04:03:02') +FROM cte +-- +ok +== diff --git a/parser/testdata/corpus/sql/function/date/test_date_trunc.test b/parser/testdata/corpus/sql/function/date/test_date_trunc.test new file mode 100644 index 0000000..bf612c5 --- /dev/null +++ b/parser/testdata/corpus/sql/function/date/test_date_trunc.test @@ -0,0 +1,197 @@ +# source: test/sql/function/date/test_date_trunc.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +CREATE TABLE timestamps(d TIMESTAMP, s VARCHAR); +-- +ok +== +INSERT INTO dates VALUES + ('1992-12-02', 'year'), + ('1993-03-03', 'month'), + ('1994-05-05', 'day'), + ('2022-01-01', 'isoyear') +; +-- +ok +== +INSERT INTO timestamps VALUES + ('-infinity', 'year'), + ('1992-02-02 02:02:03', 'millennium'), + ('1992-02-02 02:02:03', 'century'), + ('1992-02-02 02:02:03', 'decade'), + ('1992-02-02 02:02:03', 'year'), + ('1992-02-02 02:02:03', 'quarter'), + ('1992-02-02 02:02:03', 'month'), + ('1992-02-02 02:02:03', 'week'), + ('1992-02-02 02:02:03', 'day'), + ('1992-02-02 02:02:03', 'hour'), + ('1992-02-02 02:02:03', 'minute'), + ('1992-02-02 02:02:03', 'second'), + ('1992-02-02 02:02:03', 'milliseconds'), + ('1992-02-02 02:02:03', 'microseconds'), + ('infinity', 'month'), +; +-- +ok +== +SELECT date_trunc(NULL::VARCHAR, NULL::TIMESTAMP) FROM dates; +-- +ok +== +SELECT date_trunc(s, NULL::TIMESTAMP) FROM dates; +-- +ok +== +SELECT date_trunc(NULL, d) FROM dates; +-- +ok +== +SELECT date_trunc(NULL::VARCHAR, NULL::TIMESTAMP) FROM timestamps LIMIT 3; +-- +ok +== +SELECT date_trunc(s, NULL::TIMESTAMP) FROM timestamps LIMIT 3; +-- +ok +== +SELECT date_trunc(NULL, d) FROM timestamps LIMIT 3; +-- +ok +== +SELECT date_trunc('month', DATE '1992-02-02') FROM dates LIMIT 1; +-- +ok +== +SELECT date_trunc(s, d) FROM dates; +-- +ok +== +select date_trunc('{datepart}', '2022-08-15 07:52:55'::{temporal}); +-- +error: Parser Error: syntax error at or near "{" +== +select date_trunc('hour', '2022-08-15 07:52:55'::{temporal}); +-- +error: Parser Error: syntax error at or near "{" +== +SELECT date_trunc('minute', TIMESTAMP '1992-02-02 04:03:02') FROM timestamps LIMIT 1; +-- +ok +== +SELECT date_trunc(s, d) FROM timestamps; +-- +ok +== +SELECT date_trunc(s, CAST(d as DATE)) FROM timestamps; +-- +ok +== +SELECT date_trunc('{unit}', '-infinity'::TIMESTAMP), date_trunc('{unit}', 'infinity'::TIMESTAMP); +-- +ok +== +SELECT date_trunc('week', TIMESTAMP '2020-01-01 04:03:02') FROM timestamps LIMIT 1; +-- +ok +== +SELECT date_trunc('week', TIMESTAMP '2019-01-06 04:03:02') FROM timestamps LIMIT 1; +-- +ok +== +SELECT date_trunc('yearweek', TIMESTAMP '2020-01-01 04:03:02') FROM timestamps LIMIT 1; +-- +ok +== +SELECT date_trunc('yearweek', TIMESTAMP '2019-01-06 04:03:02') FROM timestamps LIMIT 1; +-- +ok +== +SELECT date_trunc('quarter', TIMESTAMP '2020-12-02 04:03:02') FROM timestamps LIMIT 1; +-- +ok +== +SELECT date_trunc('quarter', TIMESTAMP '2019-01-06 04:03:02') FROM timestamps LIMIT 1; +-- +ok +== +SELECT date_trunc('millennium', TIMESTAMP '1996-01-06 04:03:02') FROM timestamps LIMIT 1; +-- +ok +== +SELECT date_trunc('century', TIMESTAMP '2019-01-06 04:03:02') FROM timestamps LIMIT 1; +-- +ok +== +SELECT date_trunc('decade', TIMESTAMP '2019-01-06 04:03:02') FROM timestamps LIMIT 1; +-- +ok +== +SELECT date_trunc('year', TIMESTAMP '2019-01-06 04:03:02') FROM timestamps LIMIT 1; +-- +ok +== +SELECT date_trunc('day', TIMESTAMP '2019-01-06 04:03:02') FROM timestamps LIMIT 1; +-- +ok +== +SELECT date_trunc('hour', TIMESTAMP '2019-01-06 04:03:02') FROM timestamps LIMIT 1; +-- +ok +== +SELECT date_trunc('milliseconds', TIMESTAMP '2019-01-06 04:03:02.123456') FROM timestamps LIMIT 1; +-- +ok +== +SELECT date_trunc('microseconds', TIMESTAMP '2019-01-06 04:03:02.123456'); +-- +ok +== +SELECT date_trunc('epoch', TIMESTAMP '2019-01-06 04:03:02.5') FROM timestamps LIMIT 1; +-- +ok +== +SELECT d::DATE, DATE_TRUNC('isoyear', d)::DATE +FROM generate_series('2000-01-01'::TIMESTAMP, '2023-01-01'::TIMESTAMP, INTERVAL 1 YEAR) tbl(d); +-- +ok +== +SELECT date_trunc('duck', TIMESTAMP '2019-01-06 04:03:02') FROM timestamps LIMIT 1; +-- +ok +== +SELECT s.min, s.max, s.has_null, s.has_no_null FROM (SELECT stats(date_trunc('year', d)) s FROM dates LIMIT 1); +-- +ok +== +SELECT s.min, s.max, s.has_null, s.has_no_null FROM (SELECT stats(date_trunc('quarter', d)) s FROM dates LIMIT 1); +-- +ok +== +SELECT s.min, s.max, s.has_null, s.has_no_null FROM (SELECT stats(date_trunc('month', d)) s FROM dates LIMIT 1); +-- +ok +== +SELECT s.min, s.max, s.has_null, s.has_no_null FROM (SELECT stats(date_trunc('day', d)) s FROM dates LIMIT 1); +-- +ok +== +SELECT s.min, s.max, s.has_null, s.has_no_null FROM (SELECT stats(date_trunc('{daypart}', d)) s FROM timestamps LIMIT 1); +-- +ok +== +WITH cte AS ( + SELECT NULL::VARCHAR part + FROM range(1) +) +SELECT date_trunc(part, TIMESTAMP '2019-01-06 04:03:02') +FROM cte +-- +ok +== +from values ('2024-01-15 15:30:00'::timestamp) as a(t) +where date_trunc('day', t) = '2024-01-15 12:30:00'; +-- +ok +== diff --git a/parser/testdata/corpus/sql/function/date/test_extract.test b/parser/testdata/corpus/sql/function/date/test_extract.test new file mode 100644 index 0000000..28bde2f --- /dev/null +++ b/parser/testdata/corpus/sql/function/date/test_extract.test @@ -0,0 +1,85 @@ +# source: test/sql/function/date/test_extract.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +CREATE TABLE dates(i DATE) +-- +ok +== +INSERT INTO dates VALUES ('1993-08-14'), (NULL) +-- +ok +== +SELECT EXTRACT(year FROM i) FROM dates +-- +ok +== +SELECT EXTRACT(month FROM i) FROM dates +-- +ok +== +SELECT EXTRACT(quarter FROM i) FROM dates +-- +ok +== +SELECT EXTRACT(day FROM i) FROM dates +-- +ok +== +SELECT EXTRACT(decade FROM i) FROM dates +-- +ok +== +SELECT EXTRACT(century FROM i) FROM dates +-- +ok +== +SELECT EXTRACT(DOW FROM i) FROM dates +-- +ok +== +SELECT EXTRACT(DOY FROM i) FROM dates +-- +ok +== +SELECT EXTRACT(epoch FROM i) FROM dates +-- +ok +== +SELECT EXTRACT(ISODOW FROM i) FROM dates +-- +ok +== +SELECT EXTRACT(WEEK FROM i) FROM dates +-- +ok +== +SELECT EXTRACT(YEARWEEK FROM i) FROM dates +-- +ok +== +SELECT EXTRACT(millennium FROM i) FROM dates +-- +ok +== +SELECT EXTRACT(second FROM i) FROM dates +-- +ok +== +SELECT EXTRACT(minute FROM i) FROM dates +-- +ok +== +SELECT EXTRACT(hour FROM i) FROM dates +-- +ok +== +SELECT EXTRACT(milliseconds FROM i) FROM dates +-- +ok +== +SELECT EXTRACT(microsecond FROM i) FROM dates +-- +ok +== diff --git a/parser/testdata/corpus/sql/function/date/test_extract_edge_cases.test b/parser/testdata/corpus/sql/function/date/test_extract_edge_cases.test new file mode 100644 index 0000000..ae83711 --- /dev/null +++ b/parser/testdata/corpus/sql/function/date/test_extract_edge_cases.test @@ -0,0 +1,269 @@ +# source: test/sql/function/date/test_extract_edge_cases.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +SELECT EXTRACT(century FROM cast('2000-10-10' AS DATE)); +-- +ok +== +SELECT EXTRACT(century FROM cast('2001-10-10' AS DATE)); +-- +ok +== +SELECT EXTRACT(millennium FROM cast('2000-10-10' AS DATE)); +-- +ok +== +SELECT EXTRACT(millennium FROM cast('2001-10-10' AS DATE)); +-- +ok +== +SELECT EXTRACT(dow FROM cast('1970-01-01' AS DATE) + 0); +-- +ok +== +SELECT EXTRACT(dow FROM cast('1970-01-01' AS DATE) - 0); +-- +ok +== +SELECT EXTRACT(dow FROM cast('1970-01-01' AS DATE) + 1); +-- +ok +== +SELECT EXTRACT(dow FROM cast('1970-01-01' AS DATE) - 1); +-- +ok +== +SELECT EXTRACT(dow FROM cast('1970-01-01' AS DATE) + 2); +-- +ok +== +SELECT EXTRACT(dow FROM cast('1970-01-01' AS DATE) - 2); +-- +ok +== +SELECT EXTRACT(dow FROM cast('1970-01-01' AS DATE) + 3); +-- +ok +== +SELECT EXTRACT(dow FROM cast('1970-01-01' AS DATE) - 3); +-- +ok +== +SELECT EXTRACT(dow FROM cast('1970-01-01' AS DATE) + 4); +-- +ok +== +SELECT EXTRACT(dow FROM cast('1970-01-01' AS DATE) - 4); +-- +ok +== +SELECT EXTRACT(dow FROM cast('1970-01-01' AS DATE) + 5); +-- +ok +== +SELECT EXTRACT(dow FROM cast('1970-01-01' AS DATE) - 5); +-- +ok +== +SELECT EXTRACT(dow FROM cast('1970-01-01' AS DATE) + 6); +-- +ok +== +SELECT EXTRACT(dow FROM cast('1970-01-01' AS DATE) - 6); +-- +ok +== +SELECT EXTRACT(dow FROM cast('1793-05-26' AS DATE)); +-- +ok +== +SELECT EXTRACT(isodow FROM cast('1793-05-26' AS DATE)); +-- +ok +== +SELECT EXTRACT(week FROM cast('2005-01-01' AS DATE)); +-- +ok +== +SELECT EXTRACT(week FROM cast('2006-01-01' AS DATE)); +-- +ok +== +SELECT EXTRACT(week FROM cast('2007-01-01' AS DATE)); +-- +ok +== +SELECT EXTRACT(week FROM cast('2008-01-01' AS DATE)); +-- +ok +== +SELECT EXTRACT(week FROM cast('2009-01-01' AS DATE)); +-- +ok +== +SELECT EXTRACT(week FROM cast('2010-01-01' AS DATE)); +-- +ok +== +SELECT EXTRACT(week FROM cast('2007-01-01' AS DATE) + 0); +-- +ok +== +SELECT EXTRACT(week FROM cast('2007-01-01' AS DATE) + 7); +-- +ok +== +SELECT EXTRACT(week FROM cast('2007-01-01' AS DATE) + 14); +-- +ok +== +SELECT EXTRACT(week FROM cast('2007-01-01' AS DATE) + 21); +-- +ok +== +SELECT EXTRACT(week FROM cast('2007-01-01' AS DATE) + 28); +-- +ok +== +SELECT EXTRACT(week FROM cast('2007-01-01' AS DATE) + 35); +-- +ok +== +SELECT EXTRACT(week FROM cast('2007-01-01' AS DATE) + 42); +-- +ok +== +SELECT EXTRACT(week FROM cast('2007-01-01' AS DATE) + 49); +-- +ok +== +SELECT EXTRACT(week FROM cast('2007-01-01' AS DATE) + 56); +-- +ok +== +SELECT EXTRACT(week FROM cast('2007-01-01' AS DATE) + 63); +-- +ok +== +SELECT EXTRACT(week FROM cast('2007-01-01' AS DATE) + 70); +-- +ok +== +SELECT EXTRACT(week FROM cast('2007-01-01' AS DATE) + 77); +-- +ok +== +SELECT EXTRACT(week FROM cast('2007-01-01' AS DATE) + 84); +-- +ok +== +SELECT EXTRACT(week FROM cast('2007-01-01' AS DATE) + 91); +-- +ok +== +SELECT EXTRACT(week FROM cast('2007-01-01' AS DATE) + 98); +-- +ok +== +SELECT EXTRACT(week FROM cast('2007-01-01' AS DATE) + 105); +-- +ok +== +SELECT EXTRACT(week FROM cast('2007-01-01' AS DATE) + 112); +-- +ok +== +SELECT EXTRACT(week FROM cast('2007-01-01' AS DATE) + 119); +-- +ok +== +SELECT EXTRACT(week FROM cast('2007-01-01' AS DATE) + 126); +-- +ok +== +SELECT EXTRACT(week FROM cast('2007-01-01' AS DATE) + 133); +-- +ok +== +SELECT EXTRACT(week FROM cast('2007-01-01' AS DATE) + 140); +-- +ok +== +SELECT EXTRACT(week FROM cast('2007-01-01' AS DATE) + 147); +-- +ok +== +SELECT EXTRACT(week FROM cast('2007-01-01' AS DATE) + 154); +-- +ok +== +SELECT EXTRACT(week FROM cast('2007-01-01' AS DATE) + 161); +-- +ok +== +SELECT EXTRACT(week FROM cast('2007-01-01' AS DATE) + 168); +-- +ok +== +SELECT EXTRACT(week FROM cast('2007-01-01' AS DATE) + 175); +-- +ok +== +SELECT EXTRACT(week FROM cast('2007-01-01' AS DATE) + 182); +-- +ok +== +SELECT EXTRACT(week FROM cast('2007-01-01' AS DATE) + 189); +-- +ok +== +SELECT EXTRACT(week FROM cast('2007-01-01' AS DATE) + 196); +-- +ok +== +SELECT EXTRACT(week FROM cast('2007-01-01' AS DATE) + 203); +-- +ok +== +SELECT EXTRACT(week FROM cast('2007-01-01' AS DATE) + 210); +-- +ok +== +SELECT EXTRACT(week FROM cast('2007-01-01' AS DATE) + 217); +-- +ok +== +SELECT EXTRACT(week FROM cast('2007-01-01' AS DATE) + 224); +-- +ok +== +SELECT EXTRACT(week FROM cast('2007-01-01' AS DATE) + 231); +-- +ok +== +SELECT EXTRACT(week FROM cast('2007-01-01' AS DATE) + 238); +-- +ok +== +SELECT EXTRACT(week FROM cast('2007-01-01' AS DATE) + 245); +-- +ok +== +SELECT EXTRACT(week FROM cast('2007-01-01' AS DATE) + 252); +-- +ok +== +SELECT EXTRACT(week FROM cast('2007-01-01' AS DATE) + 259); +-- +ok +== +SELECT EXTRACT(week FROM cast('2007-01-01' AS DATE) + 266); +-- +ok +== +SELECT EXTRACT(week FROM cast('2007-01-01' AS DATE) + 273); +-- +ok +== diff --git a/parser/testdata/corpus/sql/function/date/test_extract_month.test b/parser/testdata/corpus/sql/function/date/test_extract_month.test new file mode 100644 index 0000000..de40137 --- /dev/null +++ b/parser/testdata/corpus/sql/function/date/test_extract_month.test @@ -0,0 +1,13 @@ +# source: test/sql/function/date/test_extract_month.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +select date '1992-01-01' + interval (i) days, month(date '1992-01-01' + interval (i) days) from range(0, 366) tbl(i); +-- +ok +== +select date '1993-01-01' + interval (i) days, month(date '1993-01-01' + interval (i) days) from range(0, 366) tbl(i); +-- +ok +== diff --git a/parser/testdata/corpus/sql/function/date/test_extract_year.test b/parser/testdata/corpus/sql/function/date/test_extract_year.test new file mode 100644 index 0000000..db9c1ef --- /dev/null +++ b/parser/testdata/corpus/sql/function/date/test_extract_year.test @@ -0,0 +1,21 @@ +# source: test/sql/function/date/test_extract_year.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +CREATE TABLE dates AS SELECT date '1970-01-01' + concat(i, ' years')::interval AS d from range(0, 430) tbl(i); +-- +ok +== +CREATE TABLE dates2 AS SELECT date '1970-01-01' + concat(i * 6, ' months')::interval AS d from range(0, 200) tbl(i); +-- +ok +== +SELECT EXTRACT(year FROM d) FROM dates ORDER BY 1 +-- +ok +== +SELECT EXTRACT(year FROM d) FROM dates2 ORDER BY 1 +-- +ok +== diff --git a/parser/testdata/corpus/sql/function/date/test_strftime.test b/parser/testdata/corpus/sql/function/date/test_strftime.test new file mode 100644 index 0000000..9614191 --- /dev/null +++ b/parser/testdata/corpus/sql/function/date/test_strftime.test @@ -0,0 +1,106 @@ +# source: test/sql/function/date/test_strftime.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +SELECT strftime(DATE '1992-01-01', '%Y'); +-- +ok +== +SELECT strftime('%Y', DATE '1992-01-01'); +-- +ok +== +SELECT strftime('%Y', TIMESTAMP '1992-01-01'); +-- +ok +== +SELECT strftime(DATE '1992-01-01', '(%Y)'); +-- +ok +== +SELECT strftime(DATE '1992-01-01', '%% %Y %%'); +-- +ok +== +SELECT strftime(DATE '1992-01-01', '%%%%%% %Y %%%%%%'); +-- +ok +== +SELECT strftime(DATE '1992-02-01', '%d/%m/%Y'); +-- +ok +== +SELECT strftime(DATE '1992-02-01', '%Y %Y %Y %Y'); +-- +ok +== +CREATE TABLE dates(d DATE); +INSERT INTO dates VALUES ('1992-01-01'), ('1993-03-20'), (NULL); +-- +ok +== +SELECT strftime(d, '%d/%m/%Y') FROM dates ORDER BY d; +-- +ok +== +SELECT strftime(NULL::DATE, '%d/%m/%Y') FROM dates ORDER BY d; +-- +ok +== +SELECT strftime(d, NULL) FROM dates ORDER BY d; +-- +ok +== +SELECT strftime(NULL::TIMESTAMP, NULL) FROM range(3); +-- +ok +== +SELECT strftime(NULL::TIMESTAMP, '%%%%%% %Y %%%%%%') FROM range(3); +-- +ok +== +SELECT strftime(DATE '1992-01-01', 'hello world'); +-- +ok +== +SELECT strftime('2019-01-23'::DATE, '42'); +-- +ok +== +SELECT strftime('infinity'::{datatype}, '%Y-%m-%d'); +-- +error: Parser Error: syntax error at or near "{" +== +SELECT strftime('-infinity'::{datatype}, '%Y-%m-%d'); +-- +error: Parser Error: syntax error at or near "{" +== +SELECT strftime(d, d::VARCHAR) FROM dates ORDER BY d; +-- +ok +== +SELECT strftime(DATE '1992-01-01', '%'); +-- +ok +== +SELECT strftime(DATE '1992-01-01', '%R'); +-- +ok +== +select strftime(strptime('023', '%g'), '%g'), strftime(strptime('0', '%g'), '%g'), strftime(strptime('000', '%g'), '%g'), strftime(strptime('999', '%g'), '%g'); +-- +ok +== +SELECT strptime('-1', '%g'); +-- +ok +== +SELECT strptime('1000', '%g'); +-- +ok +== +SELECT strftime('%Y', '1992-01-01'); +-- +ok +== diff --git a/parser/testdata/corpus/sql/function/date/test_strftime_exhaustive.test b/parser/testdata/corpus/sql/function/date/test_strftime_exhaustive.test new file mode 100644 index 0000000..45f4dc1 --- /dev/null +++ b/parser/testdata/corpus/sql/function/date/test_strftime_exhaustive.test @@ -0,0 +1,186 @@ +# source: test/sql/function/date/test_strftime_exhaustive.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +CREATE TABLE dates(d DATE); +INSERT INTO dates VALUES ('1992-01-01'), ('1993-03-20'), ('2020-08-09'), ('2020-08-10'), (NULL); +-- +ok +== +SELECT strftime(d, '%a') FROM dates ORDER BY d; +-- +ok +== +SELECT strftime(d, '%A') FROM dates ORDER BY d; +-- +ok +== +SELECT strftime(d, '%w') FROM dates ORDER BY d; +-- +ok +== +SELECT strftime(d, '%u') FROM dates ORDER BY d; +-- +ok +== +SELECT strftime(d, '%d') FROM dates ORDER BY d; +-- +ok +== +SELECT strftime(d, '%-d') FROM dates ORDER BY d; +-- +ok +== +SELECT strftime(d, '%b') FROM dates ORDER BY d; +-- +ok +== +SELECT strftime(d, '%h') FROM dates ORDER BY d; +-- +ok +== +SELECT strftime(d, '%B') FROM dates ORDER BY d; +-- +ok +== +SELECT strftime(d, '%m') FROM dates ORDER BY d; +-- +ok +== +SELECT strftime(d, '%-m') FROM dates ORDER BY d; +-- +ok +== +SELECT strftime(d, '%y') FROM dates ORDER BY d; +-- +ok +== +SELECT strftime(d, '%-y') FROM dates ORDER BY d; +-- +ok +== +SELECT strftime(DATE '2001-01-01', '%-y') +-- +ok +== +SELECT strftime(d, '%Y') FROM dates ORDER BY d; +-- +ok +== +SELECT strftime(d, '%G') FROM dates ORDER BY d; +-- +ok +== +SELECT strftime(d, '%H') FROM dates ORDER BY d; +-- +ok +== +SELECT strftime(d, '%-H') FROM dates ORDER BY d; +-- +ok +== +SELECT strftime(d, '%I') FROM dates ORDER BY d; +-- +ok +== +SELECT strftime(d, '%-I') FROM dates ORDER BY d; +-- +ok +== +SELECT strftime(d, '%p') FROM dates ORDER BY d; +-- +ok +== +SELECT strftime(d, '%M') FROM dates ORDER BY d; +-- +ok +== +SELECT strftime(d, '%-M') FROM dates ORDER BY d; +-- +ok +== +SELECT strftime(d, '%S') FROM dates ORDER BY d; +-- +ok +== +SELECT strftime(d, '%-S') FROM dates ORDER BY d; +-- +ok +== +SELECT strftime(d, '%f') FROM dates ORDER BY d; +-- +ok +== +SELECT strftime(d, '%z') FROM dates ORDER BY d; +-- +ok +== +SELECT strftime(d, '%Z') FROM dates ORDER BY d; +-- +ok +== +SELECT strftime(d, '%j') FROM dates ORDER BY d; +-- +ok +== +SELECT strftime(d, '%-j') FROM dates ORDER BY d; +-- +ok +== +SELECT strftime(d, '%U') FROM dates ORDER BY d; +-- +ok +== +SELECT strftime(d, '%W') FROM dates ORDER BY d; +-- +ok +== +SELECT strftime(d, '%V') FROM dates ORDER BY d; +-- +ok +== +SELECT strftime(d, '%c') FROM dates ORDER BY d; +-- +ok +== +SELECT strftime(d, 'XX%cXX') FROM dates ORDER BY d; +-- +ok +== +SELECT strftime(d, '%x') FROM dates ORDER BY d; +-- +ok +== +SELECT strftime(d, '%X') FROM dates ORDER BY d; +-- +ok +== +SELECT strftime(d, 'XX%cXX%xXX%XXX') FROM dates ORDER BY d; +-- +ok +== +SELECT strftime(date '-99999-01-01', '%Y') +-- +ok +== +SELECT strftime(date '99999-01-01', '%Y') +-- +ok +== +SELECT strftime(date '99999-01-01', '%y') +-- +ok +== +SELECT strftime(date '-99999-01-01', '%y') +-- +ok +== +SELECT strftime(DATE '-4869706-10-11','%-yi'); +-- +ok +== +SELECT strftime(date '-99999-01-01', random()::varchar) +-- +ok +== diff --git a/parser/testdata/corpus/sql/function/date/test_time_bucket_date.test b/parser/testdata/corpus/sql/function/date/test_time_bucket_date.test new file mode 100644 index 0000000..d51f156 --- /dev/null +++ b/parser/testdata/corpus/sql/function/date/test_time_bucket_date.test @@ -0,0 +1,318 @@ +# source: test/sql/function/date/test_time_bucket_date.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +CREATE TABLE dates(w INTERVAL, d DATE, shift INTERVAL, origin DATE); +-- +ok +== +INSERT INTO dates VALUES ('10 days', '-infinity', '0 days', '1970-01-05'), + ('10 days', '3000-01-02 (BC)', '3 days', '3000-01-01 (BC)'), + ('2 months', '1024-04-10 (BC)', '10 days', '1024-03-01 (BC)'), + ('10 days', '0044-06-15 (BC)', '6 days', '0044-02-01 (BC)'), + ('10 days', '0794-11-15', '1 week', '0790-11-01'), + ('10 days', '1700-01-01', '0 days', '1700-01-05'), + ('1 week', '1832-05-03', '0 days', '1970-05-05'), + ('10 days', '1897-07-05', '2 days', '1970-06-07'), + ('10 days', '1906-02-08', '-2 days', '1970-10-03'), + ('2 months', '1946-09-14', '0 months', '1970-07-05'), + ('2 months', '2000-01-01', '1 month 1 week', '1970-05-01'), + ('2 months', '2000-01-03', '-1 month 1 week', '1970-08-20'), + ('2 year', '2004-05-20', '6 months', '1970-12-31'), + ('2 year', '2032-12-06', '-6 months', '1969-07-01'), + ('10 days', 'infinity', '0 days', '1970-01-01'), +; +-- +ok +== +select d, time_bucket('3 days'::interval, d) from dates; +-- +ok +== +select d, time_bucket('3 years'::interval, d) from dates; +-- +ok +== +select d, time_bucket(null::interval, d) from dates; +-- +ok +== +select w, d, time_bucket(w, d) from dates; +-- +ok +== +select d, time_bucket('4 days'::interval, d, '6 hours'::interval) from dates; +-- +ok +== +select d, time_bucket('2 weeks'::interval, d, '6 days'::interval) from dates; +-- +ok +== +select d, time_bucket('3 months'::interval, d, '6 days'::interval) from dates; +-- +ok +== +select d, time_bucket(null::interval, d, '6 days'::interval) from dates; +-- +ok +== +select time_bucket('3 months'::interval, null::date, '6 days'::interval) from dates; +-- +ok +== +select d, time_bucket('3 months'::interval, d, null::interval) from dates; +-- +ok +== +select w, d, shift, time_bucket(w, d, shift) from dates; +-- +ok +== +select d, time_bucket('5 days'::interval, d, '1970-01-04'::date) from dates; +-- +ok +== +select d, time_bucket('3 months'::interval, d, '1970-01-04'::date) from dates; +-- +ok +== +select d, time_bucket('3 years'::interval, d, '1970-01-04'::date) from dates; +-- +ok +== +select d, time_bucket(null::interval, d, '1970-01-04'::date) from dates; +-- +ok +== +select time_bucket('3 years'::interval, null::date, '1970-01-04'::date) from dates; +-- +ok +== +select d, time_bucket('3 years'::interval, d, null::date) from dates; +-- +ok +== +select w, d, origin, time_bucket(w, d, origin) from dates; +-- +ok +== +select time_bucket('-3 hours'::interval, '2019-04-05'::date); +-- +ok +== +select time_bucket('-3 hours'::interval, '2019-04-05'::date, '1 hour 30 minutes'::interval); +-- +ok +== +select time_bucket('-3 hours'::interval, '2019-04-05'::date, '2019-04-05'::date); +-- +ok +== +select time_bucket('-1 month'::interval, '2019-04-05'::date); +-- +ok +== +select time_bucket('-1 month'::interval, '2019-04-05'::date, '1 week'::interval); +-- +ok +== +select time_bucket('-1 month'::interval, '2019-04-05'::date, '2019-04-05'::date); +-- +ok +== +select time_bucket('1 day - 172800 seconds'::interval, '2018-05-05'::date); +-- +ok +== +select time_bucket('1 day - 172800 seconds'::interval, '2018-05-05'::date, '1 hour 30 minutes'::interval); +-- +ok +== +select time_bucket('1 day - 172800 seconds'::interval, '2018-05-05'::date, '2018-05-05'::date); +-- +ok +== +select time_bucket('1 month 1 day'::interval, '2018-05-05'::date); +-- +ok +== +select time_bucket('1 month 1 day'::interval, '2018-05-05'::date, '1 week'::interval); +-- +ok +== +select time_bucket('1 month 1 day'::interval, '2019-05-05'::date, '2019-05-05'::date); +-- +ok +== +select time_bucket('3 days'::interval, '2019-05-05'::date, '2000000000 months'::interval); +-- +ok +== +select time_bucket('3 days'::interval, '2019-05-05'::date, '-2000000000 months'::interval); +-- +ok +== +select time_bucket('3 months'::interval, '2019-05-05'::date, '2000000000 months'::interval); +-- +ok +== +select time_bucket('3 months'::interval, '2019-05-05'::date, '-2000000000 months'::interval); +-- +ok +== +select time_bucket('1 month'::interval, '5877642-06-25 (BC)'::date); +-- +ok +== +select time_bucket('1 month'::interval, '5877642-07-01 (BC)'::date); +-- +ok +== +select time_bucket('1 week'::interval, '5877642-07-01 (BC)'::date); +-- +ok +== +select time_bucket('1 month'::interval, '5881580-07-10'::date, '-1 day'::interval); +-- +ok +== +select time_bucket('1 month'::interval, '5881580-07-10'::date); +-- +ok +== +select time_bucket('1 week'::interval, '290309-12-21 (BC)'::date); +-- +ok +== +select time_bucket('1 week'::interval, '290309-12-22 (BC)'::date); +-- +ok +== +select time_bucket('1 day'::interval, '290309-12-21 (BC)'::date); +-- +ok +== +select time_bucket('1 day'::interval, '290309-12-22 (BC)'::date); +-- +ok +== +select time_bucket('1 week'::interval, '294247-01-11'::date); +-- +ok +== +select time_bucket('1 week'::interval, '294247-01-10'::date); +-- +ok +== +select time_bucket('1 day'::interval, '294247-01-11'::date); +-- +ok +== +select time_bucket('1 day'::interval, '294247-01-10'::date); +-- +ok +== +select time_bucket('1 month 1 day'::interval, null::date); +-- +ok +== +select time_bucket('1 month 1 day'::interval, null::date, '6 days'::interval); +-- +ok +== +select time_bucket('1 month 1 day'::interval, null::date, '2022-12-20'::date); +-- +ok +== +select time_bucket('-1 month'::interval, null::date); +-- +ok +== +select time_bucket('-1 month'::interval, null::date, '6 days'::interval); +-- +ok +== +select time_bucket('-1 month'::interval, '2022-12-22'::date, null::interval); +-- +ok +== +select time_bucket('-1 month'::interval, null::date, '2022-12-20'::date); +-- +ok +== +select time_bucket('-1 month'::interval, '2022-12-22'::date, null::date); +-- +ok +== +WITH cte AS ( + SELECT NULL::INTERVAL i, + NULL::DATE d, + NULL::TIMESTAMP t + FROM range(1) +) +SELECT time_bucket(i, d) +FROM cte +-- +ok +== +WITH cte AS ( + SELECT NULL::INTERVAL i, + NULL::DATE d, + NULL::TIMESTAMP t + FROM range(1) +) +SELECT time_bucket(i, t) +FROM cte +-- +ok +== +WITH cte AS ( + SELECT NULL::INTERVAL i, + NULL::DATE d, + NULL::TIMESTAMP t + FROM range(1) +) +SELECT time_bucket(i, d, i) +FROM cte +-- +ok +== +WITH cte AS ( + SELECT NULL::INTERVAL i, + NULL::DATE d, + NULL::TIMESTAMP t + FROM range(1) +) +SELECT time_bucket(i, t, i) +FROM cte +-- +ok +== +WITH cte AS ( + SELECT NULL::INTERVAL i, + NULL::DATE d, + NULL::TIMESTAMP t + FROM range(1) +) +SELECT time_bucket(i, d, d) +FROM cte +-- +ok +== +WITH cte AS ( + SELECT NULL::INTERVAL i, + NULL::DATE d, + NULL::TIMESTAMP t + FROM range(1) +) +SELECT time_bucket(i, t, t) +FROM cte +-- +ok +== +SELECT time_bucket(INTERVAL '2147483647' MONTH, DATE '1700-01-01', DATE '1800-01-01'); +-- +ok +== diff --git a/parser/testdata/corpus/sql/function/enum/test_enum_code.test b/parser/testdata/corpus/sql/function/enum/test_enum_code.test new file mode 100644 index 0000000..77e9bd2 --- /dev/null +++ b/parser/testdata/corpus/sql/function/enum/test_enum_code.test @@ -0,0 +1,41 @@ +# source: test/sql/function/enum/test_enum_code.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +CREATE TYPE mood AS ENUM ('sad', 'ok', 'happy', 'anxious') +-- +ok +== +CREATE TABLE test (x mood) +-- +ok +== +INSERT INTO test VALUES ('ok'), ('sad'), ('anxious'), ('happy') +-- +ok +== +SELECT enum_code(x) FROM test +-- +ok +== +SELECT enum_code('bla') +-- +ok +== +PREPARE p1 as SELECT enum_code(x) FROM test +-- +ok +== +EXECUTE p1 +-- +ok +== +PREPARE p2 as SELECT enum_code(?); +-- +ok +== +EXECUTE p2('happy'::mood) +-- +ok +== diff --git a/parser/testdata/corpus/sql/function/enum/test_enum_first.test b/parser/testdata/corpus/sql/function/enum/test_enum_first.test new file mode 100644 index 0000000..5a40fed --- /dev/null +++ b/parser/testdata/corpus/sql/function/enum/test_enum_first.test @@ -0,0 +1,17 @@ +# source: test/sql/function/enum/test_enum_first.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +CREATE TYPE rainbow AS ENUM ('red', 'orange', 'yellow', 'green', 'blue', 'purple'); +-- +ok +== +SELECT enum_first(null::rainbow) +-- +ok +== +SELECT enum_first('bla') +-- +ok +== diff --git a/parser/testdata/corpus/sql/function/enum/test_enum_last.test b/parser/testdata/corpus/sql/function/enum/test_enum_last.test new file mode 100644 index 0000000..0265161 --- /dev/null +++ b/parser/testdata/corpus/sql/function/enum/test_enum_last.test @@ -0,0 +1,13 @@ +# source: test/sql/function/enum/test_enum_last.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +SELECT enum_last(null::rainbow) +-- +ok +== +SELECT enum_last('bla') +-- +ok +== diff --git a/parser/testdata/corpus/sql/function/enum/test_enum_range.test b/parser/testdata/corpus/sql/function/enum/test_enum_range.test new file mode 100644 index 0000000..6d0afac --- /dev/null +++ b/parser/testdata/corpus/sql/function/enum/test_enum_range.test @@ -0,0 +1,45 @@ +# source: test/sql/function/enum/test_enum_range.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +CREATE TYPE currency AS ENUM ('usd', 'brl', 'eur'); +-- +ok +== +SELECT enum_range(null::rainbow) +-- +ok +== +SELECT enum_range_boundary('orange'::rainbow, 'green'::rainbow) +-- +ok +== +SELECT enum_range_boundary('green'::rainbow, 'orange'::rainbow) +-- +ok +== +SELECT enum_range_boundary(NULL, 'green'::rainbow) +-- +ok +== +SELECT enum_range_boundary('orange'::rainbow, NULL) +-- +ok +== +SELECT enum_range_boundary('orange'::rainbow, 'brl'::currency) +-- +ok +== +SELECT enum_range_boundary(NULL, NULL) +-- +ok +== +SELECT enum_range_boundary('orange'::rainbow, 1) +-- +ok +== +SELECT enum_range_boundary(1, 'orange'::rainbow) +-- +ok +== diff --git a/parser/testdata/corpus/sql/function/generic/assert_true.test b/parser/testdata/corpus/sql/function/generic/assert_true.test new file mode 100644 index 0000000..506a7d2 --- /dev/null +++ b/parser/testdata/corpus/sql/function/generic/assert_true.test @@ -0,0 +1,45 @@ +# source: test/sql/function/generic/assert_true.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +SELECT assert_true(true) +-- +ok +== +SELECT assert_true(true, ['a','b']) +-- +ok +== +SELECT assert_true(1 = 1, 'never shown') +-- +ok +== +SELECT assert_true(false) +-- +ok +== +SELECT assert_true(NULL) +-- +ok +== +SELECT assert_true(false, 'my custom message') +-- +ok +== +SELECT assert_true(false, NULL) +-- +ok +== +SELECT assert_true(NULL, NULL) +-- +ok +== +SELECT assert_true(i < 3, 'row ' || i || ' is too large') FROM range(5) t(i) +-- +ok +== +SELECT assert_true(i < 10) FROM range(3) t(i) +-- +ok +== diff --git a/parser/testdata/corpus/sql/function/generic/can_cast_implicitly.test b/parser/testdata/corpus/sql/function/generic/can_cast_implicitly.test new file mode 100644 index 0000000..5085839 --- /dev/null +++ b/parser/testdata/corpus/sql/function/generic/can_cast_implicitly.test @@ -0,0 +1,25 @@ +# source: test/sql/function/generic/can_cast_implicitly.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +CREATE TABLE tbl AS SELECT * FROM range(10) tbl(i) +-- +ok +== +SELECT can_cast_implicitly(i, NULL::BIGINT) FROM tbl LIMIT 1 +-- +ok +== +SELECT can_cast_implicitly(i, NULL::HUGEINT) FROM tbl LIMIT 1 +-- +ok +== +SELECT can_cast_implicitly(i, NULL::INTEGER) FROM tbl LIMIT 1 +-- +ok +== +SELECT can_cast_implicitly(i, NULL::VARCHAR) FROM tbl LIMIT 1 +-- +ok +== diff --git a/parser/testdata/corpus/sql/function/generic/case_condition.test b/parser/testdata/corpus/sql/function/generic/case_condition.test new file mode 100644 index 0000000..a3bf1b0 --- /dev/null +++ b/parser/testdata/corpus/sql/function/generic/case_condition.test @@ -0,0 +1,13 @@ +# source: test/sql/function/generic/case_condition.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +SELECT * FROM tbl +WHERE +CASE WHEN i%2=0 THEN 1 ELSE 0 END +AND +CASE WHEN i<5 THEN 1 ELSE 0 END +-- +ok +== diff --git a/parser/testdata/corpus/sql/function/generic/case_short_circuit.test b/parser/testdata/corpus/sql/function/generic/case_short_circuit.test new file mode 100644 index 0000000..6b8bf2b --- /dev/null +++ b/parser/testdata/corpus/sql/function/generic/case_short_circuit.test @@ -0,0 +1,21 @@ +# source: test/sql/function/generic/case_short_circuit.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +create table t (n text); +-- +ok +== +insert into t values ('1'),('0'),(''); +-- +ok +== +select n, case +when n <> '' and cast(substr(n, 1, 1) as int) <= 0 then '0' +when n <> '' and cast(substr(n, 1, 1) as int) > 0 then '1' +else '2'end as x from t +ORDER BY n; +-- +ok +== diff --git a/parser/testdata/corpus/sql/function/generic/case_varchar.test b/parser/testdata/corpus/sql/function/generic/case_varchar.test new file mode 100644 index 0000000..6f546d0 --- /dev/null +++ b/parser/testdata/corpus/sql/function/generic/case_varchar.test @@ -0,0 +1,17 @@ +# source: test/sql/function/generic/case_varchar.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +CREATE TABLE tbl AS SELECT i, 'thisisalongstring' || i::VARCHAR s FROM range(10) tbl(i) +-- +ok +== +SELECT i, s, CASE WHEN i%2=0 THEN s ELSE s END FROM tbl +-- +ok +== +SELECT i, s, CASE WHEN i%2=0 THEN s ELSE s END FROM (SELECT i, s||'_suffix' FROM tbl) tbl(i, s) +-- +ok +== diff --git a/parser/testdata/corpus/sql/function/generic/cast_to_type.test b/parser/testdata/corpus/sql/function/generic/cast_to_type.test new file mode 100644 index 0000000..28fdf6a --- /dev/null +++ b/parser/testdata/corpus/sql/function/generic/cast_to_type.test @@ -0,0 +1,49 @@ +# source: test/sql/function/generic/cast_to_type.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +SELECT cast_to_type(' 42', NULL::INT) +-- +ok +== +SELECT cast_to_type('hello', NULL::INT) +-- +ok +== +CREATE OR REPLACE MACRO try_trim_null(s) AS CASE WHEN typeof(s)=='VARCHAR' THEN cast_to_type(nullif(trim(s::VARCHAR), ''), s) ELSE s END; +-- +ok +== +SELECT try_trim_null(42) as trim_int, try_trim_null(' col ') as trim_varchar, try_trim_null('') as trim_empty; +-- +ok +== +create table tbl(i int, v varchar); +-- +ok +== +insert into tbl values (42, ' hello '), (100, ' '); +-- +ok +== +SELECT try_trim_null(COLUMNS(*)) FROM tbl +-- +ok +== +PREPARE v1 AS SELECT cast_to_type(' 42', ?); +-- +ok +== +EXECUTE v1(NULL::INT) +-- +ok +== +EXECUTE v1(NULL::VARCHAR) +-- +ok +== +SELECT cast_to_type(42, NULL); +-- +ok +== diff --git a/parser/testdata/corpus/sql/function/generic/constant_or_null.test b/parser/testdata/corpus/sql/function/generic/constant_or_null.test new file mode 100644 index 0000000..3ec1682 --- /dev/null +++ b/parser/testdata/corpus/sql/function/generic/constant_or_null.test @@ -0,0 +1,25 @@ +# source: test/sql/function/generic/constant_or_null.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +SELECT constant_or_null(1, NULL), constant_or_null(1, 10) +-- +ok +== +SELECT constant_or_null(1, case when i%2=0 then null else i end) from range(5) tbl(i) +-- +ok +== +SELECT constant_or_null(1, case when i%2=0 then null else i end, case when i%2=1 then null else i end) from range(5) tbl(i) +-- +ok +== +SELECT constant_or_null(1); +-- +ok +== +SELECT constant_or_null(); +-- +ok +== diff --git a/parser/testdata/corpus/sql/function/generic/error.test b/parser/testdata/corpus/sql/function/generic/error.test new file mode 100644 index 0000000..82c2a8e --- /dev/null +++ b/parser/testdata/corpus/sql/function/generic/error.test @@ -0,0 +1,40 @@ +# source: test/sql/function/generic/error.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +SELECT error('test') +-- +ok +== +SELECT + CASE + WHEN value = 'foo' THEN 'Value is foo.' + ELSE ERROR(CONCAT('Found unexpected value: ', value)) + END AS new_value +FROM ( + SELECT 'foo' AS value UNION ALL + SELECT 'baz' AS value); +-- +ok +== +SELECT * +FROM (SELECT 4 AS x) +WHERE IF(x % 2 = 0, true, ERROR(FORMAT('x must be even number but is {}', x))); +-- +ok +== +SELECT * +FROM (SELECT 3 AS x) +WHERE IF(x % 2 = 0, true, ERROR(FORMAT('x must be even but is {}', x))); +-- +ok +== +SELECT 42=error('hello world') +-- +ok +== +SELECT error('hello world') IS NULL +-- +ok +== diff --git a/parser/testdata/corpus/sql/function/generic/hash_func.test b/parser/testdata/corpus/sql/function/generic/hash_func.test new file mode 100644 index 0000000..60d6dd2 --- /dev/null +++ b/parser/testdata/corpus/sql/function/generic/hash_func.test @@ -0,0 +1,154 @@ +# source: test/sql/function/generic/hash_func.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +SELECT HASH(NULL::{datatype}); +-- +error: Parser Error: syntax error at or near "{" +== +CREATE TABLE structs AS + SELECT * FROM (VALUES + ({'i': 5, 's': 'string'}), + ({'i': -2, 's': NULL}), + ({'i': NULL, 's': 'not null'}), + ({'i': NULL, 's': NULL}), + (NULL) +) tbl(s); +-- +ok +== +SELECT s, HASH(s) FROM structs +-- +ok +== +CREATE TABLE lists AS + SELECT * FROM (VALUES + ([1], ['TGTA']), + ([1, 2], ['CGGT']), + ([], ['CCTC']), + ([1, 2, 3], ['TCTA']), + ([1, 2, 3, 4, 5], ['AGGG']), + (NULL, NULL) +) tbl(li, lg); +-- +ok +== +SELECT li, HASH(li) FROM lists +-- +ok +== +SELECT lg, HASH(lg) FROM lists +-- +ok +== +CREATE TABLE maps AS + SELECT * FROM (VALUES + (MAP([1], ['TGTA'])), + (MAP([1, 2], ['CGGT', 'CCTC'])), + (MAP([], [])), + (MAP([1, 2, 3], ['TCTA', NULL, 'CGGT'])), + (MAP([1, 2, 3, 4, 5], ['TGTA', 'CGGT', 'CCTC', 'TCTA', 'AGGG'])), + (NULL) +) tbl(m); +-- +ok +== +SELECT m, HASH(m) FROM maps +-- +ok +== +CREATE TABLE map_as_list AS + SELECT * FROM (VALUES + ([{'key':1, 'value':'TGTA'}]), + ([{'key':1, 'value':'CGGT'}, {'key':2, 'value':'CCTC'}]), + ([]), + ([{'key':1, 'value':'TCTA'}, {'key':2, 'value':NULL}, {'key':3, 'value':'CGGT'}]), + ([{'key':1, 'value':'TGTA'}, {'key':2, 'value':'CGGT'}, {'key':3, 'value':'CCTC'}, {'key':4, 'value':'TCTA'}, {'key':5, 'value':'AGGG'}]), + (NULL) +) tbl(m); +-- +ok +== +SELECT HASH(m) FROM maps +-- +ok +== +SELECT HASH(m) FROM map_as_list +-- +ok +== +CREATE TYPE resistor AS ENUM ( + 'black', + 'brown', + 'red', + 'orange', + 'yellow', + 'green', + 'blue', + 'violet', + 'grey', + 'white' +); +-- +ok +== +CREATE TABLE enums (r resistor); +-- +ok +== +INSERT INTO enums VALUES + ('black'), + ('brown'), + ('red'), + ('orange'), + ('yellow'), + ('green'), + ('blue'), + ('violet'), + ('grey'), + ('white'), + (NULL) +; +-- +ok +== +SELECT r, HASH(r) FROM enums; +-- +ok +== +SELECT HASH(); +-- +ok +== +SELECT r, HASH() FROM enums; +-- +ok +== +SELECT r, HASH(r, 'capacitor') FROM enums; +-- +ok +== +SELECT r, HASH('2022-02-12'::DATE, r) FROM enums; +-- +ok +== +SELECT r, HASH(r, r) FROM enums; +-- +ok +== +CREATE TABLE issue2498 AS SELECT * FROM (VALUES + (24, {'x': [{'l4': [52, 53]}, {'l4': [54, 55]}]}), + (34, {'x': [{'l4': [52, 53]}, {'l4': [54, 55]}]}) +) tbl(v, k); +-- +ok +== +SELECT k, HASH(k) FROM issue2498 +-- +ok +== +select approx_count_distinct((range, range)) > 800_000 from range(1_000_000) +-- +ok +== diff --git a/parser/testdata/corpus/sql/function/generic/invoke.test b/parser/testdata/corpus/sql/function/generic/invoke.test new file mode 100644 index 0000000..fcb6b9e --- /dev/null +++ b/parser/testdata/corpus/sql/function/generic/invoke.test @@ -0,0 +1,101 @@ +# source: test/sql/function/generic/invoke.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +select invoke(lambda x: x * x, 2) as square_of_x +-- +ok +== +select invoke(lambda a: invoke(lambda b: a + b, 4), 3) as sum_ab +-- +ok +== +select invoke(lambda x, y: x * y + y, 3, 4) as result +-- +ok +== +select invoke(lambda x, y, z: x + y + z, 1, 2, 3) as result +-- +ok +== +select invoke(lambda x, y, z: x * 100 + y * 10 + z, 1, 2, 3) as result +-- +ok +== +select invoke(lambda x, y, z, w: x * y + z * w, 1, 2, 3, 4) as result +-- +ok +== +select invoke(lambda x: invoke(lambda y: y + 5, x + 3), 2) as result +-- +ok +== +select invoke(lambda x: invoke(lambda y: y + x + 5, 3), 2) as result +-- +ok +== +select invoke(lambda a: invoke(lambda b, c: a + b + c, 4, 5), 3) as result +-- +ok +== +select invoke(lambda a, b: invoke(lambda c: a + b + c, 5), 3, 4) as result +-- +ok +== +select invoke(lambda a, b: invoke(lambda c: a * 100 + b * 10 + c, 3), 1, 2) as result +-- +ok +== +SELECT unnest(invoke(lambda x: invoke(lambda y: row(x, y), 3), 2)); +-- +ok +== +SELECT invoke(lambda name: invoke(lambda age: name || age, 30), 'Alice, '); +-- +ok +== +SELECT invoke(lambda x: list_transform([1,2,3], LAMBDA y: y + x), 1); +-- +ok +== +SELECT invoke(lambda x: list_transform([10, 20], lambda y, i: x + y + i), 100); +-- +ok +== +select invoke(lambda x: x IS NULL, NULL); +-- +ok +== +select invoke(lambda x: alias(x), 1); +-- +ok +== +SELECT * FROM range(0, 10) as r(i) WHERE invoke(lambda x: x, i % 2 == 0) ORDER BY ALL; +-- +ok +== +CREATE TABLE invoke_order_tbl AS SELECT 1 a, 2 b, 3 c +-- +ok +== +CREATE VIEW invoke_order_view AS SELECT invoke(lambda x, y, z: x * 100 + y * 10 + z, a, b, c) AS result FROM invoke_order_tbl +-- +ok +== +SELECT result FROM invoke_order_view +-- +ok +== +SELECT invoke(lambda x: x + x, 2, 4, 6); +-- +ok +== +SELECT invoke(lambda x, y: x + y, 2); +-- +ok +== +SELECT invoke(NULL, 1); +-- +ok +== diff --git a/parser/testdata/corpus/sql/function/generic/least_greatest_enum.test b/parser/testdata/corpus/sql/function/generic/least_greatest_enum.test new file mode 100644 index 0000000..33d4a4d --- /dev/null +++ b/parser/testdata/corpus/sql/function/generic/least_greatest_enum.test @@ -0,0 +1,13 @@ +# source: test/sql/function/generic/least_greatest_enum.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +CREATE TYPE t AS ENUM ('z','y','x'); +-- +ok +== +SELECT greatest('x'::t, 'z'::t), 'x'::t > 'z'::t; +-- +ok +== diff --git a/parser/testdata/corpus/sql/function/generic/least_greatest_types.test b/parser/testdata/corpus/sql/function/generic/least_greatest_types.test new file mode 100644 index 0000000..a5a1574 --- /dev/null +++ b/parser/testdata/corpus/sql/function/generic/least_greatest_types.test @@ -0,0 +1,17 @@ +# source: test/sql/function/generic/least_greatest_types.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +CREATE TABLE all_types AS FROM test_all_types() +-- +ok +== +SELECT LEAST((SELECT MAX("{col}") FROM all_types), (SELECT MIN("{col}") FROM all_types)) IS NOT DISTINCT FROM (SELECT MIN("{col}") FROM all_types) +-- +ok +== +SELECT GREATEST((SELECT MAX("{col}") FROM all_types), (SELECT MIN("{col}") FROM all_types)) IS NOT DISTINCT FROM (SELECT MAX("{col}") FROM all_types) +-- +ok +== diff --git a/parser/testdata/corpus/sql/function/generic/replace_type.test b/parser/testdata/corpus/sql/function/generic/replace_type.test new file mode 100644 index 0000000..6e6a3cd --- /dev/null +++ b/parser/testdata/corpus/sql/function/generic/replace_type.test @@ -0,0 +1,41 @@ +# source: test/sql/function/generic/replace_type.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +SELECT replace_type(' 42', NULL::VARCHAR, NULL::INT) +-- +ok +== +SELECT replace_type('hello', NULL::VARCHAR, NULL::INT) +-- +ok +== +CREATE OR REPLACE MACRO try_trim_null(s) AS CASE WHEN typeof(s)=='VARCHAR' THEN replace_type(nullif(trim(s::VARCHAR), ''), NULL::VARCHAR, s) ELSE s END; +-- +ok +== +PREPARE v1 AS SELECT replace_type(' 42', NULL::VARCHAR, ?); +-- +ok +== +SELECT replace_type(42, NULL::INTEGER, NULL); +-- +ok +== +select replace_type({duck: 3.141592653589793::DOUBLE, goose: 2.718281828459045::DOUBLE}, NULL::DOUBLE, NULL::DECIMAL(15,2)) +-- +ok +== +select replace_type(map {'duck': 3.141592653589793::DOUBLE, 'goose': 2.718281828459045::DOUBLE}, NULL::DOUBLE, NULL::DECIMAL(15,2)) +-- +ok +== +select replace_type([3.141592653589793, 2.718281828459045]::DOUBLE[], NULL::DOUBLE, NULL::DECIMAL(15,2)) +-- +ok +== +select replace_type([3.141592653589793, 2.718281828459045]::DOUBLE[2], NULL::DOUBLE, NULL::DECIMAL(15,2)) +-- +ok +== diff --git a/parser/testdata/corpus/sql/function/generic/table_func_varargs.test b/parser/testdata/corpus/sql/function/generic/table_func_varargs.test new file mode 100644 index 0000000..d91601b --- /dev/null +++ b/parser/testdata/corpus/sql/function/generic/table_func_varargs.test @@ -0,0 +1,9 @@ +# source: test/sql/function/generic/table_func_varargs.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +SELECT * FROM repeat_row(1, 2, 'foo', num_rows=3) +-- +ok +== diff --git a/parser/testdata/corpus/sql/function/generic/test_approx_database_count.test b/parser/testdata/corpus/sql/function/generic/test_approx_database_count.test new file mode 100644 index 0000000..5caa03c --- /dev/null +++ b/parser/testdata/corpus/sql/function/generic/test_approx_database_count.test @@ -0,0 +1,21 @@ +# source: test/sql/function/generic/test_approx_database_count.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +ATTACH '{TEST_DIR}/board1.db' AS b1; +-- +ok +== +ATTACH '{TEST_DIR}/board2.db' AS b2; +-- +ok +== +ATTACH '{TEST_DIR}/board3.db' AS b3; +-- +ok +== +SELECT approx_count >= 3 FROM duckdb_approx_database_count(); +-- +ok +== diff --git a/parser/testdata/corpus/sql/function/generic/test_between.test b/parser/testdata/corpus/sql/function/generic/test_between.test new file mode 100644 index 0000000..2199f8f --- /dev/null +++ b/parser/testdata/corpus/sql/function/generic/test_between.test @@ -0,0 +1,214 @@ +# source: test/sql/function/generic/test_between.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +SELECT 10 BETWEEN 10 AND 20 +-- +ok +== +SELECT 9 BETWEEN 10 AND 20 +-- +ok +== +SELECT 10 BETWEEN NULL AND 20 +-- +ok +== +SELECT 30 BETWEEN NULL AND 20 +-- +ok +== +SELECT 10 BETWEEN 10 AND NULL +-- +ok +== +SELECT 9 BETWEEN 10 AND NULL +-- +ok +== +SELECT NULL BETWEEN 10 AND 20 +-- +ok +== +SELECT NULL BETWEEN NULL AND 20 +-- +ok +== +SELECT NULL BETWEEN 10 AND NULL +-- +ok +== +SELECT NULL BETWEEN NULL AND NULL +-- +ok +== +SELECT i BETWEEN 1 AND 2 FROM integers ORDER BY i +-- +ok +== +SELECT i BETWEEN NULL AND 2 FROM integers ORDER BY i +-- +ok +== +SELECT i BETWEEN 2 AND NULL FROM integers ORDER BY i +-- +ok +== +SELECT COUNT(*) FROM integers WHERE 10 BETWEEN 10 AND 20 +-- +ok +== +SELECT COUNT(*) FROM integers WHERE 9 BETWEEN 10 AND 20 +-- +ok +== +SELECT COUNT(*) FROM integers WHERE 10 BETWEEN NULL AND 20 +-- +ok +== +SELECT COUNT(*) FROM integers WHERE 30 BETWEEN NULL AND 20 +-- +ok +== +SELECT COUNT(*) FROM integers WHERE 10 BETWEEN 10 AND NULL +-- +ok +== +SELECT COUNT(*) FROM integers WHERE 9 BETWEEN 10 AND NULL +-- +ok +== +SELECT COUNT(*) FROM integers WHERE NULL BETWEEN 10 AND 20 +-- +ok +== +SELECT COUNT(*) FROM integers WHERE NULL BETWEEN NULL AND 20 +-- +ok +== +SELECT COUNT(*) FROM integers WHERE NULL BETWEEN 10 AND NULL +-- +ok +== +SELECT COUNT(*) FROM integers WHERE NULL BETWEEN NULL AND NULL +-- +ok +== +SELECT COUNT(*) FROM integers WHERE i BETWEEN 1 AND 2 +-- +ok +== +SELECT COUNT(*) FROM integers WHERE i BETWEEN NULL AND 2 +-- +ok +== +SELECT COUNT(*) FROM integers WHERE i BETWEEN 2 AND NULL +-- +ok +== +SELECT COUNT(*) FROM integers WHERE NULL BETWEEN -1 AND +1 +-- +ok +== +SELECT COUNT(*) FROM integers WHERE 0 BETWEEN -1 AND +1 +-- +ok +== +SELECT COUNT(*) FROM integers WHERE i BETWEEN i-1 AND i+1 +-- +ok +== +SELECT COUNT(*) FROM integers WHERE i BETWEEN i-1 AND 10 +-- +ok +== +SELECT COUNT(*) FROM integers WHERE i BETWEEN NULL AND NULL +-- +ok +== +SELECT COUNT(*) FROM integers WHERE i BETWEEN i-1 AND NULL +-- +ok +== +SELECT COUNT(*) FROM integers WHERE i BETWEEN 0 AND i+1 +-- +ok +== +SELECT COUNT(*) FROM integers WHERE i BETWEEN NULL AND i+1 +-- +ok +== +SELECT COUNT(*) FROM integers WHERE 1 BETWEEN i-1 AND i+1 +-- +ok +== +SELECT COUNT(*) FROM integers WHERE NULL BETWEEN i-1 AND i+1 +-- +ok +== +SELECT COUNT(*) FROM integers WHERE NULL BETWEEN i-1 AND NULL +-- +ok +== +SELECT COUNT(*) FROM integers WHERE 1 BETWEEN i-1 AND 100 +-- +ok +== +SELECT COUNT(*) FROM integers WHERE 1 BETWEEN 0 AND i-1 +-- +ok +== +SELECT * FROM integers WHERE i >= 1 AND i < 2 +-- +ok +== +SELECT * FROM integers WHERE i > 1 AND i <= 2 +-- +ok +== +SELECT * FROM range(4) tbl(i) WHERE i >= 1 AND i < 2 +-- +ok +== +SELECT * FROM range(4) tbl(i) WHERE i > 1 AND i <= 2 +-- +ok +== +CREATE TABLE issue3588(c0 INT); +-- +ok +== +SELECT * +FROM issue3588 +WHERE (SELECT 0) BETWEEN 0 AND issue3588.c0; +-- +ok +== +SELECT "__between"(2,0,10) +-- +ok +== +CREATE TABLE between_pushdown_t2(a INT, b INT, c INT); +-- +ok +== +INSERT INTO between_pushdown_t2 VALUES + (1, 0, 10), + (5, 5, 5), + (3, 1, 2), + (8, 0, 100), + (10, 1, 10), + (15, 0, 20), + (0, -5, 100), + (7, 8, 20); +-- +ok +== +SELECT a +FROM between_pushdown_t2 +WHERE (random() * 0 + a) BETWEEN b AND 10 +ORDER BY a; +-- +ok +== diff --git a/parser/testdata/corpus/sql/function/generic/test_between_sideeffects.test b/parser/testdata/corpus/sql/function/generic/test_between_sideeffects.test new file mode 100644 index 0000000..cd92704 --- /dev/null +++ b/parser/testdata/corpus/sql/function/generic/test_between_sideeffects.test @@ -0,0 +1,37 @@ +# source: test/sql/function/generic/test_between_sideeffects.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +PREPARE v1 AS SELECT ? BETWEEN 1 AND 2 +-- +ok +== +EXECUTE v1(3) +-- +ok +== +EXECUTE v1(1, 2) +-- +ok +== +PREPARE v2 AS SELECT 1 WHERE ? BETWEEN now() - INTERVAL '1 minute' AND now() + INTERVAL '1 minute'; +-- +ok +== +EXECUTE v2(now()) +-- +ok +== +EXECUTE v2(now() - INTERVAL '10 minute') +-- +ok +== +SELECT (RANDOM() * 10)::INT BETWEEN 6 AND 5 +-- +ok +== +SELECT (RANDOM() * 10)::INT NOT BETWEEN 6 AND 5 +-- +ok +== diff --git a/parser/testdata/corpus/sql/function/generic/test_boolean_test.test b/parser/testdata/corpus/sql/function/generic/test_boolean_test.test new file mode 100644 index 0000000..2954844 --- /dev/null +++ b/parser/testdata/corpus/sql/function/generic/test_boolean_test.test @@ -0,0 +1,77 @@ +# source: test/sql/function/generic/test_boolean_test.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +select true is true +-- +ok +== +select false is true +-- +ok +== +select null is true +-- +ok +== +select 42 is true +-- +ok +== +select 0 is true +-- +ok +== +select true is not true +-- +ok +== +select false is not true +-- +ok +== +select null is not true +-- +ok +== +select 42 is not true +-- +ok +== +select 0 is not true +-- +ok +== +select null is null +-- +ok +== +select 42 is null +-- +ok +== +select null is not null +-- +ok +== +select 42 is not null +-- +ok +== +select null is unknown +-- +ok +== +select 42 is unknown +-- +ok +== +select null is not unknown +-- +ok +== +select 42 is not unknown +-- +ok +== diff --git a/parser/testdata/corpus/sql/function/generic/test_connection_count.test b/parser/testdata/corpus/sql/function/generic/test_connection_count.test new file mode 100644 index 0000000..c016908 --- /dev/null +++ b/parser/testdata/corpus/sql/function/generic/test_connection_count.test @@ -0,0 +1,9 @@ +# source: test/sql/function/generic/test_connection_count.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +SELECT count FROM duckdb_connection_count(); +-- +ok +== diff --git a/parser/testdata/corpus/sql/function/generic/test_if.test b/parser/testdata/corpus/sql/function/generic/test_if.test new file mode 100644 index 0000000..adc1687 --- /dev/null +++ b/parser/testdata/corpus/sql/function/generic/test_if.test @@ -0,0 +1,25 @@ +# source: test/sql/function/generic/test_if.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +SELECT IF(true, 1, 10), IF(false, 1, 10), IF(NULL, 1, 10) +-- +ok +== +SELECT IF(true, 20, 2000), IF(false, 20, 2000), IF(NULL, 20, 2000) +-- +ok +== +SELECT IF(true, 20.5, 2000), IF(false, 20, 2000.5), IF(NULL, 20, 2000.5) +-- +ok +== +SELECT IF(true, '2020-05-05'::date, '1996-11-05 10:11:56'::timestamp), IF(false, '2020-05-05'::date, '1996-11-05 10:11:56'::timestamp), IF(NULL, '2020-05-05'::date, '1996-11-05 10:11:56'::timestamp) +-- +ok +== +SELECT IF(true, 'true', 'false'), IF(false, 'true', 'false'), IF(NULL, 'true', 'false') +-- +ok +== diff --git a/parser/testdata/corpus/sql/function/generic/test_if_null.test b/parser/testdata/corpus/sql/function/generic/test_if_null.test new file mode 100644 index 0000000..cd01fb5 --- /dev/null +++ b/parser/testdata/corpus/sql/function/generic/test_if_null.test @@ -0,0 +1,21 @@ +# source: test/sql/function/generic/test_if_null.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +SELECT IFNULL(NULL, NULL), IFNULL(NULL, 10), IFNULL(1, 10) +-- +ok +== +SELECT IFNULL(NULL, 2000), IFNULL(20.5, 2000) +-- +ok +== +SELECT IFNULL(NULL, '1996-11-05 10:11:56'::timestamp), IFNULL('2020-05-05'::date, '1996-11-05 10:11:56'::timestamp) +-- +ok +== +SELECT IFNULL(NULL, 'not NULL'), IFNULL('NULL', 'not NULL') +-- +ok +== diff --git a/parser/testdata/corpus/sql/function/generic/test_in.test b/parser/testdata/corpus/sql/function/generic/test_in.test new file mode 100644 index 0000000..0d097ec --- /dev/null +++ b/parser/testdata/corpus/sql/function/generic/test_in.test @@ -0,0 +1,142 @@ +# source: test/sql/function/generic/test_in.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +SELECT * FROM integers WHERE i IN (1, 2) ORDER BY i +-- +ok +== +SELECT * FROM integers WHERE i IN (1, 2, 3, 4, 5, 6, 7, 8) ORDER BY i +-- +ok +== +SELECT i, i IN (1, 2, 3, 4, 5, 6, 7, 8) FROM integers ORDER BY i +-- +ok +== +SELECT i, i NOT IN (1, 3, 4, 5, 6, 7, 8) FROM integers ORDER BY i +-- +ok +== +SELECT i, i IN (1, 2, NULL, 4, 5, 6, 7, 8) FROM integers ORDER BY i +-- +ok +== +SELECT i, i IN (i + 1) FROM integers ORDER BY i +-- +ok +== +SELECT i, i IN (i + 1, 42, i) FROM integers ORDER BY i +-- +ok +== +SELECT i, 1 IN (i - 1, i, i + 1) FROM integers ORDER BY i +-- +ok +== +SELECT i, 1 NOT IN (i - 1, i, i + 1) FROM integers ORDER BY i +-- +ok +== +SELECT i, i IN (11, 12, 13, 14, 15, 16, 17, 18, 1, i) FROM integers ORDER BY i +-- +ok +== +SELECT i, i NOT IN (11, 12, 13, 14, 15, 16, 17, 18, 1, i) FROM integers ORDER BY i +-- +ok +== +SELECT i, 1 IN (11, 12, 13, 14, 15, 16, 17, 18, 1, i) FROM integers ORDER BY i +-- +ok +== +SELECT i, 1 NOT IN (11, 12, 13, 14, 15, 16, 17, 18, 1, i) FROM integers ORDER BY i +-- +ok +== +SELECT i, i IN ((SELECT MAX(i) FROM integers), (SELECT MIN(i) FROM integers)) FROM integers ORDER BY i +-- +ok +== +SELECT i, (SELECT MAX(i) FROM integers WHERE i <> i1.i), (SELECT MIN(i) FROM integers WHERE i <= i1.i) FROM integers i1 ORDER BY i +-- +ok +== +SELECT i, i IN ((SELECT MAX(i) FROM integers WHERE i <> i1.i), (SELECT MIN(i) FROM integers WHERE i <= i1.i)) FROM integers i1 ORDER BY i +-- +ok +== +SELECT 1 IN [1, 2, 3]; +-- +ok +== +SELECT 1 IN [2, 2, 3]; +-- +ok +== +PREPARE v1 AS SELECT 1 IN ? +-- +ok +== +EXECUTE v1([]); +-- +ok +== +SELECT 1 IN []; +-- +ok +== +EXECUTE v1([1, 2, 3]); +-- +ok +== +EXECUTE v1([2, 2, 3]); +-- +ok +== +with list_provider as ( + select [1, 2] as lst +) +SELECT i FROM ( + from integers, list_provider +) t(i, lst) WHERE i IN lst ORDER BY i +-- +ok +== +with list_provider as ( + select [1, 2, 3, 4, 5, 6, 7, 8] as lst +) +SELECT i FROM ( + from integers, list_provider +) t(i, lst) WHERE i IN lst ORDER BY i +-- +ok +== +with list_provider as ( + select [1, 2, 3, 4, 5, 6, 7, 8] as lst +) +SELECT i, i IN lst FROM ( + from integers, list_provider +) t(i, lst) order by i +-- +ok +== +with list_provider as ( + select [1, 3, 4, 5, 6, 7, 8] as lst +) +SELECT i, i NOT IN lst FROM ( + from integers, list_provider +) t(i, lst) order by i +-- +ok +== +with list_provider as ( + select [1, 2, NULL, 4, 5, 6, 7, 8] as lst +) +SELECT i, i IN lst FROM ( + from integers, list_provider +) t(i, lst) order by i +-- +ok +== diff --git a/parser/testdata/corpus/sql/function/generic/test_least_greatest.test b/parser/testdata/corpus/sql/function/generic/test_least_greatest.test new file mode 100644 index 0000000..c9cab29 --- /dev/null +++ b/parser/testdata/corpus/sql/function/generic/test_least_greatest.test @@ -0,0 +1,137 @@ +# source: test/sql/function/generic/test_least_greatest.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +SELECT LEAST(1) +-- +ok +== +SELECT LEAST('hello world') +-- +ok +== +SELECT LEAST(1, 3) +-- +ok +== +SELECT LEAST(1, 3, 0) +-- +ok +== +SELECT LEAST(1, 3, 0, 2, 7, 8, 10, 11, -100, 30) +-- +ok +== +SELECT LEAST(1, 3, 0, 2, 7, 8, 10, 11, -100, 30, NULL) +-- +ok +== +SELECT LEAST(NULL, 3, 0, 2, 7, 8, 10, 11, -100, 30, 1) +-- +ok +== +SELECT GREATEST(NULL, 1.0::FLOAT) +-- +ok +== +SELECT LEAST(1.0, 10.0) +-- +ok +== +SELECT LEAST('hello', 'world') +-- +ok +== +SELECT LEAST('hello', 'world', 'blabla', 'tree') +-- +ok +== +SELECT LEAST(DATE '1992-01-01', DATE '1994-02-02', DATE '1991-01-01') +-- +ok +== +SELECT LEAST(DATE '1992-01-01', DATE '1994-02-02', DATE '1991-01-01', NULL) +-- +ok +== +SELECT LEAST(DATE '1992-01-01', DATE '1994-02-02', DATE '1991-01-01', DATE 'infinity', DATE '-infinity') +-- +ok +== +SELECT GREATEST(DATE '1992-01-01', DATE '1994-02-02', DATE '1991-01-01', DATE 'infinity', DATE '-infinity') +-- +ok +== +SELECT LEAST(TIMESTAMP '1992-01-01 13:45:21.890123', TIMESTAMP '1994-02-02 05:43:21', TIMESTAMP '1991-01-01 01:23:45') +-- +ok +== +SELECT LEAST(TIMESTAMP '1992-01-01 13:45:21.890123', TIMESTAMP '1994-02-02 05:43:21', TIMESTAMP '1991-01-01 01:23:45', NULL) +-- +ok +== +SELECT LEAST(TIMESTAMP '1992-01-01 13:45:21.890123', TIMESTAMP '1994-02-02 05:43:21', TIMESTAMP '1991-01-01 01:23:45', TIMESTAMP 'infinity', TIMESTAMP '-infinity') +-- +ok +== +SELECT GREATEST(TIMESTAMP '1992-01-01 13:45:21.890123', TIMESTAMP '1994-02-02 05:43:21', TIMESTAMP '1991-01-01 01:23:45', TIMESTAMP 'infinity', TIMESTAMP '-infinity') +-- +ok +== +SELECT LEAST(DATE '1992-01-01', 'hello', 123) +-- +ok +== +CREATE TABLE t1(i INTEGER, j INTEGER); +-- +ok +== +INSERT INTO t1 VALUES (1, NULL), (2, 1), (3, 7); +-- +ok +== +SELECT LEAST(i, j), GREATEST(i, j) FROM t1 ORDER BY i; +-- +ok +== +SELECT LEAST(i, i + 1, j), GREATEST(i, i - 1, j) FROM t1 ORDER BY i; +-- +ok +== +SELECT LEAST(i, 800, i + 1, 1000, j), GREATEST(i, -1000, i - 1, -700, j, -800) FROM t1 ORDER BY i; +-- +ok +== +SELECT LEAST(i, 800, i + 1, 1000, j, NULL), GREATEST(i, -1000, i - 1, -700, j, -800) FROM t1 ORDER BY i; +-- +ok +== +SELECT LEAST(i, j), GREATEST(i, j) FROM t1 WHERE j IS NOT NULL ORDER BY i; +-- +ok +== +SELECT LEAST(rowid + 10, i, j), GREATEST(i, rowid + 4, j) FROM t1 WHERE j IS NOT NULL ORDER BY i; +-- +ok +== +SELECT LEAST(REPEAT(i::VARCHAR, 20), j::VARCHAR) FROM t1; +-- +ok +== +SELECT greatest(CAST(52392441565678.308 AS DECIMAL(17,3)), CAST(52392441565678.308 AS DECIMAL(17,3))); +-- +ok +== +CREATE SEQUENCE least_greatest_sequence; +-- +ok +== +SELECT greatest(nextval('least_greatest_sequence'), nextval('least_greatest_sequence')); +-- +ok +== +SELECT least(nextval('least_greatest_sequence'), nextval('least_greatest_sequence')); +-- +ok +== diff --git a/parser/testdata/corpus/sql/function/generic/test_null_if.test b/parser/testdata/corpus/sql/function/generic/test_null_if.test new file mode 100644 index 0000000..1d5a3c1 --- /dev/null +++ b/parser/testdata/corpus/sql/function/generic/test_null_if.test @@ -0,0 +1,41 @@ +# source: test/sql/function/generic/test_null_if.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +SELECT NULLIF(NULLIF ('hello', 'world'), 'blabla'); +-- +ok +== +CREATE TABLE test (a STRING); +-- +ok +== +INSERT INTO test VALUES ('hello'), ('world'), ('test') +-- +ok +== +CREATE TABLE test2 (a STRING, b STRING); +-- +ok +== +INSERT INTO test2 VALUES ('blabla', 'b'), ('blabla2', 'c'), ('blabla3', 'd') +-- +ok +== +SELECT NULLIF(NULLIF ((SELECT a FROM test LIMIT 1 offset 1), a), b) FROM test2 +-- +ok +== +INSERT INTO test3 VALUES (11, 22), (13, 22), (12, 21) +-- +ok +== +SELECT NULLIF(CAST(a AS VARCHAR), '11') FROM test3; +-- +ok +== +SELECT a, CASE WHEN a>11 THEN CAST(a AS VARCHAR) ELSE CAST(b AS VARCHAR) END FROM test3 ORDER BY 1; +-- +ok +== diff --git a/parser/testdata/corpus/sql/function/generic/test_set.test b/parser/testdata/corpus/sql/function/generic/test_set.test new file mode 100644 index 0000000..e828cb4 --- /dev/null +++ b/parser/testdata/corpus/sql/function/generic/test_set.test @@ -0,0 +1,57 @@ +# source: test/sql/function/generic/test_set.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +SELECT CURRENT_SETTING('a'); +-- +ok +== +SELECT CURRENT_SETTING('memori_limit'); +-- +ok +== +SELECT CURRENT_SETTING('default_null_order'); +-- +ok +== +SET default_null_order = 'nulls_last'; +-- +ok +== +SET default_null_order = concat('nulls', '_', 'last'); +-- +ok +== +SELECT CURRENT_SETTING('DEFAULT_NULL_ORDER'); +-- +ok +== +SELECT * FROM range(3) UNION ALL SELECT NULL ORDER BY 1 +-- +ok +== +SELECT CURRENT_SETTING(i::VARCHAR) FROM range(1) tbl(i) +-- +ok +== +SELECT CURRENT_SETTING(NULL) +-- +ok +== +SELECT CURRENT_SETTING(CAST(NULL AS TEXT)) +-- +ok +== +SELECT CURRENT_SETTING('') +-- +error: Parser Error: Key name for current_setting must not be empty +== +SET default_null_order = colref || '_last'; +-- +ok +== +SET default_null_order = (SELECT 'nulls_last') +-- +ok +== diff --git a/parser/testdata/corpus/sql/function/generic/test_set.test.metadata.json b/parser/testdata/corpus/sql/function/generic/test_set.test.metadata.json new file mode 100644 index 0000000..2ddb5cf --- /dev/null +++ b/parser/testdata/corpus/sql/function/generic/test_set.test.metadata.json @@ -0,0 +1,5 @@ +{ + "todo": { + "ce1dfea629d91c5a": "transformer-raised parser error: upstream rejects in the transformer, not the grammar; expected to clear as transformers land (milestones 3-5)" + } +} diff --git a/parser/testdata/corpus/sql/function/generic/test_sleep.test b/parser/testdata/corpus/sql/function/generic/test_sleep.test new file mode 100644 index 0000000..e7f7e03 --- /dev/null +++ b/parser/testdata/corpus/sql/function/generic/test_sleep.test @@ -0,0 +1,133 @@ +# source: test/sql/function/generic/test_sleep.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +SELECT sleep_ms(1) +-- +ok +== +SELECT sleep_ms(0) +-- +ok +== +SELECT sleep_ms(NULL) +-- +ok +== +SELECT 1, sleep_ms(1), 2 +-- +ok +== +SELECT 42 WHERE sleep_ms(1) IS NULL +-- +ok +== +SELECT sleep_ms(1) FROM range(3) +-- +ok +== +SELECT sleep_ms(1 + 1) +-- +ok +== +SELECT sleep_ms(-10) +-- +ok +== +CREATE TABLE test_sleep_table AS SELECT * FROM range(5) tbl(id); +-- +ok +== +SELECT id, sleep_ms(1) FROM test_sleep_table ORDER BY id +-- +ok +== +SELECT id, sleep_ms(1) FROM test_sleep_table WHERE id < 3 ORDER BY id +-- +ok +== +DROP TABLE test_sleep_table +-- +ok +== +SELECT sleep_ms(sleep_ms(1)) +-- +ok +== +PRAGMA enable_profiling = 'json' +-- +ok +== +PRAGMA profiling_output = '{TEST_DIR}/sleep_nested_profiling.json' +-- +error: Parser Error: Profiler file type ({TEST_DIR}/sleep_nested_profiling.json) must either have the same file extension as the profiling output type (query_tree), or be a '.txt' file. Set "enable_profiling = 'json'" first. +== +SELECT sleep_ms(sleep_ms(50)) FROM range(1) +-- +ok +== +CREATE OR REPLACE TABLE sleep_nested_profiling AS SELECT * FROM read_json('{TEST_DIR}/sleep_nested_profiling.json') +-- +ok +== +SELECT query.cpu_time >= 0.05 FROM sleep_nested_profiling WHERE contains(query.sql, 'sleep_ms') LIMIT 1 +-- +ok +== +DROP TABLE sleep_nested_profiling +-- +ok +== +SELECT sleep_ms(sleep_ms(NULL)) +-- +ok +== +SELECT sleep_ms(sleep_ms(0)) +-- +ok +== +SELECT 42 WHERE sleep_ms(sleep_ms(1)) IS NULL +-- +ok +== +SELECT sleep_ms(sleep_ms(1 + 1)) +-- +ok +== +SELECT sleep_ms(sleep_ms(1)) FROM range(3) +-- +ok +== +SELECT pg_sleep(0.001) +-- +ok +== +SELECT pg_sleep(0) +-- +ok +== +SELECT pg_sleep(NULL) +-- +ok +== +SELECT 1, pg_sleep(0.001), 2 +-- +ok +== +SELECT 42 WHERE pg_sleep(0.001) IS NULL +-- +ok +== +SELECT pg_sleep(0.001) FROM range(3) +-- +ok +== +SELECT pg_sleep(0.001 + 0.001) +-- +ok +== +SELECT pg_sleep(-0.1) +-- +ok +== diff --git a/parser/testdata/corpus/sql/function/generic/test_sleep.test.metadata.json b/parser/testdata/corpus/sql/function/generic/test_sleep.test.metadata.json new file mode 100644 index 0000000..dc7d9c6 --- /dev/null +++ b/parser/testdata/corpus/sql/function/generic/test_sleep.test.metadata.json @@ -0,0 +1,5 @@ +{ + "todo": { + "441cdc2cfa306834": "transformer-raised parser error: upstream rejects in the transformer, not the grammar; expected to clear as transformers land (milestones 3-5)" + } +} diff --git a/parser/testdata/corpus/sql/function/generic/test_stats.test b/parser/testdata/corpus/sql/function/generic/test_stats.test new file mode 100644 index 0000000..99a08cb --- /dev/null +++ b/parser/testdata/corpus/sql/function/generic/test_stats.test @@ -0,0 +1,49 @@ +# source: test/sql/function/generic/test_stats.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +select 1=1 +-- +ok +== +SELECT s.min, s.max, s.has_null, s.has_no_null FROM (SELECT STATS(5) s); +-- +ok +== +SELECT s.min, s.max, s.has_null, s.has_no_null, s.has_unicode, s.max_string_length FROM (SELECT STATS('hello') s); +-- +ok +== +SELECT s.min, s.max, s.has_null, s.has_no_null, s.has_unicode, s.max_string_length FROM (SELECT STATS('1234567ü') s); +-- +ok +== +SELECT s.min, s.max, s.has_null, s.has_no_null FROM (SELECT STATS(5 + 2) s); +-- +ok +== +SELECT s.min, s.max, s.has_null, s.has_no_null FROM (SELECT STATS(i) s FROM integers LIMIT 1); +-- +ok +== +SELECT s.min, s.max, s.has_null, s.has_no_null FROM (SELECT STATS(i + 2) s FROM integers LIMIT 1); +-- +ok +== +SELECT s.min, s.max, s.has_null, s.has_no_null FROM (SELECT STATS(i - 5) s FROM integers LIMIT 1); +-- +ok +== +SELECT s.min, s.max, s.has_null, s.has_no_null FROM (SELECT STATS(i * 2) s FROM integers LIMIT 1); +-- +ok +== +SELECT s.min, s.max, s.has_null, s.has_no_null FROM (SELECT STATS(i * -1) s FROM integers LIMIT 1); +-- +ok +== +SELECT STATS(i+1) FROM integers LIMIT 1; +-- +ok +== diff --git a/parser/testdata/corpus/sql/function/generic/test_table_param.test b/parser/testdata/corpus/sql/function/generic/test_table_param.test new file mode 100644 index 0000000..a7afc20 --- /dev/null +++ b/parser/testdata/corpus/sql/function/generic/test_table_param.test @@ -0,0 +1,21 @@ +# source: test/sql/function/generic/test_table_param.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +create table a (i double, j double); +-- +ok +== +insert into a values (1, 10), (42, 420); +-- +ok +== +EXPLAIN SELECT * FROM summary((SELECT * FROM a)) +-- +ok +== +SELECT * FROM summary((SELECT * FROM a)) +-- +ok +== diff --git a/parser/testdata/corpus/sql/function/index/index_key.test b/parser/testdata/corpus/sql/function/index/index_key.test new file mode 100644 index 0000000..1a225ec --- /dev/null +++ b/parser/testdata/corpus/sql/function/index/index_key.test @@ -0,0 +1,296 @@ +# source: test/sql/function/index/index_key.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +CREATE TABLE tbl1( + id INTEGER PRIMARY KEY, + uid BIGINT UNIQUE, + d DATE AS (DATE '2000-01-01'), + txt VARCHAR +); +-- +ok +== +CREATE UNIQUE INDEX tbl1_idx_composite ON tbl1(id, txt); +-- +ok +== +CREATE UNIQUE INDEX tbl1_idx_txt ON tbl1(txt); +-- +ok +== +INSERT INTO tbl1 (id, uid, txt) VALUES (1, 10, 'alpha'), (2, 20, 'beta'), (3, 30, 'gamma'); +-- +ok +== +CREATE TABLE tbl2( + ref_id INTEGER PRIMARY KEY, + ref_txt VARCHAR, + tbl1_id INTEGER, + FOREIGN KEY (tbl1_id) REFERENCES tbl1(id) +); +-- +ok +== +CREATE TABLE tbl3( + key1 INTEGER, + key2 VARCHAR, + key3 BIGINT, + extra_data VARCHAR +); +-- +ok +== +CREATE UNIQUE INDEX tbl3_idx ON tbl3(key1, key2, key3); +-- +ok +== +INSERT INTO tbl3(key1, key2, key3, extra_data) +SELECT + i, + 'row' || i::VARCHAR, + CASE WHEN i <= 62 THEN 1::BIGINT << i ELSE i::BIGINT END, + 'extra_' || i::VARCHAR +FROM generate_series(1, 100) AS t(i); +-- +ok +== +SELECT index_key({'table': 'tbl1'}, 'tbl1_idx_composite', 1, 'alpha'); +-- +ok +== +SELECT index_key({'schema': 'main', 'table': 'tbl1'}, 'tbl1_idx_composite', 1, 'alpha'); +-- +ok +== +SELECT index_key({'catalog': current_catalog(), 'table': 'tbl1'}, 'PRIMARY_tbl1_0', 1); +-- +ok +== +SELECT index_key({'catalog': current_catalog(), 'schema': 'main', 'table': 'tbl1'}, 'tbl1_idx_composite', 1, 'alpha'); +-- +ok +== +SELECT index_key({'catalog': '', 'table': 'tbl1'}, 'PRIMARY_tbl1_0', 1); +-- +ok +== +SELECT index_key({'catalog': NULL::VARCHAR, 'table': 'tbl1'}, 'PRIMARY_tbl1_0', 1); +-- +ok +== +SELECT index_key({'schema': NULL::VARCHAR, 'table': 'tbl1'}, 'PRIMARY_tbl1_0', 1); +-- +ok +== +SELECT index_key({'table': 'tbl1'}, 'PRIMARY_tbl1_0', 1); +-- +ok +== +SELECT index_key({'table': 'tbl1'}, 'UNIQUE_tbl1_1', 20::BIGINT); +-- +ok +== +SELECT index_key({'table': 'tbl2'}, 'FOREIGN_tbl2_1', 1); +-- +ok +== +SELECT index_key({'table': 'tbl1'}, 'PRIMARY_tbl1_0', 143243243242432::BIGINT); +-- +ok +== +CREATE TABLE tbl3_wrong_type(c1 VARCHAR, c2 INTEGER, c3 BIGINT); +-- +ok +== +INSERT INTO tbl3_wrong_type VALUES ('test', 1, 100); +-- +ok +== +SELECT index_key({'table': 'tbl3'}, 'tbl3_idx', c1, c2, c3) FROM tbl3_wrong_type; +-- +ok +== +SELECT index_key({'table': 'tbl1'}, 'UNIQUE_tbl1_1', 42::SMALLINT); +-- +ok +== +SELECT index_key({'table': 'tbl1'}, 'tbl1_idx_composite', id, txt) +FROM tbl1 +WHERE id IN (1, 2, 3) +ORDER BY txt DESC; +-- +ok +== +SELECT index_key({'table': 'tbl1'}, 'PRIMARY_tbl1_0', v.id) +FROM (VALUES (1), (2), (3), (4), (5), (6), (7), (8), (9), (10), (11), (12)) AS v(id); +-- +ok +== +SELECT + index_key({'table': 'tbl1'}, 'tbl1_idx_composite', v.id, v.txt) AS composite_key, + index_key({'table': 'tbl1'}, 'PRIMARY_tbl1_0', v.id) AS pkey_key +FROM (VALUES (1, 'alpha'), (2, 'beta')) AS v(id, txt); +-- +ok +== +SELECT index_key({'table': 'tbl3'}, 'tbl3_idx', key1, key2, key3) +FROM tbl3 +WHERE key1 BETWEEN 1 AND 4 OR key1 BETWEEN 6 AND 16 +ORDER BY key1; +-- +ok +== +SELECT index_key({'schema': 'main', 'table': 'tbl3'}, 'tbl3_idx', key1, key2, key3) +FROM tbl3 +WHERE key1 BETWEEN 1 AND 4 +ORDER BY key1; +-- +ok +== +SELECT index_key({'catalog': current_catalog(), 'schema': 'main', 'table': 'tbl3'}, 'tbl3_idx', key1, key2, key3) +FROM tbl3 +WHERE key1 BETWEEN 1 AND 3 +ORDER BY key1; +-- +ok +== +SELECT COUNT(*) +FROM (SELECT index_key({'table': 'tbl3'}, 'tbl3_idx', key1, key2, key3) as key_blob + FROM tbl3); +-- +ok +== +CREATE TABLE other.tbl1(id INTEGER PRIMARY KEY); +-- +ok +== +SELECT index_key({'catalog': 'other', 'table': 'tbl1'}, 'PRIMARY_tbl1_0', 42); +-- +ok +== +CREATE TABLE test_schema.tbl4(id INTEGER PRIMARY KEY, value VARCHAR); +-- +ok +== +INSERT INTO test_schema.tbl4 VALUES (1, 'test1'), (2, 'test2'); +-- +ok +== +SELECT index_key({'schema': 'test_schema', 'table': 'tbl4'}, 'PRIMARY_tbl4_0', id) +FROM test_schema.tbl4 +ORDER BY id; +-- +ok +== +SELECT index_key({'table': 'tbl' || '1'}, 'PRIMARY_tbl1_0', 1); +-- +ok +== +SELECT index_key({'table': 'tbl1'}, 'PRIMARY_' || 'tbl1_0', 1); +-- +ok +== +SELECT index_key({'table': 'tbl1'}, txt, 1) FROM tbl1; +-- +ok +== +SELECT index_key($1, 'PRIMARY_tbl1_0', 1); +-- +ok +== +SELECT index_key({'schema': 'main'}, 'PRIMARY_tbl1_0', 1); +-- +ok +== +SELECT index_key({'table': NULL::VARCHAR}, 'PRIMARY_tbl1_0', 1); +-- +ok +== +SELECT index_key({'table': 123}, 'PRIMARY_tbl1_0', 1); +-- +ok +== +SELECT index_key({'table': ''}, 'PRIMARY_tbl1_0', 1); +-- +ok +== +SELECT index_key({'foo': 'bar', 'table': 'tbl1'}, 'PRIMARY_tbl1_0', 1); +-- +ok +== +SELECT index_key('tbl1', 'PRIMARY_tbl1_0', 1); +-- +ok +== +SELECT index_key({'schema': 'main', 'schema': 'main', 'table': 'tbl1'}, 'PRIMARY_tbl1_0', 1); +-- +ok +== +SELECT index_key({'table': 'tbl1'}, NULL, 1); +-- +ok +== +SELECT index_key({'table': 'tbl1'}, 'tbl1_idx_composite', NULL::INTEGER, NULL::VARCHAR); +-- +ok +== +SELECT index_key(NULL::STRUCT(t VARCHAR), 'PRIMARY_tbl1_0', 1); +-- +ok +== +SELECT index_key({'table': 'tbl1'}, 'PRIMARY_tbl1_0', v.id) +FROM (VALUES (1), (NULL), (2), (NULL), (3)) AS v(id); +-- +ok +== +SELECT index_key({'table': 'tbl1'}, 'tbl1_idx_composite', v.id, v.txt) +FROM (VALUES (1, 'a'), (NULL, 'b'), (2, NULL), (NULL, NULL), (3, 'c')) AS v(id, txt); +-- +ok +== +SELECT index_key({'table': 'tbl1'}); +-- +ok +== +SELECT index_key({'table': 'tbl1'}, 'tbl1_idx_composite', 1); +-- +ok +== +SELECT index_key({'table': 'nonexistent_table'}, 'PRIMARY_tbl1_0', 1); +-- +ok +== +SELECT index_key({'table': 'tbl1'}, 'nonexistent_index', 1); +-- +ok +== +SELECT index_key({'table': 'tbl2'}, 'FOREIGN_tbl2_2', 1); +-- +ok +== +CREATE TABLE no_index_tbl(id INTEGER, value VARCHAR); +-- +ok +== +SELECT index_key({'table': 'no_index_tbl'}, 'some_index', 1); +-- +ok +== +SELECT index_key({'schema': 'nonexistent_schema', 'table': 'tbl1'}, 'PRIMARY_tbl1_0', 1); +-- +ok +== +SELECT index_key({'catalog': 'nonexistent_catalog', 'table': 'tbl1'}, 'PRIMARY_tbl1_0', 1); +-- +ok +== +CREATE VIEW tbl1_view AS SELECT * FROM tbl1; +-- +ok +== +SELECT index_key({'table': 'tbl1_view'}, 'PRIMARY_tbl1_0', 1); +-- +ok +== diff --git a/parser/testdata/corpus/sql/function/interval/test_date_part.test b/parser/testdata/corpus/sql/function/interval/test_date_part.test new file mode 100644 index 0000000..a2cd057 --- /dev/null +++ b/parser/testdata/corpus/sql/function/interval/test_date_part.test @@ -0,0 +1,145 @@ +# source: test/sql/function/interval/test_date_part.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +CREATE TABLE intervals(i INTERVAL, s VARCHAR); +-- +ok +== +INSERT INTO intervals VALUES ('2 years', 'year'), ('16 months', 'quarter'), ('42 days', 'day'), ('2066343400 microseconds', 'minute'); +-- +ok +== +SELECT date_part(NULL::VARCHAR, NULL::INTERVAL) FROM intervals; +-- +ok +== +SELECT date_part(s, NULL::INTERVAL) FROM intervals; +-- +ok +== +SELECT date_part(NULL, i) FROM intervals; +-- +ok +== +SELECT date_part(s, INTERVAL '4 years 5 months 18 days 128 seconds') FROM intervals; +-- +ok +== +SELECT date_part('seconds', i) FROM intervals; +-- +ok +== +SELECT date_part('epoch', i) FROM intervals; +-- +ok +== +SELECT date_part(s, i) FROM intervals; +-- +ok +== +SELECT dayofweek(i) FROM intervals +-- +ok +== +SELECT isodow(i) FROM intervals +-- +ok +== +SELECT dayofyear(i) FROM intervals +-- +ok +== +SELECT week(i) FROM intervals +-- +ok +== +SELECT era(i) FROM intervals; +-- +ok +== +SELECT julian(i) FROM intervals; +-- +ok +== +SELECT extract(era from i) FROM intervals; +-- +ok +== +SELECT extract(julian from i) FROM intervals; +-- +ok +== +SELECT date_part('era', i) FROM intervals; +-- +ok +== +SELECT date_part('julian', i) FROM intervals; +-- +ok +== +SELECT date_part('offset', i) FROM intervals; +-- +ok +== +SELECT i, DATE_PART('{partcode}', i) AS p, {partcode}(i) AS f +FROM intervals +WHERE p <> f; +-- +error: Parser Error: syntax error at or near "}" +== +SELECT i, DATE_PART('{partcode}', i) AS p, DATE_PART(['{partcode}'], i) AS st +FROM intervals +WHERE p <> st['{partcode}']; +-- +ok +== +SELECT i, DATE_PART(['year', 'month', 'day'], i) AS parts +FROM intervals +ORDER BY 1; +-- +ok +== +SELECT i, DATE_PART(['millennium', 'century', 'decade', 'quarter'], i) AS parts +FROM intervals +ORDER BY 1; +-- +ok +== +SELECT i, DATE_PART(['hour', 'minute', 'second', 'epoch'], i) AS parts +FROM intervals +ORDER BY 1; +-- +ok +== +SELECT i, epoch_ns(i) AS parts +FROM intervals +ORDER BY 1; +-- +ok +== +SELECT i, epoch_us(i) AS parts +FROM intervals +ORDER BY 1; +-- +ok +== +SELECT i, epoch_ms(i) AS parts +FROM intervals +ORDER BY 1; +-- +ok +== +SELECT i, nanosecond(i) AS parts +FROM intervals +ORDER BY 1; +-- +ok +== +SELECT i, DATE_PART(['{datepart}'], i) AS parts +FROM intervals +ORDER BY 1; +-- +ok +== diff --git a/parser/testdata/corpus/sql/function/interval/test_extract.test b/parser/testdata/corpus/sql/function/interval/test_extract.test new file mode 100644 index 0000000..677abf2 --- /dev/null +++ b/parser/testdata/corpus/sql/function/interval/test_extract.test @@ -0,0 +1,129 @@ +# source: test/sql/function/interval/test_extract.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +CREATE TABLE intervals(i INTERVAL); +-- +ok +== +INSERT INTO intervals VALUES ('2 years'), ('16 months'), ('42 days'), ('2066343400 microseconds'), (NULL); +-- +ok +== +SELECT EXTRACT(year FROM i) FROM intervals +-- +ok +== +SELECT EXTRACT(month FROM i) FROM intervals +-- +ok +== +SELECT EXTRACT(day FROM i) FROM intervals +-- +ok +== +SELECT EXTRACT(decade FROM i) FROM intervals +-- +ok +== +SELECT EXTRACT(century FROM i) FROM intervals +-- +ok +== +SELECT EXTRACT(millennium FROM i) FROM intervals +-- +ok +== +SELECT EXTRACT(quarter FROM i) FROM intervals +-- +ok +== +SELECT EXTRACT(dayofweek FROM i) FROM intervals +-- +ok +== +SELECT EXTRACT(isodow FROM i) FROM intervals +-- +ok +== +SELECT EXTRACT(dayofyear FROM i) FROM intervals +-- +ok +== +SELECT EXTRACT(week FROM i) FROM intervals +-- +ok +== +SELECT EXTRACT(yearweek FROM i) FROM intervals +-- +ok +== +SELECT EXTRACT(epoch FROM i) FROM intervals +-- +ok +== +SELECT EXTRACT(microsecond FROM i) FROM intervals +-- +ok +== +SELECT EXTRACT(millisecond FROM i) FROM intervals +-- +ok +== +SELECT EXTRACT(second FROM i) FROM intervals +-- +ok +== +SELECT EXTRACT(minute FROM i) FROM intervals +-- +ok +== +SELECT EXTRACT(hour FROM i) FROM intervals +-- +ok +== +SELECT EXTRACT(year FROM interval '14 months ago') +-- +ok +== +SELECT EXTRACT(month FROM interval '14 months ago') +-- +ok +== +SELECT EXTRACT(day FROM interval '157 days ago') +-- +ok +== +SELECT EXTRACT(decade FROM interval '140 months ago') +-- +ok +== +SELECT EXTRACT(century FROM interval '1400 months ago') +-- +ok +== +SELECT EXTRACT(millennium FROM interval '14000 months ago') +-- +ok +== +SELECT EXTRACT(quarter FROM interval '14 months ago') +-- +ok +== +SELECT EXTRACT(quarter FROM interval '21 months ago') +-- +ok +== +SELECT EXTRACT(epoch FROM interval '6 months ago') +-- +ok +== +SELECT EXTRACT(doy FROM interval '6 months ago') +-- +ok +== +SELECT EXTRACT(dow FROM interval '6 months ago') +-- +ok +== diff --git a/parser/testdata/corpus/sql/function/interval/test_interval_muldiv.test b/parser/testdata/corpus/sql/function/interval/test_interval_muldiv.test new file mode 100644 index 0000000..38a8175 --- /dev/null +++ b/parser/testdata/corpus/sql/function/interval/test_interval_muldiv.test @@ -0,0 +1,58 @@ +# source: test/sql/function/interval/test_interval_muldiv.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +CREATE TABLE INTERVAL_MULDIV_TBL (span interval); +-- +ok +== +INSERT INTO INTERVAL_MULDIV_TBL VALUES + ('41 months 12 days 360:00'), + ('-41 months -12 days 360:00'), + ('-12 days'), + ('9 months -27 days 12:34:56'), + ('-3 years 482 days 76:54:32.189'), + ('4 months'), + ('14 months'), + ('999 months 999 days'), +; +-- +ok +== +SELECT span * 0.3 AS product +FROM INTERVAL_MULDIV_TBL; +-- +ok +== +SELECT span * 8.2 AS product +FROM INTERVAL_MULDIV_TBL; +-- +ok +== +SELECT span / 10 AS quotient +FROM INTERVAL_MULDIV_TBL; +-- +ok +== +SELECT span / 100 AS quotient +FROM INTERVAL_MULDIV_TBL; +-- +ok +== +select (interval '1 days') * 0.5::DOUBLE; +-- +ok +== +select 0.5::DOUBLE * (interval '1 days'); +-- +ok +== +select 2::BIGINT * (interval '1 days'); +-- +ok +== +select (interval '1 days') * 2::BIGINT; +-- +ok +== diff --git a/parser/testdata/corpus/sql/function/interval/test_interval_trunc.test b/parser/testdata/corpus/sql/function/interval/test_interval_trunc.test new file mode 100644 index 0000000..80bcf37 --- /dev/null +++ b/parser/testdata/corpus/sql/function/interval/test_interval_trunc.test @@ -0,0 +1,81 @@ +# source: test/sql/function/interval/test_interval_trunc.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +INSERT INTO intervals VALUES + ('1247 years 4 months', 'millennium'), + ('-1448 years -5 months', 'millennium'), + ('548 years 7 months', 'century'), + ('-118 years -3 months', 'century'), + ('45 years 1 months', 'decade'), + ('-97 years -11 months', 'decade'), + ('5 years 6 months', 'year'), + ('-4 years -8 months', 'year'), + ('2 years 2 months', 'quarter'), + ('-3 years -10 months', 'quarter'), + ('3 years 4 months 5 days', 'month'), + ('-7 years -3 months 29 days', 'month'), + ('4 months 22 days', 'week'), + ('-3 months -3 days', 'week'), + ('5 months 7 days 12:34:56.789012', 'day'), + ('-3 months -3 days 12:34:56.789012', 'day'), + ('1 month 11 days 12:34:56.789012', 'hour'), + ('-1 month -2 days 12:34:56.789012', 'hour'), + ('1 month 16 days 12:34:56.789012', 'minute'), + ('-1 month -9 days 12:34:56.789012', 'minute'), + ('1 month 24 days 12:34:56.789012', 'second'), + ('-1 month -17 days 12:34:56.789012', 'second'), + ('1 month 29 days 12:34:56.789012', 'milliseconds'), + ('-1 month -26 days 12:34:56.789012', 'milliseconds'), + ('1 month 7 days 12:34:56.789012', 'microseconds'), + ('-1 month -29 days 12:34:56.789012', 'microseconds'), + (NULL, NULL), +; +-- +ok +== +SELECT i FROM intervals; +-- +ok +== +SELECT DATE_TRUNC('millennium', i) FROM intervals +-- +ok +== +SELECT DATE_TRUNC('century', i) FROM intervals +-- +ok +== +SELECT DATE_TRUNC('decade', i) FROM intervals +-- +ok +== +SELECT DATE_TRUNC('{datepart}', i) FROM intervals +-- +ok +== +SELECT DATE_TRUNC('hour', i) FROM intervals +-- +ok +== +SELECT DATE_TRUNC('minute', i) FROM intervals +-- +ok +== +SELECT DATE_TRUNC('millisecond', i) FROM intervals +-- +ok +== +SELECT DATE_TRUNC('microsecond', i) FROM intervals +-- +ok +== +SELECT DATE_TRUNC(s, i) FROM intervals +-- +ok +== +SELECT DATE_TRUNC(NULL, i) FROM intervals +-- +ok +== diff --git a/parser/testdata/corpus/sql/function/list/aggregates/any_value.test b/parser/testdata/corpus/sql/function/list/aggregates/any_value.test new file mode 100644 index 0000000..a27847e --- /dev/null +++ b/parser/testdata/corpus/sql/function/list/aggregates/any_value.test @@ -0,0 +1,71 @@ +# source: test/sql/function/list/aggregates/any_value.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +SELECT list_aggr([NULL, 1, 2], 'any_value') +-- +ok +== +SELECT list_any_value() +-- +ok +== +CREATE TABLE five AS SELECT LIST(i::{type}) AS i FROM range(1, 6, 1) t1(i) +-- +error: Parser Error: syntax error at or near "{" +== +INSERT INTO five VALUES (NULL), ([NULL]), ([]), ([NULL, 1, 2]) +-- +ok +== +SELECT list_any_value(i) FROM five +-- +ok +== +CREATE TABLE five_dates AS + SELECT + LIST(NULLIF(i,0)::integer) AS i, + LIST('2021-08-20'::DATE + NULLIF(i,0)::INTEGER) AS d, + LIST('2021-08-20'::TIMESTAMP + INTERVAL (NULLIF(i,0)) HOUR) AS dt, + LIST('14:59:37'::TIME + INTERVAL (NULLIF(i,0)) MINUTE) AS t, + LIST(INTERVAL (NULLIF(i,0)) SECOND) AS s + FROM range(0, 6, 1) t1(i) +-- +ok +== +SELECT list_any_value(d), list_any_value(dt), list_any_value(t), list_any_value(s) FROM five_dates +-- +ok +== +CREATE TABLE five_dates_tz AS + SELECT + LIST(('2021-08-20'::TIMESTAMP + INTERVAL (NULLIF(i,0)) HOUR)::TIMESTAMPTZ) AS dt, + LIST(('14:59:37'::TIME + INTERVAL (NULLIF(i,0)) MINUTE)::TIMETZ) AS t, + FROM range(0, 6, 1) t1(i) +-- +ok +== +SELECT list_any_value(dt), list_any_value(t) FROM five_dates_tz +-- +ok +== +DROP TABLE five_dates_tz +-- +ok +== +CREATE TABLE five_complex AS + SELECT + LIST(NULLIF(i,0)::integer) AS i, + LIST(NULLIF(i,0)::VARCHAR) AS s, + LIST([NULLIF(i,0)]) AS l, + LIST({'a': NULLIF(i,0)}) AS r + FROM range(0, 6, 1) t1(i) +-- +ok +== +SELECT list_any_value(s), list_any_value(l), list_any_value(r) +FROM five_complex +-- +ok +== diff --git a/parser/testdata/corpus/sql/function/list/aggregates/approx_count_distinct.test b/parser/testdata/corpus/sql/function/list/aggregates/approx_count_distinct.test new file mode 100644 index 0000000..3411dde --- /dev/null +++ b/parser/testdata/corpus/sql/function/list/aggregates/approx_count_distinct.test @@ -0,0 +1,97 @@ +# source: test/sql/function/list/aggregates/approx_count_distinct.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +CREATE TABLE list_ints (l INTEGER[]); +-- +ok +== +INSERT INTO list_ints SELECT LIST(i) FROM range(100) tbl(i); +-- +ok +== +select list_approx_count_distinct([10]), list_approx_count_distinct(['hello']) from list_ints; +-- +ok +== +select list_approx_count_distinct(l), list_approx_count_distinct(['hello']) from list_ints; +-- +ok +== +select list_approx_count_distinct([]) from list_ints; +-- +ok +== +INSERT INTO list_ints VALUES ([]), (NULL), ([NULL]); +-- +ok +== +select list_approx_count_distinct(l) from list_ints; +-- +ok +== +CREATE TABLE IF NOT EXISTS dates (t date[]); +-- +ok +== +INSERT INTO dates VALUES (['2008-01-01', NULL, '2007-01-01', '2008-02-01', '2008-01-02', '2008-01-01', '2008-01-01', '2008-01-01']) +-- +ok +== +SELECT list_count(t), list_approx_count_distinct(t) from dates +-- +ok +== +CREATE TABLE IF NOT EXISTS timestamp (t TIMESTAMP[]); +-- +ok +== +INSERT INTO timestamp VALUES (['2008-01-01 00:00:01', NULL, '2007-01-01 00:00:01', '2008-02-01 00:00:01', '2008-01-02 00:00:01', '2008-01-01 10:00:00', '2008-01-01 00:10:00', '2008-01-01 00:00:10']) +-- +ok +== +SELECT list_count(t), list_approx_count_distinct(t) from timestamp +-- +ok +== +CREATE TABLE IF NOT EXISTS names (t string[]); +-- +ok +== +INSERT INTO names VALUES (['Pedro', NULL, 'Pedro', 'Pedro', 'Mark', 'Mark', 'Mark', 'Hannes-Muehleisen', 'Hannes-Muehleisen']) +-- +ok +== +SELECT list_count(t), list_approx_count_distinct(t) from names +-- +ok +== +CREATE TABLE list_ints_2 (a INTEGER[], b INTEGER[]); +-- +ok +== +INSERT INTO list_ints_2 SELECT LIST(a), LIST(mod(a, 10)) FROM range(2000) tbl(a); +-- +ok +== +SELECT list_count(a), list_approx_count_distinct(a), list_approx_count_distinct(b) from list_ints_2 +-- +ok +== +DELETE FROM list_ints_2 +-- +ok +== +INSERT INTO list_ints_2 SELECT LIST(a), NULL FROM range(2000) tbl(a, b) WHERE a % 2 = 0; +-- +ok +== +INSERT INTO list_ints_2 SELECT LIST(a), NULL FROM range(2000) tbl(a, b) WHERE a % 2 = 1; +-- +ok +== +SELECT list_approx_count_distinct(a) from list_ints_2; +-- +ok +== diff --git a/parser/testdata/corpus/sql/function/list/aggregates/avg.test b/parser/testdata/corpus/sql/function/list/aggregates/avg.test new file mode 100644 index 0000000..8fc168c --- /dev/null +++ b/parser/testdata/corpus/sql/function/list/aggregates/avg.test @@ -0,0 +1,61 @@ +# source: test/sql/function/list/aggregates/avg.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +SELECT list_avg([nextval('seq')]); +-- +ok +== +CREATE TABLE integers(i INTEGER[]); +-- +ok +== +INSERT INTO integers VALUES ([1, 2, 3]), ([6, 3, 2, 5]), ([]), ([NULL]), (NULL), ([1, NULL, 2, 3]); +-- +ok +== +SELECT list_avg(i) FROM integers; +-- +ok +== +SELECT list_avg() +-- +ok +== +CREATE TABLE vals(i INTEGER[], j HUGEINT[]); +-- +ok +== +INSERT INTO vals VALUES ([NULL, NULL], [NULL, NULL, NULL]) +-- +ok +== +SELECT list_avg(i), list_avg(j) FROM vals; +-- +ok +== +CREATE TABLE bigints(n HUGEINT[]); +-- +ok +== +INSERT INTO bigints (n) VALUES (['9007199254740992'::HUGEINT, 1::HUGEINT, 0::HUGEINT]); +-- +ok +== +SELECT list_avg(n)::DOUBLE - '3002399751580331'::DOUBLE FROM bigints; +-- +ok +== +CREATE TABLE doubles(n DOUBLE[]); +-- +ok +== +INSERT INTO doubles (n) VALUES (['9007199254740992'::DOUBLE, 1::DOUBLE, 1::DOUBLE, 0::DOUBLE]); +-- +ok +== +SELECT list_aggr(n, 'favg') - '2251799813685248.5'::DOUBLE FROM doubles; +-- +ok +== diff --git a/parser/testdata/corpus/sql/function/list/aggregates/bigints_sum_avg.test b/parser/testdata/corpus/sql/function/list/aggregates/bigints_sum_avg.test new file mode 100644 index 0000000..68e4821 --- /dev/null +++ b/parser/testdata/corpus/sql/function/list/aggregates/bigints_sum_avg.test @@ -0,0 +1,63 @@ +# source: test/sql/function/list/aggregates/bigints_sum_avg.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +CREATE TABLE bigints (i BIGINT[]); +-- +ok +== +INSERT INTO bigints VALUES ([1, 2, 3]); +-- +ok +== +SELECT list_sum(i) FROM bigints; +-- +ok +== +SELECT list_avg(i) FROM bigints; +-- +ok +== +DELETE FROM bigints; +-- +ok +== +INSERT INTO bigints VALUES ([1, 2, 3, 9223372036854775806]); +-- +ok +== +INSERT INTO bigints VALUES ([-1, -2, -3]); +-- +ok +== +INSERT INTO bigints VALUES ([-1, -2, -3, -9223372036854775806]); +-- +ok +== +CREATE TABLE decimals (i DECIMAL(18,1)[]); +-- +ok +== +INSERT INTO decimals VALUES ([1, 2, 3]); +-- +ok +== +SELECT list_sum(i) FROM decimals; +-- +ok +== +SELECT list_avg(i) FROM decimals; +-- +ok +== +DELETE FROM decimals; +-- +ok +== +INSERT INTO decimals VALUES ([99999999999999999.9, 99999999999999999.9, 99999999999999999.9, + 99999999999999999.9, 99999999999999999.9, 99999999999999999.9, 99999999999999999.9, + 99999999999999999.9, 99999999999999999.9, 99999999999999999.9, 1.0, 2.0, 3.0]); +-- +ok +== diff --git a/parser/testdata/corpus/sql/function/list/aggregates/bit_and.test b/parser/testdata/corpus/sql/function/list/aggregates/bit_and.test new file mode 100644 index 0000000..4c2b701 --- /dev/null +++ b/parser/testdata/corpus/sql/function/list/aggregates/bit_and.test @@ -0,0 +1,29 @@ +# source: test/sql/function/list/aggregates/bit_and.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +SELECT list_bit_and([nextval('seq')]) +-- +ok +== +INSERT INTO integers VALUES ([3, 7, 15, 31, 3, 15]); +-- +ok +== +SELECT list_bit_and([]) FROM integers +-- +ok +== +INSERT INTO integers VALUES ([]), (NULL), ([NULL]), ([3, 7, NULL, 15, 31, 3, 15, NULL]); +-- +ok +== +SELECT list_bit_and(i), list_bit_and([1, 1, 1, 1, 1, 1]), list_bit_and(NULL) FROM integers +-- +ok +== +SELECT list_bit_and() +-- +ok +== diff --git a/parser/testdata/corpus/sql/function/list/aggregates/bit_or.test b/parser/testdata/corpus/sql/function/list/aggregates/bit_or.test new file mode 100644 index 0000000..a85bde2 --- /dev/null +++ b/parser/testdata/corpus/sql/function/list/aggregates/bit_or.test @@ -0,0 +1,25 @@ +# source: test/sql/function/list/aggregates/bit_or.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +SELECT list_bit_or([nextval('seq')]) +-- +ok +== +INSERT INTO integers VALUES ([3, 7, 15, 31, 3, 15]) +-- +ok +== +SELECT list_bit_or([]) FROM integers +-- +ok +== +SELECT list_bit_or(i), list_bit_or([1, 1, 1, 1, 1, 1]), list_bit_or(NULL) FROM integers +-- +ok +== +SELECT list_bit_or() +-- +ok +== diff --git a/parser/testdata/corpus/sql/function/list/aggregates/bit_xor.test b/parser/testdata/corpus/sql/function/list/aggregates/bit_xor.test new file mode 100644 index 0000000..ac98a5c --- /dev/null +++ b/parser/testdata/corpus/sql/function/list/aggregates/bit_xor.test @@ -0,0 +1,25 @@ +# source: test/sql/function/list/aggregates/bit_xor.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +SELECT list_bit_xor([nextval('seq')]) +-- +ok +== +CREATE TABLE integers (i INTEGER[]); +-- +ok +== +SELECT list_bit_xor([]) FROM integers +-- +ok +== +SELECT list_bit_xor(i), list_bit_xor([1, 1, 1, 1, 1, 1]), list_bit_xor(NULL) FROM integers +-- +ok +== +SELECT list_bit_xor() +-- +ok +== diff --git a/parser/testdata/corpus/sql/function/list/aggregates/bool_and_or.test b/parser/testdata/corpus/sql/function/list/aggregates/bool_and_or.test new file mode 100644 index 0000000..7c2e30e --- /dev/null +++ b/parser/testdata/corpus/sql/function/list/aggregates/bool_and_or.test @@ -0,0 +1,41 @@ +# source: test/sql/function/list/aggregates/bool_and_or.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +select list_bool_or() +-- +ok +== +select list_bool_and() +-- +ok +== +CREATE TABLE bools (l BOOLEAN[]); +-- +ok +== +INSERT INTO bools SELECT LIST(True) FROM range(100) tbl(i); +-- +ok +== +INSERT INTO bools SELECT LIST(False) FROM range(100) tbl(i); +-- +ok +== +INSERT INTO bools VALUES ([True, False]); +-- +ok +== +INSERT INTO bools VALUES ([]), ([NULL]), (NULL), ([NULL, True, False, NULL]); +-- +ok +== +SELECT list_bool_or(l) FROM bools; +-- +ok +== +SELECT list_bool_and(l) FROM bools; +-- +ok +== diff --git a/parser/testdata/corpus/sql/function/list/aggregates/count.test b/parser/testdata/corpus/sql/function/list/aggregates/count.test new file mode 100644 index 0000000..430a337 --- /dev/null +++ b/parser/testdata/corpus/sql/function/list/aggregates/count.test @@ -0,0 +1,29 @@ +# source: test/sql/function/list/aggregates/count.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +SELECT list_count([1, 2, 3]) +-- +ok +== +SELECT list_count([1]) FROM range(3) +-- +ok +== +CREATE TABLE lists (l INTEGER[]); +-- +ok +== +INSERT INTO lists VALUES ([1, 2]), ([NULL]), (NULL), ([]), ([3, 4, 5, 6, 7]), ([1, 2, NULL, 1, NULL]); +-- +ok +== +SELECT list_count(l) FROM lists +-- +ok +== +select list_count() +-- +ok +== diff --git a/parser/testdata/corpus/sql/function/list/aggregates/entropy.test b/parser/testdata/corpus/sql/function/list/aggregates/entropy.test new file mode 100644 index 0000000..518ea5d --- /dev/null +++ b/parser/testdata/corpus/sql/function/list/aggregates/entropy.test @@ -0,0 +1,69 @@ +# source: test/sql/function/list/aggregates/entropy.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +select list_entropy() +-- +ok +== +select list_entropy([1]) +-- +ok +== +create table aggr(k int[]); +-- +ok +== +insert into aggr values ([0, 1, 1, 1, 4, 0, 3, 3, 2, 2, 4, 4, 2, 4, 0, 0, 0, 1, 2, 3, 4, 2, 3, 3, 1]); +-- +ok +== +insert into aggr values ([]), ([NULL]), (NULL), ([0, 1, 1, 1, 4, NULL, 0, 3, 3, 2, NULL, 2, 4, 4, 2, 4, 0, 0, 0, 1, NULL, 2, 3, 4, 2, 3, 3, 1]); +-- +ok +== +select list_entropy(k) from aggr; +-- +ok +== +CREATE TABLE entr (l INTEGER[]); +-- +ok +== +INSERT INTO entr SELECT LIST(2) FROM range(100) tbl(i); +-- +ok +== +SELECT list_entropy(l) FROM entr; +-- +ok +== +create table aggr2 (k int[]); +-- +ok +== +INSERT INTO aggr2 VALUES ([0, 4, 0, 2, 2, 4, 4, 2, 4, 0, 0, 0, 2, 4, 2]); +-- +ok +== +INSERT INTO aggr2 VALUES ([1, 1, 1, 3, 3, 1, 3, 3, 3, 1]); +-- +ok +== +select list_entropy(k) from aggr2 +-- +ok +== +create table names (name string[]) +-- +ok +== +insert into names values (['pedro', 'pedro', 'pedro', 'hannes', 'hannes', 'mark', null]); +-- +ok +== +select list_entropy(name) from names; +-- +ok +== diff --git a/parser/testdata/corpus/sql/function/list/aggregates/first.test b/parser/testdata/corpus/sql/function/list/aggregates/first.test new file mode 100644 index 0000000..7ae1305 --- /dev/null +++ b/parser/testdata/corpus/sql/function/list/aggregates/first.test @@ -0,0 +1,59 @@ +# source: test/sql/function/list/aggregates/first.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +SELECT list_aggr([1, 2], 'arbitrary') +-- +ok +== +SELECT list_first() +-- +ok +== +SELECT list_first(i) FROM five +-- +ok +== +CREATE TABLE five_dates AS + SELECT + LIST(i::integer) AS i, + LIST('2021-08-20'::DATE + i::INTEGER) AS d, + LIST('2021-08-20'::TIMESTAMP + INTERVAL (i) HOUR) AS dt, + LIST('14:59:37'::TIME + INTERVAL (i) MINUTE) AS t, + LIST(INTERVAL (i) SECOND) AS s + FROM range(1, 6, 1) t1(i) +-- +ok +== +SELECT list_first(d), list_first(dt), list_first(t), list_first(s) FROM five_dates +-- +ok +== +CREATE TABLE five_dates_tz AS + SELECT + LIST(('2021-08-20'::TIMESTAMP + INTERVAL (i) HOUR)::TIMESTAMPTZ) AS dt, + LIST(('14:59:37'::TIME + INTERVAL (i) MINUTE)::TIMETZ) AS t, + FROM range(1, 6, 1) t1(i) +-- +ok +== +SELECT list_first(dt), list_first(t) FROM five_dates_tz +-- +ok +== +CREATE TABLE five_complex AS + SELECT + LIST(i::integer) AS i, + LIST(i::VARCHAR) AS s, + LIST([i]) AS l, + LIST({'a': i}) AS r + FROM range(1, 6, 1) t1(i) +-- +ok +== +SELECT list_first(s), list_first(l), list_first(r) +FROM five_complex +-- +ok +== diff --git a/parser/testdata/corpus/sql/function/list/aggregates/histogram.test b/parser/testdata/corpus/sql/function/list/aggregates/histogram.test new file mode 100644 index 0000000..7b0f8eb --- /dev/null +++ b/parser/testdata/corpus/sql/function/list/aggregates/histogram.test @@ -0,0 +1,81 @@ +# source: test/sql/function/list/aggregates/histogram.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +CREATE TABLE const AS SELECT LIST(2) AS i FROM range(200) t1(i) +-- +ok +== +SELECT list_histogram(i) FROM const +-- +ok +== +select list_histogram([1]) +-- +ok +== +CREATE TABLE hist_data (g INTEGER[]) +-- +ok +== +INSERT INTO hist_data VALUES ([1, 1, 2, 2, 2, 3, 5]), ([1, 2, 3, 4, 5, 6, NULL]), ([]), (NULL), ([NULL]); +-- +ok +== +SELECT list_histogram(g) from hist_data +-- +ok +== +insert into names values (['pedro', 'pedro', 'pedro', 'hannes', 'hannes', 'mark', NULL, 'Hubert Blaine Wolfeschlegelsteinhausenbergerdorff Sr.']); +-- +ok +== +select list_histogram(name) from names; +-- +ok +== +SELECT list_histogram([1.0, 'nan'::DOUBLE, 'nan'::DOUBLE, 1.0])::VARCHAR; +-- +ok +== +select list_histogram() +-- +ok +== +SELECT list_histogram(['2021-08-20'::TIMESTAMP]) +-- +ok +== +SELECT list_histogram(['2021-08-20'::TIMESTAMP_S]) +-- +ok +== +SELECT list_histogram(['2021-08-20'::TIMESTAMP_MS]) +-- +ok +== +SELECT list_histogram(['2021-08-20'::TIMESTAMP_NS]) +-- +ok +== +SELECT list_histogram(['2021-08-20'::TIMESTAMPTZ]) +-- +ok +== +SELECT list_histogram(['2022-01-02'::DATE]) +-- +ok +== +SELECT list_histogram(['15:00:07'::TIME]) +-- +ok +== +SELECT list_histogram(['15:00:07'::TIMETZ]) +-- +ok +== +SELECT list_histogram([INTERVAL 1 YEAR]) +-- +ok +== diff --git a/parser/testdata/corpus/sql/function/list/aggregates/histogram_decimal.test b/parser/testdata/corpus/sql/function/list/aggregates/histogram_decimal.test new file mode 100644 index 0000000..8aa50cb --- /dev/null +++ b/parser/testdata/corpus/sql/function/list/aggregates/histogram_decimal.test @@ -0,0 +1,9 @@ +# source: test/sql/function/list/aggregates/histogram_decimal.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +WITH cte AS (FROM (VALUES (0.0), (9.9)) df(l_orderkey)) SELECT * FROM histogram_values(cte, l_orderkey) +-- +ok +== diff --git a/parser/testdata/corpus/sql/function/list/aggregates/hugeint.test b/parser/testdata/corpus/sql/function/list/aggregates/hugeint.test new file mode 100644 index 0000000..d35e2b1 --- /dev/null +++ b/parser/testdata/corpus/sql/function/list/aggregates/hugeint.test @@ -0,0 +1,29 @@ +# source: test/sql/function/list/aggregates/hugeint.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +CREATE TABLE hugeints(h HUGEINT[]) +-- +ok +== +INSERT INTO hugeints VALUES ([NULL, 1, 2]), (NULL), ([]), ([NULL]), ([1, 2, 3]) +-- +ok +== +SELECT list_first(h), list_last(h), list_sum(h) FROM hugeints +-- +ok +== +DELETE FROM hugeints +-- +ok +== +INSERT INTO hugeints VALUES ([42.0, 1267650600228229401496703205376, -439847238974238975238975, '-12']); +-- +ok +== +SELECT list_min(h), list_max(h), list_sum(h), list_first(h), list_last(h) FROM hugeints; +-- +ok +== diff --git a/parser/testdata/corpus/sql/function/list/aggregates/incorrect.test b/parser/testdata/corpus/sql/function/list/aggregates/incorrect.test new file mode 100644 index 0000000..755ec64 --- /dev/null +++ b/parser/testdata/corpus/sql/function/list/aggregates/incorrect.test @@ -0,0 +1,133 @@ +# source: test/sql/function/list/aggregates/incorrect.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +SELECT list_aggr([1], 2) +-- +ok +== +SELECT list_aggr([1], True) +-- +ok +== +SELECT list_aggr([1], NULL) +-- +ok +== +SELECT list_aggr('{func_name}') +-- +ok +== +SELECT list_aggr(*, '{func_name}') +-- +ok +== +SELECT list_aggr('hello', '{func_name}') +-- +ok +== +SELECT list_aggr(1, 2, '{func_name}') +-- +ok +== +SELECT list_aggr(NULL::{type}, '{func_name}') +-- +error: Parser Error: syntax error at or near "{" +== +SELECT list_aggr([1, 2, NULL], 'count_star'); +-- +ok +== +SELECT list_aggr([1, 2, NULL], 'corr'); +-- +ok +== +SELECT list_aggr([1, 2, NULL], 'covar_pop'); +-- +ok +== +SELECT list_aggr([1, 2, NULL], 'covar_samp'); +-- +ok +== +SELECT list_aggr([1, 2, NULL], 'regr_intercept'); +-- +ok +== +SELECT list_aggr([1, 2, NULL], 'regr_sxy'); +-- +ok +== +SELECT list_aggr([1, 2, NULL], 'regr_sxx'); +-- +ok +== +SELECT list_aggr([1, 2, NULL], 'regr_syy'); +-- +ok +== +SELECT list_aggr([1, 2, NULL], 'regr_r2'); +-- +ok +== +SELECT list_aggr([1, 2, NULL], 'regr_slope'); +-- +ok +== +SELECT list_aggr([1, 2, NULL], 'regr_count'); +-- +ok +== +SELECT list_aggr([1, 2, NULL], 'regr_avgy'); +-- +ok +== +SELECT list_aggr([1, 2, NULL], 'regr_avgx'); +-- +ok +== +SELECT list_aggr([1, 2, NULL], 'reservoir_quantile'); +-- +ok +== +SELECT list_aggr([1, 2, NULL], 'approx_quantile'); +-- +ok +== +SELECT list_aggr([1, 2, NULL], 'quantile'); +-- +ok +== +SELECT list_aggr([1, 2, NULL], 'quantile_cont'); +-- +ok +== +SELECT list_aggr([1, 2, NULL], 'quantile_disc'); +-- +ok +== +SELECT list_aggr([1, 2, NULL], 'arg_max'); +-- +ok +== +SELECT list_aggr([1, 2, NULL], 'max_by'); +-- +ok +== +SELECT list_aggr([1, 2, NULL], 'argmax'); +-- +ok +== +SELECT list_aggr([1, 2, NULL], 'arg_min'); +-- +ok +== +SELECT list_aggr([1, 2, NULL], 'min_by'); +-- +ok +== +SELECT list_aggr([1, 2, NULL], 'argmin'); +-- +ok +== diff --git a/parser/testdata/corpus/sql/function/list/aggregates/kurtosis.test b/parser/testdata/corpus/sql/function/list/aggregates/kurtosis.test new file mode 100644 index 0000000..134c979 --- /dev/null +++ b/parser/testdata/corpus/sql/function/list/aggregates/kurtosis.test @@ -0,0 +1,36 @@ +# source: test/sql/function/list/aggregates/kurtosis.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +select list_kurtosis([1]) +-- +ok +== +select list_kurtosis([0, 0, 0, 0, 0, 0]) +-- +ok +== +select list_kurtosis([2e304, 2e305, 2e306, 2e307]) +-- +ok +== +insert into aggr values ([1, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2]), + ([10, 10, 10, 10, 20, 20, 25, 30, 30, 30, 30]), + ([NULL, 11, 15, 18, 22, 25, NULL, 35, 40, 50, 51]), + (NULL), ([]), ([NULL]); +-- +ok +== +select list_kurtosis(k) from aggr; +-- +ok +== +select list_kurtosis_pop(k) from aggr; +-- +ok +== +select list_kurtosis() +-- +ok +== diff --git a/parser/testdata/corpus/sql/function/list/aggregates/last.test b/parser/testdata/corpus/sql/function/list/aggregates/last.test new file mode 100644 index 0000000..5883fe1 --- /dev/null +++ b/parser/testdata/corpus/sql/function/list/aggregates/last.test @@ -0,0 +1,30 @@ +# source: test/sql/function/list/aggregates/last.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +SELECT list_last() +-- +ok +== +INSERT INTO five VALUES (NULL), ([NULL]), ([]), ([1, 2, NULL]) +-- +ok +== +SELECT list_last(i) FROM five +-- +ok +== +SELECT list_last(d), list_last(dt), list_last(t), list_last(s) FROM five_dates +-- +ok +== +SELECT list_last(dt), list_last(t) FROM five_dates_tz +-- +ok +== +SELECT list_last(s), list_last(l), list_last(r) +FROM five_complex +-- +ok +== diff --git a/parser/testdata/corpus/sql/function/list/aggregates/mad.test b/parser/testdata/corpus/sql/function/list/aggregates/mad.test new file mode 100644 index 0000000..5b091e2 --- /dev/null +++ b/parser/testdata/corpus/sql/function/list/aggregates/mad.test @@ -0,0 +1,110 @@ +# source: test/sql/function/list/aggregates/mad.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +SELECT list_mad([1]) +-- +ok +== +CREATE TABLE const AS SELECT LIST(1) AS i FROM range(2000) t1(i) +-- +ok +== +SELECT list_mad(i) FROM const +-- +ok +== +create table tinys as select list(r::{type}) as r from range(100) tbl(r); +-- +error: Parser Error: syntax error at or near "{" +== +SELECT list_mad(r) FROM tinys +-- +ok +== +drop table tinys; +-- +ok +== +create table numerics as select list(r::{type}) as r from range(10000) tbl(r); +-- +error: Parser Error: syntax error at or near "{" +== +SELECT list_mad(r) FROM numerics +-- +ok +== +drop table numerics +-- +ok +== +create table date as select list(('2018-01-01'::DATE + INTERVAL (r) DAY)::DATE) as r from range(10000) tbl(r); +-- +ok +== +SELECT list_mad(r) FROM date +-- +ok +== +create table hour as select list('2018-01-01'::TIMESTAMP + INTERVAL (r) HOUR) as r from range(10000) tbl(r); +-- +ok +== +SELECT list_mad(r) FROM hour +-- +ok +== +create table second as select list('00:00:00'::TIME + INTERVAL (r) SECOND) as r from range(10000) tbl(r); +-- +ok +== +SELECT list_mad(r) FROM second +-- +ok +== +select list_mad(x) from (values (['294247-01-10'::date, '290309-12-22 (BC)'::date])) tbl(x); +-- +ok +== +select list_mad(x) from (values (['294247-01-10 04:00:54.775806'::timestamp, + '290309-12-22 (BC) 00:00:00'::timestamp])) tbl(x); +-- +ok +== +select list_mad(x) from (values (['23:59:59.999999'::time, '00:00:00'::time])) tbl(x); +-- +ok +== +SELECT list_mad(['2021-08-20'::{type}]) +-- +error: Parser Error: syntax error at or near "{" +== +SELECT list_mad([NULL::{type}]) +-- +error: Parser Error: syntax error at or near "{" +== +SELECT list_mad([INTERVAL 1 YEAR]) +-- +ok +== +SELECT list_mad([NULL::INTERVAL]) +-- +ok +== +select list_mad(x) from (values (['127'::DECIMAL(3,0), '-128'::DECIMAL(3,0)])) tbl(x); +-- +ok +== +select list_mad(x) from (values (['32767'::DECIMAL(5,0), '-32768'::DECIMAL(5,0)])) tbl(x); +-- +ok +== +select list_mad(x) from (values (['2147483647'::DECIMAL(10,0), '-2147483648'::DECIMAL(10,0)])) tbl(x); +-- +ok +== +select list_mad(x) from (values ([-1e308, 1e308])) tbl(x); +-- +ok +== diff --git a/parser/testdata/corpus/sql/function/list/aggregates/max.test b/parser/testdata/corpus/sql/function/list/aggregates/max.test new file mode 100644 index 0000000..eba8c6c --- /dev/null +++ b/parser/testdata/corpus/sql/function/list/aggregates/max.test @@ -0,0 +1,26 @@ +# source: test/sql/function/list/aggregates/max.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +SELECT list_max() +-- +ok +== +SELECT list_max(i) FROM five +-- +ok +== +SELECT list_max(d), list_max(dt), list_max(t), list_max(s) FROM five_dates +-- +ok +== +SELECT list_max(dt), list_max(t) FROM five_dates_tz +-- +ok +== +SELECT list_max(s), list_max(l), list_max(r) +FROM five_complex +-- +ok +== diff --git a/parser/testdata/corpus/sql/function/list/aggregates/median.test b/parser/testdata/corpus/sql/function/list/aggregates/median.test new file mode 100644 index 0000000..24bd7d5 --- /dev/null +++ b/parser/testdata/corpus/sql/function/list/aggregates/median.test @@ -0,0 +1,33 @@ +# source: test/sql/function/list/aggregates/median.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +CREATE TABLE quantile AS SELECT LIST(r::{type}) AS r FROM range(10000) t1(r); +-- +error: Parser Error: syntax error at or near "{" +== +SELECT list_median(r) FROM quantile +-- +ok +== +DROP TABLE quantile +-- +ok +== +CREATE TABLE quantile AS SELECT LIST(r::tinyint) AS r FROM range(100) t1(r); +-- +ok +== +CREATE TABLE range AS SELECT LIST(1) AS i FROM range(2000) t1(i) +-- +ok +== +INSERT INTO range VALUES (NULL), ([]), ([NULL]); +-- +ok +== +SELECT list_median(i) FROM range +-- +ok +== diff --git a/parser/testdata/corpus/sql/function/list/aggregates/min.test b/parser/testdata/corpus/sql/function/list/aggregates/min.test new file mode 100644 index 0000000..14eaacc --- /dev/null +++ b/parser/testdata/corpus/sql/function/list/aggregates/min.test @@ -0,0 +1,26 @@ +# source: test/sql/function/list/aggregates/min.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +SELECT list_min() +-- +ok +== +SELECT list_min(i) FROM five +-- +ok +== +SELECT list_min(d), list_min(dt), list_min(t), list_min(s) FROM five_dates +-- +ok +== +SELECT list_min(dt), list_min(t) FROM five_dates_tz +-- +ok +== +SELECT list_min(s), list_min(l), list_min(r) +FROM five_complex +-- +ok +== diff --git a/parser/testdata/corpus/sql/function/list/aggregates/minmax_nested.test b/parser/testdata/corpus/sql/function/list/aggregates/minmax_nested.test new file mode 100644 index 0000000..8443858 --- /dev/null +++ b/parser/testdata/corpus/sql/function/list/aggregates/minmax_nested.test @@ -0,0 +1,153 @@ +# source: test/sql/function/list/aggregates/minmax_nested.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +CREATE TABLE structs AS SELECT {'i': i} s FROM range(1000) t(i); +-- +ok +== +SELECT MIN(s), MAX(s) FROM structs; +-- +ok +== +INSERT INTO structs VALUES ({'i': 99999999}); +-- +ok +== +INSERT INTO structs VALUES ({'i': -9223372036854775808}), ({'i': 9223372036854775807}); +-- +ok +== +INSERT INTO structs VALUES ({'i': NULL}), (NULL) +-- +ok +== +CREATE TABLE varchar_structs AS SELECT {'i': concat('long_prefix_', i)} s FROM range(1000) t(i); +-- +ok +== +SELECT MIN(s), MAX(s) FROM varchar_structs; +-- +ok +== +INSERT INTO varchar_structs VALUES ({'i': chr(0)}), ({'i': 'zzzzz' || chr(0)}) +-- +ok +== +CREATE TABLE blob_structs AS SELECT {'i': concat('long_prefix_', '\x', 16+i%239)::blob} s FROM range(1000) t(i); +-- +ok +== +SELECT MIN(s), MAX(s) FROM blob_structs; +-- +ok +== +INSERT INTO blob_structs VALUES ({'i': '\x00z\x00\x00z\x00zzzz\x00'::blob}), ({'i': 'zzzzzz\x01\x01\x01\x00\x01\x01\x00'::blob}) +-- +ok +== +CREATE TABLE multi_member_struct AS SELECT {'i': (1000-i)//5, 'j': i} s FROM range(1000) t(i); +-- +ok +== +SELECT MIN(s), MAX(s) FROM multi_member_struct; +-- +ok +== +CREATE TABLE lists AS SELECT case when i<500 then [i, i + 1, i + 2] else [i, 0] end AS l FROM range(1000) t(i); +-- +ok +== +SELECT MIN(l), MAX(l) FROM lists; +-- +ok +== +INSERT INTO lists VALUES ([]), (NULL), ([NULL, NULL, NULL]); +-- +ok +== +CREATE TABLE list_with_structs AS SELECT case when i<500 then [{'i': i}, {'i': i + 1}, {'i': i + 2}] else [{'i': i}, {'i': 0}] end AS l FROM range(1000) t(i); +-- +ok +== +SELECT MIN(l), MAX(l) FROM list_with_structs; +-- +ok +== +INSERT INTO list_with_structs VALUES ([{'i': NULL}, {'i': 100}, NULL, {'i': NULL}]); +-- +ok +== +INSERT INTO list_with_structs VALUES ([]), (NULL), ([NULL, NULL, NULL]); +-- +ok +== +CREATE TABLE list_multi_member_struct AS SELECT [NULL, {'i': (1000-i)//5, 'j': i}, NULL] l FROM range(1000) t(i); +-- +ok +== +SELECT MIN(l), MAX(l) FROM list_multi_member_struct; +-- +ok +== +INSERT INTO list_multi_member_struct VALUES ([{'i': NULL, 'j': 42}]), ([NULL, NULL, {'i': 84, 'j': NULL}]) +-- +ok +== +CREATE TABLE struct_with_lists AS SELECT {'i': case when i<500 then [i, i + 1, i + 2] else [i, 0] end} AS s FROM range(1000) t(i); +-- +ok +== +SELECT MIN(s), MAX(s) FROM struct_with_lists; +-- +ok +== +INSERT INTO struct_with_lists VALUES ({'i': []}), (NULL), ({'i': [NULL, NULL, NULL]}) +-- +ok +== +INSERT INTO struct_with_lists VALUES ({'i': NULL}) +-- +ok +== +SELECT MAX(s) FROM struct_with_lists; +-- +ok +== +CREATE TABLE arrays AS SELECT (case when i<500 then [i, i + 1, i + 2] else [i, 0, 0] end)::BIGINT[3] AS l FROM range(1000) t(i); +-- +ok +== +SELECT MIN(l), MAX(l) FROM arrays; +-- +ok +== +INSERT INTO arrays VALUES (NULL), ([NULL, NULL, NULL]); +-- +ok +== +CREATE TABLE float_values(f FLOAT); +-- +ok +== +INSERT INTO float_values VALUES ('0'), ('-3.4e38'), ('3.4e38'), ('nan'), ('inf'), ('-inf') +-- +ok +== +SELECT f, (SELECT MIN({'v': x}) FROM (VALUES (f)) t(x)) FROM float_values ORDER BY ALL; +-- +ok +== +CREATE TABLE double_values(d DOUBLE); +-- +ok +== +INSERT INTO double_values VALUES ('0'), ('-1e308'), ('1e308'), ('nan'), ('inf'), ('-inf') +-- +ok +== +SELECT d, (SELECT MIN({'v': x}) FROM (VALUES (d)) t(x)) FROM double_values ORDER BY ALL; +-- +ok +== diff --git a/parser/testdata/corpus/sql/function/list/aggregates/mode.test b/parser/testdata/corpus/sql/function/list/aggregates/mode.test new file mode 100644 index 0000000..174c096 --- /dev/null +++ b/parser/testdata/corpus/sql/function/list/aggregates/mode.test @@ -0,0 +1,105 @@ +# source: test/sql/function/list/aggregates/mode.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +select list_mode() +-- +ok +== +CREATE TABLE range AS SELECT LIST(2) AS i FROM range(100) t1(i) +-- +ok +== +SELECT list_mode(i) FROM range; +-- +ok +== +insert into names values (['pedro', 'pedro', 'pedro', 'hannes', 'hannes', 'mark', NULL]); +-- +ok +== +select list_mode(name) from names; +-- +ok +== +create table dates (v date[]) +-- +ok +== +insert into dates values (['2021-05-02', '2021-05-02', '2021-05-02', '2020-02-29', '2020-02-29', '2004-09-01', NULL]); +-- +ok +== +select list_mode(v) from dates; +-- +ok +== +create table times (v time[]) +-- +ok +== +insert into times values (['12:11:49.5', '12:11:49.5', '12:11:49.5', '06:30:00', '06:30:00', '21:15:22', NULL]); +-- +ok +== +select list_mode(v) from times; +-- +ok +== +create table timestamps (v timestamp[]) +-- +ok +== +insert into timestamps values (['2021-05-02 12:11:49.5', '2021-05-02 12:11:49.5', '2021-05-02 12:11:49.5', + '2020-02-29 06:30:00', '2020-02-29 06:30:00', '2004-09-01 21:15:22', NULL]); +-- +ok +== +select list_mode(v) from timestamps; +-- +ok +== +create table intervals (v interval[]) +-- +ok +== +insert into intervals values + ([INTERVAL '5 months 2 days 12 hours 11 minutes 49 seconds', + INTERVAL '5 months 2 days 12 hours 11 minutes 49 seconds', + INTERVAL '5 months 2 days 12 hours 11 minutes 49 seconds', + INTERVAL '2 months 29 days 6 hours 30 minutes', + INTERVAL '2 months 29 days 6 hours 30 minutes', + INTERVAL '9 months 1 day 21 hours 15 minutes 22 seconds', + NULL]); +-- +ok +== +select list_mode(v) from intervals; +-- +ok +== +create table hugeints (v hugeint[]) +-- +ok +== +insert into hugeints values ([5, 5, 5, 2, 2, 1, NULL]); +-- +ok +== +select list_mode(v) from hugeints; +-- +ok +== +create table aggr (v decimal(10,2)[]); +-- +ok +== +insert into aggr values ([10, 10, 20, 21]), ([20, 20, 25, 30]), ([NULL]), ([]), (NULL); +-- +ok +== +select list_mode(v) from aggr; +-- +ok +== diff --git a/parser/testdata/corpus/sql/function/list/aggregates/nested.test b/parser/testdata/corpus/sql/function/list/aggregates/nested.test new file mode 100644 index 0000000..f286596 --- /dev/null +++ b/parser/testdata/corpus/sql/function/list/aggregates/nested.test @@ -0,0 +1,41 @@ +# source: test/sql/function/list/aggregates/nested.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +SELECT list_min(list_concat([1, 2], [-1])) +-- +ok +== +SELECT list_min(list_aggr([1, 2], 'list')) +-- +ok +== +CREATE TABLE lists (l1 INTEGER[], l2 INTEGER[]) +-- +ok +== +INSERT INTO lists VALUES ([1, 2, 3], [4]), ([NULL, 1, -4, NULL], [NULL]), (NULL, NULL), ([NULL], [-4]), ([], []) +-- +ok +== +SELECT list_last(list_concat(l1, l2)) FROM lists +-- +ok +== +SELECT list_concat(list(list_last(l1)), list(list_first(l2))) FROM lists +-- +ok +== +SELECT array_aggregate([1, 2], 'min') +-- +ok +== +SELECT array_aggr([1, 2], 'min') +-- +ok +== +SELECT list_aggregate([1, 2], 'min') +-- +ok +== diff --git a/parser/testdata/corpus/sql/function/list/aggregates/null_or_empty.test b/parser/testdata/corpus/sql/function/list/aggregates/null_or_empty.test new file mode 100644 index 0000000..ccb3bd5 --- /dev/null +++ b/parser/testdata/corpus/sql/function/list/aggregates/null_or_empty.test @@ -0,0 +1,25 @@ +# source: test/sql/function/list/aggregates/null_or_empty.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +SELECT list_aggr(NULL, '{func_name}') +-- +ok +== +SELECT list_aggr([NULL], '{func_name}') +-- +ok +== +SELECT list_aggr([], '{func_name}') +-- +ok +== +select * from (SELECT list_aggr(NULL, '{func_name}')) +-- +ok +== +SELECT list_aggr([], '{func_name}') WHERE 1 = 0 +-- +ok +== diff --git a/parser/testdata/corpus/sql/function/list/aggregates/product.test b/parser/testdata/corpus/sql/function/list/aggregates/product.test new file mode 100644 index 0000000..9ea0fc4 --- /dev/null +++ b/parser/testdata/corpus/sql/function/list/aggregates/product.test @@ -0,0 +1,33 @@ +# source: test/sql/function/list/aggregates/product.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +select list_product() +-- +ok +== +INSERT INTO integers VALUES ([1, 2, 4]), (NULL), ([]), ([NULL]), ([1, 2, NULL, 4, NULL]) +-- +ok +== +SELECT list_product(i) FROM integers +-- +ok +== +CREATE TABLE prods AS SELECT LIST(2) AS i FROM range(100) t1(i) +-- +ok +== +SELECT list_product(i) FROM prods; +-- +ok +== +drop table prods +-- +ok +== +CREATE TABLE prods AS SELECT LIST(2) AS i FROM range(100 // 2) t1(i) +-- +ok +== diff --git a/parser/testdata/corpus/sql/function/list/aggregates/sem.test b/parser/testdata/corpus/sql/function/list/aggregates/sem.test new file mode 100644 index 0000000..831be38 --- /dev/null +++ b/parser/testdata/corpus/sql/function/list/aggregates/sem.test @@ -0,0 +1,37 @@ +# source: test/sql/function/list/aggregates/sem.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +select list_sem() +-- +ok +== +select list_sem([1]) +-- +ok +== +create table aggr(k int[], v decimal(10,2)[], v2 decimal(10, 2)[]); +-- +ok +== +insert into aggr values ([1, 2, 2, 2, 2], [10, 10, 20, 25, 30], [NULL, 11, 22, NULL, 35]); +-- +ok +== +select list_sem(k), list_sem(v), list_sem(v2) from aggr; +-- +ok +== +create table sems (l int[]); +-- +ok +== +insert into sems values ([1, 2, 2, 2, 2]), ([1, 2, NULL, 2, 2, NULL, 2]), ([]), ([NULL]), (NULL); +-- +ok +== +select list_sem(l) from sems; +-- +ok +== diff --git a/parser/testdata/corpus/sql/function/list/aggregates/skewness.test b/parser/testdata/corpus/sql/function/list/aggregates/skewness.test new file mode 100644 index 0000000..101ef6c --- /dev/null +++ b/parser/testdata/corpus/sql/function/list/aggregates/skewness.test @@ -0,0 +1,60 @@ +# source: test/sql/function/list/aggregates/skewness.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +select list_skewness() +-- +ok +== +select list_skewness([1]) +-- +ok +== +CREATE TABLE skew AS SELECT LIST(10) AS i FROM range(5) t1(i) +-- +ok +== +select list_skewness (i) from skew +-- +ok +== +select list_skewness([5, 5, 5]) +-- +ok +== +select list_skewness([1.5, 1.5, 1.5]) +-- +ok +== +select list_skewness ([1,2]) +-- +ok +== +select list_skewness([-2e307, 0, 2e307]) +-- +ok +== +insert into aggr values ([1, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2], + [10, 10, 10, 10, 20, 20, 25, 30, 30, 30, 30], + [NULL, 11, 15, 18, 22, 25, NULL, 35, 40, 50, 51]), + ([], NULL, [NULL]); +-- +ok +== +select list_skewness(k), list_skewness(v), list_skewness(v2) from aggr +-- +ok +== +create table aggr2(v2 decimal(10, 2)[]); +-- +ok +== +insert into aggr2 values ([NULL, 11, 15, 18]), ([22, 25]), ([NULL]), ([35, 40, 50, 51]); +-- +ok +== +select list_skewness(v2) from aggr2 +-- +ok +== diff --git a/parser/testdata/corpus/sql/function/list/aggregates/string_agg.test b/parser/testdata/corpus/sql/function/list/aggregates/string_agg.test new file mode 100644 index 0000000..bbeff52 --- /dev/null +++ b/parser/testdata/corpus/sql/function/list/aggregates/string_agg.test @@ -0,0 +1,70 @@ +# source: test/sql/function/list/aggregates/string_agg.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +SELECT list_string_agg() +-- +ok +== +SELECT list_string_agg(['a', ',']) +-- +ok +== +SELECT list_string_agg(['a']) +-- +ok +== +CREATE TABLE str_aggs (str varchar[]); +-- +ok +== +INSERT INTO str_aggs VALUES (['a', ',']), ([NULL, ',']), (['a', NULL]), ([NULL, NULL]), (NULL), ([]), ([NULL]); +-- +ok +== +SELECT list_string_agg(str) from str_aggs; +-- +ok +== +CREATE TABLE strings(g INTEGER[], x VARCHAR[], y VARCHAR[]); +-- +ok +== +INSERT INTO strings VALUES ([1, 1, 2, 2, 2, 3, 4, 4, 4], ['a', 'b', 'i', NULL, 'j', 'p', 'x', 'y', 'z'], + ['/', '-', '/', '-', '+', '/', '/', '-', '+']); +-- +ok +== +SELECT list_string_agg(x), list_string_agg(y), list_string_agg(g::varchar[]) FROM strings +-- +ok +== +SELECT list_string_agg(x) FROM strings WHERE g > [100] +-- +ok +== +SELECT list_string_agg([1, 2]) +-- +ok +== +SELECT list_string_agg([1, 2]::varchar[]) +-- +ok +== +SELECT list_aggr(['a'], 'group_concat') +-- +ok +== +CREATE TABLE long AS SELECT LIST('a') g FROM range(0, 10, 1) t1(c), range(0, 10, 1) t2(e); +-- +ok +== +SELECT list_count(g), list_count(g) FROM long; +-- +ok +== +SELECT list_string_agg(g) FROM long +-- +ok +== diff --git a/parser/testdata/corpus/sql/function/list/aggregates/sum.test b/parser/testdata/corpus/sql/function/list/aggregates/sum.test new file mode 100644 index 0000000..ee88281 --- /dev/null +++ b/parser/testdata/corpus/sql/function/list/aggregates/sum.test @@ -0,0 +1,53 @@ +# source: test/sql/function/list/aggregates/sum.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +SELECT list_sum([2, 2]) +-- +ok +== +INSERT INTO integers SELECT LIST(i) FROM range(0, 1000, 1) tbl(i); +-- +ok +== +INSERT INTO integers SELECT LIST(i) FROM range(-999, 1000, 1) tbl(i); +-- +ok +== +INSERT INTO integers SELECT LIST(i) FROM range(0, -1000, -1) tbl(i); +-- +ok +== +INSERT INTO integers VALUES (NULL), ([NULL]), ([]); +-- +ok +== +SELECT list_sum(i) FROM integers; +-- +ok +== +SELECT list_aggr(n, 'fsum') FROM doubles; +-- +ok +== +SELECT list_aggr(n, 'sumKahan') FROM doubles; +-- +ok +== +SELECT list_aggr(n, 'kahan_sum') FROM doubles; +-- +ok +== +CREATE TABLE bigints(i BIGINT[]); +-- +ok +== +INSERT INTO bigints SELECT LIST(i) FROM range(4611686018427387904, 4611686018427388904, 1) tbl(i); +-- +ok +== +SELECT list_sum(i) FROM bigints +-- +ok +== diff --git a/parser/testdata/corpus/sql/function/list/aggregates/sum_bool.test b/parser/testdata/corpus/sql/function/list/aggregates/sum_bool.test new file mode 100644 index 0000000..0f108f9 --- /dev/null +++ b/parser/testdata/corpus/sql/function/list/aggregates/sum_bool.test @@ -0,0 +1,17 @@ +# source: test/sql/function/list/aggregates/sum_bool.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +INSERT INTO integers SELECT CASE WHEN i%3=0 THEN NULL ELSE i END i FROM range(10000) t(i); +-- +ok +== +SELECT SUM(i > 500), SUM(i=1), SUM(i IS NULL) FROM integers +-- +ok +== +SELECT COUNTIF(i > 500), COUNT_IF(i=1), COUNTIF(i IS NULL) FROM integers +-- +ok +== diff --git a/parser/testdata/corpus/sql/function/list/aggregates/sum_no_overflow.test b/parser/testdata/corpus/sql/function/list/aggregates/sum_no_overflow.test new file mode 100644 index 0000000..2ccecbb --- /dev/null +++ b/parser/testdata/corpus/sql/function/list/aggregates/sum_no_overflow.test @@ -0,0 +1,13 @@ +# source: test/sql/function/list/aggregates/sum_no_overflow.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +SELECT sum_no_overflow(42) +-- +ok +== +SELECT sum_no_overflow(42.5) +-- +ok +== diff --git a/parser/testdata/corpus/sql/function/list/aggregates/uhugeint.test b/parser/testdata/corpus/sql/function/list/aggregates/uhugeint.test new file mode 100644 index 0000000..c16ed2e --- /dev/null +++ b/parser/testdata/corpus/sql/function/list/aggregates/uhugeint.test @@ -0,0 +1,29 @@ +# source: test/sql/function/list/aggregates/uhugeint.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +CREATE TABLE uhugeints(h UHUGEINT[]) +-- +ok +== +INSERT INTO uhugeints VALUES ([NULL, 1, 2]), (NULL), ([]), ([NULL]), ([1, 2, 3]) +-- +ok +== +SELECT list_first(h), list_last(h), list_sum(h) FROM uhugeints +-- +ok +== +DELETE FROM uhugeints +-- +ok +== +INSERT INTO uhugeints VALUES ([42.0, 1267650600228229401496703205376, 0, '1']); +-- +ok +== +SELECT list_min(h), list_max(h), list_sum(h), list_first(h), list_last(h) FROM uhugeints; +-- +ok +== diff --git a/parser/testdata/corpus/sql/function/list/aggregates/var_stddev.test b/parser/testdata/corpus/sql/function/list/aggregates/var_stddev.test new file mode 100644 index 0000000..5c25b5e --- /dev/null +++ b/parser/testdata/corpus/sql/function/list/aggregates/var_stddev.test @@ -0,0 +1,97 @@ +# source: test/sql/function/list/aggregates/var_stddev.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +create table stddev_test(val integer[]) +-- +ok +== +insert into stddev_test values ([42, 43, 42, 1000, NULL, NULL]), ([1, 1, 2, 2, 1, 3]), ([]), ([NULL]), (NULL) +-- +ok +== +SELECT list_stddev_samp([1]) +-- +ok +== +SELECT list_var_samp([1]) +-- +ok +== +select round(list_stddev_samp(val), 1) from stddev_test +-- +ok +== +select list_sum(val), round(list_stddev_samp(val), 1), list_min(val) from stddev_test +-- +ok +== +select round(list_stddev_pop(val), 1) from stddev_test +-- +ok +== +select list_sum(val), round(list_stddev_pop(val), 1), list_min(val) from stddev_test +-- +ok +== +select round(list_var_samp(val), 1) from stddev_test +-- +ok +== +select round(list_aggr(val, 'variance'), 1) from stddev_test +-- +ok +== +select list_sum(val), round(list_var_samp(val), 1), list_min(val) from stddev_test +-- +ok +== +select round(list_var_pop(val), 1) from stddev_test +-- +ok +== +select list_sum(val), round(list_var_pop(val), 1), list_min(val) from stddev_test +-- +ok +== +select round(list_aggr(val, 'stddev'), 1) from stddev_test +-- +ok +== +select list_aggr([0], 'stddev') +-- +ok +== +select list_aggr([0, 0], 'stddev') +-- +ok +== +select list_aggr([1e301, -1e301], 'stddev') +-- +ok +== +select list_var_samp([1e301, -1e301]) +-- +ok +== +select list_var_pop([1e301, -1e301]) +-- +ok +== +SELECT list_stddev_samp() +-- +ok +== +CREATE TABLE t0 (c0 DOUBLE[]); +-- +ok +== +INSERT INTO t0 VALUES([1E200, 0]); +-- +ok +== +SELECT list_stddev_pop(c0) FROM t0; +-- +ok +== diff --git a/parser/testdata/corpus/sql/function/list/array_length.test b/parser/testdata/corpus/sql/function/list/array_length.test new file mode 100644 index 0000000..925c95c --- /dev/null +++ b/parser/testdata/corpus/sql/function/list/array_length.test @@ -0,0 +1,41 @@ +# source: test/sql/function/list/array_length.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +SELECT length([1,2,3]) +-- +ok +== +SELECT length([]) +-- +ok +== +SELECT len(NULL) +-- +ok +== +SELECT array_length(ARRAY[1, 2, 3], 1) +-- +ok +== +SELECT array_length(ARRAY[1, 2, 3], 2) +-- +ok +== +SELECT array_length(ARRAY[1, 2, 3], 0) +-- +ok +== +SELECT len([1]) FROM range(3) +-- +ok +== +CREATE TABLE lists AS SELECT * FROM (VALUES ([1, 2]), ([NULL]), (NULL), ([]), ([3, 4, 5, 6, 7])) tbl(l) +-- +ok +== +SELECT len(l) FROM lists +-- +ok +== diff --git a/parser/testdata/corpus/sql/function/list/array_to_string.test b/parser/testdata/corpus/sql/function/list/array_to_string.test new file mode 100644 index 0000000..933236e --- /dev/null +++ b/parser/testdata/corpus/sql/function/list/array_to_string.test @@ -0,0 +1,33 @@ +# source: test/sql/function/list/array_to_string.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +SELECT array_to_string([1,2,3], '') +-- +ok +== +SELECT array_to_string([1,2,3], '-') +-- +ok +== +SELECT array_to_string(NULL, '-') +-- +ok +== +SELECT array_to_string([1, 2, 3], NULL) +-- +ok +== +SELECT array_to_string([], '-') +-- +ok +== +SELECT array_to_string([i, i + 1], '-') FROM range(6) t(i) WHERE i<=2 OR i>4 +-- +ok +== +SELECT array_to_string([1, 2, 3], k) FROM repeat(',', 5) t(k) +-- +ok +== diff --git a/parser/testdata/corpus/sql/function/list/array_to_string_comma_default.test b/parser/testdata/corpus/sql/function/list/array_to_string_comma_default.test new file mode 100644 index 0000000..29d7581 --- /dev/null +++ b/parser/testdata/corpus/sql/function/list/array_to_string_comma_default.test @@ -0,0 +1,41 @@ +# source: test/sql/function/list/array_to_string_comma_default.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +SELECT array_to_string_comma_default([1,2,3]) +-- +ok +== +SELECT array_to_string_comma_default([1,2,3], sep:=',') +-- +ok +== +SELECT array_to_string_comma_default([1,2,3], sep:='') +-- +ok +== +SELECT array_to_string_comma_default([1,2,3], sep:='-') +-- +ok +== +SELECT array_to_string_comma_default(NULL, sep:='-') +-- +ok +== +SELECT array_to_string_comma_default([1, 2, 3], sep:=NULL) +-- +ok +== +SELECT array_to_string_comma_default([], sep:='-') +-- +ok +== +SELECT array_to_string_comma_default([i, i + 1], sep:='-') FROM range(6) t(i) WHERE i<=2 OR i>4 +-- +ok +== +SELECT array_to_string_comma_default([1, 2, 3], sep:=k) FROM repeat(',', 5) t(k) +-- +ok +== diff --git a/parser/testdata/corpus/sql/function/list/flatten.test b/parser/testdata/corpus/sql/function/list/flatten.test new file mode 100644 index 0000000..3b22c36 --- /dev/null +++ b/parser/testdata/corpus/sql/function/list/flatten.test @@ -0,0 +1,119 @@ +# source: test/sql/function/list/flatten.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +SELECT flatten([[1, 2, 3, 4]]) +-- +ok +== +SELECT flatten([[1, 2], [3, 4]]) +-- +ok +== +SELECT flatten(1) +-- +ok +== +SELECT flatten([[], []]) +-- +ok +== +SELECT flatten([[1, 2], [], [3, 4]]) +-- +ok +== +SELECT flatten([[1, 2], []]) +-- +ok +== +SELECT flatten([[], [1, 2]]) +-- +ok +== +SELECT flatten(NULL) +-- +ok +== +SELECT flatten([NULL]) +-- +ok +== +SELECT flatten([[NULL]]) +-- +ok +== +SELECT flatten([NULL, [1], [2, 3], NULL, [4, NULL], [NULL, NULL]]) +-- +ok +== +SELECT flatten([[[1, 2], [3, 4]], [[5,6], [7, 8]]]) +-- +ok +== +SELECT flatten(flatten(flatten([[[[1], [2]], [[3], [4]]], [[[5], [6]], [[7], [8]]]]))) +-- +ok +== +SELECT flatten([[[1, 2], [3, 4]], [], [[5, 6], [7, 8]]]); +-- +ok +== +SELECT flatten([[[1, 2], [3, 4]], [[]], [[5, 6], [7, 8]]]); +-- +ok +== +SELECT flatten([[[]], [[]]]) +-- +ok +== +SELECT flatten(flatten([[[]], [[]]])) +-- +ok +== +CREATE TABLE nums AS SELECT range % 8 i, range j FROM range(16) +-- +ok +== +CREATE TABLE lists AS SELECT i % 4 i, list(j ORDER BY rowid) j FROM nums GROUP BY i +-- +ok +== +CREATE TABLE nested_lists AS SELECT i, list_sort(list(j ORDER BY rowid)) j FROM lists GROUP BY i ORDER BY i +-- +ok +== +FROM nested_lists +-- +ok +== +SELECT i, flatten(j) FROM nested_lists +-- +ok +== +SELECT i, flatten(j) FROM nested_lists WHERE i % 2 != 0 +-- +ok +== +SELECT i, flatten([[1, 2], [3, 4]]) FROM nested_lists +-- +ok +== +select flatten(42); +-- +ok +== +select flatten([1, 2]); +-- +ok +== +select flatten(NULL); +-- +ok +== +with v_data (col, list) as ( select * FROM (VALUES ('a', [1,2,3]), ('b', [4,5]), ('a', [2,6])) ), + v_list_of_lists ( col, list, list_of_lists ) as ( select v.*, array_agg(v.list) over (partition by v.col order by v.list) from v_data v ) +select v.*, flatten(v.list_of_lists) from v_list_of_lists v; +-- +ok +== diff --git a/parser/testdata/corpus/sql/function/list/generate_series.test b/parser/testdata/corpus/sql/function/list/generate_series.test new file mode 100644 index 0000000..3cde0f6 --- /dev/null +++ b/parser/testdata/corpus/sql/function/list/generate_series.test @@ -0,0 +1,193 @@ +# source: test/sql/function/list/generate_series.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +SELECT range(3) +-- +ok +== +SELECT generate_series(3) +-- +ok +== +SELECT range(3) FROM range(3) +-- +ok +== +SELECT range(i) FROM range(3) tbl(i) +-- +ok +== +SELECT range(NULL) FROM range(3) tbl(i) +-- +ok +== +SELECT range(CASE WHEN i%2=0 THEN NULL ELSE i END) FROM range(6) tbl(i) +-- +ok +== +SELECT range(0) +-- +ok +== +SELECT range(-1) +-- +ok +== +SELECT range(NULL) +-- +ok +== +SELECT range(1, 3) +-- +ok +== +SELECT generate_series(1, 3) +-- +ok +== +SELECT range(1, 1) +-- +ok +== +SELECT range(-10, -5) +-- +ok +== +SELECT generate_series(1, 1) +-- +ok +== +SELECT range(3, 1) +-- +ok +== +SELECT range(NULL, 1) +-- +ok +== +SELECT range(1, NULL) +-- +ok +== +SELECT range(NULL, NULL) +-- +ok +== +SELECT range(i, 5) FROM range(5) tbl(i) +-- +ok +== +SELECT range(0, i) FROM range(5) tbl(i) +-- +ok +== +SELECT range(1, 6, 2) +-- +ok +== +SELECT generate_series(1, 6, 2) +-- +ok +== +SELECT generate_series(1, 7, 2) +-- +ok +== +SELECT range(1, 10, 100) +-- +ok +== +SELECT range(1, 10, 0) +-- +ok +== +SELECT range(3, 1, -1) +-- +ok +== +SELECT generate_series(3, 1, -1) +-- +ok +== +SELECT range(3, 1, 1) +-- +ok +== +SELECT range(1, 3, -1) +-- +ok +== +SELECT range(4, 1, -1) +-- +ok +== +SELECT range(50, 1, -20) +-- +ok +== +SELECT generate_series(50, 1, -20) +-- +ok +== +SELECT generate_series(50, -10, -20) +-- +ok +== +SELECT range(NULL, 1, 1) +-- +ok +== +SELECT range(1, NULL, 1) +-- +ok +== +SELECT range(1, 1, NULL) +-- +ok +== +SELECT range(NULL, NULL, NULL) +-- +ok +== +SELECT * FROM (SELECT 1 UNION ALL SELECT 0 UNION ALL SELECT 2) AS _(x), generate_series(1, x) AS __(y) ORDER BY x, y +-- +ok +== +EXPLAIN FROM range(0); +-- +ok +== +EXPLAIN FROM range(-1); +-- +ok +== +EXPLAIN FROM range(-5, -20, -1); +-- +ok +== +EXPLAIN FROM range(1, 4, 2); +-- +ok +== +EXPLAIN FROM range(1, 5, 2); +-- +ok +== +EXPLAIN FROM generate_series(0); +-- +ok +== +EXPLAIN FROM generate_series(1); +-- +ok +== +EXPLAIN FROM generate_series(1, 4, 2); +-- +ok +== +EXPLAIN FROM generate_series(1, 5, 2); +-- +ok +== diff --git a/parser/testdata/corpus/sql/function/list/generate_series_timestamp.test b/parser/testdata/corpus/sql/function/list/generate_series_timestamp.test new file mode 100644 index 0000000..b18d3d2 --- /dev/null +++ b/parser/testdata/corpus/sql/function/list/generate_series_timestamp.test @@ -0,0 +1,71 @@ +# source: test/sql/function/list/generate_series_timestamp.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +SELECT generate_series(timestamp '2020-01-01', timestamp '2020-07-01', interval '3' month); +-- +ok +== +SELECT range(timestamp '2020-01-01', timestamp '2020-07-01', interval '3' month); +-- +ok +== +SELECT generate_series(timestamp '2020-06-01', timestamp '2020-01-01', -interval '3' month); +-- +ok +== +SELECT generate_series(timestamp '2020-01-01', timestamp '2020-01-01', interval '1' day); +-- +ok +== +SELECT range(timestamp '2020-01-01', timestamp '2020-01-01', interval '1' day); +-- +ok +== +SELECT generate_series(timestamp '2020-06-01', timestamp '2020-01-01', interval '3' month); +-- +ok +== +SELECT generate_series(timestamp '2020-01-01', timestamp '2020-06-01', -interval '3' month); +-- +ok +== +SELECT generate_series(NULL, timestamp '2020-06-01', -interval '3' month); +-- +ok +== +SELECT generate_series(timestamp '2020-01-01', NULL, -interval '3' month); +-- +ok +== +SELECT generate_series(timestamp '2020-01-01', timestamp '2020-06-01', NULL); +-- +ok +== +SELECT generate_series(timestamp '2020-01-01', timestamp '2020-06-01', interval '3' month - interval '3' day); +-- +ok +== +SELECT generate_series('294247-01-10'::TIMESTAMP, 'infinity'::TIMESTAMP, INTERVAL '1 DAY'); +-- +ok +== +SELECT range('294247-01-10'::TIMESTAMP, 'infinity'::TIMESTAMP, INTERVAL '1 DAY'); +-- +ok +== +SELECT generate_series('-infinity'::TIMESTAMP, '290309-12-22 (BC) 00:00:00'::TIMESTAMP, INTERVAL '1 DAY'); +-- +ok +== +SELECT range('-infinity'::TIMESTAMP, '290309-12-22 (BC) 00:00:00'::TIMESTAMP, INTERVAL '1 DAY'); +-- +ok +== +SELECT count(*) FROM ( + SELECT unnest(generate_series(timestamp '2000-01-01', timestamp '2020-06-01', interval '1' day)) +); +-- +ok +== diff --git a/parser/testdata/corpus/sql/function/list/generate_subscripts.test b/parser/testdata/corpus/sql/function/list/generate_subscripts.test new file mode 100644 index 0000000..d7fd609 --- /dev/null +++ b/parser/testdata/corpus/sql/function/list/generate_subscripts.test @@ -0,0 +1,21 @@ +# source: test/sql/function/list/generate_subscripts.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +SELECT generate_subscripts([4,5,6], 1) +-- +ok +== +SELECT generate_subscripts([], 1) +-- +ok +== +SELECT generate_subscripts(NULL, 1) +-- +ok +== +SELECT generate_subscripts([[1,2],[3,4],[5,6]], 2) +-- +ok +== diff --git a/parser/testdata/corpus/sql/function/list/icu_generate_series_timestamptz.test b/parser/testdata/corpus/sql/function/list/icu_generate_series_timestamptz.test new file mode 100644 index 0000000..68a27f8 --- /dev/null +++ b/parser/testdata/corpus/sql/function/list/icu_generate_series_timestamptz.test @@ -0,0 +1,77 @@ +# source: test/sql/function/list/icu_generate_series_timestamptz.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +SELECT generate_series(timestamptz '2020-01-01', timestamptz '2020-07-01', interval '3' month); +-- +ok +== +SELECT range(timestamptz '2020-01-01', timestamptz '2020-07-01', interval '3' month); +-- +ok +== +SELECT generate_series(timestamptz '2020-06-01', timestamptz '2020-01-01', -interval '3' month); +-- +ok +== +SELECT generate_series(timestamptz '2020-01-01', timestamptz '2020-01-01', interval '1' day); +-- +ok +== +SELECT range(timestamptz '2020-01-01', timestamptz '2020-01-01', interval '1' day); +-- +ok +== +SELECT generate_series(timestamptz '2020-06-01', timestamptz '2020-01-01', interval '3' month); +-- +ok +== +SELECT generate_series(timestamptz '2020-01-01', timestamptz '2020-06-01', -interval '3' month); +-- +ok +== +SELECT count(*) FROM ( + SELECT unnest(generate_series(timestamptz '2000-01-01', timestamptz '2020-06-01', interval '1' day)) +); +-- +ok +== +SELECT generate_series(start, stop, step) FROM (VALUES + (timestamptz '2020-01-01', timestamptz '2020-07-01', interval '3' month), + (timestamptz '2020-12-04', timestamptz '2020-09-01', interval '-1 month -1 day'), + (timestamptz '2020-03-08', timestamptz '2020-03-09', interval '6' hour), + (timestamptz '2020-11-02', timestamptz '2020-11-01', interval '-43200' second), +) AS _(start, stop, step); +-- +ok +== +SELECT range(start, stop, step) FROM (VALUES + (timestamptz '2020-01-01', timestamptz '2020-07-01', interval '3' month), + (timestamptz '2020-12-04', timestamptz '2020-09-01', interval '-1 month -1 day'), + (timestamptz '2020-03-08', timestamptz '2020-03-09', interval '6' hour), + (timestamptz '2020-11-02', timestamptz '2020-11-01', interval '-43200' second), +) AS _(start, stop, step); +-- +ok +== +SELECT generate_series(timestamptz '2020-01-01', timestamptz '2020-06-01', interval '3' month - interval '3' day); +-- +ok +== +SELECT generate_series('294247-01-10'::TIMESTAMPTZ, 'infinity'::TIMESTAMPTZ, INTERVAL '1 DAY'); +-- +ok +== +SELECT range('294247-01-10'::TIMESTAMPTZ, 'infinity'::TIMESTAMPTZ, INTERVAL '1 DAY'); +-- +ok +== +SELECT generate_series('-infinity'::TIMESTAMPTZ, '290309-12-22 (BC) 00:00:00'::TIMESTAMPTZ, INTERVAL '1 DAY'); +-- +ok +== +SELECT range('-infinity'::TIMESTAMPTZ, '290309-12-22 (BC) 00:00:00'::TIMESTAMPTZ, INTERVAL '1 DAY'); +-- +ok +== diff --git a/parser/testdata/corpus/sql/function/list/lambda_constant_null.test b/parser/testdata/corpus/sql/function/list/lambda_constant_null.test new file mode 100644 index 0000000..b7198b6 --- /dev/null +++ b/parser/testdata/corpus/sql/function/list/lambda_constant_null.test @@ -0,0 +1,9 @@ +# source: test/sql/function/list/lambda_constant_null.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +SELECT quantile(NULL, filter(NULL, (lambda c103: 'babea54a-2261-4b0c-b14b-1d0e9b794e1a'))); +-- +ok +== diff --git a/parser/testdata/corpus/sql/function/list/lambdas/arrow/expression_iterator_cases_deprecated.test b/parser/testdata/corpus/sql/function/list/lambdas/arrow/expression_iterator_cases_deprecated.test new file mode 100644 index 0000000..5788d77 --- /dev/null +++ b/parser/testdata/corpus/sql/function/list/lambdas/arrow/expression_iterator_cases_deprecated.test @@ -0,0 +1,107 @@ +# source: test/sql/function/list/lambdas/arrow/expression_iterator_cases_deprecated.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +SET lambda_syntax='ENABLE_SINGLE_ARROW' +-- +ok +== +SELECT list_transform([10], x -> sum(1) + x) +-- +ok +== +SELECT list_filter([10], x -> sum(1) > 0) +-- +ok +== +SELECT list_transform([NULL, DATE '1992-09-20', DATE '2021-09-20'], elem -> extract('year' FROM elem) BETWEEN 2000 AND 2022) +-- +ok +== +SELECT list_filter([NULL, DATE '1992-09-20', DATE '2021-09-20'], elem -> extract('year' FROM elem) BETWEEN 2000 AND 2022) +-- +ok +== +SELECT list_transform(['hello', 'duck', 'sunshine'], str -> CASE WHEN str LIKE '%e%' THEN 'e' ELSE 'other' END) +-- +ok +== +SELECT list_filter(['hello', 'duck', 'sunshine'], str -> (CASE WHEN str LIKE '%e%' THEN 'e' ELSE 'other' END) LIKE 'e') +-- +ok +== +SELECT list_transform([2.0::DOUBLE], x -> x::INTEGER) +-- +ok +== +SELECT list_filter([2], x -> x::DOUBLE == 2) +-- +ok +== +SELECT list_transform([2.4, NULL, -4.7], x -> x != 10.4) +-- +ok +== +SELECT list_filter([2.4, NULL, -4.7], x -> x != -4.7) +-- +ok +== +SELECT list_transform([True, False, NULL], x -> x AND true) +-- +ok +== +SELECT list_filter([True, False, NULL], x -> x AND true) +-- +ok +== +SELECT list_transform([TIMESTAMP '1992-03-22', TIMESTAMP '209-03-22', TIMESTAMP '1700-03-22'], x -> century(x)) +-- +ok +== +SELECT list_filter([TIMESTAMP '1992-03-22', TIMESTAMP '209-03-22', TIMESTAMP '1700-03-22'], x -> century(x) > 16) +-- +ok +== +SELECT list_transform([2], x -> x + x) +-- +ok +== +SELECT list_filter([2], x -> x + x = 4) +-- +ok +== +SELECT list_transform([2], x -> (SELECT 1 - x) * x) +-- +ok +== +SELECT list_filter([2], x -> (SELECT 1 - x) * x > 2) +-- +ok +== +SELECT list_filter([[1, 2, 1], [1, 2, 3], [1, 1, 1]], x -> list_contains_macro(x, 3)) +-- +ok +== +SELECT list_transform([1], x -> x = UNNEST([1])); +-- +ok +== +SELECT list_filter([1], x -> x = UNNEST([1])); +-- +ok +== +CREATE TABLE my_window (l integer[], g integer, o integer) +-- +ok +== +INSERT INTO my_window VALUES ([1], 1, 1), ([1, NULL, 2], 1, 2), ([], 2, 3), (NULL, NULL, NULL), ([1, 2], 2, 4) +-- +ok +== +SELECT list(list_transform(l, e -> e + 1)) OVER (PARTITION BY g ORDER BY o) +FROM my_window +ORDER BY ALL +-- +ok +== diff --git a/parser/testdata/corpus/sql/function/list/lambdas/arrow/filter_deprecated.test b/parser/testdata/corpus/sql/function/list/lambdas/arrow/filter_deprecated.test new file mode 100644 index 0000000..21b65e9 --- /dev/null +++ b/parser/testdata/corpus/sql/function/list/lambdas/arrow/filter_deprecated.test @@ -0,0 +1,155 @@ +# source: test/sql/function/list/lambdas/arrow/filter_deprecated.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +SELECT [1] AS l, list_filter([1], l -> l > 1) +-- +ok +== +SELECT list_filter(NULL, x -> x > 1) +-- +ok +== +SELECT list_filter([True], x -> x) +-- +ok +== +SELECT list_filter(['duck', 'a', 'ö'], duck -> contains(concat(duck, 'DB'), 'duck')) +-- +ok +== +SELECT list_filter([1, 2, 3], x -> x % 2 = 0) +-- +ok +== +SELECT list_filter([], x -> x > 1) +-- +ok +== +SELECT list_filter([1, NULL, -2, NULL], x -> x % 2 != 0) +-- +ok +== +SELECT list_filter([5, -6, NULL, 7], x -> x > 0) +-- +ok +== +SELECT list_filter([5, NULL, 7, NULL], x -> x IS NOT NULL) +-- +ok +== +CREATE TABLE lists (n integer, l integer[]) +-- +ok +== +INSERT INTO lists VALUES (1, [1]), (2, [1, 2, 3]), (3, NULL), (4, [-1, NULL, 2]) +-- +ok +== +SELECT list_filter(l, x -> x + 1 <= 2) FROM lists +-- +ok +== +SELECT list_filter(l, x -> x <= n) FROM lists +-- +ok +== +SELECT list_filter(l, x -> x IS NOT NULL) FROM lists +-- +ok +== +SELECT list_filter(['x', 'abc', 'z'], x -> contains(x || '0', 'a')) +-- +ok +== +SELECT list_transform([[1, 3], [2, 3, 1], [2, 4, 2]], x -> list_filter(x, y -> y <= 2)) +-- +ok +== +SELECT list_concat(list_filter([42, -42, 8, -5, 2], elem -> elem > 0)::varchar[], list_filter(['enjoy', 'life', 'to', 'the', 'fullest'], str -> str ILIKE '%e%')) +-- +ok +== +SELECT array_filter([1, NULL], arr_elem -> arr_elem < 4) +-- +ok +== +CREATE TABLE empty_lists (l integer[]) +-- +ok +== +INSERT INTO empty_lists VALUES ([]), ([]), ([]), ([1, NULL, -1]), ([]), (NULL), (NULL), ([]), ([1, 2, 3]), ([]), ([]), ([]); +-- +ok +== +SELECT list_filter(l, x -> x > 0) FROM empty_lists +-- +ok +== +CREATE TABLE large_lists AS SELECT range % 4 g, list(range) l FROM range(10000) GROUP BY range % 4; +-- +ok +== +SELECT g, list_count(list_filter(l, x -> x % 2 = 0)) FROM large_lists ORDER BY g +-- +ok +== +CREATE TABLE corr_test (n integer, l varchar[], g integer) +-- +ok +== +INSERT INTO corr_test VALUES (1, ['a', '11', '23'], 1), (3, [NULL, '2', 'hello', 'wie gehts'], 1), (NULL, NULL, 1), (0, [], 1) +-- +ok +== +SELECT n FROM corr_test WHERE list_count(list_filter(l, elem -> length(elem) >= n)) >= n +-- +ok +== +SELECT ct.n FROM corr_test ct +WHERE list_count(ct.l) < (SELECT list_count(list_filter(list_concat(list(c.n)::varchar[], ct.l), a -> length(a) >= 1)) FROM corr_test c GROUP BY c.g) +ORDER BY ct.n +-- +ok +== +SELECT (SELECT list_filter(l, elem -> length(elem) >= 1)) FROM corr_test ORDER BY ALL +-- +ok +== +SELECT (SELECT list_filter(l, elem -> length(elem) >= n)) FROM corr_test ORDER BY ALL +-- +ok +== +SELECT (SELECT (SELECT (SELECT list_filter(l, elem -> length(elem) >= 1)))) FROM corr_test ORDER BY ALL +-- +ok +== +SELECT list_filter([1, 2, 3, 4, 5, 6, 7, 8, 9], x -> x > #1) FROM range(10) +-- +ok +== +create table lambdas AS SELECT [5,6] AS col1, [4,8] AS col2; +-- +ok +== +SELECT list_apply(col1, x -> list_filter(col2, y -> y)) from lambdas; +-- +ok +== +SELECT list_apply([5,6], x -> list_filter([4,8], y -> y)); +-- +ok +== +SELECT list_apply([[5,6]], x -> list_filter(x, y -> y)); +-- +ok +== +SELECT list_transform([['abc']], x -> list_filter(x, y -> y)); +-- +ok +== +select [[y] for y in range(5)] as c, [x for x in c if x IS NOT NULL]; +-- +ok +== diff --git a/parser/testdata/corpus/sql/function/list/lambdas/arrow/lambda_scope_deprecated.test b/parser/testdata/corpus/sql/function/list/lambdas/arrow/lambda_scope_deprecated.test new file mode 100644 index 0000000..40d37a5 --- /dev/null +++ b/parser/testdata/corpus/sql/function/list/lambdas/arrow/lambda_scope_deprecated.test @@ -0,0 +1,141 @@ +# source: test/sql/function/list/lambdas/arrow/lambda_scope_deprecated.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +CREATE TABLE t1 AS SELECT [1, 2, 3] AS x; +-- +ok +== +SELECT list_apply(['hello'], x -> x) FROM t1; +-- +ok +== +CREATE TABLE t2 AS SELECT [[1], [2], [3]] AS x; +-- +ok +== +SELECT list_transform([[1], [2], [3]], x -> x[1]) FROM t2; +-- +ok +== +CREATE TABLE l_test (l integer[]); +-- +ok +== +INSERT INTO l_test VALUES ([1, 2, 3]); +-- +ok +== +SELECT l, list_transform(l, l -> l + 1) FROM l_test; +-- +ok +== +CREATE TABLE l_filter_test (l integer[]); +-- +ok +== +INSERT INTO l_filter_test VALUES ([1, 2]); +-- +ok +== +SELECT l, list_filter(l, l -> l > 1) FROM l_filter_test; +-- +ok +== +SELECT list_apply(i, a.x -> a.x + 1) FROM (VALUES (list_value(1, 2, 3))) tbl(i); +-- +ok +== +CREATE TABLE qualified_tbl (x INTEGER[]); +-- +ok +== +INSERT INTO qualified_tbl VALUES ([1, 2]); +-- +ok +== +SELECT list_transform(qualified_tbl.x, x -> (qualified_tbl.x)[1] + 1 + x) FROM qualified_tbl; +-- +ok +== +SELECT list_transform(qualified_tbl.x, qualified_tbl.x -> qualified_tbl.x + 1) FROM qualified_tbl; +-- +ok +== +SELECT list_transform([1, 2], x -> list_transform([3, 4], x -> x)); +-- +ok +== +SELECT list_has_all([variable_has_all FOR variable_has_all IN ['a']], ['b']) AS list_comp_result; +-- +ok +== +SELECT list_has_all(list_transform(['a'], variable_has_all -> variable_has_all), ['b']) AS list_transform_result; +-- +ok +== +SELECT list_has_any(['b'], list_transform(['a'], variable_has_any -> variable_has_any)) AS list_transform_result; +-- +ok +== +SELECT list_intersect(list_intersect([1], [1]), [1]) +-- +ok +== +SELECT list_intersect([1], list_intersect([1], [1])) +-- +ok +== +SELECT list_has_any(LIST_VALUE(list_has_any([1], [1])), [1]) +-- +ok +== +SELECT list_has_any([1], LIST_VALUE(list_has_any([1], [1]))) +-- +ok +== +SELECT list_has_all(LIST_VALUE(list_has_all([1], [1])), [1]) +-- +ok +== +SELECT list_has_all([1], LIST_VALUE(list_has_all([1], [1]))) +-- +ok +== +SELECT list_has_any(LIST_VALUE(list_has_all(list_intersect([1], [1]), [1])), [1]); +-- +ok +== +SELECT list_has_all(LIST_VALUE(list_has_any(list_intersect([1], [1]), [1])), [1]); +-- +ok +== +SELECT list_intersect(LIST_VALUE(list_has_all(LIST_VALUE(list_has_any([1], [1])), [1])), [1]) +-- +ok +== +SELECT list_intersect(list_intersect([1, 2, 3, 4], [4, 5, 6, 7]), list_intersect([4, 5, 6, 7], [1, 2, 3, 4])); +-- +ok +== +CREATE TABLE tbl_qualified AS SELECT 42 AS x; +-- +ok +== +SELECT x, list_transform([1], x -> x) FROM tbl_qualified; +-- +ok +== +SELECT list_transform([1,2,3], sqrt(xxx.z) -> xxx.z + 1) AS l ; +-- +ok +== +SELECT list_transform([1, 2, 3], "x.y" -> "x.y" + x.y) AS l FROM (VALUES (42), (84)) x(y); +-- +ok +== +SELECT list_reduce([1, 2, 3, 4], x *++++++++* y -> x - y) AS l; +-- +ok +== diff --git a/parser/testdata/corpus/sql/function/list/lambdas/arrow/lambdas_and_functions_deprecated.test b/parser/testdata/corpus/sql/function/list/lambdas/arrow/lambdas_and_functions_deprecated.test new file mode 100644 index 0000000..088bd35 --- /dev/null +++ b/parser/testdata/corpus/sql/function/list/lambdas/arrow/lambdas_and_functions_deprecated.test @@ -0,0 +1,31 @@ +# source: test/sql/function/list/lambdas/arrow/lambdas_and_functions_deprecated.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +CREATE OR REPLACE function demo(n, z) AS TABLE ( + SELECT list_transform(range(0, n), x -> z) AS row +); +-- +ok +== +FROM demo(3, 0); +-- +ok +== +CREATE OR REPLACE function demo(n, z) AS TABLE ( + SELECT list_transform(range(0, n), x -> 0 + z) AS row +); +-- +ok +== +CREATE OR REPLACE function demo(n, z) AS TABLE ( + SELECT list_transform(range(0, n), x -> (z -> 'a')) AS row +); +-- +ok +== +FROM demo(3, {'a': 2}); +-- +ok +== diff --git a/parser/testdata/corpus/sql/function/list/lambdas/arrow/lambdas_and_group_by_deprecated.test b/parser/testdata/corpus/sql/function/list/lambdas/arrow/lambdas_and_group_by_deprecated.test new file mode 100644 index 0000000..92f9188 --- /dev/null +++ b/parser/testdata/corpus/sql/function/list/lambdas/arrow/lambdas_and_group_by_deprecated.test @@ -0,0 +1,48 @@ +# source: test/sql/function/list/lambdas/arrow/lambdas_and_group_by_deprecated.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +CREATE TABLE tbl (tag_product VARCHAR); +-- +ok +== +INSERT INTO tbl VALUES ('milk chickpeas apples'), ('chocolate pepper'); +-- +ok +== +SELECT tag_product, list_aggr(list_transform( + string_split(tag_product, ' '), word -> lower(word)), + 'string_agg', ',') AS tag_material, +FROM tbl GROUP BY tag_product +ORDER BY ALL; +-- +ok +== +SELECT 1, list_transform([5, 4, 3], x -> x + 1) AS lst GROUP BY 1; +-- +ok +== +CREATE TABLE uniform_purchase_forecast AS +SELECT 'gold' AS color, 10 AS forecast +UNION ALL SELECT 'blue', 15 +UNION ALL SELECT 'red', 300; +-- +ok +== +FROM uniform_purchase_forecast SELECT list(forecast).list_transform(x -> x + 10); +-- +ok +== +FROM (SELECT 1) GROUP BY ALL HAVING list_filter(NULL, x -> x); +-- +ok +== +FROM test_all_types() GROUP BY ALL HAVING array_intersect(NULL, NULL); +-- +ok +== +SELECT x FROM (VALUES (42)) t(x) GROUP BY x HAVING list_filter(NULL, lambda_param -> lambda_param = 1); +-- +ok +== diff --git a/parser/testdata/corpus/sql/function/list/lambdas/arrow/lambdas_and_macros_deprecated.test b/parser/testdata/corpus/sql/function/list/lambdas/arrow/lambdas_and_macros_deprecated.test new file mode 100644 index 0000000..57d4d47 --- /dev/null +++ b/parser/testdata/corpus/sql/function/list/lambdas/arrow/lambdas_and_macros_deprecated.test @@ -0,0 +1,65 @@ +# source: test/sql/function/list/lambdas/arrow/lambdas_and_macros_deprecated.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +create table test as select range i from range(3); +-- +ok +== +create macro my_macro(i) as (select i in (select i from test)); +-- +ok +== +CREATE MACRO list_contains_macro(x, y) AS (list_contains(x, y)) +-- +ok +== +CREATE MACRO macro_with_lambda(list, num) AS (list_transform(list, x -> x + num)) +-- +ok +== +SELECT list_filter([[1, 2], NULL, [3], [4, NULL]], f -> list_count(macro_with_lambda(f, 2)) > 1) +-- +ok +== +CREATE MACRO some_macro(x, y, z) AS (SELECT list_transform(x, a -> x + y + z)) +-- +ok +== +SELECT some_macro([1, 2], 3, 4); +-- +ok +== +CREATE MACRO reduce_macro(list, num) AS (list_reduce(list, (x, y) -> x + y + num)) +-- +ok +== +SELECT reduce_macro([1, 2, 3, 4], 5); +-- +ok +== +CREATE MACRO other_reduce_macro(list, num, bla) AS (SELECT list_reduce(list, (x, y) -> list + x + y + num + bla)) +-- +ok +== +SELECT other_reduce_macro([1, 2, 3, 4], 5, 6); +-- +ok +== +CREATE MACRO scoping_macro(x, y, z) AS (SELECT list_transform(x, x -> x + y + z)); +-- +ok +== +SELECT scoping_macro([11, 22], 3, 4); +-- +ok +== +CREATE OR REPLACE MACRO foo(bar) AS (SELECT apply([bar], x -> 0)); +-- +ok +== +SELECT foo(v) FROM (SELECT 0 AS v); +-- +ok +== diff --git a/parser/testdata/corpus/sql/function/list/lambdas/arrow/list_comprehension_deprecated.test b/parser/testdata/corpus/sql/function/list/lambdas/arrow/list_comprehension_deprecated.test new file mode 100644 index 0000000..be1fb2d --- /dev/null +++ b/parser/testdata/corpus/sql/function/list/lambdas/arrow/list_comprehension_deprecated.test @@ -0,0 +1,79 @@ +# source: test/sql/function/list/lambdas/arrow/list_comprehension_deprecated.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +SELECT list_transform(list_filter([0, 1, 2, 3, 4, 5], x -> x % 2 = 0), y -> y * y) +-- +ok +== +SELECT [x * x for x in [0, 1, 2, 3, 4, 5] if x%2=0] +-- +ok +== +SELECT list_filter(list_filter([2, 4, 3, 1, 20, 10, 3, 30], x -> x % 2 == 0), y -> y % 5 == 0) +-- +ok +== +SELECT [x for x in [x for x in [2, 4, 3, 1, 20, 10, 3, 30] if x % 2 == 0] if x % 5 == 0] +-- +ok +== +SELECT list_filter(['apple', 'banana', 'cherry', 'kiwi', 'mango'], fruit -> contains(fruit, 'a')) +-- +ok +== +SELECT [fruit for fruit in ['apple', 'banana', 'cherry', 'kiwi', 'mango'] if contains(fruit, 'a')] +-- +ok +== +CREATE TABLE fruit_tbl AS SELECT ['apple', 'banana', 'cherry', 'kiwi', 'mango'] fruits +-- +ok +== +SELECT [fruit for fruit in fruits if contains(fruit, 'a')] FROM fruit_tbl +-- +ok +== +SELECT list_transform([[1, NULL, 2], [3, NULL]], a -> list_filter(a, x -> x IS NOT NULL)) +-- +ok +== +SELECT [len(x) for x in ['goodbye', 'cruel', 'world']] +-- +ok +== +CREATE TABLE word_tbl AS SELECT ['goodbye', 'cruel', 'world'] words +-- +ok +== +SELECT [len(x) for x in words] from word_tbl +-- +ok +== +with base as ( + select [4,5,6] as l +) +select [x for x,i in l if i != 2] as filtered from base; +-- +ok +== +select [x+i for x, i in [10, 9, 8, 7, 6]] +-- +ok +== +with base as ( + select [4,5,6] as l +) +select [x + 5 for x in l] as filtered from base; +-- +ok +== +select [a for a, b, c in [1,2,3]]; +-- +ok +== +select [a for a[1], b[2] in [1,2,3,4]]; +-- +error: Parser Error: syntax error at or near "[" +== diff --git a/parser/testdata/corpus/sql/function/list/lambdas/arrow/reduce_deprecated.test b/parser/testdata/corpus/sql/function/list/lambdas/arrow/reduce_deprecated.test new file mode 100644 index 0000000..943b9fe --- /dev/null +++ b/parser/testdata/corpus/sql/function/list/lambdas/arrow/reduce_deprecated.test @@ -0,0 +1,301 @@ +# source: test/sql/function/list/lambdas/arrow/reduce_deprecated.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +SELECT list_reduce([1, 2, 3], (x, y) -> x + y); +-- +ok +== +SELECT list_reduce([1, 2, 3], (x, y) -> x * y); +-- +ok +== +SELECT list_reduce([100, 10, 1], (x, y, i) -> x - y - i); +-- +ok +== +SELECT list_reduce([1, 2, 3], (x, y) -> y - x); +-- +ok +== +SELECT list_reduce([1, 2, 3], (x, y) -> x - y); +-- +ok +== +SELECT list_reduce([1, 2, 3], (x, y, i) -> x + y + i); +-- +ok +== +SELECT list_reduce([NULL], (x, y, i) -> x + y + i); +-- +ok +== +SELECT list_reduce(NULL, (x, y, i) -> x + y + i); +-- +ok +== +SELECT list_reduce(['Once', 'upon', 'a', 'time'], (x, y) -> x || ' ' || y); +-- +ok +== +SELECT list_reduce(['a', 'b', 'c', 'd'], (x, y, i) -> x || ' - ' || CAST(i AS VARCHAR) || ' - ' || y); +-- +ok +== +SELECT list_reduce([], (x, y, i) -> x + y + i); +-- +ok +== +SELECT list_reduce([1, 2, 3], (x, y) -> (x * y)::VARCHAR || 'please work'); +-- +ok +== +SELECT list_reduce([1, 2], (x) -> x); +-- +ok +== +SELECT list_reduce([1, 2], NULL); +-- +ok +== +SELECt list_reduce([1, 2], (len('abc') AS x, y) - > x + y) +-- +error: Parser Error: syntax error at or near "AS" +== +CREATE table t1(a int[]); +-- +ok +== +INSERT INTO t1 VALUES ([1, 2, 3]); +-- +ok +== +INSERT INTO t1 VALUES ([666]); +-- +ok +== +INSERT INTO t1 VALUES (NULL); +-- +ok +== +INSERT INTO t1 VALUES ([44, 55]); +-- +ok +== +INSERT INTO t1 VALUES ([-1, NULL, -2]); +-- +ok +== +SELECT list_reduce(a, (x, y) -> x + y) FROM t1; +-- +ok +== +SELECT list_reduce(a, (x, y, i) -> x + y + i) FROM t1; +-- +ok +== +INSERT INTO t1 VALUES ([]); +-- +ok +== +CREATE TABLE t1 (a varchar[]); +-- +ok +== +INSERT INTO t1 VALUES (['Once', 'upon', 'a', 'time']), (NULL), (['there', 'was', 'a', 'table']), (['with', 'a', 'list', 'of', 'strings']), (['and', 'it', 'was', NULL]); +-- +ok +== +SELECT list_reduce(a, (x, y) -> x || ' ' || y) FROM t1; +-- +ok +== +CREATE TABLE right_only (v varchar[], i int); +-- +ok +== +INSERT INTO right_only VALUES (['blue', 'babbling', 'brook'], 1), (['dogs', 'doing', 'dishes'], 2), (['she', 'sells', 'seashells'], 3); +-- +ok +== +SELECT list_reduce(v, (x, y) -> y[i]) FROM right_only; +-- +ok +== +SELECT list_reduce([1, 2, 3], (x, y) -> list_reduce([4, 5, 6], (a, b) -> x + y + a + b)); +-- +ok +== +SELECT list_reduce([1, 2, 3], (x, y) -> list_reduce([], (a, b) -> x + y + a + b)); +-- +ok +== +SELECT list_reduce([1, 2, 3], (x, y, x_i) -> list_reduce([4, 5, 6], (a, b, a_i) -> x + y + a + b + x_i + a_i)); +-- +ok +== +SELECT list_reduce([1, 2, 3], (x, y, x_i) -> list_reduce([], (a, b, a_i) -> x + y + a + b + x_i + a_i)); +-- +ok +== +SELECT list_reduce([[10, 20], [30, 40], [50, 60]], (x, y) -> list_pack(list_reduce(x, (l, m) -> l + m) + list_reduce(y, (n, o) -> n + o))); +-- +ok +== +SELECT list_reduce([[1,2,3], [4,5,6], [7,8,9]], (x, y) -> list_pack(list_reduce(x, (l, m) -> l + m) + list_reduce(y, (n, o) -> n + o))); +-- +ok +== +SELECT list_reduce([[10, 20], [30, 40], NULL, [NULL, 60], NULL], (x, y) -> list_pack(list_reduce(x, (l, m) -> l + m) + list_reduce(y, (n, o) -> n + o))); +-- +ok +== +SELECT list_reduce(['a', 'b', 'c', 'd'], (x, y) -> list_reduce(['1', '2', '3', '4'], (a, b) -> x || y || a || b)); +-- +ok +== +SELECT list_reduce([['a', 'b'], ['c', 'd'], ['e', 'f']], (x, y) -> list_pack(list_reduce(x, (a, b) -> a || b) || list_reduce(y, (c, d) -> c || d))); +-- +ok +== +CREATE TABLE nested (n integer[], l integer[]) +-- +ok +== +INSERT INTO nested VALUES ([1, 2, 3], [4, 5, 6]), (NULL, NULL), (NULL, [110, 111, 112]), ([77, 88, 99], [55, 66, NULL]); +-- +ok +== +SELECT list_reduce(n, (x, y) -> list_reduce(l, (a, b) -> x + y + a + b)) FROM nested; +-- +ok +== +SELECT list_reduce(n, (x, y, x_i) -> list_reduce(l, (a, b, a_i) -> x + y + a + b + x_i + a_i)) FROM nested; +-- +ok +== +SELECT list_reduce(n, (x, y, x_i) -> list_reduce(l, (a, b, a_i) -> x + y + x_i < a + b + a_i)) FROM nested; +-- +ok +== +INSERT INTO nested VALUES ([4, 5, 6], []); +-- +ok +== +DROP TABLE nested; +-- +ok +== +CREATE TABLE nested (n integer[][]) +-- +ok +== +INSERT INTO nested VALUES ([[10, 20], [30, 40], [50, 60]]), ([[1,2,3], [4,5,6], [7,8,9]]), (NULL), ([[NULL, 60], [70, NULL], [NULL, NULL]]); +-- +ok +== +SELECT list_reduce(n, (x, y) -> list_pack(list_reduce(x, (l, m) -> l + m) + list_reduce(y, (j, k) -> j + k))) from nested; +-- +ok +== +INSERT INTO nested VALUES ([[4, 5, 6], []]); +-- +ok +== +CREATE TABLE nested (n varchar[], l varchar[]) +-- +ok +== +INSERT INTO nested VALUES (['a', 'b', 'c', 'd'], ['1', '2', '3', '4']), (NULL, NULL), (NULL, ['110', '111', '112']), (['77', '88', '99'], ['55', '66', NULL]); +-- +ok +== +SELECT list_reduce(n, (x, y) -> list_reduce(l, (a, b) -> x || y || a || b)) FROM nested; +-- +ok +== +SELECT list_reduce([1, 2, 3], (x, y) -> list_reduce([4, 5, 6], (a, b) -> list_reduce([7, 8, 9], (c, d) -> x + y + a + b + c + d))); +-- +ok +== +SELECT list_reduce([1, 2, 3], (x, y, x_i) -> list_reduce([4, 5, 6], (a, b, a_i) -> list_reduce([7, 8, 9], (c, d, c_i) -> x + y + a + b + c + d + x_i + a_i + c_i))); +-- +ok +== +SELECT list_reduce([[[10, 20], [100, 200]], [[30, 40], [300, 400]], [[50, 60], [500, 600]]], (x, y) -> list_pack(list_reduce(x, (l, m) -> list_pack(list_reduce(l, (a, b) -> a + b) + list_reduce(m, (c, d) -> c + d))) + list_reduce(y, (n, o) -> list_pack(list_reduce(n, (a, b) -> a + b) + list_reduce(o, (c, d) -> c + d))))); +-- +ok +== +CREATE TABLE nested (n integer[], l integer[], m integer[]) +-- +ok +== +INSERT INTO nested VALUES ([1, 2, 3], [4, 5, 6], [7, 8, 9]), (NULL, NULL, NULL), (NULL, [110, 111, 112], [113, 114, 115]), ([77, 88, 99], [55, 66, NULL], [44, 33, 22]); +-- +ok +== +SELECT list_reduce(n, (x, y) -> list_reduce(l, (a, b) -> list_reduce(m, (c, d) -> x + y + a + b + c + d))) FROM nested; +-- +ok +== +CREATE TABLE nested (n integer[][][]) +-- +ok +== +INSERT INTO nested VALUES ([[[10, 20], [100, 200]], [[30, 40], [300, 400]], [[50, 60], [500, 600]]]), ([[[1,2,3], [4,5,6], [7,8,9]]]), (NULL), ([[[NULL, 60], [70, NULL], [NULL, NULL]]]); +-- +ok +== +SELECT list_reduce(n, (x, y) -> list_pack(list_reduce(x, (l, m) -> list_pack(list_reduce(l, (a, b) -> a + b) + list_reduce(m, (c, d) -> c + d))) + list_reduce(y, (e, f) -> list_pack(list_reduce(e, (a, b) -> a + b) + list_reduce(f, (c, d) -> c + d))))) from nested; +-- +ok +== +CREATE table where_clause (a int[]); +-- +ok +== +INSERT INTO where_clause VALUES ([10, 2, 1]), ([1, 2, 3]), ([15, 4, 3]), ([3, 4, 5]), ([11, 2, 3, 4, 5]), ([5, 4, 3, 2, 1]), ([100, 2, 3, 4, 5, 6, 7, 8, 9, 10]); +-- +ok +== +SELECT a FROM where_clause WHERE list_reduce(a, (x, y) -> x - y) > 0; +-- +ok +== +CREATE TABLE t_struct (s STRUCT(v VARCHAR, i INTEGER)[]); +-- +ok +== +INSERT INTO t_struct VALUES ([row('a', 1), row('b', 2)]), ([row('c', 3), row('d', 4)]), ([row('e', 5), row('f', 6)]), ([row('g', 7), row('h', 8)]), ([row('i', 9), row('j', 10)]); +-- +ok +== +SELECT list_reduce(s, (a, b) -> row(a.v || b.v, a.i + b.i)) FROM t_struct; +-- +ok +== +CREATE OR REPLACE TABLE df(s STRUCT(a INT, b INT)[]); +-- +ok +== +INSERT INTO df VALUES ([row(0, 0), row(0, 1), row(0, 2)]); +-- +ok +== +SELECT +list_reduce( + s, (curr, next) -> struct_pack(a:=curr.a + (next.b - curr.b), b:=next.b) +) +FROM df +-- +ok +== +SELECT +list_reduce( + [struct_pack(a:=0, b:=0), struct_pack(a:=0, b:=1), struct_pack(a:=0, b:=2)], + (curr, next) -> struct_pack(a:=curr.a + (next.b - curr.b), b:=next.b) +) +-- +ok +== diff --git a/parser/testdata/corpus/sql/function/list/lambdas/arrow/reduce_initial_deprecated.test b/parser/testdata/corpus/sql/function/list/lambdas/arrow/reduce_initial_deprecated.test new file mode 100644 index 0000000..b6ff86e --- /dev/null +++ b/parser/testdata/corpus/sql/function/list/lambdas/arrow/reduce_initial_deprecated.test @@ -0,0 +1,306 @@ +# source: test/sql/function/list/lambdas/arrow/reduce_initial_deprecated.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +SELECT list_reduce([1, 2, 3], (x, y) -> x + y, 100); +-- +ok +== +SELECT list_reduce([1, 2, 3], (x, y) -> x * y, -1); +-- +ok +== +SELECT list_reduce([100, 10, 1], (x, y, i) -> x - y - i, 1000); +-- +ok +== +SELECT list_reduce([1, 2, 3], (x, y) -> y - x, -1); +-- +ok +== +SELECT list_reduce([1, 2, 3], (x, y) -> x - y, 10); +-- +ok +== +SELECT list_reduce([1, 2, 3], (x, y, i) -> x + y + i, -1); +-- +ok +== +SELECT list_reduce([1, 2, 3], (x, y) -> x + y, NULL); +-- +ok +== +SELECT list_reduce([NULL], (x, y, i) -> x + y + i, 100); +-- +ok +== +SELECT list_reduce(NULL, (x, y, i) -> x + y + i, 100); +-- +ok +== +SELECT list_reduce(['Once', 'upon', 'a', 'time'], (x, y) -> x || ' ' || y, '-->'); +-- +ok +== +SELECT list_reduce([], (x, y) -> x + y, 100); +-- +ok +== +SELECT list_reduce(['a', 'b', 'c'], (x, y) -> x || y, NULL); +-- +ok +== +SELECT list_reduce([1, 2, 3], (x, y) -> (x * y), 'i dare you to cast me'); +-- +ok +== +SELECT list_reduce([1, 2], (x) -> x, 100); +-- +ok +== +SELECT list_reduce([1, 2], NULL, 100); +-- +ok +== +SELECt list_reduce([1, 2], (len('abc') AS x, y) - > x + y, 100) +-- +error: Parser Error: syntax error at or near "AS" +== +CREATE table t1(l int[], initial int); +-- +ok +== +INSERT INTO t1 VALUES ([1, 2, 3], 100); +-- +ok +== +INSERT INTO t1 VALUES ([666], 1000); +-- +ok +== +INSERT INTO t1 VALUES ([1, 2, 3], NULL); +-- +ok +== +INSERT INTO t1 VALUES (NULL, 2); +-- +ok +== +INSERT INTO t1 VALUES ([44, 55], 3); +-- +ok +== +INSERT INTO t1 VALUES ([-1, NULL, -2], 4); +-- +ok +== +SELECT list_reduce(l, (x, y) -> x + y, initial) FROM t1; +-- +ok +== +SELECT list_reduce(l, (x, y, i) -> x + y + i, initial) FROM t1; +-- +ok +== +INSERT INTO t1 VALUES ([], 100); +-- +ok +== +SELECT list_reduce(l, (x, y) -> x + y) FROM t1; +-- +ok +== +CREATE TABLE t1 (l varchar[], initial varchar); +-- +ok +== +INSERT INTO t1 VALUES (['a', 'b'], '1:'), (NULL, '2:'), (['e', 'f'], '3:'); +-- +ok +== +SELECT list_reduce(l, (x, y) -> x || ' ' || y, initial) FROM t1; +-- +ok +== +INSERT INTO t1 values (['h', NULL], '4:'), (['i', 'j'], '5:'); +-- +ok +== +INSERT INTO t1 values (['x', 'y'], NULL); +-- +ok +== +INSERT INTO t1 VALUES ([], '7:'); +-- +ok +== +SELECT list_reduce(l, (x, y) -> x || ' ' || y) FROM t1; +-- +ok +== +SELECT list_reduce([1, 2, 3], (x, y) -> list_reduce([4, 5, 6], (a, b) -> x + y + a + b, 100), 1000); +-- +ok +== +SELECT list_reduce([1, 2, 3], (x, y) -> list_reduce([], (a, b) -> x + y + a + b), 1000); +-- +ok +== +SELECT list_reduce([1, 2, 3], (x, y, x_i) -> list_reduce([4, 5, 6], (a, b, a_i) -> x + y + a + b + x_i + a_i, 100), 1000); +-- +ok +== +SELECT list_reduce([1, 2, 3], (x, y, x_i) -> list_reduce([], (a, b, a_i) -> x + y + a + b + x_i + a_i), 1000); +-- +ok +== +SELECT list_reduce([[10, 20], [30, 40], [50, 60]], (x, y) -> list_pack(list_reduce(x, (l, m) -> l + m) + list_reduce(y, (n, o) -> n + o)), [100, 200]); +-- +ok +== +SELECT list_reduce([[1,2,3], [4,5,6], [7,8,9]], (x, y) -> list_pack(list_reduce(x, (l, m) -> l + m) + list_reduce(y, (n, o) -> n + o)), [100]); +-- +ok +== +SELECT list_reduce([[10, 20], [30, 40], NULL, [NULL, 60], NULL], (x, y) -> list_pack(list_reduce(x, (l, m) -> l + m) + list_reduce(y, (n, o) -> n + o)), [100]); +-- +ok +== +SELECT list_reduce(['a', 'b'], (x, y) -> list_reduce(['1', '2'], (a, b) -> x || y || a || b, 'B'), 'A'); +-- +ok +== +SELECT list_reduce([['a', 'b'], ['c', 'd'], ['e', 'f']], (x, y) -> list_pack(list_reduce(x, (a, b) -> a || b) || list_reduce(y, (c, d) -> c || d)), ['->']); +-- +ok +== +CREATE TABLE nested (n integer[], l integer[], initial integer); +-- +ok +== +INSERT INTO nested VALUES ([1, 2, 3], [4, 5, 6], 100), (NULL, NULL, 100), (NULL, [110, 111, 112], 44), ([77, 88, 99], [55, 66, NULL], 1); +-- +ok +== +SELECT list_reduce(n, (x, y) -> list_reduce(l, (a, b) -> x + y + a + b), initial) FROM nested; +-- +ok +== +SELECT list_reduce(n, (x, y, x_i) -> list_reduce(l, (a, b, a_i) -> x + y + a + b + x_i + a_i), initial) FROM nested; +-- +ok +== +SELECT list_reduce(n, (x, y, x_i) -> list_reduce(l, (a, b, a_i) -> x + y + x_i < a + b + a_i), initial) FROM nested; +-- +ok +== +INSERT INTO nested VALUES ([4, 5, 6], [], -1); +-- +ok +== +CREATE TABLE nested (n integer[][], initial integer[]); +-- +ok +== +INSERT INTO nested VALUES ([[10, 20], [30, 40], [50, 60]], [100]), ([[1,2,3], [4,5,6], [7,8,9]], [1000]), (NULL, [-1]), ([[NULL, 60], [70, NULL], [NULL, NULL]], [NULL]); +-- +ok +== +SELECT list_reduce(n, (x, y) -> list_pack(list_reduce(x, (l, m) -> l + m) + list_reduce(y, (j, k) -> j + k)), initial) from nested; +-- +ok +== +INSERT INTO nested VALUES ([[4, 5, 6], []], [9]); +-- +ok +== +CREATE TABLE nested (n varchar[], l varchar[], initialN varchar, initialL varchar); +-- +ok +== +INSERT INTO nested VALUES (['a', 'b'], ['1', '2'], 'A', 'B'), (NULL, NULL, 'C', 'D'), (NULL, ['110', '111', '112'], 'X', 'Y'), (['77', '88', '99'], ['55', '66', NULL], 'E', 'F'); +-- +ok +== +SELECT list_reduce(n, (x, y) -> list_reduce(l, (a, b) -> x || y || a || b, initialL), initialN) FROM nested; +-- +ok +== +SELECT list_reduce([1, 2, 3], (x, y) -> list_reduce([4, 5, 6], (a, b) -> list_reduce([7, 8, 9], (c, d) -> x + y + a + b + c + d, 1000), 100), 10); +-- +ok +== +SELECT list_reduce([1, 2, 3], (x, y, x_i) -> list_reduce([4, 5, 6], (a, b, a_i) -> list_reduce([7, 8, 9], (c, d, c_i) -> x + y + a + b + c + d + x_i + a_i + c_i, 1000), 100), 10); +-- +ok +== +CREATE TABLE nested (n integer[], l integer[], m integer[], initial integer); +-- +ok +== +INSERT INTO nested VALUES ([1, 2, 3], [4, 5, 6], [7, 8, 9], 100), (NULL, NULL, NULL, NULL), (NULL, [110, 111, 112], [113, 114, 115], NULL), ([77, 88, 99], [55, 66, NULL], [44, 33, 22], 1); +-- +ok +== +SELECT list_reduce(n, (x, y) -> list_reduce(l, (a, b) -> list_reduce(m, (c, d) -> x + y + a + b + c + d, initial), initial), initial) FROM nested; +-- +ok +== +CREATE TABLE nested (n integer[][][], initial integer[][]); +-- +ok +== +INSERT INTO nested VALUES ([[[10, 20], [100, 200]], [[30, 40], [300, 400]], [[50, 60], [500, 600]]], [[1]]), ([[[1,2,3], [4,5,6], [7,8,9]]], [[2]]), (NULL, [[3]]), ([[[NULL, 60], [70, NULL], [NULL, NULL]]], [[4]]); +-- +ok +== +CREATE TABLE t_struct (s STRUCT(v VARCHAR, i INTEGER)[], initial STRUCT(v VARCHAR, i INTEGER)); +-- +ok +== +INSERT INTO t_struct VALUES ([row('a', 1), row('b', 2)], row('->', 1)), ([row('c', 3), row('d', 4)], row('-->', 2)), ([row('e', 5), row('f', 6)], row('--->', 3)), ([row('g', 7), row('h', 8)], row('---->', 4)), ([row('i', 9), row('j', 10)], row('----->', 5)); +-- +ok +== +SELECT list_reduce(s, (a, b) -> row(a.v || b.v, a.i + b.i), initial) FROM t_struct; +-- +ok +== +CREATE OR REPLACE TABLE df(s STRUCT(a INT, b INT)[], initial STRUCT(a INT, b INT)); +-- +ok +== +INSERT INTO df VALUES ([row(0, 0), row(0, 1), row(0, 2)], row(-2, -3)); +-- +ok +== +SELECT +list_reduce( + s, (curr, next) -> struct_pack(a:=curr.a + (next.b - curr.b), b:=next.b), initial +) +FROM df +-- +ok +== +SELECT +list_reduce( + [struct_pack(a:=0, b:=0), struct_pack(a:=0, b:=1), struct_pack(a:=0, b:=2)], + (curr, next) -> struct_pack(a:=curr.a + (next.b - curr.b), b:=next.b), + struct_pack(a:=-2, b:=-3) +) +-- +ok +== +CREATE table where_clause (a int[], initial integer); +-- +ok +== +INSERT INTO where_clause VALUES ([10, 2, 1], 10), ([1, 2, 3], 20), ([15, 4, 3], 30), ([3, 4, 5], 40), ([11, 2, 3, 4, 5], 50), ([5, 4, 3, 2, 1], 60), ([100, 2, 3, 4, 5, 6, 7, 8, 9, 10], 70); +-- +ok +== +SELECT a FROM where_clause WHERE list_reduce(a, (x, y) -> x - y, initial) > 0; +-- +ok +== diff --git a/parser/testdata/corpus/sql/function/list/lambdas/arrow/rhs_parameters_deprecated.test b/parser/testdata/corpus/sql/function/list/lambdas/arrow/rhs_parameters_deprecated.test new file mode 100644 index 0000000..f3ba9a5 --- /dev/null +++ b/parser/testdata/corpus/sql/function/list/lambdas/arrow/rhs_parameters_deprecated.test @@ -0,0 +1,64 @@ +# source: test/sql/function/list/lambdas/arrow/rhs_parameters_deprecated.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +SELECT list_apply([1,2], x -> list_apply([3,4], y -> {'x': x, 'y': y})) AS bug; +-- +ok +== +select list_transform([1,2], x -> list_transform([3,4], y -> x + y)); +-- +ok +== +select list_transform([1,2], x -> list_transform([3,4], y -> list_transform([5,6], z -> z + y + x))); +-- +ok +== +select list_transform([1,2,3,4], x -> list_filter([4,5,1,2,3,3,3,5,1,4], y -> y != x)) +-- +ok +== +select list_transform([[2, 4, 6]], x -> list_transform(x, y -> list_sum([y] || x))) +-- +ok +== +SELECT list_apply(range(5), x -> {x:x, w:list_filter(range(5), y -> abs(y-x) < 2)}); +-- +ok +== +SELECT list_apply(range(8), x -> list_aggr(list_apply(range(8), +y -> list_element('▁▂▃▄▅▆▇█', 1+abs(y-x))), 'string_agg', '')); +-- +ok +== +CREATE TABLE lists (i integer, v varchar[]) +-- +ok +== +INSERT INTO lists VALUES (1, ['a', 'b', 'c']), (8, NULL), (3, ['duck', 'db', 'tests']), (NULL, NULL), (NULL, ['lambdas!']) +-- +ok +== +SELECT list_transform(v, x -> list_transform(v, y -> x || y)) FROM lists +-- +ok +== +SELECT list_transform(v, x -> list_transform(v, y -> list_transform(v, z -> x || y || z))) FROM lists +-- +ok +== +SELECT list_transform(v, x -> [list_transform([':-)'], y -> x || y || '-#lambdaLove')] +|| list_filter(list_transform(['B-)'], k -> [k] || [x]), j -> list_contains(j, 'a') or list_contains(j, 'duck'))) +FROM lists +-- +ok +== +create table no_overwrite as select [range, range + 1] l from range(3); +-- +ok +== +select l, [[{'x+y': x + y, 'x': x, 'y': y, 'l': l} for y in [42, 43]] for x in l] from no_overwrite; +-- +ok +== diff --git a/parser/testdata/corpus/sql/function/list/lambdas/arrow/storage_deprecated.test b/parser/testdata/corpus/sql/function/list/lambdas/arrow/storage_deprecated.test new file mode 100644 index 0000000..2d4a0cf --- /dev/null +++ b/parser/testdata/corpus/sql/function/list/lambdas/arrow/storage_deprecated.test @@ -0,0 +1,37 @@ +# source: test/sql/function/list/lambdas/arrow/storage_deprecated.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +CREATE MACRO my_transform(list) AS list_transform(list, x -> x * x) +-- +ok +== +CREATE MACRO my_filter(list) AS list_filter(list, x -> x > 42) +-- +ok +== +CREATE MACRO my_reduce(list) AS list_reduce(list, (x, y) -> x + y) +-- +ok +== +CREATE MACRO my_nested_lambdas(nested_list) AS list_filter(nested_list, elem -> list_reduce(list_transform(elem, x -> x + 1), (x, y) -> x + y) > 42) +-- +ok +== +SELECT my_transform([1, 2, 3]) +-- +ok +== +SELECT my_filter([41, 42, NULL, 43, 44]) +-- +ok +== +SELECT my_reduce([1, 2, 3]) +-- +ok +== +SELECT my_nested_lambdas([[40, NULL], [20, 21], [10, 10, 20]]) +-- +ok +== diff --git a/parser/testdata/corpus/sql/function/list/lambdas/arrow/table_functions_deprecated.test b/parser/testdata/corpus/sql/function/list/lambdas/arrow/table_functions_deprecated.test new file mode 100644 index 0000000..fc83c3a --- /dev/null +++ b/parser/testdata/corpus/sql/function/list/lambdas/arrow/table_functions_deprecated.test @@ -0,0 +1,74 @@ +# source: test/sql/function/list/lambdas/arrow/table_functions_deprecated.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +CREATE TABLE tmp AS SELECT range AS id FROM range(10); +-- +ok +== +COPY tmp TO '{TEST_DIR}/my_file_cba.parquet' (FORMAT PARQUET); +-- +ok +== +SELECT COUNT(*) FROM read_parquet('{TEST_DIR}/my_file_' || +list_aggr(list_transform(['C', 'B', 'A'], s -> lower(s)), 'string_agg', '') || '.parquet'); +-- +ok +== +SELECT COUNT(*) FROM read_parquet('{TEST_DIR}/my_file_' || +list_aggr(list_transform(list_sort(['a', 'b', 'c'], 'DESC'), s -> lower(s)), 'string_agg', '') || '.parquet'); +-- +ok +== +SELECT COUNT(*) FROM read_parquet('{TEST_DIR}/my_file_' || +list_aggr(list_transform(list_filter(['s', 'c', 'b', NULL, 'a'], x -> x IS NOT NULL AND x != 's'), +s -> lower(s)), 'string_agg', '') || '.parquet'); +-- +ok +== +SELECT COUNT(*) FROM read_parquet('{TEST_DIR}/my_file_' || +list_aggr(list_transform(list_filter( +list_filter(['s', 'c', 'b', NULL, 'a'], y -> y != 's'), x -> x IS NOT NULL), +s -> lower(s)), 'string_agg', '') || '.parquet'); +-- +ok +== +SELECT COUNT(*) FROM read_parquet('{TEST_DIR}/my_file_' || +list_aggr(list_reduce([['c', 'b', NULL, 'a']], (x, y) -> coalesce(x,y)), 'string_agg', '') || '.parquet'); +-- +ok +== +COPY tmp TO '{TEST_DIR}/my_file_ac.parquet' (FORMAT PARQUET); +-- +ok +== +SELECT COUNT(*) FROM read_parquet('{TEST_DIR}/my_file_' || +list_aggr(list_transform(['a'], x -> list_transform(['a', 'c'], y -> x || y)[2]), 'string_agg', '') || '.parquet'); +-- +ok +== +COPY tmp TO '{TEST_DIR}/my_file_a=1,b=2,c=3.parquet' (FORMAT PARQUET); +-- +ok +== +SELECT COUNT(*) FROM read_parquet('{TEST_DIR}/my_file_' || +list_string_agg([lower(s) for s in ['a=1', 'b=2', 'c=3']]) || '.parquet'); +-- +ok +== +CREATE TABLE cities AS +SELECT * FROM (VALUES ('Amsterdam', [90, 10]), ('London', [89, 102])) cities (name, prices); +-- +ok +== +ALTER TABLE cities +ALTER COLUMN prices SET DATA TYPE INTEGER[] USING + list_filter(cities.prices, price -> price < 100); +-- +ok +== +SELECT name, prices AS cheap_options FROM cities; +-- +ok +== diff --git a/parser/testdata/corpus/sql/function/list/lambdas/arrow/test_deprecated_lambda.test b/parser/testdata/corpus/sql/function/list/lambdas/arrow/test_deprecated_lambda.test new file mode 100644 index 0000000..da7fa71 --- /dev/null +++ b/parser/testdata/corpus/sql/function/list/lambdas/arrow/test_deprecated_lambda.test @@ -0,0 +1,17 @@ +# source: test/sql/function/list/lambdas/arrow/test_deprecated_lambda.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +SET lambda_syntax='DISABLE_SINGLE_ARROW' +-- +ok +== +SELECT v.split(' ') strings, + strings.apply(x -> x.lower()).filter(x -> x[1] == 't') lower, + strings.apply(x -> x.upper()).filter(x -> x[1] == 'T') upper, + lower + upper AS mix_case_srings +FROM varchars +-- +ok +== diff --git a/parser/testdata/corpus/sql/function/list/lambdas/arrow/test_lambda_arrow_storage_deprecated.test b/parser/testdata/corpus/sql/function/list/lambdas/arrow/test_lambda_arrow_storage_deprecated.test new file mode 100644 index 0000000..5617bc3 --- /dev/null +++ b/parser/testdata/corpus/sql/function/list/lambdas/arrow/test_lambda_arrow_storage_deprecated.test @@ -0,0 +1,23 @@ +# source: test/sql/function/list/lambdas/arrow/test_lambda_arrow_storage_deprecated.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +ATTACH '{TEST_DIR}/deprecated_syntax.db'; +-- +ok +== +CREATE OR REPLACE FUNCTION deprecated_syntax.transpose(lst) AS ( + SELECT list_transform(range(1, 1 + length(lst[1])), + j -> list_transform(range(1, length(lst) + 1), + i -> lst[i][j] + ) + ) +); +-- +ok +== +DETACH deprecated_syntax; +-- +ok +== diff --git a/parser/testdata/corpus/sql/function/list/lambdas/arrow/transform_deprecated.test b/parser/testdata/corpus/sql/function/list/lambdas/arrow/transform_deprecated.test new file mode 100644 index 0000000..95f2c67 --- /dev/null +++ b/parser/testdata/corpus/sql/function/list/lambdas/arrow/transform_deprecated.test @@ -0,0 +1,211 @@ +# source: test/sql/function/list/lambdas/arrow/transform_deprecated.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +SELECT [1] AS l, list_transform([1], l -> l + 1) +-- +ok +== +SELECT list_transform(NULL, x -> x + 1) +-- +ok +== +SELECT list_transform([1], x -> x) +-- +ok +== +SELECT list_transform(['duck', 'a', 'ö'], duck -> concat(duck, 'DB')) +-- +ok +== +SELECT list_transform([1, 2, 3], x -> 1) +-- +ok +== +SELECT list_transform([], x -> x + 1) +-- +ok +== +SELECT list_transform([1, 2, 3], x -> x + 1) +-- +ok +== +SELECT list_transform([1, NULL, -2, NULL], x -> x + 1) +-- +ok +== +SELECT list_transform(l, x -> x) FROM lists +-- +ok +== +SELECT list_transform(l, x -> x + n) FROM lists +-- +ok +== +SELECT list_transform(l, x -> x < 2) FROM lists +-- +ok +== +SELECT list_transform(['x', 'abc', 'z'], x -> x || '0') +-- +ok +== +SELECT list_transform([[1], [2, 3], [NULL], NULL], x -> list_transform(x, y -> y + 1)) +-- +ok +== +SELECT list_transform([[1], [2], [3]], x -> list_concat(x, x)) +-- +ok +== +SELECT list_transform([5, NULL, 6], x -> POW(x, 2)::INTEGER) +-- +ok +== +SELECT list_transform([5, NULL, 6], x -> COALESCE(x, 0) + 1) +-- +ok +== +SELECT list_transform(list_value(list_unique(list_concat([1,2],[2,2]))), x -> (x + 1)::INTEGER); +-- +ok +== +SELECT list_sort(list_transform(list_distinct(list_concat([1,2],[2,2])), x -> x + 1)); +-- +ok +== +SELECT list_transform([[1], [2], [3]], x -> list_concat(list_transform(x, y -> y + 1), list_transform(x, z -> z - 1))) +-- +ok +== +SELECT list_transform([[1], [4], NULL, [1], [8]], x -> list_concat(list_transform(x, y -> CASE WHEN y > 1 THEN 'yay' ELSE 'nay' END), x)) +-- +ok +== +SELECT list_transform([[1], [4], NULL, [1], [8]], x -> list_concat(list_transform(x, y -> CASE WHEN y > 1 THEN 'yay' ELSE 'nay' END), x::VARCHAR[])) +-- +ok +== +SELECT array_transform([1, NULL], arr_elem -> arr_elem - 4) +-- +ok +== +SELECT array_apply([1, NULL], arr_elem -> arr_elem - 4) +-- +ok +== +SELECT list_apply([1, NULL], arr_elem -> arr_elem - 4) +-- +ok +== +select list_apply(i, x -> (6 + 2 * 12) // x) from (values (list_value(1, 2, 3))) tbl(i); +-- +ok +== +select list_apply(i, x -> x + 1 AND x + 1) from (values (list_value(1, 2, 3))) tbl(i); +-- +ok +== +CREATE TABLE transformed_lists (g integer, l integer[]); +-- +ok +== +INSERT INTO transformed_lists (SELECT g + 1, list_transform(l, x -> x + 1) FROM large_lists WHERE g != 3) +-- +ok +== +INSERT INTO transformed_lists (SELECT g - 3, list_transform(l, x -> x - 3) FROM large_lists WHERE g = 3) +-- +ok +== +SELECT ll.l = tl.l FROM large_lists ll, transformed_lists tl WHERE ll.g = tl.g +-- +ok +== +SELECT list_transform([{'a': 1}], x -> x.a); +-- +ok +== +SELECT list_transform([{'a': [1, 2, 3]}], x -> x.a[2]); +-- +ok +== +SELECT list_transform([{'b' : {'a': 1}}], x -> x.b.a); +-- +ok +== +SELECT list_transform([{'b' : {'a': 42, 'b': 43}}], x -> x.b.b); +-- +ok +== +SELECT list_transform([{'b' : {'a': [{'c': 77}], 'b': 43}}], x -> x.b.a[1].c); +-- +ok +== +CREATE TABLE corr_test (n integer, l integer[], g integer) +-- +ok +== +INSERT INTO corr_test VALUES (1, [2, 1, 1], 1), (3, [NULL, 2, 4, 4], 1), (NULL, NULL, 1), (0, [], 1) +-- +ok +== +SELECT n FROM corr_test WHERE list_sum(list_transform(l, elem -> elem - n)) >= n +-- +ok +== +SELECT ct.n FROM corr_test ct +WHERE list_count(ct.l) < (SELECT list_count(list_transform(list_concat(list(c.n), ct.l), a -> a)) FROM corr_test c GROUP BY c.g) +ORDER BY ct.n +-- +ok +== +SELECT (SELECT list_transform(l, elem -> elem + 1)) FROM corr_test ORDER BY ALL +-- +ok +== +SELECT (SELECT list_transform(l, elem -> elem + n)) FROM corr_test ORDER BY ALL +-- +ok +== +SELECT (SELECT (SELECT (SELECT list_transform(l, elem -> elem + 1)))) FROM corr_test ORDER BY ALL +-- +ok +== +SELECT list_transform([1, 2, 3], x -> x + #1) FROM range(10) +-- +ok +== +create table test(a int, b int); +-- +ok +== +insert into test values (1, 2), (1, 3), (1, 4), (2, 2), (2, 3), (2, 4), (3, 2), (3, 3), (3, 4); +-- +ok +== +select list_transform(bb, x->[x,b]), bb, b +from (select list(b) over wind as bb, first(b) over wind as b + from test window wind as + (order by a asc, b asc rows between 4 preceding and current row) + qualify row_number() over wind >4); +-- +ok +== +SELECT list_transform([[2, 3], [4]], x -> list_transform([42], y -> y + 1)) +-- +ok +== +SELECT list_transform([[2, 3], [4]], x -> list_transform(x, y -> y + 1)) +-- +ok +== +SELECT list_transform([[2, 3], [4]], x -> list_transform([1], y -> x || [y])) +-- +ok +== +SELECT list_transform([[2, 3], [4]], x -> list_transform(x, y -> x || [y])) +-- +ok +== diff --git a/parser/testdata/corpus/sql/function/list/lambdas/arrow/transform_with_index_deprecated.test b/parser/testdata/corpus/sql/function/list/lambdas/arrow/transform_with_index_deprecated.test new file mode 100644 index 0000000..0e2b2e5 --- /dev/null +++ b/parser/testdata/corpus/sql/function/list/lambdas/arrow/transform_with_index_deprecated.test @@ -0,0 +1,85 @@ +# source: test/sql/function/list/lambdas/arrow/transform_with_index_deprecated.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +SELECT list_transform([1, 2, 3], x -> list_transform([4, 5, 6], (y, y_i) -> x + y + y_i)); +-- +ok +== +SELECT list_transform(['abc'], (x, i) -> x[i + 1]); +-- +ok +== +SELECT list_filter([1, 2, 1], (x, y) -> x >= y); +-- +ok +== +SELECT list_transform([1, 2, 3], x -> list_transform([4, 5, 6], y -> list_transform([7, 8, 9], (z, i) -> x + y + z + i))); +-- +ok +== +SELECT list_transform([10, 20, 30], (x, i) -> x + i); +-- +ok +== +SELECT list_transform([1, 2, 3, 4, 5, 6], (x, i) -> x * i); +-- +ok +== +SELECT list_transform([6, 5, 4, 3, 2, 1], (x, i) -> x * i); +-- +ok +== +SELECT list_transform([1, NULL, 3, 4, 5, 6], (x, i) -> x + i); +-- +ok +== +SELECT list_transform(NULL, (x, i) -> x + i); +-- +ok +== +SELECT list_transform(['1', '2', '3', '4'], (x, i) -> (x || ' + ' || CAST(i AS string))); +-- +ok +== +SELECT list_transform([1,2,3,4,5], (x, i) -> (x * 10 / i)); +-- +ok +== +SELECT list_transform(a, (x, i) -> x + i) FROM tbl; +-- +ok +== +SELECT list_transform(a, (x, i) -> x + i + list_any_value(a)) FROM tbl; +-- +ok +== +CREATE TABLE tbl(a int[], b int, c int); +-- +ok +== +INSERT INTO tbl VALUES ([5,4,3], 5, 10), ([1,2,3], 7, 14), (NULL, 9, 18), ([10,NULL,12], 11, 22); +-- +ok +== +SELECT list_transform(a, (x, i) -> (c / b ) * (x + i)) FROM tbl; +-- +ok +== +SELECT list_transform([1, 2, 3], (x, x_i) -> list_transform([4, 5, 6], y -> x + y + x_i)); +-- +ok +== +SELECT list_transform([1, 2, 3], (x, x_i) -> list_transform([4, 5, 6], (y, y_i) -> x + y + x_i + y_i)); +-- +ok +== +SELECT list_transform([1, 2, 3], (x, i) -> list_transform([4, 5, 6], y -> list_transform([7, 8, 9], z -> x + y + z + i))); +-- +ok +== +SELECT list_transform([1, 2, 3], x -> list_transform([4, 5, 6], (y, i) -> list_transform([7, 8, 9], z -> x + y + z + i))); +-- +ok +== diff --git a/parser/testdata/corpus/sql/function/list/lambdas/arrow/warn_deprecated_arrow.test b/parser/testdata/corpus/sql/function/list/lambdas/arrow/warn_deprecated_arrow.test new file mode 100644 index 0000000..f98074f --- /dev/null +++ b/parser/testdata/corpus/sql/function/list/lambdas/arrow/warn_deprecated_arrow.test @@ -0,0 +1,25 @@ +# source: test/sql/function/list/lambdas/arrow/warn_deprecated_arrow.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +SELECT log_level, message[0:37] FROM duckdb_logs +-- +ok +== +RESET lambda_syntax; +-- +ok +== +SELECT list_reduce([1, 2, 3], lambda x, y: x + y); +-- +ok +== +SELECT [split('01:08:22', ':'), x -> CAST (x AS INTEGER)]; +-- +ok +== +SELECT (SELECT (JSON '{ "key" : "value" }')->k AS v FROM (SELECT 'key' AS k) keys); +-- +ok +== diff --git a/parser/testdata/corpus/sql/function/list/lambdas/expression_iterator_cases.test b/parser/testdata/corpus/sql/function/list/lambdas/expression_iterator_cases.test new file mode 100644 index 0000000..da427d5 --- /dev/null +++ b/parser/testdata/corpus/sql/function/list/lambdas/expression_iterator_cases.test @@ -0,0 +1,91 @@ +# source: test/sql/function/list/lambdas/expression_iterator_cases.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +SELECT list_transform([10], lambda x: sum(1) + x) +-- +ok +== +SELECT list_filter([10], lambda x: sum(1) > 0) +-- +ok +== +SELECT list_transform([NULL, DATE '1992-09-20', DATE '2021-09-20'], lambda elem: extract('year' FROM elem) BETWEEN 2000 AND 2022) +-- +ok +== +SELECT list_filter([NULL, DATE '1992-09-20', DATE '2021-09-20'], lambda elem: extract('year' FROM elem) BETWEEN 2000 AND 2022) +-- +ok +== +SELECT list_transform(['hello', 'duck', 'sunshine'], lambda str: CASE WHEN str LIKE '%e%' THEN 'e' ELSE 'other' END) +-- +ok +== +SELECT list_filter(['hello', 'duck', 'sunshine'], lambda str: (CASE WHEN str LIKE '%e%' THEN 'e' ELSE 'other' END) LIKE 'e') +-- +ok +== +SELECT list_transform([2.0::DOUBLE], lambda x: x::INTEGER) +-- +ok +== +SELECT list_filter([2], lambda x: x::DOUBLE == 2) +-- +ok +== +SELECT list_transform([2.4, NULL, -4.7], lambda x: x != 10.4) +-- +ok +== +SELECT list_filter([2.4, NULL, -4.7], lambda x: x != -4.7) +-- +ok +== +SELECT list_transform([True, False, NULL], lambda x: x AND true) +-- +ok +== +SELECT list_filter([True, False, NULL], lambda x: x AND true) +-- +ok +== +SELECT list_transform([TIMESTAMP '1992-03-22', TIMESTAMP '209-03-22', TIMESTAMP '1700-03-22'], lambda x: century(x)) +-- +ok +== +SELECT list_filter([TIMESTAMP '1992-03-22', TIMESTAMP '209-03-22', TIMESTAMP '1700-03-22'], lambda x: century(x) > 16) +-- +ok +== +SELECT list_transform([2], lambda x: x + x) +-- +ok +== +SELECT list_filter([2], lambda x: x + x = 4) +-- +ok +== +SELECT list_transform([2], lambda x: (SELECT 1 - x) * x) +-- +ok +== +SELECT list_filter([2], lambda x: (SELECT 1 - x) * x > 2) +-- +ok +== +SELECT list_transform([1], lambda x: x = UNNEST([1])); +-- +ok +== +SELECT list_filter([1], lambda x: x = UNNEST([1])); +-- +ok +== +SELECT list(list_transform(l, lambda e: e + 1)) OVER (PARTITION BY g ORDER BY o) +FROM my_window +ORDER BY ALL +-- +ok +== diff --git a/parser/testdata/corpus/sql/function/list/lambdas/filter.test b/parser/testdata/corpus/sql/function/list/lambdas/filter.test new file mode 100644 index 0000000..cefa605 --- /dev/null +++ b/parser/testdata/corpus/sql/function/list/lambdas/filter.test @@ -0,0 +1,127 @@ +# source: test/sql/function/list/lambdas/filter.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +SELECT [1] AS l, list_filter([1], lambda l: l > 1) +-- +ok +== +SELECT list_filter(NULL, lambda x: x > 1) +-- +ok +== +SELECT list_filter([True], lambda x: x) +-- +ok +== +SELECT list_filter(['duck', 'a', 'ö'], lambda duck: contains(concat(duck, 'DB'), 'duck')) +-- +ok +== +SELECT list_filter([1, 2, 3], lambda x: x % 2 = 0) +-- +ok +== +SELECT list_filter([], lambda x: x > 1) +-- +ok +== +SELECT list_filter([1, NULL, -2, NULL], lambda x: x % 2 != 0) +-- +ok +== +SELECT list_filter([5, -6, NULL, 7], lambda x: x > 0) +-- +ok +== +SELECT list_filter([5, NULL, 7, NULL], lambda x: x IS NOT NULL) +-- +ok +== +SELECT list_filter(l, lambda x: x + 1 <= 2) FROM lists +-- +ok +== +SELECT list_filter(l, lambda x: x <= n) FROM lists +-- +ok +== +SELECT list_filter(l, lambda x: x IS NOT NULL) FROM lists +-- +ok +== +SELECT list_filter(['x', 'abc', 'z'], lambda x: contains(x || '0', 'a')) +-- +ok +== +SELECT list_transform([[1, 3], [2, 3, 1], [2, 4, 2]], lambda x: list_filter(x, lambda y: y <= 2)) +-- +ok +== +SELECT list_concat(list_filter([42, -42, 8, -5, 2], lambda elem: elem > 0)::varchar[], + list_filter(['enjoy', 'life', 'to', 'the', 'fullest'], lambda str: str ILIKE '%e%')) +-- +ok +== +SELECT array_filter([1, NULL], lambda arr_elem: arr_elem < 4) +-- +ok +== +SELECT list_filter(l, lambda x: x > 0) FROM empty_lists +-- +ok +== +SELECT g, list_count(list_filter(l, lambda x: x % 2 = 0)) FROM large_lists ORDER BY g +-- +ok +== +SELECT n FROM corr_test WHERE list_count(list_filter(l, lambda elem: length(elem) >= n)) >= n +-- +ok +== +SELECT ct.n FROM corr_test ct +WHERE list_count(ct.l) < ( + SELECT list_count(list_filter(list_concat(list(c.n)::varchar[], ct.l), lambda a: length(a) >= 1)) + FROM corr_test c GROUP BY c.g +) +ORDER BY ct.n +-- +ok +== +SELECT (SELECT list_filter(l, lambda elem: length(elem) >= 1)) FROM corr_test ORDER BY ALL +-- +ok +== +SELECT (SELECT list_filter(l, lambda elem: length(elem) >= n)) FROM corr_test ORDER BY ALL +-- +ok +== +SELECT (SELECT (SELECT (SELECT list_filter(l, lambda elem: length(elem) >= 1)))) FROM corr_test ORDER BY ALL +-- +ok +== +SELECT list_filter([1, 2, 3, 4, 5, 6, 7, 8, 9], lambda x: x > #1) FROM range(10) +-- +ok +== +CREATE TABLE lambdas AS SELECT [5, 6] AS col1, [4, 8] AS col2; +-- +ok +== +SELECT list_apply(col1, lambda x: list_filter(col2, lambda y: y)) FROM lambdas; +-- +ok +== +SELECT list_apply([5,6], lambda x: list_filter([4,8], lambda y: y)); +-- +ok +== +SELECT list_apply([[5,6]], lambda x: list_filter(x, lambda y: y)); +-- +ok +== +SELECT list_transform([['abc']], lambda x: list_filter(x, lambda y: y)); +-- +ok +== diff --git a/parser/testdata/corpus/sql/function/list/lambdas/incorrect.test b/parser/testdata/corpus/sql/function/list/lambdas/incorrect.test new file mode 100644 index 0000000..6586d22 --- /dev/null +++ b/parser/testdata/corpus/sql/function/list/lambdas/incorrect.test @@ -0,0 +1,210 @@ +# source: test/sql/function/list/lambdas/incorrect.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +CREATE TABLE incorrect_test (i INTEGER); +-- +ok +== +SELECT {func_name}(); +-- +error: Parser Error: syntax error at or near "}" +== +SELECT {func_name}([]); +-- +error: Parser Error: syntax error at or near "}" +== +SELECT {func_name}(1, 2, 3); +-- +error: Parser Error: syntax error at or near "}" +== +SELECT {func_name}(NULL, NULL); +-- +error: Parser Error: syntax error at or near "}" +== +SELECT {func_name}(NULL, x); +-- +error: Parser Error: syntax error at or near "}" +== +SELECT {func_name}([1, 2], (SELECT 1) -> x + 1); +-- +error: Parser Error: syntax error at or near "}" +== +SELECT {func_name}(NULL, i) FROM incorrect_test; +-- +error: Parser Error: syntax error at or near "}" +== +SELECT {func_name}(NULL, x -> y); +-- +error: Parser Error: syntax error at or near "}" +== +SELECT {func_name}([1]); +-- +error: Parser Error: syntax error at or near "}" +== +SELECT {func_name}([1], NULL); +-- +error: Parser Error: syntax error at or near "}" +== +SELECT {func_name}([[1]], x -> x + 1); +-- +error: Parser Error: syntax error at or near "}" +== +SELECT {func_name}(1, 1); +-- +error: Parser Error: syntax error at or near "}" +== +SELECT {func_name}(1, x -> x + 1); +-- +error: Parser Error: syntax error at or near "}" +== +SELECT {func_name}([1], x -> x, 3); +-- +error: Parser Error: syntax error at or near "}" +== +SELECT {func_name}([True], x -> x, x -> x); +-- +error: Parser Error: syntax error at or near "}" +== +SELECT list_reduce([1], x -> x, 3); +-- +ok +== +SELECT list_reduce([True], x -> x, x -> x); +-- +ok +== +select list_apply(i, x -> x * 3 + 2 / zz) from (values (list_value(1, 2, 3))) tbl(i); +-- +ok +== +select x -> x + 1 from (values (list_value(1, 2, 3))) tbl(i); +-- +ok +== +select list_apply(i, y + 1 -> x + 1) from (values (list_value(1, 2, 3))) tbl(i); +-- +ok +== +SELECT list_apply(i, a.x -> x + 1) FROM (VALUES (list_value(1, 2, 3))) tbl(i); +-- +ok +== +select list_apply(i, x -> x + 1 AND y + 1) from (values (list_value(1, 2, 3))) tbl(i); +-- +ok +== +SELECT list_transform([1, 2], (x, y, z) -> x + y + z); +-- +ok +== +SELECT list_filter([1, 2], (x, y, z) -> x >= y AND y >= z); +-- +ok +== +SELECT cos(x -> x + 1); +-- +ok +== +SELECT cos([1], x -> x + 1); +-- +ok +== +CREATE TABLE lambda_check (i BIGINT[], + CHECK (list_filter(i, x -> x % 2 = 0) == [])); +-- +ok +== +CREATE TABLE lambda_check (i BIGINT[], + CHECK (list_transform(i, x -> x % 2) == [])); +-- +ok +== +CREATE TABLE lambda_check (i BIGINT[], + CHECK ([x + 1 FOR x IN i IF x > 0] == [])); +-- +ok +== +CREATE TABLE lambda_check ( + i BIGINT[], + j BIGINT[], + CHECK ((list_apply(i, x -> list_count(list_filter(j, y -> y%2=0)) + x)) == [])); +-- +ok +== +CREATE TABLE unit2( + price INTEGER[], + total_price INTEGER GENERATED ALWAYS AS (list_transform(price, x -> x + 1)) VIRTUAL +); +-- +ok +== +CREATE TABLE tbl AS SELECT {'a': 10} AS s; +-- +ok +== +SELECT list_transform(UNNEST(s), x -> UNNEST(x)) FROM tbl; +-- +ok +== +CREATE TABLE nested_list(i INT[][], other INT[]); +-- +ok +== +INSERT INTO nested_list VALUES ([[1, 2]], [3, 4]); +-- +ok +== +SELECT list_transform(i, x -> UNNEST(x)) FROM nested_list; +-- +ok +== +SELECT list_transform(i, x -> UNNEST(other)) FROM nested_list; +-- +ok +== +CREATE TABLE map_tbl(m MAP(INTEGER, INTEGER)); +-- +ok +== +SELECT [UNNEST([x.key FOR y IN range(x.value)]) FOR x IN map_entries(m)] FROM map_tbl; +-- +ok +== +SELECT list_transform(map_entries(m), x -> UNNEST(range(x.value))) FROM map_tbl; +-- +ok +== +CREATE TABLE dummy_tbl (y INT); +-- +ok +== +SELECT list_transform([1], lambda x: lambda y: x + y) FROM dummy_tbl; +-- +ok +== +SELECT list_transform([1], lambda x: 1 : hello) FROM dummy_tbl; +-- +error: Parser Error: syntax error at or near ":" +== +CREATE OR REPLACE function transpose(lst) AS ( + SELECT list_transform(range(1, 1 + length(lst[1])), + j -> list_transform(range(1, length(lst) + 1), + lambda i: lst[i][j] + ) + ) +); +-- +ok +== +CREATE OR REPLACE FUNCTION transpose(lst) AS ( + SELECT list_transform(range(1, 1 + length(lst[1])), + j -> list_transform(range(1, length(lst) + 1), + i -> lst[i][j] + ) + ) +); +-- +ok +== diff --git a/parser/testdata/corpus/sql/function/list/lambdas/lambda_scope.test b/parser/testdata/corpus/sql/function/list/lambdas/lambda_scope.test new file mode 100644 index 0000000..b530e48 --- /dev/null +++ b/parser/testdata/corpus/sql/function/list/lambdas/lambda_scope.test @@ -0,0 +1,61 @@ +# source: test/sql/function/list/lambdas/lambda_scope.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +SELECT list_apply(['hello'], lambda x: x) FROM t1; +-- +ok +== +SELECT list_transform([[1], [2], [3]], lambda x: x[1]) FROM t2; +-- +ok +== +SELECT l, list_transform(l, lambda l: l + 1) FROM l_test; +-- +ok +== +SELECT l, list_filter(l, lambda l: l > 1) FROM l_filter_test; +-- +ok +== +SELECT list_apply(i, lambda a.x: a.x + 1) FROM (VALUES (list_value(1, 2, 3))) tbl(i); +-- +error: Parser Error: syntax error at or near "." +== +SELECT list_transform(qualified_tbl.x, lambda x: (qualified_tbl.x)[1] + 1 + x) FROM qualified_tbl; +-- +ok +== +SELECT list_transform(qualified_tbl.x, lambda qualified_tbl.x: qualified_tbl.x + 1) FROM qualified_tbl; +-- +error: Parser Error: syntax error at or near "." +== +SELECT list_transform([1, 2], lambda x: list_transform([3, 4], lambda x: x)); +-- +ok +== +SELECT list_has_all(list_transform(['a'], lambda variable_has_all: variable_has_all), ['b']) AS list_transform_result; +-- +ok +== +SELECT list_has_any(['b'], list_transform(['a'], lambda variable_has_any: variable_has_any)) AS list_transform_result; +-- +ok +== +SELECT x, list_transform([1], lambda x: x) FROM tbl_qualified; +-- +ok +== +SELECT list_transform([1,2,3], lambda sqrt(xxx.z): xxx.z + 1) AS l ; +-- +error: Parser Error: syntax error at or near "(" +== +SELECT list_transform([1, 2, 3], lambda "x.y" : "x.y" + x.y) AS l FROM (VALUES (42), (84)) x(y); +-- +ok +== +SELECT list_reduce([1, 2, 3, 4], lambda x *++++++++* y: x - y) AS l; +-- +error: Parser Error: syntax error at or near "*++++++++*" +== diff --git a/parser/testdata/corpus/sql/function/list/lambdas/lambdas_and_functions.test b/parser/testdata/corpus/sql/function/list/lambdas/lambdas_and_functions.test new file mode 100644 index 0000000..338fe3a --- /dev/null +++ b/parser/testdata/corpus/sql/function/list/lambdas/lambdas_and_functions.test @@ -0,0 +1,23 @@ +# source: test/sql/function/list/lambdas/lambdas_and_functions.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +CREATE OR REPLACE function demo(n, z) AS TABLE ( + SELECT list_transform(range(0, n), lambda x: z) AS row +); +-- +ok +== +CREATE OR REPLACE function demo(n, z) AS TABLE ( + SELECT list_transform(range(0, n), lambda x: 0 + z) AS row +); +-- +ok +== +CREATE OR REPLACE function demo(n, z) AS TABLE ( + SELECT list_transform(range(0, n), lambda x: (z -> 'a')) AS row +); +-- +ok +== diff --git a/parser/testdata/corpus/sql/function/list/lambdas/lambdas_and_group_by.test b/parser/testdata/corpus/sql/function/list/lambdas/lambdas_and_group_by.test new file mode 100644 index 0000000..bd7b51b --- /dev/null +++ b/parser/testdata/corpus/sql/function/list/lambdas/lambdas_and_group_by.test @@ -0,0 +1,29 @@ +# source: test/sql/function/list/lambdas/lambdas_and_group_by.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +SELECT tag_product, list_aggr(list_transform( + string_split(tag_product, ' '), lambda word: lower(word)), + 'string_agg', ',') AS tag_material, +FROM tbl GROUP BY tag_product +ORDER BY ALL; +-- +ok +== +SELECT 1, list_transform([5, 4, 3], lambda x: x + 1) AS lst GROUP BY 1; +-- +ok +== +FROM uniform_purchase_forecast SELECT list(forecast).list_transform(lambda x: x + 10); +-- +ok +== +FROM (SELECT 1) GROUP BY ALL HAVING list_filter(NULL, lambda x: x); +-- +ok +== +SELECT x FROM (VALUES (42)) t(x) GROUP BY x HAVING list_filter(NULL, lambda lambda_param: lambda_param = 1); +-- +ok +== diff --git a/parser/testdata/corpus/sql/function/list/lambdas/lambdas_and_macros.test b/parser/testdata/corpus/sql/function/list/lambdas/lambdas_and_macros.test new file mode 100644 index 0000000..91b9993 --- /dev/null +++ b/parser/testdata/corpus/sql/function/list/lambdas/lambdas_and_macros.test @@ -0,0 +1,41 @@ +# source: test/sql/function/list/lambdas/lambdas_and_macros.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +CREATE TABLE test AS SELECT range i FROM range(3); +-- +ok +== +CREATE MACRO my_macro(i) AS (SELECT i IN (SELECT i FROM test)); +-- +ok +== +CREATE MACRO macro_with_lambda(list, num) AS (list_transform(list, lambda x: x + num)) +-- +ok +== +SELECT list_filter([[1, 2], NULL, [3], [4, NULL]], lambda f: list_count(macro_with_lambda(f, 2)) > 1) +-- +ok +== +CREATE MACRO some_macro(x, y, z) AS (SELECT list_transform(x, lambda a: x + y + z)) +-- +ok +== +CREATE MACRO reduce_macro(list, num) AS (list_reduce(list, lambda x, y: x + y + num)) +-- +ok +== +CREATE MACRO other_reduce_macro(list, num, bla) AS (SELECT list_reduce(list, lambda x, y: list + x + y + num + bla)) +-- +ok +== +CREATE MACRO scoping_macro(x, y, z) AS (SELECT list_transform(x, lambda x: x + y + z)); +-- +ok +== +CREATE OR REPLACE MACRO foo(bar) AS (SELECT apply([bar], lambda x: 0)); +-- +ok +== diff --git a/parser/testdata/corpus/sql/function/list/lambdas/list_comprehension.test b/parser/testdata/corpus/sql/function/list/lambdas/list_comprehension.test new file mode 100644 index 0000000..61094a3 --- /dev/null +++ b/parser/testdata/corpus/sql/function/list/lambdas/list_comprehension.test @@ -0,0 +1,59 @@ +# source: test/sql/function/list/lambdas/list_comprehension.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +SELECT list_transform(list_filter([0, 1, 2, 3, 4, 5], lambda x: x % 2 = 0), lambda y: y * y) +-- +ok +== +SELECT list_filter(list_filter([2, 4, 3, 1, 20, 10, 3, 30], lambda x: x % 2 == 0), lambda y: y % 5 == 0) +-- +ok +== +SELECT list_filter(['apple', 'banana', 'cherry', 'kiwi', 'mango'], lambda fruit: contains(fruit, 'a')) +-- +ok +== +SELECT list_transform([[1, NULL, 2], [3, NULL]], lambda a: list_filter(a, lambda x: x IS NOT NULL)) +-- +ok +== +SELECT [len(x) for x in words] FROM word_tbl +-- +ok +== +WITH BASE AS (SELECT [4, 5, 6] AS l) +SELECT [x for x, i in l if i != 2] AS filtered FROM base; +-- +ok +== +SELECT [x + i for x, i in [10, 9, 8, 7, 6]] +-- +ok +== +WITH BASE AS (SELECT [4, 5, 6] AS l) +SELECT [x + 5 for x in l] AS filtered FROM base; +-- +ok +== +SELECT [a for a, b, c in [1, 2, 3]]; +-- +ok +== +SELECT [a for a[1], b[2] in [1, 2, 3, 4]]; +-- +error: Parser Error: syntax error at or near "[" +== +SELECT [i FOR x, i IN [4, 5, 6] IF x > 5]; +-- +ok +== +SELECT [x FOR x IN [4, 5, 6] IF x > 5]; +-- +ok +== +SELECT [i FOR x, i IN [4, 5, 6] IF i % 2 = 0]; +-- +ok +== diff --git a/parser/testdata/corpus/sql/function/list/lambdas/reduce.test b/parser/testdata/corpus/sql/function/list/lambdas/reduce.test new file mode 100644 index 0000000..939825d --- /dev/null +++ b/parser/testdata/corpus/sql/function/list/lambdas/reduce.test @@ -0,0 +1,205 @@ +# source: test/sql/function/list/lambdas/reduce.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +SELECT list_reduce([1, 2, 3], lambda x, y: x * y); +-- +ok +== +SELECT list_reduce([100, 10, 1], lambda x, y, i: x - y - i); +-- +ok +== +SELECT list_reduce([1, 2, 3], lambda x, y: y - x); +-- +ok +== +SELECT list_reduce([1, 2, 3], lambda x, y: x - y); +-- +ok +== +SELECT list_reduce([1, 2, 3], lambda x, y, i: x + y + i); +-- +ok +== +SELECT list_reduce([NULL], lambda x, y, i: x + y + i); +-- +ok +== +SELECT list_reduce(NULL, lambda x, y, i: x + y + i); +-- +ok +== +SELECT list_reduce(['Once', 'upon', 'a', 'time'], lambda x, y: x || ' ' || y); +-- +ok +== +SELECT list_reduce(['a', 'b', 'c', 'd'], lambda x, y, i: x || ' - ' || CAST(i AS VARCHAR) || ' - ' || y); +-- +ok +== +SELECT list_reduce([], lambda x, y, i: x + y + i); +-- +ok +== +SELECT list_reduce([1, 2, 3], lambda x, y: (x * y)::VARCHAR || 'please work'); +-- +ok +== +SELECT list_reduce([1, 2], lambda x: x); +-- +ok +== +SELECT list_reduce(a, lambda x, y: x + y) FROM t1; +-- +ok +== +SELECT list_reduce(a, lambda x, y, i: x + y + i) FROM t1; +-- +ok +== +SELECT list_reduce(a, lambda x, y: x || ' ' || y) FROM t1; +-- +ok +== +SELECT list_reduce(v, lambda x, y: y[i]) FROM right_only; +-- +ok +== +SELECT list_reduce([1, 2, 3], lambda x, y: list_reduce([4, 5, 6], lambda a, b: x + y + a + b)); +-- +ok +== +SELECT list_reduce([1, 2, 3], lambda x, y: list_reduce([], lambda a, b: x + y + a + b)); +-- +ok +== +SELECT list_reduce([1, 2, 3], lambda x, y, x_i: list_reduce([4, 5, 6], lambda a, b, a_i: x + y + a + b + x_i + a_i)); +-- +ok +== +SELECT list_reduce([1, 2, 3], lambda x, y, x_i: list_reduce([], lambda a, b, a_i: x + y + a + b + x_i + a_i)); +-- +ok +== +SELECT list_reduce([[10, 20], [30, 40], [50, 60]], lambda x, y: list_pack( + list_reduce(x, lambda l, m: l + m) + + list_reduce(y, lambda n, o: n + o))); +-- +ok +== +SELECT list_reduce([[1, 2, 3], [4, 5, 6], [7, 8, 9]], lambda x, y: list_pack( + list_reduce(x, lambda l, m: l + m) + + list_reduce(y, lambda n, o: n + o))); +-- +ok +== +SELECT list_reduce([[10, 20], [30, 40], NULL, [NULL, 60], NULL], lambda x, y: list_pack( + list_reduce(x, lambda l, m: l + m) + + list_reduce(y, lambda n, o: n + o))); +-- +ok +== +SELECT list_reduce(['a', 'b', 'c', 'd'], lambda x, y: list_reduce(['1', '2', '3', '4'], lambda a, b: x || y || a || b)); +-- +ok +== +SELECT list_reduce([['a', 'b'], ['c', 'd'], ['e', 'f']], lambda x, y: list_pack(list_reduce(x, lambda a, b: a || b) || list_reduce(y, lambda c, d: c || d))); +-- +ok +== +SELECT list_reduce(n, lambda x, y: list_reduce(l, lambda a, b: x + y + a + b)) FROM nested; +-- +ok +== +SELECT list_reduce(n, lambda x, y, x_i: list_reduce(l, lambda a, b, a_i: x + y + a + b + x_i + a_i)) FROM nested; +-- +ok +== +SELECT list_reduce(n, lambda x, y, x_i: list_reduce(l, lambda a, b, a_i: x + y + x_i < a + b + a_i)) FROM nested; +-- +ok +== +SELECT list_reduce(n, lambda x, y: list_pack(list_reduce(x, lambda l, m: l + m) + list_reduce(y, lambda j, k: j + k))) from nested; +-- +ok +== +SELECT list_reduce(n, lambda x, y: list_reduce(l, lambda a, b: x || y || a || b)) FROM nested; +-- +ok +== +SELECT + list_reduce([1, 2, 3], lambda x, y: + list_reduce([4, 5, 6], lambda a, b: + list_reduce([7, 8, 9], lambda c, d: x + y + a + b + c + d))); +-- +ok +== +SELECT + list_reduce([1, 2, 3], lambda x, y, x_i: + list_reduce([4, 5, 6], lambda a, b, a_i: + list_reduce([7, 8, 9], lambda c, d, c_i: x + y + a + b + c + d + x_i + a_i + c_i))); +-- +ok +== +SELECT + list_reduce([[[10, 20], [100, 200]], [[30, 40], [300, 400]], [[50, 60], [500, 600]]], lambda x, y: list_pack( + list_reduce(x, lambda l, m: list_pack( + list_reduce(l, lambda a, b: a + b) + + list_reduce(m, lambda c, d: c + d))) + + list_reduce(y, lambda n, o: list_pack( + list_reduce(n, lambda a, b: a + b) + + list_reduce(o, lambda c, d: c + d))))); +-- +ok +== +SELECT + list_reduce(n, lambda x, y: + list_reduce(l, lambda a, b: + list_reduce(m, lambda c, d: x + y + a + b + c + d))) +FROM nested; +-- +ok +== +SELECT + list_reduce(n, lambda x, y: + list_pack(list_reduce(x, lambda l, m: + list_pack(list_reduce(l, lambda a, b: a + b) + + list_reduce(m, lambda c, d: c + d))) + + list_reduce(y, lambda e, f: list_pack( + list_reduce(e, lambda a, b: a + b) + + list_reduce(f, lambda c, d: c + d))))) +FROM nested; +-- +ok +== +SELECT a FROM where_clause WHERE list_reduce(a, lambda x, y: x - y) > 0; +-- +ok +== +SELECT list_reduce(s, lambda a, b: row(a.v || b.v, a.i + b.i)) FROM t_struct; +-- +ok +== +SELECT list_reduce(s, lambda curr, next: struct_pack(a:=curr.a + (next.b - curr.b), b:=next.b)) +FROM df +-- +ok +== +SELECT +list_reduce( + [struct_pack(a := 0, b := 0), struct_pack(a := 0, b := 1), struct_pack(a := 0, b := 2)], + lambda curr, next: struct_pack(a := curr.a + (next.b - curr.b), b := next.b) +) +-- +ok +== +SELECT list_reduce([1, 2], lambda x, y: error('test error')); +-- +ok +== +SELECT list_reduce(['1', 'a'], lambda x, y: (x::INT + y::INT)::VARCHAR); +-- +ok +== diff --git a/parser/testdata/corpus/sql/function/list/lambdas/reduce_initial.test b/parser/testdata/corpus/sql/function/list/lambdas/reduce_initial.test new file mode 100644 index 0000000..5f06f38 --- /dev/null +++ b/parser/testdata/corpus/sql/function/list/lambdas/reduce_initial.test @@ -0,0 +1,294 @@ +# source: test/sql/function/list/lambdas/reduce_initial.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +SELECT list_reduce([1, 2, 3], lambda x, y: x + y, 100); +-- +ok +== +SELECT array_reduce([1, 2, 3], lambda x, y: x + y, 100); +-- +ok +== +SELECT reduce([1, 2, 3], lambda x, y: x + y, 100); +-- +ok +== +SELECT list_reduce([1, 2, 3], lambda x, y: x * y, -1); +-- +ok +== +SELECT list_reduce([100, 10, 1], lambda x, y, i: x - y - i, 1000); +-- +ok +== +SELECT list_reduce([1, 2, 3], lambda x, y: y - x, -1); +-- +ok +== +SELECT list_reduce([1, 2, 3], lambda x, y: x - y, 10); +-- +ok +== +SELECT list_reduce([1, 2, 3], lambda x, y, i: x + y + i, -1); +-- +ok +== +SELECT list_reduce([1, 2, 3], lambda x, y: x + y, NULL); +-- +ok +== +SELECT list_reduce(['1', '2', '3'], lambda acc, x: acc + x::INTEGER, 0); +-- +ok +== +SELECT list_reduce([NULL], lambda x, y, i: x + y + i, 100); +-- +ok +== +SELECT list_reduce(NULL, lambda x, y, i: x + y + i, 100); +-- +ok +== +SELECT list_reduce(['Once', 'upon', 'a', 'time'], lambda x, y: x || ' ' || y, '-->'); +-- +ok +== +SELECT list_reduce([], lambda x, y: x + y, 100); +-- +ok +== +SELECT list_reduce([1], lambda acc, x: acc || [x], []); +-- +ok +== +SELECT list_reduce(['a', 'b', 'c'], lambda x, y: x || y, NULL); +-- +ok +== +SELECT list_reduce([1, 2, 3], lambda x, y: (x * y), 'i dare you to cast me'); +-- +ok +== +SELECT list_reduce([0], lambda acc, x: if(len(acc::VARCHAR) - 1, true, false), false); +-- +ok +== +SELECT list_reduce([1, 2], lambda x: x, 100); +-- +ok +== +SELECT list_reduce(l, lambda x, y: x + y, initial) FROM t1; +-- +ok +== +SELECT list_reduce(l, lambda x, y, i: x + y + i, initial) FROM t1; +-- +ok +== +SELECT list_reduce(l, lambda x, y: x + y) FROM t1; +-- +ok +== +SELECT list_reduce(l, lambda x, y: x || ' ' || y, initial) FROM t1; +-- +ok +== +SELECT list_reduce(l, lambda x, y: x || ' ' || y) FROM t1; +-- +ok +== +SELECT list_reduce([1, 2, 3], lambda x, y: list_reduce([4, 5, 6], lambda a, b: x + y + a + b, 100), 1000); +-- +ok +== +SELECT list_reduce([1, 2, 3], lambda x, y: list_reduce([], lambda a, b: x + y + a + b), 1000); +-- +ok +== +SELECT list_reduce([1, 2, 3], lambda x, y, x_i: list_reduce([4, 5, 6], lambda a, b, a_i: x + y + a + b + x_i + a_i, 100), 1000); +-- +ok +== +SELECT list_reduce([1, 2, 3], lambda x, y, x_i: list_reduce([], lambda a, b, a_i: x + y + a + b + x_i + a_i), 1000); +-- +ok +== +SELECT list_reduce([[10, 20], [30, 40], [50, 60]], lambda x, y: list_pack(list_reduce(x, lambda l, m: l + m) + list_reduce(y, lambda n, o: n + o)), [100, 200]); +-- +ok +== +SELECT list_reduce([[1,2,3], [4,5,6], [7,8,9]], lambda x, y: list_pack(list_reduce(x, lambda l, m: l + m) + list_reduce(y, lambda n, o: n + o)), [100]); +-- +ok +== +SELECT list_reduce([[10, 20], [30, 40], NULL, [NULL, 60], NULL], lambda x, y: list_pack(list_reduce(x, lambda l, m: l + m) + list_reduce(y, lambda n, o: n + o)), [100]); +-- +ok +== +SELECT list_reduce(['a', 'b'], lambda x, y: list_reduce(['1', '2'], lambda a, b: x || y || a || b, 'B'), 'A'); +-- +ok +== +SELECT list_reduce([['a', 'b'], ['c', 'd'], ['e', 'f']], lambda x, y: list_pack(list_reduce(x, lambda a, b: a || b) || list_reduce(y, lambda c, d: c || d)), ['->']); +-- +ok +== +SELECT list_reduce(n, lambda x, y: list_reduce(l, lambda a, b: x + y + a + b), initial) FROM nested; +-- +ok +== +SELECT list_reduce(n, lambda x, y, x_i: list_reduce(l, lambda a, b, a_i: x + y + a + b + x_i + a_i), initial) FROM nested; +-- +ok +== +SELECT list_reduce(n, lambda x, y, x_i: list_reduce(l, lambda a, b, a_i: x + y + x_i < a + b + a_i), initial) FROM nested; +-- +ok +== +SELECT list_reduce(n, lambda x, y: list_pack(list_reduce(x, lambda l, m: l + m) + list_reduce(y, lambda j, k: j + k)), initial) from nested; +-- +ok +== +SELECT list_reduce(n, lambda x, y: list_reduce(l, lambda a, b: x || y || a || b, initialL), initialN) FROM nested; +-- +ok +== +SELECT list_reduce([1, 2, 3], lambda x, y: list_reduce([4, 5, 6], lambda a, b: list_reduce([7, 8, 9], lambda c, d: x + y + a + b + c + d, 1000), 100), 10); +-- +ok +== +SELECT list_reduce([1, 2, 3], lambda x, y, x_i: list_reduce([4, 5, 6], lambda a, b, a_i: list_reduce([7, 8, 9], lambda c, d, c_i: x + y + a + b + c + d + x_i + a_i + c_i, 1000), 100), 10); +-- +ok +== +SELECT list_reduce(n, lambda x, y: list_reduce(l, lambda a, b: list_reduce(m, lambda c, d: x + y + a + b + c + d, initial), initial), initial) FROM nested; +-- +ok +== +SELECT + list_reduce(n, lambda x, y: list_pack( + list_reduce(x, lambda l, m: list_pack( + list_reduce(l, lambda a, b: a + b) + + list_reduce(m, lambda c, d: c + d))) + + list_reduce(y, lambda e, f: list_pack( + list_reduce(e, lambda a, b: a + b) + + list_reduce(f, lambda c, d: c + d))))) +FROM nested; +-- +ok +== +SELECT list_reduce(s, lambda a, b: row(a.v || b.v, a.i + b.i), initial) FROM t_struct; +-- +ok +== +SELECT list_reduce(s, lambda curr, next: struct_pack(a:=curr.a + (next.b - curr.b), b:=next.b), initial) +FROM df +-- +ok +== +SELECT +list_reduce( + [struct_pack(a := 0, b := 0), struct_pack(a := 0, b := 1), struct_pack(a := 0, b := 2)], + lambda curr, next: struct_pack(a := curr.a + (next.b - curr.b), b := next.b), struct_pack(a := -2, b := -3) +) +-- +ok +== +SELECT a FROM where_clause WHERE list_reduce(a, lambda x, y: x - y, initial) > 0; +-- +ok +== +SELECT list_reduce([0], lambda x, y: x > 3, 3.1); +-- +ok +== +SELECT list_reduce([1, 2, 3], lambda x, y: x + y, 10.5); +-- +ok +== +SELECT list_reduce([1, 2, 3], lambda x, y: x * y, 2.5); +-- +ok +== +SELECT list_reduce([1, 2], lambda acc, x: acc || [x], []::INTEGER[]); +-- +ok +== +SELECT list_reduce([1, 2], lambda acc, x: struct_pack(a:=acc.a + x, b:=acc.b), struct_pack(a:=0, b:='s')); +-- +ok +== +SELECT list_reduce([2147483647, 1]::INTEGER[], lambda acc, x: acc + x, 0::BIGINT); +-- +ok +== +SELECT list_reduce([1, 2, 3], lambda acc, x: acc + x, 0.1::DECIMAL(18,6)); +-- +ok +== +SELECT list_reduce([1, 2, 3], lambda acc, x: acc + x::DECIMAL(18,6), 0.1::DECIMAL(18,6)); +-- +ok +== +SELECT list_reduce([0.1, 0.2, 0.3]::DECIMAL(18,6)[], lambda acc, x: acc + x, 1); +-- +ok +== +SELECT list_reduce([0.1, 0.2, 0.3]::DECIMAL(18,6)[], lambda acc, x: acc + x, 1::INTEGER); +-- +ok +== +SELECT list_reduce([1, 2, 3], lambda acc, x: acc + x, NULL::DOUBLE); +-- +ok +== +CREATE TABLE cast_test (l int[], initial float); +-- +ok +== +INSERT INTO cast_test VALUES ([1, 2, 3], 100.0), ([0], 3.1), ([3, 2, 1], 10.5); +-- +ok +== +SELECT list_reduce(l, lambda x, y: x > 3, initial) FROM cast_test; +-- +ok +== +SELECT list_reduce(l, lambda x, y: x + y, initial) FROM cast_test; +-- +ok +== +SELECT list_reduce(l, lambda x, y: x * y, initial) FROM cast_test; +-- +ok +== +SELECT list_reduce([1, 2, 3], lambda x, y: x + y, [1, 2]); +-- +ok +== +SELECT list_reduce([1], lambda acc, x: 'bad', 0); +-- +ok +== +SELECT list_reduce([BLOB 'hello'], lambda x, y: x, 'text'); +-- +ok +== +SELECT list_reduce([NULL, NULL]::INTEGER[], lambda x, y: x + y, 3.14); +-- +ok +== +SELECT list_reduce(['sad', 'happy']::mood[], lambda x, y: y::text, 'Mood:'); +-- +ok +== +SELECT list_reduce([[1, 2], [3, 4]], lambda x, y: array_append(x, list_aggregate(y, 'sum')), [0]); +-- +ok +== +SELECT list_reduce([5, 10, 15], lambda x, y: x * y, 1 + 1); +-- +ok +== diff --git a/parser/testdata/corpus/sql/function/list/lambdas/rhs_parameters.test b/parser/testdata/corpus/sql/function/list/lambdas/rhs_parameters.test new file mode 100644 index 0000000..396c52c --- /dev/null +++ b/parser/testdata/corpus/sql/function/list/lambdas/rhs_parameters.test @@ -0,0 +1,58 @@ +# source: test/sql/function/list/lambdas/rhs_parameters.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +SELECT list_apply([1,2], lambda x: list_apply([3,4], lambda y: {'x': x, 'y': y})) AS bug; +-- +ok +== +SELECT list_transform([1,2], lambda x: list_transform([3,4], lambda y: x + y)); +-- +ok +== +SELECT list_transform([1,2], lambda x: + list_transform([3,4], lambda y: + list_transform([5,6], lambda z: z + y + x))); +-- +ok +== +SELECT list_transform([1,2,3,4], lambda x: list_filter([4,5,1,2,3,3,3,5,1,4], lambda y: y != x)) +-- +ok +== +SELECT list_transform([[2, 4, 6]], lambda x: list_transform(x, lambda y: list_sum([y] || x))) +-- +ok +== +SELECT list_apply(range(5), lambda x: {x:x, w:list_filter(range(5), lambda y: abs(y-x) < 2)}); +-- +ok +== +SELECT list_apply(range(8), lambda x: list_aggr(list_apply(range(8), + lambda y: list_element('▁▂▃▄▅▆▇█', 1+abs(y-x))), 'string_agg', '')); +-- +ok +== +SELECT list_transform(v, lambda x: list_transform(v, lambda y: x || y)) FROM lists +-- +ok +== +SELECT list_transform(v, lambda x: list_transform(v, lambda y: list_transform(v, lambda z: x || y || z))) FROM lists +-- +ok +== +SELECT list_transform(v, lambda x: [list_transform([':-)'], lambda y: x || y || '-#lambdaLove')] +|| list_filter(list_transform(['B-)'], lambda k: [k] || [x]), lambda j: list_contains(j, 'a') or list_contains(j, 'duck'))) +FROM lists +-- +ok +== +CREATE TABLE no_overwrite AS SELECT [range, range + 1] l FROM range(3); +-- +ok +== +SELECT l, [[{'x+y': x + y, 'x': x, 'y': y, 'l': l} for y in [42, 43]] for x in l] FROM no_overwrite; +-- +ok +== diff --git a/parser/testdata/corpus/sql/function/list/lambdas/storage.test b/parser/testdata/corpus/sql/function/list/lambdas/storage.test new file mode 100644 index 0000000..b02ab3a --- /dev/null +++ b/parser/testdata/corpus/sql/function/list/lambdas/storage.test @@ -0,0 +1,22 @@ +# source: test/sql/function/list/lambdas/storage.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +CREATE MACRO my_transform(list) AS list_transform(list, lambda x: x * x) +-- +ok +== +CREATE MACRO my_filter(list) AS list_filter(list, lambda x: x > 42) +-- +ok +== +CREATE MACRO my_reduce(list) AS list_reduce(list, lambda x, y: x + y) +-- +ok +== +CREATE MACRO my_nested_lambdas(nested_list) AS list_filter(nested_list, lambda elem: list_reduce( + list_transform(elem, lambda x: x + 1), lambda x, y: x + y) > 42) +-- +ok +== diff --git a/parser/testdata/corpus/sql/function/list/lambdas/table_functions.test b/parser/testdata/corpus/sql/function/list/lambdas/table_functions.test new file mode 100644 index 0000000..b98c55b --- /dev/null +++ b/parser/testdata/corpus/sql/function/list/lambdas/table_functions.test @@ -0,0 +1,44 @@ +# source: test/sql/function/list/lambdas/table_functions.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +SELECT COUNT(*) FROM read_parquet('{TEST_DIR}/my_file_' || +list_aggr(list_transform(['C', 'B', 'A'], lambda s: lower(s)), 'string_agg', '') || '.parquet'); +-- +ok +== +SELECT COUNT(*) FROM read_parquet('{TEST_DIR}/my_file_' || +list_aggr(list_transform(list_sort(['a', 'b', 'c'], 'DESC'), lambda s: lower(s)), 'string_agg', '') || '.parquet'); +-- +ok +== +SELECT COUNT(*) FROM read_parquet('{TEST_DIR}/my_file_' || +list_aggr(list_transform(list_filter(['s', 'c', 'b', NULL, 'a'], lambda x: x IS NOT NULL AND x != 's'), +lambda s: lower(s)), 'string_agg', '') || '.parquet'); +-- +ok +== +SELECT COUNT(*) FROM read_parquet('{TEST_DIR}/my_file_' || +list_aggr(list_transform(list_filter( +list_filter(['s', 'c', 'b', NULL, 'a'], lambda y: y != 's'), lambda x: x IS NOT NULL), +lambda s: lower(s)), 'string_agg', '') || '.parquet'); +-- +ok +== +SELECT COUNT(*) FROM read_parquet('{TEST_DIR}/my_file_' || +list_aggr(list_reduce([['c', 'b', NULL, 'a']], lambda x, y: coalesce(x,y)), 'string_agg', '') || '.parquet'); +-- +ok +== +SELECT COUNT(*) FROM read_parquet('{TEST_DIR}/my_file_' || +list_aggr(list_transform(['a'], lambda x: list_transform(['a', 'c'], lambda y: x || y)[2]), 'string_agg', '') || '.parquet'); +-- +ok +== +ALTER TABLE cities +ALTER COLUMN prices SET DATA TYPE INTEGER[] USING + list_filter(cities.prices, lambda price: price < 100); +-- +ok +== diff --git a/parser/testdata/corpus/sql/function/list/lambdas/test_lambda_storage.test b/parser/testdata/corpus/sql/function/list/lambdas/test_lambda_storage.test new file mode 100644 index 0000000..819c28e --- /dev/null +++ b/parser/testdata/corpus/sql/function/list/lambdas/test_lambda_storage.test @@ -0,0 +1,13 @@ +# source: test/sql/function/list/lambdas/test_lambda_storage.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +SELECT SUM(list_i[1]) FROM lambda_view; +-- +ok +== +SELECT lambda_macro(1, 2); +-- +ok +== diff --git a/parser/testdata/corpus/sql/function/list/lambdas/transform.test b/parser/testdata/corpus/sql/function/list/lambdas/transform.test new file mode 100644 index 0000000..14b8629 --- /dev/null +++ b/parser/testdata/corpus/sql/function/list/lambdas/transform.test @@ -0,0 +1,193 @@ +# source: test/sql/function/list/lambdas/transform.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +SELECT [1] AS l, list_transform([1], lambda l: l + 1) +-- +ok +== +SELECT list_transform(NULL, lambda x: x + 1) +-- +ok +== +SELECT list_transform([1], lambda x: x) +-- +ok +== +SELECT list_transform(['duck', 'a', 'ö'], lambda duck: concat(duck, 'DB')) +-- +ok +== +SELECT list_transform([1, 2, 3], lambda x: 1) +-- +ok +== +SELECT list_transform([], lambda x: x + 1) +-- +ok +== +SELECT list_transform([1, 2, 3], lambda x: x + 1) +-- +ok +== +SELECT list_transform([1, NULL, -2, NULL], lambda x: x + 1) +-- +ok +== +SELECT list_transform(l, lambda x: x) FROM lists +-- +ok +== +SELECT list_transform(l, lambda x: x + n) FROM lists +-- +ok +== +SELECT list_transform(l, lambda x: x < 2) FROM lists +-- +ok +== +SELECT list_transform(['x', 'abc', 'z'], lambda x: x || '0') +-- +ok +== +SELECT list_transform([[1], [2, 3], [NULL], NULL], lambda x: list_transform(x, lambda y: y + 1)) +-- +ok +== +SELECT list_transform([[1], [2], [3]], lambda x: list_concat(x, x)) +-- +ok +== +SELECT list_transform([5, NULL, 6], lambda x: POW(x, 2)::INTEGER) +-- +ok +== +SELECT list_transform([5, NULL, 6], lambda x: COALESCE(x, 0) + 1) +-- +ok +== +SELECT list_transform(list_value(list_unique(list_concat([1,2],[2,2]))), lambda x: (x + 1)::INTEGER); +-- +ok +== +SELECT list_sort(list_transform(list_distinct(list_concat([1,2],[2,2])), lambda x: x + 1)); +-- +ok +== +SELECT list_transform([[1], [2], [3]], lambda x : list_concat( + list_transform(x, lambda y: y + 1), + list_transform(x, lambda z: z - 1))) +-- +ok +== +SELECT list_transform([[1], [4], NULL, [1], [8]], lambda x: list_concat( + list_transform(x, lambda y: CASE WHEN y > 1 THEN 'yay' ELSE 'nay' END), x)) +-- +ok +== +SELECT list_transform([[1], [4], NULL, [1], [8]], lambda x: list_concat( + list_transform(x, lambda y: CASE WHEN y > 1 THEN 'yay' ELSE 'nay' END), x::VARCHAR[])) +-- +ok +== +SELECT array_transform([1, NULL], lambda arr_elem: arr_elem - 4) +-- +ok +== +SELECT array_apply([1, NULL], lambda arr_elem: arr_elem - 4) +-- +ok +== +SELECT list_apply([1, NULL], lambda arr_elem: arr_elem - 4) +-- +ok +== +SELECT list_apply(i, lambda x: (6 + 2 * 12) // x) FROM (VALUES (list_value(1, 2, 3))) tbl(i); +-- +ok +== +SELECT list_apply(i, lambda x: x + 1 AND x + 1) FROM (VALUES (list_value(1, 2, 3))) tbl(i); +-- +ok +== +INSERT INTO transformed_lists (SELECT g + 1, list_transform(l, lambda x: x + 1) FROM large_lists WHERE g != 3) +-- +ok +== +INSERT INTO transformed_lists (SELECT g - 3, list_transform(l, lambda x: x - 3) FROM large_lists WHERE g = 3) +-- +ok +== +SELECT list_transform([{'a': 1}], lambda x: x.a); +-- +ok +== +SELECT list_transform([{'a': [1, 2, 3]}], lambda x: x.a[2]); +-- +ok +== +SELECT list_transform([{'b' : {'a': 1}}], lambda x: x.b.a); +-- +ok +== +SELECT list_transform([{'b' : {'a': 42, 'b': 43}}], lambda x: x.b.b); +-- +ok +== +SELECT list_transform([{'b' : {'a': [{'c': 77}], 'b': 43}}], lambda x: x.b.a[1].c); +-- +ok +== +SELECT n FROM corr_test WHERE list_sum(list_transform(l, lambda elem: elem - n)) >= n +-- +ok +== +SELECT ct.n FROM corr_test ct +WHERE list_count(ct.l) < ( + SELECT list_count(list_transform(list_concat(list(c.n), ct.l), lambda a: a)) + FROM corr_test c GROUP BY c.g) +ORDER BY ct.n +-- +ok +== +SELECT (SELECT list_transform(l, lambda elem: elem + 1)) FROM corr_test ORDER BY ALL +-- +ok +== +SELECT (SELECT list_transform(l, lambda elem: elem + n)) FROM corr_test ORDER BY ALL +-- +ok +== +SELECT (SELECT (SELECT (SELECT list_transform(l, lambda elem: elem + 1)))) FROM corr_test ORDER BY ALL +-- +ok +== +SELECT list_transform([1, 2, 3], lambda x: x + #1) FROM range(10) +-- +ok +== +select list_transform(bb, lambda x: [x, b]), bb, b +from (select list(b) over wind as bb, first(b) over wind as b + from test window wind as + (order by a asc, b asc rows between 4 preceding and current row) + qualify row_number() over wind >4); +-- +ok +== +SELECT list_transform([[2, 3], [4]], lambda x: list_transform([42], lambda y: y + 1)) +-- +ok +== +SELECT list_transform([[2, 3], [4]], lambda x: list_transform(x, lambda y: y + 1)) +-- +ok +== +SELECT list_transform([[2, 3], [4]], lambda x: list_transform([1], lambda y: x || [y])) +-- +ok +== +SELECT list_transform([[2, 3], [4]], lambda x: list_transform(x, lambda y: x || [y])) +-- +ok +== diff --git a/parser/testdata/corpus/sql/function/list/lambdas/transform_with_index.test b/parser/testdata/corpus/sql/function/list/lambdas/transform_with_index.test new file mode 100644 index 0000000..717c868 --- /dev/null +++ b/parser/testdata/corpus/sql/function/list/lambdas/transform_with_index.test @@ -0,0 +1,93 @@ +# source: test/sql/function/list/lambdas/transform_with_index.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +SELECT list_transform([1, 2, 3], lambda x: list_transform([4, 5, 6], lambda y, y_i: x + y + y_i)); +-- +ok +== +SELECT list_transform(['abc'], lambda x, i: x[i + 1]); +-- +ok +== +SELECT list_filter([1, 2, 1], lambda x, y: x >= y); +-- +ok +== +SELECT + list_transform([1, 2, 3], lambda x: + list_transform([4, 5, 6], lambda y: + list_transform([7, 8, 9], lambda z, i: + x + y + z + i))); +-- +ok +== +SELECT list_transform([10, 20, 30], lambda x, i: x + i); +-- +ok +== +SELECT list_transform([1, 2, 3, 4, 5, 6], lambda x, i: x * i); +-- +ok +== +SELECT list_transform([6, 5, 4, 3, 2, 1], lambda x, i: x * i); +-- +ok +== +SELECT list_transform([1, NULL, 3, 4, 5, 6], lambda x, i: x + i); +-- +ok +== +SELECT list_transform(NULL, lambda x, i: x + i); +-- +ok +== +SELECT list_transform(['1', '2', '3', '4'], lambda x, i: (x || ' + ' || CAST(i AS string))); +-- +ok +== +SELECT list_transform([1,2,3,4,5], lambda x, i: (x * 10 / i)); +-- +ok +== +SELECT list_transform(a, lambda x, i: x + i) FROM tbl; +-- +ok +== +SELECT list_transform(a, lambda x, i: (c / b ) * (x + i)) FROM tbl; +-- +ok +== +SELECT range(1, 20000, 2); +-- +ok +== +SELECT list_transform(range(10000), lambda x, i: x + i); +-- +ok +== +SELECT list_transform([1, 2, 3], lambda x, x_i: list_transform([4, 5, 6], lambda y: x + y + x_i)); +-- +ok +== +SELECT list_transform([1, 2, 3], lambda x, x_i: list_transform([4, 5, 6], lambda y, y_i: x + y + x_i + y_i)); +-- +ok +== +SELECT + list_transform([1, 2, 3], lambda x, i: + list_transform([4, 5, 6], lambda y: + list_transform([7, 8, 9], lambda z: + x + y + z + i))); +-- +ok +== +SELECT + list_transform([1, 2, 3], lambda x: + list_transform([4, 5, 6], lambda y, i: + list_transform([7, 8, 9], lambda z: + x + y + z + i))); +-- +ok +== diff --git a/parser/testdata/corpus/sql/function/list/lambdas/vector_types.test b/parser/testdata/corpus/sql/function/list/lambdas/vector_types.test new file mode 100644 index 0000000..150ceed --- /dev/null +++ b/parser/testdata/corpus/sql/function/list/lambdas/vector_types.test @@ -0,0 +1,17 @@ +# source: test/sql/function/list/lambdas/vector_types.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +SELECT [x for x in c if x IS NOT NULL] FROM test_vector_types(NULL::INT[]) t(c); +-- +ok +== +SELECT [x for x in c if x IS NULL] FROM test_vector_types(NULL::INT[]) t(c); +-- +ok +== +SELECT list_reduce(c, lambda x, y: x + y) FROM test_vector_types(NULL::INT[]) t(c) WHERE len(c) > 0; +-- +ok +== diff --git a/parser/testdata/corpus/sql/function/list/list_concat.test b/parser/testdata/corpus/sql/function/list/list_concat.test new file mode 100644 index 0000000..0e7dcb0 --- /dev/null +++ b/parser/testdata/corpus/sql/function/list/list_concat.test @@ -0,0 +1,205 @@ +# source: test/sql/function/list/list_concat.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +SELECT list_concat([1, 2], [3, 4]) +-- +ok +== +SELECT array_cat([1, 2], [3, 4]) +-- +ok +== +SELECT list_concat(NULL, [3, 4]) +-- +ok +== +SELECT list_concat([1, 2], NULL) +-- +ok +== +SELECT list_concat([], []) +-- +ok +== +SELECT list_concat([], [3, 4]) +-- +ok +== +SELECT list_concat([1, 2], []) +-- +ok +== +SELECT list_concat([1, 2], [3, 4], [5, 6]) +-- +ok +== +SELECT list_concat([1, 2], [3, 4], []) +-- +ok +== +SELECT list_concat([1, 2], [], [5, 6]) +-- +ok +== +SELECT list_concat([], [3, 4], [5, 6]) +-- +ok +== +SELECT list_concat([], [], [5, 6]) +-- +ok +== +SELECT list_concat([1, 2], [3, 4], [5, 6], [7, 8]) +-- +ok +== +SELECT list_concat([1, 2], 3) +-- +ok +== +SELECT [1, 2] || [3, 4] +-- +ok +== +SELECT [1, 2] + [3, 4] +-- +ok +== +SELECT list_concat([1, 2]::{type_a}[], [3, 4]::{type_b}[])::INTEGER[] +-- +error: Parser Error: syntax error at or near "{" +== +SELECT list_concat([1.000000, 2.000000]::float[], [3.000000, 4.000000]::double[]) +-- +ok +== +SELECT list_concat([1.000000, 2.000000]::double[], [3.000000, 4.000000]::float[]) +-- +ok +== +SELECT list_concat([NULL], [NULL]) +-- +ok +== +SELECT list_concat([1, 2], [NULL]) +-- +ok +== +SELECT list_concat([NULL], [3, 4]) +-- +ok +== +SELECT list_concat([1, 2], [3, 4], [NULL]) +-- +ok +== +SELECT list_concat([1, 2], [3, 4], NULL) +-- +ok +== +SELECT list_concat(NULL, [3, 4], [5, 6]) +-- +ok +== +SELECT list_concat([[1, 2]], [[3, 4]]) +-- +ok +== +SELECT list_concat([[1, 2]], [[3, 4]], [[5, 6]]) +-- +ok +== +SELECT list_concat([{a: 1}, {a: 2}], [{a: 3}, {a: 4}]) +-- +ok +== +SELECT list_concat([{a: 1}, {a: 2}], [{a: 3}, {a: 4}], [{a: 5}, {a: 6}]) +-- +ok +== +SELECT list_concat([[[1], [2]], [[3], [4]]], [[[5], [6]], [[7], [8]]]) +-- +ok +== +SELECT list_concat([[[1], [2]], [[3], [4]]], [[[5], [6]], [[7], [8]]], [[[9], [10]], [[11], [12]]]) +-- +ok +== +CREATE TABLE test AS SELECT range % 4 i, range j, range k FROM range(16) +-- +ok +== +CREATE TABLE lists AS SELECT i, list(j) j, list(k) k FROM test GROUP BY i +-- +ok +== +SELECT i, list_concat(j, k) FROM lists +-- +ok +== +SELECT i, list_concat(j, k, j, k, j, k) FROM lists +-- +ok +== +SELECT i, list_concat(j, cast(k AS VARCHAR)) FROM lists +-- +ok +== +SELECT list_append([1, 2], 3) +-- +ok +== +SELECT list_append([1, 2], NULL) +-- +ok +== +SELECT list_append(NULL, 3) +-- +ok +== +SELECT i, list_append(list_concat(j, k), i) FROM lists ORDER BY i; +-- +ok +== +SELECT list_prepend(1, [2, 3]) +-- +ok +== +SELECT array_prepend(1, [2, 3]) +-- +ok +== +SELECT array_push_back([1, 2], 3); +-- +ok +== +SELECT array_push_back(NULL, 3); +-- +ok +== +SELECT array_push_front([2, 3], 1); +-- +ok +== +SELECT array_push_front(NULL, 1); +-- +ok +== +SELECT [1, 2] || NULL +-- +ok +== +SELECT [1, 2] || b FROM (VALUES (NULL::INT[])) t(b) +-- +ok +== +SELECT a || b FROM (VALUES ([1,2,3], NULL::INT[])) t(a,b) +-- +ok +== +SELECT concat([42], [84], 'str') +-- +ok +== diff --git a/parser/testdata/corpus/sql/function/list/list_contains.test b/parser/testdata/corpus/sql/function/list/list_contains.test new file mode 100644 index 0000000..b5dd0ef --- /dev/null +++ b/parser/testdata/corpus/sql/function/list/list_contains.test @@ -0,0 +1,340 @@ +# source: test/sql/function/list/list_contains.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +create table TEST2 (i int[], j int); +-- +ok +== +insert into TEST2 values ([2,1,3], 2), ([2,3,4], 5), ([1], NULL); +-- +ok +== +select list_contains(i, j) from TEST2 +-- +ok +== +create table TEST (i int[]); +-- +ok +== +insert into TEST values ([2,1,3]), ([2,3,4]), ([1]); +-- +ok +== +SELECT i, list_contains(i,1) from TEST; +-- +ok +== +SELECT i, list_contains(i,4.0) from TEST; +-- +ok +== +DROP table TEST; +-- +ok +== +create table STR_TEST (i string[]); +-- +ok +== +insert into STR_TEST values (['a','b','c']), (['d','a','e']), (['b']), (['aaaaaaaaaaaaaaaaaaaaaaaa']); +-- +ok +== +SELECT i, list_contains(i,'a') from STR_TEST; +-- +ok +== +SELECT i, list_contains(i,'aaaaaaaaaaaaaaaaaaaaaaaa') from STR_TEST; +-- +ok +== +SELECT i, list_contains(i, '0') from STR_TEST; +-- +ok +== +SELECT i, list_contains(i,NULL) from STR_TEST; +-- +ok +== +DROP table STR_TEST; +-- +ok +== +SELECT list_contains([7,2,5], 7) +-- +ok +== +SELECT list_contains([], 7) +-- +ok +== +SELECT list_contains([1,2,3],1.0) +-- +ok +== +SELECT list_contains([1.0,2.0,3.0,4.0],1) +-- +ok +== +SELECT list_contains([1,2,3],4.0) +-- +ok +== +SELECT list_contains([1.0,2.0,3.0],4) +-- +ok +== +SELECT list_contains([1.0,2.0,3.0], 'a') +-- +ok +== +SELECT list_contains('a', 'a') +-- +ok +== +SELECT list_contains(NULL,NULL) +-- +ok +== +SELECT list_contains([7], 5) +-- +ok +== +SELECT list_contains([1,2,3,4],4) +-- +ok +== +SELECT list_contains([1,2,3,4],5) +-- +ok +== +SELECT list_contains([1.0,2.0,3.0,4.0],5.0) +-- +ok +== +SELECT list_contains([1.0,2.0,3.0,4.0],4.0) +-- +ok +== +SELECT list_contains([true, false],true) +-- +ok +== +SELECT list_contains([true, true],false) +-- +ok +== +SELECT list_contains(['test', 'notest'],'notest') +-- +ok +== +SELECT list_contains(['test', 'notest'],'a') +-- +ok +== +SELECT list_contains(NULL,1) +-- +ok +== +SELECT list_contains([1],NULL) +-- +ok +== +SELECT list_contains([NULL],NULL) +-- +ok +== +SELECT list_contains([NULL, 1],NULL) +-- +ok +== +SELECT list_contains([NULL, 1],1) +-- +ok +== +SELECT list_contains([NULL, 0],1) +-- +ok +== +SELECT list_contains([],NULL) +-- +ok +== +SELECT list_contains([NULL,7], 7) +-- +ok +== +SELECT list_contains([[1,2,3],[1],[1,2,3]) +-- +error: Parser Error: syntax error at or near ")" +== +SELECT list_contains([[1,2,3],[1],[1,2,3]]) +-- +ok +== +SELECT list_contains(1) +-- +ok +== +SELECT list_contains(1,1) +-- +ok +== +PRAGMA debug_force_external=true +-- +ok +== +CREATE TABLE test0 (i {type}[]) +-- +error: Parser Error: syntax error at or near "{" +== +INSERT INTO test0 VALUES ([2]), ([1]), ([1, 2]), ([]), ([2, 2]), ([NULL]), ([2, 3]) +-- +ok +== +SELECT list_contains(i,1) from test0 +-- +ok +== +DROP TABLE test0 +-- +ok +== +PRAGMA debug_force_external=false +-- +ok +== +SELECT list_contains([[1,2,3],[1]],[1]) +-- +ok +== +SELECT list_contains([[1,2,3],[1]],[2]) +-- +ok +== +SELECT list_contains([[1,2,3],[1]],[1,2,3]) +-- +ok +== +SELECT list_contains([[1,3],[1]],[1,2,3]) +-- +ok +== +SELECT list_contains([[1,3],[1], [1,2,3]],[1,2,3]) +-- +ok +== +SELECT list_contains([[NULL],[1], [1,2,3]],NULL) +-- +ok +== +SELECT list_contains([[NULL],[1], [1,2,3]],[NULL]) +-- +ok +== +SELECT list_contains([[1,NULL],[1], [1,2,3]],[1,NULL]) +-- +ok +== +SELECT list_contains([[1,NULL],[1], [1,2,3]],[0,NULL]) +-- +ok +== +SELECT list_contains([{a: 1}, {a: 2}], {a: 2}) +-- +ok +== +SELECT list_contains([{a: 1}, {a: 2}], {a: 3}) +-- +ok +== +SELECT list_contains([{a: 1, b: 3}, {a: 2, b: 2}], {a: 2, b: 2}) +-- +ok +== +SELECT list_contains([{a: 1, b: 3}, {a: 2, b: 2}], {a: 1, b: 2}) +-- +ok +== +SELECT list_contains([MAP([1], [2])], MAP([1], [2])) +-- +ok +== +SELECT list_contains([MAP([1], [2])], MAP([1], [3])) +-- +ok +== +SELECT list_contains([MAP([1], [2]), NULL], NULL) +-- +ok +== +SELECT list_contains([MAP([1], [2]), NULL], MAP([1], [2])) +-- +ok +== +SELECT list_contains([[1,2,3],NULL],NULL) +-- +ok +== +INSERT INTO test0 VALUES ([2.0]), ([1.0]), ([1.0, 2.0]), ([]), ([2.0, 2.0]), ([NULL]), ([2.0, 3.0]) +-- +ok +== +SELECT list_contains(i,1.0) from test0 +-- +ok +== +CREATE TABLE functions (function_name varchar, function_type varchar, parameter_types varchar[]); +-- +ok +== +INSERT INTO functions VALUES ('last_day', 'scalar', ['TIMESTAMP']), ('dayname', 'else', ['TIMESTAMP']), + ('date_part', 'scalar', ['DATE', 'VARCHAR']), ('scalar_part', 'scalar', ['VARCHAR', 'TIMESTAMP']); +-- +ok +== +SELECT function_name FROM functions +WHERE function_type = 'scalar' AND list_has(parameter_types, 'TIMESTAMP'); +-- +ok +== +CREATE TABLE test (id int, name text[]); +-- +ok +== +INSERT INTO test VALUES (1, ['U2']), (2, ['Blur','Rock']), (3, ['Oasis','2Pac']); +-- +ok +== +SELECT id, name FROM test WHERE ARRAY_CONTAINS(name, '2Pac'); +-- +ok +== +SELECT id, name FROM test WHERE id IN (2,3) AND ARRAY_CONTAINS(name, '2Pac'); +-- +ok +== +WITH cte AS (SELECT id, name FROM test WHERE id IN (2,3)) +SELECT id, name FROM cte WHERE ARRAY_CONTAINS(name, '2Pac'); +-- +ok +== +SELECT id, name FROM test WHERE id IN (2,3) AND name::text ILIKE '%2Pac%'; +-- +ok +== +CREATE TABLE list_of_list(l1 int[][], l2 int[][]); +-- +ok +== +INSERT INTO list_of_list VALUES ([NULL], [NULL]); +-- +ok +== +SELECT list_filter(l1, lambda x: list_contains(l2, x)) FROM list_of_list; +-- +ok +== diff --git a/parser/testdata/corpus/sql/function/list/list_cosine_similarity.test b/parser/testdata/corpus/sql/function/list/list_cosine_similarity.test new file mode 100644 index 0000000..3a6501d --- /dev/null +++ b/parser/testdata/corpus/sql/function/list/list_cosine_similarity.test @@ -0,0 +1,41 @@ +# source: test/sql/function/list/list_cosine_similarity.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +SELECT list_cosine_similarity([1, 2, 3]::{type}[], [1, 2, 3]::{type}[]); +-- +error: Parser Error: syntax error at or near "{" +== +CREATE OR REPLACE TABLE lists (l {type}[]); +-- +error: Parser Error: syntax error at or near "{" +== +INSERT INTO lists VALUES ([1, 2, 3]), ([4, 5, 6]), ([7, 8, 9]), ([-1, -2, -3]), (NULL); +-- +ok +== +SELECT list_cosine_similarity(l, [1, 2, 3]) FROM lists; +-- +ok +== +SELECT list_cosine_similarity([1, NULL, 3]::{type}[], [1, 2, 3]::{type}[]); +-- +error: Parser Error: syntax error at or near "{" +== +SELECT list_cosine_similarity([1, 2, 3]::{type}[], [1, NULL, 3]::{type}[]); +-- +error: Parser Error: syntax error at or near "{" +== +SELECT list_cosine_similarity([1, 2, 3]::{type}[], [1, 2, 3, 4]::{type}[]); +-- +error: Parser Error: syntax error at or near "{" +== +SELECT list_cosine_similarity([], []); +-- +ok +== +SELECT list_cosine_distance([1, 2, 3]::{type}[], [1, 2, 3]::{type}[]) = 1 - list_cosine_similarity([1, 2, 3]::{type}[], [1, 2, 3]::{type}[]); +-- +error: Parser Error: syntax error at or near "{" +== diff --git a/parser/testdata/corpus/sql/function/list/list_distance.test b/parser/testdata/corpus/sql/function/list/list_distance.test new file mode 100644 index 0000000..c08e761 --- /dev/null +++ b/parser/testdata/corpus/sql/function/list/list_distance.test @@ -0,0 +1,33 @@ +# source: test/sql/function/list/list_distance.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +SELECT list_distance([1, 2, 3]::{type}[], [1, 2, 3]::{type}[]); +-- +error: Parser Error: syntax error at or near "{" +== +INSERT INTO lists VALUES ([1, 2, 3]), ([1, 2, 4]), ([7, 8, 9]), ([-1, -2, -3]), (NULL); +-- +ok +== +SELECT list_distance(l, [1, 2, 3]) FROM lists; +-- +ok +== +SELECT list_distance([1, NULL, 3]::{type}[], [1, 2, 3]::{type}[]); +-- +error: Parser Error: syntax error at or near "{" +== +SELECT list_distance([1, 2, 3]::{type}[], [1, NULL, 3]::{type}[]); +-- +error: Parser Error: syntax error at or near "{" +== +SELECT list_distance([1, 2, 3]::{type}[], [1, 2, 3, 4]::{type}[]); +-- +error: Parser Error: syntax error at or near "{" +== +SELECT list_distance([], []); +-- +ok +== diff --git a/parser/testdata/corpus/sql/function/list/list_distinct.test b/parser/testdata/corpus/sql/function/list/list_distinct.test new file mode 100644 index 0000000..aa43ff3 --- /dev/null +++ b/parser/testdata/corpus/sql/function/list/list_distinct.test @@ -0,0 +1,178 @@ +# source: test/sql/function/list/list_distinct.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +SELECT list_distinct(NULL) +-- +ok +== +SELECT list_distinct([NULL]) +-- +ok +== +SELECT list_distinct([]) +-- +ok +== +SELECT list_distinct([]) WHERE 1 = 0 +-- +ok +== +SELECT list_distinct() +-- +ok +== +SELECT list_distinct(*) +-- +ok +== +SELECT list_distinct([1, 2], 2) +-- +ok +== +SELECT list_distinct(NULL::boolean) +-- +ok +== +SELECT UNNEST(list_distinct([1, 1, 2, 2, 2, 3])) AS l ORDER BY l +-- +ok +== +SELECT UNNEST(list_distinct([1, 1, NULL, 2, 2, 2, 3, NULL, NULL])) AS l ORDER BY l +-- +ok +== +SELECT UNNEST(list_distinct(list_distinct([1, 1, -5, 10, 10, 2]))) AS l ORDER BY l +-- +ok +== +CREATE TABLE integers (l integer[]) +-- +ok +== +INSERT INTO integers VALUES ([1, 1, 1]), ([1, NULL, 1, NULL]) +-- +ok +== +INSERT INTO integers VALUES ([NULL]), (NULL), ([]) +-- +ok +== +SELECT list_distinct(l) FROM integers +-- +ok +== +SELECT UNNEST(array_distinct([1, 2, 2, NULL])) AS l ORDER BY l +-- +ok +== +SELECT UNNEST(list_distinct([True, True, False, NULL])) AS l ORDER BY l +-- +ok +== +SELECT list_distinct([NULL::BOOLEAN]) +-- +ok +== +SELECT UNNEST(list_distinct(['aa', 'aa', 'cd', NULL, '42'])) AS l ORDER BY l +-- +ok +== +SELECT list_distinct([NULL::VARCHAR]) +-- +ok +== +SELECT list_distinct([1::{type}, NULL, 1::{type}]) +-- +error: Parser Error: syntax error at or near "{" +== +SELECT list_distinct([NULL::{type}]) +-- +error: Parser Error: syntax error at or near "{" +== +SELECT list_distinct([1::{type}]) +-- +error: Parser Error: syntax error at or near "{" +== +SELECT unnest(list_sort(list_distinct([1.0, 'nan'::DOUBLE, 'nan'::DOUBLE])))::VARCHAR; +-- +ok +== +SELECT list_distinct(['2021-08-20'::DATE]) +-- +ok +== +SELECT list_distinct(['14:59:37'::TIME]) +-- +ok +== +SELECT list_distinct(['2021-08-20'::TIMESTAMP]) +-- +ok +== +SELECT list_distinct(['2021-08-20'::TIMESTAMP_S]) +-- +ok +== +SELECT list_distinct(['2021-08-20 00:00:00.123'::TIMESTAMP_MS]) +-- +ok +== +SELECT list_distinct(['2021-08-20 00:00:00.123456'::TIMESTAMP_NS]) +-- +ok +== +SELECT list_distinct(['14:59:37'::TIMETZ]) +-- +ok +== +SELECT list_distinct(['2021-08-20'::TIMESTAMPTZ]) +-- +ok +== +SELECT list_distinct([INTERVAL 1 YEAR]) +-- +ok +== +CREATE TABLE enums (e mood[]) +-- +ok +== +INSERT INTO enums VALUES (['happy', 'ok']) +-- +ok +== +SELECT list_sort(list_distinct(e)) FROM enums +-- +ok +== +CREATE TABLE wheretest (name VARCHAR, l INTEGER[]); +-- +ok +== +INSERT INTO wheretest VALUES ('one1', [2, 3, 3, 4, NULL, 2]), ('one2', [NULL, NULL, 2]), ('two1', [1, 2, 3, 10, 15]), + ('one3', [2, 3, 4]), ('two2', NULL), ('two3', [10, 11, 12]); +-- +ok +== +SELECT name FROM wheretest WHERE name ILIKE 'one%' AND list_unique(list_distinct(l)) > 1; +-- +ok +== +SELECT name FROM wheretest WHERE name ILIKE 'two%' AND list_unique(list_distinct(l)) > 3; +-- +ok +== +SELECT list_sort(list_distinct(['a', 'b、c', 'a'])) +-- +ok +== +CREATE TABLE all_types AS SELECT * FROM test_all_types(); +-- +ok +== +SELECT list_distinct([COLUMNS(*)]) FROM all_types; +-- +ok +== diff --git a/parser/testdata/corpus/sql/function/list/list_has_any_and_has_all.test b/parser/testdata/corpus/sql/function/list/list_has_any_and_has_all.test new file mode 100644 index 0000000..b3dc7b7 --- /dev/null +++ b/parser/testdata/corpus/sql/function/list/list_has_any_and_has_all.test @@ -0,0 +1,229 @@ +# source: test/sql/function/list/list_has_any_and_has_all.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +select list_has_any([1,2,3], [2,3,4]); +-- +ok +== +select list_has_all([1,2,3], [2,3,4]); +-- +ok +== +CREATE TABLE list_data(l1 int[], l2 int[]); +-- +ok +== +INSERT INTO list_data VALUES (NULL, NULL); +-- +ok +== +INSERT INTO list_data VALUES (NULL, [1,2,3]); +-- +ok +== +INSERT INTO list_data VALUES ([1,2,3], NULL); +-- +ok +== +INSERT INTO list_data VALUES ([1,2,3], [2,3,NULL]); +-- +ok +== +INSERT INTO list_data VALUES ([1,2,NULL], [2,3,NULL]); +-- +ok +== +INSERT INTO list_data VALUES ([1,2,NULL], [NULL,3,4]); +-- +ok +== +INSERT INTO list_data VALUES ([1,2,3], [1,2,3]); +-- +ok +== +INSERT INTO list_data VALUES ([1,2,3], [1,2,NULL]); +-- +ok +== +select list_has_any(l1, l2) from list_data; +-- +ok +== +select list_has_all(l1, l2) from list_data; +-- +ok +== +DROP TABLE list_data; +-- +ok +== +create table list_of_list(l1 int[][], l2 int[][]); +-- +ok +== +insert into list_of_list values (NULL, NULL); +-- +ok +== +insert into list_of_list values ([[1 , 2, 3], NULL, [3, 2, 1]], [[2, 3, 4], NULL, [1, 2, 3]]); +-- +ok +== +insert into list_of_list values ([[1 , 2, 3], NULL, [3, 2, 1]], [[8, 8, 8], NULL, [8, 8, 8]]); +-- +ok +== +insert into list_of_list values ([[1 , 2, 3], NULL, [8, 8, 8]], [[8, 8, 8], NULL, [1, 2, 3]]); +-- +ok +== +select list_has_any(l1, l2) from list_of_list; +-- +ok +== +select list_has_all(l1, l2) from list_of_list; +-- +ok +== +drop table list_of_list; +-- +ok +== +create table list_of_strings(l1 string[], l2 string[]); +-- +ok +== +insert into list_of_strings values (NULL, NULL); +-- +ok +== +insert into list_of_strings values ([NULL, 'a', 'b', 'c'], [NULL, 'b', 'c', 'd']); +-- +ok +== +insert into list_of_strings values (['a', 'b', 'c'], ['a', 'b', 'c']); +-- +ok +== +insert into list_of_strings values (['here is a very long long string that is def more than 12 bytes', 'and a shorty'], ['here is a very long long string that is def more than 12 bytes', 'here is a very long long string that is def more than 12 bytes', 'c', 'd']); +-- +ok +== +insert into list_of_strings values (['here is a very long long string that is def more than 12 bytes', 'and a shorty'], ['here is a very long string that is def more than 12 bytes', 'here is a very long string that is def more than 12 bytes', 'c', 'd']); +-- +ok +== +insert into list_of_strings values (['here is a very long long string that is def more than 12 bytes', 'and a shorty'], ['here is a very long long string that is def more than 12 bytes', 'and a shorty']); +-- +ok +== +select list_has_any(l1, l2) from list_of_strings; +-- +ok +== +select list_has_all(l1, l2) from list_of_strings; +-- +ok +== +select list_has_any(l1) from list_of_strings; +-- +ok +== +select list_has_any(l1, l2, l1) from list_of_strings; +-- +ok +== +select list_has_all(l1) from list_of_strings; +-- +ok +== +select list_has_all(l1, l2, l1) from list_of_strings; +-- +ok +== +select list_has_all([1, 2], 1); +-- +ok +== +select list_has_any([[1,2], [2,4]], ['abc', 'def']); +-- +ok +== +create table tbl(l1 int[], l2 int[]); +-- +ok +== +insert into tbl values ([1,2,3], [2,3,4]); +-- +ok +== +select {f}(list_intersect(l1, l2), list_intersect(l2, l1)) from tbl; +-- +error: Parser Error: syntax error at or near "}" +== +drop table tbl; +-- +ok +== +insert into tbl values ([1,2,3,4,5,6], [2,3,4]); +-- +ok +== +insert into tbl values ([1,2,3], [1,2,3,4,7,8,9]); +-- +ok +== +select list_has_any(l1, l2) from tbl; +-- +ok +== +select list_has_all(l1, l2) from tbl; +-- +ok +== +select list_has_all(l2, l1) from tbl; +-- +ok +== +select l1 && l2 from tbl; +-- +ok +== +select 'hello' && l1 from tbl; +-- +ok +== +select NULL && [NULL]; +-- +ok +== +select l1 && NULL from tbl; +-- +ok +== +select l1 @> l2 from tbl; +-- +ok +== +select l1 <@ l2 from tbl; +-- +ok +== +select 'hello' @> l1 from tbl; +-- +ok +== +select 'hello' <@ l1 from tbl; +-- +ok +== +select l1 @> NULL from tbl; +-- +ok +== +select l1 <@ NULL from tbl; +-- +ok +== diff --git a/parser/testdata/corpus/sql/function/list/list_inner_product.test b/parser/testdata/corpus/sql/function/list/list_inner_product.test new file mode 100644 index 0000000..76092e9 --- /dev/null +++ b/parser/testdata/corpus/sql/function/list/list_inner_product.test @@ -0,0 +1,33 @@ +# source: test/sql/function/list/list_inner_product.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +SELECT list_inner_product([], []); +-- +ok +== +SELECT list_inner_product([1, 1, 1]::{type}[], [1, 1, 1]::{type}[]); +-- +error: Parser Error: syntax error at or near "{" +== +SELECT list_inner_product(l, [1, 2, 3]) FROM lists; +-- +ok +== +SELECT list_inner_product([1, NULL, 3]::{type}[], [1, 2, 3]::{type}[]); +-- +error: Parser Error: syntax error at or near "{" +== +SELECT list_inner_product([1, 2, 3]::{type}[], [1, NULL, 3]::{type}[]); +-- +error: Parser Error: syntax error at or near "{" +== +SELECT list_inner_product([1, 2, 3]::{type}[], [1, 2, 3, 4]::{type}[]); +-- +error: Parser Error: syntax error at or near "{" +== +SELECT list_negative_inner_product([1,2,3]::{type}[], [1,2,3]::{type}[]) = -list_inner_product([1,2,3]::{type}[], [1,2,3]::{type}[]); +-- +error: Parser Error: syntax error at or near "{" +== diff --git a/parser/testdata/corpus/sql/function/list/list_intersect.test b/parser/testdata/corpus/sql/function/list/list_intersect.test new file mode 100644 index 0000000..5a91ec5 --- /dev/null +++ b/parser/testdata/corpus/sql/function/list/list_intersect.test @@ -0,0 +1,137 @@ +# source: test/sql/function/list/list_intersect.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +select list_sort({f}([1,2,3], [2,3,4])); +-- +error: Parser Error: syntax error at or near "}" +== +select list_sort({f}(l1, l2)) from list_data; +-- +error: Parser Error: syntax error at or near "}" +== +insert into list_of_list values ([[1 , 2, 3], NULL, [3, 2, 1]], [[ 2, 3, 4], NULL, [1, 2, 3]]); +-- +ok +== +select {f}(l1, l2) from list_of_list; +-- +error: Parser Error: syntax error at or near "}" +== +select list_sort({f}(l1, l2)) from list_of_strings; +-- +error: Parser Error: syntax error at or near "}" +== +drop table list_of_strings; +-- +ok +== +select list_intersect(l1) from list_of_strings; +-- +ok +== +select list_intersect(l1, l2, l1) from list_of_strings; +-- +ok +== +select list_intersect([[1,2], [2,4]], ['abc', 'def']); +-- +ok +== +create table large_lists(l1 int[], l2 int[]); +-- +ok +== +insert into large_lists values (range(1, 3000), range(2000, 3000)); +-- +ok +== +insert into large_lists values (range(3000), range(3000)); +-- +ok +== +select list_intersect(l1, l2) from large_lists; +-- +ok +== +select list_intersect(list_filter([1, 2, 3, 4], lambda x: x > 2), list_filter([4, 5, 6, 7], lambda x: x > 2)); +-- +ok +== +prepare q1 as select list_intersect(?, ?); +-- +ok +== +execute q1(['abc', 'def'], ['def', 'ghi']); +-- +ok +== +select list_intersect(["{colname}"], ["{colname}"]) FROM all_types; +-- +ok +== +SELECT list_sort(list_intersect([1, 4, 3, 5, 5, 2, 2], [5, 5, 5, 1, 1, 2, 4])); +-- +ok +== +SELECT list_sort(list_intersect([1, 2, 3, 4, 5, 6, 7, 8, 9, 10], [2, 5, 8])); +-- +ok +== +SELECT list_sort(list_intersect([10, 20, 30, 40, 50], [20, 40])); +-- +ok +== +SELECT list_sort(list_intersect([1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12], [3, 6, 9, 12])); +-- +ok +== +SELECT list_sort(list_intersect(['a', 'b', 'c', 'd', 'e', 'f', 'g', 'h'], ['b', 'd', 'f'])); +-- +ok +== +SELECT list_sort(list_intersect([1, 2, 2, 3, 4, 5, 6, 7, 8, 9, 10], [2, 2, 5, 5, 8])); +-- +ok +== +SELECT list_sort(list_intersect(range(1, 1000), [100, 200, 300])); +-- +ok +== +SELECT list_sort(list_intersect([true, false], [1, 0])); +-- +ok +== +SELECT list_sort(list_intersect([1, 0], [true, false])); +-- +ok +== +SELECT list_sort(list_intersect([true, false, 1], [1, 0, 1, 1, 1, 1, 1])); +-- +ok +== +SELECT list_sort(list_intersect([1::INT, 2::INT, 3::INT], [2::BIGINT, 3::BIGINT, 4::BIGINT])); +-- +ok +== +SELECT typeof(list_intersect([1::INT, 2::INT], [2::BIGINT, 3::BIGINT])); +-- +ok +== +SELECT list_sort(list_intersect([1::SMALLINT, 2::SMALLINT, 3::SMALLINT], [2::INT, 3::INT, 4::INT])); +-- +ok +== +SELECT typeof(list_intersect([1::SMALLINT, 2::SMALLINT], [2::INT, 3::INT])); +-- +ok +== +SELECT list_sort(list_intersect([1::INT, 2::INT, 3::INT], [2.0::DOUBLE, 3.0::DOUBLE, 4.0::DOUBLE])); +-- +ok +== +SELECT typeof(list_intersect([1::INT, 2::INT], [2.0::DOUBLE, 3.0::DOUBLE])); +-- +ok +== diff --git a/parser/testdata/corpus/sql/function/list/list_position.test b/parser/testdata/corpus/sql/function/list/list_position.test new file mode 100644 index 0000000..84b2503 --- /dev/null +++ b/parser/testdata/corpus/sql/function/list/list_position.test @@ -0,0 +1,305 @@ +# source: test/sql/function/list/list_position.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +select list_position(i, j) from TEST2 +-- +ok +== +SELECT i, list_position(i,1) from TEST; +-- +ok +== +SELECT i, list_position(i,4.0) from TEST; +-- +ok +== +create table TEST(i int[], j int); +-- +ok +== +insert into TEST values ([2,1,3], 2), ([2,3,4], 5), ([1], NULL), ([1, NULL, 2], NULL); +-- +ok +== +SELECT i, j, list_position(i,j) from TEST; +-- +ok +== +CREATE TABLE NULL_TABLE (n int[], i int); +-- +ok +== +INSERT INTO NULL_TABLE VALUES (NULL, 1), (NULL, 2), (NULL, 3); +-- +ok +== +SELECT list_contains(n, i) FROM NULL_TABLE; +-- +ok +== +DROP TABLE NULL_TABLE; +-- +ok +== +SELECT i, list_position(i,'a') from STR_TEST; +-- +ok +== +SELECT i, list_position(i,'aaaaaaaaaaaaaaaaaaaaaaaa') from STR_TEST; +-- +ok +== +SELECT i, list_position(i, '0') from STR_TEST; +-- +ok +== +SELECT i, list_position(i,NULL) from STR_TEST; +-- +ok +== +create table STR_TEST (i string[], j string); +-- +ok +== +insert into STR_TEST values (['a','b','c'], 'a'), (['d','a','e'], 'b'), (['b'], NULL), (['aa', NULL, 'bb'], NULL); +-- +ok +== +SELECT i, j, list_position(i,j) from STR_TEST; +-- +ok +== +SELECT list_position([7,2,5], 7) +-- +ok +== +SELECT list_position([], 7) +-- +ok +== +SELECT list_position([1,2,3],1.0) +-- +ok +== +SELECT list_position([1.0,2.0,3.0,4.0],1) +-- +ok +== +SELECT list_position([1,2,3],4.0) +-- +ok +== +SELECT list_position([1.0,2.0,3.0],4) +-- +ok +== +SELECT list_position([1.0,2.0,3.0], 'a') +-- +ok +== +SELECT list_position([1.0,2.0,3.0]::varchar[], 'a') +-- +ok +== +SELECT list_position('a', 'a') +-- +ok +== +SELECT list_position(NULL,NULL) +-- +ok +== +SELECT list_position([7], 5) +-- +ok +== +SELECT list_position([1,2,3,4],4) +-- +ok +== +SELECT list_position([1,2,3,4],5) +-- +ok +== +SELECT list_position([1.0,2.0,3.0,4.0],5.0) +-- +ok +== +SELECT list_position([1.0,2.0,3.0,4.0],4.0) +-- +ok +== +SELECT list_position([true, false],true) +-- +ok +== +SELECT list_position([true, true],false) +-- +ok +== +SELECT list_position(['test', 'notest'],'notest') +-- +ok +== +SELECT list_position(['test', 'notest'],'a') +-- +ok +== +SELECT list_position(NULL,1) +-- +ok +== +SELECT list_position([1],NULL) +-- +ok +== +SELECT list_position([NULL],NULL) +-- +ok +== +SELECT list_position([NULL, 1],NULL) +-- +ok +== +SELECT list_position([NULL, 1],1) +-- +ok +== +SELECT list_position([NULL, 0],1) +-- +ok +== +SELECT list_position([],NULL) +-- +ok +== +SELECT list_position([NULL,7], 7) +-- +ok +== +SELECT list_position([[1,2,3],[1],[1,2,3]) +-- +error: Parser Error: syntax error at or near ")" +== +SELECT list_position([[1,2,3],[1],[1,2,3]]) +-- +ok +== +SELECT list_position(1) +-- +ok +== +SELECT list_position(1,1) +-- +ok +== +SELECT list_position(i,1::{type}) from test0 +-- +error: Parser Error: syntax error at or near "{" +== +SELECT list_position([[1,2,3],[1]],[1]) +-- +ok +== +SELECT list_position([[1,2,3],[1]],[2]) +-- +ok +== +SELECT list_position([[1,2,3],[1]],[1,2,3]) +-- +ok +== +SELECT list_position([[1,3],[1]],[1,2,3]) +-- +ok +== +SELECT list_position([[1,3],[1], [1,2,3]],[1,2,3]) +-- +ok +== +SELECT list_position([[NULL],[1], [1,2,3]],NULL) +-- +ok +== +SELECT list_position([[NULL],[1], [1,2,3]],[NULL]) +-- +ok +== +SELECT list_position([[1,NULL],[1], [1,2,3]],[1,NULL]) +-- +ok +== +SELECT list_position([[1,NULL],[1], [1,2,3]],[0,NULL]) +-- +ok +== +SELECT list_position([NULL, [1], [1,2,3]], [NULL]) +-- +ok +== +SELECT list_position([{a: 1}, {a: 2}], {a: 2}) +-- +ok +== +SELECT list_position([{a: 1}, {a: 2}], {a: 3}) +-- +ok +== +SELECT list_position([{a: 1, b: 3}, {a: 2, b: 2}], {a: 2, b: 2}) +-- +ok +== +SELECT list_position([{a: 1, b: 3}, {a: 2, b: 2}], {a: 1, b: 2}) +-- +ok +== +SELECT list_position([MAP([1], [2])], MAP([1], [2])) +-- +ok +== +SELECT list_position([MAP([1], [2])], MAP([1], [3])) +-- +ok +== +SELECT list_position([MAP([1], [2]), NULL], NULL) +-- +ok +== +SELECT list_position([MAP([1], [2]), NULL], MAP([1], [2])) +-- +ok +== +SELECT list_position([[1,2,3],NULL],NULL) +-- +ok +== +CREATE TABLE test0 (i int[][], j int[]); +-- +ok +== +INSERT INTO test0 VALUES ([[2,1,3],[1,2]], [1, 2]), ([[2,3,4],[1,2]], [1, 3]), ([[1]], NULL), ([[1, NULL, 2], [NULL]], [NULL]); +-- +ok +== +SELECT i, j, list_position(i,j) from test0 +-- +ok +== +DROP TABLE test0; +-- +ok +== +SELECT list_position(i,1.0) from test0 +-- +ok +== +CREATE TABLE test0 (i {type}[], j {type}) +-- +error: Parser Error: syntax error at or near "{" +== +INSERT INTO test0 VALUES ([2.0,1.0,3.0], 2.0), ([2.0,3.0,4.0], 5.0), ([1.0], NULL), ([1.0, NULL, 2.0], NULL); +-- +ok +== diff --git a/parser/testdata/corpus/sql/function/list/list_position_nan.test b/parser/testdata/corpus/sql/function/list/list_position_nan.test new file mode 100644 index 0000000..a15dc6d --- /dev/null +++ b/parser/testdata/corpus/sql/function/list/list_position_nan.test @@ -0,0 +1,21 @@ +# source: test/sql/function/list/list_position_nan.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +SELECT list_position(['NaN'::DOUBLE], 'NaN'::DOUBLE) +-- +ok +== +SELECT list_position([NULL, 0, 'NaN'::DOUBLE], 'NaN'::DOUBLE) +-- +ok +== +SELECT list_contains([NULL, 0, 'NaN'::DOUBLE], 'NaN'::DOUBLE) +-- +ok +== +SELECT list_position([[[NULL, 42]]], [[NULL, 42]]) +-- +ok +== diff --git a/parser/testdata/corpus/sql/function/list/list_resize.test b/parser/testdata/corpus/sql/function/list/list_resize.test new file mode 100644 index 0000000..97f3bb4 --- /dev/null +++ b/parser/testdata/corpus/sql/function/list/list_resize.test @@ -0,0 +1,265 @@ +# source: test/sql/function/list/list_resize.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +SELECT list_resize([1, 2, 4], 2); +-- +ok +== +create table tbl(a int[], b int); +-- +ok +== +insert into tbl values ([5,4,3], 3); +-- +ok +== +insert into tbl values ([1,2,3], 5); +-- +ok +== +insert into tbl values (NULL, 8); +-- +ok +== +insert into tbl values ([10,11,12], 2); +-- +ok +== +select list_resize(a, b) from tbl; +-- +ok +== +SELECT list_resize([], 2); +-- +ok +== +create table string_tbl(a string[], b int); +-- +ok +== +insert into string_tbl values (['abc', 'def'], 3); +-- +ok +== +insert into string_tbl values (['d', 'ef', 'ghij'], 8); +-- +ok +== +insert into string_tbl values (['lmnopqrs'], 5); +-- +ok +== +insert into string_tbl values (['here is a little story about a duck,', 'whose name is harold.', 'He is a cool duck who lives in a cool world'], 5); +-- +ok +== +select list_resize(a, b) from string_tbl; +-- +ok +== +SELECT list_resize(NULL, 1, 1); +-- +ok +== +SELECT list_resize(NULL, 2, NULL); +-- +ok +== +SELECT list_resize(NULL, NULL, NULL); +-- +ok +== +SELECT list_resize([1,2,3], NULL); +-- +ok +== +CREATE TABLE nulls(l INT[], b INT); +-- +ok +== +INSERT INTO nulls VALUES ([1, 2, 3], 2), (NULL, 6), ([], 4), ([NULL, NULL, 5, 6, NULL], 6); +-- +ok +== +SELECT list_resize(l, b) FROM nulls; +-- +ok +== +select * from (SELECT list_resize(NULL, 1, 1)) +-- +ok +== +SELECT list_resize([[1], [1, 2], NULL, [NULL], [], [1, 2, 3]], 3) +-- +ok +== +create table list_tbl(a int[][], b int); +-- +ok +== +insert into list_tbl values ([[1, 2, 3], [4, 5, 6]], 3); +-- +ok +== +insert into list_tbl values ([[7, 8, 9], [10, NULL, 6], [9, 8, 7]], 5); +-- +ok +== +insert into list_tbl values ([[1, 2, 3], NULL, [4, 5, 6]], 2); +-- +ok +== +select list_resize(a, b) from list_tbl; +-- +ok +== +select list_resize([{'i': 1,'j': 2}, NULL, {'i': 3, 'j': 4}], 2); +-- +ok +== +select list_resize([{'i': 1,'j': [2, 3]}, NULL, {'i': 1, 'j': [2, 3]}], 4); +-- +ok +== +select list_resize([{'i': 1,'j': [{'a': 1, 'b': 2}, {'a': 3, 'b': 4}]}, NULL, {'i': 1, 'j': [{'a': 1, 'b': 2}, {'a': 3, 'b': 4}]}], 4); +-- +ok +== +select list_resize([{'i': 1,'j': [{'a': 1, 'b': [2, 3]}, {'a': 3, 'b': [4, 5]}]}, NULL, {'i': 1, 'j': [{'a': 1, 'b': [2, 3]}, {'a': 3, 'b': [4, 5]}]}], 4); +-- +ok +== +select list_resize([[[1, 2, 3], [4, 5, 6]], [[ 7, 8, 9 ]], [[10, 11, 12], [13, 14, 15]]], 2); +-- +ok +== +select list_resize([[[1, 2, 3], [4, 5, 6]], [[ 7, 8, 9 ], NULL], NULL, [NULL], [[10, 11, 12], [13, 14, 15]]], 8); +-- +ok +== +select list_resize([1, 2, 3], len(list_resize([1, 2, 3], 2))); +-- +ok +== +select list_resize(list_filter([1, 2, 3, 4, 5, 6], lambda x: x > 1), 4); +-- +ok +== +SELECT list_resize([1, 2], 3, 4) +-- +ok +== +CREATE TABLE def(tbl INT[], b INT, d INT); +-- +ok +== +INSERT INTO def VALUES ([1, 2, 3], 5, 4), ([4, 5, 6], 6, NULL), ([7, 8, NULL], 3, 10); +-- +ok +== +SELECT list_resize(tbl, b, d) FROM def; +-- +ok +== +SELECT list_resize([1, 2], 3, NULL); +-- +ok +== +select list_resize([{'i': 1,'j': [2, 3]}, NULL, {'i': 1, 'j': [2, 3]}], 4, {'i': 5, 'j': [10, 10]}); +-- +ok +== +select list_resize([{'i': 1,'j': [2, 3]}, NULL, {'i': 1, 'j': [2, 3]}], 6, NULL); +-- +ok +== +SELECT list_resize(range(10000), 4000); +-- +ok +== +SELECT list_resize([1, 2, 3], 4000); +-- +ok +== +CREATE TABLE bool_table(a bool[], b int); +-- +ok +== +INSERT INTO bool_table VALUES ([true, false, true], 1); +-- +ok +== +INSERT INTO bool_table VALUES ([false, true, false], 2); +-- +ok +== +INSERT INTO bool_table VALUES ([true, true, NULL], 3); +-- +ok +== +SELECT list_resize(a, b) FROM bool_table; +-- +ok +== +SELECT list_resize([true], 2); +-- +ok +== +SELECT list_resize([false], 2); +-- +ok +== +SELECT list_resize([NULL], 2); +-- +ok +== +prepare q1 as select list_resize(?, ?); +-- +ok +== +prepare q2 as select array_resize(?, ?); +-- +ok +== +execute {q}([1, 2, 3], 4); +-- +error: Parser Error: syntax error at or near "{" +== +execute {q}([1, 2, 3], 2); +-- +error: Parser Error: syntax error at or near "{" +== +execute {q}([1, 2, 3], 0); +-- +error: Parser Error: syntax error at or near "{" +== +execute {q}([1, 2, 3], NULL); +-- +error: Parser Error: syntax error at or near "{" +== +execute {q}([1, 2, 3], 1.4); +-- +error: Parser Error: syntax error at or near "{" +== +execute {q}([2], 2::TINYINT); +-- +error: Parser Error: syntax error at or near "{" +== +execute {q}([1, 2, 3], -1); +-- +error: Parser Error: syntax error at or near "{" +== +SELECT LIST_RESIZE([1, 2, 3], 9999999999999999999); +-- +ok +== +SELECT LIST_RESIZE([1, 2, 3], 4000999999999999999) +-- +ok +== +SELECT list_resize([1, 2, 3]::BIGINT[], 5, 42); +-- +ok +== diff --git a/parser/testdata/corpus/sql/function/list/list_resize_error.test b/parser/testdata/corpus/sql/function/list/list_resize_error.test new file mode 100644 index 0000000..4dae98c --- /dev/null +++ b/parser/testdata/corpus/sql/function/list/list_resize_error.test @@ -0,0 +1,45 @@ +# source: test/sql/function/list/list_resize_error.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +execute {q}([1, 2, 3], 'a'); +-- +error: Parser Error: syntax error at or near "{" +== +execute {q}('cici n est pas een list', 2); +-- +error: Parser Error: syntax error at or near "{" +== +execute {q}([1, 2, 3], 'huh'); +-- +error: Parser Error: syntax error at or near "{" +== +execute {q}(); +-- +error: Parser Error: syntax error at or near "{" +== +execute {q}([1, 2, 3]); +-- +error: Parser Error: syntax error at or near "{" +== +prepare q3 as select list_resize(?, ?, ?); +-- +ok +== +prepare q4 as select array_resize(?, ?, ?); +-- +ok +== +execute {q}([1, 2, 3], 5, 'abc'); +-- +error: Parser Error: syntax error at or near "{" +== +execute {q}([1, 2, 3], 2, 3, 4); +-- +error: Parser Error: syntax error at or near "{" +== +execute {q}([1, 2, 3], 1, [1, 2, 3]); +-- +error: Parser Error: syntax error at or near "{" +== diff --git a/parser/testdata/corpus/sql/function/list/list_reverse.test b/parser/testdata/corpus/sql/function/list/list_reverse.test new file mode 100644 index 0000000..0ea9a38 --- /dev/null +++ b/parser/testdata/corpus/sql/function/list/list_reverse.test @@ -0,0 +1,205 @@ +# source: test/sql/function/list/list_reverse.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +SELECT list_reverse(NULL); +-- +ok +== +SELECT list_reverse([]); +-- +ok +== +SELECT list_reverse([NULL]); +-- +ok +== +SELECT list_reverse([1, 42, 2]); +-- +ok +== +SELECT array_reverse([1, 42, 2]); +-- +ok +== +SELECT list_reverse([1, 42, NULL, 2]); +-- +ok +== +SELECT list_reverse(list_reverse([1, 3, 3, 42, 117, 69, NULL])); +-- +ok +== +SELECT list_reverse ([[1, 2 ,42], [3, 4]]); +-- +ok +== +prepare q1 as select list_reverse(?); +execute q1([5, 42, 3]); +-- +ok +== +create or replace table tbl_big as select range(5000) as list; +-- +ok +== +select list_sort((list), 'desc') == list_reverse(list) from tbl_big; +-- +ok +== +CREATE TABLE tbl (id INTEGER, list INTEGER[]); +-- +ok +== +INSERT INTO tbl VALUES (1, [NULL, 3, 117, 42, 1]), (2, NULL), (3, [1, 8, 9]), (4, NULL), (5, NULL), (6, [NULL]); +-- +ok +== +SELECT id, list_reverse(list) FROM tbl ORDER BY id; +-- +ok +== +CREATE TABLE tbl2 (id INTEGER, list INTEGER[]); +-- +ok +== +INSERT INTO tbl2 VALUES (1, [1, 2, 3]), (1, [4, 5, 6]), (3, [7, 8, 9]); +-- +ok +== +SELECT id, list_reverse(list) FROM tbl2 ORDER BY id; +-- +ok +== +select list_reverse(list_reverse(columns(['int_array', 'varchar_array', 'nested_int_array', 'array_of_structs', 'timestamp_array', 'double_array', 'date_array', 'timestamptz_array']))) + IS NOT DISTINCT FROM + columns(['int_array', 'varchar_array', 'nested_int_array', 'array_of_structs', 'timestamp_array', 'double_array', 'date_array', 'timestamptz_array']) +from test_all_types(); +-- +ok +== +select list_reverse(test_vector) from test_vector_types(null::int[], false); +-- +ok +== +select list_reverse(test_vector) from test_vector_types(null::int[], true); +-- +ok +== +select true from test_vector_types(null::int[], false); +-- +ok +== +select list_sort((list), 'desc') IS NOT DISTINCT FROM list +from (select list_reverse(test_vector) as list from test_vector_types(null::int[], false)); +-- +ok +== +select list_sort((list), 'desc') IS NOT DISTINCT FROM list +from (select list_reverse(test_vector) as list from test_vector_types(null::int[], true)); +-- +ok +== +SELECT list_reverse() +-- +ok +== +SELECT list_reverse(42) +-- +ok +== +SELECT list_reverse ([1, 3, 2, 42, 117,, NULL]) +-- +error: Parser Error: syntax error at or near "," +== +CREATE TABLE palindromes (s VARCHAR); +-- +ok +== +INSERT INTO palindromes VALUES ('racecar'), ('civic'), ('defied'), ('repaper'), ('kayak'), ('rotator'), ('tattarrattat'), ('saippuakivikauppias'), ('malayalam'); +-- +ok +== +SELECT list_aggr(list_reverse(str_split(s, '')), 'string_agg', '') FROM palindromes ORDER BY s; +-- +ok +== +DROP TABLE palindromes; +-- +ok +== +WITH example AS ( + SELECT [1, 2, 3] AS arr UNION ALL + SELECT [4, 5] AS arr UNION ALL + SELECT [] AS arr +) +SELECT + list_reverse(arr) AS reverse_arr +FROM example ORDER BY length(reverse_arr) DESC; +-- +ok +== +SELECT list_reverse(*) +-- +ok +== +SELECT list_reverse([1, 2], 2) +-- +ok +== +SELECT list_reverse([1, 42, 39, 58]) +-- +ok +== +SELECT list_reverse([1, NULL, 42, 39, NULL, 58]) +-- +ok +== +SELECT list_reverse([1, 42, -39, 58, -1, 18]) +-- +ok +== +SELECT list_reverse(list_reverse([11, -100, 678])) +-- +ok +== +CREATE OR REPLACE TABLE integers AS SELECT LIST(i) AS i FROM range(1, 10, 1) t1(i) +-- +ok +== +SELECT list_reverse(i) FROM integers +-- +ok +== +SELECT (i).list_reverse() FROM integers +-- +ok +== +SELECT list_reverse([[1], [1, 2], NULL, [NULL], [], [1, 2, 3]]) +-- +ok +== +SELECT ([[1], [1, 2], NULL, [NULL], [], [1, 2, 3]]).list_reverse() +-- +ok +== +CREATE OR REPLACE TABLE lists AS SELECT range % 4 g, list(range) l FROM range(10000) GROUP BY range % 4; +-- +ok +== +with cte0 as ( + select g, list_reverse(l) l from lists +), cte1 as ( + select g, unnest(l) i from cte0 +), cte2 as ( + select g, i, lead(g, 1) over () lg, lead(i, 1) over () li from cte1 +) +select count(*) +from cte2 +where g = lg + and lg not null + and li > i +-- +ok +== diff --git a/parser/testdata/corpus/sql/function/list/list_sort_having.test b/parser/testdata/corpus/sql/function/list/list_sort_having.test new file mode 100644 index 0000000..abdb4c7 --- /dev/null +++ b/parser/testdata/corpus/sql/function/list/list_sort_having.test @@ -0,0 +1,49 @@ +# source: test/sql/function/list/list_sort_having.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +create or replace table test1 as ( + select 'new_customers' as child, 'dim_model_7' as parent + union all select 'exposure_1' as child, 'dim_model_7' as parent + union all select 'exposure_1' as child, 'exposure_1' as parent + union all select 'fct_model_6' as child, 'fct_model_6' as parent + union all select 'exposure_1' as child, 'fct_model_6' as parent + union all select 'report_1' as child, 'fct_model_6' as parent + union all select 'report_2' as child, 'fct_model_6' as parent + union all select 'report_3' as child, 'fct_model_6' as parent + union all select 'fct_model_9' as child, 'fct_model_9' as parent + union all select 'stg_model_5' as child, 'fct_model_9' as parent + union all select 'int_model_4' as child, 'int_model_4' as parent + union all select 'int_model_5' as child, 'int_model_4' as parent + union all select 'dim_model_7' as child, 'int_model_4' as parent + union all select 'new_customers' as child, 'int_model_4' as parent + union all select 'exposure_1' as child, 'int_model_4' as parent + union all select 'int_model_5' as child, 'int_model_5' as parent + union all select 'dim_model_7' as child, 'int_model_5' as parent + union all select 'new_customers' as child, 'int_model_5' as parent + union all select 'exposure_1' as child, 'int_model_5' as parent + union all select 'model_8' as child, 'model_8' as parent + union all select 'new_customers' as child, 'new_customers' as parent + union all select 'report_1' as child, 'report_1' as parent + union all select 'report_2' as child, 'report_2' as parent + union all select 'report_3' as child, 'report_3' as parent +); +-- +ok +== +select + child, + count(*) as cnt, + list_sort( + list( + parent + ) + ) + as source_parents +from test1 +group by 1 +having cnt > 1; +-- +ok +== diff --git a/parser/testdata/corpus/sql/function/list/list_sort_vector_types.test b/parser/testdata/corpus/sql/function/list/list_sort_vector_types.test new file mode 100644 index 0000000..1f15951 --- /dev/null +++ b/parser/testdata/corpus/sql/function/list/list_sort_vector_types.test @@ -0,0 +1,21 @@ +# source: test/sql/function/list/list_sort_vector_types.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +SELECT list_sort(l) FROM test_vector_types(NULL::INT[], all_flat={flatten}) tbl(l) +-- +error: Parser Error: syntax error at or near "}" +== +SELECT list_sort(l) FROM test_vector_types(NULL::INT[][], all_flat={flatten}) tbl(l) +-- +error: Parser Error: syntax error at or near "}" +== +SELECT list_sort(l) FROM test_vector_types(NULL::VARCHAR[], all_flat={flatten}) tbl(l) +-- +error: Parser Error: syntax error at or near "}" +== +SELECT list_sort(l) FROM test_vector_types(NULL::VARCHAR[][], all_flat={flatten}) tbl(l) +-- +error: Parser Error: syntax error at or near "}" +== diff --git a/parser/testdata/corpus/sql/function/list/list_unique.test b/parser/testdata/corpus/sql/function/list/list_unique.test new file mode 100644 index 0000000..405900e --- /dev/null +++ b/parser/testdata/corpus/sql/function/list/list_unique.test @@ -0,0 +1,141 @@ +# source: test/sql/function/list/list_unique.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +SELECT list_unique(NULL) +-- +ok +== +SELECT list_unique([NULL]) +-- +ok +== +SELECT list_unique([]) +-- +ok +== +SELECT list_unique([]) WHERE 1 = 0 +-- +ok +== +SELECT list_unique() +-- +ok +== +SELECT list_unique(*) +-- +ok +== +SELECT list_unique([1, 2], 2) +-- +ok +== +SELECT list_unique(NULL::tinyint) +-- +ok +== +SELECT list_unique([1, 1, 2, 2, 2, 3]) +-- +ok +== +SELECT list_unique([1, 1, NULL, 2, 2, 2, 3, NULL, NULL]) +-- +ok +== +SELECT list_unique([1, 1, -5, 10, 10, 2]) +-- +ok +== +INSERT INTO integers VALUES ([1, 1, 2, 2, 2, 3]), ([1, NULL, 1, NULL]) +-- +ok +== +SELECT list_unique(l) FROM integers +-- +ok +== +SELECT array_unique([1, 2, 2, NULL]) +-- +ok +== +SELECT list_unique([True, True, False, NULL]) +-- +ok +== +SELECT list_unique([NULL::BOOLEAN]) +-- +ok +== +SELECT list_unique(['aa', 'aa', 'cd', NULL, '42']) +-- +ok +== +SELECT list_unique([NULL::VARCHAR]) +-- +ok +== +SELECT list_unique([1::{type}, NULL, 1::{type}]) +-- +error: Parser Error: syntax error at or near "{" +== +SELECT list_unique([NULL::{type}]) +-- +error: Parser Error: syntax error at or near "{" +== +SELECT list_unique([1::{type}]) +-- +error: Parser Error: syntax error at or near "{" +== +SELECT list_unique([1::{type}, 'nan'::{type}, 'nan'::{type}]); +-- +error: Parser Error: syntax error at or near "{" +== +SELECT list_unique(['2021-08-20'::DATE]) +-- +ok +== +SELECT list_unique(['14:59:37'::TIME]) +-- +ok +== +SELECT list_unique(['2021-08-20'::TIMESTAMP]) +-- +ok +== +SELECT list_unique(['2021-08-20'::TIMESTAMP_S]) +-- +ok +== +SELECT list_unique(['2021-08-20 00:00:00.123'::TIMESTAMP_MS]) +-- +ok +== +SELECT list_unique(['2021-08-20 00:00:00.123456'::TIMESTAMP_NS]) +-- +ok +== +SELECT list_unique(['14:59:37'::TIMETZ]) +-- +ok +== +SELECT list_unique(['2021-08-20'::TIMESTAMPTZ]) +-- +ok +== +SELECT list_unique([INTERVAL 1 YEAR]) +-- +ok +== +SELECT list_unique(e) FROM enums +-- +ok +== +SELECT list_unique(['a', 'b、c', 'a']) +-- +ok +== +select list_unique([1,2,3]::INT[3]); +-- +ok +== diff --git a/parser/testdata/corpus/sql/function/list/list_value_arrays.test b/parser/testdata/corpus/sql/function/list/list_value_arrays.test new file mode 100644 index 0000000..bde4ede --- /dev/null +++ b/parser/testdata/corpus/sql/function/list/list_value_arrays.test @@ -0,0 +1,141 @@ +# source: test/sql/function/list/list_value_arrays.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +SELECT list_value([3, 2, 1]::INTEGER[3], [4, 5, 6]::INTEGER[3]); +-- +ok +== +SELECT list_value(['a', 'b', 'c']::VARCHAR[3], ['d', 'e', 'f']::VARCHAR[3]); +-- +ok +== +SELECT list_value([DATE '2022-01-01', DATE '2022-01-02']::DATE[2], [DATE '2022-01-03', DATE '2022-01-04']::DATE[2]); +-- +ok +== +SELECT list_value([1, 2]::INTEGER[2], [1.5, 2.5]::DOUBLE[2]); +-- +ok +== +SELECT list_value([1, 2]::INTEGER[2], [3, 4]::DOUBLE[2], [5, 6]::INTEGER[2]); +-- +ok +== +SELECT list_value([1.5, 2.5]::DOUBLE[2], [3, 4]::INTEGER[2], [5, 6]::INTEGER[2]); +-- +ok +== +SELECT list_value([1, 2]::INTEGER[2], [3, 4]::INTEGER[2], [5.6, 7.8]::DOUBLE[2]); +-- +ok +== +SELECT list_value([1, 2, 3]::INTEGER[3], NULL::INTEGER[3], [4, 5, 6]::INTEGER[3]); +-- +ok +== +SELECT list_value([1, NULL, 3]::INTEGER[3], [3, 2, 1]::INTEGER[3]); +-- +ok +== +SELECT list_value(['a', 'b', 'c']::VARCHAR[3], ['d', 'e', 'f']::VARCHAR[3], NULL::VARCHAR[3]); +-- +ok +== +SELECT list_value(['a', NULL, 'c']::VARCHAR[3], ['d', 'e', 'f']::VARCHAR[3]); +-- +ok +== +SELECT list_value([ROW(1, 'a'), ROW(2, 'b')]::ROW(i INTEGER, s VARCHAR)[], [ROW(3, 'c'), ROW(4, 'd')]::ROW(i INTEGER, s VARCHAR)[]); +-- +ok +== +SELECT list_value([[1, 2], [3, 4]]::INTEGER[][], [[5, 6], [7, 8]]::INTEGER[][]); +-- +ok +== +SELECT list_contains(list_value([1, 2]::INTEGER[2], [3, 4]::INTEGER[2]), [1, 2]::INTEGER[2]); +-- +ok +== +SELECT list_contains(list_value([1, 2]::INTEGER[2], [3, 4]::INTEGER[2]), [5, 6]::INTEGER[2]); +-- +ok +== +CREATE TABLE array_table (a INTEGER[3], b INTEGER[3], c INTEGER[3]); +-- +ok +== +INSERT INTO array_table VALUES ([1, 2, 3], [4, 5, 6], [7, 8, 9]); +-- +ok +== +INSERT INTO array_table VALUES ([10, 11, 12], NULL, [13, 14, 15]); +-- +ok +== +INSERT INTO array_table VALUES ([NULL, NULL, 16], NULL, [17, 18, 19]); +-- +ok +== +SELECT list_value(a, b, c) FROM array_table; +-- +ok +== +drop table array_table; +-- +ok +== +CREATE TABLE array_table (a STRING[3], b STRING[3], c STRING[3]); +-- +ok +== +INSERT INTO array_table VALUES (['a', 'b', 'c'], ['d', 'e', 'f'], ['g', 'h', 'i']); +-- +ok +== +INSERT INTO array_table VALUES (['j', 'k', 'l'], NULL, ['m', 'n', 'o']); +-- +ok +== +INSERT INTO array_table VALUES ([NULL, NULL, 'p'], NULL, ['q', 'r', 's']); +-- +ok +== +CREATE TABLE nested_array_table (a INTEGER[2][2], b INTEGER[2][2], c INTEGER[2][2]); +-- +ok +== +INSERT INTO nested_array_table VALUES ([[1, 2], [3, 4]], [[5, 6], [7, 8]], [NULL, [11, 12]]); +-- +ok +== +INSERT INTO nested_array_table VALUES ([[13, 14], [15, 16]], NULL, [[17, 18], [19, 20]]); +-- +ok +== +INSERT INTO nested_array_table VALUES ([[21, NULL], [23, 24]], [[25, 26], [27, 28]], NULL); +-- +ok +== +SELECT list_value(a, b, c) FROM nested_array_table; +-- +ok +== +SELECT list_value([1, 2]::INTEGER[2], [3, 4, 5]::INTEGER[3], [6]::INTEGER[1]); +-- +ok +== +CREATE TABLE mixed_array_table (a INTEGER[2], b VARCHAR[2], c DOUBLE[2]); +-- +ok +== +INSERT INTO mixed_array_table VALUES ([1, 2], ['a', 'b'], [1.5, 2.5]); +-- +ok +== +SELECT list_value(a, b, c) FROM mixed_array_table; +-- +ok +== diff --git a/parser/testdata/corpus/sql/function/list/list_value_nested_lists.test b/parser/testdata/corpus/sql/function/list/list_value_nested_lists.test new file mode 100644 index 0000000..8bc874a --- /dev/null +++ b/parser/testdata/corpus/sql/function/list/list_value_nested_lists.test @@ -0,0 +1,167 @@ +# source: test/sql/function/list/list_value_nested_lists.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +SELECT LIST_VALUE([1, 7], [2], [3]); +-- +ok +== +SELECT LIST_VALUE([1, 7], [2], [3], NULL); +-- +ok +== +SELECT LIST_VALUE([1, 7], [2], NULL, [3]); +-- +ok +== +SELECT LIST_VALUE([1, 7], [NULL], [2], [3]); +-- +ok +== +CREATE TABLE test_table (c1 INTEGER[], c2 INTEGER[], c3 INTEGER[]); +-- +ok +== +INSERT INTO test_table VALUES ([1, 1], [2, 2], [3]); +-- +ok +== +INSERT INTO test_table VALUES ([4], [5, 5, 5], [6, 6]); +-- +ok +== +INSERT INTO test_table VALUES ([7, 7, 7, 7], [8], [9, 9, 9]); +-- +ok +== +INSERT INTO test_table VALUES ([], [], []); +-- +ok +== +INSERT INTO test_table VALUES ([-1, -1, NULL], NULL, [-2, -2]); +-- +ok +== +SELECT LIST_VALUE(c1, c2, c3) FROM test_table; +-- +ok +== +SELECT LIST_VALUE([ROW(1, 1), ROW(2, 2)], [ROW(3, 3)]); +-- +ok +== +SELECT LIST_VALUE([ROW(1, 1), ROW(2, 2)], [ROW(3, 3), NULL]); +-- +ok +== +SELECT LIST_VALUE([ROW(1, 1), ROW(NULL, 2)], [NULL], [ROW(3, 3)]); +-- +ok +== +CREATE TABLE struct_table(a ROW(a INTEGER, b INTEGER)[], b ROW(a INTEGER, b INTEGER)[], c ROW(a INTEGER, b INTEGER)[]); +-- +ok +== +INSERT INTO STRUCT_TABLE VALUES ([ROW(1, 1), ROW(2, 2)], [ROW(3, 3), ROW(4, 4)], [ROW(5, 5), ROW(6, 6)]); +-- +ok +== +INSERT INTO STRUCT_TABLE VALUES ([ROW(7, 7), ROW(8, 8)], [ROW(9, 9)], [ROW(10, 10), ROW(11, 11), ROW(12, 12)]); +-- +ok +== +INSERT INTO STRUCT_TABLE VALUES ([ROW(13, 13)], [ROW(14, 14), ROW(15, 15), ROW(16, 16)], [ROW(17, 17), ROW(18, 18)]); +-- +ok +== +INSERT INTO STRUCT_TABLE VALUES ([NULL, ROW(20, 20)], NULL, [ROW(23, 23), ROW(24, 24), ROW(25, 25), ROW(26, 26)]); +-- +ok +== +SELECT LIST_VALUE([a, b], [c]) FROM struct_table; +-- +ok +== +SELECT LIST_VALUE(['a', 'a'], ['b', 'b', 'b'], ['c']); +-- +ok +== +SELECT LIST_VALUE(['a', 'a'], ['b', 'b', 'b'], ['c'], NULL); +-- +ok +== +SELECT LIST_VALUE(['a', 'a'], ['b', 'b', NULL], NULL, ['c']); +-- +ok +== +CREATE TABLE string_table(a VARCHAR[], b VARCHAR[], c VARCHAR[]); +-- +ok +== +INSERT INTO string_table VALUES (['a', 'a'], ['b', 'b', 'b'], ['c']); +-- +ok +== +INSERT INTO string_table VALUES (['d'], ['e', 'e', 'e', 'e'], ['f', 'f']); +-- +ok +== +INSERT INTO string_table VALUES (['g', 'g', 'g', 'g'], ['h'], ['i', 'i', 'i']); +-- +ok +== +INSERT INTO string_table VALUES (['j', 'j'], NULL, ['k', 'k', 'k']); +-- +ok +== +INSERT INTO string_table VALUES (['l', 'l', 'l'], ['m', 'm'], [NULL, 'n', 'n']); +-- +ok +== +SELECT LIST_VALUE(a, b, c) FROM string_table; +-- +ok +== +SELECT LIST_VALUE([[1, 1], [2]], [[3, 3], [4, 4, 4, 4], [5, 5]], [[6, 6]]); +-- +ok +== +SELECT LIST_VALUE([[1, 1], [2]], [[3, 3], [4, 4, 4, 4], [5, 5]], [[6, 6]], NULL); +-- +ok +== +SELECT LIST_VALUE([[1, 1], [2]], [[3, 3], [4, 4, NULL, 4], [5, 5]], NULL, [[6, 6]]); +-- +ok +== +CREATE TABLE nested_list_table(a INTEGER[][], b INTEGER[][], c INTEGER[][]); +-- +ok +== +INSERT INTO nested_list_table VALUES ([[1, 1, 1], [2]], [[3, 3], [4, 4, 4, 4], [5, 5]], [[6, 6]]); +-- +ok +== +INSERT INTO nested_list_table VALUES ([[7, 7], [8, 8, 8]], [[9]], [[10, 10], [11, 11, 11]]); +-- +ok +== +INSERT INTO nested_list_table VALUES ([[12, NULL]], [NULL, [13, 13, 13]], NULL); +-- +ok +== +SELECT LIST_VALUE(a, b, c) FROM nested_list_table; +-- +ok +== +SELECT LIST_VALUE([1, 1], ['a', 'a'], [ROW(2, 2), ROW(3, 3)]); +-- +ok +== +SELECT list_value([ARRAY_VALUE(1,2,3)], + [ARRAY_VALUE(4,5,6)], + [ARRAY_VALUE(7,8,9)]); +-- +ok +== diff --git a/parser/testdata/corpus/sql/function/list/list_value_structs.test b/parser/testdata/corpus/sql/function/list/list_value_structs.test new file mode 100644 index 0000000..1c828fb --- /dev/null +++ b/parser/testdata/corpus/sql/function/list/list_value_structs.test @@ -0,0 +1,99 @@ +# source: test/sql/function/list/list_value_structs.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +SELECT list_value({'a': 1, 'b': 'a'}, {'a': 2, 'b': 'b'}); +-- +ok +== +SELECT list_value(NULL, {'a': 1, 'b': 'a'}, {'a': 2, 'b': 'b'}); +-- +ok +== +SELECT list_value(NULL, {'a': 1, 'b': 'a'}, {'a': 2, 'b': 'b'}, NULL, {'a': 3, 'b': 'c'}); +-- +ok +== +SELECT list_value({'a': 1, 'b': 'a'}, {'a': 2, 'b': 'b'}, {'a': NULL, 'b': 'c'}); +-- +ok +== +CREATE TABLE tbl (s struct(a int, b varchar)); +-- +ok +== +INSERT INTO tbl VALUES ({'a': 1, 'b': 'hello'}), ({'a': 42, 'b': 'world'}); +-- +ok +== +SELECT list_value(s, s, s) AS res FROM tbl; +-- +ok +== +CREATE TABLE tbl (s1 struct(a int, b varchar), s2 struct(a int, b varchar), s3 struct(a int, b varchar)); +-- +ok +== +INSERT INTO tbl VALUES ({'a': 1, 'b': 'a'}, {'a': 2, 'b': 'b'}, {'a': 3, 'b': 'c'}); +-- +ok +== +INSERT INTO tbl VALUES ({'a': 4, 'b': 'd'}, NULL, {'a': 6, 'b': 'f'}); +-- +ok +== +INSERT INTO tbl VALUES ({'a': 7, 'b': 'g'}, {'a': 8, 'b': NULL}, {'a': 9, 'b': 'i'}); +-- +ok +== +INSERT INTO tbl VALUES (NULL, NULL, NULL); +-- +ok +== +INSERT INTO tbl VALUES (NULL, {'a': 10, 'b': 'j'}, NULL); +-- +ok +== +SELECT list_value(s1, s2, s3) AS res FROM tbl; +-- +ok +== +CREATE TABLE mixed_structs (s struct(a int[], b varchar, c int, d varchar[], e struct(a int, b varchar))); +-- +ok +== +INSERT INTO mixed_structs VALUES (ROW([1, 2, 3], 'a', 1, ['a', 'b'], ROW(1, 'a'))) +-- +ok +== +INSERT INTO mixed_structs VALUES (ROW([4, 5], NULL, 2, ['c', 'd'], ROW(2, NULL))) +-- +ok +== +INSERT INTO mixed_structs VALUES (NULL) +-- +ok +== +INSERT INTO mixed_structs VALUES (ROW(NULL, 'e', 3, ['e', 'f'], ROW(3, 'c'))) +-- +ok +== +INSERT INTO mixed_structs VALUES (ROW([7, 8], 'g', 4, ['g', 'h'], ROW(4, 'd'))) +-- +ok +== +INSERT INTO mixed_structs VALUES (ROW(NULL, NULL, 5, ['i', 'j'], ROW(5, 'e'))) +-- +ok +== +SELECT list_value(s, s, s, s) AS res FROM mixed_structs; +-- +ok +== +SELECT list_value(ROW(ARRAY_VALUE(1,2,3), ARRAY_VALUE('a','b','c')), + ROW(ARRAY_VALUE(4,5,6), ARRAY_VALUE('d','e','f')), + ROW(ARRAY_VALUE(7,8,9), ARRAY_VALUE('g','h','i'))); +-- +ok +== diff --git a/parser/testdata/corpus/sql/function/list/list_where.test b/parser/testdata/corpus/sql/function/list/list_where.test new file mode 100644 index 0000000..8f37afb --- /dev/null +++ b/parser/testdata/corpus/sql/function/list/list_where.test @@ -0,0 +1,161 @@ +# source: test/sql/function/list/list_where.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +CREATE TABLE integers (i int[]) +-- +ok +== +INSERT INTO integers VALUES ([1,2,3]), ([4,5,6]) +-- +ok +== +CREATE TABLE selections (j boolean[]) +-- +ok +== +INSERT INTO selections VALUES ([true, false, true]), ([false, true, false]) +-- +ok +== +SELECT list_where([0, 1, 2], [true, false, false]) +-- +ok +== +SELECT list_where(i, [true, false, true]) FROM integers +-- +ok +== +SELECT list_where(i, j) FROM integers, selections order by all +-- +ok +== +SELECT list_where([1,2,3], [True, NULL, FALSE]); +-- +ok +== +SELECT list_where([1,2,3], [True, True, False, False]); +-- +ok +== +SELECT list_where([1,2,3], [True, False]); +-- +ok +== +CREATE TABLE lists AS SELECT range % 4 g, list(range) l FROM range(10000) GROUP BY range % 4; +-- +ok +== +CREATE TABLE bools AS SELECT range % 4 a, list((range % 2):: bool) s FROM range(10000) GROUP BY range % 4; +-- +ok +== +select g, list_where(l, s) l from lists, bools +-- +ok +== +SELECT list_where([true, false, NULL, true, true, NULL], [true, false, true, true, true, true]) +-- +ok +== +SELECT list_where([NULL::BOOLEAN], [true]) +-- +ok +== +SELECT list_where(['aa', 'a', 'cd', NULL, '42'], [true, true, false, false, false]) +-- +ok +== +SELECT list_where([NULL::VARCHAR], [true]) +-- +ok +== +SELECT list_where([1::{type}, NULL, 2::{type}], [true, true, true]) +-- +error: Parser Error: syntax error at or near "{" +== +SELECT list_where([NULL::{type}], [true]) +-- +error: Parser Error: syntax error at or near "{" +== +SELECT list_where([1::{type}], [true]) +-- +error: Parser Error: syntax error at or near "{" +== +SELECT list_where(['2021-08-20'::DATE], [true]) +-- +ok +== +SELECT list_where(['14:59:37'::TIME], [true]) +-- +ok +== +SELECT list_where(['2021-08-20'::TIMESTAMP], [true]) +-- +ok +== +SELECT list_where(['2021-08-20'::TIMESTAMP_S], [true]) +-- +ok +== +SELECT list_where(['2021-08-20 00:00:00.123'::TIMESTAMP_MS], [true]) +-- +ok +== +SELECT list_where(['2021-08-20 00:00:00.123456'::TIMESTAMP_NS], [true]) +-- +ok +== +SELECT list_where(['14:59:37'::TIMETZ], [true]) +-- +ok +== +SELECT list_where(['2021-08-20'::TIMESTAMPTZ], [true]) +-- +ok +== +SELECT list_where([INTERVAL 1 YEAR], [true]) +-- +ok +== +SELECT list_where(['{a: 1}'::BLOB, '{a: 3}'::BLOB], [true, false]) +-- +ok +== +SELECT list_where([NULL::BLOB], [true]) +-- +ok +== +INSERT INTO enums VALUES (['happy', 'sad']) +-- +ok +== +SELECT list_where(e, [false, true]) FROM enums +-- +ok +== +SELECT list_where([[1], [1, 2], NULL, [NULL], [], [1, 2, 3]], [true, false, false, true, true, false]) +-- +ok +== +SELECT list_where([{'a': 1}, {'a': 5}, {'a': 3}], [true, true, true]) +-- +ok +== +SELECT list_where([1,2,3]::INT[3], [true, false, true]::BOOLEAN[3]); +-- +ok +== +SELECT LIST_WHERE(ARRAY_VALUE('1', NULL), [TRUE, TRUE, TRUE]); +-- +ok +== +SELECT LIST_WHERE(ARRAY_VALUE('1', NULL), [TRUE, TRUE, FALSE]); +-- +ok +== +SELECT length(list_where([1], (SELECT list(true) FROM range(4096)))); +-- +ok +== diff --git a/parser/testdata/corpus/sql/function/list/list_zip.test b/parser/testdata/corpus/sql/function/list/list_zip.test new file mode 100644 index 0000000..13adebe --- /dev/null +++ b/parser/testdata/corpus/sql/function/list/list_zip.test @@ -0,0 +1,233 @@ +# source: test/sql/function/list/list_zip.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +CREATE TABLE bools (b bool) +-- +ok +== +INSERT INTO bools VALUES (false), (true) +-- +ok +== +CREATE TABLE integers2 (j int[]) +-- +ok +== +INSERT INTO integers2 VALUES ([]), (NULL) +-- +ok +== +SELECT list_zip([1,2,3]) +-- +ok +== +SELECT list_zip([1,2,3], [2,3,4], [3,4,5], []); +-- +ok +== +SELECT list_zip([1,2,3], [1,2,3]) +-- +ok +== +SELECT list_zip([1,2,3], [1,2]) +-- +ok +== +SELECT list_zip([1, 2, 3]::int[3], [1, 2]::int[2], true) +-- +ok +== +SELECT list_zip([1, 2, 3]::int[3], [1, 2, 3]::int[3]) +-- +ok +== +SELECT list_zip([1, '2', 3]::int[], [1, 2, 3]::int[3]) +-- +ok +== +SELECT list_zip([1,2], [1,2,3]) +-- +ok +== +SELECT list_zip([1,2,3], NULL) +-- +ok +== +SELECT list_zip([1,2,3], []) +-- +ok +== +SELECT list_zip([1,2,3], NULL, true) +-- +ok +== +SELECT list_zip([1,2,3], [], true) +-- +ok +== +SELECT list_zip([1,2,3], [2,3,4], [3,4,5], [], true); +-- +ok +== +SELECT list_zip(a.i, b.i) as zipped_list FROM integers AS a, integers as b order by all; +-- +ok +== +SELECT list_zip(a.i, b.i, b.i) FROM integers AS a, integers AS b order by all +-- +ok +== +SELECT list_zip([1,2,3], true) +-- +ok +== +SELECT list_zip([1,2,3], [1,2,3], true) +-- +ok +== +SELECT list_zip([1,2,3], [1,2], true) +-- +ok +== +SELECT list_zip([1,2], [1,2,3], true) +-- +ok +== +SELECT list_zip(i, j, b) FROM integers, integers2, bools order by all desc +-- +ok +== +select g, list_zip(l, b) l from lists, bools +-- +ok +== +SELECT list_zip([1,2,3], [true, false, NULL], [{'list_1': 1}, {'list_1': 2}, {'list_1': 3}], ['a', 'b', 'c'], ['2021-08-20'::DATE, '2021-08-21'::DATE, '2021-08-22'::DATE], [1.0, 2.0, 3.0], [NULL, NULL, NULL]) +-- +ok +== +SELECT list_zip([true, false, NULL]) +-- +ok +== +SELECT list_zip([NULL::BOOLEAN, true]) +-- +ok +== +SELECT list_zip(['aa', 'a']) +-- +ok +== +SELECT list_zip([NULL::VARCHAR]) +-- +ok +== +SELECT list_zip([1::{type}, NULL, 2::{type}]) +-- +error: Parser Error: syntax error at or near "{" +== +SELECT list_zip([NULL::{type}]) +-- +error: Parser Error: syntax error at or near "{" +== +SELECT list_zip([1::{type}]) +-- +error: Parser Error: syntax error at or near "{" +== +SELECT list_zip(['2021-08-20'::DATE]) +-- +ok +== +SELECT list_zip(['14:59:37'::TIME]) a, a::VARCHAR::STRUCT("time" TIME)[] b, a == b +-- +ok +== +SELECT list_zip(['2021-08-20'::TIMESTAMP]) +-- +ok +== +SELECT list_zip(['2021-08-20'::TIMESTAMP_S]) +-- +ok +== +SELECT list_zip(['2021-08-20 00:00:00.123'::TIMESTAMP_MS]) +-- +ok +== +SELECT list_zip(['2021-08-20 00:00:00.123456'::TIMESTAMP_NS]) +-- +ok +== +SELECT list_zip(['14:59:37'::TIMETZ]) +-- +ok +== +SELECT list_zip(['2021-08-20'::TIMESTAMPTZ]) +-- +ok +== +SELECT list_zip([INTERVAL 1 YEAR]) +-- +ok +== +SELECT list_zip(['{a: 1}'::BLOB, '{a: 3}'::BLOB]) +-- +ok +== +SELECT list_zip(['{a: 1'::BLOB, '{a: 3'::BLOB]) a, a::VARCHAR::STRUCT(a BLOB)[] b, a == b +-- +ok +== +SELECT list_zip([NULL::BLOB]) +-- +ok +== +SELECT list_zip(e) FROM enums +-- +ok +== +SELECT list_zip([[1], [1, 2], NULL]) +-- +ok +== +SELECT list_zip([{'a': 1}, {'a': 5}, {'a': 3}]) +-- +ok +== +SELECT list_zip([{'a': 1}]::STRUCT(a INT)[], []::STRUCT(a INT)[]) +-- +ok +== +SELECT list_zip([{'a': 1}]::STRUCT(a INT)[], NULL::STRUCT(a INT)[]) +-- +ok +== +SELECT list_zip(CAST(['123'] AS VARIANT[]), CAST([] AS VARIANT[])) +-- +ok +== +SELECT list_zip(CAST(['123'] AS VARIANT[]), NULL::VARIANT[]) +-- +ok +== +SELECT MAP_FROM_ENTRIES(LIST_ZIP(CAST(['123'] AS VARIANT[]), CAST([] AS VARIANT[]))) +-- +ok +== +SELECT list_zip('') +-- +ok +== +SELECT list_zip(3, 4) +-- +ok +== +SELECT list_zip(FALSE) +-- +ok +== +SELECT list_zip(TRUE) +-- +ok +== diff --git a/parser/testdata/corpus/sql/function/list/repeat_list.test b/parser/testdata/corpus/sql/function/list/repeat_list.test new file mode 100644 index 0000000..962eba9 --- /dev/null +++ b/parser/testdata/corpus/sql/function/list/repeat_list.test @@ -0,0 +1,57 @@ +# source: test/sql/function/list/repeat_list.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +SELECT repeat([1], 10); +-- +ok +== +SELECT repeat([{'x': 1}], 5); +-- +ok +== +SELECT repeat([[1]], 10); +-- +ok +== +SELECT repeat([1, 2], 5); +-- +ok +== +SELECT repeat([[[], [], [NULL], NULL]], 3); +-- +ok +== +SELECT repeat(['hello', 'thisisalongstring'], 5); +-- +ok +== +SELECT repeat([], 10); +-- +ok +== +SELECT repeat([], -1); +-- +ok +== +SELECT repeat(NULL::INT[], 10); +-- +ok +== +SELECT repeat(repeat([1], 50), 50) = repeat([1], 2500); +-- +ok +== +SELECT REPEAT(c,2) FROM TEST_VECTOR_TYPES(CAST(NULL AS INT[])) AS t(c) +-- +ok +== +SELECT repeat([1], 99999999999999999); +-- +ok +== +SELECT repeat([1, 2, 3], 6148914691236517206); +-- +ok +== diff --git a/parser/testdata/corpus/sql/function/list/test_lambda_with_struct_aliases.test b/parser/testdata/corpus/sql/function/list/test_lambda_with_struct_aliases.test new file mode 100644 index 0000000..61b7a95 --- /dev/null +++ b/parser/testdata/corpus/sql/function/list/test_lambda_with_struct_aliases.test @@ -0,0 +1,46 @@ +# source: test/sql/function/list/test_lambda_with_struct_aliases.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +SELECT COALESCE(*COLUMNS(lambda c: {'title': c}.title IN ('a', 'c'))) +FROM (SELECT NULL, 2, 3) t(a, b, c); +-- +ok +== +CREATE TABLE addresses (i INT, b INT); +-- +ok +== +INSERT INTO addresses VALUES (1, 10), (2, 20), (1, 52), (3, 7); +-- +ok +== +SELECT i, sum(b) FROM addresses +GROUP BY i +HAVING sum(b) >= list_sum(list_transform([20], lambda x: {'title': x}.title + 30)) +-- +ok +== +SELECT list_transform([10], lambda x: sum(1) + {'title': x}.title) +-- +ok +== +CREATE TABLE test (a VARCHAR[]); +-- +ok +== +INSERT INTO test VALUES (NULL), ([]), (['asdf']), (['qwer', 'CXZASDF']); +-- +ok +== +ALTER TABLE test +ALTER COLUMN a TYPE STRUCT(title VARCHAR)[] +USING (list_transform(a, lambda x: {'title': x})); +-- +ok +== +SELECT a FROM test ORDER BY ALL; +-- +ok +== diff --git a/parser/testdata/corpus/sql/function/nested/array_extract_unnamed_struct.test b/parser/testdata/corpus/sql/function/nested/array_extract_unnamed_struct.test new file mode 100644 index 0000000..00650f2 --- /dev/null +++ b/parser/testdata/corpus/sql/function/nested/array_extract_unnamed_struct.test @@ -0,0 +1,41 @@ +# source: test/sql/function/nested/array_extract_unnamed_struct.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +SELECT (ROW(42, 84))['element'] +-- +ok +== +SELECT (ROW(42, 84))[1] +-- +ok +== +SELECT (ROW(42, 84))[2] +-- +ok +== +SELECT UNNEST(ROW(42, 84)) +-- +ok +== +SELECT (ROW(42, 84))[0] +-- +ok +== +SELECT (ROW(42, 84))[9999] +-- +ok +== +SELECT (ROW(42, 84))[-1] +-- +ok +== +SELECT (ROW(42, 84))[9223372036854775807] +-- +ok +== +SELECT (ROW(42, 84))[(-9223372036854775808)::BIGINT] +-- +ok +== diff --git a/parser/testdata/corpus/sql/function/nested/test_issue_5437.test b/parser/testdata/corpus/sql/function/nested/test_issue_5437.test new file mode 100644 index 0000000..f772a4d --- /dev/null +++ b/parser/testdata/corpus/sql/function/nested/test_issue_5437.test @@ -0,0 +1,13 @@ +# source: test/sql/function/nested/test_issue_5437.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +with data as ( +select * from (VALUES ('Amsterdam', {'x': 1, 'y': 2, 'z': 3}), ('London', {'x': 4, 'y': 5, 'z': 6})) Cities(Name, Id) +) +select *, struct_insert(Id, d := 4) +from data +-- +ok +== diff --git a/parser/testdata/corpus/sql/function/nested/test_struct_insert.test b/parser/testdata/corpus/sql/function/nested/test_struct_insert.test new file mode 100644 index 0000000..80439f1 --- /dev/null +++ b/parser/testdata/corpus/sql/function/nested/test_struct_insert.test @@ -0,0 +1,46 @@ +# source: test/sql/function/nested/test_struct_insert.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +SELECT struct_insert ({a: 1, b: 2}, c := 3); +-- +ok +== +WITH data AS (SELECT 1 AS a, 2 AS b, 3 AS c) +SELECT struct_insert (data, d := 4) FROM data; +-- +ok +== +SELECT struct_insert({'a': 1, 'b': 'abc', 'c': true}, d := {'a': 'new stuff'}); +-- +ok +== +SELECT struct_insert(); +-- +ok +== +SELECT struct_insert({a: 1, b: 2}); +-- +ok +== +SELECT struct_insert(123, a := 1); +-- +ok +== +SELECT struct_insert({a: 1, b: 2}, a := 2); +-- +ok +== +INSERT INTO tbl SELECT {'i': range} FROM range(3); +-- +ok +== +SELECT struct_insert(col, a := col.i + 1, b := NULL::VARCHAR) FROM tbl ORDER BY ALL; +-- +ok +== +SELECT struct_insert(col, a := NULL, b := NULL::VARCHAR, c := [NULL]) FROM tbl ORDER BY ALL; +-- +ok +== diff --git a/parser/testdata/corpus/sql/function/nested/test_struct_update.test b/parser/testdata/corpus/sql/function/nested/test_struct_update.test new file mode 100644 index 0000000..33ba567 --- /dev/null +++ b/parser/testdata/corpus/sql/function/nested/test_struct_update.test @@ -0,0 +1,78 @@ +# source: test/sql/function/nested/test_struct_update.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +SELECT struct_update ({a: 1, b: 2}, c := 3); +-- +ok +== +WITH data AS (SELECT 1 AS a, 2 AS b, 3 AS c) +SELECT struct_update (data, d := 4) FROM data; +-- +ok +== +SELECT struct_update({'a': 1, 'b': 'abc', 'c': true}, d := {'a': 'new stuff'}); +-- +ok +== +SELECT struct_update(); +-- +ok +== +SELECT struct_update({a: 1, b: 2}); +-- +ok +== +SELECT struct_update(123, a := 1); +-- +ok +== +SELECT struct_update({a: 1, b: 2}, a := 2, a := 3); +-- +ok +== +SELECT struct_update({a: 1, b: 2}, a := 3); +-- +ok +== +SELECT struct_update({a: 1, b: 2}, a := 'c'); +-- +ok +== +SELECT struct_update({a: 1, b: 2}, a := 'c', d := 3); +-- +ok +== +SELECT struct_update({a: 1, b: 2}, d := 3, a := 'c'); +-- +ok +== +SELECT struct_update(col, i:=10) FROM tbl; +-- +ok +== +SELECT struct_update(col, i:=col.i+1) FROM tbl; +-- +ok +== +SELECT struct_update(col, i:='i='||col.i) FROM tbl; +-- +ok +== +SELECT struct_update(col, a := NULL::VARCHAR) FROM tbl ORDER BY ALL; +-- +ok +== +SELECT struct_update(col, a := NULL, b := NULL::VARCHAR, c := [NULL]) FROM tbl ORDER BY ALL; +-- +ok +== +SELECT struct_update(col, i := 10, a := NULL, b := NULL::VARCHAR, c := [NULL]) FROM tbl ORDER BY ALL; +-- +ok +== +SELECT struct_update(col, i := col.i+10, a := NULL, b := NULL::VARCHAR, c := [NULL]) FROM tbl ORDER BY ALL; +-- +ok +== diff --git a/parser/testdata/corpus/sql/function/numeric/abs.test b/parser/testdata/corpus/sql/function/numeric/abs.test new file mode 100644 index 0000000..04afa25 --- /dev/null +++ b/parser/testdata/corpus/sql/function/numeric/abs.test @@ -0,0 +1,9 @@ +# source: test/sql/function/numeric/abs.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +SELECT abs('-0.0'::float), abs('-0.0'::double) +-- +ok +== diff --git a/parser/testdata/corpus/sql/function/numeric/decimal_mod.test b/parser/testdata/corpus/sql/function/numeric/decimal_mod.test new file mode 100644 index 0000000..7532e1b --- /dev/null +++ b/parser/testdata/corpus/sql/function/numeric/decimal_mod.test @@ -0,0 +1,33 @@ +# source: test/sql/function/numeric/decimal_mod.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +SELECT 10 % 2.4, -10 % 2.4 +-- +ok +== +SELECT 10.0 % 2.4, -10.0 % 2.4 +-- +ok +== +SELECT 12345678901111111 % 2.0; +-- +ok +== +select 12345678901234567890 % 123; +-- +ok +== +SELECT 10000000000000000000000000000000000001::DECIMAL(38,0) % 0.00000000000000000000000000000000004 +-- +ok +== +SELECT typeof(10.0 % 2.0), typeof(10.0 % 2.0 % 2.0 % 2.0) +-- +ok +== +SELECT 10.0 % 0.0 +-- +ok +== diff --git a/parser/testdata/corpus/sql/function/numeric/set_seed_for_sample.test b/parser/testdata/corpus/sql/function/numeric/set_seed_for_sample.test new file mode 100644 index 0000000..ec531e3 --- /dev/null +++ b/parser/testdata/corpus/sql/function/numeric/set_seed_for_sample.test @@ -0,0 +1,13 @@ +# source: test/sql/function/numeric/set_seed_for_sample.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +create table t1 as select * from generate_series(1,50) as t(number); +-- +ok +== +select * from t1 using sample 5; +-- +ok +== diff --git a/parser/testdata/corpus/sql/function/numeric/test_arithmetic_aliases.test b/parser/testdata/corpus/sql/function/numeric/test_arithmetic_aliases.test new file mode 100644 index 0000000..991aecd --- /dev/null +++ b/parser/testdata/corpus/sql/function/numeric/test_arithmetic_aliases.test @@ -0,0 +1,29 @@ +# source: test/sql/function/numeric/test_arithmetic_aliases.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +CREATE TABLE test(a integer) +-- +ok +== +insert into test values (1), (2), (3), (NULL) +-- +ok +== +select add(a,a) from test +-- +ok +== +select subtract(a,a) from test +-- +ok +== +select multiply(a,a) from test +-- +ok +== +select divide(a,a) from test +-- +ok +== diff --git a/parser/testdata/corpus/sql/function/numeric/test_binom.test b/parser/testdata/corpus/sql/function/numeric/test_binom.test new file mode 100644 index 0000000..7368a8c --- /dev/null +++ b/parser/testdata/corpus/sql/function/numeric/test_binom.test @@ -0,0 +1,61 @@ +# source: test/sql/function/numeric/test_binom.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +SELECT binom(5, 2); +-- +ok +== +SELECT binom(10, 1), binom(10, 5), binom(10, 10); +-- +ok +== +SELECT binom(0, 0), binom(1, 0), binom(1, 1); +-- +ok +== +SELECT binom(8, 6), binom(6, 8); +-- +ok +== +SELECT binom(100, 2), binom(100, 98); +-- +ok +== +SELECT binom(60, 30); +-- +ok +== +SELECT binom(120, 60); +-- +ok +== +SELECT binom(130, 65); +-- +ok +== +SELECT binom(131, 65); +-- +ok +== +SELECT binom(NULL, NULL); +-- +ok +== +SELECT binom(NULL, 3), binom(3, NULL); +-- +ok +== +SELECT binom(-6, 3); +-- +ok +== +SELECT binom(6, -3); +-- +ok +== +SELECT binom(-6, -3); +-- +ok +== diff --git a/parser/testdata/corpus/sql/function/numeric/test_bit_count.test b/parser/testdata/corpus/sql/function/numeric/test_bit_count.test new file mode 100644 index 0000000..2c557ad --- /dev/null +++ b/parser/testdata/corpus/sql/function/numeric/test_bit_count.test @@ -0,0 +1,17 @@ +# source: test/sql/function/numeric/test_bit_count.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +CREATE TABLE bits(t tinyint, s smallint, i integer, b bigint, h hugeint) +-- +ok +== +INSERT INTO bits VALUES (NULL, NULL, NULL, NULL, NULL), (31, 1023, 11834119, 50827156903621017, 3141592653589793238462643383279528841), (-59, -517, -575693, -9876543210, -148873535527910577765226390751398592512) +-- +ok +== +select bit_count(t), bit_count(s), bit_count(i), bit_count(b), bit_count(h) from bits +-- +ok +== diff --git a/parser/testdata/corpus/sql/function/numeric/test_even.test b/parser/testdata/corpus/sql/function/numeric/test_even.test new file mode 100644 index 0000000..f2a50ee --- /dev/null +++ b/parser/testdata/corpus/sql/function/numeric/test_even.test @@ -0,0 +1,41 @@ +# source: test/sql/function/numeric/test_even.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +select i, even(i + 0.4) from generate_series(-4,4) tbl(i); +-- +ok +== +select i, even(i + 0.9) from generate_series(-4,4) tbl(i); +-- +ok +== +SELECT even(19.4), even(-19.4) +-- +ok +== +SELECT even(8.9), even(-8.9) +-- +ok +== +SELECT even(45::DOUBLE), even(-35::DOUBLE) +-- +ok +== +SELECT even(NULL) +-- +ok +== +SELECT even('abcd') +-- +ok +== +SELECT even(1.7976931348623155e+308) +-- +ok +== +SELECT even(-1.7976931348623155e+308) +-- +ok +== diff --git a/parser/testdata/corpus/sql/function/numeric/test_factorial.test b/parser/testdata/corpus/sql/function/numeric/test_factorial.test new file mode 100644 index 0000000..7330ec2 --- /dev/null +++ b/parser/testdata/corpus/sql/function/numeric/test_factorial.test @@ -0,0 +1,41 @@ +# source: test/sql/function/numeric/test_factorial.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +SELECT factorial(0); +-- +ok +== +SELECT factorial(-1); +-- +ok +== +SELECT factorial(NULL); +-- +ok +== +SELECT factorial(2); +-- +ok +== +SELECT factorial(10); +-- +ok +== +SELECT 10!; +-- +ok +== +SELECT factorial(20); +-- +ok +== +SELECT factorial(30); +-- +ok +== +SELECT factorial(40); +-- +ok +== diff --git a/parser/testdata/corpus/sql/function/numeric/test_fdiv_fmod.test b/parser/testdata/corpus/sql/function/numeric/test_fdiv_fmod.test new file mode 100644 index 0000000..72aa2b4 --- /dev/null +++ b/parser/testdata/corpus/sql/function/numeric/test_fdiv_fmod.test @@ -0,0 +1,61 @@ +# source: test/sql/function/numeric/test_fdiv_fmod.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +SET ieee_floating_point_ops=false; +-- +ok +== +CREATE TABLE rs(x DOUBLE, y INTEGER) +-- +ok +== +INSERT INTO rs VALUES (10, 3),(10,-3),(-10,3),(-10,-3),(0,1),(1,1),(NULL,10),(10,NULL),(NULL,NULL) +-- +ok +== +SELECT fmod(x, y) FROM rs +-- +ok +== +SELECT fdiv(x, y) FROM rs +-- +ok +== +SELECT fmod(42, 0) +-- +ok +== +SELECT fmod(0, 0) +-- +ok +== +SELECT fdiv(42, 0) +-- +ok +== +SELECT fdiv(-42, 0) +-- +ok +== +SELECT fdiv(0, 0) +-- +ok +== +SELECT fmod(12.3456789, 5) +-- +ok +== +SELECT fdiv(12.3456789, 5) +-- +ok +== +SELECT fmod(3, 2.1) +-- +ok +== +SELECT fdiv(3, 2.1) +-- +ok +== diff --git a/parser/testdata/corpus/sql/function/numeric/test_floor_ceil.test b/parser/testdata/corpus/sql/function/numeric/test_floor_ceil.test new file mode 100644 index 0000000..5f0f09d --- /dev/null +++ b/parser/testdata/corpus/sql/function/numeric/test_floor_ceil.test @@ -0,0 +1,65 @@ +# source: test/sql/function/numeric/test_floor_ceil.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +CREATE TABLE numbers(n DOUBLE) +-- +ok +== +INSERT INTO numbers VALUES (NULL),(-42.8),(-42.2),(0), (42.2), (42.8) +-- +ok +== +SELECT cast(CEIL(n::tinyint) as bigint) FROM numbers ORDER BY n +-- +ok +== +SELECT cast(CEIL(n::smallint) as bigint) FROM numbers ORDER BY n +-- +ok +== +SELECT cast(CEIL(n::integer) as bigint) FROM numbers ORDER BY n +-- +ok +== +SELECT cast(CEIL(n::bigint) as bigint) FROM numbers ORDER BY n +-- +ok +== +SELECT cast(CEIL(n::float) as bigint) FROM numbers ORDER BY n +-- +ok +== +SELECT cast(CEIL(n::double) as bigint) FROM numbers ORDER BY n +-- +ok +== +SELECT cast(CEILING(n::double) as bigint) FROM numbers ORDER BY n +-- +ok +== +SELECT cast(FLOOR(n::tinyint) as bigint) FROM numbers ORDER BY n +-- +ok +== +SELECT cast(FLOOR(n::smallint) as bigint) FROM numbers ORDER BY n +-- +ok +== +SELECT cast(FLOOR(n::integer) as bigint) FROM numbers ORDER BY n +-- +ok +== +SELECT cast(FLOOR(n::bigint) as bigint) FROM numbers ORDER BY n +-- +ok +== +SELECT cast(FLOOR(n::float) as bigint) FROM numbers ORDER BY n +-- +ok +== +SELECT cast(FLOOR(n::double) as bigint) FROM numbers ORDER BY n +-- +ok +== diff --git a/parser/testdata/corpus/sql/function/numeric/test_gamma.test b/parser/testdata/corpus/sql/function/numeric/test_gamma.test new file mode 100644 index 0000000..b70e7ab --- /dev/null +++ b/parser/testdata/corpus/sql/function/numeric/test_gamma.test @@ -0,0 +1,105 @@ +# source: test/sql/function/numeric/test_gamma.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +SET ieee_floating_point_ops = false; +-- +ok +== +SELECT gamma(NULL) +-- +ok +== +SELECT gamma(0) +-- +ok +== +SELECT gamma(-1) +-- +ok +== +SELECT gamma(1) +-- +ok +== +SELECT gamma(-0.1) +-- +ok +== +SELECT gamma(2) +-- +ok +== +SELECT gamma(10) +-- +ok +== +SELECT gamma(2::tinyint) +-- +ok +== +SELECT gamma(2::hugeint) +-- +ok +== +SELECT gamma('asdf') +-- +ok +== +SELECT lgamma(NULL) +-- +ok +== +SELECT lgamma(0) +-- +ok +== +SELECT lgamma(-1) +-- +ok +== +SELECT lgamma(-100) +-- +ok +== +SELECT lgamma(1) +-- +ok +== +SELECT lgamma(2) +-- +ok +== +SELECT lgamma(3) +-- +ok +== +SELECT lgamma(10) +-- +ok +== +SELECT lgamma(2::tinyint) +-- +ok +== +SELECT lgamma(2::hugeint) +-- +ok +== +SELECT lgamma('asdf') +-- +ok +== +RESET ieee_floating_point_ops; +-- +ok +== +SET ieee_floating_point_ops = true; +-- +ok +== +SELECT gamma(0::DOUBLE), gamma(-1::DOUBLE), lgamma(0::DOUBLE), lgamma(-1::DOUBLE); +-- +ok +== diff --git a/parser/testdata/corpus/sql/function/numeric/test_gcd_lcm.test b/parser/testdata/corpus/sql/function/numeric/test_gcd_lcm.test new file mode 100644 index 0000000..4c6dc46 --- /dev/null +++ b/parser/testdata/corpus/sql/function/numeric/test_gcd_lcm.test @@ -0,0 +1,50 @@ +# source: test/sql/function/numeric/test_gcd_lcm.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +SELECT a, b, gcd(a, b), gcd(a, -b), gcd(b, a), gcd(-b, a) +FROM (VALUES (0::int8, 0::int8), + (0::int8, 29893644334::int8), + (288484263558::int8, 29893644334::int8), + (-288484263558::int8, 29893644334::int8), + ((-9223372036854775808)::int8, 1::int8), + ((-9223372036854775808)::int8, 9223372036854775807::int8), + ((-9223372036854775808)::int8, 4611686018427387904::int8)) AS v(a, b); +-- +ok +== +SELECT gcd(42, NULL) +-- +ok +== +SELECT gcd(42, 'abcd') +-- +ok +== +select lcm(120,25); +-- +ok +== +SELECT a, b, lcm(a, b), lcm(a, -b), lcm(b, a), lcm(-b, a) +FROM (VALUES (0::int8, 0::int8), + (0::int8, 29893644334::int8), + (29893644334::int8, 29893644334::int8), + (288484263558::int8, 29893644334::int8), + (-288484263558::int8, 29893644334::int8), + ((-9223372036854775808)::int8, 0::int8)) AS v(a, b); +-- +ok +== +SELECT lcm(42, NULL) +-- +ok +== +SELECT lcm(42, 'abcd') +-- +ok +== +select lcm(4200000000000000000,5700000000000000000) +-- +ok +== diff --git a/parser/testdata/corpus/sql/function/numeric/test_geomean.test b/parser/testdata/corpus/sql/function/numeric/test_geomean.test new file mode 100644 index 0000000..6cab46e --- /dev/null +++ b/parser/testdata/corpus/sql/function/numeric/test_geomean.test @@ -0,0 +1,25 @@ +# source: test/sql/function/numeric/test_geomean.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +CREATE TABLE numbers(x DOUBLE) +-- +ok +== +INSERT INTO numbers VALUES (NULL), (1), (2) +-- +ok +== +SELECT geomean(x) FROM numbers +-- +ok +== +SELECT geomean(x::integer) FROM numbers +-- +ok +== +SELECT geomean(i) FROM generate_series(1000, 2000) tbl(i); +-- +ok +== diff --git a/parser/testdata/corpus/sql/function/numeric/test_invalid_math.test b/parser/testdata/corpus/sql/function/numeric/test_invalid_math.test new file mode 100644 index 0000000..22e746f --- /dev/null +++ b/parser/testdata/corpus/sql/function/numeric/test_invalid_math.test @@ -0,0 +1,49 @@ +# source: test/sql/function/numeric/test_invalid_math.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +SELECT log(0); +-- +ok +== +SELECT log(-1); +-- +ok +== +SELECT ln(0); +-- +ok +== +SELECT ln(-1); +-- +ok +== +SELECT log10(0); +-- +ok +== +SELECT log10(-1); +-- +ok +== +SELECT sqrt(-1); +-- +ok +== +SELECT SQRT(0) +-- +ok +== +SELECT POW(1e300,100), POW(-1e300,100), POW(-1.0, 0.5) +-- +ok +== +SELECT EXP(1e300), EXP(1e100) +-- +ok +== +SELECT DEGREES(1e308) +-- +ok +== diff --git a/parser/testdata/corpus/sql/function/numeric/test_is_nan.test b/parser/testdata/corpus/sql/function/numeric/test_is_nan.test new file mode 100644 index 0000000..5e55054 --- /dev/null +++ b/parser/testdata/corpus/sql/function/numeric/test_is_nan.test @@ -0,0 +1,61 @@ +# source: test/sql/function/numeric/test_is_nan.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +SELECT isnan(3::{type}), isnan('nan'::{type}), isnan(NULL::{type}) +-- +error: Parser Error: syntax error at or near "{" +== +CREATE TABLE floats(f {type}) +-- +error: Parser Error: syntax error at or near "{" +== +INSERT INTO floats VALUES (3), ('nan'), ('inf'), ('-inf'), (NULL) +-- +ok +== +SELECT f, isnan(f), isinf(f), isfinite(f) FROM floats ORDER BY f +-- +ok +== +DROP TABLE floats +-- +ok +== +CREATE TABLE no_nan(f {type} NOT NULL) +-- +error: Parser Error: syntax error at or near "{" +== +INSERT INTO no_nan VALUES (-1), (0), (1), ('inf'), ('-inf') +-- +ok +== +EXPLAIN SELECT isnan(f), f FROM no_nan +-- +ok +== +EXPLAIN SELECT false, f FROM no_nan +-- +ok +== +CREATE TABLE no_nan_nullable(f {type}) +-- +error: Parser Error: syntax error at or near "{" +== +INSERT INTO no_nan_nullable VALUES (3), (NULL) +-- +ok +== +SELECT f, isnan(f) FROM no_nan_nullable ORDER BY f +-- +ok +== +DROP TABLE no_nan +-- +ok +== +DROP TABLE no_nan_nullable +-- +ok +== diff --git a/parser/testdata/corpus/sql/function/numeric/test_mod.test b/parser/testdata/corpus/sql/function/numeric/test_mod.test new file mode 100644 index 0000000..ae0aa63 --- /dev/null +++ b/parser/testdata/corpus/sql/function/numeric/test_mod.test @@ -0,0 +1,29 @@ +# source: test/sql/function/numeric/test_mod.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +CREATE TABLE modme(a DOUBLE, b INTEGER) +-- +ok +== +INSERT INTO modme VALUES (42.123456, 3) +-- +ok +== +select mod(a, 40) from modme +-- +ok +== +select mod(42, 0) +-- +ok +== +select mod(a, 2) from modme +-- +ok +== +select mod(b, 2.1) from modme +-- +ok +== diff --git a/parser/testdata/corpus/sql/function/numeric/test_nextafter.test b/parser/testdata/corpus/sql/function/numeric/test_nextafter.test new file mode 100644 index 0000000..d2ba881 --- /dev/null +++ b/parser/testdata/corpus/sql/function/numeric/test_nextafter.test @@ -0,0 +1,77 @@ +# source: test/sql/function/numeric/test_nextafter.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +select nextafter() +-- +ok +== +select nextafter('bla','bla') +-- +ok +== +select nextafter(NULL,1) +-- +ok +== +select nextafter(1,NULL) +-- +ok +== +select nextafter(99, 1) +-- +ok +== +select nextafter(99.0::DOUBLE, 1.0::DOUBLE) < 99 +-- +ok +== +select nextafter(99.0::DOUBLE, 99.0::DOUBLE) = 99 +-- +ok +== +select nextafter(99.0::DOUBLE, 100.0::DOUBLE) > 99 +-- +ok +== +select nextafter(nextafter(99.0::DOUBLE, 100.0::DOUBLE),0::DOUBLE) = 99 +-- +ok +== +select nextafter(99.0::FLOAT, 1.0::FLOAT) < 99 +-- +ok +== +select nextafter(99.0::FLOAT, 100.0::FLOAT) > 99 +-- +ok +== +select nextafter(nextafter(99.0::FLOAT, 100.0::FLOAT),0::FLOAT) = 99 +-- +ok +== +create table test (a FLOAT) +-- +ok +== +INSERT INTO test VALUES (10),(20),(30),(40) +-- +ok +== +select nextafter(a, 0::FLOAT) from test +-- +ok +== +create table test_twoc (a FLOAT, b FLOAT) +-- +ok +== +INSERT INTO test_twoc VALUES (10,1),(20,21),(30,1),(40,41) +-- +ok +== +select nextafter(a, b) from test_twoc +-- +ok +== diff --git a/parser/testdata/corpus/sql/function/numeric/test_pg_math.test b/parser/testdata/corpus/sql/function/numeric/test_pg_math.test new file mode 100644 index 0000000..b0bfdd5 --- /dev/null +++ b/parser/testdata/corpus/sql/function/numeric/test_pg_math.test @@ -0,0 +1,133 @@ +# source: test/sql/function/numeric/test_pg_math.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +select abs(-17.4) +-- +ok +== +select cbrt(27.0) +-- +ok +== +select ceil(-42.8) +-- +ok +== +select ceiling(-95.3) +-- +ok +== +select exp(1.0) +-- +ok +== +select floor(-42.8) +-- +ok +== +select ln(2.0) +-- +ok +== +select log(100.0) +-- +ok +== +select log10(100.0) +-- +ok +== +select log2(4.0) +-- +ok +== +select pi() +-- +ok +== +select sqrt(2.0) +-- +ok +== +select radians(45.0) +-- +ok +== +select degrees(0.5) +-- +ok +== +select sign(4.1) +-- +ok +== +select sign(-4.1) +-- +ok +== +select sign(0) +-- +ok +== +select sign(3) +-- +ok +== +select log(2, 64) +-- +ok +== +select log(0, 64) +-- +ok +== +select log(2, 0) +-- +ok +== +select log(-1, 64) +-- +ok +== +select log(2, -1) +-- +ok +== +select log(1, 64) +-- +ok +== +select log(2, 1) +-- +ok +== +select log(0.5, 64) +-- +ok +== +select log('Inf'::DOUBLE, 64) +-- +ok +== +select log(64, 'Inf'::DOUBLE) +-- +ok +== +select log(64, 'NaN'::DOUBLE) +-- +ok +== +select log('NaN'::DOUBLE, 64) +-- +ok +== +select log('-Inf'::DOUBLE, 64) +-- +ok +== +select log(64, '-Inf'::DOUBLE) +-- +ok +== diff --git a/parser/testdata/corpus/sql/function/numeric/test_pow.test b/parser/testdata/corpus/sql/function/numeric/test_pow.test new file mode 100644 index 0000000..6cfe013 --- /dev/null +++ b/parser/testdata/corpus/sql/function/numeric/test_pow.test @@ -0,0 +1,41 @@ +# source: test/sql/function/numeric/test_pow.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +CREATE TABLE powerme(a DOUBLE, b INTEGER) +-- +ok +== +INSERT INTO powerme VALUES (2.1, 3) +-- +ok +== +select pow(a, 0) from powerme +-- +ok +== +select pow(b, -2) from powerme +-- +ok +== +select pow(a, b) from powerme +-- +ok +== +select pow(b, a) from powerme +-- +ok +== +select power(b, a) from powerme +-- +ok +== +SELECT power(0.0::float8, -2.0::float8); +-- +ok +== +SELECT 0.0::float8 ^ -1.0::float8; +-- +ok +== diff --git a/parser/testdata/corpus/sql/function/numeric/test_random.test b/parser/testdata/corpus/sql/function/numeric/test_random.test new file mode 100644 index 0000000..6d30546 --- /dev/null +++ b/parser/testdata/corpus/sql/function/numeric/test_random.test @@ -0,0 +1,101 @@ +# source: test/sql/function/numeric/test_random.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +CREATE TABLE t1 AS SELECT [random() for a IN range(1)] FROM range(2); +-- +ok +== +CREATE TABLE t2 AS SELECT random() FROM range(2); +-- +ok +== +CREATE TABLE t3 AS SELECT [random()] FROM range(2); +-- +ok +== +CREATE TABLE t4 AS SELECT [random() + range * 0 for a IN range(1)] FROM range(2); +-- +ok +== +SELECT count(*) FROM t1 WHERE (SELECT min(#1) FROM t1 ) == (SELECT max(#1) FROM t1); +-- +ok +== +SELECT count(*) FROM t2 WHERE (SELECT min(#1) FROM t2 ) == (SELECT max(#1) FROM t2); +-- +ok +== +SELECT count(*) FROM t3 WHERE (SELECT min(#1) FROM t3 ) == (SELECT max(#1) FROM t3); +-- +ok +== +SELECT count(*) FROM t4 WHERE (SELECT min(#1) FROM t4 ) == (SELECT max(#1) FROM t4); +-- +ok +== +CREATE TEMPORARY TABLE t1 AS SELECT RANDOM() a; +-- +ok +== +CREATE TEMPORARY TABLE t2 AS SELECT RANDOM() b; +-- +ok +== +CREATE TEMPORARY TABLE t3 AS SELECT RANDOM() c; +-- +ok +== +SELECT COUNT(*) FROM (SELECT a FROM t1 JOIN t2 ON (a=b) JOIN t3 ON (b=c)) s1 +-- +ok +== +select setseed(0.1) +-- +ok +== +select setseed(1.1) +-- +ok +== +select setseed(-1.1) +-- +ok +== +CREATE TABLE seeds(a DOUBLE) +-- +ok +== +INSERT INTO seeds VALUES (-0.1), (0.0), (0.1) +-- +ok +== +select setseed(a), a from seeds; +-- +ok +== +CREATE TABLE numbers(a INTEGER) +-- +ok +== +INSERT INTO numbers VALUES (1), (2), (3), (4), (5), (6), (7), (8), (9), (10) +-- +ok +== +select case when min(random()) >= 0 then 1 else 0 end from numbers; +-- +ok +== +select case when max(random()) < 1 then 1 else 0 end from numbers; +-- +ok +== +select * from numbers order by random() +-- +ok +== +select random() from numbers +-- +ok +== diff --git a/parser/testdata/corpus/sql/function/numeric/test_round.test b/parser/testdata/corpus/sql/function/numeric/test_round.test new file mode 100644 index 0000000..be26ed7 --- /dev/null +++ b/parser/testdata/corpus/sql/function/numeric/test_round.test @@ -0,0 +1,57 @@ +# source: test/sql/function/numeric/test_round.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +CREATE TABLE roundme(a DOUBLE, b INTEGER) +-- +ok +== +INSERT INTO roundme VALUES (42.123456, 3) +-- +ok +== +select round(42.12345::DOUBLE, 0) +-- +ok +== +select round(42.12345::DOUBLE) +-- +ok +== +select round(42.12345::DOUBLE, 2) +-- +ok +== +select round(42.12345::DOUBLE, 4), round(42.1235::DOUBLE, 1000) +-- +ok +== +select round(42::DOUBLE, 0) +-- +ok +== +select round(42::DOUBLE, -1), round(42::DOUBLE, -2), round(42::DOUBLE, -1000) +-- +ok +== +select round(a, 1) from roundme +-- +ok +== +select round(b, 1) from roundme +-- +ok +== +select round(a, b) from roundme +-- +ok +== +SELECT round(1.0, (-2147483648)::INT); +-- +ok +== +SELECT round(1.0::DOUBLE, (-2147483648)::INT); +-- +ok +== diff --git a/parser/testdata/corpus/sql/function/numeric/test_round_even.test b/parser/testdata/corpus/sql/function/numeric/test_round_even.test new file mode 100644 index 0000000..aceaa41 --- /dev/null +++ b/parser/testdata/corpus/sql/function/numeric/test_round_even.test @@ -0,0 +1,61 @@ +# source: test/sql/function/numeric/test_round_even.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +SELECT roundBankers(45, -1) +-- +ok +== +select i, round_even(i + 0.5, 0) from generate_series(-2,4) tbl(i); +-- +ok +== +select i, round_even(i + 0.55, 0) from generate_series(-2,4) tbl(i); +-- +ok +== +select i, roundBankers(i + 0.55, 0) from generate_series(-2,4) tbl(i); +-- +ok +== +SELECT roundBankers(45, -1), roundBankers(35, -1) +-- +ok +== +SELECT roundBankers(45.5, 0), roundBankers(44.5, 0) +-- +ok +== +SELECT roundBankers(45.55, 1), roundBankers(45.45, 1) +-- +ok +== +SELECT roundBankers(-45, -1), roundBankers(-35, -1) +-- +ok +== +SELECT roundBankers(-45.5, 0), roundBankers(-44.5, 0) +-- +ok +== +SELECT roundBankers(-45.55, 1), roundBankers(-45.45, 1) +-- +ok +== +SELECT roundBankers(45::DOUBLE, -1), roundBankers(35::DOUBLE, -1) +-- +ok +== +SELECT roundBankers(45.5::DOUBLE, 0), roundBankers(44.5::DOUBLE, 0) +-- +ok +== +SELECT roundBankers(45.55::DOUBLE, 1), roundBankers(45.45::DOUBLE, 1) +-- +ok +== +SELECT roundBankers(NULL, 1), roundBankers(45, NULL), roundBankers(NULL, NULL) +-- +ok +== diff --git a/parser/testdata/corpus/sql/function/numeric/test_round_integers.test b/parser/testdata/corpus/sql/function/numeric/test_round_integers.test new file mode 100644 index 0000000..98847d3 --- /dev/null +++ b/parser/testdata/corpus/sql/function/numeric/test_round_integers.test @@ -0,0 +1,39 @@ +# source: test/sql/function/numeric/test_round_integers.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +CREATE TABLE zz AS + SELECT + CAST(i AS SMALLINT) AS id, + CAST(i AS SMALLINT) AS si + FROM generate_series(1, 1000) t(i); +-- +ok +== +SELECT ROUND(53) AS ag_column3 +FROM zz +GROUP BY ag_column3 +ORDER BY ag_column3 +-- +ok +== +SELECT ROUND(53, si) AS ag_column3 +FROM zz +GROUP BY ag_column3 +ORDER BY ag_column3 +-- +ok +== +SELECT ROUND(53, -si) AS ag_column3 +FROM zz +GROUP BY ag_column3 +ORDER BY ag_column3 +-- +ok +== +select round(100::INTEGER, int) +from test_all_types(); +-- +ok +== diff --git a/parser/testdata/corpus/sql/function/numeric/test_sign_bit.test b/parser/testdata/corpus/sql/function/numeric/test_sign_bit.test new file mode 100644 index 0000000..bc94310 --- /dev/null +++ b/parser/testdata/corpus/sql/function/numeric/test_sign_bit.test @@ -0,0 +1,33 @@ +# source: test/sql/function/numeric/test_sign_bit.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +SELECT signbit(3::{type}), signbit(-3::{type}), signbit(NULL::{type}) +-- +error: Parser Error: syntax error at or near "{" +== +INSERT INTO floats VALUES (3), (1.0::float), (-0.0::float), ('inf'), ('-inf'), (NULL) +-- +ok +== +SELECT f, signbit(f), isinf(f), isfinite(f) FROM floats ORDER BY f +-- +ok +== +CREATE TABLE negative_zero AS SELECT -0.0::{type} AS x FROM range(2); +-- +error: Parser Error: syntax error at or near "{" +== +SELECT signbit(abs(x)) FROM negative_zero; +-- +ok +== +DROP TABLE negative_zero; +-- +ok +== +SELECT signbit(1.0 / 0.0); +-- +ok +== diff --git a/parser/testdata/corpus/sql/function/numeric/test_trigo.test b/parser/testdata/corpus/sql/function/numeric/test_trigo.test new file mode 100644 index 0000000..df7a788 --- /dev/null +++ b/parser/testdata/corpus/sql/function/numeric/test_trigo.test @@ -0,0 +1,269 @@ +# source: test/sql/function/numeric/test_trigo.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +INSERT INTO numbers VALUES (-42),(-1),(0), (1), (42), (NULL) +-- +ok +== +SELECT cast(SIN(n::tinyint)*1000 as bigint) FROM numbers ORDER BY n +-- +ok +== +SELECT cast(SIN(n::smallint)*1000 as bigint) FROM numbers ORDER BY n +-- +ok +== +SELECT cast(SIN(n::integer)*1000 as bigint) FROM numbers ORDER BY n +-- +ok +== +SELECT cast(SIN(n::bigint)*1000 as bigint) FROM numbers ORDER BY n +-- +ok +== +SELECT cast(SIN(n::float)*1000 as bigint) FROM numbers ORDER BY n +-- +ok +== +SELECT cast(SIN(n::double)*1000 as bigint) FROM numbers ORDER BY n +-- +ok +== +SELECT cast(COS(n::tinyint)*1000 as bigint) FROM numbers ORDER BY n +-- +ok +== +SELECT cast(COS(n::smallint)*1000 as bigint) FROM numbers ORDER BY n +-- +ok +== +SELECT cast(COS(n::integer)*1000 as bigint) FROM numbers ORDER BY n +-- +ok +== +SELECT cast(COS(n::bigint)*1000 as bigint) FROM numbers ORDER BY n +-- +ok +== +SELECT cast(COS(n::float)*1000 as bigint) FROM numbers ORDER BY n +-- +ok +== +SELECT cast(COS(n::double)*1000 as bigint) FROM numbers ORDER BY n +-- +ok +== +SELECT cast(TAN(n::tinyint)*1000 as bigint) FROM numbers ORDER BY n +-- +ok +== +SELECT cast(TAN(n::smallint)*1000 as bigint) FROM numbers ORDER BY n +-- +ok +== +SELECT cast(TAN(n::integer)*1000 as bigint) FROM numbers ORDER BY n +-- +ok +== +SELECT cast(TAN(n::bigint)*1000 as bigint) FROM numbers ORDER BY n +-- +ok +== +SELECT cast(TAN(n::float)*1000 as bigint) FROM numbers ORDER BY n +-- +ok +== +SELECT cast(TAN(n::double)*1000 as bigint) FROM numbers ORDER BY n +-- +ok +== +SELECT cast(ATAN(n::tinyint)*1000 as bigint) FROM numbers ORDER BY n +-- +ok +== +SELECT cast(ATAN(n::smallint)*1000 as bigint) FROM numbers ORDER BY n +-- +ok +== +SELECT cast(ATAN(n::integer)*1000 as bigint) FROM numbers ORDER BY n +-- +ok +== +SELECT cast(ATAN(n::bigint)*1000 as bigint) FROM numbers ORDER BY n +-- +ok +== +SELECT cast(ATAN(n::float)*1000 as bigint) FROM numbers ORDER BY n +-- +ok +== +SELECT cast(ATAN(n::double)*1000 as bigint) FROM numbers ORDER BY n +-- +ok +== +SELECT cast(ASIN(n::tinyint)*1000 as bigint) FROM numbers WHERE n between -1 and 1 ORDER BY n +-- +ok +== +SELECT cast(ASIN(n::smallint)*1000 as bigint) FROM numbers WHERE n between -1 and 1 ORDER BY n +-- +ok +== +SELECT cast(ASIN(n::integer)*1000 as bigint) FROM numbers WHERE n between -1 and 1 ORDER BY n +-- +ok +== +SELECT cast(ASIN(n::bigint)*1000 as bigint) FROM numbers WHERE n between -1 and 1 ORDER BY n +-- +ok +== +SELECT cast(ASIN(n::float)*1000 as bigint) FROM numbers WHERE n between -1 and 1 ORDER BY n +-- +ok +== +SELECT cast(ASIN(n::double)*1000 as bigint) FROM numbers WHERE n between -1 and 1 ORDER BY n +-- +ok +== +SELECT cast(ACOS(n::tinyint)*1000 as bigint) FROM numbers WHERE n between -1 and 1 ORDER BY n +-- +ok +== +SELECT cast(ACOS(n::smallint)*1000 as bigint) FROM numbers WHERE n between -1 and 1 ORDER BY n +-- +ok +== +SELECT cast(ACOS(n::integer)*1000 as bigint) FROM numbers WHERE n between -1 and 1 ORDER BY n +-- +ok +== +SELECT cast(ACOS(n::bigint)*1000 as bigint) FROM numbers WHERE n between -1 and 1 ORDER BY n +-- +ok +== +SELECT cast(ACOS(n::float)*1000 as bigint) FROM numbers WHERE n between -1 and 1 ORDER BY n +-- +ok +== +SELECT cast(ACOS(n::double)*1000 as bigint) FROM numbers WHERE n between -1 and 1 ORDER BY n +-- +ok +== +SELECT cast(ASIN(n)*1000 as bigint) FROM numbers ORDER BY n +-- +ok +== +SELECT cast(COT(n::tinyint)*1000 as bigint) FROM numbers WHERE n > 0.1 OR N < -0.1 ORDER BY n +-- +ok +== +SELECT cast(COT(n::smallint)*1000 as bigint) FROM numbers WHERE n > 0.1 OR N < -0.1 ORDER BY n +-- +ok +== +SELECT cast(COT(n::integer)*1000 as bigint) FROM numbers WHERE n > 0.1 OR N < -0.1 ORDER BY n +-- +ok +== +SELECT cast(COT(n::bigint)*1000 as bigint) FROM numbers WHERE n > 0.1 OR N < -0.1 ORDER BY n +-- +ok +== +SELECT cast(COT(n::float)*1000 as bigint) FROM numbers WHERE n > 0.1 OR N < -0.1 ORDER BY n +-- +ok +== +SELECT cast(COT(n::double)*1000 as bigint) FROM numbers WHERE n > 0.1 OR N < -0.1 ORDER BY n +-- +ok +== +SELECT cast(ATAN2(n::tinyint, 42)*1000 as bigint) FROM numbers ORDER BY n +-- +ok +== +SELECT cast(ATAN2(n::smallint, 42)*1000 as bigint) FROM numbers ORDER BY n +-- +ok +== +SELECT cast(ATAN2(n::integer, 42)*1000 as bigint) FROM numbers ORDER BY n +-- +ok +== +SELECT cast(ATAN2(n::bigint, 42)*1000 as bigint) FROM numbers ORDER BY n +-- +ok +== +SELECT cast(ATAN2(n::float, 42)*1000 as bigint) FROM numbers ORDER BY n +-- +ok +== +SELECT cast(ATAN2(n::double, 42)*1000 as bigint) FROM numbers ORDER BY n +-- +ok +== +select asin(-2); +-- +ok +== +select acos(-2); +-- +ok +== +select {unary_func}('inf'::DOUBLE); +-- +error: Parser Error: syntax error at or near "}" +== +select {unary_func}('-inf'::DOUBLE); +-- +error: Parser Error: syntax error at or near "}" +== +select cot(0::DOUBLE); +-- +ok +== +select atanh({value}); +-- +error: Parser Error: syntax error at or near "}" +== +select atanh(1), atanh(-1); +-- +ok +== +select asin(2), acos(2), atanh(2), atanh(1), atanh(-1); +-- +ok +== +select sin('inf'::DOUBLE), cos('inf'::DOUBLE), tan('inf'::DOUBLE), cot('inf'::DOUBLE); +-- +ok +== +select cot(0::DOUBLE), cot(-0::DOUBLE); +-- +ok +== +select atanh(-0.5), atanh(0), atanh(0.5); +-- +ok +== +select acosh(-1), acosh(0), acosh(1), acosh(2); +-- +ok +== +select asinh(-1), asinh(0), asinh(2); +-- +ok +== +select tanh(-0.5), tanh(0), tanh(0.5), tanh(1000); +-- +ok +== +select cosh(-1), cosh(0), cosh(1), cosh(1000); +-- +ok +== +select sinh(-1), sinh(0), sinh(1), sinh(1000); +-- +ok +== diff --git a/parser/testdata/corpus/sql/function/numeric/test_trunc.test b/parser/testdata/corpus/sql/function/numeric/test_trunc.test new file mode 100644 index 0000000..f075f1d --- /dev/null +++ b/parser/testdata/corpus/sql/function/numeric/test_trunc.test @@ -0,0 +1,61 @@ +# source: test/sql/function/numeric/test_trunc.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +CREATE TABLE truncme(a DOUBLE, b INTEGER, c UINTEGER) +-- +ok +== +INSERT INTO truncme VALUES (42.123456, 3, 19), (-3.141592, -7, 5); +-- +ok +== +select trunc(42.12345::{datatype}) +-- +error: Parser Error: syntax error at or near "{" +== +select trunc(-42.12345::{datatype}) +-- +error: Parser Error: syntax error at or near "{" +== +select trunc(127::{datatype}) +-- +error: Parser Error: syntax error at or near "{" +== +select trunc(-127::{datatype}) +-- +error: Parser Error: syntax error at or near "{" +== +select trunc(0::{datatype}) +-- +error: Parser Error: syntax error at or near "{" +== +select trunc(a::{datatype}) from truncme +-- +error: Parser Error: syntax error at or near "{" +== +select trunc(54::{signed}) +-- +error: Parser Error: syntax error at or near "{" +== +select trunc(-27::{signed}) +-- +error: Parser Error: syntax error at or near "{" +== +select trunc(b::{signed}) from truncme +-- +error: Parser Error: syntax error at or near "{" +== +select trunc(15::{unsigned}) +-- +error: Parser Error: syntax error at or near "{" +== +select trunc(c::{unsigned}) from truncme +-- +error: Parser Error: syntax error at or near "{" +== +select trunc('NAN'::{special}), trunc('infinity'::{special}), trunc('-infinity'::{special}); +-- +error: Parser Error: syntax error at or near "{" +== diff --git a/parser/testdata/corpus/sql/function/numeric/test_trunc_precision.test b/parser/testdata/corpus/sql/function/numeric/test_trunc_precision.test new file mode 100644 index 0000000..3e087e5 --- /dev/null +++ b/parser/testdata/corpus/sql/function/numeric/test_trunc_precision.test @@ -0,0 +1,64 @@ +# source: test/sql/function/numeric/test_trunc_precision.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +INSERT INTO truncme VALUES (42.123456, 37, 19), (-3.141592, -75, 5); +-- +ok +== +select trunc(42.12345::{datatype}, 2), trunc(42.12345::{datatype}, -1) +-- +error: Parser Error: syntax error at or near "{" +== +select trunc(-42.12345::{datatype}, 2), trunc(-42.12345::{datatype}, -1) +-- +error: Parser Error: syntax error at or near "{" +== +select trunc(127::{datatype}, 2), trunc(127::{datatype}, -1) +-- +error: Parser Error: syntax error at or near "{" +== +select trunc(-127::{datatype}, 2), trunc(-127::{datatype}, -1) +-- +error: Parser Error: syntax error at or near "{" +== +select trunc(0::{datatype}, 2), trunc(0::{datatype}, -1) +-- +error: Parser Error: syntax error at or near "{" +== +select trunc(a::{datatype}, 2), trunc(a::{datatype}, -1) +from truncme +-- +error: Parser Error: syntax error at or near "{" +== +select trunc(54::{signed}, 2), trunc(54::{signed}, -1) +-- +error: Parser Error: syntax error at or near "{" +== +select trunc(-27::{signed}, 2), trunc(-27::{signed}, -1) +-- +error: Parser Error: syntax error at or near "{" +== +select trunc(b::{signed}, 2), trunc(b::{signed}, -1) +from truncme +-- +error: Parser Error: syntax error at or near "{" +== +select trunc(15::{unsigned}, 2), trunc(15::{unsigned}, -1) +-- +error: Parser Error: syntax error at or near "{" +== +select trunc(c::{unsigned}, 2), trunc(c::{unsigned}, -1) +from truncme +-- +error: Parser Error: syntax error at or near "{" +== +select + trunc('NAN'::{special}, {precision}), + trunc('infinity'::{special}, {precision}), + trunc('-infinity'::{special}, {precision}) +; +-- +error: Parser Error: syntax error at or near "{" +== diff --git a/parser/testdata/corpus/sql/function/numeric/test_type_resolution.test b/parser/testdata/corpus/sql/function/numeric/test_type_resolution.test new file mode 100644 index 0000000..5dbd92d --- /dev/null +++ b/parser/testdata/corpus/sql/function/numeric/test_type_resolution.test @@ -0,0 +1,173 @@ +# source: test/sql/function/numeric/test_type_resolution.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +SELECT 1::TINYINT + 1::TINYINT +-- +ok +== +SELECT 1::TINYINT + 1::SMALLINT +-- +ok +== +SELECT 1::TINYINT + 1::INT +-- +ok +== +SELECT 1::TINYINT + 1::BIGINT +-- +ok +== +SELECT 1::TINYINT + 1::REAL +-- +ok +== +SELECT 1::TINYINT + 1::DOUBLE +-- +ok +== +SELECT 1::TINYINT + 1::VARCHAR +-- +ok +== +SELECT 1::SMALLINT + 1::TINYINT +-- +ok +== +SELECT 1::SMALLINT + 1::SMALLINT +-- +ok +== +SELECT 1::SMALLINT + 1::INT +-- +ok +== +SELECT 1::SMALLINT + 1::BIGINT +-- +ok +== +SELECT 1::SMALLINT + 1::REAL +-- +ok +== +SELECT 1::SMALLINT + 1::DOUBLE +-- +ok +== +SELECT 1::SMALLINT + 1::VARCHAR +-- +ok +== +SELECT 1::INTEGER + 1::TINYINT +-- +ok +== +SELECT 1::INTEGER + 1::SMALLINT +-- +ok +== +SELECT 1::INTEGER + 1::INT +-- +ok +== +SELECT 1::INTEGER + 1::BIGINT +-- +ok +== +SELECT 1::INTEGER + 1::REAL +-- +ok +== +SELECT 1::INTEGER + 1::DOUBLE +-- +ok +== +SELECT 1::INTEGER + 1::VARCHAR +-- +ok +== +SELECT 1::BIGINT + 1::TINYINT +-- +ok +== +SELECT 1::BIGINT + 1::SMALLINT +-- +ok +== +SELECT 1::BIGINT + 1::INT +-- +ok +== +SELECT 1::BIGINT + 1::BIGINT +-- +ok +== +SELECT 1::BIGINT + 1::REAL +-- +ok +== +SELECT 1::BIGINT + 1::DOUBLE +-- +ok +== +SELECT 1::BIGINT + 1::VARCHAR +-- +ok +== +SELECT 1::REAL + 1::TINYINT +-- +ok +== +SELECT 1::REAL + 1::SMALLINT +-- +ok +== +SELECT 1::REAL + 1::INT +-- +ok +== +SELECT 1::REAL + 1::BIGINT +-- +ok +== +SELECT 1::REAL + 1::REAL +-- +ok +== +SELECT 1::REAL + 1::DOUBLE +-- +ok +== +SELECT 1::REAL + 1::VARCHAR +-- +ok +== +SELECT 1::DOUBLE + 1::TINYINT +-- +ok +== +SELECT 1::DOUBLE + 1::SMALLINT +-- +ok +== +SELECT 1::DOUBLE + 1::INT +-- +ok +== +SELECT 1::DOUBLE + 1::BIGINT +-- +ok +== +SELECT 1::DOUBLE + 1::REAL +-- +ok +== +SELECT 1::DOUBLE + 1::DOUBLE +-- +ok +== +SELECT 1::DOUBLE + 1::VARCHAR +-- +ok +== diff --git a/parser/testdata/corpus/sql/function/numeric/test_unary.test b/parser/testdata/corpus/sql/function/numeric/test_unary.test new file mode 100644 index 0000000..fe9822e --- /dev/null +++ b/parser/testdata/corpus/sql/function/numeric/test_unary.test @@ -0,0 +1,73 @@ +# source: test/sql/function/numeric/test_unary.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +INSERT INTO test VALUES (2) +-- +ok +== +SELECT ++-++-+i FROM test +-- +ok +== +SELECT +i FROM test +-- +ok +== +SELECT -i FROM test +-- +ok +== +SELECT +++++++i FROM test +-- +ok +== +SELECT -+-+-+-+-i FROM test +-- +ok +== +CREATE TABLE minima (t TINYINT, s SMALLINT, i INTEGER, b BIGINT); +-- +ok +== +INSERT INTO minima VALUES (-128, -32768, -2147483648, -9223372036854775808); +-- +ok +== +SELECT -t from minima; +-- +ok +== +SELECT -s from minima; +-- +ok +== +SELECT -i from minima; +-- +ok +== +SELECT -b from minima; +-- +ok +== +SELECT +'hello' +-- +ok +== +SELECT -'hello' +-- +ok +== +INSERT INTO dates VALUES ('1992-02-02') +-- +ok +== +SELECT +d FROM dates +-- +ok +== +SELECT -d FROM dates +-- +ok +== diff --git a/parser/testdata/corpus/sql/function/operator/test_arithmetic.test b/parser/testdata/corpus/sql/function/operator/test_arithmetic.test new file mode 100644 index 0000000..5979feb --- /dev/null +++ b/parser/testdata/corpus/sql/function/operator/test_arithmetic.test @@ -0,0 +1,57 @@ +# source: test/sql/function/operator/test_arithmetic.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +SELECT i+2=5, 5=i+2 FROM integers ORDER BY i +-- +ok +== +SELECT 2+i=5, 5=2+i FROM integers ORDER BY i +-- +ok +== +SELECT i*2=6, 6=i*2 FROM integers ORDER BY i +-- +ok +== +SELECT 2*i=6, 6=2*i FROM integers ORDER BY i +-- +ok +== +SELECT i*2=5 FROM integers ORDER BY i +-- +ok +== +SELECT i*0=5 FROM integers ORDER BY i +-- +ok +== +SELECT -i>-2 FROM integers ORDER BY i +-- +ok +== +SELECT i-2=1, 1=i-2 FROM integers ORDER BY i +-- +ok +== +SELECT 3-i=1, 1=3-i FROM integers ORDER BY i +-- +ok +== +SELECT 3-i<2, 2>3-i FROM integers ORDER BY i +-- +ok +== +SELECT 3-i<=1, 1>=3-i FROM integers ORDER BY i +-- +ok +== +SELECT i//2=1, 1=i//2 FROM integers ORDER BY i +-- +ok +== +SELECT 2/i=1, 1=2/i FROM integers ORDER BY i +-- +ok +== diff --git a/parser/testdata/corpus/sql/function/operator/test_arithmetic_sqllogic.test b/parser/testdata/corpus/sql/function/operator/test_arithmetic_sqllogic.test new file mode 100644 index 0000000..fae7412 --- /dev/null +++ b/parser/testdata/corpus/sql/function/operator/test_arithmetic_sqllogic.test @@ -0,0 +1,61 @@ +# source: test/sql/function/operator/test_arithmetic_sqllogic.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +CREATE TABLE tab0(col0 INTEGER, col1 INTEGER, col2 INTEGER); +-- +ok +== +CREATE TABLE tab1(col0 INTEGER, col1 INTEGER, col2 INTEGER); +-- +ok +== +CREATE TABLE tab2(col0 INTEGER, col1 INTEGER, col2 INTEGER); +-- +ok +== +INSERT INTO tab0 VALUES(97,1,99); +-- +ok +== +INSERT INTO tab0 VALUES(15,81,47); +-- +ok +== +INSERT INTO tab0 VALUES(87,21,10); +-- +ok +== +INSERT INTO tab1 VALUES(51,14,96); +-- +ok +== +INSERT INTO tab1 VALUES(85,5,59); +-- +ok +== +INSERT INTO tab1 VALUES(91,47,68); +-- +ok +== +INSERT INTO tab2 VALUES(64,77,40); +-- +ok +== +INSERT INTO tab2 VALUES(75,67,58); +-- +ok +== +INSERT INTO tab2 VALUES(46,51,23); +-- +ok +== +SELECT DISTINCT - col2 AS col2 FROM tab1 WHERE NOT 18 BETWEEN NULL AND ( + col0 * + CAST ( NULL AS INTEGER ) + - 3 / col2 ) OR NOT col0 BETWEEN col2 + + col1 AND NULL ORDER BY 1 DESC; +-- +ok +== +SELECT MIN ( DISTINCT + CAST ( NULL AS INTEGER ) ) * COUNT ( * ) * - + 16 * CASE + + AVG ( ALL 97 ) WHEN ( + NULLIF ( SUM ( CAST ( NULL AS REAL ) ), 6 ) ) THEN 51 * 31 + - 6 WHEN + 48 * - 34 THEN NULL WHEN 91 * + ( SUM ( CAST ( NULL AS INTEGER ) ) ) THEN NULL END * - 4 + - 67; +-- +ok +== diff --git a/parser/testdata/corpus/sql/function/operator/test_bitwise_ops.test b/parser/testdata/corpus/sql/function/operator/test_bitwise_ops.test new file mode 100644 index 0000000..50886df --- /dev/null +++ b/parser/testdata/corpus/sql/function/operator/test_bitwise_ops.test @@ -0,0 +1,65 @@ +# source: test/sql/function/operator/test_bitwise_ops.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +SELECT 1 << 2, NULL << 2, 2 << NULL +-- +ok +== +SELECT 16 >> 2, 1 >> 2, NULL >> 2, 2 >> NULL +-- +ok +== +SELECT 1 & 1, 1 & 0, 0 & 0, NULL & 1, 1 & NULL +-- +ok +== +SELECT 1 | 1, 1 | 0, 0 | 0, NULL | 1, 1 | NULL +-- +ok +== +SELECT xor(1, 1), xor(1, 0), xor(0, 0), xor(NULL, 1), xor(1, NULL) +-- +ok +== +SELECT 1::TINYINT << -1::TINYINT, 1::TINYINT >> -1::TINYINT, 1::TINYINT << 12::TINYINT, 1::TINYINT >> 12::TINYINT +-- +ok +== +SELECT 1::SMALLINT << -1::SMALLINT, 1::SMALLINT >> -1::SMALLINT, 1::SMALLINT << 20::SMALLINT, 1::SMALLINT >> 20::SMALLINT +-- +ok +== +SELECT 1::INT << -1::INT, 1::INT >> -1::INT, 1::INT << 40::INT, 1::INT >> 40::INT +-- +ok +== +SELECT 1::BIGINT << -1::BIGINT, 1::BIGINT >> -1::BIGINT, 1::BIGINT << 1000::BIGINT, 1::BIGINT >> 1000::BIGINT +-- +ok +== +SELECT 'hello' << 3 +-- +ok +== +SELECT 3 << 'hello' +-- +ok +== +SELECT 2.0 << 1 +-- +ok +== +SELECT 1::UTINYINT << 7, 1::USMALLINT << 15, 1::UINT32 << 31, 1::UBIGINT << 63 +-- +ok +== +SELECT 1::UINT32 << 32 +-- +ok +== +SELECT 2::UINT32 << 31 +-- +ok +== diff --git a/parser/testdata/corpus/sql/function/operator/test_bitwise_ops_types.test b/parser/testdata/corpus/sql/function/operator/test_bitwise_ops_types.test new file mode 100644 index 0000000..820bc51 --- /dev/null +++ b/parser/testdata/corpus/sql/function/operator/test_bitwise_ops_types.test @@ -0,0 +1,29 @@ +# source: test/sql/function/operator/test_bitwise_ops_types.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +CREATE TABLE bitwise_test(i TINYINT, j TINYINT) +-- +ok +== +INSERT INTO bitwise_test VALUES (1, 1), (1, 0), (0, 1), (0, 0), (1, NULL), (NULL, 1), (NULL, NULL) +-- +ok +== +SELECT i << j, i >> j, i & j, i | j, xor(i, j) FROM bitwise_test +-- +ok +== +CREATE TABLE bitwise_test(i SMALLINT, j SMALLINT) +-- +ok +== +CREATE TABLE bitwise_test(i INTEGER, j INTEGER) +-- +ok +== +CREATE TABLE bitwise_test(i BIGINT, j BIGINT) +-- +ok +== diff --git a/parser/testdata/corpus/sql/function/operator/test_comparison.test b/parser/testdata/corpus/sql/function/operator/test_comparison.test new file mode 100644 index 0000000..bac990e --- /dev/null +++ b/parser/testdata/corpus/sql/function/operator/test_comparison.test @@ -0,0 +1,53 @@ +# source: test/sql/function/operator/test_comparison.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +SELECT 1 == 1, 1 = 1, 1 == 0, 1 = 0, 1 == NULL +-- +ok +== +SELECT 1 <> 1, 1 != 1, 1 <> 0, 1 != 0, 1 <> NULL +-- +ok +== +SELECT 1 = 1 = 1; +-- +error: Parser Error: Chained comparisons are not supported, use AND to combine comparisons +== +SELECT 1 < 2 < 3; +-- +error: Parser Error: Chained comparisons are not supported, use AND to combine comparisons +== +SELECT 1 IS DISTINCT FROM 2 IS DISTINCT FROM 3; +-- +error: Parser Error: Chained comparisons are not supported, use AND to combine comparisons +== +SELECT 1 < 2 AND 2 < 3 +-- +ok +== +select ('abc' between 20 and True); +-- +ok +== +select 'abc' > 10 +-- +ok +== +select 20.0 = 'abc' +-- +ok +== +select '1000' > 20 +-- +ok +== +select '1000' > '20' +-- +ok +== +select ('abc' between '20' and 'true'); +-- +ok +== diff --git a/parser/testdata/corpus/sql/function/operator/test_comparison.test.metadata.json b/parser/testdata/corpus/sql/function/operator/test_comparison.test.metadata.json new file mode 100644 index 0000000..aea27ca --- /dev/null +++ b/parser/testdata/corpus/sql/function/operator/test_comparison.test.metadata.json @@ -0,0 +1,7 @@ +{ + "todo": { + "94bbc645841ee4b3": "transformer-raised parser error: upstream rejects in the transformer, not the grammar; expected to clear as transformers land (milestones 3-5)", + "9947ff756bfb6e1c": "transformer-raised parser error: upstream rejects in the transformer, not the grammar; expected to clear as transformers land (milestones 3-5)", + "ee6e0854346020ce": "transformer-raised parser error: upstream rejects in the transformer, not the grammar; expected to clear as transformers land (milestones 3-5)" + } +} diff --git a/parser/testdata/corpus/sql/function/operator/test_conjunction.test b/parser/testdata/corpus/sql/function/operator/test_conjunction.test new file mode 100644 index 0000000..c75748e --- /dev/null +++ b/parser/testdata/corpus/sql/function/operator/test_conjunction.test @@ -0,0 +1,137 @@ +# source: test/sql/function/operator/test_conjunction.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +CREATE TABLE a (i integer, j integer); +-- +ok +== +INSERT INTO a VALUES (3, 4), (4, 5), (5, 6); +-- +ok +== +SELECT * FROM a WHERE (i > 3 AND j < 5) OR (i > 3 AND j > 5); +-- +ok +== +explain SELECT * FROM a WHERE (i > 3 AND j < 5) OR (i > 3 AND j > 5); +-- +ok +== +SELECT true AND true +-- +ok +== +SELECT true AND false +-- +ok +== +SELECT false AND true +-- +ok +== +SELECT false AND false +-- +ok +== +SELECT false AND NULL +-- +ok +== +SELECT NULL AND false +-- +ok +== +SELECT NULL AND true +-- +ok +== +SELECT true AND NULL +-- +ok +== +SELECT true OR true +-- +ok +== +SELECT true OR NULL +-- +ok +== +SELECT NULL OR true +-- +ok +== +SELECT false OR NULL +-- +ok +== +SELECT NULL OR false +-- +ok +== +SELECT true OR false +-- +ok +== +SELECT false OR true +-- +ok +== +SELECT false OR false +-- +ok +== +SELECT true AND i>3 FROM a ORDER BY i +-- +ok +== +SELECT i>3 AND true FROM a ORDER BY i +-- +ok +== +SELECT 2>3 AND i>3 FROM a ORDER BY i +-- +ok +== +SELECT false AND i>3 FROM a ORDER BY i +-- +ok +== +SELECT i>3 AND false FROM a ORDER BY i +-- +ok +== +SELECT false OR i>3 FROM a ORDER BY i +-- +ok +== +SELECT i>3 OR false FROM a ORDER BY i +-- +ok +== +SELECT true OR i>3 FROM a ORDER BY i +-- +ok +== +SELECT i>3 OR true FROM a ORDER BY i +-- +ok +== +SELECT NULL OR i>3 FROM a ORDER BY i +-- +ok +== +SELECT i>3 OR NULL FROM a ORDER BY i +-- +ok +== +SELECT NULL AND i>3 FROM a ORDER BY i +-- +ok +== +SELECT i>3 AND NULL FROM a ORDER BY i +-- +ok +== diff --git a/parser/testdata/corpus/sql/function/operator/test_date_arithmetic.test b/parser/testdata/corpus/sql/function/operator/test_date_arithmetic.test new file mode 100644 index 0000000..d5c7ee6 --- /dev/null +++ b/parser/testdata/corpus/sql/function/operator/test_date_arithmetic.test @@ -0,0 +1,69 @@ +# source: test/sql/function/operator/test_date_arithmetic.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +INSERT INTO dates VALUES + ('1992-01-01'), + ('1992-03-03'), + ('1992-05-05'), + ('2022-01-01'), + ('044-03-15 (BC)'), + (NULL); +-- +ok +== +CREATE TABLE times(t TIME) +-- +ok +== +INSERT INTO times VALUES + ('00:01:20'), + ('20:08:10.998'), + ('20:08:10.33'), + ('20:08:10.001'), + (NULL); +-- +ok +== +SELECT d, t, d + t +FROM dates, times +ORDER BY 1, 2 +-- +ok +== +SELECT d, t, t + d +FROM dates, times +ORDER BY 1, 2 +-- +ok +== +CREATE TABLE timetzs(ttz TIMETZ) +-- +ok +== +INSERT INTO timetzs VALUES + ('00:01:20+00'), + ('20:08:10.998-07'), + ('20:08:10.33+12'), + ('20:08:10.001-1559'), + (NULL); +-- +ok +== +SELECT d, ttz, d + ttz +FROM dates, timetzs +ORDER BY 1, 2 +-- +ok +== +SELECT d, ttz, ttz + d +FROM dates, timetzs +ORDER BY 1, 2 +-- +ok +== +SELECT '294247-01-10'::DATE + '04:00:54.775808'::TIME; +-- +ok +== diff --git a/parser/testdata/corpus/sql/function/operator/test_division_overflow.test b/parser/testdata/corpus/sql/function/operator/test_division_overflow.test new file mode 100644 index 0000000..929a366 --- /dev/null +++ b/parser/testdata/corpus/sql/function/operator/test_division_overflow.test @@ -0,0 +1,37 @@ +# source: test/sql/function/operator/test_division_overflow.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +SELECT (-128)::TINYINT // (-1)::TINYINT +-- +ok +== +SELECT (-127)::TINYINT // (-1)::TINYINT +-- +ok +== +SELECT (-32768)::SMALLINT // (-1)::SMALLINT +-- +ok +== +SELECT (-32767)::SMALLINT // (-1)::SMALLINT +-- +ok +== +SELECT (-2147483648)::INTEGER // (-1)::INTEGER +-- +ok +== +SELECT (-2147483647)::INTEGER // (-1)::INTEGER +-- +ok +== +SELECT (-9223372036854775808)::BIGINT // (-1)::BIGINT +-- +ok +== +SELECT (-9223372036854775807)::BIGINT // (-1)::BIGINT +-- +ok +== diff --git a/parser/testdata/corpus/sql/function/operator/test_in_empty_table.test b/parser/testdata/corpus/sql/function/operator/test_in_empty_table.test new file mode 100644 index 0000000..33a5ed3 --- /dev/null +++ b/parser/testdata/corpus/sql/function/operator/test_in_empty_table.test @@ -0,0 +1,17 @@ +# source: test/sql/function/operator/test_in_empty_table.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +CREATE OR REPLACE TABLE test (a INTEGER) +-- +ok +== +SELECT * FROM test WHERE a IN ('a', 'b', 'c', 'd', 'e') +-- +ok +== +INSERT INTO test VALUES (42) +-- +ok +== diff --git a/parser/testdata/corpus/sql/function/string/format_bytes.test b/parser/testdata/corpus/sql/function/string/format_bytes.test new file mode 100644 index 0000000..c889ff6 --- /dev/null +++ b/parser/testdata/corpus/sql/function/string/format_bytes.test @@ -0,0 +1,101 @@ +# source: test/sql/function/string/format_bytes.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +SELECT format_bytes(0); +-- +ok +== +SELECT format_bytes(1); +-- +ok +== +SELECT format_bytes(1023); +-- +ok +== +SELECT format_bytes(1024); +-- +ok +== +SELECT pg_size_pretty(1024); +-- +ok +== +SELECT format_bytes(1024*1024-1); +-- +ok +== +SELECT format_bytes(1024*1024); +-- +ok +== +SELECT format_bytes(1024*1024 + 555555); +-- +ok +== +SELECT format_bytes(1024*1024*1024-1); +-- +ok +== +SELECT format_bytes(1e9::BIGINT); +-- +ok +== +SELECT format_bytes(pow(1024,3)::BIGINT); +-- +ok +== +SELECT format_bytes(pow(1024.0,4)::BIGINT); +-- +ok +== +SELECT format_bytes((pow(1024.0,4) - 1)::BIGINT); +-- +ok +== +SELECT format_bytes(1e15::BIGINT); +-- +ok +== +SELECT format_bytes(9223372036854775807); +-- +ok +== +SELECT format_bytes(NULL); +-- +ok +== +SELECT format_bytes(-1); +-- +ok +== +SELECT format_bytes(-9223372036854775808); +-- +ok +== +SELECT formatReadableDecimalSize(500); +-- +ok +== +SELECT formatReadableSize(500); +-- +ok +== +SELECT formatReadableDecimalSize(500*1000); +-- +ok +== +SELECT formatReadableSize(500*1000); +-- +ok +== +SELECT formatReadableDecimalSize(500*1000*1000); +-- +ok +== +SELECT formatReadableSize(500*1000*1000); +-- +ok +== diff --git a/parser/testdata/corpus/sql/function/string/hex.test b/parser/testdata/corpus/sql/function/string/hex.test new file mode 100644 index 0000000..edf21ae --- /dev/null +++ b/parser/testdata/corpus/sql/function/string/hex.test @@ -0,0 +1,57 @@ +# source: test/sql/function/string/hex.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +SELECT to_hex('duckdb'); +-- +ok +== +SELECT hex(unhex('abcd')); +-- +ok +== +SELECT hex(blob '\x00\x00\x80'); +-- +ok +== +SELECT from_hex('6475636B6462'); +-- +ok +== +SELECT from_hex('5'); +-- +ok +== +SELECT unhex(hex('duckdb')) +-- +ok +== +SELECT from_hex('duckdb'); +-- +ok +== +SELECT to_hex(columns('^(.*int|varchar|bignum)$')) FROM test_all_types(); +-- +ok +== +SELECT from_hex(to_hex(columns('^(.*int|varchar|bignum)$'))) FROM test_all_types(); +-- +ok +== +SELECT to_binary('duckdb'); +-- +ok +== +SELECT from_binary('011001000111010101100011011010110110010001100010'); +-- +ok +== +SELECT to_binary(columns('^(.*int|varchar|bignum)$')) FROM test_all_types(); +-- +ok +== +SELECT from_binary(to_binary(columns('^(.*int|varchar|bignum)$'))) FROM test_all_types(); +-- +ok +== diff --git a/parser/testdata/corpus/sql/function/string/like_unicode.test b/parser/testdata/corpus/sql/function/string/like_unicode.test new file mode 100644 index 0000000..67a721d --- /dev/null +++ b/parser/testdata/corpus/sql/function/string/like_unicode.test @@ -0,0 +1,45 @@ +# source: test/sql/function/string/like_unicode.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +CREATE TABLE t0 (c0 VARCHAR); +-- +ok +== +INSERT INTO t0 VALUES ('票'),('t'),('%'),('丑'),('多'), ('🦆'); +-- +ok +== +SELECT count(*) FROM t0 WHERE t0.c0 LIKE '_'; +-- +ok +== +SELECT count(*) FROM t0 WHERE t0.c0 ILIKE '_'; +-- +ok +== +SELECT '🦆a🦆' LIKE '_a_' +-- +ok +== +SELECT '🦆a🦆' ILIKE '_A_' +-- +ok +== +SELECT 'BaB' ILIKE '_A_' +-- +ok +== +SELECT '🦆🦆' ILIKE '_' +-- +ok +== +SELECT '🦆🦆' ILIKE '__' +-- +ok +== +SELECT '🦆🦆' ILIKE '___' +-- +ok +== diff --git a/parser/testdata/corpus/sql/function/string/md5.test b/parser/testdata/corpus/sql/function/string/md5.test new file mode 100644 index 0000000..e411612 --- /dev/null +++ b/parser/testdata/corpus/sql/function/string/md5.test @@ -0,0 +1,37 @@ +# source: test/sql/function/string/md5.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +select md5('hello'), md5(NULL) +-- +ok +== +select md5('\xff\xff'::BLOB) +-- +ok +== +select md5_number('hello'), md5_number_upper(NULL) +-- +ok +== +select md5_number_upper('hello'), md5_number_upper(NULL) +-- +ok +== +select md5_number_lower('hello'), md5_number_lower(NULL) +-- +ok +== +CREATE TABLE strings AS SELECT s::VARCHAR s FROM generate_series(0,10,1) t(s) +-- +ok +== +select md5(s), md5('1') from strings ORDER BY s +-- +ok +== +select md5(s), md5('1') from strings where s::INTEGER BETWEEN 1 AND 3 ORDER BY s +-- +ok +== diff --git a/parser/testdata/corpus/sql/function/string/null_byte.test b/parser/testdata/corpus/sql/function/string/null_byte.test new file mode 100644 index 0000000..4f67997 --- /dev/null +++ b/parser/testdata/corpus/sql/function/string/null_byte.test @@ -0,0 +1,98 @@ +# source: test/sql/function/string/null_byte.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +SELECT chr(0) +-- +ok +== +SELECT chr(0)::blob +-- +ok +== +select ascii(chr(0)); +-- +ok +== +CREATE TABLE null_byte AS SELECT concat('goo', chr(0), 'se') AS v +-- +ok +== +SELECT * FROM null_byte +-- +ok +== +SELECT * FROM null_byte WHERE contains(v, chr(0)) +-- +ok +== +SELECT instr(v, chr(0)) FROM null_byte +-- +ok +== +SELECT * FROM null_byte WHERE v LIKE concat('%', chr(0), '%') +-- +ok +== +SELECT * FROM null_byte WHERE regexp_matches(v, chr(0)) +-- +ok +== +SELECT * FROM null_byte WHERE regexp_full_match(v, concat('goo', chr(0), 'se')) +-- +ok +== +SELECT {'a': v} FROM null_byte +-- +ok +== +SELECT [v] FROM null_byte +-- +ok +== +SELECT LENGTH(v) FROM null_byte +-- +ok +== +SELECT STRLEN(v) FROM null_byte +-- +ok +== +SELECT LENGTH_GRAPHEME(v) FROM null_byte +-- +ok +== +SELECT v||v FROM null_byte +-- +ok +== +SELECT printf('%s - zzz', v) FROM null_byte +-- +ok +== +SELECT substr(v, 4) FROM null_byte +-- +ok +== +CREATE TABLE more_null_bytes AS +SELECT 1 AS id, v FROM null_byte +UNION ALL +SELECT 2 AS id, substr(v, 4, 1) FROM null_byte +UNION ALL +SELECT 3 AS id, v FROM null_byte +-- +ok +== +SELECT * FROM more_null_bytes ORDER BY v, id +-- +ok +== +SELECT v, SUM(id) FROM more_null_bytes GROUP BY v ORDER BY ALL +-- +ok +== +SELECT COUNT(*) FROM null_byte JOIN more_null_bytes USING(v) +-- +ok +== diff --git a/parser/testdata/corpus/sql/function/string/overlay.test b/parser/testdata/corpus/sql/function/string/overlay.test new file mode 100644 index 0000000..394acb2 --- /dev/null +++ b/parser/testdata/corpus/sql/function/string/overlay.test @@ -0,0 +1,137 @@ +# source: test/sql/function/string/overlay.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +SELECT OVERLAY('abcdef' PLACING 'XX' FROM 3) +-- +ok +== +SELECT OVERLAY('abcdef', 'XX', 3) +-- +ok +== +SELECT overlay('abcdef' PLACING 'XXX' FROM 2) +-- +ok +== +SELECT overlay('abcdef' PLACING 'XX' FROM 3 FOR 2) +-- +ok +== +SELECT overlay('abcdef' PLACING 'XX' FROM 3 FOR 0) +-- +ok +== +SELECT overlay('abcdef', 'XX', 3, 0) +-- +ok +== +SELECT overlay('abcdef' PLACING 'Z' FROM 3 FOR 10) +-- +ok +== +SELECT overlay(NULL PLACING 'XX' FROM 2) +-- +ok +== +SELECT overlay('abcdef' PLACING NULL FROM 2) +-- +ok +== +SELECT overlay('33333rce' placing 'resou' from 1); +-- +ok +== +SELECT overlay('33333rce' placing 'resou' from 0); +-- +ok +== +SELECT overlay('33333rce' placing 'resou' from -1); +-- +ok +== +SELECT overlay('33333rce' placing 'resou' from -100); +-- +ok +== +SELECT overlay('33333rce' placing 'resou' from 1 FOR -1); +-- +ok +== +SELECT overlay('33333rce' placing 'resou' from 1 FOR -100); +-- +ok +== +SELECT overlay('café' placing 'X' from 4) +-- +ok +== +SELECT overlay('café' placing 'X' from 4 for 1) +-- +ok +== +SELECT overlay('hello🌍world' placing 'X' from 6) +-- +ok +== +SELECT overlay('hello🌍world' placing 'X' from 6 for 1) +-- +ok +== +SELECT overlay('日本語テスト' placing 'XX' from 3) +-- +ok +== +SELECT overlay('日本語テスト' placing 'XX' from 3 for 2) +-- +ok +== +SELECT overlay('' placing 'abc' from 1) +-- +ok +== +SELECT overlay('hello' placing '' from 3) +-- +ok +== +SELECT overlay('' placing '' from 1) +-- +ok +== +SELECT overlay('abc' placing 'X' from 10) +-- +ok +== +SELECT overlay('abc' placing 'XY' from 5) +-- +ok +== +SELECT overlay('abc' placing 'X' from 4) +-- +ok +== +SELECT overlay('abc' placing 'X' from 2 for cast(null as bigint)) +-- +ok +== +SELECT overlay('abcdef' placing 'XY' from 0 for 2) +-- +ok +== +SELECT overlay('abcdef' placing 'XY' from -1 for 2) +-- +ok +== +CREATE TABLE t(s STRING); +-- +ok +== +INSERT INTO t VALUES ('abcdef'), ('hello'), ('xy'), (NULL); +-- +ok +== +SELECT overlay(s PLACING '__' FROM 2 FOR 2) FROM t +-- +ok +== diff --git a/parser/testdata/corpus/sql/function/string/parse_formatted_bytes.test b/parser/testdata/corpus/sql/function/string/parse_formatted_bytes.test new file mode 100644 index 0000000..3d5b005 --- /dev/null +++ b/parser/testdata/corpus/sql/function/string/parse_formatted_bytes.test @@ -0,0 +1,165 @@ +# source: test/sql/function/string/parse_formatted_bytes.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +SELECT parse_formatted_bytes('0 B'); +-- +ok +== +SELECT parse_formatted_bytes('1 byte'); +-- +ok +== +SELECT parse_formatted_bytes('2 bytes'); +-- +ok +== +SELECT parse_formatted_bytes('1 b'); +-- +ok +== +SELECT parse_formatted_bytes('1 KB'); +-- +ok +== +SELECT parse_formatted_bytes('1.5 KB'); +-- +ok +== +SELECT parse_formatted_bytes('2 MB'); +-- +ok +== +SELECT parse_formatted_bytes('1 GB'); +-- +ok +== +SELECT parse_formatted_bytes('1 TB'); +-- +ok +== +SELECT parse_formatted_bytes('1 KiB'); +-- +ok +== +SELECT parse_formatted_bytes('1.5 KiB'); +-- +ok +== +SELECT parse_formatted_bytes('2 MiB'); +-- +ok +== +SELECT parse_formatted_bytes('1 GiB'); +-- +ok +== +SELECT parse_formatted_bytes('5MB'); +-- +ok +== +SELECT parse_formatted_bytes(' 2 mib '); +-- +ok +== +SELECT parse_formatted_bytes('1e3 b'); +-- +ok +== +SELECT parse_formatted_bytes(NULL); +-- +ok +== +WITH data(value) AS ( + VALUES + ('1 KB'), + ('2 MB'), + ('3 GiB'), + ('4 TB'), + (NULL) +) +SELECT value, parse_formatted_bytes(value) AS bytes FROM data; +-- +ok +== +SELECT parse_formatted_bytes('null'); +-- +ok +== +SELECT parse_formatted_bytes('none'); +-- +ok +== +SELECT parse_formatted_bytes('5'); +-- +ok +== +SELECT parse_formatted_bytes('abc'); +-- +ok +== +SELECT parse_formatted_bytes('1 Ki'); +-- +ok +== +SELECT parse_formatted_bytes(1933); +-- +ok +== +SELECT parse_formatted_bytes('10000000000 TiB'); +-- +ok +== +SELECT parse_formatted_bytes('1.5.3 GB'); +-- +ok +== +SELECT parse_formatted_bytes('inf GiB'); +-- +ok +== +SELECT parse_formatted_bytes('-5 MB'); +-- +ok +== +SELECT parse_formatted_bytes(' -1 KiB'); +-- +ok +== +SELECT try(parse_formatted_bytes('abc')); +-- +ok +== +SELECT try(parse_formatted_bytes('-5 MB')); +-- +ok +== +SELECT try(parse_formatted_bytes('10000000000 TiB')); +-- +ok +== +SELECT try(parse_formatted_bytes('1.5.3 GB')); +-- +ok +== +SELECT try(parse_formatted_bytes('inf GiB')); +-- +ok +== +SELECT try(parse_formatted_bytes('1 Ki')); +-- +ok +== +SELECT try(parse_formatted_bytes('5')); +-- +ok +== +SELECT try(parse_formatted_bytes('none')); +-- +ok +== +SELECT try(parse_formatted_bytes('null')); +-- +ok +== diff --git a/parser/testdata/corpus/sql/function/string/parse_path.test b/parser/testdata/corpus/sql/function/string/parse_path.test new file mode 100644 index 0000000..d5f6ec1 --- /dev/null +++ b/parser/testdata/corpus/sql/function/string/parse_path.test @@ -0,0 +1,337 @@ +# source: test/sql/function/string/parse_path.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +SELECT * FROM (VALUES (parse_path('path/to/file.csv', 'system')), (parse_path('path/to/file.csv\file2.csv', 'both_slash')), (parse_path('path/to/file.csv', 'forward_slash')), (parse_path('path\to\file.csv/file2.csv', 'backslash'))) tbl(i); +-- +ok +== +SELECT parse_path('path/to/file.csv\file2.csv'); +-- +ok +== +SELECT parse_path('file.csv', 'both_slash'); +-- +ok +== +SELECT parse_path('/path/to/file.csv', 'forward_slash'); +-- +ok +== +select parse_path('\path\to\file', 'forward_slash'); +-- +ok +== +SELECT parse_path('//path/to//file.csv', 'forward_slash'); +-- +ok +== +SELECT parse_path('p@th\t0\wh@t3ve%\42/12 ch,ars.sth', 'both_slash'); +-- +ok +== +SELECT parse_path('path/to/file.csv','@'); +-- +ok +== +SELECT parse_path('path/to/file.csv', NULL); +-- +ok +== +SELECT parse_path(NULL, NULL); +-- +ok +== +SELECT parse_path(NULL, ''); +-- +ok +== +SELECT parse_path(''); +-- +ok +== +SELECT parse_path('', ''); +-- +ok +== +select parse_path('/'); +-- +ok +== +select parse_path('///'); +-- +ok +== +SELECT parse_path('/\\/', 'both_slash'); +-- +ok +== +SELECT parse_path(); +-- +ok +== +SELECT parse_path('/path/to', true, 'system'); +-- +ok +== +SELECT * FROM (VALUES (parse_dirname('path/to/file.csv', 'system')), (parse_dirname('path/to/file.csv\file2.csv', 'both_slash')), (parse_dirname('path/to/file.csv', 'forward_slash')), (parse_dirname('path\to\file.csv/file2.csv', 'backslash'))) tbl(i); +-- +ok +== +SELECT parse_dirname('path/to/file.csv\file2.csv'); +-- +ok +== +SELECT parse_dirname('file.csv', 'backslash'); +-- +ok +== +SELECT parse_dirname('\', 'backslash'); +-- +ok +== +SELECT parse_dirname('/', 'backslash'); +-- +ok +== +SELECT parse_dirname('/path/to/file.csv', 'forward_slash'); +-- +ok +== +SELECT parse_dirname('\path\to\file', 'forward_slash'); +-- +ok +== +SELECT parse_dirname('///path/to//file.csv', 'forward_slash'); +-- +ok +== +SELECT parse_dirname('wh@t3ve%\42/12 ch,ars.sth', 'both_slash'); +-- +ok +== +SELECT parse_dirname('path/to/file.csv','@'); +-- +ok +== +SELECT parse_dirname('path/to/file.csv', NULL); +-- +ok +== +SELECT parse_dirname(NULL, NULL); +-- +ok +== +SELECT parse_dirname(NULL, ''); +-- +ok +== +SELECT parse_dirname(''); +-- +ok +== +SELECT parse_dirname('', ''); +-- +ok +== +SELECT parse_dirname(); +-- +ok +== +SELECT parse_dirname('/path/to', true, 'system'); +-- +ok +== +SELECT * FROM (VALUES (parse_dirpath('path/to/file.csv', 'system')), (parse_dirpath('path/to/file.csv\file2.csv', 'both_slash')), (parse_dirpath('path/to/file.csv', 'forward_slash')), (parse_dirpath('path\to\file.csv/file2.csv', 'backslash'))) tbl(i); +-- +ok +== +SELECT parse_dirpath('path/to/file.csv\file2.csv'); +-- +ok +== +SELECT parse_dirpath('file.csv', 'backslash'); +-- +ok +== +SELECT parse_dirpath('\', 'backslash'); +-- +ok +== +SELECT parse_dirpath('/', 'backslash'); +-- +ok +== +SELECT parse_dirpath('/path/to/file.csv', 'forward_slash'); +-- +ok +== +SELECT parse_dirpath('\path\to\file', 'forward_slash'); +-- +ok +== +SELECT parse_dirpath('///path/to//file.csv', 'forward_slash'); +-- +ok +== +SELECT parse_dirpath('wh@t3ve%\42/12 ch,ars.sth', 'both_slash'); +-- +ok +== +SELECT parse_dirpath('path/to/file.csv','@'); +-- +ok +== +SELECT parse_dirpath('path/to/file.csv', NULL); +-- +ok +== +SELECT parse_dirpath(NULL, NULL); +-- +ok +== +SELECT parse_dirpath(NULL, ''); +-- +ok +== +SELECT parse_dirpath(''); +-- +ok +== +SELECT parse_dirpath('', ''); +-- +ok +== +SELECT parse_dirpath(); +-- +ok +== +SELECT parse_dirpath('/path/to', true, 'system'); +-- +ok +== +SELECT * FROM (VALUES (parse_filename('path/to/file.csv', 'system')), (parse_filename('path/to/file.csv\file2.csv', 'both_slash')), (parse_filename('path/to/file.csv', 'forward_slash')), (parse_filename('path\to\file.csv/file2.csv', 'backslash'))) tbl(i); +-- +ok +== +SELECT parse_filename('path/to/file.csv\file2.csv'); +-- +ok +== +SELECT parse_filename('/path/to/file.csv\file2.csv', true); +-- +ok +== +SELECT parse_filename('/path/to/file.csv\file2.csv', false); +-- +ok +== +SELECT * FROM (VALUES (parse_filename('path/to/file.csv', true, 'system')), (parse_filename('path/to/file.csv\file2.csv', true, 'both_slash')), (parse_filename('path/to/file.csv', true, 'forward_slash')), (parse_filename('path\to\file.csv/file2.csv', true, 'backslash'))) tbl(i); +-- +ok +== +SELECT parse_filename('path/to/file.csv\file2', true, 'forward_slash'); +-- +ok +== +SELECT parse_filename('path/to/file.csv', 'true', 'system'); +-- +ok +== +SELECT parse_filename('path/to/file.csv', 'false', 'system'); +-- +ok +== +SELECT parse_filename('file.csv', 'backslash'); +-- +ok +== +SELECT parse_filename('file.csv', true, 'backslash'); +-- +ok +== +select parse_filename('/'); +-- +ok +== +select parse_filename('//'); +-- +ok +== +select parse_filename('/', 'backslash'); +-- +ok +== +SELECT parse_filename('/', true, 'forward_slash'); +-- +ok +== +SELECT parse_filename('path/to/', 'forward_slash'); +-- +ok +== +SELECT parse_filename('path/to///', true, 'forward_slash'); +-- +ok +== +SELECT parse_filename('wh@t3ve%\42/12 ch,ars.sth', 'both_slash'); +-- +ok +== +SELECT parse_filename('wh@t3ve%\42/12 ch,ars.sth', true, 'both_slash'); +-- +ok +== +SELECT parse_filename('path/to/file.csv','@'); +-- +ok +== +SELECT parse_filename('path/to/file', true, 'both_slash'); +-- +ok +== +SELECT parse_filename(NULL, true, 'system'); +-- +ok +== +SELECT parse_filename('path/to/file.csv', NULL); +-- +ok +== +SELECT parse_filename('path/to/file.csv', NULL, NULL); +-- +ok +== +SELECT parse_filename(NULL, NULL, NULL); +-- +ok +== +SELECT parse_filename(NULL, ''); +-- +ok +== +SELECT parse_filename('', ''); +-- +ok +== +SELECT parse_filename(''); +-- +ok +== +SELECT parse_filename(true); +-- +ok +== +SELECT parse_filename('path/to/file.csv', 'system', true); +-- +ok +== +SELECT parse_filename('path/to/file.csv', 'system', 'true'); +-- +ok +== +SELECT parse_filename(); +-- +ok +== diff --git a/parser/testdata/corpus/sql/function/string/parse_path_windows.test b/parser/testdata/corpus/sql/function/string/parse_path_windows.test new file mode 100644 index 0000000..0ec5207 --- /dev/null +++ b/parser/testdata/corpus/sql/function/string/parse_path_windows.test @@ -0,0 +1,49 @@ +# source: test/sql/function/string/parse_path_windows.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +SELECT * FROM (VALUES (parse_path('path\to\file.csv/file2.csv', 'system')), (parse_path('path/to/file.csv\file2.csv', 'both_slash')), (parse_path('path/to/file.csv', 'forward_slash')), (parse_path('path\to\file.csv/file2.csv', 'backslash'))) tbl(i); +-- +ok +== +SELECT parse_path('home/user/documents/file.csv\file2.csv'); +-- +ok +== +SELECT parse_path('//path/to///file.csv', 'forward_slash'); +-- +ok +== +SELECT * FROM (VALUES (parse_dirname('path\to\file.csv/file2.csv', 'system')), (parse_dirname('path/to/file.csv\file2.csv', 'both_slash')), (parse_dirname('path/to/file.csv', 'forward_slash')), (parse_dirname('path\to\file.csv/file2.csv', 'backslash'))) tbl(i); +-- +ok +== +select parse_dirname('file.csv'); +-- +ok +== +SELECT * FROM (VALUES (parse_dirpath('path\to\file.csv/file2.csv', 'system')), (parse_dirpath('path/to/file.csv\file2.csv', 'both_slash')), (parse_dirpath('path/to/file.csv', 'forward_slash')), (parse_dirpath('path\to\file.csv/file2.csv', 'backslash'))) tbl(i); +-- +ok +== +select parse_dirpath('file.csv'); +-- +ok +== +SELECT * FROM (VALUES (parse_filename('path\to\file.csv/file2.csv', 'system')), (parse_filename('path/to/file.csv\file2.csv', 'both_slash')), (parse_filename('path/to/file.csv', 'forward_slash')), (parse_filename('path\to\file.csv/file2.csv', 'backslash'))) tbl(i); +-- +ok +== +SELECT parse_filename('file2.csv/', 'forward_slash'); +-- +ok +== +SELECT parse_filename('path/to/file.csv\file2', true, 'backslash'); +-- +ok +== +SELECT parse_filename('/path/to/file.csv\file2.csv', true, 'forward_slash'); +-- +ok +== diff --git a/parser/testdata/corpus/sql/function/string/path_join.test b/parser/testdata/corpus/sql/function/string/path_join.test new file mode 100644 index 0000000..59dc449 --- /dev/null +++ b/parser/testdata/corpus/sql/function/string/path_join.test @@ -0,0 +1,106 @@ +# source: test/sql/function/string/path_join.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +SELECT path_join('dir//subdir/', './file'); +-- +ok +== +SELECT path_join('dir/subdir', '../sibling'); +-- +ok +== +SELECT path_join('dir', '/abs/path'); +-- +ok +== +SELECT path_join('dir///', 'nested///child'); +-- +ok +== +SELECT path_join('dir', 'subdir', 'file.txt'); +-- +ok +== +SELECT path_join('dir/..', '../..'); +-- +ok +== +SELECT path_join('/usr/local', '../..'); +-- +ok +== +SELECT path_join('/', 'usr/local'); +-- +ok +== +SELECT path_join('file:/usr/local', '../bin'); +-- +ok +== +SELECT path_join('s3://foo', 'bar/baz'); +-- +ok +== +SELECT path_join('s3://foo', '..'); +-- +ok +== +SELECT path_join('s3://foo', '../..'); +-- +ok +== +SELECT path_join('s3://foo', '/foo'); +-- +ok +== +SELECT path_join('/foo', 's3://foo'); +-- +ok +== +SELECT path_join('s3://foo', 'az://foo'); +-- +ok +== +SELECT path_join(); +-- +ok +== +SELECT path_join(''); +-- +ok +== +SELECT path_join('', ''); +-- +ok +== +SELECT path_join(NULL); +-- +ok +== +SELECT path_join(NULL, NULL); +-- +ok +== +SELECT path_join(NULL, 'dir'); +-- +ok +== +SELECT path_join('dir', NULL); +-- +ok +== +SELECT path_join('base', NULL, 'dir'); +-- +ok +== +SELECT path_join('asdfoijasdofijasdofijasüîø✅xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyy-/QQQQ/', + 'IIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIII'); +-- +ok +== +SELECT path_join(A, B, C, B, A) FROM (SELECT A:'a', B: 'b', C: 'c'); +-- +ok +== diff --git a/parser/testdata/corpus/sql/function/string/regex_capture.test b/parser/testdata/corpus/sql/function/string/regex_capture.test new file mode 100644 index 0000000..52d36c1 --- /dev/null +++ b/parser/testdata/corpus/sql/function/string/regex_capture.test @@ -0,0 +1,112 @@ +# source: test/sql/function/string/regex_capture.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +CREATE TABLE filenames (filename VARCHAR); +-- +ok +== +INSERT INTO filenames VALUES + ('rundate_2023-01-01_pass_1'), + ('rundate_2023-01-01_pass_2'), + ('rundate_2023-01-01_pass_3'), + ('rundate_2023-01-10_pass_1'), + ('rundate_2023-01-10_pass_2'), + ('rundate_2023-02-14_pass_1'), + ('invalid'), + (NULL) +; +-- +ok +== +WITH files AS ( + SELECT f.*, payload FROM filenames f, range(3) t(payload) +), extracted AS ( + SELECT regexp_extract(filename, 'rundate_(\d+-\d+-\d+)_pass_(\d+)', ['rundate', 'pass']) AS groups, payload + FROM files +) +SELECT groups.rundate::DATE AS rundate, groups.pass::SMALLINT AS PASS, SUM(payload) +FROM extracted +WHERE LENGTH(groups.rundate) > 0 +GROUP BY ALL +-- +ok +== +WITH files AS ( + SELECT f.*, payload FROM filenames f, range(1000) t(payload) +), extracted AS ( + SELECT regexp_extract(filename, 'rundate_(\d+-\d+-\d+)_pass_(\d+)', ['rundate', 'pass']) AS groups, payload + FROM files +) +SELECT groups.rundate::DATE AS rundate, groups.pass::SMALLINT AS PASS, SUM(payload) +FROM extracted +WHERE LENGTH(groups.rundate) > 0 +GROUP BY ALL +-- +ok +== +WITH files AS ( + SELECT f.*, payload FROM filenames f, range(3) t(payload) +), extracted AS ( + SELECT regexp_extract(filename, 'rundate_(\d+-\d+-\d+)_([a-z]+?)_(\d+)', ['rundate', 'opt', 'pass']) AS groups, payload + FROM files +) +SELECT groups.rundate::DATE AS rundate, groups.opt AS opt, groups.pass::SMALLINT AS pass, SUM(payload) +FROM extracted +WHERE LENGTH(groups.rundate) > 0 +GROUP BY ALL +-- +ok +== +WITH files AS ( + SELECT f.*, payload FROM filenames f, range(3) t(payload) +), extracted AS ( + SELECT regexp_extract(filename, 'rundate_(\d+-\d+-\d+)_([0-9]+?)_(\d+)', ['rundate', 'opt', 'pass']) AS groups, payload + FROM files +) +SELECT groups.rundate::DATE AS rundate, groups.opt AS opt, groups.pass::SMALLINT AS pass, SUM(payload) +FROM extracted +WHERE LENGTH(groups.rundate) > 0 +GROUP BY ALL +-- +ok +== +SELECT regexp_extract(filename, 'rundate_(\d+-\d+-\d+)_pass_(\d+)', []) AS groups +FROM filenames +-- +ok +== +WITH patterns AS ( + SELECT 'rundate_(\d+-\d+-\d+)_pass_(\d+)' AS pattern FROM range(3) +) +SELECT regexp_extract(filename, pattern, ['rundate', 'pass']) AS groups +FROM filenames, patterns +-- +ok +== +SELECT regexp_extract(filename, 'rundate_(\d+-\d+-\d+)_pass_(\d+)', ['rundate', NULL]) AS groups +FROM filenames +-- +ok +== +SELECT regexp_extract(filename, 'rundate_(\d+-\d+-\d+)_pass_(\d+)', ['rundate', 'rundate']) AS groups +FROM filenames +-- +ok +== +SELECT regexp_extract(filename, 'rundate_(\d+-\d+-\d+)_pass_(\d+)', ['rundate', 'RUNDATE']) AS groups +FROM filenames +-- +ok +== +SELECT regexp_extract(filename, 'rundate_(\d+-\d+-\d+)_pass_(\d+)', ['rundate', 'pass', 'overflow']) AS groups +FROM filenames +-- +ok +== +SELECT regexp_extract(filename, NULL, ['rundate', 'pass']) AS groups +FROM filenames +-- +ok +== diff --git a/parser/testdata/corpus/sql/function/string/regex_escape.test b/parser/testdata/corpus/sql/function/string/regex_escape.test new file mode 100644 index 0000000..0d7bba6 --- /dev/null +++ b/parser/testdata/corpus/sql/function/string/regex_escape.test @@ -0,0 +1,77 @@ +# source: test/sql/function/string/regex_escape.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +SELECT regexp_escape('https://duckdb.org'); +-- +ok +== +SELECT regexp_escape('abc123ABC'); +-- +ok +== +SELECT regexp_escape('a.b[c]*'); +-- +ok +== +SELECT regexp_escape('a b c'); +-- +ok +== +SELECT regexp_escape('\n'); +-- +ok +== +SELECT regexp_escape('line1\nline2'); +-- +ok +== +SELECT regexp_escape('@'); +-- +ok +== +SELECT regexp_escape('path\to\wonderland'); +-- +ok +== +SELECT regexp_escape('$()*+.?[\]^{|}-'); +-- +ok +== +CREATE TABLE tbl (c VARCHAR(255)); +-- +ok +== +INSERT INTO tbl SELECT 'a)*.?[\]b^{2.+_c' FROM generate_series(1, 500); +-- +ok +== +INSERT INTO tbl(c) SELECT '1?ch@racter$' FROM generate_series(1, 500); +-- +ok +== +SELECT regexp_escape(c) FROM tbl; +-- +ok +== +WITH cte AS ( + SELECT c + FROM tbl + LIMIT 500 +) +SELECT sum(cast(regexp_escape(c) = 'a\)\*\.\?\[\\\]b\^\{2\.\+_c' as int)) +FROM cte +-- +ok +== +WITH cte AS ( + SELECT c + FROM tbl + OFFSET 500 LIMIT 500 +) +SELECT sum(cast(regexp_escape(c) = '1\?ch\@racter\$' as int)) +FROM cte +-- +ok +== diff --git a/parser/testdata/corpus/sql/function/string/regex_extract.test b/parser/testdata/corpus/sql/function/string/regex_extract.test new file mode 100644 index 0000000..e65eae1 --- /dev/null +++ b/parser/testdata/corpus/sql/function/string/regex_extract.test @@ -0,0 +1,106 @@ +# source: test/sql/function/string/regex_extract.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +SELECT regexp_extract('foobarbaz', 'b..') +-- +ok +== +SELECT regexp_extract('foobarbaz', 'B..') +-- +ok +== +SELECT regexp_extract('foobarbaz', 'B..', 0, 'i') +-- +ok +== +SELECT regexp_extract('foobarbaz', 'b..', 1) +-- +ok +== +SELECT regexp_extract('foobarbaz', '(b..)(b..)') +-- +ok +== +SELECT regexp_extract('foobarbaz', '(b..)(b..)', 1) +-- +ok +== +SELECT regexp_extract('foobarbaz', '(b..)(b..)', 2) +-- +ok +== +SELECT regexp_extract('foobarbaz', '(b..)(b..)', -1) +-- +ok +== +SELECT regexp_extract('foobarbaz', '(b..)(b..)', 42) +-- +ok +== +CREATE TABLE test (s VARCHAR, p VARCHAR, i INT) +-- +ok +== +INSERT INTO test VALUES + ('foobarbaz', 'b..', 0), + ('foobarbaz', 'b..', 1), + ('foobarbaz', '(b..)(b..)', 0), + ('foobarbaz', '(b..)(b..)', 1), + ('foobarbaz', '(b..)(b..)', 2) +-- +ok +== +SELECT regexp_extract(s, p, i) FROM test +-- +ok +== +SELECT regexp_extract(s, p, 0) FROM test +-- +ok +== +SELECT regexp_extract(s, 'b..', 0) FROM test +-- +ok +== +SELECT regexp_extract(s, '(b..)(b..)', i) FROM test +-- +ok +== +SELECT regexp_extract('foobarbaz', NULL, 0) +-- +ok +== +SELECT regexp_extract('foobarbaz', 'b..', NULL) +-- +ok +== +SELECT regexp_extract(NULL, 'b..') +-- +ok +== +SELECT regexp_extract('foobarbaz', 'b..', '1') +-- +ok +== +SELECT regexp_extract('foobarbaz', '(zzz)', 1, 'k') +-- +ok +== +SELECT regexp_extract('foobarbaz', '(b..)', 1, 'k') +-- +ok +== +SELECT regexp_extract('FOOBARBAZ', '(zzz)', 1, 'ik') +-- +ok +== +SELECT regexp_extract('FOOBARBAZ', '(b..)', 1, 'ik') +-- +ok +== +SELECT regexp_replace('foobarbaz', 'b..', 'X', 'k') +-- +ok +== diff --git a/parser/testdata/corpus/sql/function/string/regex_extract_all.test b/parser/testdata/corpus/sql/function/string/regex_extract_all.test new file mode 100644 index 0000000..16185d0 --- /dev/null +++ b/parser/testdata/corpus/sql/function/string/regex_extract_all.test @@ -0,0 +1,489 @@ +# source: test/sql/function/string/regex_extract_all.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +SELECT regexp_extract_all('1a 2b 14m', '(\d+)', 1); +-- +ok +== +SELECT regexp_extract_all('1a 2b 14m', '(\d+)([a-z]+)', 2) +-- +ok +== +SELECT REGEXP_EXTRACT_ALL('test', '.') +-- +ok +== +SELECT regexp_extract_all('1a 2b 14m', '(\\d+)([a-z]+)', -1); +-- +ok +== +SELECT regexp_extract_all('1a 2b 14m', '\\d+'); +-- +ok +== +SELECT regexp_extract_all('1a 2b 14m', '\\d+', 0); +-- +ok +== +SELECT regexp_extract_all('1a 2b 14m', '\\d+', 1); +-- +ok +== +SELECT regexp_extract_all('1a 2b 14m', '\\d+', 2); +-- +ok +== +SELECT regexp_extract_all('1a 2b 14m', '\\d+', -1); +-- +ok +== +SELECT regexp_extract_all('1a 2b 14m', '(\\d+)?', 1); +-- +ok +== +SELECT regexp_extract_all('a 2b 14m', '(\\d+)?', 1); +-- +ok +== +SELECT regexp_extract_all('1a 2b 14m', '(\\d+)([a-z]+)'); +-- +ok +== +SELECT regexp_extract_all('1a 2b 14m', '(\\d+)([a-z]+)', 0); +-- +ok +== +SELECT regexp_extract_all('1a 2b 14m', '(\\d+)([a-z]+)', 1); +-- +ok +== +SELECT regexp_extract_all('1a 2b 14m', '(\\d+)([a-z]+)', 2); +-- +ok +== +SELECT regexp_extract_all('1a 2b 14m', '(\\d+)([a-z]+)', 3); +-- +ok +== +SELECT regexp_extract_all('1a 2b 14m', '(\\d+)?([a-z]+)', 1); +-- +ok +== +SELECT regexp_extract_all('a 2b 14m', '(\\d+)?([a-z]+)', 1); +-- +ok +== +select regexp_extract_all('AbCdE', '([[:lower:]]+)C([[:lower:]]+)', 1); +-- +ok +== +select regexp_extract_all('AbCdEfCg', '([[:lower:]]+)C([[:lower:]]+)', 1); +-- +ok +== +select regexp_extract_all('abc=111, def=222, ghi=333', '("[^"]+"|\w+)=("[^"]+"|\w+)', 1); +-- +ok +== +select regexp_extract_all('', NULL) +-- +ok +== +select regexp_extract_all(NULL, '') +-- +ok +== +select regexp_extract_all('', '') +-- +ok +== +select regexp_extract_all('', 'abc') +-- +ok +== +select regexp_extract_all('abc', '.') +-- +ok +== +select regexp_extract_all('aaa', '^a') +-- +ok +== +select regexp_extract_all('abc', 'abc') +-- +ok +== +select regexp_extract_all('abcdef', 'a.c.*f') +-- +ok +== +select regexp_extract_all('abcdef', 'ac.*e.') +-- +ok +== +select regexp_extract_all('abcdef', 'bcde') +-- +ok +== +select regexp_extract_all('aabca', 'a*') +-- +ok +== +select regexp_extract_all('aaba', 'a?') +-- +ok +== +select regexp_extract_all('baac', 'a*') +-- +ok +== +select regexp_extract_all('abcd', 'a(bc)*') +-- +ok +== +select regexp_extract_all('щцф', '.') +-- +ok +== +select regexp_extract_all('щцф', '.{3}') +-- +ok +== +select regexp_extract_all('щцф', '.{6}') +-- +ok +== +select regexp_extract_all('щццф', 'ц*') +-- +ok +== +select regexp_extract_all('abba', 'b*') +-- +ok +== +select regexp_extract_all('', '()') +-- +ok +== +select regexp_extract_all('', '(abc)') +-- +ok +== +select regexp_extract_all('', '(abc)?') +-- +ok +== +select regexp_extract_all('abc', 'a(b)c') +-- +ok +== +select regexp_extract_all('abbb', '^a*(b)') +-- +ok +== +select regexp_extract_all('XbASDZb', '(.)b') +-- +ok +== +select regexp_extract_all('abcdef', 'a(.c.*)f') +-- +ok +== +select regexp_extract_all('abcdef', '(bcde)') +-- +ok +== +select regexp_extract_all('this_is__a___Test', '(.*?)(?:_|$)') +-- +ok +== +select regexp_extract_all('щцф', 'щ(.).', 1) +-- +ok +== +select regexp_extract_all('щцф', '(.{6})') +-- +ok +== +select regexp_extract_all('abc', '((a))') +-- +ok +== +select regexp_extract_all('abc', '(a)(b)') +-- +ok +== +select regexp_extract_all('', '(') +-- +ok +== +select regexp_extract_all('щцф', '.{2}') +-- +ok +== +select regexp_extract_all('abc', '.{2}') +-- +ok +== +select regexp_extract_all('\001\002\003', '\002?') +-- +ok +== +select regexp_extract_all('this__test_case', '(.*?)(?:_|$)') +-- +ok +== +select regexp_extract_all('щцф', 'щ(..)..') +-- +ok +== +SELECT str, + REGEXP_EXTRACT_ALL(str,'ab?cd') AS matched +FROM ( + VALUES ('acd'), ('abcd'), ('abcdacd'), ('abbcd'), ('abbbcd'), ('ab1cd') +) AS t(str) +-- +ok +== +SELECT str, + REGEXP_EXTRACT_ALL(str,'a(bc)?d') AS matched +FROM ( + VALUES ('ad'), ('abd'), ('acd'), ('abcd'), ('abce'), ('abcxd'), ('abcbcd') +) AS t(str) +-- +ok +== +SELECT str, + REGEXP_EXTRACT_ALL(str,'a[bc]?d') AS matched +FROM ( + VALUES ('ad'), ('abd'), ('acd'), ('acde'), ('abcd'), ('abbd') +) AS t(str) +-- +ok +== +SELECT str, + REGEXP_EXTRACT_ALL(str,'X[\d]?Y[\d]?') AS matched +FROM ( + VALUES ('XY'),('X1Y'),('X123Y'),('X1Y23') +) AS t(str) +-- +ok +== +SELECT str, + REGEXP_EXTRACT_ALL(str,'ab*cd') AS matched +FROM ( + VALUES ('acd'), ('abcd'), ('abcdacd'), ('abbcd'), ('abbbcd'), ('ab1cd') +) AS t(str) +-- +ok +== +SELECT str, + REGEXP_EXTRACT_ALL(str,'a(bc)*d') AS matched +FROM ( + VALUES ('ad'), ('abd'), ('acd'), ('abcd'), ('abcxd'), ('abcbcd'), ('abcbce') +) AS t(str) +-- +ok +== +SELECT str, + REGEXP_EXTRACT_ALL(str,'a[bc]*d') AS matched +FROM ( + VALUES ('ad'), ('abd'), ('acd'), ('abcd'), ('abcbbcd'), ('abce') +) AS t(str) +-- +ok +== +SELECT str, + REGEXP_EXTRACT_ALL(str,'X[\d]*Y[\d]*') AS matched +FROM ( + VALUES ('XY'),('X1Y'),('X123Y'),('X1Y23'),('X12Z34Y') +) AS t(str) +-- +ok +== +SELECT str, + REGEXP_EXTRACT_ALL(str,'ab+cd') AS matched +FROM ( + VALUES ('acd'), ('abcd'), ('abcdacd'), ('abbcd'), ('abbbcd'), ('ab1cd') +) AS t(str) +-- +ok +== +SELECT str, + REGEXP_EXTRACT_ALL(str,'(ab)+cd') AS matched +FROM ( + VALUES ('bcd'), ('abcd'), ('abbcd'), ('ababcd'), ('ababxcd') +) AS t(str) +-- +ok +== +SELECT str, + REGEXP_EXTRACT_ALL(str,'a[bc]+d') AS matched +FROM ( + VALUES ('ad'), ('abd'), ('acd'), ('abcd'), ('abce'), ('abcbd') +) AS t(str) +-- +ok +== +SELECT str, + REGEXP_EXTRACT_ALL(str,'X[\d]+Y[\d]*') AS matched +FROM ( + VALUES ('XY'),('X1Y'),('X123Y'),('X1Y23'),('X12Z34Y') +) AS t(str) +-- +ok +== +SELECT str, + REGEXP_EXTRACT_ALL(str,'ab{3}cd') AS m1, + REGEXP_EXTRACT_ALL(str,'ab{1,}cd') AS m2, + REGEXP_EXTRACT_ALL(str,'ab{1,2}cd') AS m3, + REGEXP_EXTRACT_ALL(str,'ab{0,2}cd') AS m4 +FROM ( + VALUES ('acd'), ('abcd'), ('abcdacd'), ('abbcd'), ('abbbcd'), ('ab1cd') +) AS t(str) +-- +ok +== +SELECT str, + REGEXP_EXTRACT_ALL(str,'(ab){2}cd') AS m1, + REGEXP_EXTRACT_ALL(str,'(ab){1,}cd') AS m2, + REGEXP_EXTRACT_ALL(str,'(ab){1,2}cd') AS m3, + REGEXP_EXTRACT_ALL(str,'(ab){0,2}cd') AS m4 +FROM ( + VALUES ('acd'), ('bcd'),('abcd'), ('abbcd'), ('ababcd'), ('ab1cd') +) AS t(str) +-- +ok +== +SELECT str, + REGEXP_EXTRACT_ALL(str,'[\d]{3}') AS m1, + REGEXP_EXTRACT_ALL(str,'[\d]{5}') AS m2, + REGEXP_EXTRACT_ALL(str,'[\d]{1,}') AS m3, + REGEXP_EXTRACT_ALL(str,'[\d]{1,2}') AS m4, + REGEXP_EXTRACT_ALL(str,'[\d]{0,2}') AS m5 +FROM ( + VALUES ('03-123-4567') +) AS t(str) +-- +ok +== +SELECT str, + REGEXP_EXTRACT_ALL(str,'ab++') AS m1_long, +FROM ( + VALUES ('acd'), ('abcd'), ('abbcd'), ('abbbcd') +) AS t(str) +-- +ok +== +SELECT + REGEXP_EXTRACT_ALL('123456789', '^[0-9]*$') AS m1, + REGEXP_EXTRACT_ALL('abcdefg', '^[a-z]*$') AS m2, + REGEXP_EXTRACT_ALL('ABCDEFG', '^[A-Z]*$') AS m3, + REGEXP_EXTRACT_ALL('ABCdefg', '^[a-zA-Z]*$') AS m4, + REGEXP_EXTRACT_ALL('12aaAA', '^[0-9a-zA-Z]*$') AS m5, + REGEXP_EXTRACT_ALL('123-1234', '^[0-9]{3}-[0-9]{4}$') AS m6, + REGEXP_EXTRACT_ALL('2009/7/29', '^[0-9]{4}/[01]?[0-9]/[0123]?[0-9]$') AS m7 +-- +ok +== +WITH sample AS +( + SELECT s FROM + ( + VALUES + ('https://docs.fluentd.org/v0.12/articles/out_file'), + ('https://docs.fluentd.org/v0.12/articles/out_forward'), + ('https://www.fluentd.org/v0.12/articles/out_file'), + ('out_file/article/docs.fluentd.org/') + ) AS t(s) +) +SELECT + s, REGEXP_EXTRACT_ALL(s,'docs.fluentd.org.*out_file') AS match_strs1, + REGEXP_EXTRACT_ALL(s,'docs.fluentd.org|out_file') AS match_strs2 +FROM sample +-- +ok +== +select REGEXP_EXTRACT_ALL('hello', '.', 2); +-- +ok +== +SELECT + REGEXP_EXTRACT_ALL('https://www.emakina.nl/?utm_source=sf_mail&user_id=7h87hte51kj_9866c', '([^\?&]+)=') AS parameter_key, + REGEXP_EXTRACT_ALL('https://www.emakina.nl/?utm_source=sf_mail&user_id=7h87hte51kj_9866c', '=([^&]+)') AS parameter_value +-- +ok +== +select regexp_extract_all('si1si2', 'si\d$'); +-- +ok +== +select regexp_extract_all('si1si2', '^(si\d)(?:.*)$', 1); +-- +ok +== +select regexp_extract_all('aabb', '^((aa)(bb))$', 3); +-- +ok +== +WITH t(pattern) AS ( + VALUES + (NULL), + ('(a)'), + ('(a)(a)(a)'), + ('()'), + ('(a)(a)'), + (NULL), + ('(a)'), + ('(a)(b)?(a)'), + ('(a)(a)(a)(a)(a)(a)(a)'), + (NULL), +) +select regexp_extract_all('aaaaaaaa', pattern) from t; +-- +ok +== +WITH t(input, pattern, g) AS ( + VALUES + (NULL, NULL, 0), + (NULL, NULL, 1), + ('aaaaaaaa', '(a)', 0), + ('aaaaaaaa', '(a)(a)(a)', 0), + ('aaaaaaaa', '()', 1), + ('aaaaaaaa', '(a)(a)', 0), + (NULL, NULL, NULL), + ('aaaaaaaa', '(a)', 0), + ('aaaaaaaa', '(a)(b)?(a)', NULL), + ('aaa', '(a)(a)(a)(a)(a)(a)(a)', 0), + ('aaaaaaaaaaa', '(a)(a)(a)(a)(a)(a)(a)', 0), + (NULL, '()', NULL) +) +select regexp_extract_all(input, pattern, g) from t; +-- +ok +== +select regexp_extract_all('foobarbaz', '(BA[R|Z])', 1, 'i'); +-- +ok +== +WITH t(input, pattern, g) AS ( + VALUES + (NULL, NULL, 0), + (NULL, NULL, 1), + ('aaaaaaaa', '(A)', 0), + ('aaaaaaaa', '(a)(A)(a)', 0), + ('aaaaaaaa', '()', 1), + ('aaaaaaaa', '(a)(A)', 0), + (NULL, NULL, NULL), + ('aaaaaaaa', '(a)', 0), + ('aaaaaaaa', '(a)(B)?(a)', NULL), + ('aaa', '(a)(a)(A)(A)(a)(A)(a)', 0), + ('aaaaaaaaaaa', '(a)(A)(a)(a)(a)(a)(a)', 0), + (NULL, '()', NULL) +) +select regexp_extract_all(input, pattern, g, 'i') from t; +-- +ok +== diff --git a/parser/testdata/corpus/sql/function/string/regex_extract_all_struct.test b/parser/testdata/corpus/sql/function/string/regex_extract_all_struct.test new file mode 100644 index 0000000..44ad07a --- /dev/null +++ b/parser/testdata/corpus/sql/function/string/regex_extract_all_struct.test @@ -0,0 +1,273 @@ +# source: test/sql/function/string/regex_extract_all_struct.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +SELECT regexp_extract_all('Peter:33 Paul:14', '(\w+):(\d+)', ['name','num']) AS res; +-- +ok +== +SELECT regexp_extract_all('a1 b2 c', '(\w)(\d)?', ['c','d']) AS res; +-- +ok +== +SELECT regexp_extract_all('abc', '(a)(b)(c)', []); +-- +ok +== +SELECT regexp_extract_all('abc', '(a)(b)(c)', ['x','x']); +-- +ok +== +SELECT regexp_extract_all('abc', '(a)(b)', ['g1','g2','g3']); +-- +ok +== +SELECT regexp_extract_all('Aa aA', '(a)', ['lower'], 'i') AS res; +-- +ok +== +SELECT regexp_extract_all(NULL, '(a)', ['g']); +-- +ok +== +SELECT regexp_extract_all('abc', NULL, ['g']); +-- +ok +== +SELECT regexp_extract_all('щцф', '(.)', ['ch']) AS res; +-- +ok +== +SELECT regexp_extract_all('aa', '(a)(b)?', ['a','b']) AS res; +-- +ok +== +SELECT regexp_extract_all('ab ac a', '(a)(b)?(c)?', ['a','b','c']) AS res; +-- +ok +== +SELECT regexp_extract_all('x1 y2', '(\w)(\d)', ['digit','letter']) AS res; +-- +ok +== +SELECT regexp_extract_all('aaaaa', '(a)', ['g']) AS res; +-- +ok +== +SELECT regexp_extract_all('щц', '(щ)(ц)?', ['first','second']) AS res; +-- +ok +== +SELECT regexp_extract_all('hi', '(h|i)?', ['ch']) AS res; +-- +ok +== +SELECT regexp_extract_all(NULL, '(a)', ['g']) AS res; +-- +ok +== +SELECT regexp_extract_all('bb', '(a*)b', ['a']) AS res; +-- +ok +== +SELECT regexp_extract_all('abc', '(x)(y)', ['x','y']) AS res; +-- +ok +== +SELECT regexp_extract_all('', '(a)?', ['a']) AS res; +-- +ok +== +SELECT regexp_extract_all('ab', '((a)(b))', ['outer','first','second']) AS res; +-- +ok +== +SELECT regexp_extract_all('ab aab b', '(a*)(b)', ['as','b']) AS res; +-- +ok +== +SELECT regexp_extract_all('щ', '(щ|ц)?', ['ch']) AS res; +-- +ok +== +SELECT regexp_extract_all('hi', '(h|i)?(Z)?', ['ch','z']) AS res; +-- +ok +== +SELECT regexp_extract_all('foobarbaz', '((BA)([RZ]))', ['whole','ba','letter'], 'i') AS res; +-- +ok +== +WITH t(s) AS (VALUES ('x1 y2'), ('a3'), ('no_digits')) +SELECT s, regexp_extract_all(s, '(\w)(\d)', ['c','d']) AS res FROM t; +-- +ok +== +WITH t(s) AS (VALUES ('a1 b2'), ('c3'), ('z')) +SELECT s, regexp_extract_all(s, '(\w)(\d)?', ['l','d']) AS res FROM t; +-- +ok +== +WITH t(s) AS (VALUES ('hi'), ('h'), ('')) +SELECT s, regexp_extract_all(s, '(h|i)?', ['ch']) AS res FROM t; +-- +ok +== +SELECT regexp_extract_all('1a 2b 14m', '(\d+)', ['g1']) AS res; +-- +ok +== +SELECT regexp_extract_all('1a 2b 14m', '(\d+)([a-z]+)', ['g1','g2']) AS res; +-- +ok +== +SELECT REGEXP_EXTRACT_ALL('test', '(.)', ['a']) +-- +ok +== +SELECT regexp_extract_all('a 2b 14m', '(\d+)?([a-z]+)', ['g1','g2']) AS res; +-- +ok +== +SELECT regexp_extract_all('AbCdE', '([[:lower:]]+)C([[:lower:]]+)', ['g1','g2']) AS res; +-- +ok +== +SELECT regexp_extract_all('AbCdEfCg', '([[:lower:]]+)C([[:lower:]]+)', ['g1','g2']) AS res; +-- +ok +== +SELECT regexp_extract_all('abc=111, def=222, ghi=333', '("[^"]+"|\w+)=("[^"]+"|\w+)', ['key','val']) AS res; +-- +ok +== +SELECT regexp_extract_all('abcd', 'a(bc)*', ['g1']) AS res; +-- +ok +== +SELECT regexp_extract_all('abc', '((a))', ['outer','inner']) AS res; +-- +ok +== +SELECT regexp_extract_all('abc', '(a)(b)', ['g1','g2']) AS res; +-- +ok +== +SELECT regexp_extract_all('aabb', '^((aa)(bb))$', ['all','p1','p2']) AS res; +-- +ok +== +SELECT regexp_extract_all('ababcd', '(ab){2}cd', ['g1']) AS res; +-- +ok +== +SELECT regexp_extract_all('ababcd', '(ab){1,}cd', ['g1']) AS res; +-- +ok +== +SELECT regexp_extract_all('ababcd', '(ab){1,2}cd', ['g1']) AS res; +-- +ok +== +SELECT regexp_extract_all('abd', 'a(bc)?d', ['g1']) AS res; +-- +ok +== +SELECT regexp_extract_all('ad', 'a(bc)?d', ['g1']) AS res; +-- +ok +== +SELECT regexp_extract_all('abcd', 'a(bc)*d', ['g1']) AS res; +-- +ok +== +SELECT regexp_extract_all('foobarbaz', '(BA[R|Z])', ['g1'], 'i') AS res; +-- +ok +== +SELECT regexp_extract_all('abcd', '(ab){0,2}cd', ['g1']) AS res; +-- +ok +== +SELECT regexp_extract_all('abbbcd', '(ab){0,2}cd', ['g1']) AS res; +-- +ok +== +SELECT regexp_extract_all('acdd', '(ab){0,2}cd', ['g1']) AS res; +-- +ok +== +SELECT regexp_extract_all('abbb', '^a*(b)', ['g1']) AS res; +-- +ok +== +SELECT regexp_extract_all('abcdef', 'a(.c.*)f', ['mid']) AS res; +-- +ok +== +SELECT regexp_extract_all('щцф', 'щ(.).', ['g1']) AS res; +-- +ok +== +SELECT regexp_extract_all('щцф', 'щ(..)..', ['g1']) AS res; +-- +ok +== +SELECT regexp_extract_all('abcdef', '(bcde)', ['seg']) AS res; +-- +ok +== +SELECT regexp_extract_all('aaaaaaaa', '(a)(a)', ['g1','g2']) AS res; +-- +ok +== +SELECT regexp_extract_all('aaaaaaaa', '(a)(a)(a)', ['g1','g2','g3']) AS res; +-- +ok +== +SELECT regexp_extract_all('aba aba aa', '(a)(b)?(a)', ['g1','g2','g3']) AS res; +-- +ok +== +SELECT regexp_extract_all('aBa aAA', '(a)(B)?(a)', ['g1','g2','g3'], 'i') AS res; +-- +ok +== +SELECT regexp_extract_all('aaaaaaaaaaa', '(a)(a)(a)(a)(a)(a)(a)', ['g1','g2','g3','g4','g5','g6','g7']) AS res; +-- +ok +== +SELECT regexp_extract_all('', '()', ['empty']) AS res; +-- +ok +== +WITH params(name_list) AS (SELECT ['g1','g2']) +SELECT regexp_extract_all('abc', '(a)(b)', name_list) FROM params; +-- +ok +== +SELECT regexp_extract_all('abc', '(a)', NULL::VARCHAR[]); +-- +ok +== +SELECT regexp_extract_all('abc', '(a)(b)', []::VARCHAR[]); +-- +ok +== +SELECT regexp_extract_all('abc', '(a)', ['g1', NULL::VARCHAR]); +-- +ok +== +SELECT regexp_extract_all('abc', '(a)', ['dup','dup']); +-- +ok +== +SELECT regexp_extract_all('abc', '(', ['g1']); +-- +ok +== +SELECT regexp_extract_all('abc', '(a)', ['g1','g2']); +-- +ok +== diff --git a/parser/testdata/corpus/sql/function/string/regex_filter_pushdown.test b/parser/testdata/corpus/sql/function/string/regex_filter_pushdown.test new file mode 100644 index 0000000..26c59ad --- /dev/null +++ b/parser/testdata/corpus/sql/function/string/regex_filter_pushdown.test @@ -0,0 +1,29 @@ +# source: test/sql/function/string/regex_filter_pushdown.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +CREATE TABLE regex(s STRING) +-- +ok +== +INSERT INTO regex VALUES ('asdf'), ('xxxx'), ('aaaa') +-- +ok +== +SELECT s FROM regex WHERE REGEXP_MATCHES(s, 'as(c|d|e)f') +-- +ok +== +SELECT s FROM regex WHERE NOT REGEXP_MATCHES(s, 'as(c|d|e)f') +-- +ok +== +SELECT s FROM regex WHERE REGEXP_MATCHES(s, 'as(c|d|e)f') AND s = 'asdf' +-- +ok +== +SELECT s FROM regex WHERE REGEXP_MATCHES(s, 'as(c|d|e)f') AND REGEXP_MATCHES(s, 'as[a-z]f') +-- +ok +== diff --git a/parser/testdata/corpus/sql/function/string/regex_operators.test b/parser/testdata/corpus/sql/function/string/regex_operators.test new file mode 100644 index 0000000..a32359a --- /dev/null +++ b/parser/testdata/corpus/sql/function/string/regex_operators.test @@ -0,0 +1,133 @@ +# source: test/sql/function/string/regex_operators.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +SELECT current_setting('regex_match_operator_semantics') +-- +ok +== +SELECT 'abc' ~ 'b' +-- +ok +== +SELECT 'abc' !~ 'b' +-- +ok +== +SELECT 'abc' ~ '^a' +-- +ok +== +SELECT 'abc' ~ '^b' +-- +ok +== +SELECT 'ABC' ~ 'a' +-- +ok +== +SELECT 'ABC' ~* 'a' +-- +ok +== +SELECT 'ABC' !~* 'a' +-- +ok +== +CREATE TABLE regex_columns_partial(abc INTEGER, bcd INTEGER, def INTEGER); +-- +ok +== +INSERT INTO regex_columns_partial VALUES (1, 2, 3); +-- +ok +== +SELECT * ~ 'b' FROM regex_columns_partial +-- +ok +== +SELECT * ~* 'B' FROM regex_columns_partial +-- +ok +== +SELECT 'abc' ~ ANY(['b', 'z']) +-- +ok +== +SELECT 'abc' ~* ANY(['Z', 'B']) +-- +ok +== +SELECT 'abc' !~* ALL(['z', 'y']) +-- +ok +== +SELECT 'abc' ~ ANY(['z', NULL]) IS NULL +-- +ok +== +SELECT 'abc' ~ ALL(['abc', NULL]) IS NULL +-- +ok +== +SELECT 'abc' ~ ANY([]::VARCHAR[]) +-- +ok +== +SELECT 'abc' ~ ALL([]::VARCHAR[]) +-- +ok +== +SET regex_match_operator_semantics = 'full' +-- +ok +== +SELECT 'abc' ~ '^a.*' +-- +ok +== +SELECT 'ABC' ~* 'a.*' +-- +ok +== +SELECT 'ABC' !~* 'a.*' +-- +ok +== +CREATE TABLE regex_columns_full(abc INTEGER, "Bcd" INTEGER, def INTEGER); +-- +ok +== +INSERT INTO regex_columns_full VALUES (1, 2, 3); +-- +ok +== +SELECT * ~* 'b.*' FROM regex_columns_full +-- +ok +== +SELECT 'abc' ~ ANY(['b', 'abc']) +-- +ok +== +SELECT 'abc' ~* ANY(['B', 'ABC']) +-- +ok +== +SELECT 'abc' ~* ALL(['ABC', 'A.*']) +-- +ok +== +RESET regex_match_operator_semantics +-- +ok +== +SET regex_match_operator_semantics = 'PARTIAL' +-- +ok +== +SET regex_match_operator_semantics = 'unknown' +-- +ok +== diff --git a/parser/testdata/corpus/sql/function/string/regex_operators_v1_5_view.test b/parser/testdata/corpus/sql/function/string/regex_operators_v1_5_view.test new file mode 100644 index 0000000..21d7bf9 --- /dev/null +++ b/parser/testdata/corpus/sql/function/string/regex_operators_v1_5_view.test @@ -0,0 +1,21 @@ +# source: test/sql/function/string/regex_operators_v1_5_view.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +SET regex_match_operator_semantics = 'partial' +-- +ok +== +SELECT col FROM tbl WHERE col ~ 'b' ORDER BY col +-- +ok +== +SELECT col FROM v_regex_match +-- +ok +== +SELECT col FROM v_regex_not_match +-- +ok +== diff --git a/parser/testdata/corpus/sql/function/string/regex_replace.test b/parser/testdata/corpus/sql/function/string/regex_replace.test new file mode 100644 index 0000000..12c9df5 --- /dev/null +++ b/parser/testdata/corpus/sql/function/string/regex_replace.test @@ -0,0 +1,172 @@ +# source: test/sql/function/string/regex_replace.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +SELECT regexp_replace('foobarbaz', 'b..', 'X') +-- +ok +== +SELECT regexp_replace('ana ana', 'ana', 'banana', 'g') +-- +ok +== +SELECT regexp_replace('ANA ana', 'ana', 'banana', 'gi') +-- +ok +== +SELECT regexp_replace('ana', 'ana', 'banana', 'c') +-- +ok +== +SELECT regexp_replace('ANA', 'ana', 'banana', 'i') +-- +ok +== +SELECT regexp_replace('as^/$df', '^/$', '', 'l') +-- +ok +== +SELECT regexp_replace('as^/$df', '^/$', '') +-- +ok +== +SELECT regexp_replace('hello +world', '.*', 'x', 'sg') +-- +ok +== +SELECT COUNT(*) FROM (SELECT 'x +x') t1(a) JOIN (SELECT regexp_replace('hello +world', '.*', 'x', 'ng')) t2(a) USING (a) +-- +ok +== +CREATE TABLE test(v VARCHAR); +-- +ok +== +INSERT INTO test VALUES ('hello'), ('HELLO'); +-- +ok +== +SELECT regexp_replace(v, 'h.*', 'world', 'i') FROM test ORDER BY v +-- +ok +== +SELECT regexp_replace(v, 'h.*', 'world', 'c') FROM test ORDER BY v +-- +ok +== +SELECT regexp_replace(v, 'h.*', 'world', v) FROM test ORDER BY v +-- +ok +== +SELECT regexp_replace('asdf', '.*SD.*', 'a', 'q') +-- +ok +== +select regexp_matches('abc', '*'); +-- +ok +== +select regexp_replace('abc', '*', 'X'); +-- +ok +== +create table regex (s string, r string); +-- +ok +== +insert into regex values ('abc', '*'); +-- +ok +== +select regexp_matches(s, r) from regex; +-- +ok +== +select regexp_replace(s, r, 'X') from regex; +-- +ok +== +SELECT regexp_replace(s, '^/([^/]+)/.*$', '\1') FROM (VALUES + ('/usr/local/bin/duckdb'), + ('/etc/hosts'), + ('/var/'), + ('relative/path/no/leading/slash')) t(s); +-- +ok +== +SELECT regexp_replace('aXYbZW', '^(a)(XY)(b)(ZW).*$', '\1'); +-- +ok +== +SELECT regexp_replace('left-right', '^([^-]+)-([^-]+)$', '\2'); +-- +ok +== +SELECT COUNT(*) FROM (SELECT E'https://www.example.com/path\nsecond-line') t1(a) + JOIN (SELECT regexp_replace(E'https://www.example.com/path\nsecond-line', + '^https?://(?:www\.)?([^/]+)/.*$', '\1')) t2(a) USING (a); +-- +ok +== +SELECT regexp_replace(E'https://www.example.com/path\nsecond-line', + '^https?://(?:www\.)?([^/]+)/.*$', '\1', 's'); +-- +ok +== +SELECT COUNT(*) FROM (SELECT E'a\nb') t1(a) + JOIN (SELECT regexp_replace(s, '^(?m)(a).*$', '\1') FROM (VALUES (E'a\nb')) v(s)) t2(a) USING (a); +-- +ok +== +SELECT regexp_replace(s, '^a(.*)$|b(.*).*$', '\1') FROM (VALUES ('xxbzz'), ('azz')) v(s); +-- +ok +== +SELECT regexp_replace(s, '^a(b)\.*$', '\1') FROM (VALUES ('ab'), ('ab.'), ('cd')) v(s); +-- +ok +== +SELECT regexp_replace('héllo-café/rest', '^([^/]+)/.*$', '\1'); +-- +ok +== +SELECT regexp_replace('abcabc', '(b)', '\3Y', 'g'); +-- +ok +== +SELECT regexp_replace('abcabc', 'b', E'X\\xY', 'g'); +-- +ok +== +SELECT regexp_replace('abcabc', 'b', E'X\\', 'g'); +-- +ok +== +SELECT regexp_replace('abc', '(b)', '\3Y'); +-- +ok +== +CREATE TABLE t_repl_invalid(s VARCHAR, pat VARCHAR, repl VARCHAR); +-- +ok +== +INSERT INTO t_repl_invalid VALUES ('abcabc', '(b)', '\3Y'); +-- +ok +== +SELECT regexp_replace(s, pat, repl) FROM t_repl_invalid; +-- +ok +== +DELETE FROM t_repl_invalid; +-- +ok +== +INSERT INTO t_repl_invalid VALUES ('abcabc', 'b', E'X\\xY'); +-- +ok +== diff --git a/parser/testdata/corpus/sql/function/string/regex_search.test b/parser/testdata/corpus/sql/function/string/regex_search.test new file mode 100644 index 0000000..de58d96 --- /dev/null +++ b/parser/testdata/corpus/sql/function/string/regex_search.test @@ -0,0 +1,151 @@ +# source: test/sql/function/string/regex_search.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +CREATE TABLE t0 as FROM VALUES('asdf') t(c0); +-- +ok +== +SELECT regexp_matches(c0, NULL) from t0 +-- +ok +== +SELECT regexp_matches(c0, '.*sd.*') from t0; +-- +ok +== +SELECT regexp_matches(c0, '.*yu.*') from t0; +-- +ok +== +SELECT regexp_matches(c0, '') from t0; +-- +ok +== +SELECT regexp_matches(c0, 'sd') from t0; +-- +ok +== +SELECT regexp_full_match(c0, 'sd') from t0; +-- +ok +== +SELECT regexp_full_match(c0, '.sd.') from t0; +-- +ok +== +SELECT regexp_matches(c0, '^sdf$') from t0; +-- +ok +== +SELECT regexp_matches('', '.*yu.*') +-- +ok +== +SELECT regexp_matches('', '.*') +-- +ok +== +SELECT regexp_matches(c0, CAST(NULL AS STRING)) from t0; +-- +ok +== +SELECT regexp_matches(CAST(NULL AS STRING), '.*sd.*') +-- +ok +== +SELECT regexp_matches(CAST(NULL AS STRING), CAST(NULL AS STRING)) +-- +ok +== +SELECT regexp_matches('foobarbequebaz', '(bar)(beque)') +-- +ok +== +SELECT regexp_matches('', '\X') +-- +ok +== +CREATE TABLE regex(s STRING, p STRING) +-- +ok +== +INSERT INTO regex VALUES ('asdf', 'sd'), ('asdf', '^sd'), (NULL, '^sd'), ('asdf', NULL) +-- +ok +== +SELECT regexp_matches(s, '.*') FROM regex +-- +ok +== +SELECT regexp_matches(s, p) FROM regex +-- +ok +== +SELECT regexp_matches(c0, '.*SD.*', 'i') from t0; +-- +ok +== +SELECT regexp_matches(c0, '.*SD.*', 'c') from t0; +-- +ok +== +SELECT regexp_matches('as^/$df', '^/$', 'l') +-- +ok +== +SELECT regexp_matches('as^/$df', '^/$') +-- +ok +== +SELECT regexp_matches('hello +world', '.*', 's') +-- +ok +== +SELECT regexp_full_match('hello +world', '.*', 'n') +-- +ok +== +SELECT regexp_matches(c0, '.*SD.*', ' i ') from t0; +-- +ok +== +SELECT regexp_matches(c0, '.*SD.*', NULL) from t0; +-- +ok +== +SELECT regexp_matches(v, 'h.*', 'i') FROM test ORDER BY v +-- +ok +== +SELECT regexp_matches(v, 'h.*', 'c') FROM test ORDER BY v +-- +ok +== +SELECT regexp_matches(v, 'h.*', v) FROM test ORDER BY v +-- +ok +== +SELECT regexp_matches(c0, '.*SD.*', 'q') from t0; +-- +ok +== +SELECT regexp_matches(c0, '.*SD.*', 'g') from t0; +-- +ok +== +INSERT INTO regex VALUES ('asdf', '(') +-- +ok +== +SELECT regexp_full_match(s, p) FROM regex +-- +ok +== +SELECT regexp_full_match(s, p, 'c') FROM regex +-- +ok +== diff --git a/parser/testdata/corpus/sql/function/string/regexp_split_to_table.test b/parser/testdata/corpus/sql/function/string/regexp_split_to_table.test new file mode 100644 index 0000000..7902568 --- /dev/null +++ b/parser/testdata/corpus/sql/function/string/regexp_split_to_table.test @@ -0,0 +1,17 @@ +# source: test/sql/function/string/regexp_split_to_table.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +SELECT regexp_split_to_table('a b c', ' ') +-- +ok +== +SELECT regexp_split_to_table('axbyc', '[x|y]') +-- +ok +== +SELECT regexp_split_to_table('axbyc', '[x|y]'), 42 +-- +ok +== diff --git a/parser/testdata/corpus/sql/function/string/regexp_unicode_literal.test b/parser/testdata/corpus/sql/function/string/regexp_unicode_literal.test new file mode 100644 index 0000000..a78195b --- /dev/null +++ b/parser/testdata/corpus/sql/function/string/regexp_unicode_literal.test @@ -0,0 +1,49 @@ +# source: test/sql/function/string/regexp_unicode_literal.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +CREATE TABLE data(wsc INT, zipcode VARCHAR) +-- +ok +== +INSERT INTO data VALUES (32, '00' || chr(32) || '001'), (160, '00' || chr(160) || '001'), (0, '00🦆001'); +-- +ok +== +from data +where regexp_matches(zipcode, '^00\x{0020}001$') +-- +ok +== +from data +where regexp_matches(zipcode, '^00\x{00A0}001$') +-- +ok +== +from data +where regexp_matches(zipcode, '\x{00A0}001$') +-- +ok +== +from data +where regexp_matches(zipcode, '^00\x{1F986}001$') +-- +ok +== +from data +where regexp_matches(zipcode, '\x{1F986}') +-- +ok +== +select * +from data +where regexp_matches(zipcode, '^00\x{00A0}001$') +and regexp_matches(zipcode, '^00\x{0020}001$') +-- +ok +== +select regexp_matches(zipcode, '^00\x{FFFFFFFF}001$') from data +-- +ok +== diff --git a/parser/testdata/corpus/sql/function/string/sha1.test b/parser/testdata/corpus/sql/function/string/sha1.test new file mode 100644 index 0000000..b2adf5b --- /dev/null +++ b/parser/testdata/corpus/sql/function/string/sha1.test @@ -0,0 +1,37 @@ +# source: test/sql/function/string/sha1.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +SELECT sha1('hello'), sha1(NULL) +-- +ok +== +SELECT sha1('') +-- +ok +== +SELECT sha1('\xff\xff'::BLOB) +-- +ok +== +SELECT sha1(s), sha1('1') FROM strings ORDER BY s +-- +ok +== +SELECT sha1(s), sha1('1') FROM strings WHERE s::INTEGER BETWEEN 1 AND 3 ORDER BY s +-- +ok +== +SELECT sha1() +-- +ok +== +SELECT sha1(''::blob) +-- +ok +== +SELECT sha1(42) +-- +ok +== diff --git a/parser/testdata/corpus/sql/function/string/sha256.test b/parser/testdata/corpus/sql/function/string/sha256.test new file mode 100644 index 0000000..5db99dc --- /dev/null +++ b/parser/testdata/corpus/sql/function/string/sha256.test @@ -0,0 +1,29 @@ +# source: test/sql/function/string/sha256.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +SELECT sha256('hello'), sha256(NULL) +-- +ok +== +SELECT sha256('') +-- +ok +== +SELECT sha256('\xff\xff'::BLOB) +-- +ok +== +SELECT sha256(s), sha256('1') FROM strings ORDER BY s +-- +ok +== +SELECT sha256(s), sha256('1') FROM strings WHERE s::INTEGER BETWEEN 1 AND 3 ORDER BY s +-- +ok +== +SELECT sha256() +-- +ok +== diff --git a/parser/testdata/corpus/sql/function/string/strip_accents.test b/parser/testdata/corpus/sql/function/string/strip_accents.test new file mode 100644 index 0000000..8270be3 --- /dev/null +++ b/parser/testdata/corpus/sql/function/string/strip_accents.test @@ -0,0 +1,37 @@ +# source: test/sql/function/string/strip_accents.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +SELECT strip_accents('hello'), strip_accents('héllo') +-- +ok +== +SELECT strip_accents('mühleisen'), strip_accents('hannes mühleisen') +-- +ok +== +CREATE TABLE collate_test(s VARCHAR, str VARCHAR) +-- +ok +== +INSERT INTO collate_test VALUES ('äää', 'aaa') +-- +ok +== +INSERT INTO collate_test VALUES ('hännës mühlëïsën', 'hannes muhleisen') +-- +ok +== +INSERT INTO collate_test VALUES ('olá', 'ola') +-- +ok +== +INSERT INTO collate_test VALUES ('ôâêóáëòõç', 'oaeoaeooc') +-- +ok +== +SELECT strip_accents(s)=strip_accents(str) FROM collate_test +-- +ok +== diff --git a/parser/testdata/corpus/sql/function/string/test_array_extract.test b/parser/testdata/corpus/sql/function/string/test_array_extract.test new file mode 100644 index 0000000..2b09127 --- /dev/null +++ b/parser/testdata/corpus/sql/function/string/test_array_extract.test @@ -0,0 +1,77 @@ +# source: test/sql/function/string/test_array_extract.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +CREATE TABLE strings(s VARCHAR, off INTEGER); +-- +ok +== +INSERT INTO strings VALUES ('hello', 1), ('world', 2), ('b', 1), (NULL, 2) +-- +ok +== +SELECT array_extract('🦆ab', 4), array_extract('abc', 4) +-- +ok +== +SELECT array_extract(s, 2) FROM strings +-- +ok +== +SELECT array_extract(s, 3) FROM strings +-- +ok +== +SELECT array_extract(s, off) FROM strings +-- +ok +== +SELECT array_extract('hello', off) FROM strings +-- +ok +== +SELECT array_extract(NULL::VARCHAR, off) FROM strings +-- +ok +== +SELECT array_extract('hello', NULL) FROM strings +-- +ok +== +SELECT array_extract(NULL::VARCHAR, NULL) FROM strings +-- +ok +== +SELECT array_extract(s, -1) FROM strings +-- +ok +== +SELECT array_extract(s, 1) FROM strings +-- +ok +== +SELECT array_extract(s, 6) FROM strings +-- +ok +== +SELECT array_extract(s, 2147483646) FROM strings +-- +ok +== +SELECT array_extract(s, -2147483647) FROM strings +-- +ok +== +SELECT list_extract('1', -1); +-- +ok +== +SELECT array_extract('1', 9223372036854775807); +-- +ok +== +SELECT array_extract('0', -9223372036854775808); +-- +ok +== diff --git a/parser/testdata/corpus/sql/function/string/test_ascii.test b/parser/testdata/corpus/sql/function/string/test_ascii.test new file mode 100644 index 0000000..bbe0edc --- /dev/null +++ b/parser/testdata/corpus/sql/function/string/test_ascii.test @@ -0,0 +1,69 @@ +# source: test/sql/function/string/test_ascii.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +SELECT ascii('x') +-- +ok +== +SELECT ASCII('a') +-- +ok +== +SELECT ASCII('ABC') +-- +ok +== +SELECT ASCII('Ω') +-- +ok +== +SELECT ASCII('ΩΩ') +-- +ok +== +SELECT ASCII('Ä') +-- +ok +== +SELECT ASCII('5') +-- +ok +== +SELECT ASCII(NULL) +-- +ok +== +SELECT ASCII() +-- +ok +== +SELECT CHR(97) +-- +ok +== +SELECT CHR(196) +-- +ok +== +SELECT CHR(937) +-- +ok +== +SELECT CHR(NULL) +-- +ok +== +SELECT CHR(-10) +-- +ok +== +SELECT CHR(1073741824) +-- +ok +== +SELECT CHR() +-- +ok +== diff --git a/parser/testdata/corpus/sql/function/string/test_bar.test b/parser/testdata/corpus/sql/function/string/test_bar.test new file mode 100644 index 0000000..0dfe7c1 --- /dev/null +++ b/parser/testdata/corpus/sql/function/string/test_bar.test @@ -0,0 +1,141 @@ +# source: test/sql/function/string/test_bar.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +select bar(x * x, 0, 100) from range(0, 11) t(x) +-- +ok +== +select bar(9, 10, 20) +-- +ok +== +select bar(120, -10, 100, 10) +-- +ok +== +select bar(40, 20, 0) +-- +ok +== +select bar(100, 200, 0) +-- +ok +== +select bar(-10, 20, 0) +-- +ok +== +select bar('nan'::double, 0, 10) +-- +ok +== +select bar('infinity'::double, 0, 10) +-- +ok +== +select bar('-infinity'::double, 0, 10) +-- +ok +== +select bar(null, 0, 10) +-- +ok +== +select bar(1, 'nan'::double, 10) +-- +ok +== +select bar(1, '-infinity'::double, 10) +-- +ok +== +select bar(1, 'infinity'::double, 10) +-- +ok +== +select bar(1, null, 10) +-- +ok +== +select bar(1, 0, 'nan'::double) +-- +ok +== +select bar(1, 0, '-infinity'::double) +-- +ok +== +select bar(1, 0, 'infinity'::double) +-- +ok +== +select bar(1, 0, 10, 'nan'::double) +-- +ok +== +select bar(1, 0, 10, 'infinity'::double) +-- +ok +== +select bar(1, 0, 10, '-infinity'::double) +-- +ok +== +select bar(1, 0, 10, 1000) +-- +ok +== +select bar(1, 0, 10, 1001) +-- +ok +== +select bar(1, 0, 10, 1) +-- +ok +== +select bar(10, 10, 10, 10) +-- +ok +== +select bar(1, 0, 10, 0.99) +-- +ok +== +select bar(1, 0, 1, 1.125) +-- +ok +== +select bar(1, 0, 1, 1.25) +-- +ok +== +select bar(1, 0, 1, 1.375) +-- +ok +== +select bar(1, 0, 1, 1.5) +-- +ok +== +select bar(1, 0, 1, 1.625) +-- +ok +== +select bar(1, 0, 1, 1.75) +-- +ok +== +select bar(1, 0, 1, 1.875) +-- +ok +== +select bar(1, 0, 1, 2) +-- +ok +== +select bar(1, 0, 1, width) from (values (1), (1.125), (1.25), (1.375), (1.5), (1.625), (1.75), (1.875), (2)) as _(width); +-- +ok +== diff --git a/parser/testdata/corpus/sql/function/string/test_bit_length.test b/parser/testdata/corpus/sql/function/string/test_bit_length.test new file mode 100644 index 0000000..539bf6f --- /dev/null +++ b/parser/testdata/corpus/sql/function/string/test_bit_length.test @@ -0,0 +1,37 @@ +# source: test/sql/function/string/test_bit_length.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +select BIT_LENGTH(NULL), BIT_LENGTH(''), BIT_LENGTH('$'), BIT_LENGTH('¢'), BIT_LENGTH('€'), BIT_LENGTH('𐍈') +-- +ok +== +CREATE TABLE strings(a STRING, b STRING) +-- +ok +== +INSERT INTO strings VALUES ('', 'Zero'), ('$', NULL), ('¢','Two'), ('€', NULL), ('𐍈','Four') +-- +ok +== +select BIT_LENGTH(a) FROM strings +-- +ok +== +select BIT_LENGTH(b) FROM strings +-- +ok +== +select BIT_LENGTH(a) FROM strings WHERE b IS NOT NULL +-- +ok +== +select BIT_LENGTH() +-- +ok +== +select BIT_LENGTH(1, 2) +-- +ok +== diff --git a/parser/testdata/corpus/sql/function/string/test_caseconvert.test b/parser/testdata/corpus/sql/function/string/test_caseconvert.test new file mode 100644 index 0000000..df00637 --- /dev/null +++ b/parser/testdata/corpus/sql/function/string/test_caseconvert.test @@ -0,0 +1,49 @@ +# source: test/sql/function/string/test_caseconvert.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +select UPPER('áaaá'), UPPER('ö'), LOWER('S̈'), UPPER('ω') +-- +ok +== +SELECT UPPER('Αα Ββ Γγ Δδ Εε Ζζ Ηη Θθ Ιι Κκ Λλ Μμ Νν Ξξ Οο Ππ Ρρ Σσς Ττ Υυ Φφ Χχ Ψψ Ωω'), LOWER('Αα Ββ Γγ Δδ Εε Ζζ Ηη Θθ Ιι Κκ Λλ Μμ Νν Ξξ Οο Ππ Ρρ Σσς Ττ Υυ Φφ Χχ Ψψ Ωω') +-- +ok +== +select UPPER(''), UPPER('hello'), UPPER('MotörHead'), UPPER(NULL) +-- +ok +== +select LOWER(''), LOWER('hello'), LOWER('MotörHead'), LOWER(NULL) +-- +ok +== +select UCASE(''), UCASE('hello'), UCASE('MotörHead'), UCASE(NULL) +-- +ok +== +select LCASE(''), LCASE('hello'), LCASE('MotörHead'), LCASE(NULL) +-- +ok +== +INSERT INTO strings VALUES ('Hello', 'World'), ('HuLlD', NULL), ('MotörHead','RÄcks') +-- +ok +== +select UPPER(a), UCASE(a) FROM strings +-- +ok +== +select LOWER(a), LCASE(a) FROM strings +-- +ok +== +select LOWER(b), LCASE(b) FROM strings +-- +ok +== +select UPPER(a), LOWER(a), UCASE(a), LCASE(a) FROM strings WHERE b IS NOT NULL +-- +ok +== diff --git a/parser/testdata/corpus/sql/function/string/test_complex_unicode.test b/parser/testdata/corpus/sql/function/string/test_complex_unicode.test new file mode 100644 index 0000000..1c9508f --- /dev/null +++ b/parser/testdata/corpus/sql/function/string/test_complex_unicode.test @@ -0,0 +1,77 @@ +# source: test/sql/function/string/test_complex_unicode.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +SELECT length_grapheme('S̈a') +-- +ok +== +SELECT length_grapheme('🤦🏼‍♂️') +-- +ok +== +SELECT length_grapheme('🤦🏼‍♂️ L🤦🏼‍♂️R 🤦🏼‍♂️') +-- +ok +== +SELECT length('S̈a') +-- +ok +== +SELECT length('🤦🏼‍♂️') +-- +ok +== +SELECT length('🤦🏼‍♂️ L🤦🏼‍♂️R 🤦🏼‍♂️') +-- +ok +== +SELECT strlen('🤦🏼‍♂️') +-- +ok +== +SELECT strlen('S̈a') +-- +ok +== +SELECT REVERSE('S̈a︍') +-- +ok +== +SELECT REVERSE('Z͑ͫ̓ͪ̂ͫ̽͏̴̙̤̞͉͚̯̞̠͍A̴̵̜̰͔ͫ͗͢') +-- +ok +== +SELECT REVERSE('🤦🏼‍♂️') +-- +ok +== +SELECT REVERSE('🤦🏼‍♂️ L🤦🏼‍♂️R 🤦🏼‍♂️') +-- +ok +== +SELECT REVERSE('MotörHead') +-- +ok +== +SELECT substring_grapheme('🤦🏼‍♂️🤦🏼‍♂️🤦🏼‍♂️', 1, 1) +-- +ok +== +SELECT substring_grapheme('S̈a︍', 2, 1) +-- +ok +== +SELECT substring_grapheme('test: 🤦🏼‍♂️hello🤦🏼‍♂️ world', 7, 7) +-- +ok +== +SELECT substring_grapheme('S̈a', 1, 1) +-- +ok +== +SELECT substring_grapheme('S̈a︍', -1, 1) +-- +ok +== diff --git a/parser/testdata/corpus/sql/function/string/test_concat.test b/parser/testdata/corpus/sql/function/string/test_concat.test new file mode 100644 index 0000000..5295c8e --- /dev/null +++ b/parser/testdata/corpus/sql/function/string/test_concat.test @@ -0,0 +1,37 @@ +# source: test/sql/function/string/test_concat.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +SELECT s || ' ' || s FROM strings ORDER BY s +-- +ok +== +SELECT s || ' ' || '🦆' FROM strings ORDER BY s +-- +ok +== +SELECT s || ' ' || '🦆' || NULL FROM strings ORDER BY s +-- +ok +== +SELECT CONCAT() +-- +ok +== +SELECT CONCAT('hello') +-- +ok +== +SELECT CONCAT('hello', 33, 22) +-- +ok +== +SELECT CONCAT('hello', 33, NULL, 22, NULL) +-- +ok +== +SELECT CONCAT('hello', ' ', s) FROM strings ORDER BY s +-- +ok +== diff --git a/parser/testdata/corpus/sql/function/string/test_concat_binding.test b/parser/testdata/corpus/sql/function/string/test_concat_binding.test new file mode 100644 index 0000000..caab4b1 --- /dev/null +++ b/parser/testdata/corpus/sql/function/string/test_concat_binding.test @@ -0,0 +1,57 @@ +# source: test/sql/function/string/test_concat_binding.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +select [1] || [2]; +-- +ok +== +select [1] || NULL; +-- +ok +== +select list_concat([1], NULL); +-- +ok +== +select array[1] || array[2]; +-- +ok +== +select array[1] || array[NULL]; +-- +ok +== +select list_concat(array[1], array[NULL]); +-- +ok +== +select array[1] || cast(NULL as int array); +-- +ok +== +select concat([1], 'hello'); +-- +ok +== +SELECT list_concat([1, 2], ['3', '4']) +-- +ok +== +SELECT list_concat([1, 2], 4) +-- +ok +== +select 'hi' || NULL; +-- +ok +== +select list_concat([1], [2], [3]); +-- +ok +== +select [1] || [2] || [3]; +-- +ok +== diff --git a/parser/testdata/corpus/sql/function/string/test_concat_function.test b/parser/testdata/corpus/sql/function/string/test_concat_function.test new file mode 100644 index 0000000..7976db9 --- /dev/null +++ b/parser/testdata/corpus/sql/function/string/test_concat_function.test @@ -0,0 +1,37 @@ +# source: test/sql/function/string/test_concat_function.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +select CONCAT(a, 'SUFFIX') FROM strings +-- +ok +== +select CONCAT('PREFIX', b) FROM strings +-- +ok +== +select CONCAT(a, b) FROM strings +-- +ok +== +select CONCAT(a, b, 'SUFFIX') FROM strings +-- +ok +== +select CONCAT(a, b, a) FROM strings +-- +ok +== +select CONCAT('1', '2', '3', '4', '5', '6', '7', '8', '9', '0') +-- +ok +== +select '1234567890' || '1234567890', '1234567890' || NULL +-- +ok +== +select CONCAT('1234567890', '1234567890'), CONCAT('1234567890', NULL) +-- +ok +== diff --git a/parser/testdata/corpus/sql/function/string/test_concat_ws.test b/parser/testdata/corpus/sql/function/string/test_concat_ws.test new file mode 100644 index 0000000..948bc4b --- /dev/null +++ b/parser/testdata/corpus/sql/function/string/test_concat_ws.test @@ -0,0 +1,97 @@ +# source: test/sql/function/string/test_concat_ws.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +select CONCAT_WS(',',a, 'SUFFIX') FROM strings +-- +ok +== +select CONCAT_WS('@','PREFIX', b) FROM strings +-- +ok +== +select CONCAT_WS('$',a, b) FROM strings +-- +ok +== +select CONCAT_WS(a, b, 'SUFFIX') FROM strings +-- +ok +== +select CONCAT_WS(a, b, b) FROM strings +-- +ok +== +select CONCAT_WS('@','1', '2', '3', '4', '5', '6', '7', '8', '9') +-- +ok +== +select CONCAT_WS(b, '[', ']') FROM strings ORDER BY a +-- +ok +== +select CONCAT_WS(',', a, 'SUFFIX') FROM strings WHERE a != 'Hello' +-- +ok +== +select CONCAT_WS() +-- +ok +== +select CONCAT_WS(',') +-- +ok +== +select CONCAT_WS(',', 'hello') +-- +ok +== +select CONCAT_WS(NULL, 'hello') +-- +ok +== +select CONCAT_WS(',', NULL) +-- +ok +== +select CONCAT_WS(NULL, b, 'SUFFIX') FROM strings +-- +ok +== +select CONCAT_WS(',', NULL, 'SUFFIX') FROM strings +-- +ok +== +select CONCAT_WS(',', '', '') +-- +ok +== +select CONCAT_WS(',', '', '', '') +-- +ok +== +select CONCAT_WS(',', NULL, NULL) +-- +ok +== +select CONCAT_WS(',', NULL, NULL, NULL) +-- +ok +== +select CONCAT_WS(',', NULL, NULL, 'hello') +-- +ok +== +select CONCAT_WS(a, '', NULL, '') FROM strings ORDER BY a +-- +ok +== +select CONCAT_WS(a, NULL, '', '') FROM strings ORDER BY a; +-- +ok +== +select CONCAT_WS(a, NULL, b, '') FROM strings ORDER BY a +-- +ok +== diff --git a/parser/testdata/corpus/sql/function/string/test_contains.test b/parser/testdata/corpus/sql/function/string/test_contains.test new file mode 100644 index 0000000..64fe0ac --- /dev/null +++ b/parser/testdata/corpus/sql/function/string/test_contains.test @@ -0,0 +1,91 @@ +# source: test/sql/function/string/test_contains.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +SELECT CONTAINS('hello world', 'h'), + CONTAINS('hello world', 'he'), + CONTAINS('hello world', 'hel'), + CONTAINS('hello world', 'hell'), + CONTAINS('hello world', 'hello'), + CONTAINS('hello world', 'hello '), + CONTAINS('hello world', 'hello w'), + CONTAINS('hello world', 'hello wo'), + CONTAINS('hello world', 'hello wor'), + CONTAINS('hello world', 'hello worl') +-- +ok +== +SELECT CONTAINS('hello world', 'a'), + CONTAINS('hello world', 'ha'), + CONTAINS('hello world', 'hea'), + CONTAINS('hello world', 'hela'), + CONTAINS('hello world', 'hella'), + CONTAINS('hello world', 'helloa'), + CONTAINS('hello world', 'hello a'), + CONTAINS('hello world', 'hello wa'), + CONTAINS('hello world', 'hello woa'), + CONTAINS('hello world', 'hello wora') +-- +ok +== +select contains('hello', ''), contains('', ''), contains(NULL, '') +-- +ok +== +CREATE TABLE strings(s VARCHAR, off INTEGER, length INTEGER); +-- +ok +== +INSERT INTO strings VALUES ('hello', 1, 2), ('world', 2, 3), ('b', 1, 1), (NULL, 2, 2) +-- +ok +== +SELECT contains(s,'h') FROM strings +-- +ok +== +SELECT contains(s,'e') FROM strings +-- +ok +== +SELECT contains(s,'d') FROM strings +-- +ok +== +SELECT contains(s,'he') FROM strings +-- +ok +== +SELECT contains(s,'ello') FROM strings +-- +ok +== +SELECT contains(s,'lo') FROM strings +-- +ok +== +SELECT contains(s,'he-man') FROM strings +-- +ok +== +SELECT contains(s,'o') FROM strings +-- +ok +== +SELECT contains(NULL,'o') FROM strings +-- +ok +== +SELECT contains(s,NULL) FROM strings +-- +ok +== +SELECT contains(NULL,NULL) FROM strings +-- +ok +== +SELECT contains(s,'') FROM strings +-- +ok +== diff --git a/parser/testdata/corpus/sql/function/string/test_contains_utf8.test b/parser/testdata/corpus/sql/function/string/test_contains_utf8.test new file mode 100644 index 0000000..2a615ff --- /dev/null +++ b/parser/testdata/corpus/sql/function/string/test_contains_utf8.test @@ -0,0 +1,49 @@ +# source: test/sql/function/string/test_contains_utf8.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +INSERT INTO strings VALUES ('átomo') +-- +ok +== +INSERT INTO strings VALUES ('olá mundo') +-- +ok +== +INSERT INTO strings VALUES ('你好世界') +-- +ok +== +INSERT INTO strings VALUES ('two ñ three ₡ four 🦆 end') +-- +ok +== +SELECT contains(s,'á') FROM strings +-- +ok +== +SELECT contains(s,'olá mundo') FROM strings +-- +ok +== +SELECT contains(s,'你好世界') FROM strings +-- +ok +== +SELECT contains(s,'two ñ thr') FROM strings +-- +ok +== +SELECT contains(s,'ñ') FROM strings +-- +ok +== +SELECT contains(s,'₡ four 🦆 e') FROM strings +-- +ok +== +SELECT contains(s,'🦆 end') FROM strings +-- +ok +== diff --git a/parser/testdata/corpus/sql/function/string/test_damerau_levenshtein.test b/parser/testdata/corpus/sql/function/string/test_damerau_levenshtein.test new file mode 100644 index 0000000..d01f417 --- /dev/null +++ b/parser/testdata/corpus/sql/function/string/test_damerau_levenshtein.test @@ -0,0 +1,230 @@ +# source: test/sql/function/string/test_damerau_levenshtein.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +SELECT damerau_levenshtein('out', 'out') +-- +ok +== +SELECT damerau_levenshtein('three', 'there') +-- +ok +== +SELECT damerau_levenshtein('potion', 'option') +-- +ok +== +SELECT damerau_levenshtein('letter', 'lettre') +-- +ok +== +SELECT damerau_levenshtein('out', 'to') +-- +ok +== +SELECT damerau_levenshtein('to', 'out') +-- +ok +== +SELECT damerau_levenshtein('laos', 'also') +-- +ok +== +SELECT damerau_levenshtein('tomato', 'otamot') +-- +ok +== +SELECT damerau_levenshtein('abcdefg', 'bacedgf') +-- +ok +== +SELECT damerau_levenshtein('abcdefghi', 'bzacdefig') +-- +ok +== +SELECT damerau_levenshtein('bzacdefig', 'abcdefghi') +-- +ok +== +SELECT damerau_levenshtein('at', 'tarokk') +-- +ok +== +SELECT damerau_levenshtein('tarokk', 'at') +-- +ok +== +SELECT damerau_levenshtein('organ', 'no') +-- +ok +== +SELECT damerau_levenshtein('trips', 'strip') +-- +ok +== +SELECT damerau_levenshtein('cat', 'cats') +-- +ok +== +SELECT damerau_levenshtein('rat', 'brat') +-- +ok +== +SELECT damerau_levenshtein('amanaplanacanalpanama', 'm23aanaplancaanaalnama') +-- +ok +== +SELECT damerau_levenshtein('', 'great') +-- +ok +== +SELECT damerau_levenshtein('great', '') +-- +ok +== +SELECT damerau_levenshtein('', '') +-- +ok +== +SELECT damerau_levenshtein(NULL, 'drive') +-- +ok +== +SELECT damerau_levenshtein('drive', NULL) +-- +ok +== +SELECT damerau_levenshtein(NULL, NULL) +-- +ok +== +SELECT damerau_levenshtein('', NULL) +-- +ok +== +SELECT damerau_levenshtein(NULL, '') +-- +ok +== +SELECT damerau_levenshtein('one', 'two', 'three') +-- +ok +== +SELECT damerau_levenshtein('one') +-- +ok +== +SELECT damerau_levenshtein() +-- +ok +== +INSERT INTO strings VALUES ('here'), ('heres'), ('there'), ('three'), ('threes') +-- +ok +== +SELECT damerau_levenshtein(s, 'theres') FROM strings ORDER BY s +-- +ok +== +SELECT damerau_levenshtein('herse', s) FROM strings ORDER BY s +-- +ok +== +SELECT damerau_levenshtein(NULL, s) FROM strings +-- +ok +== +SELECT damerau_levenshtein('', s) FROM strings ORDER BY s +-- +ok +== +SELECT damerau_levenshtein(s, '') FROM strings ORDER BY s +-- +ok +== +DROP TABLE strings +-- +ok +== +INSERT INTO strings VALUES (NULL) +-- +ok +== +SELECT damerau_levenshtein(s, NULL) from strings +-- +ok +== +SELECT damerau_levenshtein(NULL, s) from strings +-- +ok +== +SELECT damerau_levenshtein('test', s) from strings +-- +ok +== +SELECT damerau_levenshtein(s, 'test') from strings +-- +ok +== +SELECT damerau_levenshtein('null', s) from strings +-- +ok +== +SELECT damerau_levenshtein('', s) FROM strings +-- +ok +== +SELECT damerau_levenshtein(s, '') FROM strings +-- +ok +== +INSERT INTO strings VALUES ('') +-- +ok +== +SELECT damerau_levenshtein(NULL, s) FROM strings +-- +ok +== +SELECT damerau_levenshtein(s, NULL) FROM strings +-- +ok +== +SELECT damerau_levenshtein(s, 'test') FROM strings +-- +ok +== +SELECT damerau_levenshtein('test', s) FROM strings +-- +ok +== +SELECT damerau_levenshtein('null', s) FROM strings +-- +ok +== +CREATE TABLE strings(s_left VARCHAR, s_right VARCHAR) +-- +ok +== +INSERT INTO strings VALUES ('identical', 'identical'), ('dientical', 'identical'), + ('dinetcila', 'identical'), ('abcdefghijk', 'bacdfzzeghki'), + ('abcd', 'bcda'), ('great', 'greta'), + ('abcdefghijklmnopqrstuvwxyz', 'abdcpoxwz'), + ('a_considerably_longer_string', 'a_ocnsiderably_longre_tsrig'), + ('another-quite-long-string', 'naothre-quit-elongstrnig'), + ('littlehampton', 'littlerhamptoner'), + ('an_incredibly_long_string_to_compare', 'na_incerdibl_ylong_sr56ting_ot_ocmrpe'), + ('smaller', 'notsmaller,longer'), + ('againalongerstring', 'string'), + (NULL, NULL), ('', ''), + (NULL, 'test'), ('test', NULL), + ('four', ''), ('', 'four'), + (NULL, ''), ('', NULL) +-- +ok +== +SELECT damerau_levenshtein(s_left, s_right) FROM strings +-- +ok +== diff --git a/parser/testdata/corpus/sql/function/string/test_format.test b/parser/testdata/corpus/sql/function/string/test_format.test new file mode 100644 index 0000000..1a16d37 --- /dev/null +++ b/parser/testdata/corpus/sql/function/string/test_format.test @@ -0,0 +1,89 @@ +# source: test/sql/function/string/test_format.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +SELECT format('hello'), format(NULL) +-- +ok +== +SELECT format('{}', 'hello'), format('{}: {}', 'hello', 'world') +-- +ok +== +SELECT format('{}', NULL), format(NULL, 'hello', 'world') +-- +ok +== +SELECT format('{} {}', TRUE, FALSE) +-- +ok +== +SELECT format('{}', 33), format('{} + {} = {}', 3, 5, 3 + 5) +-- +ok +== +SELECT format('{} {} = {}', DATE '1992-01-01', TIME '12:01:00', TIMESTAMP '1992-01-01 12:01:00') +-- +ok +== +SELECT format('{}', BLOB '\x00hello') +-- +ok +== +SELECT format('{}', 120381902481294715712::HUGEINT) +-- +ok +== +SELECT format('{}', 120381902481294715712::UHUGEINT) +-- +ok +== +SELECT format('{:.3f}', '1.234'::DECIMAL) +-- +ok +== +SELECT format('{:04d}', 33), format('{} {:02d}:{:02d}:{:02d} {}', 'time', 12, 3, 16, 'AM'), format('{:10d}', 1992) +-- +ok +== +SELECT format('{1} {1} {0} {0}', 1, 2) +-- +ok +== +select format('{:x}', 123456789) +-- +ok +== +select format('{:b}', 123456789) +-- +ok +== +select format('{:.2}', 0.00023404094995959); +-- +ok +== +select format('{:.3}', 0.0); +-- +ok +== +SELECT format('{}') +-- +ok +== +SELECT format('{} {}', 'hello') +-- +ok +== +SELECT format('{}', 'hello', 'world') +-- +ok +== +SELECT format('{:s}', 42) +-- +ok +== +SELECT format('{:d}', 'hello') +-- +ok +== diff --git a/parser/testdata/corpus/sql/function/string/test_format_extensions.test b/parser/testdata/corpus/sql/function/string/test_format_extensions.test new file mode 100644 index 0000000..67f21b7 --- /dev/null +++ b/parser/testdata/corpus/sql/function/string/test_format_extensions.test @@ -0,0 +1,125 @@ +# source: test/sql/function/string/test_format_extensions.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +select printf('%,d', 123456789) +-- +ok +== +select format('{:d}', 123456789) +-- +ok +== +select printf('%,d', 123456789123456789123456789::HUGEINT) +-- +ok +== +select printf('%.d', 123456789) +-- +ok +== +select printf('%.d', -123456789123456789123456789::HUGEINT) +-- +ok +== +select printf('%_d', 123456789) +-- +ok +== +select printf('%''d', 123456789) +-- +ok +== +select printf('%.0d', 123456789) +-- +ok +== +select format('{:,}', 123456789) +-- +ok +== +select format('{:_}', 123456789) +-- +ok +== +select format('{:''}', 123456789) +-- +ok +== +select format('{:,}', 123456789123456789123456789::UHUGEINT) +-- +ok +== +select format('{:t }', 123456789) +-- +ok +== +select format('{:t|}', 123456789) +-- +ok +== +select format('{:tss}', 123456789) +-- +ok +== +select format('{:,}', 123456789.123) +-- +ok +== +select format('{:_}', 123456789.123) +-- +ok +== +select printf('%,.3f', 123456.789::DOUBLE) +-- +ok +== +select printf('%+,.0f', -5::TINYINT), printf('%+,.0f', -5::SMALLINT), printf('%+,.0f', -5::INTEGER), printf('%+,.0f', -5::BIGINT), printf('%+,.0f', -5::HUGEINT) +-- +ok +== +select printf('%,.0f', 9007199254740993::BIGINT), printf('%,.0f', 18446744073709551615::UBIGINT) +-- +ok +== +select printf('%,.0e', -5::BIGINT), printf('%,.0f', -5::BIGINT), printf('%,.3g', -5::BIGINT), printf('%,.0a', -5::BIGINT) +-- +ok +== +select printf('%+,.0f / %,.0f / %,.0f', -5::BIGINT, 9007199254740993::BIGINT, 5::UBIGINT) +-- +ok +== +select printf('%,.f', {val}::double) = printf('%,d', {val}::bigint); +-- +error: Parser Error: syntax error at or near "}" +== +select format('{:t}', 123456789) +-- +ok +== +select format('{0:d} {0:L}', 123456789) +-- +ok +== +select format('{1}', 123456789) +-- +ok +== +select format('{L}', 123456789) +-- +ok +== +select printf('%:', 123456789) +-- +ok +== +select printf('%:', 123456789.123) +-- +ok +== +select printf('%:', 'str') +-- +ok +== diff --git a/parser/testdata/corpus/sql/function/string/test_glob.test b/parser/testdata/corpus/sql/function/string/test_glob.test new file mode 100644 index 0000000..1d45224 --- /dev/null +++ b/parser/testdata/corpus/sql/function/string/test_glob.test @@ -0,0 +1,213 @@ +# source: test/sql/function/string/test_glob.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +SELECT 'aaa' GLOB 'bbb' +-- +ok +== +SELECT 'aaa' GLOB 'aaa' +-- +ok +== +SELECT 'aaa' GLOB '*' +-- +ok +== +SELECT 'aaa' GLOB '*a' +-- +ok +== +SELECT 'aaa' GLOB '*b' +-- +ok +== +SELECT 'aaa' GLOB 'a*' +-- +ok +== +SELECT 'aaa' GLOB 'b*' +-- +ok +== +SELECT 'aaa' GLOB 'a?a' +-- +ok +== +SELECT 'aaa' GLOB 'a?' +-- +ok +== +SELECT 'aaa' GLOB '??*' +-- +ok +== +SELECT 'aaa' GLOB '????*' +-- +ok +== +SELECT 'ababac' GLOB '*abac' +-- +ok +== +SELECT '3' GLOB '[0-9]' +-- +ok +== +SELECT 'a' GLOB '[0-9]' +-- +ok +== +SELECT '012' GLOB '[0-9][0-9][0-9]' +-- +ok +== +SELECT '012' GLOB '[0-9][0-9][0-9]a' +-- +ok +== +SELECT '012a' GLOB '[0-9][0-9][0-9]' +-- +ok +== +SELECT 'b3' GLOB '[abc0-9][abc0-9]' +-- +ok +== +SELECT 'd3' GLOB '[abc0-9][abc0-9]' +-- +ok +== +SELECT 'a' GLOB '[!0-9]' +-- +ok +== +SELECT '1' GLOB '[!0-9]' +-- +ok +== +SELECT '*' GLOB '\*' +-- +ok +== +SELECT 'a' GLOB '\*' +-- +ok +== +SELECT '\' GLOB '\\' +-- +ok +== +SELECT 'a' GLOB '\\' +-- +ok +== +SELECT '3]' GLOB '[]3][]]' +-- +ok +== +SELECT '3' GLOB '[3' +-- +ok +== +SELECT '3' GLOB '[3-' +-- +ok +== +SELECT '3' GLOB '\\' +-- +ok +== +SELECT '3' GLOB '\' +-- +ok +== +SELECT '3' GLOB '3***' +-- +ok +== +SELECT '1245' GLOB '**1***2*******4*5***' +-- +ok +== +SELECT 'aaaaaaaaaaaaaaaaaaaaaaa' GLOB '*a' +-- +ok +== +SELECT '?' GLOB '[?]' +-- +ok +== +SELECT '3' GLOB '[?]' +-- +ok +== +SELECT '*' GLOB '[*]' +-- +ok +== +SELECT '3' GLOB '[*]' +-- +ok +== +SELECT '6' GLOB '[1-35-7]' +-- +ok +== +SELECT '4' GLOB '[1-35-7]' +-- +ok +== +SELECT '4' GLOB '[' +-- +ok +== +SELECT 'abac' GLOB '*a[bc]' +-- +ok +== +SELECT 'abad' GLOB '*a[bc]' +-- +ok +== +SELECT 'xx*' GLOB '*\*' +-- +ok +== +SELECT 'xxa' GLOB '*\*' +-- +ok +== +SELECT 'ab' GLOB '*?' +-- +ok +== +SELECT 'abc' GLOB '*[' +-- +ok +== +SELECT repeat('a', 35) || 'c' GLOB '*a*a*a*a*a*a*a*a*a*a*a*a*a*a*b' +-- +ok +== +CREATE TABLE strings(s STRING, pat STRING); +-- +ok +== +INSERT INTO strings VALUES ('abab', 'ab*'), ('aaa', 'a?a'), ('aaa', '*b*') +-- +ok +== +SELECT s FROM strings WHERE s GLOB 'ab*' +-- +ok +== +SELECT s FROM strings WHERE 'aba' GLOB pat +-- +ok +== +SELECT s FROM strings WHERE s GLOB pat +-- +ok +== diff --git a/parser/testdata/corpus/sql/function/string/test_ilike.test b/parser/testdata/corpus/sql/function/string/test_ilike.test new file mode 100644 index 0000000..63de0f4 --- /dev/null +++ b/parser/testdata/corpus/sql/function/string/test_ilike.test @@ -0,0 +1,117 @@ +# source: test/sql/function/string/test_ilike.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +SELECT 'aaa' ILIKE 'bbb' +-- +ok +== +SELECT 'aaa' ILIKE 'aAa' +-- +ok +== +SELECT 'aaa' ILIKE '%' +-- +ok +== +SELECT 'aaa' ILIKE '%A' +-- +ok +== +SELECT 'aaa' ILIKE '%b' +-- +ok +== +SELECT 'aaa' ILIKE 'A%' +-- +ok +== +SELECT 'aaa' ILIKE 'b%' +-- +ok +== +SELECT 'aaa' ILIKE 'A_a' +-- +ok +== +SELECT 'aaa' ILIKE 'a_' +-- +ok +== +SELECT 'aaa' ILIKE '__%' +-- +ok +== +SELECT 'aaa' ILIKE '____%' +-- +ok +== +SELECT 'ababac' ILIKE '%abac' +-- +ok +== +SELECT 'ababac' ILIKE '%%%aBac' +-- +ok +== +SELECT 'ababac' ILIKE 'abab%%%%%' +-- +ok +== +SELECT 'ababac' ILIKE '%%%a%%%b%%a%b%%%%%a%c%%' +-- +ok +== +SELECT 'ababac' ILIKE '%%%a%%%b%%a%b%%%%%a%d%%' +-- +ok +== +SELECT 'ababac' NOT ILIKE '%Abac' +-- +ok +== +INSERT INTO strings VALUES ('abab', 'Ab%'), ('aaa', 'A_a'), ('aaa', '%b%') +-- +ok +== +SELECT s FROM strings WHERE s LIKE 'ab%' +-- +ok +== +SELECT s FROM strings WHERE 'aba' ILIKE pat +-- +ok +== +SELECT s FROM strings WHERE 'aba' NOT ILIKE pat +-- +ok +== +SELECT s FROM strings WHERE s ILIKE pat +-- +ok +== +SELECT s FROM strings WHERE s NOT ILIKE pat +-- +ok +== +SELECT 'MÜHLEISEN' ILIKE 'mühleisen' +-- +ok +== +CREATE TABLE unicode_strings(s STRING, pat STRING); +-- +ok +== +INSERT INTO unicode_strings VALUES ('öäb', 'Ö%B'), ('aaÄ', 'A_ä'), ('aaa', '%b%') +-- +ok +== +SELECT s FROM unicode_strings WHERE s ILIKE pat +-- +ok +== +SELECT s FROM unicode_strings WHERE s NOT ILIKE pat +-- +ok +== diff --git a/parser/testdata/corpus/sql/function/string/test_ilike_constant_pattern.test b/parser/testdata/corpus/sql/function/string/test_ilike_constant_pattern.test new file mode 100644 index 0000000..80c421a --- /dev/null +++ b/parser/testdata/corpus/sql/function/string/test_ilike_constant_pattern.test @@ -0,0 +1,129 @@ +# source: test/sql/function/string/test_ilike_constant_pattern.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +CREATE TABLE t(id INTEGER, s VARCHAR); +-- +ok +== +INSERT INTO t VALUES + (1, 'café Hello World'), + (2, 'DuckDB is FAST'), + (3, 'the quick brown fox'), + (4, 'STRAßE'), + (5, 'Æther WAVE'), + (6, 'café déjà vu'), + (7, NULL), + (8, ''), + (9, 'ALPHA bravo CHARLIE'); +-- +ok +== +SELECT id FROM t WHERE s ILIKE '%hello%' ORDER BY id +-- +ok +== +SELECT id FROM t WHERE s ILIKE '%WORLD%' ORDER BY id +-- +ok +== +SELECT id FROM t WHERE s ILIKE '%brown fox%' ORDER BY id +-- +ok +== +SELECT id FROM t WHERE s ILIKE '%zznotfound%' ORDER BY id +-- +ok +== +SELECT id FROM t WHERE s ILIKE 'duckdb%' ORDER BY id +-- +ok +== +SELECT id FROM t WHERE s ILIKE '%fast' ORDER BY id +-- +ok +== +SELECT id FROM t WHERE s ILIKE 'the quick brown fox' ORDER BY id +-- +ok +== +SELECT id FROM t WHERE s ILIKE '%æther%' ORDER BY id +-- +ok +== +SELECT id FROM t WHERE s ILIKE '%DÉJÀ%' ORDER BY id +-- +ok +== +SELECT id FROM t WHERE s ILIKE '%strasse%' ORDER BY id +-- +ok +== +SELECT id FROM t WHERE s ILIKE '%straße%' ORDER BY id +-- +ok +== +SELECT id FROM t WHERE s ILIKE '%c_fé%' ORDER BY id +-- +ok +== +SELECT id FROM t WHERE s ILIKE '%alpha%charlie%' ORDER BY id +-- +ok +== +SELECT id FROM t WHERE s NOT ILIKE '%a%' ORDER BY id +-- +ok +== +SELECT id FROM t WHERE s ILIKE '%' ORDER BY id +-- +ok +== +SELECT id FROM t WHERE s ILIKE '' ORDER BY id +-- +ok +== +SELECT id FROM t WHERE s ILIKE NULL ORDER BY id +-- +ok +== +PREPARE p AS SELECT id FROM t WHERE s ILIKE '%' || ? || '%' ORDER BY id +-- +ok +== +EXECUTE p('hello') +-- +ok +== +EXECUTE p('CAFÉ') +-- +ok +== +EXECUTE p('zznotfound') +-- +ok +== +CREATE TABLE pats(id INTEGER, s VARCHAR, pat VARCHAR); +-- +ok +== +INSERT INTO pats VALUES + (1, 'café Hello', '%HELLO%'), + (2, 'DuckDB', '%duck%'), + (3, 'fox', '%cat%'); +-- +ok +== +SELECT id FROM pats WHERE s ILIKE pat ORDER BY id +-- +ok +== +SELECT 'MÜHLEISEN' ILIKE '%hleis%' +-- +ok +== +SELECT 'Hello' NOT ILIKE '%XYZ%' +-- +ok +== diff --git a/parser/testdata/corpus/sql/function/string/test_ilike_embedded_null.test b/parser/testdata/corpus/sql/function/string/test_ilike_embedded_null.test new file mode 100644 index 0000000..629bc3e --- /dev/null +++ b/parser/testdata/corpus/sql/function/string/test_ilike_embedded_null.test @@ -0,0 +1,61 @@ +# source: test/sql/function/string/test_ilike_embedded_null.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +CREATE TABLE t(a VARCHAR, b VARCHAR); +-- +ok +== +INSERT INTO t VALUES ('goo'||chr(0)||'se', 'goo'||chr(0)||'se'), ('🦆','🦆'); +-- +ok +== +SELECT a ILIKE b FROM t +-- +ok +== +SELECT ('goo' || chr(0) || 'se') ILIKE ('goo' || chr(0) || 'se') +-- +ok +== +CREATE TABLE ascii_only(a VARCHAR, b VARCHAR); +-- +ok +== +INSERT INTO ascii_only VALUES ('goo' || chr(0) || 'se', 'goo' || chr(0) || 'se'); +-- +ok +== +SELECT a ILIKE b FROM ascii_only +-- +ok +== +CREATE TABLE unicode_possible(a VARCHAR, b VARCHAR); +-- +ok +== +INSERT INTO unicode_possible VALUES ('goo' || chr(0) || 'se', 'goo' || chr(0) || 'se'), ('🦆', '🦆'); +-- +ok +== +SELECT a ILIKE b, a !~~* b FROM unicode_possible ORDER BY a +-- +ok +== +SELECT a ILIKE ('goo' || chr(0) || 'se'), a NOT ILIKE ('goo' || chr(0) || 'se') FROM unicode_possible ORDER BY a +-- +ok +== +SELECT a ILIKE ('GOO' || chr(0) || 'SE') FROM unicode_possible ORDER BY a +-- +ok +== +SELECT a ILIKE ('goo' || chr(0) || '%') FROM unicode_possible ORDER BY a +-- +ok +== +SELECT a ILIKE ('goo' || chr(0) || 'se') ESCAPE '' FROM unicode_possible ORDER BY a +-- +ok +== diff --git a/parser/testdata/corpus/sql/function/string/test_ilike_escape.test b/parser/testdata/corpus/sql/function/string/test_ilike_escape.test new file mode 100644 index 0000000..7f1fd39 --- /dev/null +++ b/parser/testdata/corpus/sql/function/string/test_ilike_escape.test @@ -0,0 +1,97 @@ +# source: test/sql/function/string/test_ilike_escape.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +select 'a%c' ilike 'a$%C' escape '$'; +-- +ok +== +select 'A%C' ilike 'a$%c' escape '$'; +-- +ok +== +select 'a%c' ilike 'a$%C' escape '/'; +-- +ok +== +select NULL ilike 'a$%C' escape '/'; +-- +ok +== +select 'a%c' ilike NULL escape '$'; +-- +ok +== +select 'a%c' ilike 'a$%C' escape NULL; +-- +ok +== +CREATE TABLE tbl(str VARCHAR, pat VARCHAR); +-- +ok +== +INSERT INTO tbl VALUES ('a%c', 'a$%C'); +-- +ok +== +SELECT str ILIKE pat ESCAPE '$' FROM tbl +-- +ok +== +SELECT str NOT ILIKE pat ESCAPE '$' FROM tbl +-- +ok +== +SELECT NULL ILIKE pat ESCAPE '$' FROM tbl +-- +ok +== +SELECT str ILIKE NULL ESCAPE '$' FROM tbl +-- +ok +== +SELECT str ILIKE pat ESCAPE NULL FROM tbl +-- +ok +== +select 'a%c' ilike 'a$%C' escape '///'; +-- +ok +== +SELECT str ILIKE pat ESCAPE str FROM tbl +-- +ok +== +SELECT '%' ILIKE (chr(0) || '%') ESCAPE chr(0), + '%' NOT ILIKE (chr(0) || '%') ESCAPE chr(0), + '%' ILIKE (chr(0) || '%') ESCAPE '', + (chr(0) || '%') ILIKE (chr(0) || '%') ESCAPE '' +-- +ok +== +CREATE TABLE nul_escapes(str VARCHAR, pat VARCHAR, esc VARCHAR); +-- +ok +== +INSERT INTO nul_escapes VALUES + ('A%', 'a' || chr(0) || '%', chr(0)), + ('A%', 'a' || chr(0) || '%', ''); +-- +ok +== +SELECT str ILIKE pat ESCAPE esc FROM nul_escapes ORDER BY esc +-- +ok +== +SELECT str ILIKE ('a' || chr(0) || '%') ESCAPE chr(0), + str ILIKE ('a' || chr(0) || '%') ESCAPE '' +FROM (VALUES ('A%'), ('🦆')) t(str) +ORDER BY str +-- +ok +== +SELECT 'ab' ILIKE ('a' || chr(0)) ESCAPE chr(0) +-- +ok +== diff --git a/parser/testdata/corpus/sql/function/string/test_ilike_escape_constant_pattern.test b/parser/testdata/corpus/sql/function/string/test_ilike_escape_constant_pattern.test new file mode 100644 index 0000000..1aa8732 --- /dev/null +++ b/parser/testdata/corpus/sql/function/string/test_ilike_escape_constant_pattern.test @@ -0,0 +1,154 @@ +# source: test/sql/function/string/test_ilike_escape_constant_pattern.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +INSERT INTO t VALUES + (1, 'café Hello World'), + (2, 'DuckDB is FAST'), + (3, 'the quick brown fox'), + (4, 'STRAßE'), + (5, 'Æther WAVE'), + (6, 'café déjà vu'), + (7, NULL), + (8, ''), + (9, '100% done'), + (10, 'under_score here'); +-- +ok +== +SELECT id FROM t WHERE s ILIKE '%hello%' ESCAPE '\' ORDER BY id +-- +ok +== +SELECT id FROM t WHERE s ILIKE '%BROWN FOX%' ESCAPE '\' ORDER BY id +-- +ok +== +SELECT id FROM t WHERE s ILIKE '%zznotfound%' ESCAPE '\' ORDER BY id +-- +ok +== +SELECT id FROM t WHERE s ILIKE 'duckdb%' ESCAPE '\' ORDER BY id +-- +ok +== +SELECT id FROM t WHERE s ILIKE '%fast' ESCAPE '\' ORDER BY id +-- +ok +== +SELECT id FROM t WHERE s ILIKE 'the quick brown fox' ESCAPE '\' ORDER BY id +-- +ok +== +SELECT id FROM t WHERE s ILIKE '%æther%' ESCAPE '\' ORDER BY id +-- +ok +== +SELECT id FROM t WHERE s ILIKE '%DÉJÀ%' ESCAPE '\' ORDER BY id +-- +ok +== +SELECT id FROM t WHERE s ILIKE '%strasse%' ESCAPE '\' ORDER BY id +-- +ok +== +SELECT id FROM t WHERE s ILIKE '%straße%' ESCAPE '\' ORDER BY id +-- +ok +== +SELECT id FROM t WHERE s ILIKE '%100%done%' ESCAPE '\' ORDER BY id +-- +ok +== +SELECT id FROM t WHERE s ILIKE '%\%%' ESCAPE '\' ORDER BY id +-- +ok +== +SELECT id FROM t WHERE s ILIKE '%\_%' ESCAPE '\' ORDER BY id +-- +ok +== +SELECT id FROM t WHERE s ILIKE '%100\% DONE%' ESCAPE '\' ORDER BY id +-- +ok +== +SELECT id FROM t WHERE s ILIKE '%100x%%' ESCAPE 'x' ORDER BY id +-- +ok +== +SELECT id FROM t WHERE s ILIKE '%c_fé%' ESCAPE '\' ORDER BY id +-- +ok +== +SELECT id FROM t WHERE s ILIKE '%c_zzz%' ESCAPE '\' ORDER BY id +-- +ok +== +SELECT id FROM t WHERE s NOT ILIKE '%a%' ESCAPE '\' ORDER BY id +-- +ok +== +SELECT id FROM t WHERE s ILIKE '%' ESCAPE '\' ORDER BY id +-- +ok +== +SELECT id FROM t WHERE s ILIKE '' ESCAPE '\' ORDER BY id +-- +ok +== +SELECT id FROM t WHERE s ILIKE '%hello%' ESCAPE '' ORDER BY id +-- +ok +== +SELECT id FROM t WHERE s ILIKE NULL ESCAPE '\' ORDER BY id +-- +ok +== +SELECT id FROM t WHERE s ILIKE '%hello%' ESCAPE NULL ORDER BY id +-- +ok +== +SELECT 'abc' ILIKE '%a%' ESCAPE NULL +-- +ok +== +PREPARE p AS SELECT id FROM t WHERE s ILIKE '%' || ? || '%' ESCAPE '\' ORDER BY id +-- +ok +== +INSERT INTO pats VALUES + (1, 'café Hello', '%HELLO%'), + (2, 'DuckDB', '%duck%'), + (3, '50% off', '%\%%'), + (4, 'fox', '%cat%'); +-- +ok +== +SELECT id FROM pats WHERE s ILIKE pat ESCAPE '\' ORDER BY id +-- +ok +== +SELECT id FROM t +WHERE (s ILIKE '%café%' ESCAPE '\' AND s ILIKE '%hello%' ESCAPE '\') + OR (s ILIKE '%duck%' ESCAPE '\' AND s ILIKE '%fast%' ESCAPE '\') +ORDER BY id +-- +ok +== +CREATE TABLE esc_t(id INTEGER, s VARCHAR, pat VARCHAR, esc VARCHAR); +-- +ok +== +INSERT INTO esc_t VALUES + (1, 'café x', '%c_fé%', '\'), + (2, '50% off', '%50\% off%', '\'), + (3, 'fox', '%cat%', '#'), + (4, 'a#%b', '%a#%%', '#'); +-- +ok +== +SELECT id FROM esc_t WHERE s ILIKE pat ESCAPE esc ORDER BY id +-- +ok +== diff --git a/parser/testdata/corpus/sql/function/string/test_instr.test b/parser/testdata/corpus/sql/function/string/test_instr.test new file mode 100644 index 0000000..403e89f --- /dev/null +++ b/parser/testdata/corpus/sql/function/string/test_instr.test @@ -0,0 +1,57 @@ +# source: test/sql/function/string/test_instr.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +SELECT instr(s,'h') FROM strings +-- +ok +== +SELECT position('h' in s) FROM strings +-- +ok +== +SELECT instr(s,'e') FROM strings +-- +ok +== +SELECT instr(s,'d') FROM strings +-- +ok +== +SELECT instr(s,'he') FROM strings +-- +ok +== +SELECT position('he' in s) FROM strings +-- +ok +== +SELECT instr(s,'ello') FROM strings +-- +ok +== +SELECT instr(s,'lo') FROM strings +-- +ok +== +SELECT instr(s,'he-man') FROM strings +-- +ok +== +SELECT instr(s,'o'),s FROM strings +-- +ok +== +SELECT instr(NULL,'o') FROM strings +-- +ok +== +SELECT instr(s,NULL) FROM strings +-- +ok +== +SELECT instr(NULL,NULL) FROM strings +-- +ok +== diff --git a/parser/testdata/corpus/sql/function/string/test_instr_utf8.test b/parser/testdata/corpus/sql/function/string/test_instr_utf8.test new file mode 100644 index 0000000..a9dd56c --- /dev/null +++ b/parser/testdata/corpus/sql/function/string/test_instr_utf8.test @@ -0,0 +1,37 @@ +# source: test/sql/function/string/test_instr_utf8.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +SELECT INSTR(s,'á') FROM strings +-- +ok +== +SELECT POSITION('á' in s) FROM strings +-- +ok +== +SELECT INSTR(s,'olá mundo') FROM strings +-- +ok +== +SELECT INSTR(s,'你好世界') FROM strings +-- +ok +== +SELECT instr(s,'two ñ thr') FROM strings +-- +ok +== +SELECT instr(s,'ñ') FROM strings +-- +ok +== +SELECT instr(s,'₡ four 🦆 e') FROM strings +-- +ok +== +SELECT instr(s,'🦆 end') FROM strings +-- +ok +== diff --git a/parser/testdata/corpus/sql/function/string/test_issue_1812.test b/parser/testdata/corpus/sql/function/string/test_issue_1812.test new file mode 100644 index 0000000..972b7b2 --- /dev/null +++ b/parser/testdata/corpus/sql/function/string/test_issue_1812.test @@ -0,0 +1,52 @@ +# source: test/sql/function/string/test_issue_1812.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +CREATE TABLE t (str VARCHAR); +-- +ok +== +INSERT INTO t VALUES ('hello1'), ('hello2'), ('hello3'), ('world1'), ('world2'), ('world3'); +-- +ok +== +SELECT COUNT(*) FROM t WHERE str LIKE '%o%'; -- 6 +-- +ok +== +SELECT COUNT(*) FROM t WHERE str LIKE '%rld%'; -- 3 +-- +ok +== +SELECT COUNT(*) FROM t WHERE str LIKE '%o%' OR (str LIKE '%o%' AND str LIKE '%rld%'); +-- +ok +== +SELECT COUNT(*) FROM t +WHERE (str LIKE '%o%' AND str LIKE '%rld%') + OR str LIKE '%o%'; +-- +ok +== +SELECT COUNT(*) FROM t +WHERE (str LIKE '%o%' AND str LIKE '%rld%') + OR (str LIKE '%o%') + OR (str LIKE '%o%'); +-- +ok +== +SELECT COUNT(*) FROM t +WHERE (str LIKE '%o%' AND str LIKE '%rld%') + OR (str LIKE '%o%') + OR (str LIKE '%o%' AND str LIKE 'blabla%'); +-- +ok +== +SELECT COUNT(*) FROM t +WHERE (str LIKE '%o%' AND str LIKE '%1%') + OR (str LIKE '%o%' AND str LIKE '%1%' AND str LIKE 'blabla%') + OR (str LIKE '%o%' AND str LIKE '%1%' AND str LIKE 'blabla2%') +-- +ok +== diff --git a/parser/testdata/corpus/sql/function/string/test_jaccard.test b/parser/testdata/corpus/sql/function/string/test_jaccard.test new file mode 100644 index 0000000..1147b8f --- /dev/null +++ b/parser/testdata/corpus/sql/function/string/test_jaccard.test @@ -0,0 +1,113 @@ +# source: test/sql/function/string/test_jaccard.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +SELECT jaccard('hello', 'hello') +-- +ok +== +SELECT jaccard('hello', NULL) +-- +ok +== +SELECT jaccard(NULL, 'hello') +-- +ok +== +SELECT jaccard(NULL, NULL) +-- +ok +== +SELECT jaccard('ab', 'aabb') +-- +ok +== +SELECT jaccard('aabb', 'ab') +-- +ok +== +SELECT jaccard('ab', 'cd') +-- +ok +== +SELECT jaccard('cd', 'ab') +-- +ok +== +SELECT round(jaccard('ab', 'aabbcc'), 3) +-- +ok +== +SELECT round(jaccard('aabbcc', 'ab'), 3) +-- +ok +== +SELECT round(jaccard('aabbccddeeff', 'ab'), 3) +-- +ok +== +SELECT round(jaccard('ab', 'aabbccddeeff'), 3) +-- +ok +== +SELECT round(jaccard('aabbccddeeffg', 'ab'), 3) +-- +ok +== +SELECT round(jaccard('ab', 'aaaabbbccddeeffgabcccc'), 3) +-- +ok +== +SELECT round(jaccard('ababababababba', 'aaaabbbccddeeffgabcccc'), 3) +-- +ok +== +SELECT jaccard('hello', '') +-- +ok +== +SELECT jaccard('', 'hello') +-- +ok +== +SELECT jaccard('', '') +-- +ok +== +CREATE TABLE strings(s VARCHAR, t VARCHAR) +-- +ok +== +INSERT INTO strings VALUES ('hello', 'hallo'), ('aloha', 'fello'), ('fellow', 'ducks'), (NULL, NULL) +-- +ok +== +select round(jaccard(s, t), 1) from strings +-- +ok +== +select round(jaccard(s, 'hallo'), 1) from strings +-- +ok +== +select round(jaccard('hallo', t), 1) from strings +-- +ok +== +select round(jaccard(NULL, t), 1) from strings +-- +ok +== +select round(jaccard(s, NULL), 1) from strings +-- +ok +== +select round(jaccard('', t), 1) from strings +-- +ok +== +select round(jaccard(s, ''), 1) from strings +-- +ok +== diff --git a/parser/testdata/corpus/sql/function/string/test_jaro_winkler.test b/parser/testdata/corpus/sql/function/string/test_jaro_winkler.test new file mode 100644 index 0000000..2434c0c --- /dev/null +++ b/parser/testdata/corpus/sql/function/string/test_jaro_winkler.test @@ -0,0 +1,161 @@ +# source: test/sql/function/string/test_jaro_winkler.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +select jaro_winkler_similarity('CRATE', 'TRACE') +-- +ok +== +select jaro_winkler_similarity('DwAyNE', 'DuANE') +-- +ok +== +select jaro_winkler_similarity('0', '0') +-- +ok +== +select jaro_winkler_similarity('00', '00') +-- +ok +== +select jaro_winkler_similarity('0', '00') +-- +ok +== +select jaro_winkler_similarity('00000000000000000000000000000000000000000000000000000000000000000', '00000000000000000000000000000000000000000000000000000000000000000') +-- +ok +== +select jaro_winkler_similarity('0000000000000000000000000000000000000000000000000000000000000000', '00000000000000000000000000000000000000000000000000000000000000000') +-- +ok +== +select jaro_winkler_similarity('000000000000000000000000000000000000000000000000000000000000000', '00000000000000000000000000000000000000000000000000000000000000000') +-- +ok +== +select jaro_winkler_similarity('10000000000000000000000000000000000000000000000000000000000000020', '00000000000000000000000000000000000000000000000000000000000000000') +-- +ok +== +select jaro_winkler_similarity('0000000000000000000000000000000000000000000000000000000000000000000000000000001', '00000000000000100000000000000000000000010000000000000000000000000') +-- +ok +== +select jaro_winkler_similarity('01000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000', '00000000000000000000000000000000000000000000000000000000000000000') +-- +ok +== +select jaro_winkler_similarity(null, null) +-- +ok +== +select jaro_winkler_similarity('foo', null) +-- +ok +== +select jaro_winkler_similarity(null, 'foo') +-- +ok +== +select jaro_winkler_similarity('', '') +-- +ok +== +select jaro_winkler_similarity('foo', 'foo') +-- +ok +== +select jaro_winkler_similarity('foo', 'foo ') +-- +ok +== +select jaro_winkler_similarity('foo', 'foo ') +-- +ok +== +select jaro_winkler_similarity('foo', ' foo ') +-- +ok +== +select jaro_winkler_similarity('foo', ' foo') +-- +ok +== +select jaro_winkler_similarity('', 'a') +-- +ok +== +select jaro_winkler_similarity('aaapppp', '') +-- +ok +== +select jaro_winkler_similarity('frog', 'fog') +-- +ok +== +select jaro_winkler_similarity('fly', 'ant') +-- +ok +== +select jaro_winkler_similarity('elephant', 'hippo') +-- +ok +== +select jaro_winkler_similarity('hippo', 'elephant') +-- +ok +== +select jaro_winkler_similarity('hippo', 'zzzzzzzz') +-- +ok +== +select jaro_winkler_similarity('hello', 'hallo') +-- +ok +== +select jaro_winkler_similarity('ABC Corporation', 'ABC Corp') +-- +ok +== +select jaro_winkler_similarity('D N H Enterprises Inc', 'D & H Enterprises, Inc.') +-- +ok +== +select jaro_winkler_similarity('My Gym Children''s Fitness Center', 'My Gym. Childrens Fitness') +-- +ok +== +select jaro_winkler_similarity('PENNSYLVANIA', 'PENNCISYLVNIA') +-- +ok +== +select jaro_winkler_similarity('CRATE', 'TRACE', 0.6) +-- +ok +== +select jaro_winkler_similarity('CRATE', 'TRACE', 0.8) +-- +ok +== +select jaro_winkler_similarity('000000000000000000000000000000000000000000000000000000000000000', '00000000000000000000000000000000000000000000000000000000000000000', 0.9) +-- +ok +== +select jaro_winkler_similarity('000000000000000000000000000000000000000000000000000000000000000', '00000000000000000000000000000000000000000000000000000000000000000', 0.995) +-- +ok +== +create table test as select '0000' || range::varchar s from range(10000); +-- +ok +== +select avg(jaro_winkler_similarity('00000000', s)) from test; +-- +ok +== +select avg(jaro_winkler_similarity(s, '00000000')) from test; +-- +ok +== diff --git a/parser/testdata/corpus/sql/function/string/test_left.test b/parser/testdata/corpus/sql/function/string/test_left.test new file mode 100644 index 0000000..741ed56 --- /dev/null +++ b/parser/testdata/corpus/sql/function/string/test_left.test @@ -0,0 +1,61 @@ +# source: test/sql/function/string/test_left.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +SELECT {FUN}('abcd', 0), {FUN}('abc', 1), {FUN}('abc', 2), {FUN}('abc', 3), {FUN}('abc', 4) +-- +error: Parser Error: syntax error at or near "}" +== +SELECT {FUN}('🦆ab', 0), {FUN}('🦆ab', 1), {FUN}('🦆ab', 2), {FUN}('🦆ab', 3), {FUN}('🦆ab', 4) +-- +error: Parser Error: syntax error at or near "}" +== +SELECT {FUN}('abcd', 0), {FUN}('abc', -1), {FUN}('abc', -2), {FUN}('abc', -3), {FUN}('abc', -4) +-- +error: Parser Error: syntax error at or near "}" +== +SELECT {FUN}('🦆ab', 0), {FUN}('🦆ab', -1), {FUN}('🦆ab', -2), {FUN}('🦆ab', -3), {FUN}('🦆ab', -4) +-- +error: Parser Error: syntax error at or near "}" +== +SELECT {FUN}(NULL, 0), {FUN}('abc', NULL), {FUN}(NULL, NULL) +-- +error: Parser Error: syntax error at or near "}" +== +SELECT {FUN}(NULL, 0), {FUN}('🦆ab', NULL), {FUN}(NULL, NULL) +-- +error: Parser Error: syntax error at or near "}" +== +DROP TABLE IF EXISTS strings +-- +ok +== +CREATE TABLE strings(a STRING, b BIGINT) +-- +ok +== +INSERT INTO STRINGS VALUES ('abcd', 0), ('abc', 1), ('abc', 2), ('abc', 3), ('abc', 4) +-- +ok +== +SELECT {FUN}(a, b) FROM strings +-- +error: Parser Error: syntax error at or near "}" +== +INSERT INTO STRINGS VALUES ('abcd', 0), ('abc', -1), ('abc', -2), ('abc', -3), ('abc', -4) +-- +ok +== +INSERT INTO STRINGS VALUES (NULL, 0), ('abc', NULL), (NULL, NULL) +-- +ok +== +SELECT LEFT_GRAPHEME('🦆🤦S̈', 0), LEFT_GRAPHEME('🦆🤦S̈', 1), LEFT_GRAPHEME('🦆🤦S̈', 2), LEFT_GRAPHEME('🦆🤦S̈', 3) +-- +ok +== +SELECT LEFT_GRAPHEME('🦆🤦S̈', 0), LEFT_GRAPHEME('🦆🤦S̈', -1), LEFT_GRAPHEME('🦆🤦S̈', -2), LEFT_GRAPHEME('🦆🤦S̈', -3) +-- +ok +== diff --git a/parser/testdata/corpus/sql/function/string/test_length.test b/parser/testdata/corpus/sql/function/string/test_length.test new file mode 100644 index 0000000..ee9727e --- /dev/null +++ b/parser/testdata/corpus/sql/function/string/test_length.test @@ -0,0 +1,17 @@ +# source: test/sql/function/string/test_length.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +SELECT length(s) FROM strings ORDER BY s +-- +ok +== +SELECT length(s || ' ' || '🦆') FROM strings ORDER BY s +-- +ok +== +SELECT char_length('asdf'), CHARACTER_LENGTH('asdf') +-- +ok +== diff --git a/parser/testdata/corpus/sql/function/string/test_levenshtein.test b/parser/testdata/corpus/sql/function/string/test_levenshtein.test new file mode 100644 index 0000000..22ea0f7 --- /dev/null +++ b/parser/testdata/corpus/sql/function/string/test_levenshtein.test @@ -0,0 +1,158 @@ +# source: test/sql/function/string/test_levenshtein.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +SELECT levenshtein('hallo', 'hallo') +-- +ok +== +SELECT levenshtein('hallo', 'hello') +-- +ok +== +SELECT levenshtein('hello', 'hallo') +-- +ok +== +SELECT levenshtein('lawn', 'flaw') +-- +ok +== +SELECT levenshtein('flaw', 'lawn') +-- +ok +== +SELECT levenshtein('kitten', 'sitting') +-- +ok +== +SELECT levenshtein('sitting', 'kitten') +-- +ok +== +SELECT levenshtein('hallo', 'hoi') +-- +ok +== +SELECT levenshtein('hoi', 'hallo') +-- +ok +== +SELECT levenshtein(NULL, 'hi') +-- +ok +== +SELECT levenshtein('hi', NULL) +-- +ok +== +SELECT levenshtein(NULL, NULL) +-- +ok +== +SELECT levenshtein('', NULL) +-- +ok +== +SELECT levenshtein(NULL, '') +-- +ok +== +SELECT levenshtein('', 'hi') +-- +ok +== +SELECT levenshtein('hi', '') +-- +ok +== +SELECT levenshtein('', '') +-- +ok +== +INSERT INTO strings VALUES ('hello'), ('hallo'), ('aloha'), ('fello'), ('fellow'), ('ducks') +-- +ok +== +SELECT levenshtein(s, 'hallo') FROM strings ORDER BY s +-- +ok +== +SELECT levenshtein('hallo', s) FROM strings ORDER BY s +-- +ok +== +SELECT levenshtein(NULL, s) FROM strings +-- +ok +== +SELECT levenshtein('', s) FROM strings ORDER BY s +-- +ok +== +SELECT levenshtein(s, '') FROM strings ORDER BY s +-- +ok +== +SELECT levenshtein(s, NULL) from strings +-- +ok +== +SELECT levenshtein(NULL, s) from strings +-- +ok +== +SELECT levenshtein('hi', s) from strings +-- +ok +== +SELECT levenshtein(s, 'hi') from strings +-- +ok +== +SELECT levenshtein('', s) FROM strings +-- +ok +== +SELECT levenshtein(s, '') FROM strings +-- +ok +== +SELECT levenshtein(NULL, s) FROM strings +-- +ok +== +SELECT levenshtein(s, NULL) FROM strings +-- +ok +== +SELECT levenshtein(s, 'hi') FROM strings +-- +ok +== +SELECT levenshtein('hi', s) FROM strings +-- +ok +== +SELECT editdist3('hallo', 'hello') +-- +ok +== +SELECT editdist3(s, 'hello') FROM strings +-- +ok +== +INSERT INTO strings VALUES ('hello', 'hello'), ('hello', 'hallo'), ('flaw', 'lawn'), + ('sitting', 'kitten'), ('hallo', 'aloha'), ('hello', 'aloha'), + (NULL, NULL), ('', ''), + (NULL, 'bora'), ('bora', NULL), + ('hi', ''), ('', 'hi'), + (NULL, ''), ('', NULL) +-- +ok +== +SELECT levenshtein(s, t) ld FROM strings +-- +ok +== diff --git a/parser/testdata/corpus/sql/function/string/test_like.test b/parser/testdata/corpus/sql/function/string/test_like.test new file mode 100644 index 0000000..8e0e726 --- /dev/null +++ b/parser/testdata/corpus/sql/function/string/test_like.test @@ -0,0 +1,225 @@ +# source: test/sql/function/string/test_like.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +SELECT 'aaa' LIKE 'bbb' +-- +ok +== +SELECT 'aaa' LIKE 'abab' +-- +ok +== +SELECT 'aaa' LIKE 'aaa' +-- +ok +== +SELECT 'aaa' LIKE '%' +-- +ok +== +SELECT 'aaa' LIKE '%a' +-- +ok +== +SELECT 'aaa' LIKE '%b' +-- +ok +== +SELECT 'aaa' LIKE 'a%' +-- +ok +== +SELECT 'aaa' LIKE 'b%' +-- +ok +== +SELECT 'aaa' LIKE 'a_a' +-- +ok +== +SELECT 'aaa' LIKE 'a_' +-- +ok +== +SELECT 'aaa' LIKE '__%' +-- +ok +== +SELECT 'aaa' LIKE '____%' +-- +ok +== +SELECT 'ababac' LIKE '%abac' +-- +ok +== +SELECT 'ababac' LIKE '%%%abac' +-- +ok +== +SELECT 'ababac' LIKE 'abab%%%%%' +-- +ok +== +SELECT 'ababac' LIKE '%%%a%%%b%%a%b%%%%%a%c%%' +-- +ok +== +SELECT 'ababac' LIKE '%%%a%%%b%%a%b%%%%%a%d%%' +-- +ok +== +SELECT 'ababac' NOT LIKE '%abac' +-- +ok +== +SELECT 'aabbccc' LIKE '%aa%bb%cc' +-- +ok +== +SELECT 'zebra elephant tiger horse' LIKE '' +-- +ok +== +SELECT 'zebra elephant tiger horse' LIKE '%' +-- +ok +== +SELECT 'zebra elephant tiger horse' LIKE 'zebra' +-- +ok +== +SELECT 'zebra elephant tiger horse' LIKE 'zebra elephant tiger horse' +-- +ok +== +SELECT 'zebra elephant tiger horse' LIKE 'zebra elephant tiger horse%' +-- +ok +== +SELECT 'zebra elephant tiger horse' LIKE '%zebra elephant tiger horse%' +-- +ok +== +SELECT 'zebra elephant tiger horse' LIKE '%zebra elephant tiger horse blabla' +-- +ok +== +SELECT 'zebra elephant tiger horse' LIKE 'zebra elephant tiger horse blabla%' +-- +ok +== +SELECT 'zebra elephant tiger horse' LIKE 'zebra%' +-- +ok +== +SELECT 'zebra elephant tiger horse' LIKE '%horse' +-- +ok +== +SELECT 'zebra elephant tiger horse' LIKE 'zebra%elephant%horse' +-- +ok +== +SELECT 'zebra elephant tiger horse' LIKE 'zebra%elephant%tiger%horse' +-- +ok +== +SELECT 'zebra elephant tiger horse' LIKE '%zebra%elephant%tiger%horse' +-- +ok +== +SELECT 'zebra elephant tiger horse' LIKE 'zebra%elephant%tiger%horse%' +-- +ok +== +SELECT 'zebra elephant tiger horse' LIKE '%zebra%elephant%tiger%horse%' +-- +ok +== +SELECT 'zebra elephant tiger horse' LIKE '%%zebra %%%ele%phan%t t%ig%er% horse%' +-- +ok +== +SELECT 'zebra elephant tiger horse' LIKE 'zebra%tiger%horse' +-- +ok +== +SELECT 'zebra elephant tiger horse' LIKE 'zebra%tiger%elephant%horse' +-- +ok +== +SELECT 'zebra elephant tiger horse' NOT LIKE '' +-- +ok +== +SELECT 'zebra elephant tiger horse' NOT LIKE '%' +-- +ok +== +SELECT 'zebra elephant tiger horse' NOT LIKE 'zebra' +-- +ok +== +SELECT 'zebra elephant tiger horse' NOT LIKE 'zebra elephant tiger horse' +-- +ok +== +SELECT 'zebra elephant tiger horse' NOT LIKE 'zebra%' +-- +ok +== +SELECT 'zebra elephant tiger horse' NOT LIKE '%horse' +-- +ok +== +SELECT 'zebra elephant tiger horse' NOT LIKE 'zebra%elephant%horse' +-- +ok +== +SELECT 'zebra elephant tiger horse' NOT LIKE 'zebra%elephant%tiger%horse' +-- +ok +== +SELECT 'zebra elephant tiger horse' NOT LIKE '%zebra%elephant%tiger%horse' +-- +ok +== +SELECT 'zebra elephant tiger horse' NOT LIKE 'zebra%elephant%tiger%horse%' +-- +ok +== +SELECT 'zebra elephant tiger horse' NOT LIKE '%zebra%elephant%tiger%horse%' +-- +ok +== +SELECT 'zebra elephant tiger horse' NOT LIKE '%%zebra %%%ele%phan%t t%ig%er% horse%' +-- +ok +== +SELECT 'zebra elephant tiger horse' NOT LIKE 'zebra%tiger%horse' +-- +ok +== +SELECT 'zebra elephant tiger horse' NOT LIKE 'zebra%tiger%elephant%horse' +-- +ok +== +INSERT INTO strings VALUES ('abab', 'ab%'), ('aaa', 'a_a'), ('aaa', '%b%') +-- +ok +== +SELECT s FROM strings WHERE 'aba' LIKE pat +-- +ok +== +SELECT s FROM strings WHERE s LIKE pat +-- +ok +== +SELECT 'hello' LIKE 'hê?llo' COLLATE idontexist; +-- +ok +== diff --git a/parser/testdata/corpus/sql/function/string/test_like_escape.test b/parser/testdata/corpus/sql/function/string/test_like_escape.test new file mode 100644 index 0000000..b1b0cbd --- /dev/null +++ b/parser/testdata/corpus/sql/function/string/test_like_escape.test @@ -0,0 +1,91 @@ +# source: test/sql/function/string/test_like_escape.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +SELECT '%++' LIKE '*%++' ESCAPE '*'; +-- +ok +== +SELECT '%++' NOT LIKE '*%++' ESCAPE '*'; +-- +ok +== +SELECT '%' LIKE '%' ESCAPE '%'; +-- +ok +== +SELECT '%' LIKE '*' ESCAPE '*'; +-- +ok +== +SELECT '\' LIKE '\\' ESCAPE '\'; +-- +ok +== +SELECT '\\' LIKE '\\' ESCAPE '\'; +-- +ok +== +SELECT '%' LIKE '*%' ESCAPE '*'; +-- +ok +== +SELECT '_ ' LIKE '*_ ' ESCAPE '*'; +-- +ok +== +SELECT ' a ' LIKE '*_ ' ESCAPE '*'; +-- +ok +== +SELECT '%_' LIKE '%_' ESCAPE ''; +-- +ok +== +SELECT '*%' NOT LIKE '*%' ESCAPE '*'; +-- +ok +== +SELECT '%_' LIKE '%_' ESCAPE '\\'; +-- +ok +== +SELECT '%_' LIKE '%_' ESCAPE '**'; +-- +ok +== +INSERT INTO strings VALUES ('abab', 'ab%'), ('aaa', 'a*_a'), ('aaa', '*%b'), ('bbb', 'a%'); +-- +ok +== +SELECT s FROM strings; +-- +ok +== +SELECT pat FROM strings; +-- +ok +== +SELECT s FROM strings WHERE pat LIKE 'a*%' ESCAPE '*'; +-- +ok +== +SELECT s FROM strings WHERE 'aba' LIKE pat ESCAPE '*'; +-- +ok +== +SELECT s FROM strings WHERE s LIKE pat ESCAPE '*'; +-- +ok +== +select 'a' like 'a' escape NULL; +-- +ok +== +SELECT '%' LIKE (chr(0) || '%') ESCAPE chr(0), + '%' LIKE (chr(0) || '%') ESCAPE '', + (chr(0) || 'abc') LIKE (chr(0) || '%') ESCAPE '' +-- +ok +== diff --git a/parser/testdata/corpus/sql/function/string/test_mismatches.test b/parser/testdata/corpus/sql/function/string/test_mismatches.test new file mode 100644 index 0000000..e17b564 --- /dev/null +++ b/parser/testdata/corpus/sql/function/string/test_mismatches.test @@ -0,0 +1,125 @@ +# source: test/sql/function/string/test_mismatches.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +SELECT mismatches('hallo', 'hallo') +-- +ok +== +SELECT mismatches('hello', 'hallo') +-- +ok +== +SELECT mismatches('hallo', 'hello') +-- +ok +== +SELECT mismatches('aloha', 'hallo') +-- +ok +== +SELECT mismatches('hallo', 'aloha') +-- +ok +== +SELECT mismatches(NULL, 'hallo') +-- +ok +== +SELECT mismatches('hello', NULL) +-- +ok +== +SELECT mismatches(NULL, NULL) +-- +ok +== +INSERT INTO strings VALUES ('hello'), ('hallo'), ('aloha'), ('world'), (NULL) +-- +ok +== +SELECT mismatches(s, 'hallo') FROM strings ORDER BY s +-- +ok +== +SELECT mismatches('hallo', s) FROM strings ORDER BY s +-- +ok +== +SELECT mismatches('', '') +-- +ok +== +SELECT mismatches(NULL, s) FROM strings ORDER BY s +-- +ok +== +SELECT mismatches(s, NULL) FROM strings ORDER BY s +-- +ok +== +SELECT mismatches('hoi', 'hallo') +-- +ok +== +SELECT mismatches('hallo', 'hoi') +-- +ok +== +SELECT mismatches('', 'hallo') +-- +ok +== +SELECT mismatches('hi', '') +-- +ok +== +SELECT mismatches('', s) FROM strings ORDER BY s +-- +ok +== +SELECT mismatches(s, '') FROM strings ORDER BY s +-- +ok +== +INSERT INTO strings VALUES ('hello'), ('halo'), (NULL) +-- +ok +== +SELECT mismatches(s, 'hallo') FROM strings +-- +ok +== +SELECT mismatches('hallo', s) FROM strings +-- +ok +== +SELECT hamming('hallo', 'hallo') +-- +ok +== +SELECT hamming('hello', 'hallo') +-- +ok +== +SELECT hamming(s, 'hallo') FROM strings WHERE s = 'hello' +-- +ok +== +DROP TABLE strings; +-- +ok +== +INSERT INTO strings VALUES ('hello', 'world'), ('hallo', 'ola'), ('hello', ''), (NULL, NULL), ('', ''), ('bora', 'bora') +-- +ok +== +SELECT s, t, hamming(s, t) hd FROM strings WHERE length(s) = length(t) +-- +ok +== +SELECT hamming(s, t) FROM strings +-- +ok +== diff --git a/parser/testdata/corpus/sql/function/string/test_pad.test b/parser/testdata/corpus/sql/function/string/test_pad.test new file mode 100644 index 0000000..308512c --- /dev/null +++ b/parser/testdata/corpus/sql/function/string/test_pad.test @@ -0,0 +1,85 @@ +# source: test/sql/function/string/test_pad.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +select LPAD(NULL, 7, '-'), LPAD('Base', NULL, '-'), LPAD('Base', 7, NULL), LPAD(NULL, NULL, '-'), LPAD(NULL, 7, NULL), LPAD('Base', NULL, NULL), LPAD(NULL, NULL, NULL) +-- +ok +== +select RPAD(NULL, 7, '-'), RPAD('Base', NULL, '-'), RPAD('Base', 7, NULL), RPAD(NULL, NULL, '-'), RPAD(NULL, 7, NULL), RPAD('Base', NULL, NULL), RPAD(NULL, NULL, NULL) +-- +ok +== +select LPAD('Base', 7, '-'), LPAD('Base', 4, '-'), LPAD('Base', 2, ''), LPAD('Base', -1, '-') +-- +ok +== +select RPAD('Base', 7, '-'), RPAD('Base', 4, '-'), RPAD('Base', 2, ''), RPAD('Base', -1, '-') +-- +ok +== +select LPAD('Base', 7, '-|'), LPAD('Base', 6, '-|'), LPAD('Base', 5, '-|'), LPAD('Base', 4, '-|') +-- +ok +== +select RPAD('Base', 7, '-|'), RPAD('Base', 6, '-|'), RPAD('Base', 5, '-|'), RPAD('Base', 4, '-|') +-- +ok +== +select LPAD('MotörHead', 16, 'RÄcks'), LPAD('MotörHead', 12, 'RÄcks'), LPAD('MotörHead', 10, 'RÄcks') +-- +ok +== +select RPAD('MotörHead', 16, 'RÄcks'), RPAD('MotörHead', 12, 'RÄcks'), RPAD('MotörHead', 10, 'RÄcks') +-- +ok +== +select LPAD(a, 16, b), RPAD(a, 16, b) FROM strings +-- +ok +== +select LPAD(a, 12, b), RPAD(a, 12, b), UCASE(a), LCASE(a) FROM strings WHERE b IS NOT NULL +-- +ok +== +select LPAD() +-- +ok +== +select LPAD(1) +-- +ok +== +select LPAD(1, 2) +-- +ok +== +select LPAD('Hello', 10, '') +-- +ok +== +select LPAD('a', 100000000000000000, 0) +-- +ok +== +select RPAD() +-- +ok +== +select RPAD(1) +-- +ok +== +select RPAD(1, 2) +-- +ok +== +select RPAD('Hello', 10, '') +-- +ok +== +select RPAD('a', 100000000000000000, 0) +-- +ok +== diff --git a/parser/testdata/corpus/sql/function/string/test_prefix.test b/parser/testdata/corpus/sql/function/string/test_prefix.test new file mode 100644 index 0000000..bf4a5de --- /dev/null +++ b/parser/testdata/corpus/sql/function/string/test_prefix.test @@ -0,0 +1,169 @@ +# source: test/sql/function/string/test_prefix.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +SELECT prefix('abcd', 'a') +-- +ok +== +SELECT prefix('abcd', 'ab') +-- +ok +== +SELECT prefix('abcd', 'abc') +-- +ok +== +SELECT prefix('abcd', 'abcd') +-- +ok +== +SELECT prefix('abcd', 'b') +-- +ok +== +SELECT prefix('abcdefgh', 'a') +-- +ok +== +SELECT prefix('abcdefgh', 'ab') +-- +ok +== +SELECT prefix('abcdefgh', 'abc') +-- +ok +== +SELECT prefix('abcdefgh', 'abcd') +-- +ok +== +SELECT prefix('abcdefgh', 'abcde') +-- +ok +== +SELECT prefix('abcdefgh', 'b') +-- +ok +== +SELECT prefix('abcdefghijklmnopqrstuvwxyz', 'a') +-- +ok +== +SELECT prefix('abcdefghijklmnopqrstuvwxyz', 'ab') +-- +ok +== +SELECT prefix('abcdefghijklmnopqrstuvwxyz', 'abc') +-- +ok +== +SELECT prefix('abcdefghijklmnopqrstuvwxyz', 'abcd') +-- +ok +== +SELECT prefix('abcdefghijklmnopqrstuvwxyz', 'abcde') +-- +ok +== +SELECT prefix('abcdefghijklmnopqrstuvwxyz', 'b') +-- +ok +== +SELECT prefix('abcdefghijklmnopqrstuvwxyz', 'abcdefghijklmnopqrstuvwx') +-- +ok +== +SELECT prefix('abcdefghijklmnopqrstuvwxyz', 'abcfefghijklmnopqrstuvwx') +-- +ok +== +SELECT prefix('', 'aaa') +-- +ok +== +SELECT prefix('aaa', '') +-- +ok +== +CREATE TABLE t0(c0 VARCHAR) +-- +ok +== +SELECT * FROM t0 WHERE PREFIX(t0.c0, '') +-- +ok +== +SELECT prefix('átomo', 'á') +-- +ok +== +SELECT prefix('átomo', 'a') +-- +ok +== +SELECT prefix('olá mundo', 'olá') +-- +ok +== +SELECT prefix('olá mundo', 'ola') +-- +ok +== +SELECT prefix('ñeft', 'ñ') +-- +ok +== +SELECT prefix('ñeft', 'ñeft') +-- +ok +== +SELECT prefix('ñeft', 'neft') +-- +ok +== +SELECT prefix('two ñ three ₡ four 🦆 end', 'two ñ') +-- +ok +== +SELECT prefix('two ñ three ₡ four 🦆 end', 'two n') +-- +ok +== +SELECT prefix('two ñ three ₡ four 🦆 end', 'two ñ three') +-- +ok +== +SELECT prefix('two ñ three ₡ four 🦆 end', 'two ñ three ₡') +-- +ok +== +SELECT prefix('two ñ three ₡ four 🦆 end', 'two ñ three ₡ four 🦆') +-- +ok +== +SELECT prefix('two ñ three ₡ four 🦆 end', 'two ñ three ₡ four 🦆 end') +-- +ok +== +INSERT INTO t0 VALUES ('a'), ('b'), ('d') +-- +ok +== +SELECT COUNT(*) FROM t0 WHERE prefix(t0.c0, ''); +-- +ok +== +SELECT c0, prefix(t0.c0, '') FROM t0 WHERE c0 <> 'b' ORDER BY t0.c0; +-- +ok +== +INSERT INTO t0 VALUES (NULL) +-- +ok +== +SELECT c0, prefix(t0.c0, '') FROM t0 WHERE c0 IS NULL OR c0 <> 'b' ORDER BY t0.c0; +-- +ok +== diff --git a/parser/testdata/corpus/sql/function/string/test_printf.test b/parser/testdata/corpus/sql/function/string/test_printf.test new file mode 100644 index 0000000..fe71339 --- /dev/null +++ b/parser/testdata/corpus/sql/function/string/test_printf.test @@ -0,0 +1,181 @@ +# source: test/sql/function/string/test_printf.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +SELECT printf('hello'), printf(NULL) +-- +ok +== +SELECT printf('%s', 'hello'), printf('%s: %s', 'hello', 'world') +-- +ok +== +SELECT printf('%s', NULL), printf(NULL, 'hello', 'world') +-- +ok +== +SELECT printf('%d', TRUE) +-- +ok +== +SELECT printf('%d', 33), printf('%d + %d = %d', 3, 5, 3 + 5) +-- +ok +== +SELECT printf('%d', 18446744073709551615::UBIGINT); +-- +ok +== +SELECT printf('%04d', 33), printf('%s %02d:%02d:%02d %s', 'time', 12, 3, 16, 'AM'), printf('%10d', 1992) +-- +ok +== +SELECT printf('%hhd %hd %d %lld', 33::TINYINT, 12::SMALLINT, 40::INTEGER, 80::BIGINT) +-- +ok +== +SELECT printf('%d %lld %hhd %hd', 33::TINYINT, 12::SMALLINT, 40::INTEGER, 80::BIGINT) +-- +ok +== +SELECT printf('%s %s = %s', DATE '1992-01-01', TIME '12:01:00', TIMESTAMP '1992-01-01 12:01:00') +-- +ok +== +SELECT printf('%s', BLOB '\x01\xa0') +-- +ok +== +SELECT printf('%d', 120381902481294715712::HUGEINT) +-- +ok +== +SELECT printf('%d', '-170141183460469231731687303715884105728'::HUGEINT) +-- +ok +== +SELECT printf('%d', '170141183460469231731687303715884105727'::HUGEINT) +-- +ok +== +SELECT printf('%d', 120381902481294715712::UHUGEINT) +-- +ok +== +SELECT printf('%d', '340282366920938463463374607431768211455'::UHUGEINT) +-- +ok +== +select printf('%x', 255::utinyint); +-- +ok +== +select printf('%x', 65535::usmallint); +-- +ok +== +select printf('%x', 4294967295::uinteger); +-- +ok +== +select printf('%x', 18446744073709551615::ubigint); +-- +ok +== +select printf('%x', '340282366920938463463374607431768211455'::uhugeint); +-- +ok +== +SELECT printf('%.3f', '1.234'::DECIMAL) +-- +ok +== +SELECT printf('%d %x %o %#x %#o', 100, 100, 100, 100, 100) +-- +ok +== +select printf('%b', '-170141183460469231731687303715884105728'::HUGEINT); +-- +ok +== +SELECT printf('%c', 65) +-- +ok +== +SELECT printf('%*d', 5, 10) +-- +ok +== +SELECT printf('%.2f', 10.0::FLOAT), printf('%.4f', 0.5) +-- +ok +== +SELECT printf('floats: %4.2f %+.0e %E', 3.1416, 3.1416, 3.1416) +-- +ok +== +SELECT printf('%s') +-- +ok +== +SELECT printf('%s %s', 'hello') +-- +ok +== +SELECT printf('%s', 'hello', 'world') +-- +ok +== +SELECT printf('%s', 42) +-- +ok +== +SELECT printf('%d', 'hello') +-- +ok +== +CREATE TABLE strings(idx INTEGER, fmt STRING, pint INTEGER, pstring STRING) +-- +ok +== +INSERT INTO strings VALUES (1, '%d: %s', 10, 'hello') +-- +ok +== +INSERT INTO strings VALUES (2, 'blabla %d blabla %s', 20, 'blabla') +-- +ok +== +INSERT INTO strings VALUES (3, NULL, 30, 'abcde') +-- +ok +== +SELECT printf(fmt) FROM strings ORDER BY idx +-- +ok +== +SELECT printf(CASE WHEN pint < 15 THEN NULL ELSE pint::VARCHAR END) FROM strings ORDER BY idx +-- +ok +== +SELECT printf(fmt, pint, pstring) FROM strings ORDER BY idx +-- +ok +== +SELECT printf(fmt, 10, pstring) FROM strings ORDER BY idx +-- +ok +== +SELECT printf('%s: %s', pstring, pstring) FROM strings ORDER BY idx +-- +ok +== +SELECT printf('%s: %s', pstring, pstring) FROM strings WHERE idx <> 2 ORDER BY idx +-- +ok +== +SELECT printf('%d %d %d %d', 100::tinyint, 1000::smallint, 1000::int, 1000::bigint); +-- +ok +== diff --git a/parser/testdata/corpus/sql/function/string/test_repeat.test b/parser/testdata/corpus/sql/function/string/test_repeat.test new file mode 100644 index 0000000..327cce1 --- /dev/null +++ b/parser/testdata/corpus/sql/function/string/test_repeat.test @@ -0,0 +1,61 @@ +# source: test/sql/function/string/test_repeat.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +select REPEAT(NULL, NULL), REPEAT(NULL, 3), REPEAT('MySQL', NULL) +-- +ok +== +select REPEAT('', 3), REPEAT('MySQL', 3), REPEAT('MotörHead', 2), REPEAT('Hello', -1) +-- +ok +== +INSERT INTO strings VALUES ('Hello', 'World'), ('HuLlD', NULL), ('MotörHead','RÄcks'), ('', NULL) +-- +ok +== +select REPEAT(a, 3) FROM strings +-- +ok +== +select REPEAT(b, 2) FROM strings +-- +ok +== +select REPEAT(a, 4) FROM strings WHERE b IS NOT NULL +-- +ok +== +SELECT repeat('', 99); +-- +ok +== +SELECT repeat('hello world', 0); +-- +ok +== +SELECT repeat('hello world', -1); +-- +ok +== +SELECT repeat(blob '00', 2); +-- +ok +== +select REPEAT() +-- +ok +== +select REPEAT(1) +-- +ok +== +select REPEAT('hello', 'world') +-- +ok +== +select REPEAT('hello', 'world', 3) +-- +ok +== diff --git a/parser/testdata/corpus/sql/function/string/test_replace.test b/parser/testdata/corpus/sql/function/string/test_replace.test new file mode 100644 index 0000000..b1a0486 --- /dev/null +++ b/parser/testdata/corpus/sql/function/string/test_replace.test @@ -0,0 +1,53 @@ +# source: test/sql/function/string/test_replace.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +select REPLACE('This is the main test string', NULL, 'ALT') +-- +ok +== +select REPLACE(NULL, 'main', 'ALT') +-- +ok +== +select REPLACE('This is the main test string', 'main', NULL) +-- +ok +== +select REPLACE('This is the main test string', 'main', 'ALT') +-- +ok +== +select REPLACE('This is the main test string', 'main', 'larger-main') +-- +ok +== +select REPLACE('aaaaaaa', 'a', '0123456789') +-- +ok +== +select REPLACE(a, 'l', '-') FROM strings +-- +ok +== +select REPLACE(b, 'Ä', '--') FROM strings +-- +ok +== +select REPLACE(a, 'H', '') FROM strings WHERE b IS NOT NULL +-- +ok +== +select REPLACE(1) +-- +ok +== +select REPLACE(1, 2) +-- +ok +== +select REPLACE(1, 2, 3, 4) +-- +ok +== diff --git a/parser/testdata/corpus/sql/function/string/test_reverse.test b/parser/testdata/corpus/sql/function/string/test_reverse.test new file mode 100644 index 0000000..6fc0d4a --- /dev/null +++ b/parser/testdata/corpus/sql/function/string/test_reverse.test @@ -0,0 +1,33 @@ +# source: test/sql/function/string/test_reverse.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +select REVERSE(''), REVERSE('Hello'), REVERSE('MotörHead'), REVERSE(NULL) +-- +ok +== +select REVERSE(a) FROM strings +-- +ok +== +select REVERSE(b) FROM strings +-- +ok +== +select REVERSE(a) FROM strings WHERE b IS NOT NULL +-- +ok +== +select REVERSE() +-- +ok +== +select REVERSE(1, 2) +-- +ok +== +select REVERSE('hello', 'world') +-- +ok +== diff --git a/parser/testdata/corpus/sql/function/string/test_right.test b/parser/testdata/corpus/sql/function/string/test_right.test new file mode 100644 index 0000000..e09126c --- /dev/null +++ b/parser/testdata/corpus/sql/function/string/test_right.test @@ -0,0 +1,25 @@ +# source: test/sql/function/string/test_right.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +SELECT RIGHT_GRAPHEME('🦆🤦S̈', 0), RIGHT_GRAPHEME('🦆🤦S̈', 1), RIGHT_GRAPHEME('🦆🤦S̈', 2), RIGHT_GRAPHEME('🦆🤦S̈', 3) +-- +ok +== +SELECT RIGHT_GRAPHEME('🦆🤦S̈', 0), RIGHT_GRAPHEME('🦆🤦S̈', -1), RIGHT_GRAPHEME('🦆🤦S̈', -2), RIGHT_GRAPHEME('🦆🤦S̈', -3) +-- +ok +== +SELECT right_grapheme('a', -9223372036854775808); +-- +ok +== +SELECT "right"('a', -9223372036854775808); +-- +ok +== +SELECT right_grapheme('a', 9223372036854775808); +-- +ok +== diff --git a/parser/testdata/corpus/sql/function/string/test_similar_to.test b/parser/testdata/corpus/sql/function/string/test_similar_to.test new file mode 100644 index 0000000..5f8c197 --- /dev/null +++ b/parser/testdata/corpus/sql/function/string/test_similar_to.test @@ -0,0 +1,113 @@ +# source: test/sql/function/string/test_similar_to.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +SELECT 'aaa' SIMILAR TO 'bbb' +-- +ok +== +SELECT 'aaa' SIMILAR TO 'aaa' +-- +ok +== +SELECT 'aaa' SIMILAR TO '.*' +-- +ok +== +SELECT 'aaa' SIMILAR TO 'a.*' +-- +ok +== +SELECT 'aaa' SIMILAR TO '.*a' +-- +ok +== +SELECT 'aaa' SIMILAR TO '.*b' +-- +ok +== +SELECT 'aaa' SIMILAR TO 'b.*' +-- +ok +== +SELECT 'aaa' SIMILAR TO 'a[a-z]a' +-- +ok +== +SELECT 'aaa' SIMILAR TO 'a[a-z]{2}' +-- +ok +== +SELECT 'aaa' SIMILAR TO 'a[a-z].*' +-- +ok +== +SELECT 'aaa' SIMILAR TO '[a-z][a-z].*' +-- +ok +== +SELECT 'aaa' SIMILAR TO '[a-z]{3}' +-- +ok +== +SELECT 'aaa' NOT SIMILAR TO '[b-z]{3}' +-- +ok +== +SELECT 'aaa' ~ 'aaa' +-- +ok +== +SELECT 'aaa' !~ 'bbb' +-- +ok +== +SELECT 'aaa' SIMILAR TO '^a' +-- +ok +== +SELECT 'aaa' ~ '^a' +-- +ok +== +SELECT 'aaa' ~ '^a+' +-- +ok +== +SELECT 'aaa' ~ '(a|b)*' +-- +ok +== +SELECT 'abc' ~ '^(b|c)' +-- +ok +== +CREATE TABLE strings (s STRING, p STRING); +-- +ok +== +INSERT INTO strings VALUES('aaa', 'a[a-z]a'), ('abab', 'ab.*'), ('aaa', 'a[a-z]a'), ('aaa', '.*b.*'); +-- +ok +== +SELECT s FROM strings WHERE s SIMILAR TO 'ab.*' +-- +ok +== +SELECT s FROM strings WHERE 'aba' SIMILAR TO p +-- +ok +== +SELECT s FROM strings WHERE s SIMILAR TO p +-- +ok +== +SELECT s FROM strings WHERE s NOT SIMILAR TO p +-- +ok +== +SELECT s FROM strings WHERE s SIMILAR TO 'ab.*%' {escape ''} +-- +error: Parser Error: syntax error at or near "{" +== diff --git a/parser/testdata/corpus/sql/function/string/test_split_part.test b/parser/testdata/corpus/sql/function/string/test_split_part.test new file mode 100644 index 0000000..2232e4e --- /dev/null +++ b/parser/testdata/corpus/sql/function/string/test_split_part.test @@ -0,0 +1,81 @@ +# source: test/sql/function/string/test_split_part.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +select split_part('a,b,c',',',1) +-- +ok +== +select split_part('a,b,c',',',2) +-- +ok +== +select split_part('a,,b,,c',',,',2) +-- +ok +== +SELECT split_part('a,b,c','|',1) +-- +ok +== +select split_part('a,b,c',',',-1) +-- +ok +== +select split_part('a,b,c',',',-2) +-- +ok +== +select split_part('a,b,c',',',0) +-- +ok +== +select split_part('a,b,c',',',5) +-- +ok +== +select split_part('a,b,c',',',-5) +-- +ok +== +select split_part('','',1) +-- +ok +== +select split_part('a,b,c','',3) +-- +ok +== +select split_part('',',',1) +-- +ok +== +select split_part(NULL,NULL,1) +-- +ok +== +select split_part('a,b,c',NULL,1) +-- +ok +== +select split_part(NULL,',',1) +-- +ok +== +select split_part('a,b,c', ',', NULL) +-- +ok +== +select split_part() +-- +ok +== +select split_part('a') +-- +ok +== +select split_part('a','a') +-- +ok +== diff --git a/parser/testdata/corpus/sql/function/string/test_starts_with_function.test b/parser/testdata/corpus/sql/function/string/test_starts_with_function.test new file mode 100644 index 0000000..5a0b60e --- /dev/null +++ b/parser/testdata/corpus/sql/function/string/test_starts_with_function.test @@ -0,0 +1,67 @@ +# source: test/sql/function/string/test_starts_with_function.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +SELECT STARTS_WITH('hello world', 'h'), + STARTS_WITH('hello world', 'he'), + STARTS_WITH('hello world', 'hel'), + STARTS_WITH('hello world', 'hell'), + STARTS_WITH('hello world', 'hello'), + STARTS_WITH('hello world', 'hello '), + STARTS_WITH('hello world', 'hello w'), + STARTS_WITH('hello world', 'hello wo'), + STARTS_WITH('hello world', 'hello wor'), + STARTS_WITH('hello world', 'hello worl') +-- +ok +== +SELECT STARTS_WITH('hello world', 'a'), + STARTS_WITH('hello world', 'ha'), + STARTS_WITH('hello world', 'hea'), + STARTS_WITH('hello world', 'hela'), + STARTS_WITH('hello world', 'hella'), + STARTS_WITH('hello world', 'helloa'), + STARTS_WITH('hello world', 'hello a'), + STARTS_WITH('hello world', 'hello wa'), + STARTS_WITH('hello world', 'hello woa'), + STARTS_WITH('hello world', 'hello wora') +-- +ok +== +select starts_with('hello', ''), starts_with('', ''), starts_with(NULL, '') +-- +ok +== +INSERT INTO strings VALUES ('hello', 1, 2), ('world', 2, 3), ('h', 1, 1), (NULL, 2, 2) +-- +ok +== +SELECT starts_with(s,'h') FROM strings +-- +ok +== +SELECT starts_with(s,'he') FROM strings +-- +ok +== +SELECT starts_with(s,'he-man') FROM strings +-- +ok +== +SELECT starts_with(NULL,'h') FROM strings +-- +ok +== +SELECT starts_with(s,NULL) FROM strings +-- +ok +== +SELECT starts_with(NULL,NULL) FROM strings +-- +ok +== +SELECT starts_with(s,'') FROM strings +-- +ok +== diff --git a/parser/testdata/corpus/sql/function/string/test_starts_with_function_utf8.test b/parser/testdata/corpus/sql/function/string/test_starts_with_function_utf8.test new file mode 100644 index 0000000..601c42a --- /dev/null +++ b/parser/testdata/corpus/sql/function/string/test_starts_with_function_utf8.test @@ -0,0 +1,29 @@ +# source: test/sql/function/string/test_starts_with_function_utf8.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +SELECT starts_with(s,'á') FROM strings +-- +ok +== +SELECT starts_with(s,'olá mundo') FROM strings +-- +ok +== +SELECT starts_with(s,'你好世界') FROM strings +-- +ok +== +SELECT starts_with(s,'two ñ thr') FROM strings +-- +ok +== +SELECT starts_with(s,'ñ') FROM strings +-- +ok +== +SELECT starts_with(s,'₡ four 🦆 e') FROM strings +-- +ok +== diff --git a/parser/testdata/corpus/sql/function/string/test_starts_with_operator.test b/parser/testdata/corpus/sql/function/string/test_starts_with_operator.test new file mode 100644 index 0000000..0268ff0 --- /dev/null +++ b/parser/testdata/corpus/sql/function/string/test_starts_with_operator.test @@ -0,0 +1,63 @@ +# source: test/sql/function/string/test_starts_with_operator.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +SELECT 'hello world' ^@ 'h', + 'hello world' ^@ 'he', + 'hello world' ^@ 'hel', + 'hello world' ^@ 'hell', + 'hello world' ^@ 'hello', + 'hello world' ^@ 'hello ', + 'hello world' ^@ 'hello w', + 'hello world' ^@ 'hello wo', + 'hello world' ^@ 'hello wor', + 'hello world' ^@ 'hello worl' +-- +ok +== +SELECT 'hello world' ^@ 'a', + 'hello world' ^@ 'ha', + 'hello world' ^@ 'hea', + 'hello world' ^@ 'hela', + 'hello world' ^@ 'hella', + 'hello world' ^@ 'helloa', + 'hello world' ^@ 'hello a', + 'hello world' ^@ 'hello wa', + 'hello world' ^@ 'hello woa', + 'hello world' ^@ 'hello wora' +-- +ok +== +select 'hello' ^@ '', '' ^@ '', NULL ^@ '' +-- +ok +== +SELECT s ^@ 'h' FROM strings +-- +ok +== +SELECT s ^@ 'he' FROM strings +-- +ok +== +SELECT s ^@ 'he-man' FROM strings +-- +ok +== +SELECT NULL ^@ 'h' FROM strings +-- +ok +== +SELECT s ^@ NULL FROM strings +-- +ok +== +SELECT NULL ^@ NULL FROM strings +-- +ok +== +SELECT s ^@ '' FROM strings +-- +ok +== diff --git a/parser/testdata/corpus/sql/function/string/test_starts_with_operator_utf8.test b/parser/testdata/corpus/sql/function/string/test_starts_with_operator_utf8.test new file mode 100644 index 0000000..fae8ca0 --- /dev/null +++ b/parser/testdata/corpus/sql/function/string/test_starts_with_operator_utf8.test @@ -0,0 +1,29 @@ +# source: test/sql/function/string/test_starts_with_operator_utf8.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +SELECT s ^@ 'á' FROM strings +-- +ok +== +SELECT s ^@ 'olá mundo' FROM strings +-- +ok +== +SELECT s ^@ '你好世界' FROM strings +-- +ok +== +SELECT s ^@ 'two ñ thr' FROM strings +-- +ok +== +SELECT s ^@ 'ñ' FROM strings +-- +ok +== +SELECT s ^@ '₡ four 🦆 e' FROM strings +-- +ok +== diff --git a/parser/testdata/corpus/sql/function/string/test_string_array_slice.test b/parser/testdata/corpus/sql/function/string/test_string_array_slice.test new file mode 100644 index 0000000..8ca299f --- /dev/null +++ b/parser/testdata/corpus/sql/function/string/test_string_array_slice.test @@ -0,0 +1,133 @@ +# source: test/sql/function/string/test_string_array_slice.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +SELECT 'hello'[0:2] +-- +ok +== +SELECT ('hello')[0:2] +-- +ok +== +INSERT INTO strings VALUES ('hello', 0, 2), ('world', 1, 3), ('b', 0, 1), (NULL, 1, 2) +-- +ok +== +SELECT array_slice('🦆ab', 0, 0), array_slice('abc', 0, 0) +-- +ok +== +SELECT array_slice(s, 0, 2) FROM strings +-- +ok +== +SELECT list_slice(s, 0, 2) FROM strings +-- +ok +== +SELECT array_slice(s, 1, 3) FROM strings +-- +ok +== +SELECT array_slice(s, 2, 3) FROM strings +-- +ok +== +SELECT array_slice(s, off, length+off) FROM strings +-- +ok +== +SELECT array_slice(s, off, 2+off) FROM strings +-- +ok +== +SELECT array_slice(s, 0, length) FROM strings +-- +ok +== +SELECT array_slice('hello', off, length+off) FROM strings +-- +ok +== +SELECT array_slice(NULL::varchar, off, length+off) FROM strings +-- +ok +== +SELECT array_slice('hello', NULL, length+NULL) FROM strings +-- +ok +== +SELECT array_slice('hello', off+1, NULL+off) FROM strings +-- +ok +== +SELECT array_slice(NULL::varchar, NULL, length+NULL) FROM strings +-- +ok +== +SELECT array_slice('hello', NULL, NULL+NULL) FROM strings +-- +ok +== +SELECT array_slice(NULL::varchar, off, NULL+off) FROM strings +-- +ok +== +SELECT array_slice(NULL::varchar, NULL, NULL+NULL) FROM strings +-- +ok +== +SELECT array_slice(s, -2, NULL) FROM strings +-- +ok +== +SELECT array_slice(s, 0, 1) FROM strings +-- +ok +== +SELECT array_slice(s, -4, -2) FROM strings +-- +ok +== +SELECT array_slice(s, 1, 0) FROM strings +-- +ok +== +SELECT array_slice(s, 2, NULL) FROM strings +-- +ok +== +SELECT array_slice(s, (2147483647-1), 1) FROM strings +-- +ok +== +SELECT array_slice(s, (2147483647-1), -1) FROM strings +-- +ok +== +SELECT array_slice(s, (-2147483646-1), -1) FROM strings +-- +ok +== +SELECT array_slice(s, (-2147483646-1), -2147483647) FROM strings +-- +ok +== +select array_slice([], -1, -9223372036854775808) +-- +ok +== +select * from (SELECT list_slice(NULL, 1, 3, 2)); +-- +ok +== +select s[1:2] from (SELECT NULL) as t(s); +-- +ok +== +select * from (SELECT list_slice(NULL::INT[3], 1, 3, 2)); +-- +ok +== diff --git a/parser/testdata/corpus/sql/function/string/test_string_slice.test b/parser/testdata/corpus/sql/function/string/test_string_slice.test new file mode 100644 index 0000000..8505d0c --- /dev/null +++ b/parser/testdata/corpus/sql/function/string/test_string_slice.test @@ -0,0 +1,133 @@ +# source: test/sql/function/string/test_string_slice.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +CREATE TABLE nulltable(n VARCHAR); +-- +ok +== +INSERT INTO nulltable VALUES (NULL) +-- +ok +== +SELECT NULL::VARCHAR[off:length+off] FROM strings +-- +error: Parser Error: Subscript/slice cannot be applied directly after a cast operator (e.g. x::TYPE[1:3] is not allowed). Wrap the cast in parentheses: (x::TYPE)[1:3] +== +SELECT NULL::VARCHAR[NULL:length+NULL] FROM strings +-- +error: Parser Error: Subscript/slice cannot be applied directly after a cast operator (e.g. x::TYPE[1:3] is not allowed). Wrap the cast in parentheses: (x::TYPE)[1:3] +== +SELECT NULL::VARCHAR[off:NULL+off] FROM strings +-- +error: Parser Error: Subscript/slice cannot be applied directly after a cast operator (e.g. x::TYPE[1:3] is not allowed). Wrap the cast in parentheses: (x::TYPE)[1:3] +== +SELECT NULL::VARCHAR[NULL:NULL+NULL] FROM strings +-- +error: Parser Error: Subscript/slice cannot be applied directly after a cast operator (e.g. x::TYPE[1:3] is not allowed). Wrap the cast in parentheses: (x::TYPE)[1:3] +== +SELECT '🦆ab'[0:0], 'abc'[0:0] +-- +ok +== +SELECT 'MotörHead'[:5] +-- +ok +== +SELECT s[0:2] FROM strings +-- +ok +== +SELECT s[1:3] FROM strings +-- +ok +== +SELECT s[2:3] FROM strings +-- +ok +== +SELECT s[off:length+off] FROM strings +-- +ok +== +SELECT s[off:2+off] FROM strings +-- +ok +== +SELECT s[0:length] FROM strings +-- +ok +== +SELECT 'hello'[off:length+off] FROM strings +-- +ok +== +SELECT n[off:length+off] FROM strings, nulltable +-- +ok +== +SELECT 'hello'[NULL:length+NULL] FROM strings +-- +ok +== +SELECT 'hello'[off:NULL+off] FROM strings +-- +ok +== +SELECT 'hello'[off+1:NULL+off] FROM strings +-- +ok +== +SELECT n[NULL:length+NULL] FROM strings, nulltable +-- +ok +== +SELECT 'hello'[NULL:NULL+NULL] FROM strings +-- +ok +== +SELECT n[off:NULL+off] FROM strings, nulltable +-- +ok +== +SELECT n[NULL:NULL+NULL] FROM strings, nulltable +-- +ok +== +SELECT s[-2:] FROM strings +-- +ok +== +SELECT s[0:1] FROM strings +-- +ok +== +SELECT s[-4:-2] FROM strings +-- +ok +== +SELECT s[1:0] FROM strings +-- +ok +== +SELECT s[2:] FROM strings +-- +ok +== +SELECT s[(2147483647-1):1] FROM strings +-- +ok +== +SELECT s[(2147483647-1):-1] FROM strings +-- +ok +== +SELECT s[(-2147483646-1):-1] FROM strings +-- +ok +== +SELECT s[(-2147483646-1):-2147483647] FROM strings +-- +ok +== diff --git a/parser/testdata/corpus/sql/function/string/test_string_slice.test.metadata.json b/parser/testdata/corpus/sql/function/string/test_string_slice.test.metadata.json new file mode 100644 index 0000000..560d160 --- /dev/null +++ b/parser/testdata/corpus/sql/function/string/test_string_slice.test.metadata.json @@ -0,0 +1,8 @@ +{ + "todo": { + "3cbbda9f20c62757": "transformer-raised parser error: upstream rejects in the transformer, not the grammar; expected to clear as transformers land (milestones 3-5)", + "42e2f1e99e063d83": "transformer-raised parser error: upstream rejects in the transformer, not the grammar; expected to clear as transformers land (milestones 3-5)", + "b0bf995facf139bf": "transformer-raised parser error: upstream rejects in the transformer, not the grammar; expected to clear as transformers land (milestones 3-5)", + "e24ce8a19cf28f7e": "transformer-raised parser error: upstream rejects in the transformer, not the grammar; expected to clear as transformers land (milestones 3-5)" + } +} diff --git a/parser/testdata/corpus/sql/function/string/test_string_split.test b/parser/testdata/corpus/sql/function/string/test_string_split.test new file mode 100644 index 0000000..4d044b7 --- /dev/null +++ b/parser/testdata/corpus/sql/function/string/test_string_split.test @@ -0,0 +1,201 @@ +# source: test/sql/function/string/test_string_split.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +SELECT string_split(NULL, NULL) +-- +ok +== +SELECT * FROM (VALUES (string_split('hello world', ' ')), (string_split(NULL, ' ')), (string_split('a b c', NULL)), (string_split('a b c', ' '))) tbl(i) +-- +ok +== +CREATE TABLE strings_with_null (s VARCHAR) +-- +ok +== +INSERT INTO strings_with_null VALUES ('aba'), (NULL), ('ababa') +-- +ok +== +SELECT UNNEST(string_split(s, 'b')) FROM strings_with_null +-- +ok +== +SELECT UNNEST(string_split(NULL, ' ')) IS NULL LIMIT 5 +-- +ok +== +SELECT UNNEST(string_split('üüüüü', '◌̈')) +-- +ok +== +SELECT UNNEST(string_split('üüüüü', '◌')) +-- +ok +== +SELECT UNNEST(string_split_regex('üüüüü', '◌̈')) +-- +ok +== +SELECT UNNEST(string_split_regex('üüüüü', '◌')) +-- +ok +== +SELECT UNNEST(string_split(' 🦆🦆 🦆🦆', ' ')) +-- +ok +== +SELECT UNNEST(string_split('a a a a a', ' ')) +-- +ok +== +SELECT UNNEST(string_split('🦆 🦆 🦆 🦆 🦆', ' ')) +-- +ok +== +SELECT UNNEST(string_split('🦆🐈🐈🦆🐈🐈🦆🐈🐈🦆🐈🐈🦆', '🐈🐈')) +-- +ok +== +SELECT UNNEST(string_split('', 'delim')) +-- +ok +== +SELECT UNNEST(string_split('aaaaa', '')) +-- +ok +== +SELECT UNNEST(string_split('🦆🦆🦆🦆🦆', '')) +-- +ok +== +SELECT UNNEST(string_split('abab', 'b')) +-- +ok +== +SELECT UNNEST(string_split('🦆b🦆b', 'b')) +-- +ok +== +CREATE TABLE documents(s VARCHAR) +-- +ok +== +INSERT INTO documents VALUES ('baabbaa'), ('aabbaab'), ('ababababa'), ('b🦆🦆bb🦆🦆'), ('🦆🦆bb🦆🦆b'), ('🦆b🦆b🦆b🦆b🦆') +-- +ok +== +SELECT UNNEST(string_split(s, 'bb')) FROM documents WHERE 1 +-- +ok +== +SELECT UNNEST(string_split(s, 'bb')) FROM documents WHERE s LIKE 'b%' +-- +ok +== +SELECT string_agg(ss, 'bb') FROM (SELECT rowid AS id, UNNEST(string_split(s, 'bb')) AS ss FROM documents) AS q GROUP BY id ORDER BY id +-- +ok +== +SELECT UNNEST(string_split_regex('a1a11a111a', '[0-9]+')) +-- +ok +== +SELECT UNNEST(string_split_regex('aaaaa', '')) +-- +ok +== +SELECT UNNEST(string_split_regex('a a a a', '\s+')) +-- +ok +== +SELECT UNNEST(string_split('aaaaa', NULL)) +-- +ok +== +select UNNEST(string_split('1|2|3', '|')) +-- +ok +== +select UNNEST(string_split('1|2|3|', '|')) +-- +ok +== +select UNNEST(string_split('1||2|3||', '||')) +-- +ok +== +select UNNEST(string_split('1|2|3', '')) +-- +ok +== +select UNNEST(string_split('', '|')) +-- +ok +== +select UNNEST(string_split('1|2|3', NULL)) +-- +ok +== +select string_split(NULL, '|') IS NULL +-- +ok +== +select UNNEST(string_split('abc', '')) +-- +ok +== +select UNNEST(string_split_regex('abc', '(|abc)')) +-- +ok +== +select UNNEST(string_split_regex('abc', '(abc|)')) +-- +ok +== +select UNNEST(string_split('abc', ',')) +-- +ok +== +select UNNEST(string_split_regex('abc', '(,|abc)')) +-- +ok +== +select UNNEST(string_split_regex('abc', '(abc|,)')) +-- +ok +== +select UNNEST(string_split('1,2,3,4,,6', ',')) +-- +ok +== +select UNNEST(string_split_regex('1,2,3,4,,6', '(,|)')) +-- +ok +== +select UNNEST(string_split_regex('1,2,3,4,,6', '(|,)')) +-- +ok +== +select UNNEST(string_split_regex('1,2,3,4,*,6', '(,|\*)')) +-- +ok +== +select UNNEST(string_split_regex('1,2,3,4,*,6', '(\*|,)')) +-- +ok +== +select string_split() +-- +ok +== +select string_split('a') +-- +ok +== +SELECT string_split_regex(a, '[') FROM test ORDER BY a; +-- +ok +== diff --git a/parser/testdata/corpus/sql/function/string/test_subscript.test b/parser/testdata/corpus/sql/function/string/test_subscript.test new file mode 100644 index 0000000..7484683 --- /dev/null +++ b/parser/testdata/corpus/sql/function/string/test_subscript.test @@ -0,0 +1,61 @@ +# source: test/sql/function/string/test_subscript.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +SELECT '🦆ab'[1], 'abc'[2] +-- +ok +== +SELECT s[2] FROM strings +-- +ok +== +SELECT s[3] FROM strings +-- +ok +== +SELECT s[off] FROM strings +-- +ok +== +SELECT 'hello'[off] FROM strings +-- +ok +== +SELECT NULL::VARCHAR[off] FROM strings +-- +error: Parser Error: Expected a constant number as array size +== +SELECT 'hello'[NULL] FROM strings +-- +ok +== +SELECT NULL::VARCHAR[NULL] FROM strings +-- +ok +== +SELECT s[-1] FROM strings +-- +ok +== +SELECT s[1] FROM strings +-- +ok +== +SELECT s[6] FROM strings +-- +ok +== +SELECT s[2147483646] FROM strings +-- +ok +== +SELECT s[-2147483647] FROM strings +-- +ok +== +SELECT ([1,2,3])[-2147483647] +-- +ok +== diff --git a/parser/testdata/corpus/sql/function/string/test_subscript.test.metadata.json b/parser/testdata/corpus/sql/function/string/test_subscript.test.metadata.json new file mode 100644 index 0000000..4cf640f --- /dev/null +++ b/parser/testdata/corpus/sql/function/string/test_subscript.test.metadata.json @@ -0,0 +1,5 @@ +{ + "todo": { + "2b291c35a430c7b3": "transformer-raised parser error: upstream rejects in the transformer, not the grammar; expected to clear as transformers land (milestones 3-5)" + } +} diff --git a/parser/testdata/corpus/sql/function/string/test_substring.test b/parser/testdata/corpus/sql/function/string/test_substring.test new file mode 100644 index 0000000..f85fda7 --- /dev/null +++ b/parser/testdata/corpus/sql/function/string/test_substring.test @@ -0,0 +1,177 @@ +# source: test/sql/function/string/test_substring.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +SELECT {FUN}('🦆ab', 1, 0), {FUN}('abc', 1, 0) +-- +error: Parser Error: syntax error at or near "}" +== +SELECT substring(s from 1 for 2) FROM strings +-- +ok +== +SELECT substring(s from 2 for 2) FROM strings +-- +ok +== +SELECT substring(s from off for length) FROM strings +-- +ok +== +SELECT substring(s from off for 2) FROM strings +-- +ok +== +SELECT substring(s from 1 for length) FROM strings +-- +ok +== +SELECT substring('hello' from off for length) FROM strings +-- +ok +== +SELECT substring(NULL from off for length) FROM strings +-- +ok +== +SELECT substring('hello' from NULL for length) FROM strings +-- +ok +== +SELECT substring('hello' from off for NULL) FROM strings +-- +ok +== +SELECT substring(NULL from NULL for length) FROM strings +-- +ok +== +SELECT substring('hello' from NULL for NULL) FROM strings +-- +ok +== +SELECT substring(NULL from off for NULL) FROM strings +-- +ok +== +SELECT substring(NULL from NULL for NULL) FROM strings +-- +ok +== +SELECT substring(s from -2 for 2) FROM strings +-- +ok +== +SELECT substring(s from 0 for length) FROM strings +-- +ok +== +SELECT {FUN}(s, 2, -2) FROM strings +-- +error: Parser Error: syntax error at or near "}" +== +SELECT {FUN}(s, -2, -2) FROM strings +-- +error: Parser Error: syntax error at or near "}" +== +SELECT {FUN}(s, 2, 0) FROM strings +-- +error: Parser Error: syntax error at or near "}" +== +SELECT {FUN}(s, 2) FROM strings +-- +error: Parser Error: syntax error at or near "}" +== +SELECT {FUN}({FUN}(s, 2), 2) FROM strings +-- +error: Parser Error: syntax error at or near "}" +== +SELECT {FUN}(s, 2147483647, 2147483647) FROM strings +-- +error: Parser Error: syntax error at or near "}" +== +SELECT {FUN}(s, 2147483647, -2147483648) FROM strings +-- +error: Parser Error: syntax error at or near "}" +== +SELECT {FUN}(s, -2147483647, 2147483647) FROM strings +-- +error: Parser Error: syntax error at or near "}" +== +SELECT {FUN}(s, -2147483648, -2147483648) FROM strings +-- +error: Parser Error: syntax error at or near "}" +== +SELECT {FUN}('abc', INSTR('abc', 'b')); +-- +error: Parser Error: syntax error at or near "}" +== +SELECT {FUN}('a', -1) +-- +error: Parser Error: syntax error at or near "}" +== +SELECT {FUN}('abcd', -1) +-- +error: Parser Error: syntax error at or near "}" +== +SELECT {FUN}('abcd', -7) +-- +error: Parser Error: syntax error at or near "}" +== +SELECT {FUN}(s, 9223372036854775807, -9223372036854775808) FROM strings +-- +error: Parser Error: syntax error at or near "}" +== +SELECT {FUN}(s, -9223372036854775808, -9223372036854775808) FROM strings +-- +error: Parser Error: syntax error at or near "}" +== +SELECT {FUN}(s, 9223372036854775807, 9223372036854775807) FROM strings +-- +error: Parser Error: syntax error at or near "}" +== +SELECT {FUN}(s, -9223372036854775808, 9223372036854775807) FROM strings +-- +error: Parser Error: syntax error at or near "}" +== +SELECT {FUN}(s, 0, 9223372036854775807) FROM strings +-- +error: Parser Error: syntax error at or near "}" +== +SELECT {FUN}(s, 0, -9223372036854775808) FROM strings +-- +error: Parser Error: syntax error at or near "}" +== +SELECT {FUN}(s, 4294967296, 2147483647) FROM strings +-- +error: Parser Error: syntax error at or near "}" +== +SELECT {FUN}(s, -4294967297, 2147483647) FROM strings +-- +error: Parser Error: syntax error at or near "}" +== +SELECT {FUN}(s, 0, 4294967296) FROM strings +-- +error: Parser Error: syntax error at or near "}" +== +SELECT {FUN}(s, 0, -4294967297) FROM strings +-- +error: Parser Error: syntax error at or near "}" +== +SELECT substring(s from off) FROM strings +-- +ok +== +SELECT substring(s for length) FROM strings +-- +ok +== +SELECT SUBSTRING('hello' FROM 2) +-- +ok +== +SELECT SUBSTRING('hello' FOR 3) +-- +ok +== diff --git a/parser/testdata/corpus/sql/function/string/test_substring_utf8.test b/parser/testdata/corpus/sql/function/string/test_substring_utf8.test new file mode 100644 index 0000000..2e97dec --- /dev/null +++ b/parser/testdata/corpus/sql/function/string/test_substring_utf8.test @@ -0,0 +1,45 @@ +# source: test/sql/function/string/test_substring_utf8.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +INSERT INTO strings VALUES ('twoñthree₡four🦆end') +-- +ok +== +SELECT substring(s from 1 for 7) FROM strings +-- +ok +== +SELECT substring(s from 10 for 7) FROM strings +-- +ok +== +SELECT substring(s from 15 for 7) FROM strings +-- +ok +== +SELECT {FUN}(s, -4, 4) FROM strings +-- +error: Parser Error: syntax error at or near "}" +== +SELECT {FUN}(s, -1, -4) FROM strings +-- +error: Parser Error: syntax error at or near "}" +== +SELECT {FUN}(s, 0, -4) FROM strings +-- +error: Parser Error: syntax error at or near "}" +== +SELECT {FUN}(s, 0, 5) FROM strings +-- +error: Parser Error: syntax error at or near "}" +== +SELECT {FUN}(s, 5, -5) FROM strings +-- +error: Parser Error: syntax error at or near "}" +== +SELECT {FUN}(s, 5) FROM strings +-- +error: Parser Error: syntax error at or near "}" +== diff --git a/parser/testdata/corpus/sql/function/string/test_suffix.test b/parser/testdata/corpus/sql/function/string/test_suffix.test new file mode 100644 index 0000000..1fc369b --- /dev/null +++ b/parser/testdata/corpus/sql/function/string/test_suffix.test @@ -0,0 +1,153 @@ +# source: test/sql/function/string/test_suffix.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +SELECT suffix('abcd', 'd') +-- +ok +== +SELECT suffix('abcd', 'cd') +-- +ok +== +SELECT suffix('abcd', 'bcd') +-- +ok +== +SELECT suffix('abcd', 'abcd') +-- +ok +== +SELECT suffix('abcd', 'X') +-- +ok +== +SELECT suffix('abcdefgh', 'h') +-- +ok +== +SELECT suffix('abcdefgh', 'gh') +-- +ok +== +SELECT suffix('abcdefgh', 'fgh') +-- +ok +== +SELECT suffix('abcdefgh', 'efgh') +-- +ok +== +SELECT suffix('abcdefgh', 'defgh') +-- +ok +== +SELECT suffix('abcdefgh', 'X') +-- +ok +== +SELECT suffix('abcdefgh', 'abcdefgh') +-- +ok +== +SELECT suffix('abcdefghijklmnopqrstuvwxyz', 'z') +-- +ok +== +SELECT suffix('abcdefghijklmnopqrstuvwxyz', 'yz') +-- +ok +== +SELECT suffix('abcdefghijklmnopqrstuvwxyz', 'xyz') +-- +ok +== +SELECT suffix('abcdefghijklmnopqrstuvwxyz', 'wxyz') +-- +ok +== +SELECT suffix('abcdefghijklmnopqrstuvwxyz', 'vwxyz') +-- +ok +== +SELECT suffix('abcdefghijklmnopqrstuvwxyz', 'X') +-- +ok +== +SELECT suffix('abcdefghijklmnopqrstuvwxyz', 'defghijklmnopqrstuvwxyz') +-- +ok +== +SELECT suffix('', 'aaa') +-- +ok +== +SELECT suffix('aaa', '') +-- +ok +== +SELECT suffix(NULL, 'aaa') +-- +ok +== +SELECT suffix('aaa', NULL) +-- +ok +== +SELECT suffix(NULL, NULL) +-- +ok +== +SELECT suffix('omotá', 'á') +-- +ok +== +SELECT suffix('omotá', 'a') +-- +ok +== +SELECT suffix('mundo olá', 'olá') +-- +ok +== +SELECT suffix('mundo olá', 'mundo olá') +-- +ok +== +SELECT suffix('mundo olá', 'ola') +-- +ok +== +SELECT suffix('eftñ', 'ñ') +-- +ok +== +SELECT suffix('ñeft', 'ñeft') +-- +ok +== +SELECT suffix('ñeft', 'neft') +-- +ok +== +SELECT suffix('two ñ three ₡ four 🦆 end', '🦆 end') +-- +ok +== +SELECT suffix('two ñ three ₡ four 🦆 end', 'three ₡ four 🦆 end') +-- +ok +== +SELECT suffix('two ñ three ₡ four 🦆 end', 'two ñ three ₡ four 🦆 end') +-- +ok +== +SELECT suffix('two ñ three ₡ four 🦆 end', 'two n three ₡ four 🦆 end') +-- +ok +== +SELECT suffix('two ñ three ₡ four 🦆 end', 'XXXtwo ñ three ₡ four 🦆 end') +-- +ok +== diff --git a/parser/testdata/corpus/sql/function/string/test_to_base.test b/parser/testdata/corpus/sql/function/string/test_to_base.test new file mode 100644 index 0000000..d320041 --- /dev/null +++ b/parser/testdata/corpus/sql/function/string/test_to_base.test @@ -0,0 +1,111 @@ +# source: test/sql/function/string/test_to_base.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +SELECT to_base(-10, 2) +-- +ok +== +SELECT to_base(-10, 2, 64) +-- +ok +== +SELECT to_base(10, 1) +-- +ok +== +SELECT to_base(10, 37) +-- +ok +== +SELECT to_base(10, 0, 10) +-- +ok +== +SELECT to_base(10, 37, 10) +-- +ok +== +SELECT to_base(10, 2, -10) +-- +ok +== +SELECT to_base(10, 2) +-- +ok +== +SELECT to_base(10, 2, 64) +-- +ok +== +SELECT to_base(10, 3) +-- +ok +== +SELECT to_base(10, 16) +-- +ok +== +SELECT to_base(10, 36) +-- +ok +== +SELECT to_base(42, 36) +-- +ok +== +SELECT + to_base(range, 2), + to_base(range, 2, 8), + to_base(range, 16), + to_base(range, 16, 2), + to_base(range, 36), + to_base(range, 36, 2) +FROM range(1, 43) +ORDER BY range +-- +ok +== +CREATE TABLE fib AS SELECT * FROM (VALUES + (0), + (1), + (1), + (2), + (3), + (5), + (8), + (13), + (21), + (34), + (55), + (89), + (144), + (233), + (377), + (610), + (987), + (1597), + (2584), + (4181), + (6765), + (10946), + (17711), + (28657), + (46368) +) +-- +ok +== +SELECT to_base(col0, 2) FROM fib ORDER BY col0; +-- +ok +== +SELECT to_base(col0, 16) FROM fib ORDER BY col0; +-- +ok +== +SELECT to_base(col0, 36) FROM fib ORDER BY col0; +-- +ok +== diff --git a/parser/testdata/corpus/sql/function/string/test_translate.test b/parser/testdata/corpus/sql/function/string/test_translate.test new file mode 100644 index 0000000..a40f69d --- /dev/null +++ b/parser/testdata/corpus/sql/function/string/test_translate.test @@ -0,0 +1,97 @@ +# source: test/sql/function/string/test_translate.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +select TRANSLATE('This is the main test string', NULL, 'ALT') +-- +ok +== +select TRANSLATE(NULL, 'main', 'ALT') +-- +ok +== +select TRANSLATE('This is the main test string', 'main', NULL) +-- +ok +== +select TRANSLATE('12', '2', 'a') +-- +ok +== +select TRANSLATE('abcde', 'abcde', 'fghij') +-- +ok +== +select TRANSLATE('abcde', 'aabcc', '14235') +-- +ok +== +select TRANSLATE('https://dxyzdb.org', 'zyx.orghttps:/', 'kcu') +-- +ok +== +select TRANSLATE('12345', '14367', 'ax') +-- +ok +== +select TRANSLATE('hacco worcdxxx', 'acx2', 'el') +-- +ok +== +select TRANSLATE('hacCo worcd', 'acC', 'ellaabb') +-- +ok +== +select TRANSLATE('RÄcks', 'Ä', 'A') +-- +ok +== +select TRANSLATE('🦆', '🦆', 'D') +-- +ok +== +select TRANSLATE('MotörHeadΩ', 'aeΩ', 'eÄ') +-- +ok +== +select TRANSLATE('This is 🐱.', '🐱', '🦆') +-- +ok +== +select TRANSLATE('Äañt₡Xá你好世界我', 'ñá世界我xyz', 'naDBá') +-- +ok +== +INSERT INTO strings VALUES ('Hello', 'World'), ('HuLlD', NULL), ('MotörHead','RÄcks'), ('', NULL), ('Hi', '🦆') +-- +ok +== +select TRANSLATE(a, 'öHl', 'oA-') FROM strings +-- +ok +== +select TRANSLATE(a, 'loD', '🦆') FROM strings +-- +ok +== +select TRANSLATE(b, 'ÄW🦆l', 'ow🐱') FROM strings +-- +ok +== +select TRANSLATE(a, 'oel', 'OEL') FROM strings WHERE b IS NOT NULL +-- +ok +== +select TRANSLATE(1) +-- +ok +== +select TRANSLATE(1, 2) +-- +ok +== +select TRANSLATE(1, 2, 3, 4) +-- +ok +== diff --git a/parser/testdata/corpus/sql/function/string/test_trim.test b/parser/testdata/corpus/sql/function/string/test_trim.test new file mode 100644 index 0000000..5e2abb4 --- /dev/null +++ b/parser/testdata/corpus/sql/function/string/test_trim.test @@ -0,0 +1,93 @@ +# source: test/sql/function/string/test_trim.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +select LTRIM(''), LTRIM('Neither'), LTRIM(' Leading'), LTRIM('Trailing '), LTRIM(' Both '), LTRIM(NULL), LTRIM(' ') +-- +ok +== +select RTRIM(''), RTRIM('Neither'), RTRIM(' Leading'), RTRIM('Trailing '), RTRIM(' Both '), RTRIM(NULL), RTRIM(' ') +-- +ok +== +select TRIM(''), TRIM('Neither'), TRIM(' Leading'), TRIM('Trailing '), TRIM(' Both '), TRIM(NULL), TRIM(' ') +-- +ok +== +INSERT INTO strings VALUES ('', 'Neither'), (' Leading', NULL), (' Both ','Trailing '), ('', NULL) +-- +ok +== +select LTRIM(a) FROM strings +-- +ok +== +select LTRIM(b) FROM strings +-- +ok +== +select LTRIM(a) FROM strings WHERE b IS NOT NULL +-- +ok +== +select RTRIM(a) FROM strings +-- +ok +== +select RTRIM(b) FROM strings +-- +ok +== +select RTRIM(a) FROM strings WHERE b IS NOT NULL +-- +ok +== +select LTRIM('', 'ho'), LTRIM('hello', 'ho'), LTRIM('papapapa', 'pa'), LTRIM('blaHblabla', 'bla'), LTRIM('blabla', NULL), LTRIM(NULL, 'blabla'), LTRIM('blabla', '') +-- +ok +== +select RTRIM('', 'ho'), RTRIM('hello', 'ho'), RTRIM('papapapa', 'pa'), RTRIM('blaHblabla', 'bla'), RTRIM('blabla', NULL), RTRIM(NULL, 'blabla'), RTRIM('blabla', '') +-- +ok +== +select TRIM('', 'ho'), TRIM('hello', 'ho'), TRIM('papapapa', 'pa'), TRIM('blaHblabla', 'bla'), TRIM('blabla', NULL), TRIM(NULL, 'blabla'), TRIM('blabla', '') +-- +ok +== +CREATE TABLE trim_test(a VARCHAR, b VARCHAR) +-- +ok +== +INSERT INTO trim_test VALUES ('hello', 'ho'), ('test', 't'), ('mühleisen','mün'), (NULL, ' '), ('', NULL), ('', ''), (NULL, NULL) +-- +ok +== +SELECT LTRIM(a, b), RTRIM(a, b), TRIM(a, b) FROM trim_test +-- +ok +== +select LTRIM() +-- +ok +== +select LTRIM('hello', 'world', 'aaa') +-- +ok +== +select RTRIM() +-- +ok +== +select RTRIM('hello', 'world', 'aaa') +-- +ok +== +select TRIM() +-- +error: Parser Error: syntax error at or near ")" +== +select TRIM('hello', 'world', 'aaa') +-- +ok +== diff --git a/parser/testdata/corpus/sql/function/string/test_unicode.test b/parser/testdata/corpus/sql/function/string/test_unicode.test new file mode 100644 index 0000000..42af10c --- /dev/null +++ b/parser/testdata/corpus/sql/function/string/test_unicode.test @@ -0,0 +1,29 @@ +# source: test/sql/function/string/test_unicode.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +select UNICODE(NULL), UNICODE(''), UNICODE('$'), UNICODE('¢'), UNICODE('€'), UNICODE('𐍈') +-- +ok +== +select UNICODE(a) FROM strings +-- +ok +== +select UNICODE(b) FROM strings +-- +ok +== +select UNICODE(a) FROM strings WHERE b IS NOT NULL +-- +ok +== +select UNICODE() +-- +ok +== +select UNICODE(1, 2) +-- +ok +== diff --git a/parser/testdata/corpus/sql/function/string/test_url_encode.test b/parser/testdata/corpus/sql/function/string/test_url_encode.test new file mode 100644 index 0000000..3513f11 --- /dev/null +++ b/parser/testdata/corpus/sql/function/string/test_url_encode.test @@ -0,0 +1,41 @@ +# source: test/sql/function/string/test_url_encode.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +SELECT url_encode(''), url_decode('') +-- +ok +== +SELECT url_encode(NULL), url_decode(NULL) +-- +ok +== +SELECT url_decode(url_encode('http://www.google.com/this is a long url')) +-- +ok +== +SELECT COUNT(*) from range(1000) t(n) WHERE url_decode(url_encode(chr(n::INT))) = chr(n::INT) +-- +ok +== +SELECT url_decode('%'), url_decode('%5'), url_decode('%X'), url_decode('%%') +-- +ok +== +select url_decode('%FF%FF%FF'); +-- +ok +== +CREATE TABLE t24268 AS SELECT '%c0' AS c FROM range(4096); +-- +ok +== +SELECT COUNT(*) FROM t24268 WHERE TRY(url_decode(c)) IS NULL +-- +ok +== +SELECT url_decode(c) FROM t24268 +-- +ok +== diff --git a/parser/testdata/corpus/sql/function/test_scalar_executor.test b/parser/testdata/corpus/sql/function/test_scalar_executor.test new file mode 100644 index 0000000..186a3b0 --- /dev/null +++ b/parser/testdata/corpus/sql/function/test_scalar_executor.test @@ -0,0 +1,33 @@ +# source: test/sql/function/test_scalar_executor.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +CREATE TABLE executor_input(i INTEGER, s VARCHAR); +-- +ok +== +INSERT INTO executor_input VALUES (-3, 'aardvark'), (2, 'beta'), (NULL, NULL), (5, 'gamma'); +-- +ok +== +SELECT abs(i), upper(s), i + 10 FROM executor_input ORDER BY rowid; +-- +ok +== +SELECT abs(i), upper(s) FROM executor_input WHERE i > 0 ORDER BY i; +-- +ok +== +SELECT replace(s, 'a', 'x') FROM executor_input ORDER BY rowid; +-- +ok +== +SELECT try_strptime(s, '%Y-%m-%d') FROM (VALUES ('2024-01-02'), ('invalid'), (NULL)) input(s); +-- +ok +== +SELECT make_timestamp(2024, 1, 2, 3, 4, 5); +-- +ok +== diff --git a/parser/testdata/corpus/sql/function/time/epoch.test b/parser/testdata/corpus/sql/function/time/epoch.test new file mode 100644 index 0000000..98ac76f --- /dev/null +++ b/parser/testdata/corpus/sql/function/time/epoch.test @@ -0,0 +1,17 @@ +# source: test/sql/function/time/epoch.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +select epoch(TIME '14:21:13') +-- +ok +== +select extract(epoch from TIME '14:21:13') +-- +ok +== +select extract(seconds from TIME '14:21:13') +-- +ok +== diff --git a/parser/testdata/corpus/sql/function/time/test_date_part.test b/parser/testdata/corpus/sql/function/time/test_date_part.test new file mode 100644 index 0000000..ffae67d --- /dev/null +++ b/parser/testdata/corpus/sql/function/time/test_date_part.test @@ -0,0 +1,174 @@ +# source: test/sql/function/time/test_date_part.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +CREATE TABLE times(d TIME, s VARCHAR); +-- +ok +== +INSERT INTO times VALUES ('00:01:20', 'hour'), ('20:08:10.998', 'minute'), ('20:08:10.33', 'second'), +('20:08:10.001', 'millisecond'); +-- +ok +== +SELECT date_part(NULL::VARCHAR, NULL::TIME) FROM times; +-- +ok +== +SELECT date_part(s, NULL::TIME) FROM times; +-- +ok +== +SELECT date_part(NULL, d) FROM times; +-- +ok +== +SELECT date_part(s, TIME '14:28:50.447') FROM times; +-- +ok +== +SELECT date_part('hour', d) FROM times; +-- +ok +== +SELECT date_part(s, d) FROM times; +-- +ok +== +select date_part('{datepart}', time '10:00:00'); +-- +ok +== +SELECT era(i) FROM times +-- +ok +== +SELECT year(i) FROM times +-- +ok +== +SELECT month(i) FROM times +-- +ok +== +SELECT day(i) FROM times +-- +ok +== +SELECT decade(i) FROM times +-- +ok +== +SELECT century(i) FROM times +-- +ok +== +SELECT millennium(i) FROM times +-- +ok +== +SELECT quarter(i) FROM times +-- +ok +== +SELECT dayofweek(i) FROM times +-- +ok +== +SELECT isodow(i) FROM times +-- +ok +== +SELECT dayofyear(i) FROM times +-- +ok +== +SELECT week(i) FROM times +-- +ok +== +SELECT yearweek(i) FROM times +-- +ok +== +select extract(dow from time '10:00:00'); +-- +ok +== +select extract(doy from time '10:00:00'); +-- +ok +== +select extract(yearweek from time '10:00:00'); +-- +ok +== +select extract(century from time '10:00:00'); +-- +ok +== +select extract(era from time '10:00:00'); +-- +ok +== +select date_part('era', time '10:00:00'); +-- +ok +== +select extract(julian from time '10:00:00'); +-- +ok +== +select date_part('julian', time '10:00:00'); +-- +ok +== +SELECT * FROM ( + SELECT d, DATE_PART('{partcode}', d) AS p, {partcode}(d) AS f + FROM times +) tbl +WHERE p <> f; +-- +error: Parser Error: syntax error at or near "}" +== +SELECT d, DATE_PART('{partcode}', d) AS p, DATE_PART(['{partcode}'], d) AS st +FROM times +WHERE p <> st['{partcode}']; +-- +ok +== +SELECT d, DATE_PART(['hour', 'minute', 'microsecond'], d) AS parts +FROM times +ORDER BY 1; +-- +ok +== +SELECT d, DATE_PART(['epoch', 'second', 'timezone', 'timezone_hour', 'timezone_minute'], d) AS parts +FROM times +ORDER BY 1; +-- +ok +== +SELECT d, epoch_ns(d) FROM times ORDER BY ALL; +-- +ok +== +SELECT d, epoch_us(d) FROM times ORDER BY ALL; +-- +ok +== +SELECT d, epoch_ms(d) FROM times ORDER BY ALL; +-- +ok +== +SELECT d, nanosecond(d) FROM times ORDER BY ALL; +-- +ok +== +SELECT d, DATE_PART(['{datepart}'], d) AS parts +FROM times +ORDER BY 1; +-- +ok +== diff --git a/parser/testdata/corpus/sql/function/time/test_extract.test b/parser/testdata/corpus/sql/function/time/test_extract.test new file mode 100644 index 0000000..754fa5e --- /dev/null +++ b/parser/testdata/corpus/sql/function/time/test_extract.test @@ -0,0 +1,85 @@ +# source: test/sql/function/time/test_extract.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +CREATE TABLE times(i TIME) +-- +ok +== +INSERT INTO times VALUES ('00:01:20'), ('20:08:10.998'), ('20:08:10.33'), ('20:08:10.001'), (NULL) +-- +ok +== +SELECT EXTRACT(second FROM i) FROM times +-- +ok +== +SELECT EXTRACT(minute FROM i) FROM times +-- +ok +== +SELECT EXTRACT(hour FROM i) FROM times +-- +ok +== +SELECT EXTRACT(milliseconds FROM i) FROM times +-- +ok +== +SELECT EXTRACT(microseconds FROM i) FROM times +-- +ok +== +SELECT EXTRACT(epoch FROM i) FROM times +-- +ok +== +SELECT EXTRACT(year FROM i) FROM times +-- +ok +== +SELECT EXTRACT(month FROM i) FROM times +-- +ok +== +SELECT EXTRACT(day FROM i) FROM times +-- +ok +== +SELECT EXTRACT(decade FROM i) FROM times +-- +ok +== +SELECT EXTRACT(century FROM i) FROM times +-- +ok +== +SELECT EXTRACT(millennium FROM i) FROM times +-- +ok +== +SELECT EXTRACT(quarter FROM i) FROM times +-- +ok +== +SELECT EXTRACT(dayofweek FROM i) FROM times +-- +ok +== +SELECT EXTRACT(isodow FROM i) FROM times +-- +ok +== +SELECT EXTRACT(dayofyear FROM i) FROM times +-- +ok +== +SELECT EXTRACT(week FROM i) FROM times +-- +ok +== +SELECT EXTRACT(yearweek FROM i) FROM times +-- +ok +== diff --git a/parser/testdata/corpus/sql/function/time/test_extract_stats.test b/parser/testdata/corpus/sql/function/time/test_extract_stats.test new file mode 100644 index 0000000..9d735aa --- /dev/null +++ b/parser/testdata/corpus/sql/function/time/test_extract_stats.test @@ -0,0 +1,24 @@ +# source: test/sql/function/time/test_extract_stats.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +CREATE TABLE expected_result AS FROM (VALUES + ('microseconds', 0, 59999999), + ('milliseconds', 0, 59999), + ('second', 0, 59), + ('minute', 0, 59), + ('hour', 0, 24), + ('epoch', 0, 86400) + ) t(component, min, max) +-- +ok +== +SELECT + CASE WHEN stats.min::DOUBLE = expected_result.min AND stats.max::DOUBLE = expected_result.max THEN NULL ELSE {'stats': stats, 'expected_result': expected_result} END +FROM ( + SELECT STATS(EXTRACT({component} FROM i)) AS stats, (SELECT expected_result FROM expected_result WHERE component = '{component}') expected_result FROM times LIMIT 1 +) +-- +error: Parser Error: syntax error at or near "{" +== diff --git a/parser/testdata/corpus/sql/function/time/test_time_bucket_time.test b/parser/testdata/corpus/sql/function/time/test_time_bucket_time.test new file mode 100644 index 0000000..36390fa --- /dev/null +++ b/parser/testdata/corpus/sql/function/time/test_time_bucket_time.test @@ -0,0 +1,233 @@ +# source: test/sql/function/time/test_time_bucket_time.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +CREATE TABLE times(w INTERVAL, t TIME, shift INTERVAL, origin TIME); +-- +ok +== +INSERT INTO times VALUES + ('10 days', '03:16:23.003003', '3 days', '00:00:00'), + ('2 months', '12:35:40.003003', '10 days', '00:00:00'), + ('10 days', '12:35:40.003003', '6 days', '00:00:00'), + ('333 microseconds', '02:02:03.003003', '0 microseconds', '00:00:00'), + ('333 microseconds', '02:02:04.003003', '444 microseconds', '00:05:05.006006'), + ('333 microseconds', '00:00:00', '-444 microseconds', '00:05:05.006006'), + ('333 milliseconds', '00:00:00', '0 milliseconds', '00:00:00'), + ('333 milliseconds', '00:00:00', '444 milliseconds', '00:05:05.006006'), + ('333 milliseconds', '02:02:08.003003', '-444 milliseconds', '00:05:05.006006'), + ('333 seconds', '02:02:09.003003', '0 seconds', '00:00:00'), + ('333 seconds', '02:02:10.003003', '444 seconds', '00:05:05.006006'), + ('333 seconds', '02:02:11.003003', '-444 seconds', '00:05:05.006006'), + ('333 minutes', '02:02:12.003003', '0 minutes', '00:00:00'), + ('333 minutes', '02:02:13.003003', '444 minute', '00:05:05.006006'), + ('333 minutes', '02:02:14.003003', '-444 minute', '00:00:00'), + ('333 hours', '02:02:15.003003', '0 hours', '00:00:00'), + ('333 hours', '00:00:00', '444 hours', '00:05:05.006006'), + ('333 hours', '00:00:00', '-444 hours', '00:05:05.006006'), + ('10 days', '02:02:18.003003', '0 days', '00:00:00'), + ('1 week', '02:02:19.003003', '0 days', '00:00:00'), + ('10 days', '02:02:20.003003', '2 days 4 hours', '00:05:05.006006'), + ('10 days', '02:02:21.003003', '-2 days 4 hours', '00:05:05.006006'), + ('2 months', '02:02:22.003003', '0 months', '00:00:00'), + ('2 months', '02:02:23.003003', '1 month 1 week', '00:05:05.006006'), + ('2 months', '02:02:24.003003', '-1 month 1 week', '00:05:05.006006'), + ('2 year', '02:02:25.003003', '6 months', '00:05:05.006006'), + ('2 year', '02:02:26.003003', '-6 months', '00:05:05.006006'), +; +-- +ok +== +select t, time_bucket('56 seconds'::interval, t) from times; +-- +ok +== +select t, time_bucket('3 days'::interval, t) from times; +-- +ok +== +select t, time_bucket('3 years'::interval, t) from times; +-- +ok +== +select t, time_bucket(null::interval, t) from times; +-- +ok +== +select time_bucket('3 years'::interval, null::time) from times; +-- +ok +== +select w, t, time_bucket(w, t) from times; +-- +ok +== +select t, time_bucket('4 seconds'::interval, t, '2 seconds'::interval) from times; +-- +ok +== +select t, time_bucket('4 days'::interval, t, '6 hours'::interval) from times; +-- +ok +== +select t, time_bucket('3 months'::interval, t, '6 days 11 hours'::interval) from times; +-- +ok +== +select t, time_bucket(null::interval, t, '2 seconds'::interval) from times; +-- +ok +== +select time_bucket('3 months'::interval, null::time, '2 seconds'::interval) from times; +-- +ok +== +select t, time_bucket('3 months'::interval, t, null::interval) from times; +-- +ok +== +select w, t, shift, time_bucket(w, t, shift) from times; +-- +ok +== +select t, time_bucket('11 seconds'::interval, t, '08:08:10'::time) from times; +-- +ok +== +select t, time_bucket('11 days'::interval, t, '08:08:10'::time) from times; +-- +ok +== +select t, time_bucket('7 months'::interval, t, '08:08:10'::time) from times; +-- +ok +== +select t, time_bucket(null::interval, t, '08:08:10'::time) from times; +-- +ok +== +select time_bucket('7 months'::interval, null::time, '08:08:10'::time) from times; +-- +ok +== +select t, time_bucket('7 months'::interval, t, null::time) from times; +-- +ok +== +select w, t, origin, time_bucket(w, t, origin) from times; +-- +ok +== +select time_bucket('-3 hours'::interval, '00:00:00'::time); +-- +ok +== +select time_bucket('-3 hours'::interval, '00:00:00'::time, '1 hour 30 minutes':: interval); +-- +ok +== +select time_bucket('-3 hours'::interval, '00:00:00'::time, '00:00:00'::time); +-- +ok +== +select time_bucket('-1 month'::interval, '00:00:00'::time); +-- +ok +== +select time_bucket('-1 month'::interval, '00:00:00'::time, '1 hour 30 minutes':: interval); +-- +ok +== +select time_bucket('-1 month'::interval, '00:00:00'::time, '00:00:00'::time); +-- +ok +== +select time_bucket('1 day - 172800 seconds'::interval, '00:00:00'::time); +-- +ok +== +select time_bucket('1 day - 172800 seconds'::interval, '00:00:00'::time, '1 hour 30 minutes':: interval); +-- +ok +== +select time_bucket('1 day - 172800 seconds'::interval, '00:00:00'::time, '00:00:00'::time); +-- +ok +== +select time_bucket('1 month 1 day'::interval, '00:00:00'::time); +-- +ok +== +select time_bucket('1 month 1 day'::interval, '00:00:00'::time, '1 hour 30 minutes':: interval); +-- +ok +== +select time_bucket('1 month 1 day'::interval, '00:00:00'::time, '00:00:00'::time); +-- +ok +== +select time_bucket('3 days'::interval, '00:00:00'::time, '2000000000 months'::interval); +-- +ok +== +select time_bucket('3 days'::interval, '00:00:00'::time, '-2000000000 months'::interval); +-- +ok +== +select time_bucket('3 months'::interval, '00:00:00'::time, '2000000000 months'::interval); +-- +ok +== +select time_bucket('3 months'::interval, '00:00:00'::time, '-2000000000 months'::interval); +-- +ok +== +select time_bucket('1 microseconds'::interval, '23:59:59.999999'::time); +-- +ok +== +select time_bucket('1 microseconds'::interval, '00:00:00'::time); +-- +ok +== +select time_bucket('1 microseconds'::interval, '04:00:54.775807'::time); +-- +ok +== +select time_bucket('1 microseconds'::interval, '04:00:54.775806'::time); +-- +ok +== +select time_bucket('1 month 1 day'::interval, null::time); +-- +ok +== +select time_bucket('1 month 1 day'::interval, null::time, '6 days'::interval); +-- +ok +== +select time_bucket('1 month 1 day'::interval, null::time, '10:00:00'::time); +-- +ok +== +select time_bucket('-1 month'::interval, null::time); +-- +ok +== +select time_bucket('-1 month'::interval, null::time, '6 days'::interval); +-- +ok +== +select time_bucket('-1 month'::interval, '10:00:00'::time, null::interval); +-- +ok +== +select time_bucket('-1 month'::interval, null::time, '10:00:00'::time); +-- +ok +== +select time_bucket('-1 month'::interval, '2022-12-22'::time, null::time); +-- +ok +== diff --git a/parser/testdata/corpus/sql/function/timestamp/age.test b/parser/testdata/corpus/sql/function/timestamp/age.test new file mode 100644 index 0000000..5f317a6 --- /dev/null +++ b/parser/testdata/corpus/sql/function/timestamp/age.test @@ -0,0 +1,129 @@ +# source: test/sql/function/timestamp/age.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +SELECT AGE(TIMESTAMP '1957-06-13') t +-- +ok +== +SELECT AGE(TIMESTAMP '2001-04-10', TIMESTAMP '1957-06-13'); +-- +ok +== +SELECT age(TIMESTAMP '2014-04-25', TIMESTAMP '2014-04-17'); +-- +ok +== +SELECT age(TIMESTAMP '2014-04-25', TIMESTAMP '2014-01-01'); +-- +ok +== +SELECT age(TIMESTAMP '2019-06-11', TIMESTAMP '2019-06-11'); +-- +ok +== +SELECT age(TIMESTAMP '2019-06-11', TIMESTAMP '2019-06-11')::VARCHAR; +-- +ok +== + SELECT age(timestamp '2019-06-11 12:00:00', timestamp '2019-07-11 11:00:00'); +-- +ok +== +CREATE TABLE timestamp(t1 TIMESTAMP, t2 TIMESTAMP) +-- +ok +== +INSERT INTO timestamp VALUES('2001-04-10', '1957-06-13') +-- +ok +== +INSERT INTO timestamp VALUES('2014-04-25', '2014-04-17') +-- +ok +== +INSERT INTO timestamp VALUES('2014-04-25','2014-01-01') +-- +ok +== +INSERT INTO timestamp VALUES('2019-06-11', '2019-06-11') +-- +ok +== +INSERT INTO timestamp VALUES(NULL, '2019-06-11') +-- +ok +== +INSERT INTO timestamp VALUES('2019-06-11', NULL) +-- +ok +== +INSERT INTO timestamp VALUES(NULL, NULL) +-- +ok +== +SELECT AGE(t1, TIMESTAMP '1957-06-13') FROM timestamp; +-- +ok +== +SELECT AGE(TIMESTAMP '2001-04-10', t2) FROM timestamp; +-- +ok +== +SELECT AGE(t1, t2) FROM timestamp; +-- +ok +== +SELECT t1 - t2 FROM timestamp; +-- +ok +== +SELECT AGE(t1, t2) FROM timestamp WHERE t1 > '2001-12-12'; +-- +ok +== +SELECT AGE(NULL, NULL); +-- +ok +== +SELECT AGE(TIMESTAMP '1957-06-13', NULL); +-- +ok +== +SELECT AGE(NULL, TIMESTAMP '1957-06-13'); +-- +ok +== +SELECT INTERVAL '1' DAY < AGE(DATE '1900-06-13'); +-- +ok +== +SELECT AGE(DATE '1900-01-01', DATE '1950-01-01'); +-- +ok +== +select age(timestamp '1992-01-01 01:01:02.400', timestamp '1992-01-01 01:01:02.200'); +-- +ok +== +select age(timestamp '1992-01-01 01:01:02.200', timestamp '1992-01-01 01:01:02.400'); +-- +ok +== +select age(timestamp '1992-01-01 01:01:01.400', timestamp '1992-01-01 01:01:02.200'); +-- +ok +== +SELECT AGE('{lspecial}'::TIMESTAMP); +-- +ok +== +SELECT AGE('{lspecial}'::TIMESTAMP, '{rspecial}'::TIMESTAMP); +-- +ok +== +SELECT AGE('{rspecial}'::TIMESTAMP, '{lspecial}'::TIMESTAMP); +-- +ok +== diff --git a/parser/testdata/corpus/sql/function/timestamp/current_time.test b/parser/testdata/corpus/sql/function/timestamp/current_time.test new file mode 100644 index 0000000..78eed28 --- /dev/null +++ b/parser/testdata/corpus/sql/function/timestamp/current_time.test @@ -0,0 +1,53 @@ +# source: test/sql/function/timestamp/current_time.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +SET Calendar='gregorian'; +-- +ok +== +SELECT CAST(CURRENT_TIME AS STRING), CAST(CURRENT_DATE AS STRING), CAST(CURRENT_TIMESTAMP AS STRING), CAST(NOW() AS STRING) +-- +ok +== +SELECT typeof(CURRENT_TIME); +-- +ok +== +SELECT typeof(CURRENT_DATE); +-- +ok +== +SELECT typeof(CURRENT_TIMESTAMP); +-- +ok +== +SELECT typeof(get_current_time()); +-- +ok +== +SELECT typeof({func}()); +-- +error: Parser Error: syntax error at or near "}" +== +SELECT CURRENT_TIME AS TIME +-- +ok +== +SELECT CURRENT_TIME + interval (1) second AS TIME +-- +ok +== +SET TimeZone='Pacific/Honolulu'; +-- +ok +== +select current_timestamp; +-- +ok +== +select current_time; +-- +ok +== diff --git a/parser/testdata/corpus/sql/function/timestamp/current_timestamp.test b/parser/testdata/corpus/sql/function/timestamp/current_timestamp.test new file mode 100644 index 0000000..d17e361 --- /dev/null +++ b/parser/testdata/corpus/sql/function/timestamp/current_timestamp.test @@ -0,0 +1,27 @@ +# source: test/sql/function/timestamp/current_timestamp.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +SET TimeZone = 'America/Chihuahua'; +-- +ok +== +SELECT EXTRACT(MILLENNIUM FROM NOW()) +-- +ok +== +SELECT SUFFIX(CURRENT_TIMESTAMP::VARCHAR, '-06'); +-- +ok +== +SELECT SUFFIX({func}()::VARCHAR, '-06'); +-- +error: Parser Error: syntax error at or near "}" +== +select + current_timestamp - interval 1 {unit} = ago(interval 1 {unit}), + current_timestamp - interval 1 {unit} = ago('1 {unit}'); +-- +error: Parser Error: syntax error at or near "{" +== diff --git a/parser/testdata/corpus/sql/function/timestamp/epoch.test b/parser/testdata/corpus/sql/function/timestamp/epoch.test new file mode 100644 index 0000000..a40704c --- /dev/null +++ b/parser/testdata/corpus/sql/function/timestamp/epoch.test @@ -0,0 +1,37 @@ +# source: test/sql/function/timestamp/epoch.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +SELECT + make_timestamp(0) as epoch1, + make_timestamp(1574802684123 * 1000) as epoch2, + make_timestamp(-291044928000 * 1000) as epoch3, + make_timestamp(-291081600000 * 1000) as epoch4, + make_timestamp(-291081600001 * 1000) as epoch5, + make_timestamp(-290995201000 * 1000) as epoch6 +-- +ok +== +SELECT + make_timestamp_ms(0) as epoch1, + make_timestamp_ms(1574802684123) as epoch2, + make_timestamp_ms(-291044928000) as epoch3, + make_timestamp_ms(-291081600000) as epoch4, + make_timestamp_ms(-291081600001) as epoch5, + make_timestamp_ms(-290995201000) as epoch6 +-- +ok +== +SELECT to_timestamp(0), to_timestamp(1), to_timestamp(1574802684), to_timestamp(-1) +-- +ok +== +SELECT to_timestamp(1284352323.5); +-- +ok +== +SELECT to_timestamp(1284352323::DOUBLE * 100000000); +-- +ok +== diff --git a/parser/testdata/corpus/sql/function/timestamp/make_date.test b/parser/testdata/corpus/sql/function/timestamp/make_date.test new file mode 100644 index 0000000..200a2c0 --- /dev/null +++ b/parser/testdata/corpus/sql/function/timestamp/make_date.test @@ -0,0 +1,287 @@ +# source: test/sql/function/timestamp/make_date.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +CREATE TABLE IF NOT EXISTS dates (d date); +-- +ok +== +INSERT INTO dates VALUES + (NULL), + ('-99999-01-01'), + ('-1993-08-14'), + ('1992-01-01 (BC)'), + ('-1992-01-01'), + ('0044-03-15 (BC)'), + ('0000-01-01'), + ('0020-01-01'), + ('1992-01-01'), + ('1992-01-20'), + ('1992-02-01'), + ('1992-02-02'), + ('1992-02-12'), + ('1992-02-20'), + ('1992-03-03'), + ('1992-03-20'), + ('1992-04-20'), + ('1992-05-05'), + ('1992-05-20'), + ('1992-06-20'), + ('1992-07-20'), + ('1992-08-20'), + ('1992-09-20'), + ('1992-10-20'), + ('1992-11-20'), + ('1992-12-02'), + ('1992-12-20'), + ('1993-03-20'), + ('1993-03-03'), + ('1994-05-05'), + ('1993-08-14'), + ('2000-12-31'), + ('2000-02-12'), + ('2001-01-01'), + ('2007-01-01'), + ('2008-01-01'), + ('2008-01-02'), + ('2008-02-01'), + ('2020-08-09'), + ('2020-08-10'), + ('2020-09-27'), + ('99999-01-01') +-- +ok +== +SELECT d +FROM (SELECT d, make_date(year(d), month(d), day(d)) md FROM dates) tbl +WHERE md IS DISTINCT FROM d; +-- +ok +== +SELECT d +FROM (SELECT d, make_date(date_part(['year', 'month', 'day'], d)) md FROM dates) tbl +WHERE md IS DISTINCT FROM d; +-- +ok +== +SELECT md +FROM (SELECT make_date(NULL, month(d), day(d)) md FROM dates) t +WHERE md IS NOT NULL +-- +ok +== +SELECT md +FROM (SELECT make_date(year(d), NULL, day(d)) md FROM dates) t +WHERE md IS NOT NULL +-- +ok +== +SELECT md +FROM (SELECT make_date(year(d), month(d), NULL) md FROM dates) t +WHERE md IS NOT NULL +-- +ok +== +SELECT * +FROM dates +WHERE d <> make_date((d - date '1970-01-01')::INT) +-- +ok +== +SELECT + make_date(2021, 12, 30), + make_date(NULL, 12, 30), + make_date(2021, NULL, 30), + make_date(2021, 12, NULL) +; +-- +ok +== +CREATE TABLE timestamps(ts TIMESTAMP) +-- +ok +== +INSERT INTO timestamps VALUES + ('1001-03-15 (BC) 20:38:40'), + ('0044-03-15 (BC) 20:38:40'), + ('1962-07-31 12:20:48.123456'), + ('1969-01-01 01:03:20.45432'), + ('1992-01-01 01:01:01.400'), + ('1992-01-01 01:01:02.200'), + ('1992-01-01 01:01:02.400'), + ('1993-08-14 08:22:33.42'), + ('2001-04-20 14:42:11.0'), + ('2001-04-20 14:42:11.123'), + ('2004-01-31 12:00:00.000050'), + ('2004-01-31 12:00:00.050'), + ('2004-02-01 12:00:00.000050'), + ('2004-02-01 12:00:00.050'), + ('2004-02-29 13:05:47.123456'), + ('2008-01-01 00:00:01.5'), + ('2008-01-01 00:00:01.594'), + ('2008-01-01 00:00:01.794'), + ('2008-01-01 00:00:01.88926'), + ('2008-01-01 00:00:01.894'), + ('2008-01-01 00:00:01.98926'), + ('2008-01-01 00:00:01.99926'), + ('2008-01-01 00:00:11.1'), + ('2019-01-06 04:03:02.123456'), + ('2019-01-06 04:03:02.5'), + ('2020-01-01 00:00:01.88926'), + ('2020-12-31 21:25:58.745232'), + ('2021-04-15 14:55:17.915'), + ('2021-04-15 14:55:17.915000'), + ('2021-05-02 12:11:49.5'), + ('2021-12-01 13:54:48.123456'), + ('1993-08-14 08:22:33'), + (NULL) +; +-- +ok +== +SELECT ts, mts +FROM (SELECT ts, make_timestamp(year(ts), month(ts), day(ts), hour(ts), minute(ts), microsecond(ts) / 1000000.0) mts + FROM timestamps) t +WHERE mts IS DISTINCT FROM ts; +-- +ok +== +SELECT md +FROM ( + SELECT make_timestamp(NULL, month(ts), day(ts), hour(ts), minute(ts), microsecond(ts) / 1000000.0) md + FROM timestamps) t +WHERE md IS NOT NULL +-- +ok +== +SELECT md +FROM ( + SELECT make_timestamp(year(ts), NULL, day(ts), hour(ts), minute(ts), microsecond(ts) / 1000000.0) md + FROM timestamps) t +WHERE md IS NOT NULL +-- +ok +== +SELECT md +FROM ( + SELECT make_timestamp(year(ts), month(ts), NULL, hour(ts), minute(ts), microsecond(ts) / 1000000.0) md + FROM timestamps) t +WHERE md IS NOT NULL +-- +ok +== +SELECT md +FROM ( + SELECT make_timestamp(year(ts), month(ts), day(ts), NULL, minute(ts), microsecond(ts) / 1000000.0) md + FROM timestamps) t +WHERE md IS NOT NULL +-- +ok +== +SELECT md +FROM ( + SELECT make_timestamp(year(ts), month(ts), day(ts), hour(ts), NULL, microsecond(ts) / 1000000.0) md + FROM timestamps) t +WHERE md IS NOT NULL +-- +ok +== +SELECT md +FROM ( + SELECT make_timestamp(year(ts), month(ts), day(ts), hour(ts), minute(ts), NULL) md + FROM timestamps) t +WHERE md IS NOT NULL +-- +ok +== +SELECT + make_timestamp(2021, 12, 30, 12, 41, 46.123456), + make_timestamp(NULL, 12, 30, 12, 41, 46.123456), + make_timestamp(2021, NULL, 30, 12, 41, 46.123456), + make_timestamp(2021, 12, NULL, 12, 41, 46.123456), + make_timestamp(2021, 12, 30, NULL, 41, 46.123456), + make_timestamp(2021, 12, 30, 12, NULL, 46.123456), + make_timestamp(2021, 12, 30, 12, 41, NULL) +; +-- +ok +== +SELECT make_timestamp(0), make_timestamp(1684509234845000); +-- +ok +== +SELECT make_timestamp(9223372036854775807); -- Infinity +-- +ok +== +SELECT make_timestamp_ns(0), make_timestamp_ns(1684509234845000123); +-- +ok +== +SELECT make_timestamp_ns(9223372036854775806); +-- +ok +== +SELECT make_timestamp_ns(9223372036854775807); -- Infinity +-- +ok +== +INSERT INTO times VALUES + (NULL), + ('00:00:01'), + ('00:01:20'), + ('01:00:00'), + ('02:30:01'), + ('06:30:00'), + ('12:00:30.1234'), + ('12:20:48.123456'), + ('12:11:49.5'), + ('14:55:17.915000'), + ('21:15:22'), + ('20:08:10.001'), + ('20:08:10.33'), + ('20:08:10.998'), + ('21:25:58.745232') +; +-- +ok +== +SELECT t, mt +FROM (SELECT t, make_time(hour(t), minute(t), microsecond(t) / 1000000.0) mt + FROM times) tbl +WHERE mt IS DISTINCT FROM t; +-- +ok +== +SELECT md +FROM (SELECT make_time(NULL, minute(d), microsecond(d) / 1000000.0) md FROM dates) t +WHERE md IS NOT NULL +-- +ok +== +SELECT md +FROM (SELECT make_time(hour(d), NULL, microsecond(d) / 1000000.0) md FROM dates) t +WHERE md IS NOT NULL +-- +ok +== +SELECT md +FROM (SELECT make_time(hour(d), minute(d), NULL) md FROM dates) t +WHERE md IS NOT NULL +-- +ok +== +SELECT + make_time(12, 41, 46.123456), + make_time(NULL, 41, 46.123456), + make_time(12, NULL, 46.123456), + make_time(12, 41, NULL) +; +-- +ok +== +SELECT make_timestamp(294247, 1, 10, 4, 0, 54.775807); +-- +ok +== diff --git a/parser/testdata/corpus/sql/function/timestamp/test_date_diff_epoch.test b/parser/testdata/corpus/sql/function/timestamp/test_date_diff_epoch.test new file mode 100644 index 0000000..f5ebe23 --- /dev/null +++ b/parser/testdata/corpus/sql/function/timestamp/test_date_diff_epoch.test @@ -0,0 +1,60 @@ +# source: test/sql/function/timestamp/test_date_diff_epoch.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +SELECT + start_ts, + end_ts, + DATEDIFF('day', start_ts, end_ts) AS dd_hour +FROM VALUES ( + '1970-01-03 12:12:12'::TIMESTAMP, + '1969-12-25 05:05:05'::TIMESTAMP + ) x(start_ts, end_ts); +-- +ok +== +SELECT + start_ts, + end_ts, + DATEDIFF('hour', start_ts, end_ts) AS dd_hour +FROM VALUES ( + '1970-01-01 12:12:12'::TIMESTAMP, + '1969-12-31 05:05:05'::TIMESTAMP + ) x(start_ts, end_ts); +-- +ok +== +SELECT + start_ts, + end_ts, + DATEDIFF('minute', start_ts, end_ts) AS dd_minute +FROM VALUES ( + '1970-01-01 00:12:12'::TIMESTAMP, + '1969-12-31 23:05:05'::TIMESTAMP + ) x(start_ts, end_ts); +-- +ok +== +SELECT + start_ts, + end_ts, + DATEDIFF('second', start_ts, end_ts) AS dd_second +FROM VALUES ( + '1970-01-01 00:00:12.456'::TIMESTAMP, + '1969-12-31 23:59:05.123'::TIMESTAMP + ) x(start_ts, end_ts); +-- +ok +== +SELECT + start_ts, + end_ts, + DATEDIFF('millisecond', start_ts, end_ts) AS dd_second +FROM VALUES ( + '1970-01-01 00:00:12.456789'::TIMESTAMP, + '1969-12-31 23:59:05.123456'::TIMESTAMP + ) x(start_ts, end_ts); +-- +ok +== diff --git a/parser/testdata/corpus/sql/function/timestamp/test_date_part.test b/parser/testdata/corpus/sql/function/timestamp/test_date_part.test new file mode 100644 index 0000000..42d0e92 --- /dev/null +++ b/parser/testdata/corpus/sql/function/timestamp/test_date_part.test @@ -0,0 +1,280 @@ +# source: test/sql/function/timestamp/test_date_part.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +INSERT INTO timestamps VALUES + ('-infinity'), + ('1962-07-31 12:20:48.123456'), + ('1969-01-01 01:03:20.45432'), + ('1992-01-01 01:01:01.400'), + ('1992-01-01 01:01:02.200'), + ('1992-01-01 01:01:02.400'), + ('1993-08-14 08:22:33'), + ('1993-08-14 08:22:33.42'), + ('2001-04-20 14:42:11.0'), + ('2001-04-20 14:42:11.123'), + ('2004-01-31 12:00:00.000050'), + ('2004-01-31 12:00:00.050'), + ('2004-02-01 12:00:00.000050'), + ('2004-02-01 12:00:00.050'), + ('2004-02-29 13:05:47.123456'), + ('2008-01-01 00:00:01.5'), + ('2008-01-01 00:00:01.594'), + ('2008-01-01 00:00:01.794'), + ('2008-01-01 00:00:01.88926'), + ('2008-01-01 00:00:01.894'), + ('2008-01-01 00:00:01.98926'), + ('2008-01-01 00:00:01.99926'), + ('2008-01-01 00:00:11.1'), + ('2019-01-06 04:03:02.123456'), + ('2019-01-06 04:03:02.5'), + ('2020-01-01 00:00:01.88926'), + ('2020-12-31 21:25:58.745232'), + ('2021-04-15 14:55:17.915'), + ('2021-04-15 14:55:17.915000'), + ('2021-05-02 12:11:49.5'), + ('2021-12-01 13:54:48.123456'), + ('2022-01-01 00:00:41'), + ('infinity'), + (NULL) +-- +ok +== +CREATE TABLE millennia AS SELECT * FROM (VALUES + ('1001-03-15 (BC) 20:38:40'::TIMESTAMP), + ('0044-03-15 (BC) 20:38:40'::TIMESTAMP), + ('0998-02-16 20:38:40'::TIMESTAMP), + ('1998-02-16 20:38:40'::TIMESTAMP), + ('2001-02-16 20:38:40'::TIMESTAMP) +) tbl(ts); +-- +ok +== +SELECT ts, DATE_PART('millennium', ts) FROM millennia; +-- +ok +== +SELECT ts, DATE_PART('century', ts) FROM millennia; +-- +ok +== +SELECT DATE_PART('isoyear', ts), ts +FROM timestamps +ORDER BY 2; +-- +ok +== +SELECT DATE_PART('isoyear', ts), ts +FROM generate_series('2021-12-26'::TIMESTAMP, '2022-01-12'::TIMESTAMP, INTERVAL 1 DAY) tbl(ts); +-- +ok +== +SELECT DATE_PART('julian', ts), ts +FROM timestamps +ORDER BY 2; +-- +ok +== +SELECT ts, DATE_PART('{partcode}', ts) AS p, {partcode}(ts) AS f +FROM timestamps +WHERE p <> f +-- +error: Parser Error: syntax error at or near "}" +== +SELECT EXTRACT(EPOCH FROM {tstype} '1992-09-20 11:30:00.0'); +-- +error: Parser Error: syntax error at or near "}" +== +SELECT EXTRACT(JULIAN FROM {tstype} '1992-09-20 00:00:00.0'); +-- +error: Parser Error: syntax error at or near "}" +== +SELECT ts, DATE_PART('{partcode}', ts) AS p, DATE_PART(['{partcode}'], ts) AS s +FROM timestamps +WHERE p <> s['{partcode}']; +-- +ok +== +SELECT ts::DATE AS d, DATE_PART(['year', 'month', 'day'], ts) AS parts +FROM timestamps +ORDER BY 1; +-- +ok +== +SELECT ts::DATE AS d, DATE_PART(['year', 'month', 'day'], ts) AS parts +FROM millennia +ORDER BY 1; +-- +ok +== +SELECT ts::DATE AS d, DATE_PART(['era', 'millennium', 'century', 'decade', 'quarter'], ts) AS parts +FROM timestamps +ORDER BY 1; +-- +ok +== +SELECT ts::DATE AS d, DATE_PART(['era', 'millennium', 'century', 'decade', 'quarter'], ts) AS parts +FROM millennia +ORDER BY 1; +-- +ok +== +SELECT ts::DATE AS d, DATE_PART(['weekday', 'isodow','doy', 'julian'], ts) AS parts +FROM timestamps +ORDER BY ts; +-- +ok +== +SELECT DATE_PART(['weekday', 'isodow', 'doy', 'julian'], '2008-01-01 00:00:01.894'::TIMESTAMP) AS parts +-- +ok +== +SELECT ts::DATE AS d, DATE_PART(['weekday', 'isodow', 'doy', 'julian'], ts) AS parts +FROM millennia +ORDER BY 1; +-- +ok +== +SELECT ts::DATE AS d, DATE_PART(['isoyear', 'week', 'yearweek'], ts) AS parts +FROM timestamps +ORDER BY 1; +-- +ok +== +SELECT ts::DATE AS d, DATE_PART(['isoyear', 'week', 'yearweek'], ts) AS parts +FROM millennia +ORDER BY 1; +-- +ok +== +SELECT ts, DATE_PART(['hour', 'minute', 'microsecond'], ts) AS parts +FROM timestamps +ORDER BY 1; +-- +ok +== +SELECT ts, DATE_PART(['hour', 'minute', 'microsecond'], ts) AS parts +FROM millennia +ORDER BY 1; +-- +ok +== +SELECT ts, DATE_PART(['epoch', 'timezone', 'timezone_hour', 'timezone_minute'], ts) AS parts +FROM timestamps +ORDER BY 1; +-- +ok +== +SELECT ts, DATE_PART(['epoch', 'timezone', 'timezone_hour', 'timezone_minute'], ts) AS parts +FROM millennia +ORDER BY 1; +-- +ok +== +SELECT DATE_PART(['hour', 'minute', 'microsecond'], NULL::TIMESTAMP); +-- +ok +== +SELECT DATE_PART(['hour', 'minute', 'microsecond'], '1962-07-31 12:20:48.123456'::TIMESTAMP); +-- +ok +== +SELECT DATE_PART(['month', 'months', 'mon'], '1962-07-31 12:20:48.123456'::TIMESTAMP); +-- +ok +== +SELECT ts::DATE AS d, DATE_PART(['year', 'month', 'months'], ts) AS parts +FROM timestamps +ORDER BY 1; +-- +ok +== +SELECT ts, epoch_us(ts) FROM timestamps ORDER BY ALL; +-- +ok +== +SELECT ts::TIMESTAMPTZ, epoch_us(ts::TIMESTAMPTZ) FROM timestamps ORDER BY ALL; +-- +ok +== +SELECT ts, epoch_ms(ts) FROM timestamps ORDER BY ALL; +-- +ok +== +SELECT ts::TIMESTAMPTZ, epoch_ms(ts::TIMESTAMPTZ) FROM timestamps ORDER BY ALL; +-- +ok +== +SELECT ts, epoch_ns(ts) FROM timestamps ORDER BY ALL; +-- +ok +== +SELECT ts::TIMESTAMPTZ, epoch_ns(ts::TIMESTAMPTZ) FROM timestamps ORDER BY ALL; +-- +ok +== +SELECT ts, nanosecond(ts) FROM timestamps ORDER BY ALL; +-- +ok +== +SELECT ts::TIMESTAMPTZ, nanosecond(ts::TIMESTAMPTZ) FROM timestamps ORDER BY ALL; +-- +ok +== +SELECT nanosecond(t) +FROM VALUES + ('1992-01-01 12:03:27.123456789'::TIMESTAMP_NS), + ('1900-01-01 03:08:47.987654'::TIMESTAMP_NS), + (NULL::TIMESTAMP_NS), + ('2020-09-27 13:12:01'::TIMESTAMP_NS) + AS tbl(t); +-- +ok +== +SELECT ts, DATE_PART(['duck', 'month', 'day'], ts) AS parts +FROM timestamps +ORDER BY 1; +-- +ok +== +SELECT ts, DATE_PART(['year', 'month', 'day', 'year'], ts) AS parts +FROM timestamps +ORDER BY 1; +-- +ok +== +SELECT DATE_PART([], ts) FROM timestamps; +-- +ok +== +SELECT DATE_PART(['year', NULL, 'month'], ts) FROM timestamps; +-- +ok +== +WITH parts(p) AS (VALUES (['year', 'month', 'day']), (['hour', 'minute', 'microsecond'])) +SELECT DATE_PART(p, ts) FROM parts, timestamps; +-- +ok +== +select epoch_ns(make_timestamp_ns(1732118940123456789)) +-- +ok +== +select epoch_ns('{value}'::{type}) +-- +error: Parser Error: syntax error at or near "{" +== +CREATE TABLE parts(p VARCHAR); +-- +ok +== +INSERT INTO parts VALUES ('epoch'), ('julian'), ('year'); +-- +ok +== +SELECT p, date_part(p, TIMESTAMP '2023-05-15 10:00:00+00') +FROM parts; +-- +ok +== diff --git a/parser/testdata/corpus/sql/function/timestamp/test_extract.test b/parser/testdata/corpus/sql/function/timestamp/test_extract.test new file mode 100644 index 0000000..3480026 --- /dev/null +++ b/parser/testdata/corpus/sql/function/timestamp/test_extract.test @@ -0,0 +1,81 @@ +# source: test/sql/function/timestamp/test_extract.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +CREATE TABLE timestamps(i TIMESTAMP) +-- +ok +== +INSERT INTO timestamps VALUES ('1993-08-14 08:22:33'), (NULL) +-- +ok +== +SELECT EXTRACT(year FROM i) FROM timestamps +-- +ok +== +SELECT EXTRACT(month FROM i) FROM timestamps +-- +ok +== +SELECT EXTRACT(day FROM i) FROM timestamps +-- +ok +== +SELECT EXTRACT(week FROM i) FROM timestamps +-- +ok +== +SELECT EXTRACT(yearweek FROM i) FROM timestamps +-- +ok +== +SELECT EXTRACT(quarter FROM i) FROM timestamps +-- +ok +== +SELECT EXTRACT(decade FROM i) FROM timestamps +-- +ok +== +SELECT EXTRACT(century FROM i) FROM timestamps +-- +ok +== +SELECT EXTRACT(DOW FROM i) FROM timestamps +-- +ok +== +SELECT EXTRACT(DOY FROM i) FROM timestamps +-- +ok +== +SELECT EXTRACT(epoch FROM i) FROM timestamps +-- +ok +== +SELECT EXTRACT(ISODOW FROM i) FROM timestamps +-- +ok +== +SELECT EXTRACT(millennium FROM i) FROM timestamps +-- +ok +== +SELECT EXTRACT(second FROM i) FROM timestamps +-- +ok +== +SELECT EXTRACT(minute FROM i) FROM timestamps +-- +ok +== +SELECT EXTRACT(hour FROM i) FROM timestamps +-- +ok +== +SELECT EXTRACT(milliseconds FROM i) FROM timestamps +-- +ok +== diff --git a/parser/testdata/corpus/sql/function/timestamp/test_extract_ms.test b/parser/testdata/corpus/sql/function/timestamp/test_extract_ms.test new file mode 100644 index 0000000..5560116 --- /dev/null +++ b/parser/testdata/corpus/sql/function/timestamp/test_extract_ms.test @@ -0,0 +1,29 @@ +# source: test/sql/function/timestamp/test_extract_ms.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +CREATE TABLE timestamps(i TIMESTAMP); +-- +ok +== +INSERT INTO timestamps VALUES ('1993-08-14 08:22:33.42'), (NULL); +-- +ok +== +SELECT EXTRACT(second FROM i) FROM timestamps; +-- +ok +== +SELECT EXTRACT(minute FROM i) FROM timestamps; +-- +ok +== +SELECT EXTRACT(milliseconds FROM i) FROM timestamps; +-- +ok +== +SELECT EXTRACT(microseconds FROM i) FROM timestamps; +-- +ok +== diff --git a/parser/testdata/corpus/sql/function/timestamp/test_icu_age.test b/parser/testdata/corpus/sql/function/timestamp/test_icu_age.test new file mode 100644 index 0000000..a680cbc --- /dev/null +++ b/parser/testdata/corpus/sql/function/timestamp/test_icu_age.test @@ -0,0 +1,88 @@ +# source: test/sql/function/timestamp/test_icu_age.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +SELECT AGE(TIMESTAMPTZ '1957-06-13') t; +-- +ok +== +SELECT AGE(TIMESTAMP '2001-04-10 00:00:00-07', TIMESTAMP '1957-06-13 00:00:00-07'); +-- +ok +== +SELECT age(TIMESTAMP '2014-04-25 00:00:00-07', TIMESTAMP '2014-04-17 00:00:00-07'); +-- +ok +== +SELECT age(TIMESTAMPTZ '2014-04-25', TIMESTAMPTZ '2014-01-01'); +-- +ok +== +SELECT age(TIMESTAMPTZ '2019-06-11', TIMESTAMPTZ '2019-06-11'); +-- +ok +== +SELECT age(TIMESTAMPTZ '2019-06-11', TIMESTAMPTZ '2019-06-11')::VARCHAR; +-- +ok +== +SELECT age(TIMESTAMPTZ '2019-06-11 12:00:00-07', TIMESTAMPTZ '2019-07-11 11:00:00-07'); +-- +ok +== +CREATE TABLE timestamps(t1 TIMESTAMPTZ, t2 TIMESTAMPTZ); +-- +ok +== +INSERT INTO timestamps VALUES + ('2001-04-10', '1957-06-13'), + ('2014-04-25', '2014-04-17'), + ('2014-04-25','2014-01-01'), + ('2019-06-11', '2019-06-11'), + (NULL, '2019-06-11'), + ('2019-06-11', NULL), + (NULL, NULL) +-- +ok +== +SELECT AGE(t1, TIMESTAMPTZ '1957-06-13') FROM timestamps; +-- +ok +== +SELECT AGE(TIMESTAMPTZ '2001-04-10', t2) FROM timestamps; +-- +ok +== +SELECT AGE(t1, t2) FROM timestamps; +-- +ok +== +SELECT t1 - t2 FROM timestamps; +-- +ok +== +SELECT AGE(t1, t2) FROM timestamps WHERE t1 > '2001-12-12'; +-- +ok +== +SELECT AGE(TIMESTAMPTZ '1957-06-13', NULL); +-- +ok +== +SELECT AGE(NULL, TIMESTAMPTZ '1957-06-13'); +-- +ok +== +SELECT AGE(TIMESTAMPTZ '1992-01-01 01:01:02.400', TIMESTAMPTZ '1992-01-01 01:01:02.200'); +-- +ok +== +SELECT AGE(TIMESTAMPTZ '1992-01-01 01:01:02.200', TIMESTAMPTZ '1992-01-01 01:01:02.400'); +-- +ok +== +SELECT AGE(TIMESTAMPTZ '1992-01-01 01:01:01.400', TIMESTAMPTZ '1992-01-01 01:01:02.200'); +-- +ok +== diff --git a/parser/testdata/corpus/sql/function/timestamp/test_icu_dateadd.test b/parser/testdata/corpus/sql/function/timestamp/test_icu_dateadd.test new file mode 100644 index 0000000..d98941a --- /dev/null +++ b/parser/testdata/corpus/sql/function/timestamp/test_icu_dateadd.test @@ -0,0 +1,340 @@ +# source: test/sql/function/timestamp/test_icu_dateadd.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +SELECT '2021-12-01 13:54:48Z'::TIMESTAMPTZ + INTERVAL 1 DAY; +-- +ok +== +CREATE TABLE intervals AS SELECT iv FROM (VALUES + (INTERVAL 1 year), + (INTERVAL (-1) year), + (INTERVAL 1 month), + (INTERVAL (-1) month), + (INTERVAL 13 month), + (INTERVAL (-15) month), + (INTERVAL 1 day), + (INTERVAL (-1) day), + (INTERVAL 32 day), + (INTERVAL (-40) day), + (INTERVAL 1 hour), + (INTERVAL (-1) hour), + (INTERVAL 11 hour), + (INTERVAL (-14) hour), + (INTERVAL 1 minute), + (INTERVAL (-1) minute), + (INTERVAL 6 minute), + (INTERVAL (-72) minute), + (INTERVAL 1 second), + (INTERVAL (-1) second), + (INTERVAL 23 second), + (INTERVAL (-118) second), + (INTERVAL 1 millisecond), + (INTERVAL (-1) millisecond), + (INTERVAL 910 millisecond), + (INTERVAL (-150) millisecond), + (INTERVAL 1 microsecond), + (INTERVAL (-1) microsecond), + (INTERVAL 612 microsecond), + (INTERVAL (-485) microsecond) +) tbl(iv); +-- +ok +== +SELECT iv, '2021-12-01 13:54:48.123456Z'::TIMESTAMPTZ + iv FROM intervals; +-- +ok +== +select '1999-12-31 16:00:00-08'::timestamptz + interval 2400 hours +-- +ok +== +select 'epoch'::timestamptz + '9223372036854775000 microseconds'::interval +-- +ok +== +select 'epoch'::timestamptz + '9223372036854774999 microseconds'::interval +-- +ok +== +select 'epoch'::timestamptz + '-9223372022400001001 microseconds'::interval +-- +ok +== +select 'epoch'::timestamptz + '-9223372022400001000 microseconds'::interval +-- +ok +== +SELECT iv, iv + '2021-12-01 13:54:48.123456Z'::TIMESTAMPTZ FROM intervals; +-- +ok +== +select interval 2400 hours + '1999-12-31 16:00:00-08'::timestamptz +-- +ok +== +select '9223372036854775000 microseconds'::interval + 'epoch'::timestamptz +-- +ok +== +select '9223372036854774999 microseconds'::interval + 'epoch'::timestamptz +-- +ok +== +select '-9223372022400001001 microseconds'::interval + 'epoch'::timestamptz +-- +ok +== +select '-9223372022400001000 microseconds'::interval + 'epoch'::timestamptz +-- +ok +== +select 'infinity'::timestamptz + '1 microsecond'::interval +-- +ok +== +select '1 microsecond'::interval + 'infinity'::timestamptz +-- +ok +== +select '-infinity'::timestamptz + '1 microsecond'::interval +-- +ok +== +select '1 microsecond'::interval + '-infinity'::timestamptz +-- +ok +== +SELECT iv, '2021-12-01 13:54:48.123456Z'::TIMESTAMPTZ - iv FROM intervals; +-- +ok +== +select '2000-04-09 17:00:00-07'::timestamptz - interval 2400 hours +-- +ok +== +select 'epoch'::timestamptz - '9223372022400001001 microseconds'::interval +-- +ok +== +select 'epoch'::timestamptz - '9223372022400001000 microseconds'::interval +-- +ok +== +select 'infinity'::timestamptz - '1 day'::interval +-- +ok +== +select '-infinity'::timestamptz - '1 day'::interval +-- +ok +== +SELECT iv, '1962-07-31 12:20:48.123456Z'::TIMESTAMPTZ + iv FROM intervals; +-- +ok +== +CREATE TABLE limits AS SELECT ts, label FROM (VALUES + ('290309-12-22 (BC) 00:00:00Z'::TIMESTAMPTZ, 'tsmin'), + ('294247-01-10 04:00:54.775806Z'::TIMESTAMPTZ, 'tsmax') +) tbl(ts, label); +-- +ok +== +SELECT iv, ts + iv FROM limits, intervals +WHERE label = 'tsmin' + AND iv >= INTERVAL 0 SECONDS; +-- +ok +== +SELECT ts + (INTERVAL (-1) year) FROM limits WHERE label = 'tsmin'; +-- +ok +== +SELECT ts + (INTERVAL (-1) month) FROM limits WHERE label = 'tsmin'; +-- +ok +== +SELECT ts + (INTERVAL (-15) month) FROM limits WHERE label = 'tsmin'; +-- +ok +== +SELECT ts + (INTERVAL (-1) day) FROM limits WHERE label = 'tsmin'; +-- +ok +== +SELECT ts + (INTERVAL (-40) day) FROM limits WHERE label = 'tsmin'; +-- +ok +== +SELECT ts + (INTERVAL (-1) hour) FROM limits WHERE label = 'tsmin'; +-- +ok +== +SELECT ts + (INTERVAL (-14) hour) FROM limits WHERE label = 'tsmin'; +-- +ok +== +SELECT ts + (INTERVAL (-1) minute) FROM limits WHERE label = 'tsmin'; +-- +ok +== +SELECT ts + (INTERVAL (-72) minute) FROM limits WHERE label = 'tsmin'; +-- +ok +== +SELECT ts + (INTERVAL (-1) second) FROM limits WHERE label = 'tsmin'; +-- +ok +== +SELECT ts + (INTERVAL (-118) second) FROM limits WHERE label = 'tsmin'; +-- +ok +== +SELECT ts + (INTERVAL (-1) millisecond) FROM limits WHERE label = 'tsmin'; +-- +ok +== +SELECT ts + (INTERVAL (-150) millisecond) FROM limits WHERE label = 'tsmin'; +-- +ok +== +SELECT ts + (INTERVAL (-1) microsecond) FROM limits WHERE label = 'tsmin'; +-- +ok +== +SELECT ts + (INTERVAL (-485) microsecond) FROM limits WHERE label = 'tsmin'; +-- +ok +== +SELECT ts + INTERVAL (-150) millisecond FROM limits WHERE label = 'tsmin'; +-- +ok +== +SELECT ts + INTERVAL (-485) microsecond FROM limits WHERE label = 'tsmin'; +-- +ok +== +SELECT iv, ts + iv FROM limits, intervals +WHERE label = 'tsmax' + AND iv < (INTERVAL (-1) millisecond); +-- +ok +== +SELECT ts + (INTERVAL (-485) microsecond) FROM limits WHERE label = 'tsmax'; +-- +ok +== +SELECT ts + (INTERVAL (-1) microsecond) FROM limits WHERE label = 'tsmax'; +-- +ok +== +SELECT ts + (INTERVAL (-1) millisecond) FROM limits WHERE label = 'tsmax'; +-- +ok +== +SELECT ts + (INTERVAL 1 year) FROM limits WHERE label = 'tsmax'; +-- +ok +== +SELECT ts + (INTERVAL 1 month) FROM limits WHERE label = 'tsmax'; +-- +ok +== +SELECT ts + (INTERVAL 13 month) FROM limits WHERE label = 'tsmax'; +-- +ok +== +SELECT ts + (INTERVAL 1 day) FROM limits WHERE label = 'tsmax'; +-- +ok +== +SELECT ts + (INTERVAL 32 day) FROM limits WHERE label = 'tsmax'; +-- +ok +== +SELECT ts + (INTERVAL 1 hour) FROM limits WHERE label = 'tsmax'; +-- +ok +== +SELECT ts + (INTERVAL 11 hour) FROM limits WHERE label = 'tsmax'; +-- +ok +== +SELECT ts + (INTERVAL 1 minute) FROM limits WHERE label = 'tsmax'; +-- +ok +== +SELECT ts + (INTERVAL 6 minute) FROM limits WHERE label = 'tsmax'; +-- +ok +== +SELECT ts + (INTERVAL 1 second) FROM limits WHERE label = 'tsmax'; +-- +ok +== +SELECT ts + (INTERVAL 23 second) FROM limits WHERE label = 'tsmax'; +-- +ok +== +SELECT ts + (INTERVAL 1 millisecond) FROM limits WHERE label = 'tsmax'; +-- +ok +== +SELECT ts + (INTERVAL 910 millisecond) FROM limits WHERE label = 'tsmax'; +-- +ok +== +SELECT ts + (INTERVAL 1 microsecond) FROM limits WHERE label = 'tsmax'; +-- +ok +== +SELECT ts + (INTERVAL 612 microsecond) FROM limits WHERE label = 'tsmax'; +-- +ok +== +set timezone = 'Europe/London'; +-- +ok +== +CREATE TABLE london AS ( + SELECT * + FROM (VALUES + ('2000-10-29 03:00:00+00'::TIMESTAMPTZ, '2000-03-26 03:00:00+01'::TIMESTAMPTZ, '2000-01-03 00:00:00+00'::TIMESTAMPTZ) + ) tbl(dst2, dst1, origin) + ); +-- +ok +== +SELECT origin + (dst1 - origin) FROM london; +-- +ok +== +SELECT origin + (dst2 - origin) FROM london; +-- +ok +== +set timezone = 'Asia/Kolkata'; +-- +ok +== +select ('1920-12-12 01:02:02+05:30'::timestamptz + interval '-1 month 400 day')::timestamptz as r; +-- +ok +== +select ('1920-12-12 01:02:02+05:30'::timestamptz + interval '1 month -400 day')::timestamptz as r; +-- +ok +== +SELECT TIMESTAMPTZ 'Infinity' - TIMESTAMPTZ 'Infinity'; +-- +ok +== +SELECT TIMESTAMPTZ 'Infinity' - TIMESTAMPTZ '-Infinity'; +-- +ok +== +SELECT TIMESTAMPTZ 'Infinity' - TIMESTAMPTZ '2020-01-01'; +-- +ok +== diff --git a/parser/testdata/corpus/sql/function/timestamp/test_icu_datediff.test b/parser/testdata/corpus/sql/function/timestamp/test_icu_datediff.test new file mode 100644 index 0000000..d7a46d5 --- /dev/null +++ b/parser/testdata/corpus/sql/function/timestamp/test_icu_datediff.test @@ -0,0 +1,212 @@ +# source: test/sql/function/timestamp/test_icu_datediff.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +CREATE TABLE datetime1 AS +SELECT '2005-12-31 23:59:59.9999999-08'::TIMESTAMPTZ AS startdate, '2006-01-01 00:00:00.0000000-08'::TIMESTAMPTZ AS enddate; +-- +ok +== +SELECT DATEDIFF('{datepart}', startdate, enddate) FROM datetime1 +-- +ok +== +SELECT DATEDIFF('isoyear', '2022-01-01 00:00:00-08'::TIMESTAMPTZ, '2022-01-03 00:00:00-08'::TIMESTAMPTZ); +-- +ok +== +SELECT + date_diff('isoyear', '1-01-01 (BC)'::TIMESTAMPTZ, '1-01-01'::TIMESTAMPTZ), + date_diff('isoyear', '1-01-01'::TIMESTAMPTZ, '1-01-01 (BC)'::TIMESTAMPTZ), + date_diff('era', '1-01-01 (BC)'::TIMESTAMPTZ, '1-01-01'::TIMESTAMPTZ), + date_diff('era', '1-01-01'::TIMESTAMPTZ, '1-01-01 (BC)'::TIMESTAMPTZ); +-- +ok +== +SELECT + date_diff('era', '2000-01-01'::TIMESTAMPTZ, '2020-01-01'::TIMESTAMPTZ), + date_diff('era', '2020-01-01'::TIMESTAMPTZ, '2000-01-01'::TIMESTAMPTZ); +-- +ok +== +CREATE TEMP TABLE datetime_ns AS +SELECT '2005-12-31 23:59:59.999999999-08'::TIMESTAMPTZ_NS AS startdate, '2006-01-01 00:00:00.000000000-08'::TIMESTAMPTZ_NS AS enddate; +-- +ok +== +SELECT DATEDIFF('{datepart}', startdate, enddate) FROM datetime_ns +-- +ok +== +SELECT part, date_diff(part, startdate, enddate) +FROM datetime_ns, (VALUES ('era'), ('year'), ('month'), ('day'), ('hour')) parts(part) +-- +ok +== +SELECT + date_diff('microsecond', '1969-12-31 23:59:59.999999999+00'::TIMESTAMPTZ_NS, '1970-01-01 00:00:00.000000000+00'::TIMESTAMPTZ_NS), + date_diff('millisecond', '1969-12-31 23:59:59.999999999+00'::TIMESTAMPTZ_NS, '1970-01-01 00:00:00.000000000+00'::TIMESTAMPTZ_NS), + date_diff('second', '1969-12-31 23:59:59.999999999+00'::TIMESTAMPTZ_NS, '1970-01-01 00:00:00.000000000+00'::TIMESTAMPTZ_NS), + date_diff('microsecond', '1970-01-01 00:00:00.000000000+00'::TIMESTAMPTZ_NS, '1969-12-31 23:59:59.999999999+00'::TIMESTAMPTZ_NS), + date_diff('millisecond', '1970-01-01 00:00:00.000000000+00'::TIMESTAMPTZ_NS, '1969-12-31 23:59:59.999999999+00'::TIMESTAMPTZ_NS) +-- +ok +== +SELECT + date_diff('microsecond', '1970-01-01 00:00:00.000000001+00'::TIMESTAMPTZ_NS, '1970-01-01 00:00:00.000000999+00'::TIMESTAMPTZ_NS), + date_diff('microsecond', '1970-01-01 00:00:00.000000999+00'::TIMESTAMPTZ_NS, '1970-01-01 00:00:00.000001000+00'::TIMESTAMPTZ_NS), + date_diff('millisecond', '1970-01-01 00:00:00.000999999+00'::TIMESTAMPTZ_NS, '1970-01-01 00:00:00.001000000+00'::TIMESTAMPTZ_NS), + date_diff('second', '1970-01-01 00:00:00.999999999+00'::TIMESTAMPTZ_NS, '1970-01-01 00:00:01.000000001+00'::TIMESTAMPTZ_NS) +-- +ok +== +SELECT part, date_diff(part, '1970-01-01 00:00:00.999999999+00'::TIMESTAMPTZ_NS, '1970-01-01 00:00:01.000000001+00'::TIMESTAMPTZ_NS) +FROM (VALUES ('microsecond'), ('millisecond'), ('second')) parts(part) +-- +ok +== +SELECT DATEDIFF('day', 'infinity'::TIMESTAMPTZ_NS, enddate) FROM datetime_ns; +-- +ok +== +SELECT DATEDIFF('{specifier}', '{lspecial}'::TIMESTAMPTZ_NS, '{rspecial}'::TIMESTAMPTZ_NS); +-- +ok +== +SELECT DATEDIFF('{specifier}', '{rspecial}'::TIMESTAMPTZ_NS, '{lspecial}'::TIMESTAMPTZ_NS); +-- +ok +== +SELECT DATEDIFF('{datepart}', startdate, enddate) + DATEDIFF('{datepart}', enddate, startdate) FROM datetime_ns +-- +ok +== +SELECT DATEDIFF('{specifier}', '{lspecial}'::TIMESTAMPTZ, '{rspecial}'::TIMESTAMPTZ); +-- +ok +== +SELECT DATEDIFF('{specifier}', '{rspecial}'::TIMESTAMPTZ, '{lspecial}'::TIMESTAMPTZ); +-- +ok +== +SELECT DATEDIFF('{datepart}', startdate, enddate) + DATEDIFF('{datepart}', enddate, startdate) FROM datetime1 +-- +ok +== +SELECT DATEDIFF('{datepart}', startdate, startdate + INTERVAL 1 {datepart}) +FROM (SELECT '2021-07-30'::TIMESTAMP + INTERVAL (d) DAY AS startdate FROM range(0, 5) tbl(d)) days +-- +error: Parser Error: syntax error at or near "{" +== +SELECT *, DATE_DIFF('week', lo, hi) +FROM ( + SELECT (d - INTERVAL 9 HOUR)::TIMESTAMPTZ AS lo, (d + INTERVAL 7 HOUR)::TIMESTAMPTZ AS hi + FROM generate_series('2022-09-01'::DATE, '2022-09-12'::DATE, INTERVAL 1 DAY) tbl(d) +); +-- +ok +== +SELECT date_diff('week', '2015-10-06 04:22:11'::timestamptz, '2016-11-25 23:19:37'::timestamptz); +-- +ok +== +SELECT date_diff('week', '2015-10-06 04:22:11.000000001'::TIMESTAMPTZ_NS, '2016-11-25 23:19:37.000000001'::TIMESTAMPTZ_NS); +-- +ok +== +SELECT + date_diff('week', '2022-09-05 00:00:00.000000001-07'::TIMESTAMPTZ_NS, '2022-09-11 23:59:59.999999999-07'::TIMESTAMPTZ_NS), + date_diff('week', '2022-09-05 00:00:00.000000001-07'::TIMESTAMPTZ_NS, '2022-09-12 00:00:00.000000001-07'::TIMESTAMPTZ_NS); +-- +ok +== +set timezone='CET'; +-- +ok +== +CREATE TABLE issue9673(starttime TIMESTAMPTZ, recordtime TIMESTAMPTZ); +-- +ok +== +INSERT INTO issue9673 VALUES ('2022-10-30 02:17:00+02', '2022-10-30 02:00:21+01'); +-- +ok +== +INSERT INTO issue9673 VALUES ('2021-10-31 02:39:00+02', '2021-10-31 02:38:20+01'); +-- +ok +== +SELECT starttime, recordtime, date_diff('minute', starttime, recordtime) +FROM issue9673; +-- +ok +== +CREATE TEMP TABLE issue9673_ns(starttime TIMESTAMPTZ_NS, recordtime TIMESTAMPTZ_NS); +-- +ok +== +INSERT INTO issue9673_ns VALUES ('2022-10-30 02:17:00.000000001+02', '2022-10-30 02:00:21.000000001+01'); +-- +ok +== +INSERT INTO issue9673_ns VALUES ('2021-10-31 02:39:00.000000001+02', '2021-10-31 02:38:20.000000001+01'); +-- +ok +== +SELECT starttime, recordtime, date_diff('minute', starttime, recordtime) +FROM issue9673_ns; +-- +ok +== +SELECT + date_diff('minute', '2022-10-30 02:17:00.000000000+02'::TIMESTAMPTZ_NS, '2022-10-30 01:59:59.999999999+01'::TIMESTAMPTZ_NS), + date_diff('minute', '2022-10-30 02:17:00.000000000+02'::TIMESTAMPTZ_NS, '2022-10-30 02:00:00.000000001+01'::TIMESTAMPTZ_NS); +-- +ok +== +select date_diff('day', '2022-01-04 19:00:00'::timestamptz, '2024-03-01'::date) as c1; +-- +ok +== +SET TimeZone = 'UTC'; +-- +ok +== +CREATE TEMP TABLE era_boundaries(name VARCHAR, startdate TIMESTAMPTZ, enddate TIMESTAMPTZ); +-- +ok +== +INSERT INTO era_boundaries VALUES + ('coptic', '0283-08-29 12:00:00+00', '0284-08-29 12:00:00+00'), + ('roc', '1911-12-31 12:00:00+00', '1912-01-01 12:00:00+00'), + ('japanese', '1912-07-29 00:00:00+00', '2019-05-01 00:00:00+00'); +-- +ok +== +SET Calendar = '{calendar}'; +-- +ok +== +SELECT date_diff('era', startdate, enddate), date_diff('era', enddate, startdate) +FROM era_boundaries WHERE name = '{calendar}'; +-- +ok +== +SET TimeZone = 'Asia/Tokyo'; +-- +ok +== +SET Calendar = 'japanese'; +-- +ok +== +SELECT + date_diff('era', startdate, enddate), + date_diff('era', enddate, startdate), + date_diff('era', '1912-07-29 00:00:00+00'::TIMESTAMPTZ_NS, '2019-05-01 00:00:00+00'::TIMESTAMPTZ_NS), + date_diff('era', '2019-05-01 00:00:00+00'::TIMESTAMPTZ_NS, '1912-07-29 00:00:00+00'::TIMESTAMPTZ_NS) +FROM era_boundaries WHERE name = 'japanese'; +-- +ok +== diff --git a/parser/testdata/corpus/sql/function/timestamp/test_icu_datepart.test b/parser/testdata/corpus/sql/function/timestamp/test_icu_datepart.test new file mode 100644 index 0000000..a1d790e --- /dev/null +++ b/parser/testdata/corpus/sql/function/timestamp/test_icu_datepart.test @@ -0,0 +1,322 @@ +# source: test/sql/function/timestamp/test_icu_datepart.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +CREATE TABLE timestamps AS SELECT * FROM (VALUES + ('0044-03-13 (BC) 10:33:41.987654+01'::TIMESTAMPTZ, 'era'), + ('1962-07-31 12:20:48.123456+00'::TIMESTAMPTZ, 'epoch'), + ('2021-01-01 00:00:00+00'::TIMESTAMPTZ, 'year'), + ('2021-02-02 00:00:00+00'::TIMESTAMPTZ, 'month'), + ('2021-11-26 10:15:13.123456+00'::TIMESTAMPTZ, 'microsecond'), + ('2021-11-15 02:30:00-08'::TIMESTAMPTZ, 'hour'), + ('2021-11-15 02:30:00-07'::TIMESTAMPTZ, 'minute'), + ('2021-12-25 00:00:00+02'::TIMESTAMPTZ, 'day'), + ('infinity'::TIMESTAMPTZ, 'second'), + ('-infinity'::TIMESTAMPTZ, 'decade'), + (NULL::TIMESTAMPTZ, 'century'), +) tbl(ts, part); +-- +ok +== +SELECT year(ts), year(ts::TIMESTAMP) FROM timestamps; +-- +ok +== +SELECT month(ts), month(ts::TIMESTAMP) FROM timestamps; +-- +ok +== +SELECT day(ts), day(ts::TIMESTAMP) FROM timestamps; +-- +ok +== +SELECT decade(ts), decade(ts::TIMESTAMP) FROM timestamps; +-- +ok +== +SELECT century(ts), century(ts::TIMESTAMP) FROM timestamps; +-- +ok +== +SELECT millennium(ts), millennium(ts::TIMESTAMP) FROM timestamps; +-- +ok +== +SELECT microsecond(ts), microsecond(ts::TIMESTAMP) FROM timestamps; +-- +ok +== +SELECT millisecond(ts), millisecond(ts::TIMESTAMP) FROM timestamps; +-- +ok +== +SELECT second(ts), second(ts::TIMESTAMP) FROM timestamps; +-- +ok +== +SELECT minute(ts), minute(ts::TIMESTAMP) FROM timestamps; +-- +ok +== +SELECT hour(ts), hour(ts::TIMESTAMP) FROM timestamps; +-- +ok +== +SELECT dayofweek(ts), dayofweek(ts::TIMESTAMP) FROM timestamps; +-- +ok +== +SELECT isodow(ts), isodow(ts::TIMESTAMP) FROM timestamps; +-- +ok +== +SELECT date_part('isodow', ts), date_part('isodow', ts::timestamp) +FROM range('1992-01-06'::timestamptz, '1992-01-13'::timestamptz, interval 1 day) as t(ts); +-- +ok +== +SELECT date_part('dow', ts), date_part('dow', ts::timestamp) +FROM range('1992-01-05'::timestamptz, '1992-01-12'::timestamptz, interval 1 day) as t(ts); +-- +ok +== +SELECT week(ts), week(ts::TIMESTAMP) FROM timestamps; +-- +ok +== +SELECT dayofyear(ts), dayofyear(ts::TIMESTAMP) FROM timestamps; +-- +ok +== +SELECT quarter(ts), quarter(ts::TIMESTAMP) FROM timestamps; +-- +ok +== +SELECT yearweek(ts), yearweek(ts::TIMESTAMP) FROM timestamps; +-- +ok +== +SELECT isoyear(ts), isoyear(ts::TIMESTAMP) FROM timestamps; +-- +ok +== +SELECT epoch(ts), epoch(ts::TIMESTAMP) FROM timestamps; +-- +ok +== +SELECT date_part(part, ts), date_part(part, ts::TIMESTAMP), part +FROM timestamps +-- +ok +== +SELECT ERA(ts) FROM timestamps; +-- +ok +== +SELECT DATE_PART('era', ts) FROM timestamps; +-- +ok +== +SELECT DATE_PART('julian', '0044-03-15 (BC) 12:00:00'::TIMESTAMPTZ); +-- +ok +== +SELECT JULIAN(ts) FROM timestamps; +-- +ok +== +SELECT DATE_PART('julian', ts) FROM timestamps; +-- +ok +== +SELECT DATE_PART('timezone', ts) FROM timestamps; +-- +ok +== +SELECT DATE_PART('timezone_hour', ts) FROM timestamps; +-- +ok +== +SELECT DATE_PART('timezone_minute', ts) FROM timestamps; +-- +ok +== +SELECT DATE_PART('timezone', '2021-07-31 00:00:00-07'::TIMESTAMPTZ); +-- +ok +== +SELECT DATE_PART('timezone_hour', '2021-07-31 00:00:00-07'::TIMESTAMPTZ); +-- +ok +== +SELECT DATE_PART('timezone_minute', '2021-07-31 00:00:00-07'::TIMESTAMPTZ); +-- +ok +== +SELECT MAX(EXTRACT(YEAR FROM ts)) + , MAX(EXTRACT(MONTH FROM ts)) + , MAX(EXTRACT(DAY FROM ts)) + , MAX(EXTRACT(DECADE FROM ts)) + , MAX(EXTRACT(CENTURY FROM ts)) +FROM timestamps +-- +ok +== +SELECT dayofmonth(ts), dayofmonth(ts::TIMESTAMP) FROM timestamps; +-- +ok +== +SELECT weekday(ts), weekday(ts::TIMESTAMP) FROM timestamps; +-- +ok +== +SELECT weekofyear(ts), weekofyear(ts::TIMESTAMP) FROM timestamps; +-- +ok +== +SELECT * +FROM ( + SELECT ts, DATE_PART('{partcode}', ts) AS p, {partcode}(ts) AS f + FROM timestamps +) tbl +WHERE p IS DISTINCT FROM f +-- +error: Parser Error: syntax error at or near "}" +== +SELECT ts, DATE_PART('{partcode}', ts) AS pc, DATE_PART(['{partcode}'], ts) AS st +FROM timestamps +WHERE pc IS DISTINCT FROM st['{partcode}']; +-- +ok +== +SELECT DATE_PART(['era', 'year', 'month', 'day', 'julian'], ts), ts +FROM timestamps +ORDER BY 2 +-- +ok +== +SELECT DATE_PART(['hour', 'minute', 'microsecond'], ts), ts +FROM timestamps +ORDER BY 2 +-- +ok +== +SELECT DATE_PART(['millennium', 'century', 'decade', 'quarter'], ts), ts +FROM timestamps +ORDER BY 2 +-- +ok +== +SELECT DATE_PART(['weekday', 'isodow', 'doy'], ts), ts +FROM timestamps +ORDER BY 2 +-- +ok +== +SELECT DATE_PART(['isoyear', 'week', 'yearweek'], ts), ts +FROM timestamps +ORDER BY 2 +-- +ok +== +SELECT DATE_PART(['epoch', 'second', 'timezone', 'timezone_hour', 'timezone_minute'], ts), ts +FROM timestamps +ORDER BY 2 +-- +ok +== +SELECT ts, DATE_PART('{partcode}', ts) AS p, DATE_PART(['{partcode}'], ts) AS s +FROM timestamps +WHERE p IS DISTINCT FROM s['{partcode}']; +-- +ok +== +SELECT ts, DATE_PART(['year', 'month', 'day'], ts) AS parts +FROM timestamps +WHERE part = 'day' +ORDER BY 1; +-- +ok +== +SELECT DATE_PART(['duck', 'minute', 'microsecond', 'timezone'], ts), ts +FROM timestamps +ORDER BY 2 +-- +ok +== +SELECT DATE_PART(['era', 'year', 'month', 'era'], ts), ts +FROM timestamps +ORDER BY 2 +-- +ok +== +CREATE TABLE februaries AS +SELECT ts::TIMESTAMPTZ AS ts +FROM (VALUES + ('1900-02-12'), + ('1992-02-12'), + ('2000-02-12') +) tbl(ts); +-- +ok +== +SELECT ts, LAST_DAY(ts), LAST_DAY(ts::TIMESTAMP) FROM februaries; +-- +ok +== +SELECT ts, LAST_DAY(ts), LAST_DAY(ts::TIMESTAMP) FROM timestamps; +-- +ok +== +SELECT dayname(ts), monthname(ts) from timestamps; +-- +ok +== +SET TimeZone='Asia/Kathmandu'; +-- +ok +== +SELECT DATE_PART(['timezone', 'timezone_hour', 'timezone_minute'], '2021-12-22'::TIMESTAMPTZ); +-- +ok +== +SET TimeZone='Canada/Newfoundland'; +-- +ok +== +SET Calendar = 'hebrew'; +-- +ok +== +SELECT year(ts), month(ts), monthname(ts) +FROM range('5872-01-01'::TIMESTAMPTZ, '5873-01-01'::TIMESTAMPTZ, INTERVAL 1 DAY) tbl(ts) +GROUP BY ALL +ORDER BY ALL; +-- +ok +== +CREATE TABLE t1(c0 TIMESTAMPTZ); +-- +ok +== +INSERT INTO t1(c0) VALUES ('-infinity'), ('infinity'); +-- +ok +== +SELECT WEEKOFYEAR(c0), WEEKOFYEAR(c0) IS NULL, WEEKOFYEAR(c0) IS NOT NULL FROM t1; +-- +ok +== +SELECT WEEKDAY(c0), WEEKDAY(c0) IS NULL FROM t1; +-- +ok +== +SELECT DAYOFMONTH(c0), DAYOFMONTH(c0) IS NULL FROM t1; +-- +ok +== +SELECT EXTRACT(month FROM c0) IS NULL, EXTRACT(quarter FROM c0) IS NULL FROM t1; +-- +ok +== diff --git a/parser/testdata/corpus/sql/function/timestamp/test_icu_datesub.test b/parser/testdata/corpus/sql/function/timestamp/test_icu_datesub.test new file mode 100644 index 0000000..1541da3 --- /dev/null +++ b/parser/testdata/corpus/sql/function/timestamp/test_icu_datesub.test @@ -0,0 +1,238 @@ +# source: test/sql/function/timestamp/test_icu_datesub.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +select DATESUB('month', '2004-01-31 12:00:00-08'::TIMESTAMPTZ, '2004-02-29 13:00:00-08'::TIMESTAMPTZ); +-- +ok +== +select DATESUB('month', '2004-01-29 12:00:00-08'::TIMESTAMPTZ, '2004-02-29 13:00:00-08'::TIMESTAMPTZ); +-- +ok +== +select DATESUB('month', '2004-02-29 12:00:00-08'::TIMESTAMPTZ, '2004-03-31 13:00:00-08'::TIMESTAMPTZ); +-- +ok +== +select DATESUB('month', '2004-02-29 13:00:00-08'::TIMESTAMPTZ, '2004-03-31 12:00:00-08'::TIMESTAMPTZ); +-- +ok +== +select DATESUB('quarter', '2004-01-31 12:00:00-07'::TIMESTAMPTZ, '2004-04-30 13:00:00-07'::TIMESTAMPTZ); +-- +ok +== +select DATESUB('year', '2004-02-29 12:00:00-08'::TIMESTAMPTZ, '2005-02-28 13:00:00-08'::TIMESTAMPTZ); +-- +ok +== +select DATESUB('isoyear', '2004-02-29 12:00:00-08'::TIMESTAMPTZ, '2005-02-28 13:00:00-08'::TIMESTAMPTZ); +-- +ok +== +SELECT + date_sub('{datepart}', '1-01-01 (BC)'::TIMESTAMPTZ, '1-01-01'::TIMESTAMPTZ), + date_sub('{datepart}', '1-01-01'::TIMESTAMPTZ, '1-01-01 (BC)'::TIMESTAMPTZ); +-- +ok +== +SELECT + date_sub('year', '2-01-01 (BC)'::TIMESTAMPTZ, '2-01-01'::TIMESTAMPTZ), + date_sub('year', '2-01-01'::TIMESTAMPTZ, '2-01-01 (BC)'::TIMESTAMPTZ); +-- +ok +== +SELECT + date_sub('era', '2000-01-01'::TIMESTAMPTZ, '2020-01-01'::TIMESTAMPTZ), + date_sub('era', '2020-01-01'::TIMESTAMPTZ, '2000-01-01'::TIMESTAMPTZ); +-- +ok +== +select DATESUB('decade', '1994-02-28 12:00:00-08'::TIMESTAMPTZ, '2004-02-29 13:00:00-08'::TIMESTAMPTZ); +-- +ok +== +select DATESUB('century', '1904-02-29 12:00:00-08'::TIMESTAMPTZ, '2005-02-28 13:00:00-08'::TIMESTAMPTZ); +-- +ok +== +select DATESUB('month', '2004-01-31 13:00:00-08'::TIMESTAMPTZ, '2004-02-29 12:00:00-08'::TIMESTAMPTZ); +-- +ok +== +select DATESUB('month', '2004-01-29 13:00:00-08'::TIMESTAMPTZ, '2004-02-29 12:00:00-08'::TIMESTAMPTZ); +-- +ok +== +select DATESUB('quarter', '2004-01-31 13:00:00-08'::TIMESTAMPTZ, '2004-04-30 12:00:00-07'::TIMESTAMPTZ); +-- +ok +== +select DATESUB('year', '2004-02-29 13:00:00-08'::TIMESTAMPTZ, '2005-02-28 12:00:00-08'::TIMESTAMPTZ); +-- +ok +== +select DATESUB('isoyear', '2004-02-29 13:00:00-08'::TIMESTAMPTZ, '2005-02-28 12:00:00-08'::TIMESTAMPTZ); +-- +ok +== +select DATESUB('decade', '1992-02-29 13:00:00-08'::TIMESTAMPTZ, '2002-02-28 12:00:00-08'::TIMESTAMPTZ); +-- +ok +== +select DATESUB('century', '1904-02-29 13:00:00-08'::TIMESTAMPTZ, '2004-02-28 12:00:00-08'::TIMESTAMPTZ); +-- +ok +== +select DATESUB('millennium', '1004-02-29 11:00:00-08'::TIMESTAMPTZ, '2004-02-29 11:00:00-08'::TIMESTAMPTZ); +-- +ok +== +select DATESUB('{datepart}', '2004-01-31 12:00:00-08'::TIMESTAMPTZ, '2004-02-29 13:00:00-08'::TIMESTAMPTZ); +-- +ok +== +select DATESUB('{datepart}', '2004-01-31 13:00:00-08'::TIMESTAMPTZ, '2004-02-29 12:00:00-08'::TIMESTAMPTZ); +-- +ok +== +select DATESUB('{datepart}', '2004-01-31 12:00:00-08'::TIMESTAMPTZ, '2004-02-28 13:00:00-08'::TIMESTAMPTZ); +-- +ok +== +select DATESUB('{datepart}', '2004-01-31 13:00:00-08'::TIMESTAMPTZ, '2004-02-28 12:00:00-08'::TIMESTAMPTZ); +-- +ok +== +select DATESUB('hour', '2004-01-31 12:00:00-08'::TIMESTAMPTZ, '2004-02-01 13:05:00-08'::TIMESTAMPTZ); +-- +ok +== +select DATESUB('hour', '2004-01-31 12:00:00-08'::TIMESTAMPTZ, '2004-02-01 12:00:00-08'::TIMESTAMPTZ); +-- +ok +== +select DATESUB('hour', '2004-01-31 13:00:00-08'::TIMESTAMPTZ, '2004-02-01 12:05:00-08'::TIMESTAMPTZ); +-- +ok +== +select DATESUB('minute', '2004-01-31 12:00:00-08'::TIMESTAMPTZ, '2004-02-01 13:05:00-08'::TIMESTAMPTZ); +-- +ok +== +select DATESUB('minute', '2004-01-31 12:00:00-08'::TIMESTAMPTZ, '2004-02-01 12:00:00-08'::TIMESTAMPTZ); +-- +ok +== +select DATESUB('minute', '2004-01-31 13:00:00-08'::TIMESTAMPTZ, '2004-02-01 12:05:00-08'::TIMESTAMPTZ); +-- +ok +== +select DATESUB('second', '2004-01-31 12:00:00-08'::TIMESTAMPTZ, '2004-02-01 12:00:05-08'::TIMESTAMPTZ); +-- +ok +== +select DATESUB('second', '2004-01-31 12:00:00-08'::TIMESTAMPTZ, '2004-02-01 12:00:00-08'::TIMESTAMPTZ); +-- +ok +== +select DATESUB('second', '2004-01-31 12:00:05-08'::TIMESTAMPTZ, '2004-02-01 12:00:00-08'::TIMESTAMPTZ); +-- +ok +== +select DATESUB('millisecond', '2004-01-31 12:00:00-08'::TIMESTAMPTZ, '2004-02-01 12:00:00.050-08'::TIMESTAMPTZ); +-- +ok +== +select DATESUB('millisecond', '2004-01-31 12:00:00-08'::TIMESTAMPTZ, '2004-02-01 12:00:00-08'::TIMESTAMPTZ); +-- +ok +== +select DATESUB('millisecond', '2004-01-31 12:00:00.050-08'::TIMESTAMPTZ, '2004-02-01 12:00:00-08'::TIMESTAMPTZ); +-- +ok +== +select DATESUB('microsecond', '2004-01-31 12:00:00-08'::TIMESTAMPTZ, '2004-02-01 12:00:00.000050-08'::TIMESTAMPTZ); +-- +ok +== +select DATESUB('microsecond', '2004-01-31 12:00:00-08'::TIMESTAMPTZ, '2004-02-01 12:00:00-08'::TIMESTAMPTZ); +-- +ok +== +select DATESUB('microsecond', '2004-01-31 12:00:00.000050-08'::TIMESTAMPTZ, '2004-02-01 12:00:00-08'::TIMESTAMPTZ); +-- +ok +== +SELECT DATESUB('{specifier}', '{lspecial}'::TIMESTAMPTZ, '{rspecial}'::TIMESTAMPTZ); +-- +ok +== +SELECT DATESUB('{specifier}', '{rspecial}'::TIMESTAMPTZ, '{lspecial}'::TIMESTAMPTZ); +-- +ok +== +CREATE TABLE datetime1 AS +SELECT '2004-01-31 12:00:00-08'::TIMESTAMPTZ AS startdate, '2004-02-29 13:05:00-08'::TIMESTAMPTZ AS enddate; +-- +ok +== +CREATE TABLE dateparts AS SELECT datepart FROM (VALUES + ('year'), + ('quarter'), + ('month'), + ('day'), + ('dayofyear'), + ('hour'), + ('minute'), + ('second'), + ('millisecond'), + ('microsecond'), + ('decade'), + ('century'), + ('millennium'), + ('week'), + ('yearweek'), + ('isoyear') +) tbl(datepart) +-- +ok +== +SELECT DATESUB(datepart, startdate, enddate) + DATESUB(datepart, enddate, startdate), datepart +FROM datetime1, dateparts +-- +ok +== +SELECT DATESUB('{datepart}', startdate, startdate + INTERVAL 1 {datepart}) +FROM ( + SELECT '2021-07-30 00:00:00-07'::TIMESTAMPTZ + INTERVAL (d) DAY AS startdate + FROM range(0, 5) tbl(d) + ) days +-- +error: Parser Error: syntax error at or near "{" +== +CREATE TEMP TABLE era_subtraction(name VARCHAR, startdate TIMESTAMPTZ, enddate TIMESTAMPTZ); +-- +ok +== +INSERT INTO era_subtraction VALUES + ('coptic', '0283-08-30 12:00:00+00', '0284-08-29 12:00:00+00'), + ('japanese', '1872-10-01 12:00:00+00', '2023-10-01 12:00:00+00'); +-- +ok +== +SET Calendar = 'coptic'; +-- +ok +== +SELECT date_sub('era', startdate, enddate), date_sub('era', enddate, startdate) +FROM era_subtraction WHERE name = 'coptic'; +-- +ok +== +SELECT date_sub('era', startdate, enddate), date_sub('era', enddate, startdate) +FROM era_subtraction WHERE name = 'japanese'; +-- +ok +== diff --git a/parser/testdata/corpus/sql/function/timestamp/test_icu_datetrunc.test b/parser/testdata/corpus/sql/function/timestamp/test_icu_datetrunc.test new file mode 100644 index 0000000..7a1977a --- /dev/null +++ b/parser/testdata/corpus/sql/function/timestamp/test_icu_datetrunc.test @@ -0,0 +1,135 @@ +# source: test/sql/function/timestamp/test_icu_datetrunc.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +CREATE TABLE timestamps(d TIMESTAMPTZ, s VARCHAR); +-- +ok +== +INSERT INTO timestamps VALUES + ('-infinity', 'year'), + ('1992-02-02 02:02:03.123456-08', 'millennium'), + ('1992-02-02 02:02:03.123456-08', 'century'), + ('1992-02-02 02:02:03.123456-08', 'decade'), + ('1992-02-02 02:02:03.123456-08', 'year'), + ('1992-02-02 02:02:03.123456-08', 'quarter'), + ('1992-02-02 02:02:03.123456-08', 'month'), + ('1992-02-02 02:02:03.123456-08', 'week'), + ('1992-02-02 02:02:03.123456-08', 'day'), + ('1992-02-02 02:02:03.123456-08', 'hour'), + ('1992-02-02 02:02:03.123456-08', 'minute'), + ('1992-02-02 02:02:03.123456-08', 'second'), + ('1992-02-02 02:02:03.123456-08', 'milliseconds'), + ('1992-02-02 02:02:03.123456-08', 'microseconds'), + ('infinity', 'month'), +; +-- +ok +== +SELECT date_trunc(NULL::VARCHAR, NULL::TIMESTAMPTZ) FROM timestamps LIMIT 3; +-- +ok +== +SELECT date_trunc(s, NULL::TIMESTAMPTZ) FROM timestamps LIMIT 3; +-- +ok +== +SELECT date_trunc('minute', TIMESTAMPTZ '1992-02-02 04:03:02Z') FROM timestamps LIMIT 1; +-- +ok +== +SELECT date_trunc(s, d), s FROM timestamps; +-- +ok +== +SELECT datetrunc(s, d), s FROM timestamps; +-- +ok +== +SELECT date_trunc('week', TIMESTAMPTZ '2019-01-06 04:03:02-08') FROM timestamps LIMIT 1; +-- +ok +== +SELECT date_trunc('yearweek', TIMESTAMPTZ '2019-01-06 04:03:02-08') FROM timestamps LIMIT 1; +-- +ok +== +SELECT date_trunc('week', TIMESTAMPTZ '2020-01-01 04:03:02-08') FROM timestamps LIMIT 1; +-- +ok +== +SELECT date_trunc('yearweek', TIMESTAMPTZ '2020-01-01 04:03:02-08') FROM timestamps LIMIT 1; +-- +ok +== +SELECT date_trunc('quarter', TIMESTAMPTZ '2020-12-02 04:03:02-08') FROM timestamps LIMIT 1; +-- +ok +== +SELECT date_trunc('quarter', TIMESTAMPTZ '2019-01-06 04:03:02-08') FROM timestamps LIMIT 1; +-- +ok +== +SELECT date_trunc('millennium', TIMESTAMPTZ '1996-01-06 04:03:02-08') FROM timestamps LIMIT 1; +-- +ok +== +SELECT date_trunc('century', TIMESTAMPTZ '2019-01-06 04:03:02-08') FROM timestamps LIMIT 1; +-- +ok +== +SELECT date_trunc('decade', TIMESTAMPTZ '2019-01-06 04:03:02-08') FROM timestamps LIMIT 1; +-- +ok +== +SELECT date_trunc('year', TIMESTAMPTZ '2019-01-06 04:03:02-08') FROM timestamps LIMIT 1; +-- +ok +== +SELECT date_trunc('day', TIMESTAMPTZ '2019-01-06 04:03:02-08') FROM timestamps LIMIT 1; +-- +ok +== +SELECT date_trunc('hour', TIMESTAMPTZ '2019-01-06 04:03:02-08') FROM timestamps LIMIT 1; +-- +ok +== +SELECT date_trunc('milliseconds', TIMESTAMPTZ '2019-01-06 04:03:02.123456-08') FROM timestamps LIMIT 1; +-- +ok +== +SELECT date_trunc('microseconds', TIMESTAMPTZ '2019-01-06 04:03:02.123456-08'); +-- +ok +== +SELECT date_trunc('epoch', TIMESTAMPTZ '2019-01-06 04:03:02.5-08') FROM timestamps LIMIT 1; +-- +ok +== +SELECT d, date_trunc('{daypart}', d) +FROM (SELECT DISTINCT d FROM timestamps) tbl(d); +-- +ok +== +SELECT ts, DATE_TRUNC('isoyear', ts::TIMESTAMPTZ) +FROM generate_series('2000-01-01 08:00:00'::TIMESTAMP, '2023-01-01 08:00:00'::TIMESTAMP, INTERVAL 1 YEAR) tbl(ts); +-- +ok +== +SELECT date_trunc('duck', TIMESTAMPTZ '2019-01-06 04:03:02-08') FROM timestamps LIMIT 1; +-- +ok +== +select date_trunc('minute', '2022-10-30 02:17:00+02'::TIMESTAMPTZ); +-- +ok +== +set time zone 'UTC'; +-- +ok +== +select date_trunc('day', '2024-05-06 16:09:28+05:00'::timestamptz) >= '2024-05-06 17:19:18+05:20'::date as r +-- +ok +== diff --git a/parser/testdata/corpus/sql/function/timestamp/test_icu_makedate.test b/parser/testdata/corpus/sql/function/timestamp/test_icu_makedate.test new file mode 100644 index 0000000..a8a16a8 --- /dev/null +++ b/parser/testdata/corpus/sql/function/timestamp/test_icu_makedate.test @@ -0,0 +1,203 @@ +# source: test/sql/function/timestamp/test_icu_makedate.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +CREATE TABLE timestamps(ts TIMESTAMPTZ) +-- +ok +== +INSERT INTO timestamps VALUES + ('1001-03-15 (BC) 20:38:40+00'), + ('0044-03-15 (BC) 20:38:40+00'), + ('1962-07-31 12:20:48.123456+00'), + ('1969-01-01 01:03:20.45432+00'), + ('1992-01-01 01:01:01.400+00'), + ('1992-01-01 01:01:02.200+00'), + ('1992-01-01 01:01:02.400+00'), + ('1993-08-14 08:22:33+00'), + ('1993-08-14 08:22:33.42+00'), + ('2001-04-20 14:42:11.0+00'), + ('2001-04-20 14:42:11.123+00'), + ('2004-01-31 12:00:00.000050+00'), + ('2004-01-31 12:00:00.050+00'), + ('2004-02-01 12:00:00.000050+00'), + ('2004-02-01 12:00:00.050+00'), + ('2004-02-29 13:05:47.123456+00'), + ('2008-01-01 00:00:01.5+00'), + ('2008-01-01 00:00:01.594+00'), + ('2008-01-01 00:00:01.794+00'), + ('2008-01-01 00:00:01.88926+00'), + ('2008-01-01 00:00:01.894+00'), + ('2008-01-01 00:00:01.98926+00'), + ('2008-01-01 00:00:01.99926+00'), + ('2008-01-01 00:00:11.1+00'), + ('2019-01-06 04:03:02.123456+00'), + ('2019-01-06 04:03:02.5+00'), + ('2020-01-01 00:00:01.88926+00'), + ('2020-12-31 21:25:58.745232+00'), + ('2021-04-15 14:55:17.915+00'), + ('2021-04-15 14:55:17.915000+00'), + ('2021-05-02 12:11:49.5+00'), + ('2021-12-01 13:54:48.123456+00'), + (NULL) +; +-- +ok +== +SELECT era(ts), year(ts), ts FROM timestamps; +-- +ok +== +CREATE MACRO yeartz(ts) AS year(ts::TIMESTAMPTZ) * (CASE WHEN ERA(ts::TIMESTAMPTZ) > 0 THEN 1 ELSE -1 END); +-- +ok +== +SELECT ts, mts +FROM (SELECT ts, make_timestamptz(yeartz(ts), month(ts), day(ts), hour(ts), minute(ts), microsecond(ts) / 1000000.0) mts + FROM timestamps) t +WHERE mts IS DISTINCT FROM ts +ORDER BY 1; +-- +ok +== +SELECT ts, mts +FROM (SELECT ts, make_timestamptz(yeartz(ts), NULL, day(ts), hour(ts), minute(ts), microsecond(ts) / 1000000.0) mts + FROM timestamps) t +WHERE mts IS NOT NULL; +-- +ok +== +SELECT make_timestamptz(2021, 13, 1, 0, 0, 0) mts +-- +ok +== +SELECT make_timestamptz(2021, -1, 1, 0, 0, 0) mts +-- +ok +== +SELECT make_timestamptz(0), make_timestamptz(1684509234845000); +-- +ok +== +SELECT make_timestamptz(2021, 12, 30, 10, 12, 4.123, 'America/New_York'); +-- +ok +== +SELECT make_timestamptz(NULL, 12, 30, 10, 12, 4.123, 'America/New_York'); +-- +ok +== +SELECT make_timestamptz(2021, NULL, 30, 10, 12, 4.123, 'America/New_York'); +-- +ok +== +SELECT make_timestamptz(2021, 12, NULL, 10, 12, 4.123, 'America/New_York'); +-- +ok +== +SELECT make_timestamptz(2021, 12, 30, NULL, 12, 4.123, 'America/New_York'); +-- +ok +== +SELECT make_timestamptz(2021, 12, 30, 10, NULL, 4.123, 'America/New_York'); +-- +ok +== +SELECT make_timestamptz(2021, 12, 30, 10, 12, NULL, 'America/New_York'); +-- +ok +== +SELECT make_timestamptz(2021, 12, 30, 10, 12, 4.123, NULL); +-- +ok +== +CREATE TABLE timezones AS (SELECT mm, tz FROM (VALUES + (1, 'America/New_York'), + (2, 'America/Los_Angeles'), + (3, 'Europe/Rome'), + (4, 'Asia/Kathmandu'), + (5, 'Canada/Newfoundland'), + (7, 'Pacific/Auckland'), + (8, 'Asia/Hong_Kong'), + (12, 'US/Hawaii') + ) tbl(mm, tz) +); +-- +ok +== +CREATE TABLE timeparts AS ( + SELECT ts, + yeartz(ts) yyyy, + month(ts) mm, + day(ts) dd, + hour(ts) hr, + minute(ts) mn, + microsecond(ts) / 1000000.0 as ss, + tz + FROM timestamps t + LEFT JOIN timezones z ON (month(t.ts) = z.mm) + ORDER BY ts +); +-- +ok +== +SELECT * FROM timeparts; +-- +ok +== +SELECT ts, make_timestamptz(yyyy, mm, dd, hr, mn, ss, 'America/New_York'), make_timestamptz(yyyy, mm, dd, hr, mn, ss) +FROM timeparts; +-- +ok +== +SELECT ts, make_timestamptz(yyyy, NULL, dd, hr, mn, ss, tz) mts +FROM timeparts +WHERE mts IS NOT NULL; +-- +ok +== +SELECT ts, make_timestamptz(yyyy, mm, dd, hr, mn, ss, NULL) mts +FROM timeparts +WHERE mts IS NOT NULL; +-- +ok +== +SELECT tz, ts, make_timestamptz(yyyy, mm, dd, hr, mn, ss, tz) +FROM timeparts; +-- +ok +== +SELECT ts, make_timestamptz(yyyy, mm, dd, hr, mn, ss, 'Europe/Duck') mts +FROM timeparts; +-- +ok +== +SELECT ts, ts::DATE FROM timeparts +-- +ok +== +WITH all_types AS ( + select * exclude(small_enum, medium_enum, large_enum) + from test_all_types() +) +SELECT make_timestamptz( + CAST(century(CAST(a."interval" AS INTERVAL)) AS BIGINT), + CAST(a."bigint" AS BIGINT), + CAST(a."bigint" AS BIGINT), + CAST(a."bigint" AS BIGINT), + CAST(a."bigint" AS BIGINT), + CAST(txid_current() AS BIGINT), + 'UTC') +FROM all_types a; +-- +ok +== +SELECT make_timestamptz(9223372036854775807); -- Infinity +-- +ok +== +SELECT make_timestamptz(294248, 1, 10, 4, 0, 54.775807); +-- +ok +== diff --git a/parser/testdata/corpus/sql/function/timestamp/test_icu_strftime.test b/parser/testdata/corpus/sql/function/timestamp/test_icu_strftime.test new file mode 100644 index 0000000..cacbf65 --- /dev/null +++ b/parser/testdata/corpus/sql/function/timestamp/test_icu_strftime.test @@ -0,0 +1,128 @@ +# source: test/sql/function/timestamp/test_icu_strftime.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +CREATE TABLE timestamps AS SELECT ts::TIMESTAMPTZ AS ts FROM (VALUES + ('-infinity'), + ('0044-03-13 (BC) 10:33:41.987654+01'), + ('1962-07-31 12:20:48.123456+00'), + ('epoch'), + ('2021-01-01 00:00:00+00'), + ('2021-02-02 00:00:00+00'), + ('2021-11-26 10:15:13.123456+00'), + ('2021-11-15 02:30:00-08'), + ('2021-11-15 02:30:00-07'), + ('2021-12-25 00:00:00+02'), + ('infinity'), + (NULL), +) tbl(ts); +-- +ok +== +SELECT ts::VARCHAR FROM timestamps; +-- +ok +== +SELECT ts, strftime(ts, '%Y-%m-%d %H:%M:%S.%f %Z') FROM timestamps; +-- +ok +== +SELECT ts, strftime(ts, '%Z %Y-%m-%d %H:%M:%S.%f') FROM timestamps; +-- +ok +== +CREATE TABLE formats (f VARCHAR); +-- +ok +== +INSERT INTO formats VALUES + ('%Y-%m-%d %H:%M:%S.%f %Z'), + ('%Y-%m-%d %H:%M:%S.%f'), + ('%Y'), + ('(%Y)'), + ('%% %Y %%'), + ('%%%%%% %Y %%%%%%'), + ('%d/%m/%Y'), + ('%Y %Y %Y %Y'), + ('%d/%m/%Y'), + ('hello world'), + ('%g'), + ('%a'), + ('%A'), + ('%w'), + ('%d'), + ('%-d'), + ('%b'), + ('%h'), + ('%B'), + ('%m'), + ('%-m'), + ('%y'), + ('%-y'), + ('%-y'), + ('%Y'), + ('%H'), + ('%-H'), + ('%I'), + ('%-I'), + ('%p'), + ('%M'), + ('%-M'), + ('%S'), + ('%-S'), + ('%f'), + ('%z'), + ('%Z'), + ('%j'), + ('%-j'), + ('%U'), + ('%W'), + ('%c'), + ('XX%cXX'), + ('%x'), + ('%X'), + ('XX%cXX%xXX%XXX'), + ('%Y'), + ('%Y'), + ('%y'), + ('%y'), + ('%V'), + ('%G'), + ('%u'), + (NULL), +; +-- +ok +== +SELECT strftime('2022-04-07 18:12:15.123456+00'::TIMESTAMPTZ, f) +FROM formats +-- +ok +== +SELECT ts, strftime(ts, '%Y-%m-%d %H:%M:%S.%f %z') FROM timestamps; +-- +ok +== +SELECT ts, strftime(ts, '%C') FROM timestamps; +-- +ok +== +PRAGMA TIMEZONE='Asia/Baghdad'; +SELECT strftime(TIMESTAMPTZ '-268535-1-1 0:0:0 America/Pangnirtung','%Z'); +-- +ok +== +PRAGMA TIMEZONE='Pacific/Truk'; +SELECT strftime(TIMESTAMPTZ '-217208-11-5 1:47:22 America/Merida','%Z'); +-- +ok +== +SELECT strftime(TIMESTAMPTZ '-204873-8-9 6:35:55 America/North_Dakota/Beulah','x%Z'); +-- +ok +== +SELECT strftime(TIMESTAMPTZ '292555-4-29 18:38:18 Asia/Damascus','e%Z'); +-- +ok +== diff --git a/parser/testdata/corpus/sql/function/timestamp/test_icu_strptime.test b/parser/testdata/corpus/sql/function/timestamp/test_icu_strptime.test new file mode 100644 index 0000000..41800d2 --- /dev/null +++ b/parser/testdata/corpus/sql/function/timestamp/test_icu_strptime.test @@ -0,0 +1,290 @@ +# source: test/sql/function/timestamp/test_icu_strptime.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +select strptime('2022-03-05 17:59:17.877 CST', '%Y-%m-%d %H:%M:%S.%g %Z'); +-- +ok +== +select strptime('2022-03-05 17:59:17.877 CST', NULL); +-- +ok +== +select strptime(NULL, '%Y-%m-%d %H:%M:%S.%g %Z'); +-- +ok +== +select strptime('2022-03-05 17:59:17.123456 CST', '%Y-%m-%d %H:%M:%S.%f %Z'); +-- +ok +== +select strptime('2022-03-05 17:59:17.123456789 CST', '%Y-%m-%d %H:%M:%S.%n %Z'); +-- +ok +== +select {func}('infinity', '%Y-%m-%d %H:%M:%S.%g %Z'); +-- +error: Parser Error: syntax error at or near "}" +== +select {func}('-infinity', '%Y-%m-%d %H:%M:%S.%g %Z'); +-- +error: Parser Error: syntax error at or near "}" +== +select {func}('epoch', '%Y-%m-%d %H:%M:%S.%g %Z'); +-- +error: Parser Error: syntax error at or near "}" +== +select '1582-01-01 10:33:41+01'::timestamptz +-- +ok +== +select '1582-06-01 10:40:43+01'::timestamptz +-- +ok +== +select '0044-03-13 (BC) 10:33:41+01'::timestamptz +-- +ok +== +SELECT '1582-10-10'::TIMESTAMPTZ AS ts; +-- +ok +== +CREATE TABLE zones AS ( + FROM (VALUES + ('Etc/GMT-14'), + ('NZ-CHAT'), + ('Pacific/Auckland'), + ('Pacific/Enderbury'), + ('Australia/LHI'), + ('Australia/Melbourne'), + ('Pacific/Efate'), + ('Australia/Darwin'), + ('Asia/Tokyo'), + ('Australia/Eucla'), + ('Asia/Shanghai'), + ('Asia/Novosibirsk'), + ('Asia/Yangon'), + ('Asia/Omsk'), + ('Asia/Kathmandu'), + ('Asia/Colombo'), + ('Asia/Oral'), + ('Asia/Kabul'), + ('Europe/Astrakhan'), + ('Asia/Tehran'), + ('Asia/Kuwait'), + ('Asia/Nicosia'), + ('Europe/Budapest'), + ('Etc/GMT-0'), + ('Atlantic/Azores'), + ('America/Cayenne'), + ('America/Nuuk'), + ('CNT'), + ('America/Martinique'), + ('America/Louisville'), + ('America/Rainy_River'), + ('America/Shiprock'), + ('Mexico/BajaNorte'), + ('America/Sitka'), + ('Pacific/Marquesas'), + ('Pacific/Johnston'), + ('Pacific/Niue'), + ('Etc/GMT+12'), + ) tbl(tz_name) +); +-- +ok +== +CREATE TABLE abbrevs AS ( + FROM (VALUES + ('Etc/GMT-14'), + ('NZ-CHAT'), + ('NZ'), + ('Pacific/Enderbury'), + ('Australia/Hobart'), + ('Australia/LHI'), + ('Pacific/Efate'), + ('Australia/Adelaide'), + ('Etc/GMT-9'), + ('Australia/Eucla'), + ('CTT'), + ('Asia/Phnom_Penh'), + ('Asia/Yangon'), + ('Asia/Thimbu'), + ('Asia/Kathmandu'), + ('IST'), + ('Asia/Qyzylorda'), + ('Asia/Kabul'), + ('Europe/Samara'), + ('Iran'), + ('EAT'), + ('CAT'), + ('Europe/Bratislava'), + ('GMT'), + ('Atlantic/Azores'), + ('America/Cayenne'), + ('America/Nuuk'), + ('CNT'), + ('PRT'), + ('America/Panama'), + ('America/Rankin_Inlet'), + ('Canada/Yukon'), + ('PST'), + ('America/Nome'), + ('Pacific/Marquesas'), + ('Pacific/Johnston'), + ('Pacific/Niue'), + ('Etc/GMT+12'), + ) tbl(tz_name) +); +-- +ok +== +CREATE TABLE offsets AS + FROM (VALUES + ('+14'), + ('+13'), + ('+12:45'), + ('+12'), + ('+11'), + ('+10:30'), + ('+10'), + ('+09:30'), + ('+09'), + ('+08:45'), + ('+08'), + ('+07'), + ('+06:30'), + ('+06'), + ('+05:45'), + ('+05:30'), + ('+05'), + ('+04:30'), + ('+04'), + ('+03:30'), + ('+03'), + ('+02'), + ('+01'), + ('+00'), + ('-01'), + ('-02'), + ('-03'), + ('-03:30'), + ('-04'), + ('-05'), + ('-06'), + ('-07'), + ('-08'), + ('-09'), + ('-09:30'), + ('-10'), + ('-11'), + ('-12'), + ) tbl(utc_offset) +; +-- +ok +== +SELECT {func}('2022-03-05 17:59:17.877 ' || tz_name, '%Y-%m-%d %H:%M:%S.%g %Z') tstz, tz_name +FROM zones +ORDER BY ALL +-- +error: Parser Error: syntax error at or near "}" +== +SELECT {func}('2022-03-05 17:59:17.877 ' || tz_name, '%Y-%m-%d %H:%M:%S.%g %Z') tstz, tz_name +FROM abbrevs +ORDER BY ALL +-- +error: Parser Error: syntax error at or near "}" +== +SELECT {func}('2022-03-05 17:59:17.877 ' || utc_offset, '%Y-%m-%d %H:%M:%S.%g %z') tstz, utc_offset +FROM offsets +ORDER BY tstz +-- +error: Parser Error: syntax error at or near "}" +== +SELECT {func}('2022-03-05 17:59:17.877 ' || tz_name, ['%m/%d/%Y %H:%M:%S.%g %Z', '%Y-%m-%d %H:%M:%S.%g %Z']) tstz, tz_name +FROM zones +ORDER BY ALL +-- +error: Parser Error: syntax error at or near "}" +== +SELECT {func}('2022-03-05 17:59:17.877 ' || tz_name, ['%Y-%m-%d %H:%M:%S.%g', '%Y-%m-%d %H:%M:%S.%g %Z']) tstz, tz_name +FROM zones +ORDER BY ALL +-- +error: Parser Error: syntax error at or near "}" +== +SELECT {func}('2022-03-05 17:59:17.877', ['%m/%d/%Y %H:%M:%S.%g', '%Y-%m-%d %H:%M:%S.%g']) tstz, tz_name +FROM zones +ORDER BY ALL +-- +error: Parser Error: syntax error at or near "}" +== +SELECT STRPTIME('2025-09-16', ['%Y-%m-%d', '%Y-%m-%d%z']); +-- +ok +== +SELECT try_strptime('2022-03-05 17:59:17.877 ' || tz_name, '%m/%d/%Y %H:%M:%S.%g %Z') tstz, tz_name +FROM zones +WHERE tstz IS NOT NULL +ORDER BY ALL +-- +ok +== +CREATE TABLE multiples (s VARCHAR, f VARCHAR); +-- +ok +== +INSERT INTO multiples VALUES + ('2022-03-05 17:59:17.877 CST', '%Y-%m-%d %H:%M:%S.%g %Z'), + ('2022-03-05 17:59:17.877', '%Y-%m-%d %H:%M:%S.%g'), +; +-- +ok +== +SELECT strptime(s, f) FROM multiples; +-- +ok +== +select strptime('2022-03-05 17:59:17.877 CST', '%C'); +-- +ok +== +select strptime('2022-03-05 17:59:17.877 CST', '%Y-%m-%d %H:%M:%S.%g'); +-- +ok +== +select 'fnord'::timestamptz; +-- +ok +== +select TRY_CAST('fnord' AS timestamptz); +-- +ok +== +select '2022-03-05 17:59:17.123456 CST'::timestamptz; +-- +ok +== +select 'infinity'::timestamptz; +-- +ok +== +select '-infinity'::timestamptz; +-- +ok +== +select 'epoch'::timestamptz; +-- +ok +== +SELECT TIMESTAMPTZ '294247-01-10 04:00:54.7758'; +-- +ok +== +select try_strptime('2015-01-05 00:00:00 FNORD', '%Y-%m-%d %H:%M:%S %Z'); +-- +ok +== diff --git a/parser/testdata/corpus/sql/function/timestamp/test_icu_time_bucket_timestamptz.test b/parser/testdata/corpus/sql/function/timestamp/test_icu_time_bucket_timestamptz.test new file mode 100644 index 0000000..692a2b5 --- /dev/null +++ b/parser/testdata/corpus/sql/function/timestamp/test_icu_time_bucket_timestamptz.test @@ -0,0 +1,308 @@ +# source: test/sql/function/timestamp/test_icu_time_bucket_timestamptz.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +CREATE TABLE timestamps_tz(w INTERVAL, t TIMESTAMPTZ, shift INTERVAL, origin TIMESTAMPTZ, timezone VARCHAR); +-- +ok +== +INSERT INTO timestamps_tz VALUES ('10 days', '-infinity', '0 days', '1970-01-05 00:00:00+00', 'UTC'), + ('333 microseconds', '1907-11-20 04:00:00+08', '0 microseconds', '1970-03-06 00:00:00+00', 'UTC'), + ('333 microseconds', '1970-01-01 00:00:00+00', '444 microseconds', '1970-01-05 00:05:05.006006+03', 'America/Los_Angeles'), + ('333 microseconds', '1979-04-10 02:02:05.003003-03', '-444 microseconds', '1962-12-10 00:05:05.006006-03', 'America/Los_Angeles'), + ('333 milliseconds', '1981-09-30 02:02:06.003003+00', '0 milliseconds', '1970-02-05 00:00:00+00', 'UTC'), + ('333 milliseconds', '1982-06-15 02:02:07.003003+04', '444 milliseconds', '1970-11-15 00:05:05.006006+04', 'Asia/Aden'), + ('333 milliseconds', '1985-02-20 02:02:08.003003-04', '-444 milliseconds', '1980-08-05 00:05:05.006006-04', 'Asia/Aden'), + ('333 seconds', '1989-06-08 02:02:09.003003+00', '0 seconds', '1970-11-25 00:00:00+00', 'UTC'), + ('333 seconds', '1990-07-11 02:02:10.003003+02', '444 seconds', '1970-04-10 00:05:05.006006+02', 'Pacific/Guam'), + ('333 seconds', '1991-05-12 02:02:11.003003-02', '-444 seconds', '1971-01-05 00:05:05.006006-02', 'Pacific/Guam'), + ('333 minutes', '1992-10-17 02:02:12.003003+00', '0 minutes', '1950-04-24 00:00:00+00', 'UTC'), + ('333 minutes', '1994-12-05 02:02:13.003003+05', '444 minute', '1970-06-09 00:05:05.006006+05', 'Europe/Berlin'), + ('333 minutes', '1997-01-02 02:02:14.003003-05', '-444 minute', '1970-07-06 00:05:05.006006-05', 'Europe/Berlin'), + ('333 hours', '1999-04-26 02:02:15.003003+00', '0 hours', '1970-02-05 00:00:00+00', 'UTC'), + ('333 hours', '2000-01-01 00:00:00+00', '444 hours', '1970-01-05 00:05:05.006006+01', 'Europe/London'), + ('333 hours', '2000-01-03 00:00:00+00', '-444 hours', '1970-03-15 00:05:05.006006-01', 'Europe/London'), + ('333 hours', '2000-03-26 02:00:00+01', '0 hours', '1980-10-05 00:00:00+00', 'Europe/London'), + ('333 hours', '2000-04-02 03:00:00-07', '0 hours', '1990-05-20 00:00:00+00', 'Europe/London'), + ('333 hours', '2000-10-29 01:00:00+00', '0 hours', '2010-07-27 00:00:00+00', 'Europe/London'), + ('333 hours', '2000-10-29 01:00:00-08', '0 hours', '2010-07-27 00:00:00+00', 'Europe/London'), + ('10 days', '2008-12-31 23:59:59.999999+00', '0 days', '1970-02-27 00:00:00+00', 'UTC'), + ('1 week', '2010-05-03 02:02:19.003003+00', '0 days', '1970-07-25 00:00:00+00', 'UTC'), + ('10 days', '2013-08-19 02:02:20.003003+02', '2 days 4 hours', '2003-03-24 00:05:05.006006+02', 'Asia/Kolkata'), + ('10 days', '2014-07-15 02:02:21.003003-02', '-2 days 4 hours', '1970-04-12 00:05:05.006006-02', 'Asia/Kolkata'), + ('2 months', '2016-03-21 02:02:22.003003+00', '0 months', '1970-11-05 00:00:00+00', 'UTC'), + ('2 months', '2018-02-01 02:02:23.003003+09', '1 month 1 week', '1970-05-07 00:05:05.006006+09', 'Australia/Sydney'), + ('2 months', '2019-09-30 02:02:24.003003-09', '-1 month 1 week', '1969-10-09 00:05:05.006006-09', 'Australia/Sydney'), + ('2 year', '2020-03-20 02:02:25.003003+11', '6 months', '2032-06-29 00:05:05.006006+11', 'Asia/Yekaterinburg'), + ('2 year', '2022-07-20 02:02:26.003003-11', '-6 months', '1969-11-14 00:05:05.006006-11', 'Asia/Yekaterinburg'), + ('10 days', '2024-08-12 02:02:26.003003+07', '1 year', '-infinity', 'Asia/Tokyo'), + ('10 days', '2032-12-18 02:02:26.003003-07', '-1 year', 'infinity', 'Asia/Tokyo'), + ('10 days', 'infinity', '0 days', '1970-01-01 00:00:00+00', 'UTC'), +; +-- +ok +== +select t, time_bucket('56 seconds'::interval, t) from timestamps_tz; +-- +ok +== +select t, time_bucket('3 days'::interval, t) from timestamps_tz; +-- +ok +== +select t, time_bucket('3 years'::interval, t) from timestamps_tz; +-- +ok +== +select t, time_bucket(null::interval, t) from timestamps_tz; +-- +ok +== +select time_bucket('3 years'::interval, null::timestamptz) from timestamps_tz; +-- +ok +== +select w, t, time_bucket(w, t) from timestamps_tz; +-- +ok +== +select t, time_bucket('4 seconds'::interval, t, '2 seconds'::interval) from timestamps_tz; +-- +ok +== +select t, time_bucket('4 days'::interval, t, '6 hours'::interval) from timestamps_tz; +-- +ok +== +select t, time_bucket('3 months'::interval, t, '6 days 11 hours'::interval) from timestamps_tz; +-- +ok +== +select t, time_bucket(null::interval, t, '2 seconds'::interval) from timestamps_tz; +-- +ok +== +select time_bucket('3 months'::interval, null::timestamptz, '2 seconds'::interval) from timestamps_tz; +-- +ok +== +select t, time_bucket('3 months'::interval, t, null::interval) from timestamps_tz; +-- +ok +== +select w, t, shift, time_bucket(w, t, shift) from timestamps_tz; +-- +ok +== +select t, time_bucket('11 seconds'::interval, t, '1990-12-10 08:08:10+03'::timestamptz) from timestamps_tz; +-- +ok +== +select t, time_bucket('11 days'::interval, t, '1990-01-06 08:08:10+09'::timestamptz) from timestamps_tz; +-- +ok +== +select t, time_bucket('7 months'::interval, t, '1990-01-06 08:08:10+01'::timestamptz) from timestamps_tz; +-- +ok +== +select t, time_bucket(null::interval, t, '1990-01-06 08:08:10'::timestamptz) from timestamps_tz; +-- +ok +== +select time_bucket('7 months'::interval, null::timestamptz, '1990-01-06 08:08:10'::timestamptz) from timestamps_tz; +-- +ok +== +select t, time_bucket('7 months'::interval, t, null::timestamptz) from timestamps_tz; +-- +ok +== +select w, t, origin, time_bucket(w, t, origin) from timestamps_tz; +-- +ok +== +select t, time_bucket('11 seconds'::interval, t, 'Asia/Calcutta') from timestamps_tz; +-- +ok +== +select t, time_bucket('5 months'::interval, t, 'Europe/Berlin') from timestamps_tz; +-- +ok +== +select t, time_bucket('11 seconds'::interval, t, 'Europe/Berlin') from timestamps_tz; +-- +ok +== +select t, time_bucket('5 months'::interval, t, 'Europe/London') from timestamps_tz; +-- +ok +== +select t, time_bucket('11 seconds'::interval, t, 'Europe/London') from timestamps_tz; +-- +ok +== +select t, time_bucket(null::interval, t, 'Asia/Calcutta') from timestamps_tz; +-- +ok +== +select time_bucket('11 seconds'::interval, null::timestamptz, 'Asia/Calcutta') from timestamps_tz; +-- +ok +== +select t, time_bucket('11 seconds'::interval, t, null::text) from timestamps_tz; +-- +ok +== +select w, t, timezone, time_bucket(w, t, timezone) from timestamps_tz; +-- +ok +== +select time_bucket('-3 hours'::interval, '2019-04-05 00:00:00+03'::timestamptz); +-- +ok +== +select time_bucket('-3 hours'::interval, '2019-04-05 00:00:00+03'::timestamptz, '1 hour 30 minutes'::interval); +-- +ok +== +select time_bucket('-3 hours'::interval, '2019-04-05 00:00:00+03'::timestamptz, '2019-04-05 00:00:00+03'::timestamptz); +-- +ok +== +select time_bucket('-1 month'::interval, '2019-04-05 00:00:00-11'::timestamptz); +-- +ok +== +select time_bucket('-1 month'::interval, '2019-04-05 00:00:00-11'::timestamptz, '1 hour 30 minutes'::interval); +-- +ok +== +select time_bucket('-1 month'::interval, '2019-04-05 00:00:00-11'::timestamptz, '2018-04-05 00:00:00+11'::timestamptz); +-- +ok +== +select time_bucket('1 day - 172800 seconds'::interval, '2018-05-05 00:00:00+07'::timestamptz); +-- +ok +== +select time_bucket('1 day - 172800 seconds'::interval, '2018-05-05 00:00:00+07'::timestamptz, '1 hour 30 minutes'::interval); +-- +ok +== +select time_bucket('1 day - 172800 seconds'::interval, '2018-05-05 00:00:00+07'::timestamptz, '2018-05-05 00:00:00+07'::timestamptz); +-- +ok +== +select time_bucket('1 month 1 day'::interval, '2018-05-05 00:00:00+02'::timestamptz); +-- +ok +== +select time_bucket('1 month 1 day'::interval, '2018-05-05 00:00:00+02'::timestamptz, '1 hour 30 minutes'::interval); +-- +ok +== +select time_bucket('1 month 1 day'::interval, '2018-05-05 00:00:00+02'::timestamptz, '2018-05-05 00:00:00+02'::timestamptz); +-- +ok +== +select time_bucket('3 days'::interval, '2019-05-05 00:00:00+09'::timestamptz, '2000000000 months'::interval); +-- +ok +== +select time_bucket('3 days'::interval, '2019-05-05 00:00:00+09'::timestamptz, '-2000000000 months'::interval); +-- +ok +== +select time_bucket('3 months'::interval, '2019-05-05 00:00:00+00'::timestamptz, '2000000000 months'::interval); +-- +ok +== +select time_bucket('3 months'::interval, '2019-05-05 00:00:00+00'::timestamptz, '-2000000000 months'::interval); +-- +ok +== +select time_bucket('1 microseconds'::interval, '290279-12-24 (BC) 19:59:05.224191+00'::timestamptz); +-- +ok +== +select time_bucket('1 microseconds'::interval, '290279-12-24 (BC) 19:59:05.224192+00'::timestamptz); +-- +ok +== +select time_bucket('1 microseconds'::interval, '294247-01-10 04:00:54.775+00'::timestamptz); +-- +ok +== +SELECT TIME_BUCKET(CAST('0.' AS INTERVAL), CAST('2000-01-01 00:00:00+00' AS TIMESTAMPTZ)); +-- +ok +== +select time_bucket('1 microseconds'::interval, '294247-01-10 04:00:54.774999+00'::timestamptz); +-- +ok +== +with t2 as (select '2000-03-26 00:00:00'::timestamptz + (n::text || 'hours')::interval as ts from generate_series(0, 72, 3) t1(n)) select ts, time_bucket('10 seconds'::interval, ts, 'Europe/London') from t2; +-- +ok +== +with t2 as (select '2000-10-28 00:00:00'::timestamptz + (n::text || 'hours')::interval as ts from generate_series(0, 72, 3) t1(n)) select ts, time_bucket('10 seconds'::interval, ts, 'Europe/London') from t2; +-- +ok +== +select + time_bucket(interval '1' day, timestamptz '2000-01-03 17:40:00+00', origin) +from + generate_series(timestamptz '2000-01-03 00:00:00+00', + timestamptz '2000-01-04 00:00:00+00', + interval '1' hour) as t(origin) +order by + origin +; +-- +ok +== +set TimeZone='UTC'; +-- +ok +== +select + time_bucket(interval '1' day, timestamptz '2023-10-07 16:08:09+00', origin) +from + generate_series(timestamptz '2001-01-03 00:00:00+00', + timestamptz '2001-01-04 00:00:00+00', + interval '1' hour) as t(origin) +order by origin +; +-- +ok +== +set TimeZone='America/St_Johns'; +-- +ok +== +select + time_bucket(interval '1' day, timestamptz '2023-10-07 16:08:09+03', origin) +from + generate_series(timestamptz '2001-01-03 00:00:00+05', + timestamptz '2001-01-04 00:00:00+05', + interval '1' hour) as t(origin) +order by origin +; +-- +ok +== +select + bool_and( + date_part('epoch', time_bucket(interval '3' day, timestamptz '2023-06-07 16:08:09+00', origin)) + = date_part('epoch', time_bucket(interval '3' day, timestamp '2023-06-07 16:08:09', origin at time zone 'UTC')) + ) +from + generate_series(timestamptz '2023-01-03 00:00:00+05', + timestamptz '2024-01-04 00:00:00+05', + interval '7877' minute) as t(origin) +; +-- +ok +== diff --git a/parser/testdata/corpus/sql/function/timestamp/test_last_modified.test b/parser/testdata/corpus/sql/function/timestamp/test_last_modified.test new file mode 100644 index 0000000..b78b1c5 --- /dev/null +++ b/parser/testdata/corpus/sql/function/timestamp/test_last_modified.test @@ -0,0 +1,18 @@ +# source: test/sql/function/timestamp/test_last_modified.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +copy (select 42 i) to '{TEST_DIR}/last_modified_tz.csv' +-- +ok +== +with cte as ( + select epoch(last_modified) as last_modified + from read_blob('{TEST_DIR}/last_modified_tz.csv') +) +select abs(epoch(now()) - last_modified) < 5 +from cte; +-- +ok +== diff --git a/parser/testdata/corpus/sql/function/timestamp/test_now.test b/parser/testdata/corpus/sql/function/timestamp/test_now.test new file mode 100644 index 0000000..3c067a7 --- /dev/null +++ b/parser/testdata/corpus/sql/function/timestamp/test_now.test @@ -0,0 +1,21 @@ +# source: test/sql/function/timestamp/test_now.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +CREATE TABLE t1(t TIMESTAMP) +-- +ok +== +INSERT INTO t1 VALUES (NOW()); +-- +ok +== +INSERT INTO t1 SELECT NOW(); +-- +ok +== +SELECT COUNT(DISTINCT t) FROM t1 +-- +ok +== diff --git a/parser/testdata/corpus/sql/function/timestamp/test_now_prepared.test b/parser/testdata/corpus/sql/function/timestamp/test_now_prepared.test new file mode 100644 index 0000000..af9fd35 --- /dev/null +++ b/parser/testdata/corpus/sql/function/timestamp/test_now_prepared.test @@ -0,0 +1,33 @@ +# source: test/sql/function/timestamp/test_now_prepared.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +CREATE TABLE timestamps(ts TIMESTAMP); +-- +ok +== +PREPARE v1 AS INSERT INTO timestamps VALUES(NOW()); +-- +ok +== +EXECUTE v1; +-- +ok +== +SELECT COUNT(DISTINCT ts) FROM timestamps +-- +ok +== +CREATE TABLE timestamps_default(ts TIMESTAMP DEFAULT NOW()); +-- +ok +== +INSERT INTO timestamps_default DEFAULT VALUES +-- +ok +== +SELECT COUNT(DISTINCT ts) FROM timestamps_default +-- +ok +== diff --git a/parser/testdata/corpus/sql/function/timestamp/test_strftime_timestamp.test b/parser/testdata/corpus/sql/function/timestamp/test_strftime_timestamp.test new file mode 100644 index 0000000..c0cfe2d --- /dev/null +++ b/parser/testdata/corpus/sql/function/timestamp/test_strftime_timestamp.test @@ -0,0 +1,167 @@ +# source: test/sql/function/timestamp/test_strftime_timestamp.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +CREATE TABLE timestamps(d TIMESTAMP); +INSERT INTO timestamps VALUES + ('1992-01-01 01:20:30'), + ('1993-03-20 23:50:01.123'), + ('2020-08-09 12:01:55.123456'), + ('2020-08-10 10:10:10.123456789'), + (NULL); +-- +ok +== +SELECT strftime(d, '%a') FROM timestamps ORDER BY d; +-- +ok +== +SELECT strftime(d, '%A') FROM timestamps ORDER BY d; +-- +ok +== +SELECT strftime(d, '%w') FROM timestamps ORDER BY d; +-- +ok +== +SELECT strftime(d, '%u') FROM timestamps ORDER BY d; +-- +ok +== +SELECT strftime(d, '%d') FROM timestamps ORDER BY d; +-- +ok +== +SELECT strftime(d, '%-d') FROM timestamps ORDER BY d; +-- +ok +== +SELECT strftime(d, '%b') FROM timestamps ORDER BY d; +-- +ok +== +SELECT strftime(d, '%h') FROM timestamps ORDER BY d; +-- +ok +== +SELECT strftime(d, '%B') FROM timestamps ORDER BY d; +-- +ok +== +SELECT strftime(d, '%m') FROM timestamps ORDER BY d; +-- +ok +== +SELECT strftime(d, '%-m') FROM timestamps ORDER BY d; +-- +ok +== +SELECT strftime(d, '%y') FROM timestamps ORDER BY d; +-- +ok +== +SELECT strftime(d, '%-y') FROM timestamps ORDER BY d; +-- +ok +== +SELECT strftime(d, '%Y') FROM timestamps ORDER BY d; +-- +ok +== +SELECT strftime(d, '%G') FROM timestamps ORDER BY d; +-- +ok +== +SELECT strftime(d, '%H') FROM timestamps ORDER BY d; +-- +ok +== +SELECT strftime(d, '%-H') FROM timestamps ORDER BY d; +-- +ok +== +SELECT strftime(d, '%I') FROM timestamps ORDER BY d; +-- +ok +== +SELECT strftime(d, '%-I') FROM timestamps ORDER BY d; +-- +ok +== +SELECT strftime(d, '%p') FROM timestamps ORDER BY d; +-- +ok +== +SELECT strftime(d, '%M') FROM timestamps ORDER BY d; +-- +ok +== +SELECT strftime(d, '%-M') FROM timestamps ORDER BY d; +-- +ok +== +SELECT strftime(d, '%S') FROM timestamps ORDER BY d; +-- +ok +== +SELECT strftime(d, '%-S') FROM timestamps ORDER BY d; +-- +ok +== +SELECT strftime(d, '%f') FROM timestamps ORDER BY d; +-- +ok +== +SELECT strftime(d, '%g') +FROM timestamps +ORDER BY d; +-- +ok +== +SELECT strftime(d, '%n') +FROM timestamps +ORDER BY d; +-- +ok +== +SELECT strftime(d, '%z') FROM timestamps ORDER BY d; +-- +ok +== +SELECT strftime(d, '%Z') FROM timestamps ORDER BY d; +-- +ok +== +SELECT strftime(d, '%j') FROM timestamps ORDER BY d; +-- +ok +== +SELECT strftime(d, '%-j') FROM timestamps ORDER BY d; +-- +ok +== +SELECT strftime(d, '%U') FROM timestamps ORDER BY d; +-- +ok +== +SELECT strftime(d, '%W') FROM timestamps ORDER BY d; +-- +ok +== +SELECT strftime(d, '%V') FROM timestamps ORDER BY d; +-- +ok +== +SELECT strftime(d, '%c') FROM timestamps ORDER BY d; +-- +ok +== +SELECT strftime(d, '%x') FROM timestamps ORDER BY d; +-- +ok +== +SELECT strftime(d, '%X') FROM timestamps ORDER BY d; +-- +ok +== diff --git a/parser/testdata/corpus/sql/function/timestamp/test_strftime_timestamp_ns.test b/parser/testdata/corpus/sql/function/timestamp/test_strftime_timestamp_ns.test new file mode 100644 index 0000000..728c8d1 --- /dev/null +++ b/parser/testdata/corpus/sql/function/timestamp/test_strftime_timestamp_ns.test @@ -0,0 +1,15 @@ +# source: test/sql/function/timestamp/test_strftime_timestamp_ns.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +CREATE TABLE timestamps(d TIMESTAMP_NS); +INSERT INTO timestamps VALUES + ('1992-01-01 01:20:30'), + ('1993-03-20 23:50:01.123'), + ('2020-08-09 12:01:55.123456'), + ('2020-08-10 10:10:10.123456789'), + (NULL); +-- +ok +== diff --git a/parser/testdata/corpus/sql/function/timestamp/test_strptime.test b/parser/testdata/corpus/sql/function/timestamp/test_strptime.test new file mode 100644 index 0000000..2e4b697 --- /dev/null +++ b/parser/testdata/corpus/sql/function/timestamp/test_strptime.test @@ -0,0 +1,533 @@ +# source: test/sql/function/timestamp/test_strptime.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +SELECT strptime('21 June, 2018', '%d %B, %Y') +-- +ok +== +SELECT strptime('21/10/2018', '%d/%m/%Y') +-- +ok +== +SELECT strptime('2018-20-10', '%Y-%d-%m') +-- +ok +== +SELECT strptime('20182010', '%Y%d%m') +-- +ok +== +SELECT strptime('Mon 30, June 2003, 12:03:10 AM', '%a %d, %B %Y, %I:%M:%S %p') +-- +ok +== +SELECT strptime('Mon 30, June 2003, 12:03:10 PM', '%a %d, %B %Y, %I:%M:%S %p') +-- +ok +== +SELECT strptime('Mon 30, December 2003, 7:3:5 PM', '%a %d, %B %Y, %I:%M:%S %p') +-- +ok +== +SELECT strptime('Tuesday 30, December 2003, 7:3:5 PM', '%A %d, %B %Y, %I:%M:%S %p') +-- +ok +== +SELECT strptime('Mon 30, December 30, 7:3:5 PM', '%a %d, %B %y, %I:%M:%S %p') +-- +ok +== +SELECT strptime('Mon 30, June 2003, 12:03:10 AM', '%a %-d, %B %Y, %-I:%-M:%-S %p') +-- +ok +== +SELECT strptime('mon', '%a') +-- +ok +== +SELECT strptime('tuesday', '%A') +-- +ok +== +SELECT strptime('jun', '%b') +-- +ok +== +SELECT strptime('1', '%W') +-- +ok +== +SELECT strptime('1', '%U') +-- +ok +== +SELECT strptime('30', '%U'), strftime('1900-07-29'::DATE, '%U') +-- +ok +== +SELECT strptime('1', '%V') +-- +ok +== +SELECT strptime('30', '%W'), strftime('1900-07-23'::DATE, '%W') +-- +ok +== +SELECT strptime('30', '%V'), strftime('1900-07-23'::DATE, '%V') +-- +ok +== +SELECT strptime('6', '%w') +-- +ok +== +SELECT strptime('6', '%u') +-- +ok +== +SELECT strptime('1-4', '%U-%w'), strftime('1900-01-11'::DATE, '%U-%w') +-- +ok +== +SELECT strptime('2-4', '%V-%u'), strftime('1900-01-11'::DATE, '%V-%u') +-- +ok +== +SELECT strptime('1-4', '%W-%w'), strftime('1900-01-04'::DATE, '%W-%w') +-- +ok +== +SELECT strptime('1-4', '%V-%u'), strftime('1900-01-04'::DATE, '%V-%u') +-- +ok +== +SELECT strptime('30', '%j'), strftime('1900-01-30'::DATE, '%-j') +-- +ok +== +select strptime('100 2024', '%j %Y'); +-- +ok +== +select strptime('2024 100', '%Y %j'); +-- +ok +== +SELECT strptime('1992-01-30 30', '%Y-%m-%d %j') +-- +ok +== +SELECT strptime('2021-19-4', '%Y-%U-%w'), strftime('2021-05-13'::DATE, '%Y-%U-%w') +-- +ok +== +SELECT strptime('2021-19-4', '%Y-%W-%w'), strftime('2021-05-13'::DATE, '%Y-%U-%w') +-- +ok +== +SELECT strptime('2021-19-4', '%G-%V-%u'), strftime('2021-05-13'::DATE, '%G-%V-%u') +-- +ok +== +SELECT strptime('2021-0-5', '%Y-%U-%w'), strftime('2021-01-01'::DATE, '%Y-%U-%w') +-- +ok +== +SELECT strptime('2021-1-5', '%G-%V-%u'), strftime('2021-01-08'::DATE, '%G-%V-%u') +-- +ok +== +SELECT strptime('2021-0-5', '%Y-%W-%w'), strftime('2021-01-01'::DATE, '%Y-%W-%w') +-- +ok +== +SELECT strptime('2021-05-12 19-4', '%Y-%m-%d %U-%w') +-- +ok +== +SELECT strptime('2021-05-12 19-4', '%Y-%m-%d %W-%w') +-- +ok +== +SELECT strptime('2021-05-12 19-4', '%Y-%m-%d %V-%u') +-- +ok +== +SELECT * FROM ( + SELECT dt, strftime(dt, '%Y-%U-%w') AS ft, strptime(strftime(dt, '%Y-%U-%w'), '%Y-%U-%w') AS rt + FROM (SELECT '2021-01-01'::DATE + (INTERVAL (d) DAY) AS dt FROM range(365) tbl(d)) days +) diffs +WHERE rt <> dt +-- +ok +== +SELECT * FROM ( + SELECT dt, strftime(dt, '%Y-%W-%w') AS ft, strptime(strftime(dt, '%Y-%W-%w'), '%Y-%W-%w') AS rt + FROM (SELECT '2021-01-01'::DATE + (INTERVAL (d) DAY) AS dt FROM range(365) tbl(d)) days +) diffs +WHERE rt <> dt +-- +ok +== +SELECT * FROM ( + SELECT dt, strftime(dt, '%G-%V-%u') AS ft, strptime(strftime(dt, '%G-%V-%u'), '%G-%V-%u') AS rt + FROM (SELECT '2021-01-01'::DATE + (INTERVAL (d) DAY) AS dt FROM range(365) tbl(d)) days +) diffs +WHERE rt <> dt +-- +ok +== +SELECT strptime('', '') +-- +ok +== +SELECT strptime(NULL, '') +-- +ok +== +SELECT strptime('', NULL) +-- +ok +== +SELECT strptime('Jun 30 2003 2:03:10AM', '%b %d %Y %-I:%M:%S%p'); +-- +ok +== +select strptime('2020-12-31 21:25:58.745232159', '%Y-%m-%d %H:%M:%S.%n'); +-- +ok +== +select strptime('2020-12-31 21:25:58.745232951', '%Y-%m-%d %H:%M:%S.%n'); +-- +ok +== +select strptime('2020-12-31 21:25:58.745232', '%Y-%m-%d %H:%M:%S.%f'); +-- +ok +== +select strptime('2020-12-31 21:25:58.745232+00', '%Y-%m-%d %H:%M:%S.%f%z'); +-- +ok +== +select strptime('2020-12-31 21:25:58.745232+0000', '%Y-%m-%d %H:%M:%S.%f%z'); +-- +ok +== +select strptime('2020-12-31 21:25:58.745232+02', '%Y-%m-%d %H:%M:%S.%f%z'); +-- +ok +== +select strptime('2020-12-31 21:25:58.745232-02', '%Y-%m-%d %H:%M:%S.%f%z'); +-- +ok +== +select strptime('2020-12-31 21:25:58.745232+0215', '%Y-%m-%d %H:%M:%S.%f%z'); +-- +ok +== +select strptime('2020-12-31 21:25:58.745232-0215', '%Y-%m-%d %H:%M:%S.%f%z'); +-- +ok +== +select strptime('2020-12-31 03:25:58.745232+04', '%Y-%m-%d %H:%M:%S.%f%z'); +-- +ok +== +select strptime('2020-12-30 23:25:58.745232-04', '%Y-%m-%d %H:%M:%S.%f%z'); +-- +ok +== +select strptime('2024-11-28 23:59:00.3', '%Y-%m-%d %H:%M:%S.%g'); +-- +ok +== +select strptime('2024-11-28 23:59:00.312', '%Y-%m-%d %H:%M:%S.%f'); +-- +ok +== +select strptime('2024-11-28 23:59:00.312457', '%Y-%m-%d %H:%M:%S.%n'); +-- +ok +== +select strptime('infinity', '%m/%d/%Y'); +-- +ok +== +select strptime('-infinity', '%m/%d/%Y'); +-- +ok +== +select strptime('epoch', '%m/%d/%Y'); +-- +ok +== +SELECT strptime('Mon Oct 17 2022 22:00:00 GMT+0000 (GMT)', '%a %b %d %Y %X GMT%z (%Z)') as fixed; +-- +ok +== +SELECT strptime('Mon Oct 17 2022 22:00:00 GMT+0000 (GMT', '%a %b %d %Y %X GMT%z (%Z') as working; +-- +ok +== +SELECT strptime('10/28/1910', ['%d-%m-%Y', '%m-%d-%Y', '%d/%m/%Y', '%m/%d/%Y']) +-- +ok +== +SELECT strptime('10.28.1910', ['%d-%m-%Y', '%m-%d-%Y', '%d/%m/%Y', '%m/%d/%Y']) +-- +ok +== +SELECT strptime('Mon Oct 17 2022 22:00:00 GMT+0000 (GMT)', '%a %b %d %Y %X GMT%z (%Z') as broken; +-- +ok +== +select strptime('2020-12-31 21:25:58.745232+0', '%Y-%m-%d %H:%M:%S.%f%z'); +-- +ok +== +select strptime('2020-12-31 21:25:58.745232+0X', '%Y-%m-%d %H:%M:%S.%f%z'); +-- +ok +== +select strptime('2020-12-31 21:25:58.745232+X0', '%Y-%m-%d %H:%M:%S.%f%z'); +-- +ok +== +select strptime('2020-12-31 21:25:58.745232+000', '%Y-%m-%d %H:%M:%S.%f%z'); +-- +ok +== +select strptime('2020-12-31 21:25:58.745232X00', '%Y-%m-%d %H:%M:%S.%f%z'); +-- +ok +== +SELECT strptime('2018-20-10', '%Y-%m-%d') +-- +ok +== +SELECT strptime('2018-10-100', '%Y-%m-%d') +-- +ok +== +SELECT strptime('969-10-10', '%y-%m-%d') +-- +ok +== +SELECT strptime('2000/10/10', '%Y-%m-%d') +-- +ok +== +SELECT strptime('2001-02-30', '%Y-%m-%d') +-- +ok +== +SELECT strptime('2000-10-hello', '%Y-%m-%d') +-- +ok +== +SELECT strptime('2000-10-01 24:00:00', '%Y-%m-%d %H:%M:%S') +-- +ok +== +SELECT strptime('2000-10-01 00:00:00 AM', '%Y-%m-%d %I:%M:%S %p') +-- +ok +== +SELECT strptime('2000-10-01 13:00:00 AM', '%Y-%m-%d %I:%M:%S %p') +-- +ok +== +SELECT strptime('2000-10-01 23:60:00', '%Y-%m-%d %H:%M:%S') +-- +ok +== +SELECT strptime('2000-10-01 23:59:60', '%Y-%m-%d %H:%M:%S') +-- +ok +== +SELECT strptime('2000-10-01 23:59:59.10000000', '%Y-%m-%d %H:%M:%S.%f') +-- +ok +== +SELECT strptime('2000-10-01 23:59:59.1000000000000000000000000000', '%Y-%m-%d %H:%M:%S.%f') +-- +ok +== +SELECT strptime('', '%Y-%m-%d %H:%M:%S.%f') +-- +ok +== +SELECT strptime('', '%p') +-- +ok +== +SELECT strptime('a', '%p') +-- +ok +== +SELECT strptime('mp', '%p') +-- +ok +== +SELECT strptime('pp', '%p') +-- +ok +== +SELECT strptime('zm', '%p') +-- +ok +== +SELECT strptime('moa', '%a') +-- +ok +== +SELECT strptime('moaday', '%A') +-- +ok +== +SELECT strptime('mondayy', '%A') +-- +ok +== +SELECT strptime('juk', '%b') +-- +ok +== +SELECT strptime('juke', '%B') +-- +ok +== +SELECT strptime('junee', '%B') +-- +ok +== +SELECT strptime('500', '%j') +-- +ok +== +SELECT strptime('500', '%-j') +-- +ok +== +SELECT strptime('0', '%j') +-- +ok +== +SELECT strptime('0', '%-j') +-- +ok +== +SELECT strptime('60', '%U') +-- +ok +== +SELECT strptime('60', '%W') +-- +ok +== +SELECT strptime('60', '%V') +-- +ok +== +SELECT strptime('9', '%w') +-- +ok +== +SELECT strptime('9', '%u') +-- +ok +== +SELECT strptime('20 19', '%U %W') +-- +ok +== +SELECT strptime('20 19', '%U %V') +-- +ok +== +SELECT strptime('20 2021', '%U %G') +-- +ok +== +SELECT strptime('20 19', '%U %j') +-- +ok +== +SELECT strptime('20 19', '%W %U') +-- +ok +== +SELECT strptime('20 19', '%W %V') +-- +ok +== +SELECT strptime('20 2021', '%W %G') +-- +ok +== +SELECT strptime('20 19', '%W %j') +-- +ok +== +SELECT strptime('20 19', '%V %U') +-- +ok +== +SELECT strptime('20 19', '%V %W') +-- +ok +== +SELECT strptime('20 19', '%V %j') +-- +ok +== +SELECT strptime('2021 19', '%G %U') +-- +ok +== +SELECT strptime('2021 19', '%G %W') +-- +ok +== +SELECT strptime('2021 19', '%G %j') +-- +ok +== +SELECT strptime('2021 1950', '%G %Y') +-- +ok +== +SELECT strptime('2021 1950', '%Y %G') +-- +ok +== +SELECT strptime('20 1950', '%V %Y') +-- +ok +== +SELECT strptime('2021 19', '%Y %V') +-- +ok +== +SELECT strptime('Mon 30, December 30, 20:3:5 PM', '%a %d, %B %y, %H:%M:%S %p') +-- +ok +== +SELECT strptime('21/10/2018', '%-q/%m/%Y') +-- +ok +== +SELECT strptime('9999999', '%f') +-- +ok +== +SELECT strptime('9999', '%g') +-- +ok +== +SELECT strptime('2000/10/10', random()::varchar) +-- +ok +== diff --git a/parser/testdata/corpus/sql/function/timestamp/test_strptime_nonascii.test b/parser/testdata/corpus/sql/function/timestamp/test_strptime_nonascii.test new file mode 100644 index 0000000..c548bba --- /dev/null +++ b/parser/testdata/corpus/sql/function/timestamp/test_strptime_nonascii.test @@ -0,0 +1,21 @@ +# source: test/sql/function/timestamp/test_strptime_nonascii.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +SELECT try_strptime('21 Jüne, 2018', '%d %B, %Y') +-- +ok +== +SELECT try_strptime('Mänday', '%A') +-- +ok +== +SELECT try_strptime('10 äm', '%I %p') +-- +ok +== +SELECT try_strptime('21 June, 2018', '%d %B, %Y') +-- +ok +== diff --git a/parser/testdata/corpus/sql/function/timestamp/test_time_bucket_timestamp.test b/parser/testdata/corpus/sql/function/timestamp/test_time_bucket_timestamp.test new file mode 100644 index 0000000..e47c71b --- /dev/null +++ b/parser/testdata/corpus/sql/function/timestamp/test_time_bucket_timestamp.test @@ -0,0 +1,240 @@ +# source: test/sql/function/timestamp/test_time_bucket_timestamp.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +CREATE TABLE timestamps(w INTERVAL, t TIMESTAMP, shift INTERVAL, origin TIMESTAMP); +-- +ok +== +INSERT INTO timestamps VALUES ('10 days', '-infinity', '0 days', '1970-01-05 00:00:00'), + ('10 days', '3000-01-02 (BC) 03:16:23.003003', '3 days', '3000-01-01 (BC) 00:00:00'), + ('2 months', '1024-04-10 (BC) 12:35:40.003003', '10 days', '1024-03-01 (BC) 00:00:00'), + ('10 days', '0044-06-15 (BC) 12:35:40.003003', '6 days', '0044-02-01 (BC) 00:00:00'), + ('333 microseconds', '0678-06-30 02:02:03.003003', '0 microseconds', '1970-02-10 00:00:00'), + ('333 microseconds', '0794-07-03 02:02:04.003003', '444 microseconds', '1970-10-17 00:05:05.006006'), + ('333 microseconds', '1700-01-01 00:00:00', '-444 microseconds', '1970-09-27 00:05:05.006006'), + ('333 milliseconds', '1962-12-31 00:00:00', '0 milliseconds', '1970-08-12 00:00:00'), + ('333 milliseconds', '1970-01-01 00:00:00', '444 milliseconds', '1970-06-23 00:05:05.006006'), + ('333 milliseconds', '1985-12-07 02:02:08.003003', '-444 milliseconds', '1970-01-05 00:05:05.006006'), + ('333 seconds', '1989-10-18 02:02:09.003003', '0 seconds', '1970-09-07 00:00:00'), + ('333 seconds', '1990-01-21 02:02:10.003003', '444 seconds', '1970-07-06 00:05:05.006006'), + ('333 seconds', '1991-02-10 02:02:11.003003', '-444 seconds', '1970-10-09 00:05:05.006006'), + ('333 minutes', '1992-09-11 02:02:12.003003', '0 minutes', '1970-04-10 00:00:00'), + ('333 minutes', '1994-12-26 02:02:13.003003', '444 minute', '1970-03-05 00:05:05.006006'), + ('333 minutes', '1997-05-13 02:02:14.003003', '-444 minute', '2000-01-03 00:00:00'), + ('333 hours', '1999-02-14 02:02:15.003003', '0 hours', '2000-01-01 00:00:00'), + ('333 hours', '2000-01-01 00:00:00', '444 hours', '1980-11-25 00:05:05.006006'), + ('333 hours', '2000-01-03 00:00:00', '-444 hours', '2045-01-05 00:05:05.006006'), + ('10 days', '2008-09-17 02:02:18.003003', '0 days', '2009-11-05 00:00:00'), + ('1 week', '2010-08-18 02:02:19.003003', '0 days', '2100-09-05 00:00:00'), + ('10 days', '2013-03-19 02:02:20.003003', '2 days 4 hours', '2300-10-07 00:05:05.006006'), + ('10 days', '2014-11-20 02:02:21.003003', '-2 days 4 hours', '1970-12-07 00:05:05.006006'), + ('2 months', '2016-02-21 02:02:22.003003', '0 months', '1970-09-05 00:00:00'), + ('2 months', '2018-08-22 02:02:23.003003', '1 month 1 week', '1970-07-01 00:05:05.006006'), + ('2 months', '2019-01-23 02:02:24.003003', '-1 month 1 week', '1969-09-01 00:05:05.006006'), + ('2 year', '2020-02-24 02:02:25.003003', '6 months', '1970-02-13 00:05:05.006006'), + ('2 year', '2022-07-25 02:02:26.003003', '-6 months', '1969-10-09 00:05:05.006006'), + ('10 days', '2024-02-25 02:02:26.003003', '1 year', '-infinity'), + ('10 days', '2032-09-25 02:02:26.003003', '-1 year', 'infinity'), + ('10 days', 'infinity', '0 days', '1970-01-01 00:00:00'), +; +-- +ok +== +select t, time_bucket('56 seconds'::interval, t) from timestamps; +-- +ok +== +select t, time_bucket('3 days'::interval, t) from timestamps; +-- +ok +== +select t, time_bucket('3 years'::interval, t) from timestamps; +-- +ok +== +select t, time_bucket(null::interval, t) from timestamps; +-- +ok +== +select time_bucket('3 years'::interval, null::timestamp) from timestamps; +-- +ok +== +select w, t, time_bucket(w, t) from timestamps; +-- +ok +== +select t, time_bucket('4 seconds'::interval, t, '2 seconds'::interval) from timestamps; +-- +ok +== +select t, time_bucket('4 days'::interval, t, '6 hours'::interval) from timestamps; +-- +ok +== +select t, time_bucket('3 months'::interval, t, '6 days 11 hours'::interval) from timestamps; +-- +ok +== +select t, time_bucket(null::interval, t, '2 seconds'::interval) from timestamps; +-- +ok +== +select time_bucket('3 months'::interval, null::timestamp, '2 seconds'::interval) from timestamps; +-- +ok +== +select t, time_bucket('3 months'::interval, t, null::interval) from timestamps; +-- +ok +== +select w, t, shift, time_bucket(w, t, shift) from timestamps; +-- +ok +== +select t, time_bucket('11 seconds'::interval, t, '1990-12-10 08:08:10'::timestamp) from timestamps; +-- +ok +== +select t, time_bucket('11 days'::interval, t, '1990-01-06 08:08:10'::timestamp) from timestamps; +-- +ok +== +select t, time_bucket('7 months'::interval, t, '1990-01-06 08:08:10'::timestamp) from timestamps; +-- +ok +== +select t, time_bucket(null::interval, t, '1990-01-06 08:08:10'::timestamp) from timestamps; +-- +ok +== +select time_bucket('7 months'::interval, null::timestamp, '1990-01-06 08:08:10'::timestamp) from timestamps; +-- +ok +== +select t, time_bucket('7 months'::interval, t, null::timestamp) from timestamps; +-- +ok +== +select w, t, origin, time_bucket(w, t, origin) from timestamps; +-- +ok +== +select time_bucket('-3 hours'::interval, '2019-04-05 00:00:00'::timestamp); +-- +ok +== +select time_bucket('-3 hours'::interval, '2019-04-05 00:00:00'::timestamp, '1 hour 30 minutes':: interval); +-- +ok +== +select time_bucket('-3 hours'::interval, '2019-04-05 00:00:00'::timestamp, '2019-04-05 00:00:00'::timestamp); +-- +ok +== +select time_bucket('-1 month'::interval, '2019-04-05 00:00:00'::timestamp); +-- +ok +== +select time_bucket('-1 month'::interval, '2019-04-05 00:00:00'::timestamp, '1 hour 30 minutes':: interval); +-- +ok +== +select time_bucket('-1 month'::interval, '2019-04-05 00:00:00'::timestamp, '2018-04-05 00:00:00'::timestamp); +-- +ok +== +select time_bucket('1 day - 172800 seconds'::interval, '2018-05-05 00:00:00'::timestamp); +-- +ok +== +select time_bucket('1 day - 172800 seconds'::interval, '2018-05-05 00:00:00'::timestamp, '1 hour 30 minutes':: interval); +-- +ok +== +select time_bucket('1 day - 172800 seconds'::interval, '2018-05-05 00:00:00'::timestamp, '2018-05-05 00:00:00'::timestamp); +-- +ok +== +select time_bucket('1 month 1 day'::interval, '2018-05-05 00:00:00'::timestamp); +-- +ok +== +select time_bucket('1 month 1 day'::interval, '2018-05-05 00:00:00'::timestamp, '1 hour 30 minutes':: interval); +-- +ok +== +select time_bucket('1 month 1 day'::interval, '2018-05-05 00:00:00'::timestamp, '2018-05-05 00:00:00'::timestamp); +-- +ok +== +select time_bucket('3 days'::interval, '2019-05-05 00:00:00'::timestamp, '2000000000 months'::interval); +-- +ok +== +select time_bucket('3 days'::interval, '2019-05-05 00:00:00'::timestamp, '-2000000000 months'::interval); +-- +ok +== +select time_bucket('3 months'::interval, '2019-05-05 00:00:00'::timestamp, '2000000000 months'::interval); +-- +ok +== +select time_bucket('3 months'::interval, '2019-05-05 00:00:00'::timestamp, '-2000000000 months'::interval); +-- +ok +== +select time_bucket('1 microseconds'::interval, '290309-12-21 (BC) 23:59:59.999999'::timestamp); +-- +ok +== +select time_bucket('1 microseconds'::interval, '290309-12-22 (BC) 00:00:00'::timestamp); +-- +ok +== +select time_bucket('1 microseconds'::interval, '294247-01-10 04:00:54.775807'::timestamp); +-- +ok +== +select time_bucket('1 microseconds'::interval, '294247-01-10 04:00:54.775806'::timestamp); +-- +ok +== +select time_bucket('1 month 1 day'::interval, null::timestamp); +-- +ok +== +select time_bucket('1 month 1 day'::interval, null::timestamp, '6 days'::interval); +-- +ok +== +select time_bucket('1 month 1 day'::interval, null::timestamp, '2022-12-20 10:00:00'::timestamp); +-- +ok +== +select time_bucket('-1 month'::interval, null::timestamp); +-- +ok +== +select time_bucket('-1 month'::interval, null::timestamp, '6 days'::interval); +-- +ok +== +select time_bucket('-1 month'::interval, '2022-12-22 10:00:00'::timestamp, null::interval); +-- +ok +== +select time_bucket('-1 month'::interval, null::timestamp, '2022-12-20 10:00:00'::timestamp); +-- +ok +== +select time_bucket('-1 month'::interval, '2022-12-22'::timestamp, null::timestamp); +-- +ok +== +SELECT time_bucket(INTERVAL '106751991' DAY, TIMESTAMP '1800-01-01 00:00:00', TIMESTAMP '1900-01-01 00:00:00'); +-- +ok +== diff --git a/parser/testdata/corpus/sql/function/timestamp/test_try_strptime.test b/parser/testdata/corpus/sql/function/timestamp/test_try_strptime.test new file mode 100644 index 0000000..eebd35d --- /dev/null +++ b/parser/testdata/corpus/sql/function/timestamp/test_try_strptime.test @@ -0,0 +1,489 @@ +# source: test/sql/function/timestamp/test_try_strptime.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +SELECT try_strptime('21/10/2018', '%d/%m/%Y') +-- +ok +== +SELECT try_strptime('2018-20-10', '%Y-%d-%m') +-- +ok +== +SELECT try_strptime('20182010', '%Y%d%m') +-- +ok +== +SELECT try_strptime('Mon 30, June 2003, 12:03:10 AM', '%a %d, %B %Y, %I:%M:%S %p') +-- +ok +== +SELECT try_strptime('Mon 30, June 2003, 12:03:10 PM', '%a %d, %B %Y, %I:%M:%S %p') +-- +ok +== +SELECT try_strptime('Mon 30, December 2003, 7:3:5 PM', '%a %d, %B %Y, %I:%M:%S %p') +-- +ok +== +SELECT try_strptime('Tuesday 30, December 2003, 7:3:5 PM', '%A %d, %B %Y, %I:%M:%S %p') +-- +ok +== +SELECT try_strptime('Mon 30, December 30, 7:3:5 PM', '%a %d, %B %y, %I:%M:%S %p') +-- +ok +== +SELECT try_strptime('Mon 30, June 2003, 12:03:10 AM', '%a %-d, %B %Y, %-I:%-M:%-S %p') +-- +ok +== +SELECT try_strptime('mon', '%a') +-- +ok +== +SELECT try_strptime('tuesday', '%A') +-- +ok +== +SELECT try_strptime('jun', '%b') +-- +ok +== +SELECT try_strptime('1', '%W') +-- +ok +== +SELECT try_strptime('1', '%U') +-- +ok +== +SELECT try_strptime('1', '%V') +-- +ok +== +SELECT try_strptime('30', '%U'), strftime('1900-07-29'::DATE, '%U') +-- +ok +== +SELECT try_strptime('30', '%W'), strftime('1900-07-23'::DATE, '%W') +-- +ok +== +SELECT try_strptime('30', '%V'), strftime('1900-07-23'::DATE, '%V') +-- +ok +== +SELECT try_strptime('6', '%w') +-- +ok +== +SELECT try_strptime('6', '%u') +-- +ok +== +SELECT try_strptime('1-4', '%U-%w'), strftime('1900-01-11'::DATE, '%U-%w') +-- +ok +== +SELECT try_strptime('2-4', '%V-%u'), strftime('1900-01-11'::DATE, '%V-%u') +-- +ok +== +SELECT try_strptime('1-4', '%W-%w'), strftime('1900-01-04'::DATE, '%W-%w') +-- +ok +== +SELECT try_strptime('1-4', '%V-%u'), strftime('1900-01-04'::DATE, '%V-%u') +-- +ok +== +SELECT try_strptime('30', '%j'), strftime('1900-01-30'::DATE, '%-j') +-- +ok +== +SELECT try_strptime('1992-01-30 30', '%Y-%m-%d %j') +-- +ok +== +SELECT try_strptime('2021-19-4', '%Y-%U-%w'), strftime('2021-05-13'::DATE, '%Y-%U-%w') +-- +ok +== +SELECT try_strptime('2021-19-4', '%Y-%W-%w'), strftime('2021-05-13'::DATE, '%Y-%U-%w') +-- +ok +== +SELECT try_strptime('2021-19-4', '%G-%V-%u'), strftime('2021-05-13'::DATE, '%G-%V-%u') +-- +ok +== +SELECT try_strptime('2021-0-5', '%Y-%U-%w'), strftime('2021-01-01'::DATE, '%Y-%U-%w') +-- +ok +== +SELECT try_strptime('2021-0-5', '%Y-%W-%w'), strftime('2021-01-01'::DATE, '%Y-%W-%w') +-- +ok +== +SELECT try_strptime('2021-1-5', '%G-%V-%u'), strftime('2021-01-08'::DATE, '%G-%V-%u') +-- +ok +== +SELECT try_strptime('2021-05-12 19-4', '%Y-%m-%d %U-%w') +-- +ok +== +SELECT try_strptime('2021-05-12 19-4', '%Y-%m-%d %W-%w') +-- +ok +== +SELECT try_strptime('2021-05-12 19-4', '%Y-%m-%d %V-%u') +-- +ok +== +SELECT * FROM ( + SELECT dt, strftime(dt, '%Y-%U-%w') AS ft, try_strptime(strftime(dt, '%Y-%U-%w'), '%Y-%U-%w') AS rt + FROM (SELECT '2021-01-01'::DATE + (INTERVAL (d) DAY) AS dt FROM range(365) tbl(d)) days +) diffs +WHERE rt <> dt +-- +ok +== +SELECT * FROM ( + SELECT dt, strftime(dt, '%Y-%W-%w') AS ft, try_strptime(strftime(dt, '%Y-%W-%w'), '%Y-%W-%w') AS rt + FROM (SELECT '2021-01-01'::DATE + (INTERVAL (d) DAY) AS dt FROM range(365) tbl(d)) days +) diffs +WHERE rt <> dt +-- +ok +== +SELECT * FROM ( + SELECT dt, strftime(dt, '%G-%V-%u') AS ft, try_strptime(strftime(dt, '%G-%V-%u'), '%G-%V-%u') AS rt + FROM (SELECT '2021-01-01'::DATE + (INTERVAL (d) DAY) AS dt FROM range(365) tbl(d)) days +) diffs +WHERE rt <> dt +-- +ok +== +SELECT try_strptime('', '') +-- +ok +== +SELECT try_strptime(NULL, '') +-- +ok +== +SELECT try_strptime('', NULL) +-- +ok +== +SELECT try_strptime('Jun 30 2003 2:03:10AM', '%b %d %Y %-I:%M:%S%p'); +-- +ok +== +select try_strptime('2020-12-31 21:25:58.745232', '%Y-%m-%d %H:%M:%S.%f'); +-- +ok +== +select try_strptime('2020-12-31 21:25:58.745232+00', '%Y-%m-%d %H:%M:%S.%f%z'); +-- +ok +== +select try_strptime('2020-12-31 21:25:58.745232+0000', '%Y-%m-%d %H:%M:%S.%f%z'); +-- +ok +== +select try_strptime('2020-12-31 21:25:58.745232+02', '%Y-%m-%d %H:%M:%S.%f%z'); +-- +ok +== +select try_strptime('2020-12-31 21:25:58.745232-02', '%Y-%m-%d %H:%M:%S.%f%z'); +-- +ok +== +select try_strptime('2020-12-31 21:25:58.745232+0215', '%Y-%m-%d %H:%M:%S.%f%z'); +-- +ok +== +select try_strptime('2020-12-31 21:25:58.745232-0215', '%Y-%m-%d %H:%M:%S.%f%z'); +-- +ok +== +select try_strptime('2020-12-31 03:25:58.745232+04', '%Y-%m-%d %H:%M:%S.%f%z'); +-- +ok +== +select try_strptime('2020-12-30 23:25:58.745232-04', '%Y-%m-%d %H:%M:%S.%f%z'); +-- +ok +== +SELECT try_strptime('Mon Oct 17 2022 22:00:00 GMT+0000 (GMT)', '%a %b %d %Y %X GMT%z (%Z)') as fixed; +-- +ok +== +SELECT try_strptime('Mon Oct 17 2022 22:00:00 GMT+0000 (GMT', '%a %b %d %Y %X GMT%z (%Z') as working; +-- +ok +== +SELECT try_strptime('Mon Oct 17 2022 22:00:00 GMT+0000 (GMT)', '%a %b %d %Y %X GMT%z (%Z') as broken; +-- +ok +== +SELECT try_strptime('10/28/1910', ['%d-%m-%Y', '%m-%d-%Y', '%d/%m/%Y', '%m/%d/%Y']) +-- +ok +== +SELECT try_strptime('10.28.1910', ['%d-%m-%Y', '%m-%d-%Y', '%d/%m/%Y', '%m/%d/%Y']) +-- +ok +== +select try_strptime('2020-12-31 21:25:58.745232+0', '%Y-%m-%d %H:%M:%S.%f%z'); +-- +ok +== +select try_strptime('2020-12-31 21:25:58.745232+0X', '%Y-%m-%d %H:%M:%S.%f%z'); +-- +ok +== +select try_strptime('2020-12-31 21:25:58.745232+X0', '%Y-%m-%d %H:%M:%S.%f%z'); +-- +ok +== +select try_strptime('2020-12-31 21:25:58.745232+000', '%Y-%m-%d %H:%M:%S.%f%z'); +-- +ok +== +select try_strptime('2020-12-31 21:25:58.745232X00', '%Y-%m-%d %H:%M:%S.%f%z'); +-- +ok +== +SELECT try_strptime('2018-20-10', '%Y-%m-%d') +-- +ok +== +SELECT try_strptime('2018-10-100', '%Y-%m-%d') +-- +ok +== +SELECT try_strptime('969-10-10', '%y-%m-%d') +-- +ok +== +SELECT try_strptime('2000/10/10', '%Y-%m-%d') +-- +ok +== +SELECT try_strptime('2001-02-30', '%Y-%m-%d') +-- +ok +== +SELECT try_strptime('2000-10-hello', '%Y-%m-%d') +-- +ok +== +SELECT try_strptime('2000-10-01 24:00:00', '%Y-%m-%d %H:%M:%S') +-- +ok +== +SELECT try_strptime('2000-10-01 00:00:00 AM', '%Y-%m-%d %I:%M:%S %p') +-- +ok +== +SELECT try_strptime('2000-10-01 13:00:00 AM', '%Y-%m-%d %I:%M:%S %p') +-- +ok +== +SELECT try_strptime('2000-10-01 23:60:00', '%Y-%m-%d %H:%M:%S') +-- +ok +== +SELECT try_strptime('2000-10-01 23:59:60', '%Y-%m-%d %H:%M:%S') +-- +ok +== +SELECT try_strptime('2000-10-01 23:59:59.10000000', '%Y-%m-%d %H:%M:%S.%f') +-- +ok +== +SELECT try_strptime('2000-10-01 23:59:59.1000000000000000000000000000', '%Y-%m-%d %H:%M:%S.%f') +-- +ok +== +SELECT try_strptime('', '%Y-%m-%d %H:%M:%S.%f') +-- +ok +== +SELECT try_strptime('', '%p') +-- +ok +== +SELECT try_strptime('a', '%p') +-- +ok +== +SELECT try_strptime('mp', '%p') +-- +ok +== +SELECT try_strptime('pp', '%p') +-- +ok +== +SELECT try_strptime('zm', '%p') +-- +ok +== +SELECT try_strptime('moa', '%a') +-- +ok +== +SELECT try_strptime('moaday', '%A') +-- +ok +== +SELECT try_strptime('mondayy', '%A') +-- +ok +== +SELECT try_strptime('juk', '%b') +-- +ok +== +SELECT try_strptime('juke', '%B') +-- +ok +== +SELECT try_strptime('junee', '%B') +-- +ok +== +SELECT try_strptime('500', '%j') +-- +ok +== +SELECT try_strptime('500', '%-j') +-- +ok +== +SELECT try_strptime('0', '%j') +-- +ok +== +SELECT try_strptime('0', '%-j') +-- +ok +== +SELECT try_strptime('60', '%U') +-- +ok +== +SELECT try_strptime('60', '%W') +-- +ok +== +SELECT try_strptime('60', '%V') +-- +ok +== +SELECT try_strptime('9', '%w') +-- +ok +== +SELECT try_strptime('9', '%u') +-- +ok +== +SELECT try_strptime('20 19', '%U %W') +-- +ok +== +SELECT try_strptime('20 19', '%U %V') +-- +ok +== +SELECT try_strptime('20 2021', '%U %G') +-- +ok +== +SELECT try_strptime('20 19', '%U %j') +-- +ok +== +SELECT try_strptime('20 19', '%W %U') +-- +ok +== +SELECT try_strptime('20 19', '%W %V') +-- +ok +== +SELECT try_strptime('20 2021', '%W %G') +-- +ok +== +SELECT try_strptime('20 19', '%W %j') +-- +ok +== +SELECT try_strptime('20 19', '%V %U') +-- +ok +== +SELECT try_strptime('20 19', '%V %W') +-- +ok +== +SELECT try_strptime('20 19', '%V %j') +-- +ok +== +SELECT try_strptime('2021 19', '%G %U') +-- +ok +== +SELECT try_strptime('2021 19', '%G %W') +-- +ok +== +SELECT try_strptime('2021 19', '%G %j') +-- +ok +== +SELECT try_strptime('2021 1950', '%G %Y') +-- +ok +== +SELECT try_strptime('2021 1950', '%Y %G') +-- +ok +== +SELECT try_strptime('20 1950', '%V %Y') +-- +ok +== +SELECT try_strptime('2021 19', '%Y %V') +-- +ok +== +SELECT try_strptime('Mon 30, December 30, 20:3:5 PM', '%a %d, %B %y, %H:%M:%S %p') +-- +ok +== +SELECT try_strptime('9999999', '%f') +-- +ok +== +SELECT try_strptime('9999', '%g') +-- +ok +== +SELECT try_strptime('21/10/2018', '%-q/%m/%Y') +-- +ok +== +SELECT try_strptime('2000/10/10', random()::varchar) +-- +ok +== diff --git a/parser/testdata/corpus/sql/function/timetz/test_date_part.test b/parser/testdata/corpus/sql/function/timetz/test_date_part.test new file mode 100644 index 0000000..ccb95c5 --- /dev/null +++ b/parser/testdata/corpus/sql/function/timetz/test_date_part.test @@ -0,0 +1,154 @@ +# source: test/sql/function/timetz/test_date_part.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +CREATE TABLE timetzs(d TIMETZ, s VARCHAR); +-- +ok +== +INSERT INTO timetzs VALUES + (NULL, NULL), + ('00:00:00+1559', 'timezone'), + ('00:00:00+1558', 'timezone_hour'), + ('02:30:00', 'hour'), + ('02:30:00+04', 'timezone_hour'), + ('02:30:00+04:30', 'timezone_minute'), + ('02:30:00+04:30:45', 'timezone_minute'), + ('16:15:03.123456', 'microseconds'), + ('02:30:00+1200', 'minute'), + ('02:30:00-1200', 'second'), + ('24:00:00-1558', 'timezone_hour'), + ('24:00:00-1559', 'timezone'), + ; +-- +ok +== +SELECT date_part(NULL::VARCHAR, NULL::TIMETZ) FROM timetzs; +-- +ok +== +SELECT date_part(s, NULL::TIMETZ) FROM timetzs; +-- +ok +== +SELECT date_part(NULL, d) FROM timetzs; +-- +ok +== +SELECT date_part(s, '14:28:50.447+07:15'::TIMETZ) FROM timetzs; +-- +ok +== +SELECT date_part('hour', d) FROM timetzs; +-- +ok +== +SELECT date_part(s, d) FROM timetzs; +-- +ok +== +select date_part('{datepart}', '10:00:00'::TIMETZ); +-- +ok +== +SELECT era(d) FROM timetzs +-- +ok +== +SELECT year(d) FROM timetzs +-- +ok +== +SELECT month(d) FROM timetzs +-- +ok +== +SELECT day(d) FROM timetzs +-- +ok +== +SELECT decade(d) FROM timetzs +-- +ok +== +SELECT century(d) FROM timetzs +-- +ok +== +SELECT millennium(d) FROM timetzs +-- +ok +== +SELECT quarter(d) FROM timetzs +-- +ok +== +SELECT dayofweek(d) FROM timetzs +-- +ok +== +SELECT isodow(d) FROM timetzs +-- +ok +== +SELECT dayofyear(d) FROM timetzs +-- +ok +== +SELECT week(d) FROM timetzs +-- +ok +== +SELECT yearweek(d) FROM timetzs +-- +ok +== +SELECT * FROM ( + SELECT d, DATE_PART('{partcode}', d) AS p, {partcode}(d) AS f + FROM timetzs +) tbl +WHERE p <> f; +-- +error: Parser Error: syntax error at or near "}" +== +SELECT d, DATE_PART('{partcode}', d) AS p, DATE_PART(['{partcode}'], d) AS st +FROM timetzs +WHERE p <> st['{partcode}']; +-- +ok +== +SELECT d, DATE_PART(['hour', 'minute', 'microsecond'], d) AS parts +FROM timetzs +ORDER BY 1; +-- +ok +== +SELECT d, DATE_PART(['epoch', 'second', 'timezone', 'timezone_hour', 'timezone_minute'], d) AS parts +FROM timetzs +ORDER BY 1; +-- +ok +== +SELECT d, epoch_ns(d) FROM timetzs ORDER BY ALL; +-- +ok +== +SELECT d, epoch_us(d) FROM timetzs ORDER BY ALL; +-- +ok +== +SELECT d, epoch_ms(d) FROM timetzs ORDER BY ALL; +-- +ok +== +SELECT d, nanosecond(d) FROM timetzs ORDER BY ALL; +-- +ok +== +SELECT d, DATE_PART(['{datepart}'], d) AS parts +FROM timetzs +ORDER BY 1; +-- +ok +== diff --git a/parser/testdata/corpus/sql/function/timetz/test_extract.test b/parser/testdata/corpus/sql/function/timetz/test_extract.test new file mode 100644 index 0000000..38af688 --- /dev/null +++ b/parser/testdata/corpus/sql/function/timetz/test_extract.test @@ -0,0 +1,33 @@ +# source: test/sql/function/timetz/test_extract.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +CREATE TABLE timetzs (i TIMETZ); +-- +ok +== +SELECT EXTRACT(second FROM i) FROM timetzs +-- +ok +== +SELECT EXTRACT(minute FROM i) FROM timetzs +-- +ok +== +SELECT EXTRACT(hour FROM i) FROM timetzs +-- +ok +== +SELECT EXTRACT(milliseconds FROM i) FROM timetzs +-- +ok +== +SELECT EXTRACT(microseconds FROM i) FROM timetzs +-- +ok +== +SELECT EXTRACT(epoch FROM i) FROM timetzs +-- +ok +== diff --git a/parser/testdata/corpus/sql/function/timetz/timetz_group_by.test b/parser/testdata/corpus/sql/function/timetz/timetz_group_by.test new file mode 100644 index 0000000..d07d71b --- /dev/null +++ b/parser/testdata/corpus/sql/function/timetz/timetz_group_by.test @@ -0,0 +1,13 @@ +# source: test/sql/function/timetz/timetz_group_by.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +create table time_testtz as select i::timetz as t from generate_series(TIMESTAMPtz '2001-04-10', TIMESTAMPtz '2001-04-11', INTERVAL 30 MINUTE) as t(i); +-- +ok +== +SELECT TYPEOF(t) FROM (select t from time_testtz group by t) LIMIT 1 +-- +ok +== diff --git a/parser/testdata/corpus/sql/function/tokenize/simple_tokenize.test b/parser/testdata/corpus/sql/function/tokenize/simple_tokenize.test new file mode 100644 index 0000000..94cfcc9 --- /dev/null +++ b/parser/testdata/corpus/sql/function/tokenize/simple_tokenize.test @@ -0,0 +1,85 @@ +# source: test/sql/function/tokenize/simple_tokenize.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +select start, token_type, word from sql_tokenize($$select a$$); +-- +ok +== +select start, token_type, word from sql_tokenize($$select a;$$); +-- +ok +== +select start, token_type, word from sql_tokenize($$select 'a' - 1;$$); +-- +ok +== +select start, token_type, word from sql_tokenize($TEST_TOKENIZER$select $$dollar$$;$TEST_TOKENIZER$); +-- +ok +== +select start, token_type, word from sql_tokenize($$select $tag$val$ue$tag$;$$); +-- +ok +== +select start, token_type, word from sql_tokenize($$select "column name" from "Table";$$); +-- +ok +== +select start, token_type, word from sql_tokenize($$select (a + b) * 2, c;$$); +-- +ok +== +select start, token_type, word from sql_tokenize($$select 1; -- this is a comment$$); +-- +ok +== +select start, token_type, word from sql_tokenize($$SELECT 1 /* I /* love */ comments */ + 2;$$); +-- +ok +== +select start, token_type, word from sql_tokenize($$SELECT 1 -- /* not a block */ rest$$); +-- +ok +== +select start, token_type, word from sql_tokenize($$select * fro$$); +-- +ok +== +select start, token_type, word from sql_tokenize($$crea tab$$); +-- +ok +== +select start, token_type, word from sql_tokenize($$select 1.5, 1e2$$); +-- +ok +== +select start, token_type, word from sql_tokenize($$select 'O''Neil', "My ""Table""";$$); +-- +ok +== +select start, token_type, word from sql_tokenize($$from ''hello world';$$); +-- +ok +== +select start, token_type, word from sql_tokenize($$select json::json from json$$); +-- +ok +== +select start, token_type, word from sql_tokenize($$select json::json from$$); +-- +ok +== +select start, token_type, word from sql_tokenize('from ''hello world'''); +-- +ok +== +select start, token_type, word from sql_tokenize('from ''hello world'); +-- +ok +== +select start, token_type, word from sql_tokenize($$select r.e100$$); +-- +ok +== diff --git a/parser/testdata/corpus/sql/function/uuid/test_uuid.test b/parser/testdata/corpus/sql/function/uuid/test_uuid.test new file mode 100644 index 0000000..5b4812d --- /dev/null +++ b/parser/testdata/corpus/sql/function/uuid/test_uuid.test @@ -0,0 +1,55 @@ +# source: test/sql/function/uuid/test_uuid.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +CREATE TEMPORARY TABLE t1 AS SELECT gen_random_uuid() a FROM range(0, 16); +-- +ok +== +CREATE TEMPORARY TABLE t2 AS SELECT uuid() b FROM range(0, 16); +-- +ok +== +CREATE TEMPORARY TABLE t3 AS SELECT gen_random_uuid() c FROM range(0, 16); +-- +ok +== +CREATE TABLE uuids(u UUID NOT NULL DEFAULT gen_random_uuid(), a INTEGER); +-- +ok +== +INSERT INTO uuids (a) VALUES (1), (2), (3), (4), (5), (6), (7), (8), (9), (10); +-- +ok +== +SELECT COUNT(DISTINCT u) FROM uuids; +-- +ok +== +SELECT * FROM uuids ORDER BY gen_random_uuid(); +-- +ok +== +SELECT gen_random_uuid() FROM uuids; +SELECT uuidv4() FROM uuids; +SELECT uuidv7() FROM uuids; +-- +ok +== +SELECT DISTINCT substring(uuid()::varchar, 15, 1) FROM range(100); +-- +ok +== +SELECT DISTINCT substring(uuidv4()::varchar, 15, 1) FROM range(100); +-- +ok +== +SELECT DISTINCT substring(uuidv7()::varchar, 15, 1) FROM range(100); +-- +ok +== +SELECT DISTINCT substring(uuid()::varchar, 20, 1) AS x FROM range(100) ORDER BY x +-- +ok +== diff --git a/parser/testdata/corpus/sql/function/uuid/test_uuid_function.test b/parser/testdata/corpus/sql/function/uuid/test_uuid_function.test new file mode 100644 index 0000000..9858c54 --- /dev/null +++ b/parser/testdata/corpus/sql/function/uuid/test_uuid_function.test @@ -0,0 +1,37 @@ +# source: test/sql/function/uuid/test_uuid_function.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +SELECT uuid_extract_version('ac227128-7d55-7ee0-a765-5025cc52e55a'); +-- +ok +== +SELECT uuid_extract_version(uuidv7()); +-- +ok +== +SELECT uuid_extract_version('ac227128-7d55-4ee0-a765-5025cc52e55a'); +-- +ok +== +SELECT uuid_extract_version(uuidv4()); +-- +ok +== +SELECT uuid_extract_version(gen_random_uuid()); +-- +ok +== +SELECT uuid_extract_timestamp(uuidv4()); +-- +ok +== +SELECT uuid_extract_timestamp('0196f97a-db14-71c3-9132-9f0b1334466f'); +-- +ok +== +SELECT datediff('month', uuid_extract_timestamp(uuidv7()), now()); +-- +ok +== diff --git a/parser/testdata/corpus/sql/function/variant/variant_array_length.test b/parser/testdata/corpus/sql/function/variant/variant_array_length.test new file mode 100644 index 0000000..1429aed --- /dev/null +++ b/parser/testdata/corpus/sql/function/variant/variant_array_length.test @@ -0,0 +1,150 @@ +# source: test/sql/function/variant/variant_array_length.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +CREATE MACRO struct_cast_data() AS TABLE ( + SELECT {'a': [ + { + 'b': 'hello', + 'c': NULL, + 'a': '1970/03/15'::DATE + }, + { + 'b': NULL, + 'c': True, + 'a': '2020/11/03'::DATE + } + ]}::VARIANT AS a + UNION ALL + SELECT {'a': [ + { + 'b': 'this is a long string', + 'c': False, + 'a': '1953/9/16'::DATE + } + ], + 'b': 42, + 'c': { + 'd': 'world' + }}::VARIANT +); +-- +ok +== +select variant_array_length('{"a": [1, 2], "b": {"c": 12, "d": 10}}', 'a'); +-- +ok +== +select variant_array_length(a, '') from struct_cast_data(); +-- +ok +== +select variant_array_length([1, 2]::VARIANT, ''); +-- +ok +== +select variant_array_length(a, []) from struct_cast_data(); +-- +ok +== +select variant_array_length(a, ['']) from struct_cast_data(); +-- +ok +== +select variant_array_length([1, 2]::VARIANT, ['']); +-- +ok +== +select variant_array_length(a, 'a') from struct_cast_data(); +-- +ok +== +select variant_array_length(a, ['a']) from struct_cast_data(); +-- +ok +== +select variant_array_length(a, ['a', 'c']) from struct_cast_data(); +-- +ok +== +select variant_array_length(MAP {'a': 1, 'b': 2}::VARIANT, 'a'); +-- +ok +== +select variant_array_length(NULL::VARIANT, NULL); +-- +ok +== +select variant_array_length(NULL, NULL); +-- +ok +== +select variant_array_length(NULL::VARIANT, 'a'); +-- +ok +== +select variant_array_length(j, 'a') from (values ({'a': [1, 2]}::VARIANT), (NULL::VARIANT)) t(j); +-- +ok +== +select variant_array_length(j, ['a', 'b']) from (values ({'a': [1, 2]}::VARIANT), (NULL::VARIANT)) t(j); +-- +ok +== +select variant_array_length({'a': 1}::VARIANT, NULL); +-- +ok +== +select variant_array_length({'a': 1, 'b': {'c': [1, 2, 3]}}::VARIANT, '$.b.c'); +-- +ok +== +select variant_array_length({'a': 1}::VARIANT, [1]); +-- +ok +== +select variant_array_length({'a': []}::VARIANT, [NULL]); +-- +ok +== +select variant_array_length({'a': []}::VARIANT, [NULL::VARCHAR]); +-- +ok +== +select variant_array_length({'c': []}::VARIANT, ['c', NULL]::VARCHAR[]); +-- +ok +== +select variant_array_length({'c': []}::VARIANT, []::VARCHAR[]); +-- +ok +== +select variant_array_length('{"a"\: 1}'::VARIANT, 'a'); +-- +ok +== +create table t1 as +select range, case when range % 2 = 0 then {"duck": [42]}::VARIANT else {"duck": [42, 42]}::VARIANT end j +from range(4096) +-- +ok +== +select range % 2 g, sum(variant_array_length(j, 'duck')) c +from t1 +group by g +order by all +-- +ok +== +create table t2 as +select range, {'duck': [42], 'goose': [42, 43]}::VARIANT j +from range(4096) +-- +ok +== +select sum(list_sum([l for l in variant_array_length(j, ['duck', 'goose'])])) s +from t2 +-- +ok +== diff --git a/parser/testdata/corpus/sql/function/variant/variant_array_length_shredded.test b/parser/testdata/corpus/sql/function/variant/variant_array_length_shredded.test new file mode 100644 index 0000000..a30a82a --- /dev/null +++ b/parser/testdata/corpus/sql/function/variant/variant_array_length_shredded.test @@ -0,0 +1,68 @@ +# source: test/sql/function/variant/variant_array_length_shredded.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +SET variant_minimum_shredding_size = 0; +-- +ok +== +SET force_variant_shredding = 'STRUCT(arr INTEGER[], scalar INTEGER)'; +-- +ok +== +CREATE TABLE variants(id INTEGER, v VARIANT); +-- +ok +== +INSERT INTO variants VALUES + -- array with items + (1, {'arr': [10, 20], 'scalar': 7}::VARIANT), + -- empty array + (2, {'arr': [], 'scalar': 8}::VARIANT), + -- VARIANT_NULL + (3, {'arr': NULL, 'scalar': 9}::VARIANT), + -- missing value in shredded schema + (4, {'scalar': 10}::VARIANT), + -- root with different type than shredded schema + (5, 42::VARIANT), + -- SQL-NULL + (6, NULL::VARIANT); +-- +ok +== +SELECT DISTINCT vector_type(v) FROM variants; +-- +ok +== +SELECT variant_array_length(v, 'arr') FROM variants ORDER BY id; +-- +ok +== +SELECT variant_array_length(v, ['arr', 'scalar', 'missing']) FROM variants ORDER BY id; +-- +ok +== +SET force_variant_shredding = 'INTEGER[]'; +-- +ok +== +CREATE TABLE fully_shredded_arrays(id INTEGER, v VARIANT); +-- +ok +== +INSERT INTO fully_shredded_arrays VALUES + (1, [1, 2, 3]::VARIANT), + (2, []::INTEGER[]::VARIANT), + (3, NULL::VARIANT); +-- +ok +== +SELECT DISTINCT vector_type(v) FROM fully_shredded_arrays; +-- +ok +== +SELECT variant_array_length(v) FROM fully_shredded_arrays ORDER BY id; +-- +ok +== diff --git a/parser/testdata/corpus/sql/function/variant/variant_contains.test b/parser/testdata/corpus/sql/function/variant/variant_contains.test new file mode 100644 index 0000000..b60bf09 --- /dev/null +++ b/parser/testdata/corpus/sql/function/variant/variant_contains.test @@ -0,0 +1,237 @@ +# source: test/sql/function/variant/variant_contains.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +SELECT variant_contains(({haystack})::VARIANT, ({needle})::VARIANT); +-- +error: Parser Error: syntax error at or near "}" +== +SELECT variant_contains(1::{dst}::VARIANT, 1::{src}::VARIANT); +-- +error: Parser Error: syntax error at or near "{" +== +SELECT variant_contains(1.0::{dst}::VARIANT, 1.0::{src}::VARIANT); +-- +error: Parser Error: syntax error at or near "{" +== +SELECT variant_contains('2020-01-01'::{dst}::VARIANT, '2020-01-01'::{src}::VARIANT); +-- +error: Parser Error: syntax error at or near "{" +== +SELECT variant_contains('2020-01-01 12:34:56+00'::{dst}::VARIANT, + '2020-01-01 12:34:56+00'::{src}::VARIANT); +-- +error: Parser Error: syntax error at or near "{" +== +SELECT variant_contains('12:34:56'::{dst}::VARIANT, '12:34:56'::{src}::VARIANT); +-- +error: Parser Error: syntax error at or near "{" +== +SELECT variant_contains({value}::{haystack_type}::VARIANT, {value}::{needle_type}::VARIANT); +-- +error: Parser Error: syntax error at or near "}" +== +SELECT + variant_contains('550e8400-e29b-41d4-a716-446655440000'::UUID::VARIANT, + '550e8400-e29b-41d4-a716-446655440000'::UUID::VARIANT), + variant_contains(INTERVAL '1 month 2 days'::VARIANT, INTERVAL '1 month 2 days'::VARIANT), + variant_contains('1010'::BIT::VARIANT, '1010'::BIT::VARIANT), + variant_contains('duck'::BLOB::VARIANT, 'duck'::BLOB::VARIANT); +-- +ok +== +SELECT + variant_contains('550e8400-e29b-41d4-a716-446655440000'::UUID::VARIANT, + '550e8400-e29b-41d4-a716-446655440001'::UUID::VARIANT), + variant_contains(INTERVAL '1 month 2 days'::VARIANT, INTERVAL '1 month 3 days'::VARIANT), + variant_contains('1010'::BIT::VARIANT, '1011'::BIT::VARIANT), + variant_contains('duck'::BLOB::VARIANT, 'goose'::BLOB::VARIANT); +-- +ok +== +CREATE MACRO variant_contains_self(value) AS variant_contains(value::VARIANT, value::VARIANT); +-- +ok +== +SELECT list_bool_and(results) AND list_count(results) = length(results) +FROM ( + SELECT [*COLUMNS(*)] AS results + FROM ( + SELECT variant_contains_self( + COLUMNS(lambda c: NOT regexp_matches(c, 'array|struct|map|union|tuple')) + ) + FROM test_all_types() + WHERE bool IS NOT NULL + ) +); +-- +ok +== +SELECT + variant_contains('{"a": {"b": [1, 2, 3]}}'::JSON::VARIANT, 2::VARIANT), + variant_contains('{"a": {"b": [1, 2, 3]}}'::JSON::VARIANT, 4::VARIANT), + variant_contains('{"a": 1}'::JSON::VARIANT, 'a'::VARIANT), + variant_contains('[{"a": "needle"}]'::JSON::VARIANT, 'needle'::VARIANT); +-- +ok +== +SELECT + variant_contains('{"a": 1, "b": 2}'::JSON::VARIANT, '{"a": 1}'::JSON::VARIANT), + variant_contains('{"a": 1, "b": 2}'::JSON::VARIANT, '{"b": 2, "a": 1}'::JSON::VARIANT), + variant_contains('{"a": 1}'::JSON::VARIANT, '{"a": 1, "b": 2}'::JSON::VARIANT), + variant_contains('{"a": 1}'::JSON::VARIANT, '{"b": 1}'::JSON::VARIANT); +-- +ok +== +SELECT + variant_contains('{"a": {"b": [{"c": 1, "d": 2}]}}'::JSON::VARIANT, + '{"d": 2}'::JSON::VARIANT), + variant_contains('{"a": {"b": [{"c": 1, "d": 2}]}}'::JSON::VARIANT, + '{"a": {"b": [{"c": 1}]}}'::JSON::VARIANT), + variant_contains('{"a": {"b": 42}}'::JSON::VARIANT, '{"a": 42}'::JSON::VARIANT); +-- +ok +== +SELECT variant_contains('[{"a": 1}, {"b": 2}]'::JSON::VARIANT, '{"a": 1, "b": 2}'::JSON::VARIANT); +-- +ok +== +SELECT + variant_contains('{"a": 1}'::JSON::VARIANT, '{}'::JSON::VARIANT), + variant_contains('[1, {"a": 2}]'::JSON::VARIANT, '{}'::JSON::VARIANT), + variant_contains('[1, 2]'::JSON::VARIANT, '{}'::JSON::VARIANT); +-- +ok +== +SELECT + variant_contains('[1, 2, 3]'::JSON::VARIANT, '[3, 1]'::JSON::VARIANT), + variant_contains('[1, 2]'::JSON::VARIANT, '[1, 2, 3]'::JSON::VARIANT), + variant_contains('[1, 2]'::JSON::VARIANT, '[3]'::JSON::VARIANT); +-- +ok +== +SELECT + variant_contains([1]::VARIANT, [1, 1]::VARIANT), + variant_contains('[{"a": 1, "b": 2}]'::JSON::VARIANT, '[{"a": 1}]'::JSON::VARIANT), + variant_contains('[{"a": 1}]'::JSON::VARIANT, '[{"a": 2}]'::JSON::VARIANT); +-- +ok +== +SELECT + variant_contains([1, 2]::VARIANT, []::INTEGER[]::VARIANT), + variant_contains('{"a": [1, 2]}'::JSON::VARIANT, '[]'::JSON::VARIANT), + variant_contains('{"a": 1}'::JSON::VARIANT, '[]'::JSON::VARIANT); +-- +ok +== +SELECT + variant_contains('100000000000000000000000000000000000000'::BIGNUM::VARIANT, + '100000000000000000000000000000000000000.0'::BIGNUM::VARIANT), + variant_contains(1::INTEGER::VARIANT, 1::DOUBLE::VARIANT); +-- +ok +== +SELECT + variant_contains((-1)::INTEGER::VARIANT, (-1)::DECIMAL(3, 2)::VARIANT), + variant_contains((0)::INTEGER::VARIANT, (-0.00)::DECIMAL(3, 2)::VARIANT), + variant_contains('-1'::BIGNUM::VARIANT, (-1)::BIGINT::VARIANT), + variant_contains(1::BIGINT::VARIANT, 1.1::DECIMAL(4, 2)::VARIANT); +-- +ok +== +SELECT + variant_contains(1.5::FLOAT::VARIANT, 1.5::DOUBLE::VARIANT), + variant_contains('NaN'::FLOAT::VARIANT, 'NaN'::DOUBLE::VARIANT), + variant_contains('-0.0'::DOUBLE::VARIANT, '0.0'::FLOAT::VARIANT), + variant_contains('Infinity'::FLOAT::VARIANT, 'Infinity'::DOUBLE::VARIANT); +-- +ok +== +SELECT + variant_contains('2020-01-01'::DATE::VARIANT, '2020-01-02'::TIMESTAMP::VARIANT), + variant_contains('2020-01-01 00:00:00.000001'::TIMESTAMP::VARIANT, + '2020-01-01 00:00:00'::TIMESTAMP_S::VARIANT), + variant_contains('12:34:56'::TIME::VARIANT, '12:34:57'::TIME_NS::VARIANT), + variant_contains('2020-01-01 00:00:00+00'::TIMESTAMPTZ::VARIANT, + '2020-01-01 00:00:00+01'::TIMESTAMPTZ::VARIANT); +-- +ok +== +SELECT + variant_contains('2020-01-01 00:00:00+00'::TIMESTAMPTZ::VARIANT, + '2020-01-01 01:00:00+01'::TIMESTAMPTZ::VARIANT), + variant_contains('2020-01-01 00:00:00+00'::TIMESTAMPTZ::VARIANT, + '2020-01-01 00:00:00+01'::TIMESTAMPTZ::VARIANT); +-- +ok +== +SELECT + variant_contains('2020-01-01 12:34:56'::TIMESTAMP::VARIANT, + '2020-01-01 12:34:56+00'::TIMESTAMPTZ::VARIANT), + variant_contains('12:34:56'::TIME::VARIANT, '12:34:56+00'::TIMETZ::VARIANT), + variant_contains('12:34:56+02'::TIMETZ::VARIANT, '12:34:56+02'::TIMETZ::VARIANT), + variant_contains('12:34:56+02'::TIMETZ::VARIANT, '12:34:56+03'::TIMETZ::VARIANT); +-- +ok +== +SELECT + variant_contains({'a': NULL}::VARIANT, {'a': NULL}::VARIANT), + variant_contains({'x': {'a': NULL}}::VARIANT, {'a': NULL}::VARIANT), + variant_contains([{'a': NULL}]::VARIANT, {'a': NULL}::VARIANT), + variant_contains({'a': 1}::VARIANT, {'a': NULL}::VARIANT); +-- +ok +== +SELECT + variant_contains(NULL::VARIANT, 1::VARIANT), + variant_contains(1::VARIANT, NULL::VARIANT), + variant_contains(NULL::VARIANT, NULL::VARIANT), + variant_contains(NULL, NULL); +-- +ok +== +CREATE TABLE contains_data(id INTEGER, haystack VARIANT, needle VARIANT); +-- +ok +== +INSERT INTO contains_data VALUES + (1, '{"a": 1}'::JSON::VARIANT, '{"a": 1}'::JSON::VARIANT), + (2, '{"a": 1}'::JSON::VARIANT, '{"b": 1}'::JSON::VARIANT), + (3, '[1, 2, 3]'::JSON::VARIANT, 2::VARIANT), + (4, '[1, 2, 3]'::JSON::VARIANT, 4::VARIANT), + (5, NULL::VARIANT, 1::VARIANT), + (6, '{"a": 1}'::JSON::VARIANT, NULL::VARIANT); +-- +ok +== +SELECT id, variant_contains(haystack, needle) FROM contains_data ORDER BY id; +-- +ok +== +CREATE TABLE varying_objects AS +SELECT + range AS id, + CASE + WHEN range % 2 = 0 THEN {'duck': 42}::VARIANT + ELSE {'duck': 42, 'goose': 43}::VARIANT + END AS haystack +FROM range(4096); +-- +ok +== +SELECT id % 2, count_if(variant_contains(haystack, {'goose': 43}::VARIANT)) +FROM varying_objects +GROUP BY ALL +ORDER BY ALL; +-- +ok +== +SELECT variant_contains(1::VARIANT); +-- +ok +== +SELECT variant_contains(1::VARIANT, 1::VARIANT, 1::VARIANT); +-- +ok +== diff --git a/parser/testdata/corpus/sql/function/variant/variant_contains_shredded.test b/parser/testdata/corpus/sql/function/variant/variant_contains_shredded.test new file mode 100644 index 0000000..e02661b --- /dev/null +++ b/parser/testdata/corpus/sql/function/variant/variant_contains_shredded.test @@ -0,0 +1,32 @@ +# source: test/sql/function/variant/variant_contains_shredded.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +SET force_variant_shredding = 'STRUCT(b INTEGER, a INTEGER)'; +-- +ok +== +INSERT INTO variants VALUES + (1, {'z': 9, 'a': 1, 'b': 2}::VARIANT), + (2, {'a': 10, 'b': NULL}::VARIANT), + (3, {'a': 20}::VARIANT), + (4, {'z': 40}::VARIANT), + (5, 42::VARIANT), + (6, NULL::VARIANT); +-- +ok +== +SELECT variant_contains(v, {'a': 1}::VARIANT), variant_contains(v, {'b': 2}::VARIANT), + variant_contains(v, 42::VARIANT) +FROM variants +ORDER BY id; +-- +ok +== +SELECT variant_contains(v, {'b': NULL}::VARIANT) +FROM variants +ORDER BY id; +-- +ok +== diff --git a/parser/testdata/corpus/sql/function/variant/variant_exists.test b/parser/testdata/corpus/sql/function/variant/variant_exists.test new file mode 100644 index 0000000..3990327 --- /dev/null +++ b/parser/testdata/corpus/sql/function/variant/variant_exists.test @@ -0,0 +1,117 @@ +# source: test/sql/function/variant/variant_exists.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +select variant_exists('{"a": 1, "b": {"c": 12, "d": 10}}', 'a'); +-- +ok +== +select variant_exists(a, '') from struct_cast_data(); +-- +ok +== +select variant_exists(a, []) from struct_cast_data(); +-- +ok +== +select variant_exists(a, ['']) from struct_cast_data(); +-- +ok +== +select variant_exists(a, 'c') from struct_cast_data(); +-- +ok +== +select variant_exists(a, ['c']) from struct_cast_data(); +-- +ok +== +select variant_exists(a, ['', 'c']) from struct_cast_data(); +-- +ok +== +select variant_exists(a, [NULL, 'c']) from struct_cast_data(); +-- +ok +== +select variant_exists(MAP {'a': 1, 'b': 2}::VARIANT, 'a'); +-- +ok +== +select variant_exists(NULL::VARIANT, NULL); +-- +ok +== +select variant_exists(NULL, NULL); +-- +ok +== +select variant_exists(NULL::VARIANT, 'a'); +-- +ok +== +select variant_exists(j, 'a') from (values ({'a': 1}::VARIANT), (NULL::VARIANT)) t(j); +-- +ok +== +select variant_exists(j, ['a', 'b']) from (values ({'a': 1}::VARIANT), (NULL::VARIANT)) t(j); +-- +ok +== +select variant_exists({'a': 1}::VARIANT, NULL); +-- +ok +== +select variant_exists({'a': 1, 'b': {'c': {'d': 12}}}::VARIANT, '$.b.c'); +-- +ok +== +select variant_exists({'a': 1}::VARIANT, [1]); +-- +ok +== +select variant_exists({'a': 1}::VARIANT, [NULL]); +-- +ok +== +select variant_exists({'a': 1}::VARIANT, [NULL::VARCHAR]); +-- +ok +== +select variant_exists({'c': 1}::VARIANT, ['c', NULL]::VARCHAR[]); +-- +ok +== +select variant_exists({'c': 1}::VARIANT, []::VARCHAR[]); +-- +ok +== +select variant_exists('{"a"\: 1}'::VARIANT, 'a'); +-- +ok +== +create table t1 as +select range, case when range % 2 = 0 then {"duck": 42}::VARIANT else {"duck": 42, "goose": 43}::VARIANT end j +from range(4096) +-- +ok +== +select range % 2 g, sum(length([present for present in variant_exists(j, ['duck', 'goose']) if present])) c +from t1 +group by g +order by all +-- +ok +== +create table t2 as +select range, {'duck': {'key1': 42}, 'goose': {'key1': 42, 'key2': 43}}::VARIANT j +from range(4096) +-- +ok +== +select sum(length([present for present in variant_exists(j, ['duck', 'goose']) if present])) s +from t2 +-- +ok +== diff --git a/parser/testdata/corpus/sql/function/variant/variant_exists_shredded.test b/parser/testdata/corpus/sql/function/variant/variant_exists_shredded.test new file mode 100644 index 0000000..c5397ce --- /dev/null +++ b/parser/testdata/corpus/sql/function/variant/variant_exists_shredded.test @@ -0,0 +1,49 @@ +# source: test/sql/function/variant/variant_exists_shredded.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +INSERT INTO variants VALUES + -- partially shredded + (1, {'z': 9, 'a': 1, 'b': 2}::VARIANT), + -- VARIANT_NULL + (2, {'a': 10, 'b': NULL}::VARIANT), + -- missing value in shredded schema + (3, {'a': 20}::VARIANT), + (4, {'z': 40}::VARIANT), + -- root with different type than shredded schema + (5, 42::VARIANT), + -- SQL-NULL + (6, NULL::VARIANT); +-- +ok +== +SELECT variant_exists(v, 'b'), variant_exists(v, 'z') FROM variants ORDER BY id; +-- +ok +== +SELECT variant_exists(v, ['b', 'z', 'missing']) FROM variants ORDER BY id; +-- +ok +== +CREATE TABLE fully_shredded_objects(id INTEGER, v VARIANT); +-- +ok +== +INSERT INTO fully_shredded_objects VALUES + (1, {'a': 1, 'b': 2}::VARIANT), + (2, {'a': 3, 'b': 4}::VARIANT), + (3, NULL::VARIANT); +-- +ok +== +SELECT DISTINCT vector_type(v) FROM fully_shredded_objects; +-- +ok +== +SELECT variant_exists(v, 'b'), variant_exists(v, 'missing') +FROM fully_shredded_objects +ORDER BY id; +-- +ok +== diff --git a/parser/testdata/corpus/sql/function/variant/variant_extract.test b/parser/testdata/corpus/sql/function/variant/variant_extract.test new file mode 100644 index 0000000..bbf4f31 --- /dev/null +++ b/parser/testdata/corpus/sql/function/variant/variant_extract.test @@ -0,0 +1,80 @@ +# source: test/sql/function/variant/variant_extract.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +select variant_extract({'a': 1234}::VARIANT, 'a')::VARCHAR; +-- +ok +== +CREATE MACRO struct_cast_data() AS TABLE ( + SELECT {'a': [ + { + 'b': 'hello', + 'c': NULL, + 'a': '1970/03/15'::DATE + }, + { + 'b': NULL, + 'c': True, + 'a': '2020/11/03'::DATE + } + ]}::VARIANT AS a + UNION ALL + SELECT {'a': [ + { + 'b': 'this is a long string', + 'c': False, + 'a': '1953/9/16'::DATE + } + ]}::VARIANT +); +-- +ok +== +select variant_extract(a, 'a[1].c') from struct_cast_data(); +-- +ok +== +select variant_extract(a, 'a').variant_extract(1::UINTEGER).variant_extract('c') from struct_cast_data(); +-- +ok +== +select ('{"a": 42, "b": [true, "test", true]}'::JSON::VARIANT).b[2]; +-- +ok +== +select ('{"a": 42, "b": [true, "test", true]}'::JSON::VARIANT)['b'][2]; +-- +ok +== +select ('{"a": 42, "b": [true, "test", true]}'::JSON::VARIANT)['b']['1']; +-- +ok +== +select ('{"a": 42, "b": [true, "test", true]}'::JSON::VARIANT)['b[2]']; +-- +ok +== +select ([10, 20, 30]::VARIANT)[1]; +-- +ok +== +select ([10, 20, 30]::VARIANT)[1.5]; +-- +ok +== +SELECT [ + x.a for x in [ + {'a': 42, 'b': [1,2,3]}::VARIANT, + NULL, + 84 + ] +] +-- +ok +== +SELECT variant_extract((SELECT list(i) FROM range(500) t(i))::VARIANT, 300::UINTEGER)::BIGINT; +-- +ok +== diff --git a/parser/testdata/corpus/sql/function/variant/variant_extract_string.test b/parser/testdata/corpus/sql/function/variant/variant_extract_string.test new file mode 100644 index 0000000..d43c217 --- /dev/null +++ b/parser/testdata/corpus/sql/function/variant/variant_extract_string.test @@ -0,0 +1,185 @@ +# source: test/sql/function/variant/variant_extract_string.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +select variant_extract_string('{"a": 1, "b": {"c": 12, "d": 10}}'); +-- +ok +== +select variant_extract_string(a, '') from struct_cast_data(); +-- +ok +== +select variant_extract_string(a, []) from struct_cast_data(); +-- +ok +== +select variant_extract_string(a, ['']) from struct_cast_data(); +-- +ok +== +select variant_extract_string(a, 'c') from struct_cast_data(); +-- +ok +== +select variant_extract_string(a, ['c']) from struct_cast_data(); +-- +ok +== +select variant_extract_string(a, ['b', 'c']) from struct_cast_data(); +-- +ok +== +select variant_extract_string('{}'::VARIANT, ''); +-- +ok +== +select variant_extract_string(['duck', 'goose']::VARIANT, ''); +-- +ok +== +select variant_extract_string({'a': 1, 'b': ['duck', 'goose']}::VARIANT, 'b'); +-- +ok +== +select variant_extract_string(MAP {'a': 1, 'b': 2}::VARIANT, 'a'); +-- +ok +== +SELECT [*COLUMNS(*)] FROM ( + SELECT variant_extract_string( + COLUMNS(lambda c: NOT regexp_matches(c, 'array|struct|map|union|tuple'))::VARIANT, + '' + ) + FROM test_all_types() + -- strip NULLs from output + WHERE bool IS NOT NULL +); +-- +ok +== +SELECT variant_extract_string(float::VARIANT, '')::DOUBLE = float::DOUBLE, + variant_extract_string(double::VARIANT, '')::DOUBLE = double +FROM test_all_types() +WHERE bool IS NOT NULL; +-- +ok +== +SELECT variant_extract_string({'uuid': uuid}::VARIANT, '') +FROM test_all_types() +WHERE bool = false; +-- +ok +== +SELECT variant_extract_string({'blob': blob}::VARIANT, '') +FROM test_all_types() +WHERE bool = false; +-- +ok +== +SELECT variant_extract_string({'bit': bit}::VARIANT, '') +FROM test_all_types() +WHERE bool = false; +-- +ok +== +SELECT variant_extract_string({'interval': interval}::VARIANT, '') +FROM test_all_types() +WHERE bool = false; +-- +ok +== +SELECT variant_extract_string({'timestamp': timestamp}::VARIANT, '') +FROM test_all_types() +WHERE bool = false; +-- +ok +== +SELECT variant_extract_string({'timestamp_tz': timestamp_tz}::VARIANT, '') +FROM test_all_types() +WHERE bool = false; +-- +ok +== +SELECT variant_extract_string({'geometry': geometry}::VARIANT, '') +FROM test_all_types() +WHERE bool = false; +-- +ok +== +SELECT variant_extract_string(chr({val})::VARIANT, '') == chr({val}) +-- +error: Parser Error: syntax error at or near "}" +== +SELECT variant_extract_string( + [chr(34), chr(92), chr(8), chr(12), chr(10), chr(13), chr(9), chr(1), '🦆']::VARIANT, + '' +); +-- +ok +== +select variant_extract_string(NULL::VARIANT, ''); +-- +ok +== +select variant_extract_string(NULL, ''); +-- +ok +== +select variant_extract_string(NULL::VARIANT, 'a'); +-- +ok +== +select variant_extract_string(j, 'a') from (values ({'a': {'x': 1}}::VARIANT), (NULL::VARIANT)) t(j); +-- +ok +== +select variant_extract_string(j, ['a', 'b']) from (values ({'a': {'x': 1}}::VARIANT), (NULL::VARIANT)) t(j); +-- +ok +== +select variant_extract_string({'a': 1, 'b': null}::VARIANT, 'b'); +-- +ok +== +select variant_extract_string('{}'::VARIANT, 'a'); +-- +ok +== +select variant_extract_string({'a': 1, 'b': {'c': 12, 'd': 10}}::VARIANT, 'q'); +-- +ok +== +select variant_extract_string({'a': 1}::VARIANT, NULL); +-- +ok +== +select variant_extract_string({'a': 1, 'b': {'c': {'d': 12}}}::VARIANT, '$.b.c'); +-- +ok +== +select variant_extract_string({'a': 1}::VARIANT); +-- +ok +== +select variant_extract_string({'a': 1}::VARIANT, [1]); +-- +ok +== +select variant_extract_string({'a': 1}::VARIANT, [NULL]); +-- +ok +== +select variant_extract_string({'a': 1}::VARIANT, [NULL::VARCHAR]); +-- +ok +== +select variant_extract_string({'c': 1}::VARIANT, ['c', NULL]::VARCHAR[]); +-- +ok +== +select variant_extract_string({'c': 1}::VARIANT, []::VARCHAR[]); +-- +ok +== diff --git a/parser/testdata/corpus/sql/function/variant/variant_extract_string_shredded.test b/parser/testdata/corpus/sql/function/variant/variant_extract_string_shredded.test new file mode 100644 index 0000000..62d7b00 --- /dev/null +++ b/parser/testdata/corpus/sql/function/variant/variant_extract_string_shredded.test @@ -0,0 +1,28 @@ +# source: test/sql/function/variant/variant_extract_string_shredded.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +SET force_variant_shredding = 'STRUCT(obj STRUCT(x VARCHAR), arr INTEGER[], a INTEGER)'; +-- +ok +== +INSERT INTO variants VALUES + -- partially shredded with an unshredded field at each object level + (1, {'z': 9, 'a': 1, 'arr': [10, NULL, 30], 'obj': {'x': 'duck', 'y': 2}}::VARIANT), + -- VARIANT_NULL + (2, {'a': 2, 'arr': [], 'obj': NULL}::VARIANT), + -- SQL-NULL + (3, NULL::VARIANT); +-- +ok +== +SELECT + variant_extract_string(v, ''), + variant_extract_string(v, 'a'), + variant_extract_string(v, 'z') +FROM variants +ORDER BY id; +-- +ok +== diff --git a/parser/testdata/corpus/sql/function/variant/variant_extract_try_cast.test b/parser/testdata/corpus/sql/function/variant/variant_extract_try_cast.test new file mode 100644 index 0000000..87008e1 --- /dev/null +++ b/parser/testdata/corpus/sql/function/variant/variant_extract_try_cast.test @@ -0,0 +1,47 @@ +# source: test/sql/function/variant/variant_extract_try_cast.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +create table tbl(col VARIANT); +-- +ok +== +insert into tbl SELECT * FROM UNNEST([ + {'almost_a_number': c, 'a_number': CAST(TRY_CAST(c AS INT) AS VARCHAR)} for c in ['12', '24', '25a6', '24c', '16'] +]) +-- +ok +== +from tbl order by all +-- +ok +== +select col.almost_a_number from tbl order by all +-- +ok +== +select col.almost_a_number::BIGINT from tbl order by all +-- +ok +== +select TRY_CAST(col.almost_a_number AS BIGINT) from tbl order by all +-- +ok +== +select col.a_number from tbl order by all +-- +ok +== +select col.a_number::BIGINT from tbl order by all +-- +ok +== +set explain_output='optimized_only'; +-- +ok +== +EXPLAIN select TRY_CAST(col.almost_a_number AS BIGINT) from tbl order by all +-- +ok +== diff --git a/parser/testdata/corpus/sql/function/variant/variant_group_array.test b/parser/testdata/corpus/sql/function/variant/variant_group_array.test new file mode 100644 index 0000000..fa0b645 --- /dev/null +++ b/parser/testdata/corpus/sql/function/variant/variant_group_array.test @@ -0,0 +1,61 @@ +# source: test/sql/function/variant/variant_group_array.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +select variant_group_array(i), typeof(variant_group_array(i)) from range(4) t(i); +-- +ok +== +select variant_group_array(s) from (values ('duck'), ('goose')) t(s); +-- +ok +== +select variant_group_array(x) +from (values ({a: 1, b: ['duck', 'goose']}), ({a: 2, b: NULL})) t(x); +-- +ok +== +select variant_group_array(v) +from (values (1::VARIANT), ('duck'::VARIANT), ({a: true}::VARIANT), (NULL::VARIANT)) t(v); +-- +ok +== +select variant_group_array(i) from (values (1), (NULL), (2)) t(i); +-- +ok +== +select variant_group_array(i) from (values (NULL::INTEGER), (NULL::INTEGER)) t(i); +-- +ok +== +select variant_group_array(i) from (select NULL::INTEGER i where false); +-- +ok +== +select i % 2 as g, variant_group_array(i) from range(4) t(i) group by g order by g; +-- +ok +== +select distinct variant_group_array(v) over (partition by g) +from (values (1, 10), (1, 20), (2, 30)) t(g, v) +order by 1; +-- +ok +== +select variant_group_array(); +-- +ok +== +select variant_group_array(1, 2); +-- +ok +== +create table integers as select i from range(4096) t(i); +-- +ok +== +select variant_array_length(variant_group_array(i)) from integers; +-- +ok +== diff --git a/parser/testdata/corpus/sql/function/variant/variant_group_array_shredded.test b/parser/testdata/corpus/sql/function/variant/variant_group_array_shredded.test new file mode 100644 index 0000000..107de5b --- /dev/null +++ b/parser/testdata/corpus/sql/function/variant/variant_group_array_shredded.test @@ -0,0 +1,50 @@ +# source: test/sql/function/variant/variant_group_array_shredded.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +INSERT INTO variants VALUES + -- partially shredded + (1, {'z': 9, 'a': 1, 'b': 2}::VARIANT), + -- VARIANT_NULL + (2, {'a': 10, 'b': NULL}::VARIANT), + -- missing value in shredded schema + (3, {'a': 20}::VARIANT), + -- root with different type than shredded schema + (4, 42::VARIANT), + -- SQL-NULL + (5, NULL::VARIANT); +-- +ok +== +SELECT variant_group_array(v) FROM (SELECT v FROM variants ORDER BY id); +-- +ok +== +SET force_variant_shredding = 'INTEGER'; +-- +ok +== +CREATE TABLE fully_shredded(id INTEGER, v VARIANT); +-- +ok +== +INSERT INTO fully_shredded VALUES + (1, 42::INTEGER::VARIANT), + (2, 84::INTEGER::VARIANT), + (3, NULL::VARIANT); +-- +ok +== +SELECT DISTINCT vector_type(v) FROM fully_shredded; +-- +ok +== +SELECT variant_group_array(v) FROM (SELECT v FROM fully_shredded ORDER BY id); +-- +ok +== +SELECT variant_group_array(v) FROM (SELECT v FROM fully_shredded_objects ORDER BY id); +-- +ok +== diff --git a/parser/testdata/corpus/sql/function/variant/variant_keys.test b/parser/testdata/corpus/sql/function/variant/variant_keys.test new file mode 100644 index 0000000..caa03ff --- /dev/null +++ b/parser/testdata/corpus/sql/function/variant/variant_keys.test @@ -0,0 +1,141 @@ +# source: test/sql/function/variant/variant_keys.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +select variant_keys('{"a": 1, "b": {"c": 12, "d": 10}}'); +-- +ok +== +select variant_keys(a) from struct_cast_data(); +-- +ok +== +select variant_keys(a, '') from struct_cast_data(); +-- +ok +== +select variant_keys(a, []) from struct_cast_data(); +-- +ok +== +select variant_keys(a, ['']) from struct_cast_data(); +-- +ok +== +select variant_keys(a, 'c') from struct_cast_data(); +-- +ok +== +select variant_keys(a, ['c']) from struct_cast_data(); +-- +ok +== +select variant_keys(a, ['', 'c']) from struct_cast_data(); +-- +ok +== +select variant_keys('{}'::VARIANT); +-- +ok +== +select variant_keys(['duck', 'goose']::VARIANT); +-- +ok +== +select variant_keys({'a': 1, 'b': ['duck', 'goose']}::VARIANT, 'b'); +-- +ok +== +select variant_keys(MAP {'a': 1, 'b': 2}::VARIANT, 'a'); +-- +ok +== +select variant_keys(''::VARIANT); +-- +ok +== +select variant_keys({'a': 'goose'}::VARIANT, 'a'); +-- +ok +== +select variant_keys(42::VARIANT); +-- +ok +== +select variant_keys({'a': 42}::VARIANT, 'a'); +-- +ok +== +select variant_keys(NULL::VARIANT); +-- +ok +== +select variant_keys(NULL::VARIANT, 'a'); +-- +ok +== +select variant_keys(j, 'a') from (values ({'a': {'x': 1}}::VARIANT), (NULL::VARIANT)) t(j); +-- +ok +== +select variant_keys(j, ['a', 'b']) from (values ({'a': {'x': 1}}::VARIANT), (NULL::VARIANT)) t(j); +-- +ok +== +select variant_keys({'a': 1, 'b': null}::VARIANT, 'b'); +-- +ok +== +select variant_keys('{}'::VARIANT, 'a'); +-- +ok +== +select variant_keys({'a': 1, 'b': {'c': 12, 'd': 10}}::VARIANT, 'q'); +-- +ok +== +select variant_keys({'a': 1}::VARIANT, NULL); +-- +ok +== +select variant_keys({'a': 1, 'b': {'c': {'d': 12}}}::VARIANT, '$.b.c'); +-- +ok +== +select variant_keys({'a': 1}::VARIANT, [1]); +-- +ok +== +select variant_keys({'a': 1}::VARIANT, [NULL]); +-- +ok +== +select variant_keys({'a': 1}::VARIANT, [NULL::VARCHAR]); +-- +ok +== +select variant_keys({'c': 1}::VARIANT, ['c', NULL]::VARCHAR[]); +-- +ok +== +select variant_keys({'c': 1}::VARIANT, []::VARCHAR[]); +-- +ok +== +select variant_keys('{"a"\: 1}'::VARIANT); +-- +ok +== +select range % 2 g, sum(length(variant_keys(j))) c +from t1 +group by g +order by all +-- +ok +== +select sum(list_sum([length(l) for l in variant_keys(j, ['duck', 'goose'])])) s +from t2 +-- +ok +== diff --git a/parser/testdata/corpus/sql/function/variant/variant_keys_shredded.test b/parser/testdata/corpus/sql/function/variant/variant_keys_shredded.test new file mode 100644 index 0000000..68601c1 --- /dev/null +++ b/parser/testdata/corpus/sql/function/variant/variant_keys_shredded.test @@ -0,0 +1,39 @@ +# source: test/sql/function/variant/variant_keys_shredded.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +SET force_variant_shredding = 'STRUCT(b INTEGER, a INTEGER, obj STRUCT(y INTEGER, x INTEGER))'; +-- +ok +== +INSERT INTO variants VALUES + -- partially shredded + (1, {'z': 9, 'a': 1, 'b': 2, 'obj': {'x': 10, 'y': 20}}::VARIANT), + -- VARIANT_NULL + (2, {'a': 10, 'b': NULL, 'obj': NULL}::VARIANT), + -- missing value in shredded schema + (3, {'a': 20}::VARIANT), + -- root with different type than shredded schema + (4, 42::VARIANT), + -- SQL-NULL + (5, NULL::VARIANT); +-- +ok +== +SELECT variant_keys(v) FROM variants ORDER BY id; +-- +ok +== +SELECT variant_keys(v, 'obj') FROM variants ORDER BY id; +-- +ok +== +SELECT variant_keys(v, ['', 'obj', 'missing']) FROM variants ORDER BY id; +-- +ok +== +SELECT variant_keys(v) FROM fully_shredded_objects ORDER BY id; +-- +ok +== diff --git a/parser/testdata/corpus/sql/function/variant/variant_shredded_extract_nested.test b/parser/testdata/corpus/sql/function/variant/variant_shredded_extract_nested.test new file mode 100644 index 0000000..426a89d --- /dev/null +++ b/parser/testdata/corpus/sql/function/variant/variant_shredded_extract_nested.test @@ -0,0 +1,65 @@ +# source: test/sql/function/variant/variant_shredded_extract_nested.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +create table list_variant as select + { + 'id': l_orderkey, + 'my_list': [ + l_orderkey, + l_orderkey + 1, + l_orderkey + 2 + ], + 'my_struct': { + 'a': l_orderkey, + 'b': l_orderkey + 30 + } + }::variant as list_variant +from + range(5) t(l_orderkey) +-- +ok +== +select + list_variant.my_list +from + list_variant +limit + 1; +-- +ok +== +select + list_variant.my_list::BIGINT[] +from + list_variant +limit + 1; +-- +ok +== +select + list_variant.my_struct +from + list_variant +limit 1; +-- +ok +== +select + list_variant.my_struct::STRUCT(b BIGINT, a BIGINT) +from + list_variant +limit 1; +-- +ok +== +select + (list_variant.my_struct::STRUCT(b VARCHAR, a VARCHAR)).b[1] +from + list_variant +limit 1; +-- +ok +== diff --git a/parser/testdata/corpus/sql/function/variant/variant_type.test b/parser/testdata/corpus/sql/function/variant/variant_type.test new file mode 100644 index 0000000..1af2c21 --- /dev/null +++ b/parser/testdata/corpus/sql/function/variant/variant_type.test @@ -0,0 +1,124 @@ +# source: test/sql/function/variant/variant_type.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +select variant_type('{"a": 1, "b": {"c": 12, "d": 10}}'); +-- +ok +== +select variant_type(a) from struct_cast_data(); +-- +ok +== +select variant_type(a, '') from struct_cast_data(); +-- +ok +== +select variant_type(a, []) from struct_cast_data(); +-- +ok +== +select variant_type(a, ['']) from struct_cast_data(); +-- +ok +== +select variant_type(a, 'c') from struct_cast_data(); +-- +ok +== +select variant_type(a, ['c']) from struct_cast_data(); +-- +ok +== +select variant_type(a, ['', 'c']) from struct_cast_data(); +-- +ok +== +select variant_type('{}'::VARIANT); +-- +ok +== +select variant_type(['duck', 'goose']::VARIANT); +-- +ok +== +select variant_type({'a': 1, 'b': ['duck', 'goose']}::VARIANT, 'b'); +-- +ok +== +select variant_type(MAP {'a': 1, 'b': 2}::VARIANT, 'a'); +-- +ok +== +SELECT [*COLUMNS(*)] FROM ( + SELECT variant_type( + COLUMNS(lambda c: NOT regexp_matches(c, 'array|struct|map|union|tuple'))::VARIANT + ) + FROM test_all_types() + -- strip NULLs from output + WHERE bool IS NOT NULL +); +-- +ok +== +select variant_type(NULL::VARIANT); +-- +ok +== +select variant_type(NULL::VARIANT, 'a'); +-- +ok +== +select variant_type(j, 'a') from (values ({'a': {'x': 1}}::VARIANT), (NULL::VARIANT)) t(j); +-- +ok +== +select variant_type(j, ['a', 'b']) from (values ({'a': {'x': 1}}::VARIANT), (NULL::VARIANT)) t(j); +-- +ok +== +select variant_type({'a': 1, 'b': null}::VARIANT, 'b'); +-- +ok +== +select variant_type('{}'::VARIANT, 'a'); +-- +ok +== +select variant_type({'a': 1, 'b': {'c': 12, 'd': 10}}::VARIANT, 'q'); +-- +ok +== +select variant_type({'a': 1}::VARIANT, NULL); +-- +ok +== +select variant_type({'a': 1, 'b': {'c': {'d': 12}}}::VARIANT, '$.b.c'); +-- +ok +== +select variant_type({'a': 1}::VARIANT, [1]); +-- +ok +== +select variant_type({'a': 1}::VARIANT, [NULL]); +-- +ok +== +select variant_type({'a': 1}::VARIANT, [NULL::VARCHAR]); +-- +ok +== +select variant_type({'c': 1}::VARIANT, ['c', NULL]::VARCHAR[]); +-- +ok +== +select variant_type({'c': 1}::VARIANT, []::VARCHAR[]); +-- +ok +== +select variant_type('{"a"\: 1}'::VARIANT); +-- +ok +== diff --git a/parser/testdata/corpus/sql/function/variant/variant_type_shredded.test b/parser/testdata/corpus/sql/function/variant/variant_type_shredded.test new file mode 100644 index 0000000..d1e272e --- /dev/null +++ b/parser/testdata/corpus/sql/function/variant/variant_type_shredded.test @@ -0,0 +1,27 @@ +# source: test/sql/function/variant/variant_type_shredded.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +SELECT variant_type(v), variant_type(v, 'b') FROM variants ORDER BY id; +-- +ok +== +SELECT variant_type(v, 'z') FROM variants ORDER BY id; +-- +ok +== +SELECT variant_type(v, ['b', 'z', 'missing']) FROM variants ORDER BY id; +-- +ok +== +SELECT variant_type(v) FROM fully_shredded ORDER BY id; +-- +ok +== +SELECT variant_type(v), variant_type(v, 'b') +FROM fully_shredded_objects +ORDER BY id; +-- +ok +== diff --git a/parser/testdata/corpus/sql/function/variant/variant_typeof.test b/parser/testdata/corpus/sql/function/variant/variant_typeof.test new file mode 100644 index 0000000..8df708e --- /dev/null +++ b/parser/testdata/corpus/sql/function/variant/variant_typeof.test @@ -0,0 +1,56 @@ +# source: test/sql/function/variant/variant_typeof.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +select variant_typeof({'a': 42}::VARIANT); +-- +ok +== +select variant_typeof(({'a': 42}::VARIANT).variant_extract('a')); +-- +ok +== +select variant_typeof(struct_pack(*COLUMNS(*))::VARIANT) test from test_all_types(); +-- +ok +== +CREATE TABLE T (v VARIANT); +-- +ok +== +create table all_types as select struct_pack(*COLUMNS(*))::VARIANT test from test_all_types(); +-- +ok +== +select variant_typeof(variant_extract(test, 'bool')) from all_types; +-- +ok +== +select variant_typeof(variant_extract(test, 'struct')) from all_types; +-- +ok +== +select variant_typeof(variant_extract(test, 'struct').a) from all_types; +-- +ok +== +select variant_typeof(variant_extract(test, 'struct').variant_extract('a')) from all_types limit 2; +-- +ok +== +select variant_typeof(variant_extract(test, 'dec_18_6')) from all_types +-- +ok +== +select variant_typeof(variant_extract(test, 'array_of_structs')) from all_types +-- +ok +== +with cte as ( + select * from all_types limit 1 offset 1 +) +select variant_typeof(variant_extract(test, 'array_of_structs')[1]), variant_typeof(variant_extract(test, 'array_of_structs')[2]), variant_typeof(variant_extract(test, 'array_of_structs')[3]) from cte; +-- +ok +== diff --git a/parser/testdata/corpus/sql/generated_columns/stored/basic.test b/parser/testdata/corpus/sql/generated_columns/stored/basic.test new file mode 100644 index 0000000..fa4e4bf --- /dev/null +++ b/parser/testdata/corpus/sql/generated_columns/stored/basic.test @@ -0,0 +1,12 @@ +# source: test/sql/generated_columns/stored/basic.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +CREATE TABLE tbl ( + price INTEGER, + gcol AS (price) STORED, +); +-- +ok +== diff --git a/parser/testdata/corpus/sql/generated_columns/virtual/alter_table.test b/parser/testdata/corpus/sql/generated_columns/virtual/alter_table.test new file mode 100644 index 0000000..f253222 --- /dev/null +++ b/parser/testdata/corpus/sql/generated_columns/virtual/alter_table.test @@ -0,0 +1,41 @@ +# source: test/sql/generated_columns/virtual/alter_table.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +INSERT INTO unit VALUES (5,4) +-- +ok +== +ALTER TABLE unit ADD COLUMN profit_total BOOLEAN GENERATED ALWAYS AS(non_existant_function() * price) VIRTUAL; +-- +error: Parser Error: Adding generated columns after table creation is not supported yet +== +ALTER TABLE unit ADD COLUMN profit_total BOOLEAN GENERATED ALWAYS AS(price) VIRTUAL; +-- +error: Parser Error: Adding generated columns after table creation is not supported yet +== +ALTER TABLE unit ADD COLUMN total_profit BOOLEAN GENERATED ALWAYS AS((SELECT 1)) VIRTUAL; +-- +error: Parser Error: Adding generated columns after table creation is not supported yet +== +ALTER TABLE unit ADD COLUMN total_profit INTEGER GENERATED ALWAYS AS (price * amount_sold) VIRTUAL; +-- +error: Parser Error: Adding generated columns after table creation is not supported yet +== +INSERT INTO unit (total_profit) VALUES (1) +-- +ok +== +INSERT INTO unit VALUES (1,1,1) +-- +ok +== +INSERT INTO unit VALUES (0,1) +-- +ok +== +SELECT * FROM unit +-- +ok +== diff --git a/parser/testdata/corpus/sql/generated_columns/virtual/alter_table.test.metadata.json b/parser/testdata/corpus/sql/generated_columns/virtual/alter_table.test.metadata.json new file mode 100644 index 0000000..3efe944 --- /dev/null +++ b/parser/testdata/corpus/sql/generated_columns/virtual/alter_table.test.metadata.json @@ -0,0 +1,8 @@ +{ + "todo": { + "06ad91019f245b72": "transformer-raised parser error: upstream rejects in the transformer, not the grammar; expected to clear as transformers land (milestones 3-5)", + "1e580bf960d161c0": "transformer-raised parser error: upstream rejects in the transformer, not the grammar; expected to clear as transformers land (milestones 3-5)", + "b47bf0ffa43d4332": "transformer-raised parser error: upstream rejects in the transformer, not the grammar; expected to clear as transformers land (milestones 3-5)", + "edb5239250179eb9": "transformer-raised parser error: upstream rejects in the transformer, not the grammar; expected to clear as transformers land (milestones 3-5)" + } +} diff --git a/parser/testdata/corpus/sql/generated_columns/virtual/ambiguity.test b/parser/testdata/corpus/sql/generated_columns/virtual/ambiguity.test new file mode 100644 index 0000000..b979d9e --- /dev/null +++ b/parser/testdata/corpus/sql/generated_columns/virtual/ambiguity.test @@ -0,0 +1,55 @@ +# source: test/sql/generated_columns/virtual/ambiguity.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +CREATE TABLE unit ( + price INTEGER, + amount_sold INTEGER, + total_profit AS (price * amount_sold) +); +-- +ok +== +CREATE TABLE unit2 ( + price INTEGER, + amount_sold INTEGER, + total_profit AS (price / amount_sold), + profit_total AS (unit2.price * unit2.amount_sold) +); +-- +error: Parser Error: Qualified (tbl.name) column references are not allowed inside of generated column expressions +== +CREATE TABLE unit2 ( + price INTEGER, + amount_sold INTEGER, + total_profit AS (price / amount_sold), + profit_total AS (price * amount_sold) +); +-- +ok +== +SELECT total_profit FROM unit, unit2 +-- +ok +== +INSERT INTO unit2 VALUES (100, 4) +-- +ok +== +SELECT unit.total_profit FROM unit, unit2 +-- +ok +== +SELECT unit.total_profit FROM unit AS unit2, unit2 AS unit +-- +ok +== +SELECT profit_total FROM unit2 +-- +ok +== +SELECT profit_total FROM unit2 as unit +-- +ok +== diff --git a/parser/testdata/corpus/sql/generated_columns/virtual/ambiguity.test.metadata.json b/parser/testdata/corpus/sql/generated_columns/virtual/ambiguity.test.metadata.json new file mode 100644 index 0000000..6f425ac --- /dev/null +++ b/parser/testdata/corpus/sql/generated_columns/virtual/ambiguity.test.metadata.json @@ -0,0 +1,5 @@ +{ + "todo": { + "558a0624636dfa71": "transformer-raised parser error: upstream rejects in the transformer, not the grammar; expected to clear as transformers land (milestones 3-5)" + } +} diff --git a/parser/testdata/corpus/sql/generated_columns/virtual/cascading_delete.test b/parser/testdata/corpus/sql/generated_columns/virtual/cascading_delete.test new file mode 100644 index 0000000..3583142 --- /dev/null +++ b/parser/testdata/corpus/sql/generated_columns/virtual/cascading_delete.test @@ -0,0 +1,41 @@ +# source: test/sql/generated_columns/virtual/cascading_delete.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +CREATE TABLE unit ( + price INTEGER, + amount_sold INTEGER, + total_profit as (price * amount_sold), + profit_total AS (total_profit), + dependent AS (profit_total), + also_dependent AS (profit_total * dependent), + dont_delete_me AS (amount_sold), +); +-- +ok +== +SELECT * FROM unit; +-- +ok +== +ALTER TABLE unit DROP COLUMN price; +-- +ok +== +ALTER TABLE unit DROP COLUMN price CASCADE; +-- +ok +== +INSERT INTO unit VALUES (5) +-- +ok +== +ALTER TABLE unit DROP COLUMN dont_delete_me; +-- +ok +== +ALTER TABLE unit DROP COLUMN amount_sold CASCADE; +-- +ok +== diff --git a/parser/testdata/corpus/sql/generated_columns/virtual/casting.test b/parser/testdata/corpus/sql/generated_columns/virtual/casting.test new file mode 100644 index 0000000..1fc0352 --- /dev/null +++ b/parser/testdata/corpus/sql/generated_columns/virtual/casting.test @@ -0,0 +1,33 @@ +# source: test/sql/generated_columns/virtual/casting.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +CREATE TABLE tbl ( + price INTEGER, + total_price AS ((price)::DATE) +); +-- +ok +== +INSERT INTO tbl VALUES (5); +-- +ok +== +CREATE TABLE a ( + gen_x AS (x), + gen_y AS (y), + x TEXT, + y INTEGER +); +-- +ok +== +INSERT INTO a VALUES ('hello', 42) +-- +ok +== +ALTER TABLE a ALTER COLUMN gen_x TYPE BOOLEAN; +-- +ok +== diff --git a/parser/testdata/corpus/sql/generated_columns/virtual/check.test b/parser/testdata/corpus/sql/generated_columns/virtual/check.test new file mode 100644 index 0000000..2a5cf17 --- /dev/null +++ b/parser/testdata/corpus/sql/generated_columns/virtual/check.test @@ -0,0 +1,44 @@ +# source: test/sql/generated_columns/virtual/check.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +CREATE TABLE unit ( + price INTEGER, + amount_sold AS (price) CHECK (price > 5), +); +-- +ok +== +CREATE TABLE tbl ( + price INTEGER, + amount_sold AS (price) CHECK (amount_sold > 5) +); +-- +ok +== +CREATE TABLE tbl ( + price INTEGER, + amount_sold AS (price), + CHECK (amount_sold > price) +); +-- +ok +== +CREATE TABLE chk ( + g1 AS (x), + g2 AS (x), + x INTEGER, + CHECK (x > 5) +); +-- +ok +== +INSERT INTO chk VALUES (6); +-- +ok +== +INSERT INTO chk VALUES (3); +-- +ok +== diff --git a/parser/testdata/corpus/sql/generated_columns/virtual/circular_dependency_stresstest.test b/parser/testdata/corpus/sql/generated_columns/virtual/circular_dependency_stresstest.test new file mode 100644 index 0000000..1c8d951 --- /dev/null +++ b/parser/testdata/corpus/sql/generated_columns/virtual/circular_dependency_stresstest.test @@ -0,0 +1,54 @@ +# source: test/sql/generated_columns/virtual/circular_dependency_stresstest.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +CREATE TABLE tbl ( + gcol1 AS (gcol10), + gcol2 AS (gcol4), + gcol3 AS (gcol7), + gcol4 AS (gcol6), + gcol5 AS (x), + gcol6 AS (gcol2), + gcol7 AS (gcol8), + gcol8 AS (gcol1), + gcol9 AS (gcol2), + gcol10 AS (gcol3), + x INTEGER +); +-- +ok +== +CREATE TABLE tbl ( + gcol1 AS (gcol2), + gcol2 AS (gcol3), + gcol3 AS (gcol4), + gcol4 AS (gcol5), + gcol5 AS (gcol6), + gcol6 AS (gcol7), + gcol7 AS (gcol8), + gcol8 AS (gcol9), + gcol9 AS (gcol10), + gcol10 AS (x), + x INTEGER, +); +-- +ok +== +CREATE TABLE circular ( + a AS (k), + k AS (j), + j AS (i), + i AS (h), + h AS (g), + g AS (f), + f AS (e), + e AS (d), + d AS (c), + c AS (b), + b AS (a), + x INTEGER, +); +-- +ok +== diff --git a/parser/testdata/corpus/sql/generated_columns/virtual/collate.test b/parser/testdata/corpus/sql/generated_columns/virtual/collate.test new file mode 100644 index 0000000..e541350 --- /dev/null +++ b/parser/testdata/corpus/sql/generated_columns/virtual/collate.test @@ -0,0 +1,28 @@ +# source: test/sql/generated_columns/virtual/collate.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +CREATE TABLE tbl ( + price VARCHAR, + also_price VARCHAR AS (price) COLLATE NOCASE +); +-- +error: Parser Error: Collations are not supported on generated columns +== +CREATE TABLE coll ( + g1 AS (x), + g2 AS (x), + x VARCHAR COLLATE NOCASE +); +-- +ok +== +INSERT INTO coll VALUES ('string'), ('STRING') +-- +ok +== +SELECT * FROM coll; +-- +ok +== diff --git a/parser/testdata/corpus/sql/generated_columns/virtual/collate.test.metadata.json b/parser/testdata/corpus/sql/generated_columns/virtual/collate.test.metadata.json new file mode 100644 index 0000000..a48b27b --- /dev/null +++ b/parser/testdata/corpus/sql/generated_columns/virtual/collate.test.metadata.json @@ -0,0 +1,5 @@ +{ + "todo": { + "d3544f1572e0c863": "transformer-raised parser error: upstream rejects in the transformer, not the grammar; expected to clear as transformers land (milestones 3-5)" + } +} diff --git a/parser/testdata/corpus/sql/generated_columns/virtual/create_table.test b/parser/testdata/corpus/sql/generated_columns/virtual/create_table.test new file mode 100644 index 0000000..fc8496c --- /dev/null +++ b/parser/testdata/corpus/sql/generated_columns/virtual/create_table.test @@ -0,0 +1,84 @@ +# source: test/sql/generated_columns/virtual/create_table.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +CREATE TEMP TABLE t0(c0 AS (1)); +-- +ok +== +CREATE TABLE unit ( + price INTEGER, + total_profit BOOLEAN GENERATED ALWAYS AS(non_existant_function() * price) VIRTUAL, +); +-- +ok +== +CREATE TABLE unit ( + total_profit BOOLEAN GENERATED ALWAYS AS(price * 2) VIRTUAL, +); +-- +ok +== +CREATE TABLE tbl ( + total_profit BOOLEAN GENERATED ALWAYS AS(word) VIRTUAL, + word VARCHAR, + price INTEGER, + amount_sold INTEGER, +); +-- +ok +== +INSERT INTO tbl VALUES ('string', 5, 12); +-- +ok +== +CREATE TABLE unit ( + total_profit BOOLEAN GENERATED ALWAYS AS((SELECT 1)) VIRTUAL, + word VARCHAR, + price INTEGER, + amount_sold INTEGER, +); +-- +error: Parser Error: Expression of generated column "total_profit" contains a subquery, which isn't allowed +== +CREATE MACRO my_macro() AS ( + (select 42) +); +-- +ok +== +CREATE TABLE unit ( + total_profit INTEGER GENERATED ALWAYS AS(my_macro()) VIRTUAL, + word VARCHAR, + price INTEGER, + amount_sold INTEGER, +); +-- +ok +== +CREATE TABLE unit ( + total_profit INTEGER GENERATED ALWAYS AS(price * amount_sold) VIRTUAL, + total_profit INTEGER GENERATED ALWAYS AS(price * amount_sold) VIRTUAL, + price INTEGER, + amount_sold INTEGER, +); +-- +ok +== +CREATE TABLE unit ( + total_profit INTEGER GENERATED ALWAYS AS(price * amount_sold) VIRTUAL, + price INTEGER, + amount_sold INTEGER, +); +-- +ok +== +ALTER TABLE unit DROP COLUMN total_profit; +-- +ok +== +SELECT total_profit FROM unit; +-- +ok +== diff --git a/parser/testdata/corpus/sql/generated_columns/virtual/create_table.test.metadata.json b/parser/testdata/corpus/sql/generated_columns/virtual/create_table.test.metadata.json new file mode 100644 index 0000000..1fdb161 --- /dev/null +++ b/parser/testdata/corpus/sql/generated_columns/virtual/create_table.test.metadata.json @@ -0,0 +1,5 @@ +{ + "todo": { + "7492b9a8ac417db0": "transformer-raised parser error: upstream rejects in the transformer, not the grammar; expected to clear as transformers land (milestones 3-5)" + } +} diff --git a/parser/testdata/corpus/sql/generated_columns/virtual/default.test b/parser/testdata/corpus/sql/generated_columns/virtual/default.test new file mode 100644 index 0000000..c731484 --- /dev/null +++ b/parser/testdata/corpus/sql/generated_columns/virtual/default.test @@ -0,0 +1,37 @@ +# source: test/sql/generated_columns/virtual/default.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +INSERT INTO unit VALUES (4,5) +-- +ok +== +ALTER TABLE unit ADD COLUMN total_profit INTEGER DEFAULT 1 GENERATED ALWAYS AS (price * amount_sold) VIRTUAL; +-- +error: Parser Error: syntax error at or near "GENERATED" +== +CREATE TABLE unit2 ( + price INTEGER, + amount_sold INTEGER, + total_profit INTEGER GENERATED ALWAYS AS (price * amount_sold) VIRTUAL DEFAULT 1 +); +-- +error: Parser Error: Not allowed to set default on a generated column +== +select * from unit2 +-- +ok +== +CREATE TABLE tbl ( + g1 AS (x), + g2 AS (x), + x INTEGER DEFAULT (5), +); +-- +ok +== +INSERT INTO tbl VALUES (DEFAULT); +-- +ok +== diff --git a/parser/testdata/corpus/sql/generated_columns/virtual/default.test.metadata.json b/parser/testdata/corpus/sql/generated_columns/virtual/default.test.metadata.json new file mode 100644 index 0000000..5384371 --- /dev/null +++ b/parser/testdata/corpus/sql/generated_columns/virtual/default.test.metadata.json @@ -0,0 +1,5 @@ +{ + "todo": { + "96641e80d10d5022": "transformer-raised parser error: upstream rejects in the transformer, not the grammar; expected to clear as transformers land (milestones 3-5)" + } +} diff --git a/parser/testdata/corpus/sql/generated_columns/virtual/drop_dependency.test b/parser/testdata/corpus/sql/generated_columns/virtual/drop_dependency.test new file mode 100644 index 0000000..a700de7 --- /dev/null +++ b/parser/testdata/corpus/sql/generated_columns/virtual/drop_dependency.test @@ -0,0 +1,16 @@ +# source: test/sql/generated_columns/virtual/drop_dependency.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +CREATE TABLE tbl ( + price INTEGER, + total_profit AS (price) +); +-- +ok +== +ALTER TABLE tbl DROP COLUMN price; +-- +ok +== diff --git a/parser/testdata/corpus/sql/generated_columns/virtual/foreign_key.test b/parser/testdata/corpus/sql/generated_columns/virtual/foreign_key.test new file mode 100644 index 0000000..ad1f1f8 --- /dev/null +++ b/parser/testdata/corpus/sql/generated_columns/virtual/foreign_key.test @@ -0,0 +1,69 @@ +# source: test/sql/generated_columns/virtual/foreign_key.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +CREATE TABLE tbl1 ( + a INTEGER UNIQUE, +); +-- +ok +== +CREATE TABLE tbl2 ( + a INTEGER, + b AS (a) REFERENCES tbl1(a), +); +-- +ok +== +CREATE TABLE tbl2 ( + a INTEGER, + b AS (a), + FOREIGN KEY (b) REFERENCES tbl1 (a) +); +-- +ok +== +CREATE TABLE tbl2 ( + price INTEGER, + also_price AS (price) UNIQUE +); +-- +ok +== +CREATE TABLE tbl2 ( + price INTEGER, + also_price AS (price) +); +-- +ok +== +CREATE TABLE tbl3 ( + a INTEGER, + FOREIGN KEY (a) REFERENCES tbl2 (also_price) +); +-- +ok +== +CREATE TABLE a ( + a_gen1 AS (a_reg), + a_gen2 AS (a_reg), + a_reg INTEGER, + PRIMARY KEY (a_reg) +); +-- +ok +== +CREATE TABLE b ( + gen1 AS (price), + gen2 AS (price), + price INTEGER, + FOREIGN KEY (price) REFERENCES a (a_reg) +); +-- +ok +== +INSERT INTO a VALUES (5); +-- +ok +== diff --git a/parser/testdata/corpus/sql/generated_columns/virtual/foreign_key_extensive.test b/parser/testdata/corpus/sql/generated_columns/virtual/foreign_key_extensive.test new file mode 100644 index 0000000..99d71db --- /dev/null +++ b/parser/testdata/corpus/sql/generated_columns/virtual/foreign_key_extensive.test @@ -0,0 +1,16 @@ +# source: test/sql/generated_columns/virtual/foreign_key_extensive.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +CREATE TABLE album ( + gen_artistid AS (artistid), + gen_albumname AS (albumname), + artistid INTEGER, + albumname TEXT, + albumcover TEXT, + UNIQUE (artistid, albumname) +); +-- +ok +== diff --git a/parser/testdata/corpus/sql/generated_columns/virtual/from_generated_column.test b/parser/testdata/corpus/sql/generated_columns/virtual/from_generated_column.test new file mode 100644 index 0000000..ab99265 --- /dev/null +++ b/parser/testdata/corpus/sql/generated_columns/virtual/from_generated_column.test @@ -0,0 +1,34 @@ +# source: test/sql/generated_columns/virtual/from_generated_column.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +SELECT total_profit FROM unit +-- +ok +== +ALTER TABLE unit ADD COLUMN also_total_profit INTEGER GENERATED ALWAYS AS (total_profit) VIRTUAL; +-- +error: Parser Error: Adding generated columns after table creation is not supported yet +== +SELECT also_total_profit FROM unit +-- +ok +== +CREATE TABLE unit2( + price INTEGER, + amount_sold INTEGER, + total_profit INTEGER GENERATED ALWAYS AS (price * amount_sold) VIRTUAL, + also_total_profit INTEGER GENERATED ALWAYS AS (total_profit) VIRTUAL +); +-- +ok +== +INSERT INTO unit2 VALUES (100, 0) +-- +ok +== +SELECT * FROM unit2 +-- +ok +== diff --git a/parser/testdata/corpus/sql/generated_columns/virtual/from_generated_column.test.metadata.json b/parser/testdata/corpus/sql/generated_columns/virtual/from_generated_column.test.metadata.json new file mode 100644 index 0000000..be5b796 --- /dev/null +++ b/parser/testdata/corpus/sql/generated_columns/virtual/from_generated_column.test.metadata.json @@ -0,0 +1,5 @@ +{ + "todo": { + "fbde2884feb212aa": "transformer-raised parser error: upstream rejects in the transformer, not the grammar; expected to clear as transformers land (milestones 3-5)" + } +} diff --git a/parser/testdata/corpus/sql/generated_columns/virtual/gcol_duckdb_columns.test b/parser/testdata/corpus/sql/generated_columns/virtual/gcol_duckdb_columns.test new file mode 100644 index 0000000..5527e99 --- /dev/null +++ b/parser/testdata/corpus/sql/generated_columns/virtual/gcol_duckdb_columns.test @@ -0,0 +1,29 @@ +# source: test/sql/generated_columns/virtual/gcol_duckdb_columns.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +create table t (i int, j int as (1)); +-- +ok +== +select column_default from duckdb_columns; +-- +ok +== +select column_name, is_generated from duckdb_columns order by column_index; +-- +ok +== +select column_name, generation_expression from duckdb_columns order by column_index; +-- +ok +== +select column_name, is_generated from information_schema.columns where table_name = 't' order by ordinal_position; +-- +ok +== +select column_name, generation_expression from information_schema.columns where table_name = 't' order by ordinal_position; +-- +ok +== diff --git a/parser/testdata/corpus/sql/generated_columns/virtual/group_by.test b/parser/testdata/corpus/sql/generated_columns/virtual/group_by.test new file mode 100644 index 0000000..9e0d8cf --- /dev/null +++ b/parser/testdata/corpus/sql/generated_columns/virtual/group_by.test @@ -0,0 +1,65 @@ +# source: test/sql/generated_columns/virtual/group_by.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +CREATE TABLE tbl ( + foo INTEGER, + bar INTEGER GENERATED ALWAYS AS (foo+1) VIRTUAL, + foobar INTEGER +); +-- +ok +== +insert into tbl VALUES +(1, 24), +(2342, 123), +(23523, 1), +(235, 213), +(8435, null), +(NULL, NULL), +(345, 213), +(12, 5) +-- +ok +== +insert into tbl select i % 20, random()::INTEGER * 20 from range(100) tbl(i); +-- +ok +== +CREATE TABLE non_generated as select * from tbl; +-- +ok +== +SELECT sql FROM sqlite_master WHERE name = 'tbl' and contains(sql, 'GENERATED'); +-- +ok +== +SELECT sql FROM sqlite_master WHERE name = 'non_generated' and contains(sql, 'GENERATED'); +-- +ok +== +select * from non_generated; +-- +ok +== +select count(*), foobar, foo, last(foo), avg(bar), count(bar) from {table_name} group by bar, foobar, foo order by all; +-- +error: Parser Error: syntax error at or near "{" +== +select count(*), last(foo), avg(bar), count(bar) from {table_name} group by bar order by all; +-- +error: Parser Error: syntax error at or near "{" +== +select count(bar order by foobar desc), count(bar), count(distinct bar), avg(bar) from {table_name} group by foo, foobar order by all; +-- +error: Parser Error: syntax error at or near "{" +== +select count(bar order by foo asc), count(distinct bar) filter ((foo+1) != bar) from {table_name} group by foo order by all; +-- +error: Parser Error: syntax error at or near "{" +== +select count(foo), count(foobar), bar from {table_name} group by CUBE(foo, foobar, bar), bar, foo, CUBE(foo) order by all; +-- +error: Parser Error: syntax error at or near "{" +== diff --git a/parser/testdata/corpus/sql/generated_columns/virtual/implicit_type.test b/parser/testdata/corpus/sql/generated_columns/virtual/implicit_type.test new file mode 100644 index 0000000..ab6c6b6 --- /dev/null +++ b/parser/testdata/corpus/sql/generated_columns/virtual/implicit_type.test @@ -0,0 +1,43 @@ +# source: test/sql/generated_columns/virtual/implicit_type.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +CREATE TABLE test ( + foo INTEGER, + bar GENERATED ALWAYS AS (foo+1), + foobar INTEGER DEFAULT 5 +); +-- +ok +== +CREATE TABLE unit ( + foo INTEGER, + bar AS (foo+1), +) +-- +ok +== +CREATE TABLE tbl ( + foo, + bar GENERATED ALWAYS AS (foo+1) +); +-- +error: Parser Error: Column foo must have a type or be defined as a GENERATED column. +== +INSERT INTO test(foo) VALUES (1); +-- +ok +== +SELECT bar FROM test +-- +ok +== +INSERT INTO unit VALUES(5) +-- +ok +== +SELECT bar FROM unit +-- +ok +== diff --git a/parser/testdata/corpus/sql/generated_columns/virtual/implicit_type.test.metadata.json b/parser/testdata/corpus/sql/generated_columns/virtual/implicit_type.test.metadata.json new file mode 100644 index 0000000..0ee49ef --- /dev/null +++ b/parser/testdata/corpus/sql/generated_columns/virtual/implicit_type.test.metadata.json @@ -0,0 +1,5 @@ +{ + "todo": { + "0eda6c1ffe5252f7": "transformer-raised parser error: upstream rejects in the transformer, not the grammar; expected to clear as transformers land (milestones 3-5)" + } +} diff --git a/parser/testdata/corpus/sql/generated_columns/virtual/insert.test b/parser/testdata/corpus/sql/generated_columns/virtual/insert.test new file mode 100644 index 0000000..f24dde2 --- /dev/null +++ b/parser/testdata/corpus/sql/generated_columns/virtual/insert.test @@ -0,0 +1,59 @@ +# source: test/sql/generated_columns/virtual/insert.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +CREATE TABLE test ( + foo INTEGER, + bar INTEGER GENERATED ALWAYS AS (foo+1) VIRTUAL, + foobar INTEGER DEFAULT 5 +); +-- +ok +== +INSERT INTO test (bar) VALUES (5) +-- +ok +== +INSERT INTO test (foo, foobar) VALUES (1, 10); +-- +ok +== +INSERT INTO test (foo) VALUES (12) +-- +ok +== +INSERT INTO test VALUES (22) +-- +ok +== +INSERT INTO test VALUES (22, 10); +-- +ok +== +INSERT INTO test VALUES (22, 10, 10) +-- +ok +== +CREATE TABLE tbl ( + x INTEGER, + y BOOLEAN AS (x), +); +-- +ok +== +INSERT INTO tbl VALUES (0); +-- +ok +== +CREATE TABLE tbl2 ( + x TEXT, + y BOOLEAN AS (x), +); +-- +ok +== +INSERT INTO tbl2 VALUES ('test'); +-- +ok +== diff --git a/parser/testdata/corpus/sql/generated_columns/virtual/not_referencing_columns.test b/parser/testdata/corpus/sql/generated_columns/virtual/not_referencing_columns.test new file mode 100644 index 0000000..ef1bb41 --- /dev/null +++ b/parser/testdata/corpus/sql/generated_columns/virtual/not_referencing_columns.test @@ -0,0 +1,20 @@ +# source: test/sql/generated_columns/virtual/not_referencing_columns.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +CREATE TABLE tbl ( + price INTEGER, + amount_sold INTEGER, + gcol AS (list(5,4,3)) +); +-- +ok +== +CREATE TABLE tbl ( + price INTEGER, + gcol AS (map()) +); +-- +ok +== diff --git a/parser/testdata/corpus/sql/generated_columns/virtual/null.test b/parser/testdata/corpus/sql/generated_columns/virtual/null.test new file mode 100644 index 0000000..30dcb6c --- /dev/null +++ b/parser/testdata/corpus/sql/generated_columns/virtual/null.test @@ -0,0 +1,24 @@ +# source: test/sql/generated_columns/virtual/null.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +CREATE TABLE unit ( + price INTEGER, + amount_sold AS (price) NOT NULL, +); +-- +ok +== +CREATE TABLE tbl ( + gen1 AS (price), + gen2 AS (price), + price INTEGER NOT NULL +); +-- +ok +== +INSERT INTO tbl VALUES (null); +-- +ok +== diff --git a/parser/testdata/corpus/sql/generated_columns/virtual/partition.test b/parser/testdata/corpus/sql/generated_columns/virtual/partition.test new file mode 100644 index 0000000..8153606 --- /dev/null +++ b/parser/testdata/corpus/sql/generated_columns/virtual/partition.test @@ -0,0 +1,40 @@ +# source: test/sql/generated_columns/virtual/partition.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +CREATE TABLE unit ( + price INTEGER, + amount_sold INTEGER, + name VARCHAR, + total_profit AS (price * amount_sold) +); +-- +ok +== +INSERT INTO unit VALUES (5,4, 'Soda can') +-- +ok +== +INSERT INTO unit VALUES (5,8, 'Mars bar') +-- +ok +== +INSERT INTO unit VALUES (4, 5, 'Chewing gum') +-- +ok +== +SELECT total_profit, COUNT(total_profit), SUM(amount_sold), SUM(price) FROM unit GROUP BY total_profit ORDER BY ALL +-- +ok +== +SELECT total_profit, + name, + COUNT(total_profit) OVER(PARTITION BY total_profit) AS CountTotalProfit, + SUM(amount_sold) OVER(PARTITION BY total_profit) AS SumAmountSold, + SUM(price) OVER(PARTITION BY total_profit) AS SumPrice +FROM unit +ORDER BY 1, 2 DESC +-- +ok +== diff --git a/parser/testdata/corpus/sql/generated_columns/virtual/preserve_order.test b/parser/testdata/corpus/sql/generated_columns/virtual/preserve_order.test new file mode 100644 index 0000000..0b21ac5 --- /dev/null +++ b/parser/testdata/corpus/sql/generated_columns/virtual/preserve_order.test @@ -0,0 +1,13 @@ +# source: test/sql/generated_columns/virtual/preserve_order.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +CREATE TABLE test ( + foo INTEGER, + bar INTEGER GENERATED ALWAYS AS (foo+1) VIRTUAL, + foobar INTEGER +); +-- +ok +== diff --git a/parser/testdata/corpus/sql/generated_columns/virtual/primary_key.test b/parser/testdata/corpus/sql/generated_columns/virtual/primary_key.test new file mode 100644 index 0000000..c738695 --- /dev/null +++ b/parser/testdata/corpus/sql/generated_columns/virtual/primary_key.test @@ -0,0 +1,28 @@ +# source: test/sql/generated_columns/virtual/primary_key.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +CREATE TABLE unit ( + price INTEGER, + amount_sold AS (price) PRIMARY KEY, +); +-- +ok +== +CREATE TABLE unit ( + price INTEGER, + amount_sold AS (price), + PRIMARY KEY (amount_sold), +); +-- +ok +== +CREATE TABLE tbl ( + gen1 AS (price), + gen2 AS (price), + price INTEGER PRIMARY KEY +); +-- +ok +== diff --git a/parser/testdata/corpus/sql/generated_columns/virtual/referencing_gencols.test b/parser/testdata/corpus/sql/generated_columns/virtual/referencing_gencols.test new file mode 100644 index 0000000..36fd88e --- /dev/null +++ b/parser/testdata/corpus/sql/generated_columns/virtual/referencing_gencols.test @@ -0,0 +1,65 @@ +# source: test/sql/generated_columns/virtual/referencing_gencols.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +CREATE TABLE unit ( + price INTEGER, + amount_sold INTEGER, + total_profit AS (price * amount_sold), + profit_total AS (total_profit * 5) +); +-- +ok +== +INSERT INTO unit VALUES (4,5); +-- +ok +== +CREATE TABLE tbl2 ( + circular INTEGER AS (dependency), + dependency INTEGER AS (circular) +); +-- +ok +== +CREATE TABLE tbl2 ( + price INTEGER, + circular AS (dependency * price), + dependency AS (price), +); +-- +ok +== +CREATE TABLE tbl3 ( + dependency INTEGER AS (price), + price INTEGER, + circular AS (dependency), +); +-- +ok +== +CREATE TABLE tbl ( + price INTEGER, + dependency INTEGER AS (price), + circular AS (dependency * price), +); +-- +ok +== +CREATE TABLE tbl4 ( + price INTEGER, + dependency AS (price), + depth1 AS (dependency), + depth2 AS (price * dependency), + depth3 AS (depth1 * depth2 * dependency), + depth4 aS ((dependency * depth3) + depth1), + depth5 AS (depth4 - (depth3 + depth2) + (dependency * depth1)) +); +-- +ok +== +INSERT INTO tbl4 VALUES (5); +-- +ok +== diff --git a/parser/testdata/corpus/sql/generated_columns/virtual/rename.test b/parser/testdata/corpus/sql/generated_columns/virtual/rename.test new file mode 100644 index 0000000..47d2929 --- /dev/null +++ b/parser/testdata/corpus/sql/generated_columns/virtual/rename.test @@ -0,0 +1,13 @@ +# source: test/sql/generated_columns/virtual/rename.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +ALTER TABLE unit RENAME COLUMN total_profit TO profit_total +-- +ok +== +SELECT profit_total FROM unit +-- +ok +== diff --git a/parser/testdata/corpus/sql/generated_columns/virtual/rename_dependency.test b/parser/testdata/corpus/sql/generated_columns/virtual/rename_dependency.test new file mode 100644 index 0000000..2d0e233 --- /dev/null +++ b/parser/testdata/corpus/sql/generated_columns/virtual/rename_dependency.test @@ -0,0 +1,23 @@ +# source: test/sql/generated_columns/virtual/rename_dependency.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +CREATE TABLE unit ( + price INTEGER, + amount_sold INTEGER, + total_profit AS (price * amount_sold), + profit_total AS (total_profit), + sold_amount AS (5 + 3) +); +-- +ok +== +ALTER TABLE unit RENAME COLUMN price TO value +-- +ok +== +ALTER TABLE unit DROP COLUMN value; +-- +ok +== diff --git a/parser/testdata/corpus/sql/generated_columns/virtual/rename_table.test b/parser/testdata/corpus/sql/generated_columns/virtual/rename_table.test new file mode 100644 index 0000000..285522b --- /dev/null +++ b/parser/testdata/corpus/sql/generated_columns/virtual/rename_table.test @@ -0,0 +1,21 @@ +# source: test/sql/generated_columns/virtual/rename_table.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +CREATE TABLE unit ( + price INTEGER, + amount_sold INTEGER, + total_profit AS (price * amount_sold) +); +-- +ok +== +ALTER TABLE unit RENAME TO not_unit; +-- +ok +== +SELECT * FROM not_unit; +-- +ok +== diff --git a/parser/testdata/corpus/sql/generated_columns/virtual/row_group_fetch.test b/parser/testdata/corpus/sql/generated_columns/virtual/row_group_fetch.test new file mode 100644 index 0000000..ee6db58 --- /dev/null +++ b/parser/testdata/corpus/sql/generated_columns/virtual/row_group_fetch.test @@ -0,0 +1,25 @@ +# source: test/sql/generated_columns/virtual/row_group_fetch.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +CREATE TABLE t1 ( + tr INTEGER, + td INTEGER GENERATED ALWAYS AS (tr), + tz INTEGER +); +-- +ok +== +CREATE INDEX id ON t1(tr); +-- +ok +== +INSERT INTO t1(tr) VALUES (2); +-- +ok +== +SELECT tz from t1 WHERE tr < 5; +-- +ok +== diff --git a/parser/testdata/corpus/sql/generated_columns/virtual/rowid.test b/parser/testdata/corpus/sql/generated_columns/virtual/rowid.test new file mode 100644 index 0000000..753a5a8 --- /dev/null +++ b/parser/testdata/corpus/sql/generated_columns/virtual/rowid.test @@ -0,0 +1,31 @@ +# source: test/sql/generated_columns/virtual/rowid.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +ALTER TABLE unit ADD COLUMN total_profit BIGINT GENERATED ALWAYS AS (price * rowid) VIRTUAL; +-- +error: Parser Error: Adding generated columns after table creation is not supported yet +== +CREATE TABLE tbl ( + price INTEGER, + rowid BIGINT GENERATED ALWAYS AS (rowid) VIRTUAL +); +-- +ok +== +CREATE TABLE tbl ( + rowid INTEGER, + index INTEGER GENERATED ALWAYS AS (rowid) VIRTUAL +) +-- +ok +== +INSERT INTO tbl VALUES (5) +-- +ok +== +SELECT index FROM tbl; +-- +ok +== diff --git a/parser/testdata/corpus/sql/generated_columns/virtual/rowid.test.metadata.json b/parser/testdata/corpus/sql/generated_columns/virtual/rowid.test.metadata.json new file mode 100644 index 0000000..94c6da2 --- /dev/null +++ b/parser/testdata/corpus/sql/generated_columns/virtual/rowid.test.metadata.json @@ -0,0 +1,5 @@ +{ + "todo": { + "4a155647396b2908": "transformer-raised parser error: upstream rejects in the transformer, not the grammar; expected to clear as transformers land (milestones 3-5)" + } +} diff --git a/parser/testdata/corpus/sql/generated_columns/virtual/select.test b/parser/testdata/corpus/sql/generated_columns/virtual/select.test new file mode 100644 index 0000000..57f6351 --- /dev/null +++ b/parser/testdata/corpus/sql/generated_columns/virtual/select.test @@ -0,0 +1,25 @@ +# source: test/sql/generated_columns/virtual/select.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +CREATE TABLE tbl ( + price INTEGER, + amount_sold INTEGER, + total_profit AS (price * amount_sold), +); +-- +ok +== +INSERT INTO tbl VALUES (5,4); +-- +ok +== +SELECT total_profit FROM tbl +-- +ok +== +SELECT tbl.* FROM tbl +-- +ok +== diff --git a/parser/testdata/corpus/sql/generated_columns/virtual/select_alias.test b/parser/testdata/corpus/sql/generated_columns/virtual/select_alias.test new file mode 100644 index 0000000..db6c3a5 --- /dev/null +++ b/parser/testdata/corpus/sql/generated_columns/virtual/select_alias.test @@ -0,0 +1,35 @@ +# source: test/sql/generated_columns/virtual/select_alias.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +CREATE TABLE tbl ( + price INTEGER, + amount_sold INTEGER, + total_profit AS (price * amount_sold), + order_id BIGINT, + y as (order_id + total_profit - amount_sold) +); +-- +ok +== +select * from tbl {table_alias}(y, order_id, total_profit, amount_sold, price); +-- +error: Parser Error: syntax error at or near "{" +== +select * from tbl {table_alias}; +-- +error: Parser Error: syntax error at or near "{" +== +select * from tbl {table_alias}(a, b, c, d, e); +-- +error: Parser Error: syntax error at or near "{" +== +select a, b from tbl {table_alias}(e, c, b, d, a); +-- +error: Parser Error: syntax error at or near "{" +== +select y, amount_sold from tbl; +-- +ok +== diff --git a/parser/testdata/corpus/sql/generated_columns/virtual/type_resolution_bug.test b/parser/testdata/corpus/sql/generated_columns/virtual/type_resolution_bug.test new file mode 100644 index 0000000..c5fa724 --- /dev/null +++ b/parser/testdata/corpus/sql/generated_columns/virtual/type_resolution_bug.test @@ -0,0 +1,20 @@ +# source: test/sql/generated_columns/virtual/type_resolution_bug.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +CREATE TABLE unit ( + bar TEXT, + foobar as (concat(foo, bar)), + profit_total AS (foobar), + dependent AS (profit_total), + also_dependent AS (concat(profit_total,dependent)), + foo TEXT, +); +-- +ok +== +INSERT INTO unit VALUES ('string','test') +-- +ok +== diff --git a/parser/testdata/corpus/sql/generated_columns/virtual/typechange.test b/parser/testdata/corpus/sql/generated_columns/virtual/typechange.test new file mode 100644 index 0000000..9730bcd --- /dev/null +++ b/parser/testdata/corpus/sql/generated_columns/virtual/typechange.test @@ -0,0 +1,20 @@ +# source: test/sql/generated_columns/virtual/typechange.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +ALTER TABLE unit ALTER COLUMN total_profit TYPE BOOLEAN; +-- +ok +== +INSERT INTO unit VALUES (5,0); +-- +ok +== +CREATE TABLE tbl ( + price INTEGER, + total_profit DATE AS (price * 5), +); +-- +ok +== diff --git a/parser/testdata/corpus/sql/generated_columns/virtual/typechange_dependency.test b/parser/testdata/corpus/sql/generated_columns/virtual/typechange_dependency.test new file mode 100644 index 0000000..5ae41b8 --- /dev/null +++ b/parser/testdata/corpus/sql/generated_columns/virtual/typechange_dependency.test @@ -0,0 +1,9 @@ +# source: test/sql/generated_columns/virtual/typechange_dependency.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +ALTER TABLE unit ALTER COLUMN price TYPE BOOLEAN; +-- +ok +== diff --git a/parser/testdata/corpus/sql/generated_columns/virtual/unique.test b/parser/testdata/corpus/sql/generated_columns/virtual/unique.test new file mode 100644 index 0000000..fe0f67c --- /dev/null +++ b/parser/testdata/corpus/sql/generated_columns/virtual/unique.test @@ -0,0 +1,28 @@ +# source: test/sql/generated_columns/virtual/unique.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +CREATE TABLE unit ( + price INTEGER, + amount_sold AS (price) UNIQUE, +); +-- +ok +== +CREATE TABLE unit ( + price INTEGER, + amount_sold AS (price), + UNIQUE (amount_sold), +); +-- +ok +== +CREATE TABLE tbl ( + gen1 AS (price), + gen2 AS (price), + price INTEGER UNIQUE +); +-- +ok +== diff --git a/parser/testdata/corpus/sql/generated_columns/virtual/update.test b/parser/testdata/corpus/sql/generated_columns/virtual/update.test new file mode 100644 index 0000000..96ac5cd --- /dev/null +++ b/parser/testdata/corpus/sql/generated_columns/virtual/update.test @@ -0,0 +1,29 @@ +# source: test/sql/generated_columns/virtual/update.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +INSERT INTO test VALUES (5, DEFAULT) +-- +ok +== +INSERT INTO test VALUES (10, 3); +-- +ok +== +UPDATE test SET bar = 5 +-- +ok +== +UPDATE test SET foo=3; +-- +ok +== +UPDATE test SET foo=9001 WHERE (foobar == 3); +-- +ok +== +UPDATE test SET foo=0 WHERE (bar < 9000); +-- +ok +== diff --git a/parser/testdata/corpus/sql/generated_columns/virtual/update_index.test b/parser/testdata/corpus/sql/generated_columns/virtual/update_index.test new file mode 100644 index 0000000..8232d54 --- /dev/null +++ b/parser/testdata/corpus/sql/generated_columns/virtual/update_index.test @@ -0,0 +1,26 @@ +# source: test/sql/generated_columns/virtual/update_index.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +CREATE TABLE tbl_comp ( + a INT, + gen AS (2 * a), + b INT, + c VARCHAR, + PRIMARY KEY(c)); +-- +ok +== +INSERT INTO tbl_comp VALUES (1, 1, 'hello'); +-- +ok +== +UPDATE tbl_comp SET c='world' +-- +ok +== +FROM tbl_comp +-- +ok +== diff --git a/parser/testdata/corpus/sql/index/art/constraints/test_art_compound_key_changes.test b/parser/testdata/corpus/sql/index/art/constraints/test_art_compound_key_changes.test new file mode 100644 index 0000000..6a26ba1 --- /dev/null +++ b/parser/testdata/corpus/sql/index/art/constraints/test_art_compound_key_changes.test @@ -0,0 +1,80 @@ +# source: test/sql/index/art/constraints/test_art_compound_key_changes.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +SET immediate_transaction_mode = true; +-- +ok +== +CREATE TABLE tbl_comp ( + a INT, + b VARCHAR UNIQUE, + gen AS (2 * a), + c INT, + d VARCHAR, + PRIMARY KEY (c, b)); +-- +ok +== +CREATE UNIQUE INDEX unique_idx ON tbl_comp((d || 'hello'), (a + 42)); +-- +ok +== +CREATE INDEX normal_idx ON tbl_comp(d, a, c); +-- +ok +== +CREATE UNIQUE INDEX lookup_idx ON tbl_comp(c); +-- +ok +== +INSERT INTO tbl_comp VALUES (1, 'hello', 1, 'hello'); +-- +ok +== +INSERT INTO tbl_comp VALUES (2, 'hello', 1, 'world') +ON CONFLICT (c, b) DO UPDATE SET a = excluded.a, d = excluded.d; +-- +ok +== +SELECT a, b, gen, c, d FROM tbl_comp WHERE c = 1; +-- +ok +== +INSERT INTO tbl_comp VALUES (2, 'hola', 5, 'world'); +-- +ok +== +INSERT INTO tbl_comp VALUES (3, 'hoi', 1, 'wereld'); +-- +ok +== +INSERT INTO tbl_comp VALUES (3, 'hoi', 2, 'wereld'); +-- +ok +== +SELECT a, b, gen, c, d FROM tbl_comp ORDER BY ALL; +-- +ok +== +INSERT INTO tbl_comp VALUES (42, 'hoi', 2, 'welt'); +-- +ok +== +INSERT INTO tbl_comp VALUES (42, 'hoii', 22, 'welt'); +-- +ok +== +DELETE FROM tbl_comp; +-- +ok +== +INSERT INTO tbl_comp VALUES (200, 'hello', 1, 'world'), (300, 'hoi', 2, 'wereld'); +-- +ok +== +SELECT a, b, gen, c, d FROM tbl_comp WHERE c = 2; +-- +ok +== diff --git a/parser/testdata/corpus/sql/index/art/constraints/test_art_eager_batch_insert.test b/parser/testdata/corpus/sql/index/art/constraints/test_art_eager_batch_insert.test new file mode 100644 index 0000000..a843191 --- /dev/null +++ b/parser/testdata/corpus/sql/index/art/constraints/test_art_eager_batch_insert.test @@ -0,0 +1,33 @@ +# source: test/sql/index/art/constraints/test_art_eager_batch_insert.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +CREATE TABLE test1 (id INT PRIMARY KEY, payload VARCHAR); +-- +ok +== +CREATE TABLE test2 (id INT PRIMARY KEY, payload VARCHAR); +-- +ok +== +INSERT INTO test1 VALUES (1, 'row 1'); +-- +ok +== +INSERT INTO test2 VALUES (1, 'row 1 from test 2'); +-- +ok +== +SELECT id, payload FROM test1; +-- +ok +== +DELETE FROM test1 WHERE id = 1; +-- +ok +== +INSERT INTO test1 SELECT * FROM test2; +-- +ok +== diff --git a/parser/testdata/corpus/sql/index/art/constraints/test_art_eager_constraint_checking.test b/parser/testdata/corpus/sql/index/art/constraints/test_art_eager_constraint_checking.test new file mode 100644 index 0000000..b8c750b --- /dev/null +++ b/parser/testdata/corpus/sql/index/art/constraints/test_art_eager_constraint_checking.test @@ -0,0 +1,248 @@ +# source: test/sql/index/art/constraints/test_art_eager_constraint_checking.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +SET max_vacuum_tasks = 0; +-- +ok +== +CREATE TABLE t_7182 (it INTEGER PRIMARY KEY, jt INTEGER); +-- +ok +== +CREATE TABLE u_7182 (iu INTEGER PRIMARY KEY, ju INTEGER REFERENCES t_7182 (it)); +-- +ok +== +INSERT INTO t_7182 VALUES (1, 1); +-- +ok +== +INSERT INTO u_7182 VALUES (1, NULL); +-- +ok +== +UPDATE u_7182 SET ju = 1 WHERE iu = 1; +-- +ok +== +SELECT iu, ju, rowid FROM u_7182 WHERE iu = 1; +-- +ok +== +CREATE TABLE tunion_5807 (id INTEGER PRIMARY KEY, u UNION (i int)); +-- +ok +== +INSERT INTO tunion_5807 SELECT 1, 41; +-- +ok +== +UPDATE tunion_5807 SET u = 42 WHERE id = 1; +-- +ok +== +SELECT id, u, rowid FROM tunion_5807 WHERE id = 1; +-- +ok +== +CREATE TABLE IF NOT EXISTS workers_5771 ( + id INTEGER PRIMARY KEY NOT NULL, + worker VARCHAR(150) UNIQUE NOT NULL, + phone VARCHAR(20) NOT NULL); +-- +ok +== +INSERT INTO workers_5771 VALUES (1, 'wagner', '123'); +-- +ok +== +UPDATE workers_5771 SET phone = '345' WHERE id = 1; +-- +ok +== +UPDATE workers_5771 SET worker = 'leo' WHERE id = 1; +-- +ok +== +SELECT id, worker, phone, rowid FROM workers_5771 WHERE id = 1; +-- +ok +== +CREATE TABLE test_4886 (i INTEGER PRIMARY KEY); +-- +ok +== +INSERT INTO test_4886 VALUES (1); +-- +ok +== +UPDATE test_4886 SET i = 4 WHERE i = 1; +-- +ok +== +SELECT i, rowid FROM test_4886 ORDER BY ALL; +-- +ok +== +SELECT i, rowid FROM test_4886 WHERE i = 1; +-- +ok +== +SELECT i, rowid FROM test_4886 WHERE i = 4; +-- +ok +== +CREATE TABLE tbl_1631 ( + id INTEGER PRIMARY KEY, + c1 text NOT NULL UNIQUE, + c2 text NOT NULL); +-- +ok +== +INSERT INTO tbl_1631 VALUES (1, 'abc', 'def'), (2, 'asdf', 'jkl'); +-- +ok +== +UPDATE tbl_1631 SET c1 = 'ghi', c2 = 'mno' WHERE id = 2; +-- +ok +== +SELECT id, c1, c2, rowid FROM tbl_1631 ORDER BY ALL; +-- +ok +== +CREATE TABLE c_4214 (id INTEGER NOT NULL PRIMARY KEY); +-- +ok +== +CREATE TABLE a_4214 ( + id INTEGER NOT NULL PRIMARY KEY, + c_id INTEGER NOT NULL, + FOREIGN KEY(c_id) REFERENCES c_4214 (id) +); +-- +ok +== +INSERT INTO c_4214 (id) VALUES (1), (2); +-- +ok +== +INSERT INTO a_4214 (id, c_id) VALUES (1, 1); +-- +ok +== +UPDATE a_4214 SET c_id = 2 WHERE id = 1; +-- +ok +== +SELECT id, c_id, rowid FROM a_4214 WHERE id = 1; +-- +ok +== +CREATE TABLE tag_8764 ( + key VARCHAR(65535) NOT NULL, + name VARCHAR(65535) NULL, + value VARCHAR(65535) NOT NULL, + PRIMARY KEY (key, name) +); +-- +ok +== +CREATE UNIQUE INDEX idx_name_8764 ON tag_8764(name); +-- +ok +== +CREATE UNIQUE INDEX idx_value_8764 ON tag_8764(value); +-- +ok +== +INSERT INTO tag_8764 (key, name, value) VALUES ('key1', 'name1', 'value1'); +-- +ok +== +UPDATE tag_8764 SET value = 'new_value' WHERE key = 'key1' AND name = 'name1'; +-- +ok +== +SELECT key, name, value, rowid FROM tag_8764; +-- +ok +== +CREATE TABLE t_11288 (i INT PRIMARY KEY, j MAP(VARCHAR, VARCHAR)); +-- +ok +== +INSERT INTO t_11288 VALUES (1, MAP(['a'], ['b'])); +-- +ok +== +UPDATE t_11288 SET j = MAP(['c'], ['d']) WHERE i = 1; +-- +ok +== +SELECT i, j FROM t_11288 WHERE i = 1; +-- +ok +== +CREATE TABLE t_4807 (id INT PRIMARY KEY, u UNION (i INT)); +-- +ok +== +INSERT INTO t_4807 SELECT 1, 41; +-- +ok +== +UPDATE t_4807 SET u = 42 WHERE id = 1; +-- +ok +== +SELECT id, u, rowid FROM t_4807; +-- +ok +== +CREATE TABLE t_14133 (i INT PRIMARY KEY, s VARCHAR); +-- +ok +== +INSERT INTO t_14133 SELECT i, i::string FROM generate_series(1, 100) s(i); +-- +ok +== +DELETE FROM t_14133 WHERE i IN (SELECT i FROM generate_series(1, 20) s(i)); +-- +ok +== +INSERT OR REPLACE INTO t_14133 SELECT i, (i * 2)::string FROM generate_series(1, 20) s(i); +-- +ok +== +SELECT COUNT(*), MIN(i), MAX(i) FROM t_14133; +-- +ok +== +CREATE TABLE tbl_6500 (i INTEGER, j INTEGER); +-- +ok +== +INSERT INTO tbl_6500 VALUES (1, 100), (2, 200); +-- +ok +== +CREATE UNIQUE INDEX idx_6500 ON tbl_6500 (i); +-- +ok +== +INSERT OR IGNORE INTO tbl_6500 VALUES (1, 101), (2, 201); +-- +ok +== +SELECT i, j FROM tbl_6500 ORDER BY ALL; +-- +ok +== +INSERT INTO tbl_6500 VALUES (1,101), (2,201) ON CONFLICT DO NOTHING; +-- +ok +== diff --git a/parser/testdata/corpus/sql/index/art/constraints/test_art_eager_with_wal.test b/parser/testdata/corpus/sql/index/art/constraints/test_art_eager_with_wal.test new file mode 100644 index 0000000..d185166 --- /dev/null +++ b/parser/testdata/corpus/sql/index/art/constraints/test_art_eager_with_wal.test @@ -0,0 +1,13 @@ +# source: test/sql/index/art/constraints/test_art_eager_with_wal.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +CREATE TABLE tbl (id INT PRIMARY KEY); +-- +ok +== +DELETE FROM tbl WHERE id = 1; +-- +ok +== diff --git a/parser/testdata/corpus/sql/index/art/constraints/test_art_large_abort.test b/parser/testdata/corpus/sql/index/art/constraints/test_art_large_abort.test new file mode 100644 index 0000000..bd94f0b --- /dev/null +++ b/parser/testdata/corpus/sql/index/art/constraints/test_art_large_abort.test @@ -0,0 +1,33 @@ +# source: test/sql/index/art/constraints/test_art_large_abort.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +CREATE TABLE a(id INTEGER PRIMARY KEY, c INT); +-- +ok +== +INSERT INTO a VALUES (1, 4) +-- +ok +== +INSERT INTO a SELECT i id, NULL c FROM range(-2, -250000, -1) tbl(i) +-- +ok +== +INSERT INTO a VALUES (1, 5) +-- +ok +== +SELECT c FROM a WHERE id=1 +-- +ok +== +SELECT * FROM a +-- +ok +== +INSERT INTO a SELECT i id, -i c FROM range(-2, -250000, -1) tbl(i) +-- +ok +== diff --git a/parser/testdata/corpus/sql/index/art/constraints/test_art_simple_update.test b/parser/testdata/corpus/sql/index/art/constraints/test_art_simple_update.test new file mode 100644 index 0000000..184497b --- /dev/null +++ b/parser/testdata/corpus/sql/index/art/constraints/test_art_simple_update.test @@ -0,0 +1,29 @@ +# source: test/sql/index/art/constraints/test_art_simple_update.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +CREATE TABLE tbl (i BIGINT PRIMARY KEY, l1 BIGINT[]); +-- +ok +== +INSERT INTO tbl VALUES(1, [1, 2, 3]), (2, [42]); +-- +ok +== +SELECT i, l1, rowid FROM tbl ORDER BY ALL; +-- +ok +== +UPDATE tbl SET l1 = [1, 2, 4] WHERE i = 1; +-- +ok +== +INSERT OR REPLACE INTO tbl VALUES (2, [43]); +-- +ok +== +INSERT OR REPLACE INTO tbl VALUES (2, [44]); +-- +ok +== diff --git a/parser/testdata/corpus/sql/index/art/constraints/test_art_tx_conflict_revert.test b/parser/testdata/corpus/sql/index/art/constraints/test_art_tx_conflict_revert.test new file mode 100644 index 0000000..9a960f7 --- /dev/null +++ b/parser/testdata/corpus/sql/index/art/constraints/test_art_tx_conflict_revert.test @@ -0,0 +1,45 @@ +# source: test/sql/index/art/constraints/test_art_tx_conflict_revert.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +SET immediate_transaction_mode=true; +-- +ok +== +CREATE TABLE tbl(i INT PRIMARY KEY); +-- +ok +== +INSERT INTO tbl FROM range(100_000); +-- +ok +== +CREATE TABLE tbl2(i INT); +-- +ok +== +INSERT INTO tbl2 VALUES (42); +-- +ok +== +DELETE FROM tbl; +-- +ok +== +ALTER TABLE tbl2 ADD COLUMN j INTEGER +-- +ok +== +FROM tbl WHERE i=50_000 +-- +ok +== +INSERT INTO tbl VALUES (50_000) +-- +ok +== +DROP TABLE tbl2 +-- +ok +== diff --git a/parser/testdata/corpus/sql/index/art/constraints/test_art_tx_delete_with_global_nested.test b/parser/testdata/corpus/sql/index/art/constraints/test_art_tx_delete_with_global_nested.test new file mode 100644 index 0000000..a41ed09 --- /dev/null +++ b/parser/testdata/corpus/sql/index/art/constraints/test_art_tx_delete_with_global_nested.test @@ -0,0 +1,25 @@ +# source: test/sql/index/art/constraints/test_art_tx_delete_with_global_nested.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +CREATE TABLE tbl (id INT PRIMARY KEY, payload VARCHAR[]); +-- +ok +== +INSERT INTO tbl VALUES (1, ['first payload']); +-- +ok +== +INSERT INTO tbl VALUES (1, ['con1 payload']); +-- +ok +== +INSERT INTO tbl VALUES (1, ['con2 payload']); +-- +ok +== +SELECT id, payload, rowid FROM tbl WHERE id = 1; +-- +ok +== diff --git a/parser/testdata/corpus/sql/index/art/constraints/test_art_tx_deletes_list.test b/parser/testdata/corpus/sql/index/art/constraints/test_art_tx_deletes_list.test new file mode 100644 index 0000000..63016a4 --- /dev/null +++ b/parser/testdata/corpus/sql/index/art/constraints/test_art_tx_deletes_list.test @@ -0,0 +1,33 @@ +# source: test/sql/index/art/constraints/test_art_tx_deletes_list.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +CREATE TABLE tbl_list (id INT PRIMARY KEY, payload VARCHAR[]); +-- +ok +== +INSERT INTO tbl_list VALUES (1, ['first payload']); +-- +ok +== +INSERT INTO tbl_list VALUES (5, ['old payload']); +-- +ok +== +DELETE FROM tbl_list; +-- +ok +== +INSERT INTO tbl_list VALUES (1, ['con1 payload']); +-- +ok +== +SELECT id, payload, rowid FROM tbl_list WHERE id = 1; +-- +ok +== +SELECT id, payload, rowid FROM tbl_list ORDER BY ALL; +-- +ok +== diff --git a/parser/testdata/corpus/sql/index/art/constraints/test_art_tx_deletes_rollback.test b/parser/testdata/corpus/sql/index/art/constraints/test_art_tx_deletes_rollback.test new file mode 100644 index 0000000..1ca59a1 --- /dev/null +++ b/parser/testdata/corpus/sql/index/art/constraints/test_art_tx_deletes_rollback.test @@ -0,0 +1,25 @@ +# source: test/sql/index/art/constraints/test_art_tx_deletes_rollback.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +CREATE TABLE tbl_rollback (id INT PRIMARY KEY, payload VARCHAR[]); +-- +ok +== +INSERT INTO tbl_rollback VALUES (1, ['first payload']); +-- +ok +== +DELETE FROM tbl_rollback; +-- +ok +== +INSERT INTO tbl_rollback VALUES (1, ['con1 payload']); +-- +ok +== +SELECT id, payload, rowid FROM tbl_rollback ORDER BY ALL; +-- +ok +== diff --git a/parser/testdata/corpus/sql/index/art/constraints/test_art_tx_deletes_varchar.test b/parser/testdata/corpus/sql/index/art/constraints/test_art_tx_deletes_varchar.test new file mode 100644 index 0000000..fc16160 --- /dev/null +++ b/parser/testdata/corpus/sql/index/art/constraints/test_art_tx_deletes_varchar.test @@ -0,0 +1,25 @@ +# source: test/sql/index/art/constraints/test_art_tx_deletes_varchar.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +CREATE TABLE tbl (id INT PRIMARY KEY, payload VARCHAR); +-- +ok +== +INSERT INTO tbl VALUES (1, 'first payload'); +-- +ok +== +INSERT INTO tbl VALUES (5, 'old payload'); +-- +ok +== +INSERT INTO tbl VALUES (1, 'con1 payload'); +-- +ok +== +SELECT id, payload, rowid FROM tbl ORDER BY ALL; +-- +ok +== diff --git a/parser/testdata/corpus/sql/index/art/constraints/test_art_tx_over_eager.test b/parser/testdata/corpus/sql/index/art/constraints/test_art_tx_over_eager.test new file mode 100644 index 0000000..ee0f761 --- /dev/null +++ b/parser/testdata/corpus/sql/index/art/constraints/test_art_tx_over_eager.test @@ -0,0 +1,25 @@ +# source: test/sql/index/art/constraints/test_art_tx_over_eager.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +CREATE TABLE tbl(i INT PRIMARY KEY, v VARCHAR); +-- +ok +== +INSERT INTO tbl VALUES (1, 'row 1'), (2, 'row 2'), (3, 'row 3'); +-- +ok +== +DELETE FROM tbl WHERE i=2; +-- +ok +== +SELECT * FROM tbl WHERE i=2 +-- +ok +== +INSERT INTO tbl VALUES (2, 'new row'); +-- +ok +== diff --git a/parser/testdata/corpus/sql/index/art/constraints/test_art_tx_returning.test b/parser/testdata/corpus/sql/index/art/constraints/test_art_tx_returning.test new file mode 100644 index 0000000..0aaeb16 --- /dev/null +++ b/parser/testdata/corpus/sql/index/art/constraints/test_art_tx_returning.test @@ -0,0 +1,21 @@ +# source: test/sql/index/art/constraints/test_art_tx_returning.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +INSERT INTO tbl_list SELECT range, [range || ' payload'] FROM range(5); +-- +ok +== +UPDATE tbl_list SET id = id + 5 RETURNING id, payload; +-- +ok +== +INSERT INTO tbl_list SELECT range + 10, [(range + 10) || ' payload'] FROM range(3000); +-- +ok +== +UPDATE tbl_list SET id = id + 1 RETURNING id, payload; +-- +ok +== diff --git a/parser/testdata/corpus/sql/index/art/constraints/test_art_tx_same_row_id.test b/parser/testdata/corpus/sql/index/art/constraints/test_art_tx_same_row_id.test new file mode 100644 index 0000000..95cf72d --- /dev/null +++ b/parser/testdata/corpus/sql/index/art/constraints/test_art_tx_same_row_id.test @@ -0,0 +1,13 @@ +# source: test/sql/index/art/constraints/test_art_tx_same_row_id.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +INSERT INTO tbl_list SELECT range, [range || ' payload'] FROM range(10); +-- +ok +== +DELETE FROM tbl_list USING range(100) t(i) RETURNING id, payload; +-- +ok +== diff --git a/parser/testdata/corpus/sql/index/art/constraints/test_art_tx_update_with_global_nested.test b/parser/testdata/corpus/sql/index/art/constraints/test_art_tx_update_with_global_nested.test new file mode 100644 index 0000000..c1847db --- /dev/null +++ b/parser/testdata/corpus/sql/index/art/constraints/test_art_tx_update_with_global_nested.test @@ -0,0 +1,13 @@ +# source: test/sql/index/art/constraints/test_art_tx_update_with_global_nested.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +UPDATE tbl SET payload = ['con1 payload'] WHERE id = 1; +-- +ok +== +UPDATE tbl SET payload = ['con2 payload'] WHERE id = 1; +-- +ok +== diff --git a/parser/testdata/corpus/sql/index/art/constraints/test_art_tx_updates_list.test b/parser/testdata/corpus/sql/index/art/constraints/test_art_tx_updates_list.test new file mode 100644 index 0000000..c4f111e --- /dev/null +++ b/parser/testdata/corpus/sql/index/art/constraints/test_art_tx_updates_list.test @@ -0,0 +1,33 @@ +# source: test/sql/index/art/constraints/test_art_tx_updates_list.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +INSERT INTO tbl_list VALUES (1, ['first payload']), (2, ['second payload']); +-- +ok +== +UPDATE tbl_list SET payload = ['con1 payload'] WHERE id = 1; +-- +ok +== +UPDATE tbl_list SET id = 3 WHERE id = 2; +-- +ok +== +INSERT INTO tbl_list VALUES (2, ['new payload']); +-- +ok +== +SELECT id, payload, rowid FROM tbl_list WHERE id = 2; +-- +ok +== +UPDATE tbl_list SET payload = ['second payload'] WHERE id = 1; +-- +ok +== +SELECT id, payload, rowid FROM tbl_list WHERE id = 3; +-- +ok +== diff --git a/parser/testdata/corpus/sql/index/art/constraints/test_art_tx_updates_pk_col.test b/parser/testdata/corpus/sql/index/art/constraints/test_art_tx_updates_pk_col.test new file mode 100644 index 0000000..698bdbf --- /dev/null +++ b/parser/testdata/corpus/sql/index/art/constraints/test_art_tx_updates_pk_col.test @@ -0,0 +1,29 @@ +# source: test/sql/index/art/constraints/test_art_tx_updates_pk_col.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +UPDATE tbl SET id = 3 WHERE id = 1; +-- +ok +== +INSERT INTO tbl VALUES (1, 'new payload'); +-- +ok +== +UPDATE tbl SET payload = 'second payload' WHERE id = 1; +-- +ok +== +SELECT id, payload FROM tbl WHERE id = 1; +-- +ok +== +SELECT id, payload FROM tbl WHERE id = 3; +-- +ok +== +SELECT id, payload, rowid FROM tbl WHERE id = 3; +-- +ok +== diff --git a/parser/testdata/corpus/sql/index/art/constraints/test_art_tx_updates_rollback.test b/parser/testdata/corpus/sql/index/art/constraints/test_art_tx_updates_rollback.test new file mode 100644 index 0000000..db05786 --- /dev/null +++ b/parser/testdata/corpus/sql/index/art/constraints/test_art_tx_updates_rollback.test @@ -0,0 +1,9 @@ +# source: test/sql/index/art/constraints/test_art_tx_updates_rollback.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +UPDATE tbl_rollback SET payload = ['con1 payload'] WHERE id = 1; +-- +ok +== diff --git a/parser/testdata/corpus/sql/index/art/constraints/test_art_tx_upsert_with_global_nested.test b/parser/testdata/corpus/sql/index/art/constraints/test_art_tx_upsert_with_global_nested.test new file mode 100644 index 0000000..1c181ea --- /dev/null +++ b/parser/testdata/corpus/sql/index/art/constraints/test_art_tx_upsert_with_global_nested.test @@ -0,0 +1,13 @@ +# source: test/sql/index/art/constraints/test_art_tx_upsert_with_global_nested.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +INSERT OR REPLACE INTO tbl VALUES (1, ['con1 payload']); +-- +ok +== +INSERT OR REPLACE INTO tbl VALUES (1, ['con2 payload']); +-- +ok +== diff --git a/parser/testdata/corpus/sql/index/art/constraints/test_art_tx_upserts_list.test b/parser/testdata/corpus/sql/index/art/constraints/test_art_tx_upserts_list.test new file mode 100644 index 0000000..110c0a5 --- /dev/null +++ b/parser/testdata/corpus/sql/index/art/constraints/test_art_tx_upserts_list.test @@ -0,0 +1,13 @@ +# source: test/sql/index/art/constraints/test_art_tx_upserts_list.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +INSERT OR REPLACE INTO tbl_list VALUES (1, ['con1 payload']); +-- +ok +== +INSERT OR REPLACE INTO tbl_list VALUES (1, ['second payload']); +-- +ok +== diff --git a/parser/testdata/corpus/sql/index/art/constraints/test_art_tx_upserts_local.test b/parser/testdata/corpus/sql/index/art/constraints/test_art_tx_upserts_local.test new file mode 100644 index 0000000..f5ace72 --- /dev/null +++ b/parser/testdata/corpus/sql/index/art/constraints/test_art_tx_upserts_local.test @@ -0,0 +1,29 @@ +# source: test/sql/index/art/constraints/test_art_tx_upserts_local.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +CREATE TABLE tbl_local (id INT PRIMARY KEY, payload VARCHAR[]); +-- +ok +== +INSERT INTO tbl_local VALUES (1, ['first payload']); +-- +ok +== +INSERT OR REPLACE INTO tbl_local VALUES (1, ['con1 payload']); +-- +ok +== +INSERT OR REPLACE INTO tbl_local VALUES (1, ['local payload']); +-- +ok +== +SELECT id, payload, rowid FROM tbl_local WHERE id = 1; +-- +ok +== +INSERT OR REPLACE INTO tbl_local VALUES (1, ['val2 payload']), (1, ['val2 payload']); +-- +ok +== diff --git a/parser/testdata/corpus/sql/index/art/constraints/test_art_tx_upserts_rollback.test b/parser/testdata/corpus/sql/index/art/constraints/test_art_tx_upserts_rollback.test new file mode 100644 index 0000000..9ce6189 --- /dev/null +++ b/parser/testdata/corpus/sql/index/art/constraints/test_art_tx_upserts_rollback.test @@ -0,0 +1,13 @@ +# source: test/sql/index/art/constraints/test_art_tx_upserts_rollback.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +INSERT OR REPLACE INTO tbl_rollback VALUES (1, ['con1 payload']); +-- +ok +== +INSERT INTO tbl_rollback VALUES (2, ['second payload']); +-- +ok +== diff --git a/parser/testdata/corpus/sql/index/art/constraints/test_art_upsert_duplicate.test b/parser/testdata/corpus/sql/index/art/constraints/test_art_upsert_duplicate.test new file mode 100644 index 0000000..e363870 --- /dev/null +++ b/parser/testdata/corpus/sql/index/art/constraints/test_art_upsert_duplicate.test @@ -0,0 +1,30 @@ +# source: test/sql/index/art/constraints/test_art_upsert_duplicate.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +CREATE TABLE hero ( + name VARCHAR NOT NULL, + secret_name VARCHAR NOT NULL, + age INTEGER, + PRIMARY KEY (name)); +-- +ok +== +CREATE INDEX ix_hero_age ON hero (age); +-- +ok +== +INSERT INTO hero (name, secret_name, age) +VALUES + ('Captain North America', 'Esteban Rogelios', 93), + ('Rusty-Man', 'Tommy Sharp', 48), + ('Tarantula', 'Natalia Roman-on', 32), + ('Spider-Boy', 'Pedro Parqueador', 17), + ('Captain North America', 'Esteban Rogelios', 93) +ON CONFLICT (name) DO UPDATE +SET secret_name = EXCLUDED.secret_name, + age = EXCLUDED.age; +-- +ok +== diff --git a/parser/testdata/corpus/sql/index/art/constraints/test_art_upsert_other_index.test b/parser/testdata/corpus/sql/index/art/constraints/test_art_upsert_other_index.test new file mode 100644 index 0000000..5feb300 --- /dev/null +++ b/parser/testdata/corpus/sql/index/art/constraints/test_art_upsert_other_index.test @@ -0,0 +1,37 @@ +# source: test/sql/index/art/constraints/test_art_upsert_other_index.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +CREATE TABLE kvp ( + "key" VARCHAR PRIMARY KEY, + "value" VARCHAR, + expiration BIGINT, + "cache" BOOLEAN); +-- +ok +== +CREATE INDEX kve_idx ON kvp (expiration); +-- +ok +== +INSERT OR REPLACE INTO kvp VALUES ('/key', 'value', 0, false); +-- +ok +== +SELECT key, value, expiration, cache FROM kvp; +-- +ok +== +INSERT OR REPLACE INTO kvp VALUES ('/key', 'value', 10000000, false); +-- +ok +== +INSERT INTO kvp VALUES ('/key', 'value', 20000000, false) +ON CONFLICT DO UPDATE SET + value = excluded.value, + expiration = excluded.expiration, + cache = excluded.cache; +-- +ok +== diff --git a/parser/testdata/corpus/sql/index/art/create_drop/test_art_big_compound_key.test b/parser/testdata/corpus/sql/index/art/create_drop/test_art_big_compound_key.test new file mode 100644 index 0000000..68bd7f8 --- /dev/null +++ b/parser/testdata/corpus/sql/index/art/create_drop/test_art_big_compound_key.test @@ -0,0 +1,19 @@ +# source: test/sql/index/art/create_drop/test_art_big_compound_key.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +CREATE TABLE v0 (v2 VARCHAR, v1 INT); +-- +ok +== +INSERT INTO v0 (v2 ,v1 ) VALUES ('358677 4 2 1', 7), ('a%', 1); +-- +ok +== +CREATE UNIQUE INDEX v3 ON v0 + (v1, v1, v1, v1, v1, v2, v1, v2, v1, v2, v2, v1, v2, v2, + v2, v2, v2, v2, v1, v1, v2, v2, v1, v1, v2, v1); +-- +ok +== diff --git a/parser/testdata/corpus/sql/index/art/create_drop/test_art_create_if_exists.test b/parser/testdata/corpus/sql/index/art/create_drop/test_art_create_if_exists.test new file mode 100644 index 0000000..466bd84 --- /dev/null +++ b/parser/testdata/corpus/sql/index/art/create_drop/test_art_create_if_exists.test @@ -0,0 +1,29 @@ +# source: test/sql/index/art/create_drop/test_art_create_if_exists.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +PRAGMA immediate_transaction_mode = True; +-- +ok +== +CREATE TABLE tbl AS SELECT range AS i FROM range(100); +-- +ok +== +CREATE INDEX IF NOT EXISTS my_idx ON tbl(i); +-- +ok +== +SELECT COUNT(*) FROM duckdb_indexes; +-- +ok +== +DROP INDEX my_idx; +-- +ok +== +CREATE INDEX my_idx ON tbl(i); +-- +ok +== diff --git a/parser/testdata/corpus/sql/index/art/create_drop/test_art_create_index_delete.test b/parser/testdata/corpus/sql/index/art/create_drop/test_art_create_index_delete.test new file mode 100644 index 0000000..bdf9b4f --- /dev/null +++ b/parser/testdata/corpus/sql/index/art/create_drop/test_art_create_index_delete.test @@ -0,0 +1,25 @@ +# source: test/sql/index/art/create_drop/test_art_create_index_delete.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +INSERT INTO integers SELECT * FROM range(10) +-- +ok +== +DELETE FROM integers WHERE i=2 OR i=7 +-- +ok +== +SELECT * FROM integers WHERE i=1; +-- +ok +== +SELECT * FROM integers WHERE i=2; +-- +ok +== +CREATE INDEX i_index ON integers(i) +-- +ok +== diff --git a/parser/testdata/corpus/sql/index/art/create_drop/test_art_create_index_duplicate_deletes.test b/parser/testdata/corpus/sql/index/art/create_drop/test_art_create_index_duplicate_deletes.test new file mode 100644 index 0000000..1f6e4a6 --- /dev/null +++ b/parser/testdata/corpus/sql/index/art/create_drop/test_art_create_index_duplicate_deletes.test @@ -0,0 +1,9 @@ +# source: test/sql/index/art/create_drop/test_art_create_index_duplicate_deletes.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +DELETE FROM integers +-- +ok +== diff --git a/parser/testdata/corpus/sql/index/art/create_drop/test_art_create_many_duplicates.test b/parser/testdata/corpus/sql/index/art/create_drop/test_art_create_many_duplicates.test new file mode 100644 index 0000000..fdc0eeb --- /dev/null +++ b/parser/testdata/corpus/sql/index/art/create_drop/test_art_create_many_duplicates.test @@ -0,0 +1,41 @@ +# source: test/sql/index/art/create_drop/test_art_create_many_duplicates.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +INSERT INTO integers SELECT * FROM repeat(1, 1500) t1(i) +-- +ok +== +INSERT INTO integers SELECT * FROM repeat(2, 1500) t1(i) +-- +ok +== +INSERT INTO integers SELECT * FROM repeat(3, 1500) t1(i) +-- +ok +== +INSERT INTO integers SELECT * FROM repeat(4, 1500) t1(i) +-- +ok +== +SELECT count(i) FROM integers WHERE i > 1 AND i < 3 +-- +ok +== +SELECT count(i) FROM integers WHERE i >= 1 AND i < 3 +-- +ok +== +SELECT count(i) FROM integers WHERE i > 1 +-- +ok +== +SELECT count(i) FROM integers WHERE i < 4 +-- +ok +== +SELECT count(i) FROM integers WHERE i < 5 +-- +ok +== diff --git a/parser/testdata/corpus/sql/index/art/create_drop/test_art_create_many_duplicates_deletes.test b/parser/testdata/corpus/sql/index/art/create_drop/test_art_create_many_duplicates_deletes.test new file mode 100644 index 0000000..39308ed --- /dev/null +++ b/parser/testdata/corpus/sql/index/art/create_drop/test_art_create_many_duplicates_deletes.test @@ -0,0 +1,13 @@ +# source: test/sql/index/art/create_drop/test_art_create_many_duplicates_deletes.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +INSERT INTO integers SELECT * FROM repeat(5, 1500) t1(i) +-- +ok +== +DELETE FROM integers WHERE i = 5 +-- +ok +== diff --git a/parser/testdata/corpus/sql/index/art/create_drop/test_art_create_unique.test b/parser/testdata/corpus/sql/index/art/create_drop/test_art_create_unique.test new file mode 100644 index 0000000..a3c8635 --- /dev/null +++ b/parser/testdata/corpus/sql/index/art/create_drop/test_art_create_unique.test @@ -0,0 +1,33 @@ +# source: test/sql/index/art/create_drop/test_art_create_unique.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +CREATE UNIQUE INDEX i0 ON t0(c0); +-- +ok +== +SELECT * FROM t0 WHERE t0.c0 = 1; +-- +ok +== +CREATE TABLE merge_violation (id INT); +-- +ok +== +INSERT INTO merge_violation SELECT range FROM range(2048); +-- +ok +== +INSERT INTO merge_violation SELECT range + 10000 FROM range(2048); +-- +ok +== +INSERT INTO merge_violation VALUES (2047); +-- +ok +== +CREATE UNIQUE INDEX idx ON merge_violation(id); +-- +ok +== diff --git a/parser/testdata/corpus/sql/index/art/create_drop/test_art_drop_index.test b/parser/testdata/corpus/sql/index/art/create_drop/test_art_drop_index.test new file mode 100644 index 0000000..a0403e8 --- /dev/null +++ b/parser/testdata/corpus/sql/index/art/create_drop/test_art_drop_index.test @@ -0,0 +1,61 @@ +# source: test/sql/index/art/create_drop/test_art_drop_index.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +CREATE TABLE A (A1 INTEGER,A2 VARCHAR, A3 INTEGER) +-- +ok +== +INSERT INTO A VALUES (1, 1, 1) +-- +ok +== +INSERT INTO A VALUES (2, 2, 2) +-- +ok +== +CREATE TABLE B (B1 INTEGER,B2 INTEGER, B3 INTEGER) +-- +ok +== +INSERT INTO B VALUES (1, 1, 1) +-- +ok +== +INSERT INTO B VALUES (2, 2, 2) +-- +ok +== +CREATE TABLE C (C1 VARCHAR, C2 INTEGER, C3 INTEGER) +-- +ok +== +INSERT INTO C VALUES ('t1', 1, 1) +-- +ok +== +INSERT INTO C VALUES ('t2', 2, 2) +-- +ok +== +SELECT A2 FROM A WHERE A1=1 +-- +ok +== +CREATE INDEX A_index ON A (A1) +-- +ok +== +CREATE INDEX B_index ON B (B1) +-- +ok +== +CREATE INDEX C_index ON C (C2) +-- +ok +== +DROP INDEX IF EXISTS A_index +-- +ok +== diff --git a/parser/testdata/corpus/sql/index/art/create_drop/test_art_invalid_create_index.test b/parser/testdata/corpus/sql/index/art/create_drop/test_art_invalid_create_index.test new file mode 100644 index 0000000..bbf5225 --- /dev/null +++ b/parser/testdata/corpus/sql/index/art/create_drop/test_art_invalid_create_index.test @@ -0,0 +1,45 @@ +# source: test/sql/index/art/create_drop/test_art_invalid_create_index.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +CREATE TABLE integers(i integer, j integer, k BOOLEAN) +-- +ok +== +CREATE INDEX ON integers(i) +-- +ok +== +CREATE INDEX i_index ON integers(i COLLATE "NOCASE") +-- +ok +== +CREATE INDEX i_index ON integers(i COLLATE "de_DE") +-- +ok +== +CREATE INDEX i_index ON integers using blabla(i) +-- +ok +== +CREATE INDEX i_index ON integers(f) +-- +ok +== +create table lists(id int, l int[]); +-- +ok +== +create index i_index on lists(l); +-- +ok +== +create index i_index on lists(id, l); +-- +ok +== +create index i_index on integers(('hello')); +-- +ok +== diff --git a/parser/testdata/corpus/sql/index/art/create_drop/test_art_many_versions.test b/parser/testdata/corpus/sql/index/art/create_drop/test_art_many_versions.test new file mode 100644 index 0000000..b2ba1c3 --- /dev/null +++ b/parser/testdata/corpus/sql/index/art/create_drop/test_art_many_versions.test @@ -0,0 +1,21 @@ +# source: test/sql/index/art/create_drop/test_art_many_versions.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +INSERT INTO integers SELECT * FROM range(1, 20001, 1) +-- +ok +== +UPDATE integers SET i=i+1 +-- +ok +== +CREATE INDEX i_index ON integers using art(i) +-- +ok +== +SELECT SUM(i) FROM integers WHERE i > 0 +-- +ok +== diff --git a/parser/testdata/corpus/sql/index/art/create_drop/test_art_single_value.test b/parser/testdata/corpus/sql/index/art/create_drop/test_art_single_value.test new file mode 100644 index 0000000..4989c87 --- /dev/null +++ b/parser/testdata/corpus/sql/index/art/create_drop/test_art_single_value.test @@ -0,0 +1,45 @@ +# source: test/sql/index/art/create_drop/test_art_single_value.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +SELECT * FROM integers WHERE i < 3 +-- +ok +== +SELECT * FROM integers WHERE i <= 1 +-- +ok +== +SELECT * FROM integers WHERE i > 0 +-- +ok +== +SELECT * FROM integers WHERE i >= 1 +-- +ok +== +SELECT * FROM integers WHERE i = 1 +-- +ok +== +SELECT * FROM integers WHERE i < 1 +-- +ok +== +SELECT * FROM integers WHERE i <= 0 +-- +ok +== +SELECT * FROM integers WHERE i > 1 +-- +ok +== +SELECT * FROM integers WHERE i >= 2 +-- +ok +== +SELECT * FROM integers WHERE i = 2 +-- +ok +== diff --git a/parser/testdata/corpus/sql/index/art/insert_update_delete/test_art_sel_vector.test b/parser/testdata/corpus/sql/index/art/insert_update_delete/test_art_sel_vector.test new file mode 100644 index 0000000..c0c2447 --- /dev/null +++ b/parser/testdata/corpus/sql/index/art/insert_update_delete/test_art_sel_vector.test @@ -0,0 +1,45 @@ +# source: test/sql/index/art/insert_update_delete/test_art_sel_vector.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +CREATE TABLE source(i INTEGER) +-- +ok +== +INSERT INTO source VALUES (1), (2), (3), (4), (5), (6) +-- +ok +== +INSERT INTO integers SELECT * FROM source WHERE i % 2 = 0 +-- +ok +== +SELECT * FROM integers WHERE i<3 ORDER BY 1 +-- +ok +== +SELECT * FROM integers WHERE i>3 ORDER BY 1 +-- +ok +== +SELECT * FROM integers WHERE i<=3 ORDER BY 1 +-- +ok +== +SELECT * FROM integers WHERE i>=3 ORDER BY 1 +-- +ok +== +UPDATE integers SET i=3 WHERE i=4 +-- +ok +== +DELETE FROM integers WHERE i>3 +-- +ok +== +SELECT * FROM integers WHERE i < 3 ORDER BY 1 +-- +ok +== diff --git a/parser/testdata/corpus/sql/index/art/insert_update_delete/test_art_simple_update.test b/parser/testdata/corpus/sql/index/art/insert_update_delete/test_art_simple_update.test new file mode 100644 index 0000000..d1f1293 --- /dev/null +++ b/parser/testdata/corpus/sql/index/art/insert_update_delete/test_art_simple_update.test @@ -0,0 +1,13 @@ +# source: test/sql/index/art/insert_update_delete/test_art_simple_update.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +UPDATE integers SET i=10 WHERE i=1 +-- +ok +== +SELECT * FROM integers WHERE i < 5 +-- +ok +== diff --git a/parser/testdata/corpus/sql/index/art/insert_update_delete/test_art_update.test b/parser/testdata/corpus/sql/index/art/insert_update_delete/test_art_update.test new file mode 100644 index 0000000..ef9a003 --- /dev/null +++ b/parser/testdata/corpus/sql/index/art/insert_update_delete/test_art_update.test @@ -0,0 +1,29 @@ +# source: test/sql/index/art/insert_update_delete/test_art_update.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +CREATE INDEX i_index ON integers using art(j) +-- +ok +== +INSERT INTO integers VALUES (1, 2), (2, 2) +-- +ok +== +UPDATE integers SET j=10 WHERE i=1 +-- +ok +== +UPDATE integers SET j=10 WHERE rowid=0 +-- +ok +== +DELETE FROM integers WHERE rowid=1 +-- +ok +== +SELECT * FROM integers WHERE j>5 +-- +ok +== diff --git a/parser/testdata/corpus/sql/index/art/insert_update_delete/test_art_update_other_column.test b/parser/testdata/corpus/sql/index/art/insert_update_delete/test_art_update_other_column.test new file mode 100644 index 0000000..086f316 --- /dev/null +++ b/parser/testdata/corpus/sql/index/art/insert_update_delete/test_art_update_other_column.test @@ -0,0 +1,37 @@ +# source: test/sql/index/art/insert_update_delete/test_art_update_other_column.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +CREATE TABLE integers(i BIGINT, j INTEGER, k VARCHAR) +-- +ok +== +INSERT INTO integers VALUES (10, 1, 'hello'), (11, 2, 'world') +-- +ok +== +SELECT * FROM integers WHERE j=1 +-- +ok +== +UPDATE integers SET i=100, k='update' WHERE j=1 +-- +ok +== +UPDATE integers SET i=20, k='t1' WHERE j=1 +-- +ok +== +UPDATE integers SET i=21, k='t2' WHERE j=2 +-- +ok +== +SELECT * FROM integers WHERE j=2 +-- +ok +== +SELECT * FROM integers ORDER BY j +-- +ok +== diff --git a/parser/testdata/corpus/sql/index/art/insert_update_delete/test_art_update_same_value.test b/parser/testdata/corpus/sql/index/art/insert_update_delete/test_art_update_same_value.test new file mode 100644 index 0000000..ef4614f --- /dev/null +++ b/parser/testdata/corpus/sql/index/art/insert_update_delete/test_art_update_same_value.test @@ -0,0 +1,13 @@ +# source: test/sql/index/art/insert_update_delete/test_art_update_same_value.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +UPDATE integers SET i={i}+1 WHERE i={i}; +-- +error: Parser Error: syntax error at or near "}" +== +SELECT COUNT(*) FROM (SELECT * FROM integers WHERE i > 0 EXCEPT SELECT {i} + 1) t1; +-- +error: Parser Error: syntax error at or near "}" +== diff --git a/parser/testdata/corpus/sql/index/art/insert_update_delete/test_art_update_with_dict_fsst.test b/parser/testdata/corpus/sql/index/art/insert_update_delete/test_art_update_with_dict_fsst.test new file mode 100644 index 0000000..ea8025f --- /dev/null +++ b/parser/testdata/corpus/sql/index/art/insert_update_delete/test_art_update_with_dict_fsst.test @@ -0,0 +1,25 @@ +# source: test/sql/index/art/insert_update_delete/test_art_update_with_dict_fsst.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +CREATE OR REPLACE TABLE bar (col1 VARCHAR, col2 VARCHAR UNIQUE) +-- +ok +== +INSERT INTO bar (col1, col2) VALUES (NULL, 'one'); +-- +ok +== +SET wal_autocheckpoint='1TB' +-- +ok +== +UPDATE bar AS original SET col1 = 'a' +-- +ok +== +SELECT col1 FROM bar WHERE col2 = 'one' +-- +ok +== diff --git a/parser/testdata/corpus/sql/index/art/issues/test_art_fuzzer.test b/parser/testdata/corpus/sql/index/art/issues/test_art_fuzzer.test new file mode 100644 index 0000000..d63a662 --- /dev/null +++ b/parser/testdata/corpus/sql/index/art/issues/test_art_fuzzer.test @@ -0,0 +1,93 @@ +# source: test/sql/index/art/issues/test_art_fuzzer.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +CREATE TABLE t1 (c1 DECIMAL(4, 3)); +-- +ok +== +INSERT INTO t1(c1) VALUES (1), (-0.505); +-- +ok +== +CREATE INDEX i1 ON t1 (TRY_CAST(c1 AS USMALLINT)); +-- +ok +== +INSERT INTO t1(c1) VALUES (2), (3); +-- +ok +== +CREATE TABLE t2 (c1 VARCHAR); +-- +ok +== +CREATE INDEX i2 ON t2 (c1); +-- +ok +== +INSERT INTO t2 VALUES (decode('g\x00'::BLOB)::VARCHAR),('g'); +-- +ok +== +INSERT INTO t2 VALUES ('\0'); +-- +ok +== +CREATE INDEX i22 ON t2 (c1); +-- +ok +== +CREATE TABLE t3(c1 INT); +-- +ok +== +INSERT INTO t3 VALUES (0), (85491); +-- +ok +== +CREATE INDEX i3 ON t3 (c1, (TRY_CAST(c1 AS USMALLINT))); +-- +ok +== +CREATE TABLE t4 (c1 BOOLEAN); +-- +ok +== +CREATE INDEX i4 ON t4 (c1); +-- +ok +== +INSERT INTO t4 VALUES (1), (0), (1), (1); +-- +ok +== +UPDATE t4 SET c1 = NULL; +-- +ok +== +CREATE TABLE t_leak (c1 INT); +-- +ok +== +INSERT INTO t_leak VALUES (2), (1), (1), (540000); +-- +ok +== +CREATE UNIQUE INDEX i_leak ON t_leak (c1); +-- +ok +== +CREATE TABLE t21 (c1 INT); +-- +ok +== +CREATE INDEX i21 ON t21 (c1, "decode"('\x00'::BLOB)); +-- +ok +== +INSERT INTO t21 VALUES (1); +-- +ok +== diff --git a/parser/testdata/corpus/sql/index/art/issues/test_art_fuzzer_persisted.test b/parser/testdata/corpus/sql/index/art/issues/test_art_fuzzer_persisted.test new file mode 100644 index 0000000..8c46de7 --- /dev/null +++ b/parser/testdata/corpus/sql/index/art/issues/test_art_fuzzer_persisted.test @@ -0,0 +1,17 @@ +# source: test/sql/index/art/issues/test_art_fuzzer_persisted.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +CREATE TABLE t1 AS (SELECT 1 c1, 'a' c2); +-- +ok +== +PRAGMA MEMORY_LIMIT='4MB'; +-- +ok +== +INSERT INTO t1(c2) (SELECT DISTINCT 'b'); +-- +ok +== diff --git a/parser/testdata/corpus/sql/index/art/issues/test_art_internal_issue_4742.test b/parser/testdata/corpus/sql/index/art/issues/test_art_internal_issue_4742.test new file mode 100644 index 0000000..85fca85 --- /dev/null +++ b/parser/testdata/corpus/sql/index/art/issues/test_art_internal_issue_4742.test @@ -0,0 +1,41 @@ +# source: test/sql/index/art/issues/test_art_internal_issue_4742.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +create or replace table test as select 9223372036854776 + range * 9223372036854776 i from range(100); +-- +ok +== +create index my_index on test(i); +-- +ok +== +explain analyze select i from test SEMI JOIN (select i from test using sample reservoir(10) repeatable (42)) USING (i); +-- +ok +== +select count(*) from test SEMI JOIN (select i from test using sample reservoir(10) repeatable (42)) USING (i); +-- +ok +== +select i from test SEMI JOIN (select i from test using sample reservoir(10) repeatable (42)) USING (i) order by all; +-- +ok +== +create or replace table sample as select i from test using sample reservoir(10) repeatable (42); +-- +ok +== +explain analyze select i from test SEMI JOIN sample USING (i); +-- +ok +== +select count(*) from test SEMI JOIN sample USING (i); +-- +ok +== +select i from test SEMI JOIN sample USING (i) order by all; +-- +ok +== diff --git a/parser/testdata/corpus/sql/index/art/issues/test_art_issue_21394.test b/parser/testdata/corpus/sql/index/art/issues/test_art_issue_21394.test new file mode 100644 index 0000000..78016b5 --- /dev/null +++ b/parser/testdata/corpus/sql/index/art/issues/test_art_issue_21394.test @@ -0,0 +1,13 @@ +# source: test/sql/index/art/issues/test_art_issue_21394.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +INSERT INTO t0(c0) VALUES (2); +-- +ok +== +UPDATE t0 SET c0=0; +-- +ok +== diff --git a/parser/testdata/corpus/sql/index/art/issues/test_art_issue_4976.test b/parser/testdata/corpus/sql/index/art/issues/test_art_issue_4976.test new file mode 100644 index 0000000..570be2c --- /dev/null +++ b/parser/testdata/corpus/sql/index/art/issues/test_art_issue_4976.test @@ -0,0 +1,21 @@ +# source: test/sql/index/art/issues/test_art_issue_4976.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +CREATE TABLE t0(c0 DOUBLE, c1 TIMESTAMP DEFAULT(TIMESTAMP '1970-01-04 12:58:32')); +-- +ok +== +INSERT INTO t0(c1, c0) VALUES (TIMESTAMP '1969-12-28 23:02:08', 1); +-- +ok +== +INSERT INTO t0(c0) VALUES (DEFAULT); +-- +ok +== +CREATE INDEX i2 ON t0(c1, c0); +-- +ok +== diff --git a/parser/testdata/corpus/sql/index/art/issues/test_art_issue_6603.test b/parser/testdata/corpus/sql/index/art/issues/test_art_issue_6603.test new file mode 100644 index 0000000..639d283 --- /dev/null +++ b/parser/testdata/corpus/sql/index/art/issues/test_art_issue_6603.test @@ -0,0 +1,38 @@ +# source: test/sql/index/art/issues/test_art_issue_6603.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +CREATE TABLE path ( + it INTEGER, + x0 TEXT NOT NULL, + x1 TEXT NOT NULL +); +-- +ok +== +CREATE TABLE edge ( + id INTEGER DEFAULT nextval('seq'), + it INTEGER DEFAULT 0, + x0 TEXT, + x1 TEXT +); +-- +ok +== +CREATE INDEX edge1_idx ON edge (x1); +-- +ok +== +INSERT INTO edge (x0, x1) VALUES ('n2880','n3966'); +-- +ok +== +INSERT INTO path SELECT 1, y0, y1 FROM (SELECT DISTINCT edge0.x0 AS y0, edge0.x1 AS y1 FROM edge AS edge0 WHERE edge0.it = 0 AND true AND NOT EXISTS (SELECT * from path AS pre WHERE pre.x0 = edge0.x0 AND pre.x1 = edge0.x1)); +-- +ok +== +SELECT 1, y0, y1 FROM (SELECT DISTINCT edge0.x0 AS y0, path1.x1 AS y1 FROM edge AS edge0,path AS path1 WHERE edge0.it = 0 AND edge0.x1 = path1.x0 AND NOT EXISTS (SELECT * from path AS pre WHERE pre.x0 = edge0.x0 AND pre.x1 = path1.x1)); +-- +ok +== diff --git a/parser/testdata/corpus/sql/index/art/issues/test_art_issue_6799.test b/parser/testdata/corpus/sql/index/art/issues/test_art_issue_6799.test new file mode 100644 index 0000000..f96aaea --- /dev/null +++ b/parser/testdata/corpus/sql/index/art/issues/test_art_issue_6799.test @@ -0,0 +1,36 @@ +# source: test/sql/index/art/issues/test_art_issue_6799.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +CREATE TABLE key_value_pairs (key VARCHAR PRIMARY KEY, value VARCHAR) +-- +ok +== +INSERT INTO key_value_pairs + SELECT concat('key_', i::VARCHAR), concat('value_', i::VARCHAR) + FROM range(10000) t(i) + WHERE random() < 0.5 +-- +ok +== +CREATE TABLE keys_to_lookup (key VARCHAR PRIMARY KEY) +-- +ok +== +INSERT INTO keys_to_lookup + SELECT concat('key_', i::VARCHAR) + FROM range(100) t(i) +-- +ok +== +SELECT COUNT(*) FROM +( + SELECT key, value + FROM + keys_to_lookup + JOIN key_value_pairs USING(key) +) +-- +ok +== diff --git a/parser/testdata/corpus/sql/index/art/issues/test_art_issue_7349.test b/parser/testdata/corpus/sql/index/art/issues/test_art_issue_7349.test new file mode 100644 index 0000000..3610789 --- /dev/null +++ b/parser/testdata/corpus/sql/index/art/issues/test_art_issue_7349.test @@ -0,0 +1,45 @@ +# source: test/sql/index/art/issues/test_art_issue_7349.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +CREATE TABLE td(tz VARCHAR(30) NOT NULL); +-- +ok +== +CREATE UNIQUE INDEX sqlsim0 ON td(tz); +-- +ok +== +CREATE TABLE tab0(c2 DATE NOT NULL); +-- +ok +== +CREATE TABLE tab1(c2 DATE NOT NULL); +-- +ok +== +INSERT INTO td VALUES (date '2008-02-29'); +-- +ok +== +INSERT INTO td VALUES('2006-12-25'); +-- +ok +== +INSERT INTO tab0 VALUES('2006-12-25'); +-- +ok +== +COMMIT TRANSACTION; +-- +ok +== +INSERT INTO tab1 VALUES('2006-12-25'); +-- +ok +== +SELECT tz FROM td ORDER BY tz; +-- +ok +== diff --git a/parser/testdata/corpus/sql/index/art/issues/test_art_issue_7530.test b/parser/testdata/corpus/sql/index/art/issues/test_art_issue_7530.test new file mode 100644 index 0000000..51f6d7e --- /dev/null +++ b/parser/testdata/corpus/sql/index/art/issues/test_art_issue_7530.test @@ -0,0 +1,21 @@ +# source: test/sql/index/art/issues/test_art_issue_7530.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +CREATE TABLE t14(c0 BIGINT); +-- +ok +== +INSERT INTO t14(c0) VALUES ((1)), ((1)), ((1)); +-- +ok +== +CREATE INDEX i1 ON t14(c0 ); +-- +ok +== +DELETE FROM t14 WHERE t14.rowid; +-- +ok +== diff --git a/parser/testdata/corpus/sql/index/art/issues/test_art_view_col_binding.test b/parser/testdata/corpus/sql/index/art/issues/test_art_view_col_binding.test new file mode 100644 index 0000000..1999a4b --- /dev/null +++ b/parser/testdata/corpus/sql/index/art/issues/test_art_view_col_binding.test @@ -0,0 +1,50 @@ +# source: test/sql/index/art/issues/test_art_view_col_binding.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +create or replace table test as ( + select + cast(unnest(range(1000)) as varchar) as x, + cast(unnest(range(2000,3000)) as varchar) as y, + cast(unnest(range(3000,4000)) as varchar) as z +); +-- +ok +== +create index test_x on test(x); +-- +ok +== +create view test_view as (select z, y, x from test); +-- +ok +== +explain analyze select * from test_view where x = '525'; +-- +ok +== +select z, y, x from test_view where x = '525'; +-- +ok +== +drop index test_x; +-- +ok +== +create index test_upper_x on test(upper(x)); +-- +ok +== +explain analyze select * from test_view where upper(x) = '526'; +-- +ok +== +select z, y, x from test_view where upper(x) = '526'; +-- +ok +== +drop index test_upper_x; +-- +ok +== diff --git a/parser/testdata/corpus/sql/index/art/multi_column/test_art_multi_column.test b/parser/testdata/corpus/sql/index/art/multi_column/test_art_multi_column.test new file mode 100644 index 0000000..8e06043 --- /dev/null +++ b/parser/testdata/corpus/sql/index/art/multi_column/test_art_multi_column.test @@ -0,0 +1,29 @@ +# source: test/sql/index/art/multi_column/test_art_multi_column.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +SELECT i FROM integers WHERE i=10 +-- +ok +== +SELECT * FROM integers WHERE i=10 +-- +ok +== +SELECT j FROM integers WHERE j=1 +-- +ok +== +SELECT k FROM integers WHERE k='hello' +-- +ok +== +SELECT i, k FROM integers WHERE k='hello' +-- +ok +== +SELECT * FROM integers WHERE k='hello' +-- +ok +== diff --git a/parser/testdata/corpus/sql/index/art/multi_column/test_art_multi_predicate.test b/parser/testdata/corpus/sql/index/art/multi_column/test_art_multi_predicate.test new file mode 100644 index 0000000..f26b2c5 --- /dev/null +++ b/parser/testdata/corpus/sql/index/art/multi_column/test_art_multi_predicate.test @@ -0,0 +1,13 @@ +# source: test/sql/index/art/multi_column/test_art_multi_predicate.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +INSERT INTO integers VALUES (1, 2), (1, 3) +-- +ok +== +SELECT * FROM integers WHERE i = 1 AND j = 2 +-- +ok +== diff --git a/parser/testdata/corpus/sql/index/art/nodes/test_art_leaf_coverage.test b/parser/testdata/corpus/sql/index/art/nodes/test_art_leaf_coverage.test new file mode 100644 index 0000000..a21d9c8 --- /dev/null +++ b/parser/testdata/corpus/sql/index/art/nodes/test_art_leaf_coverage.test @@ -0,0 +1,77 @@ +# source: test/sql/index/art/nodes/test_art_leaf_coverage.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +CREATE TABLE duplicates (id UBIGINT); +-- +ok +== +INSERT INTO duplicates SELECT range + 500 FROM range(500); +-- +ok +== +INSERT INTO duplicates SELECT range FROM range(500); +-- +ok +== +INSERT INTO duplicates SELECT range + 1000 FROM range(500); +-- +ok +== +CREATE INDEX idx_duplicates ON duplicates(id); +-- +ok +== +SELECT id FROM duplicates WHERE id = 255; +-- +ok +== +CREATE TABLE leaf_merge_1 (id UINT32, id2 INT64); +-- +ok +== +INSERT INTO leaf_merge_1 SELECT range, range FROM range (0, 2048, 1); +-- +ok +== +INSERT INTO leaf_merge_1 SELECT 2047, 2047 FROM range (10); +-- +ok +== +CREATE INDEX idx_merge_1 ON leaf_merge_1(id, id2); +-- +ok +== +CREATE TABLE leaf_merge_2 (id UINT32, id2 INT64); +-- +ok +== +INSERT INTO leaf_merge_2 SELECT range, range FROM range (0, 2048, 1); +-- +ok +== +INSERT INTO leaf_merge_2 VALUES (2047, 2047) +-- +ok +== +CREATE INDEX idx_merge_2 ON leaf_merge_2(id, id2); +-- +ok +== +CREATE TABLE tbl_dup_ser (id INTEGER); +-- +ok +== +INSERT INTO tbl_dup_ser SELECT range FROM range(2043); +-- +ok +== +INSERT INTO tbl_dup_ser SELECT 12345 FROM range(11); +-- +ok +== +CREATE INDEX idx_dup_ser ON tbl_dup_ser(id); +-- +ok +== diff --git a/parser/testdata/corpus/sql/index/art/nodes/test_art_nested_leaf_coverage.test b/parser/testdata/corpus/sql/index/art/nodes/test_art_nested_leaf_coverage.test new file mode 100644 index 0000000..13e80be --- /dev/null +++ b/parser/testdata/corpus/sql/index/art/nodes/test_art_nested_leaf_coverage.test @@ -0,0 +1,33 @@ +# source: test/sql/index/art/nodes/test_art_nested_leaf_coverage.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +CREATE TABLE integers(i integer); +-- +ok +== +INSERT INTO integers VALUES (2); +-- +ok +== +DELETE FROM integers where rowid = 1; +-- +ok +== +SELECT COUNT(*) FROM integers; +-- +ok +== +INSERT INTO integers VALUES (2) +-- +ok +== +DELETE FROM integers where rowid = 2 +-- +ok +== +DELETE FROM integers where rowid = 3 +-- +ok +== diff --git a/parser/testdata/corpus/sql/index/art/nodes/test_art_node_16.test b/parser/testdata/corpus/sql/index/art/nodes/test_art_node_16.test new file mode 100644 index 0000000..d526bba --- /dev/null +++ b/parser/testdata/corpus/sql/index/art/nodes/test_art_node_16.test @@ -0,0 +1,29 @@ +# source: test/sql/index/art/nodes/test_art_node_16.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +INSERT INTO integers VALUES ({i} + 1); +-- +error: Parser Error: syntax error at or near "}" +== +SELECT COUNT(*) FROM integers WHERE i = {i} + 1 +-- +error: Parser Error: syntax error at or near "}" +== +SELECT sum(i) FROM integers WHERE i <= 2 +-- +ok +== +SELECT sum(i) FROM integers WHERE i > 4 +-- +ok +== +DELETE FROM integers WHERE i = {i} + 1 +-- +error: Parser Error: syntax error at or near "}" +== +DELETE FROM integers WHERE i = 0 +-- +ok +== diff --git a/parser/testdata/corpus/sql/index/art/nodes/test_art_node_256.test b/parser/testdata/corpus/sql/index/art/nodes/test_art_node_256.test new file mode 100644 index 0000000..4932d60 --- /dev/null +++ b/parser/testdata/corpus/sql/index/art/nodes/test_art_node_256.test @@ -0,0 +1,17 @@ +# source: test/sql/index/art/nodes/test_art_node_256.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +SELECT sum(i) FROM integers WHERE i > 15 +-- +ok +== +DELETE FROM integers WHERE i=16; +-- +ok +== +INSERT INTO integers VALUES (16); +-- +ok +== diff --git a/parser/testdata/corpus/sql/index/art/nodes/test_art_node_4.test b/parser/testdata/corpus/sql/index/art/nodes/test_art_node_4.test new file mode 100644 index 0000000..7300031 --- /dev/null +++ b/parser/testdata/corpus/sql/index/art/nodes/test_art_node_4.test @@ -0,0 +1,9 @@ +# source: test/sql/index/art/nodes/test_art_node_4.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +SELECT sum(i) FROM integers WHERE i > 1 +-- +ok +== diff --git a/parser/testdata/corpus/sql/index/art/nodes/test_art_node_48.test b/parser/testdata/corpus/sql/index/art/nodes/test_art_node_48.test new file mode 100644 index 0000000..8165064 --- /dev/null +++ b/parser/testdata/corpus/sql/index/art/nodes/test_art_node_48.test @@ -0,0 +1,41 @@ +# source: test/sql/index/art/nodes/test_art_node_48.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +CREATE TABLE n48_tbl(i varchar, k integer) +-- +ok +== +INSERT INTO n48_tbl SELECT 'a', range FROM range(10000); +-- +ok +== +INSERT INTO n48_tbl SELECT 'b', range FROM range(25); +-- +ok +== +INSERT INTO n48_tbl SELECT 'c', range FROM range(25); +-- +ok +== +CREATE INDEX n48_tbl_idx ON n48_tbl(i, k); +-- +ok +== +CREATE TABLE n48_free (id INTEGER); +-- +ok +== +INSERT INTO n48_free SELECT range % 100 FROM range(2048); +-- +ok +== +INSERT INTO n48_free VALUES ({i} + 107); +-- +error: Parser Error: syntax error at or near "}" +== +CREATE INDEX idx_n48_free ON n48_free(id); +-- +ok +== diff --git a/parser/testdata/corpus/sql/index/art/nodes/test_art_prefix_transform_deprecated_create.test b/parser/testdata/corpus/sql/index/art/nodes/test_art_prefix_transform_deprecated_create.test new file mode 100644 index 0000000..0d42800 --- /dev/null +++ b/parser/testdata/corpus/sql/index/art/nodes/test_art_prefix_transform_deprecated_create.test @@ -0,0 +1,23 @@ +# source: test/sql/index/art/nodes/test_art_prefix_transform_deprecated_create.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +ATTACH '{TEST_DIR}/prefix_transform.db' AS db (STORAGE_VERSION 'v1.0.0'); +-- +ok +== +CREATE TABLE db.t (id VARCHAR, ts TIMESTAMP, value INTEGER, PRIMARY KEY (id, ts)); +-- +ok +== +INSERT OR IGNORE INTO db.t + SELECT range || 'hello this is a long prefix', current_timestamp, range + FROM range(1_000_000); +-- +ok +== +CHECKPOINT db; +-- +ok +== diff --git a/parser/testdata/corpus/sql/index/art/nodes/test_art_prefix_transform_deprecated_gated.test b/parser/testdata/corpus/sql/index/art/nodes/test_art_prefix_transform_deprecated_gated.test new file mode 100644 index 0000000..923ee67 --- /dev/null +++ b/parser/testdata/corpus/sql/index/art/nodes/test_art_prefix_transform_deprecated_gated.test @@ -0,0 +1,89 @@ +# source: test/sql/index/art/nodes/test_art_prefix_transform_deprecated_gated.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +SET index_scan_max_count = 0; +-- +ok +== +SET index_scan_percentage = 1.0; +-- +ok +== +ATTACH '{TEST_DIR}/prefix_transform_gated.db' AS db (STORAGE_VERSION 'v1.0.0'); +-- +ok +== +CREATE TABLE db.t(k1 VARCHAR, k2 VARCHAR, k VARCHAR, payload INTEGER); +-- +ok +== +INSERT INTO db.t +SELECT + repeat('a', 80) || 'gate', + repeat('b', 80) || 'tail', + repeat('a', 80) || 'gate' || repeat('b', 80) || 'tail', + i +FROM range(1, 10) AS r(i); +-- +ok +== +INSERT INTO db.t VALUES + (repeat('a', 80) || 'gath', repeat('b', 80) || 'tail', + repeat('a', 80) || 'gath' || repeat('b', 80) || 'tail', 100), + (repeat('a', 80) || 'gate', repeat('b', 80) || 'taih', + repeat('a', 80) || 'gate' || repeat('b', 80) || 'taih', 101); +-- +ok +== +CREATE INDEX idx_t_compound ON db.t(k1, k2); +-- +ok +== +CREATE INDEX idx_t_scan ON db.t(k); +-- +ok +== +DETACH db; +-- +ok +== +ATTACH '{TEST_DIR}/prefix_transform_gated.db' AS db; +-- +ok +== +EXPLAIN ANALYZE +SELECT payload +FROM db.t +WHERE k = repeat('a', 80) || 'gate' || repeat('b', 80) || 'tail'; +-- +ok +== +SELECT payload +FROM db.t +WHERE k = repeat('a', 80) || 'gate' || repeat('b', 80) || 'tail' +ORDER BY payload; +-- +ok +== +SELECT payload +FROM db.t +WHERE k = repeat('a', 80) || 'gath' || repeat('b', 80) || 'tail'; +-- +ok +== +SELECT payload +FROM db.t +WHERE k = repeat('a', 80) || 'gate' || repeat('b', 80) || 'taih'; +-- +ok +== +DELETE FROM db.t WHERE payload IN (2, 4, 6, 8); +-- +ok +== +DELETE FROM db.t WHERE payload = 1; +-- +ok +== diff --git a/parser/testdata/corpus/sql/index/art/nodes/test_art_prefixes_restart.test b/parser/testdata/corpus/sql/index/art/nodes/test_art_prefixes_restart.test new file mode 100644 index 0000000..167d999 --- /dev/null +++ b/parser/testdata/corpus/sql/index/art/nodes/test_art_prefixes_restart.test @@ -0,0 +1,54 @@ +# source: test/sql/index/art/nodes/test_art_prefixes_restart.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +CREATE TABLE tbl (id INTEGER); +-- +ok +== +CREATE INDEX idx ON tbl(id); +-- +ok +== +INSERT INTO tbl VALUES (1), (2); +-- +ok +== +CREATE TABLE tbl_varchar (id VARCHAR); +-- +ok +== +CREATE INDEX idx_varchar ON tbl_varchar(id); +-- +ok +== +INSERT INTO tbl_varchar VALUES + ('hello I am a prefix, and it is a beautiful sommer evening, and the plants are blossoming - 1'), + ('hello I am a prefix, and it is a beautiful sommer evening, and the plants are blossoming - 2'); +-- +ok +== +DELETE FROM tbl_varchar +WHERE id = 'hello I am a prefix, and it is a beautiful sommer evening, and the plants are blossoming - 1'; +-- +ok +== +DELETE FROM tbl_varchar; +-- +ok +== +INSERT INTO tbl_varchar VALUES ('012345678901234'), ('012345678901235'); +-- +ok +== +INSERT INTO tbl_varchar VALUES + ('0123456789-0123456789-0123456789-0123456789'); +-- +ok +== +INSERT INTO tbl_varchar VALUES + ('0123456779-0123456789-0123456789-0123456789'); +-- +ok +== diff --git a/parser/testdata/corpus/sql/index/art/nodes/test_art_sparse_merge.test b/parser/testdata/corpus/sql/index/art/nodes/test_art_sparse_merge.test new file mode 100644 index 0000000..8de654f --- /dev/null +++ b/parser/testdata/corpus/sql/index/art/nodes/test_art_sparse_merge.test @@ -0,0 +1,25 @@ +# source: test/sql/index/art/nodes/test_art_sparse_merge.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +CREATE TABLE tbl1 (i INT); +-- +ok +== +INSERT INTO tbl1 SELECT range FROM range(50000); +-- +ok +== +DELETE FROM tbl1 WHERE i > 4; +-- +ok +== +CREATE INDEX idx ON tbl1(i); +-- +ok +== +SELECT COUNT(i) FROM tbl1 WHERE i = 1; +-- +ok +== diff --git a/parser/testdata/corpus/sql/index/art/scan/test_art_adaptive_scan.test b/parser/testdata/corpus/sql/index/art/scan/test_art_adaptive_scan.test new file mode 100644 index 0000000..974d529 --- /dev/null +++ b/parser/testdata/corpus/sql/index/art/scan/test_art_adaptive_scan.test @@ -0,0 +1,25 @@ +# source: test/sql/index/art/scan/test_art_adaptive_scan.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +CREATE TABLE integers AS SELECT 42 AS i FROM range(2050); +-- +ok +== +INSERT INTO integers SELECT 42 + 1 + range FROM range(5000); +-- +ok +== +CREATE INDEX i_index ON integers USING ART(i); +-- +ok +== +EXPLAIN ANALYZE SELECT COUNT(i) FROM integers WHERE i = 42; +-- +ok +== +SELECT COUNT(i) FROM integers WHERE i = 42; +-- +ok +== diff --git a/parser/testdata/corpus/sql/index/art/scan/test_art_many_matches.test b/parser/testdata/corpus/sql/index/art/scan/test_art_many_matches.test new file mode 100644 index 0000000..f70708e --- /dev/null +++ b/parser/testdata/corpus/sql/index/art/scan/test_art_many_matches.test @@ -0,0 +1,37 @@ +# source: test/sql/index/art/scan/test_art_many_matches.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +INSERT INTO integers SELECT i FROM RANGE(0, 1024, 1) t2(j), (VALUES (0), (1)) t1(i) ORDER BY j, i; +-- +ok +== +SELECT COUNT(*) FROM integers WHERE i<1 +-- +ok +== +SELECT COUNT(*) FROM integers WHERE i<=1 +-- +ok +== +SELECT COUNT(*) FROM integers WHERE i=0 +-- +ok +== +SELECT COUNT(*) FROM integers WHERE i=1 +-- +ok +== +SELECT COUNT(*) FROM integers WHERE i>0 +-- +ok +== +SELECT COUNT(*) FROM integers WHERE i>=0 +-- +ok +== +INSERT INTO integers SELECT i FROM RANGE(0, 2048, 1) t2(j), (VALUES (0), (1)) t1(i) ORDER BY j, i; +-- +ok +== diff --git a/parser/testdata/corpus/sql/index/art/scan/test_art_negative_range_scan.test b/parser/testdata/corpus/sql/index/art/scan/test_art_negative_range_scan.test new file mode 100644 index 0000000..2bda4d8 --- /dev/null +++ b/parser/testdata/corpus/sql/index/art/scan/test_art_negative_range_scan.test @@ -0,0 +1,21 @@ +# source: test/sql/index/art/scan/test_art_negative_range_scan.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +INSERT INTO integers SELECT * FROM range(-500, 500, 1) +-- +ok +== +SELECT sum(i) FROM integers WHERE i >= -500 AND i <= -498 +-- +ok +== +SELECT sum(i) FROM integers WHERE i >= -10 AND i <= 5 +-- +ok +== +SELECT sum(i) FROM integers WHERE i >= 10 AND i <= 15 +-- +ok +== diff --git a/parser/testdata/corpus/sql/index/art/scan/test_art_node256_byte_edges.test b/parser/testdata/corpus/sql/index/art/scan/test_art_node256_byte_edges.test new file mode 100644 index 0000000..b9d75d5 --- /dev/null +++ b/parser/testdata/corpus/sql/index/art/scan/test_art_node256_byte_edges.test @@ -0,0 +1,54 @@ +# source: test/sql/index/art/scan/test_art_node256_byte_edges.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +SET index_scan_max_count = 1000; +-- +ok +== +CREATE TABLE byte_edges(k INTEGER PRIMARY KEY); +-- +ok +== +INSERT INTO byte_edges SELECT i FROM range(-1, 258) r(i); +-- +ok +== +EXPLAIN ANALYZE SELECT k FROM byte_edges WHERE k <= 1; +-- +ok +== +SELECT k FROM byte_edges WHERE k <= 1 ORDER BY k; +-- +ok +== +EXPLAIN ANALYZE SELECT k FROM byte_edges WHERE k > 254; +-- +ok +== +SELECT k FROM byte_edges WHERE k > 254 ORDER BY k; +-- +ok +== +DELETE FROM byte_edges WHERE k BETWEEN 36 AND 255; +-- +ok +== +INSERT INTO byte_edges VALUES (255); +-- +ok +== +EXPLAIN ANALYZE +SELECT count(*), min(k), max(k), sum(k) +FROM byte_edges +WHERE k >= 0; +-- +ok +== +SELECT count(*), min(k), max(k), sum(k) +FROM byte_edges +WHERE k >= 0; +-- +ok +== diff --git a/parser/testdata/corpus/sql/index/art/scan/test_art_null_bytes.test b/parser/testdata/corpus/sql/index/art/scan/test_art_null_bytes.test new file mode 100644 index 0000000..bee8d4f --- /dev/null +++ b/parser/testdata/corpus/sql/index/art/scan/test_art_null_bytes.test @@ -0,0 +1,69 @@ +# source: test/sql/index/art/scan/test_art_null_bytes.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +CREATE TABLE varchars(v VARCHAR PRIMARY KEY); +-- +ok +== +INSERT INTO varchars VALUES ('hello'), ('hello' || chr(0)), ('hello' || chr(0) || chr(0)), ('hello' || chr(0) || chr(0) || chr(0)); +-- +ok +== +INSERT INTO varchars VALUES ('hello' || chr(0) || chr(0) || chr(0)); +-- +ok +== +SELECT * FROM varchars WHERE v = 'hello' +-- +ok +== +SELECT * FROM varchars WHERE v = 'hello' || chr(0) +-- +ok +== +SELECT * FROM varchars WHERE v = 'hello' || chr(0) || chr(0) +-- +ok +== +SELECT * FROM varchars WHERE v = 'hello' || chr(0) || chr(0) || chr(0) +-- +ok +== +CREATE TABLE blobs(b BLOB PRIMARY KEY); +-- +ok +== +INSERT INTO blobs VALUES (''), ('\x00'), ('\x01'), ('\x00\x01'), ('\x01\x00'), ('\x01\x01'), ('\x00\x00'); +-- +ok +== +INSERT INTO blobs VALUES ('\x00\x01'); +-- +ok +== +SELECT * FROM blobs WHERE b = '' +-- +ok +== +SELECT * FROM blobs WHERE b = '\x00' +-- +ok +== +SELECT * FROM blobs WHERE b = '\x00\x01' +-- +ok +== +SELECT * FROM blobs WHERE b >= '\x00' ORDER BY b::VARCHAR +-- +ok +== +SELECT * FROM blobs WHERE b >= '\x01' ORDER BY b::VARCHAR +-- +ok +== +SELECT * FROM blobs WHERE b >= '\x01\x00' ORDER BY b::VARCHAR +-- +ok +== diff --git a/parser/testdata/corpus/sql/index/art/scan/test_art_prepared_scan.test b/parser/testdata/corpus/sql/index/art/scan/test_art_prepared_scan.test new file mode 100644 index 0000000..44094bb --- /dev/null +++ b/parser/testdata/corpus/sql/index/art/scan/test_art_prepared_scan.test @@ -0,0 +1,29 @@ +# source: test/sql/index/art/scan/test_art_prepared_scan.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +INSERT INTO integers VALUES (1), (2), (4); +-- +ok +== +EXPLAIN ANALYZE SELECT i FROM integers WHERE i = 2; +-- +ok +== +SELECT i FROM integers WHERE i = 2; +-- +ok +== +PREPARE v1 AS SELECT * FROM integers WHERE i = $1; +-- +ok +== +EXPLAIN ANALYZE EXECUTE v1(2); +-- +ok +== +EXECUTE v1(2); +-- +ok +== diff --git a/parser/testdata/corpus/sql/index/art/scan/test_art_range_scan.test b/parser/testdata/corpus/sql/index/art/scan/test_art_range_scan.test new file mode 100644 index 0000000..56e456d --- /dev/null +++ b/parser/testdata/corpus/sql/index/art/scan/test_art_range_scan.test @@ -0,0 +1,61 @@ +# source: test/sql/index/art/scan/test_art_range_scan.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +CREATE TABLE test (x VARCHAR PRIMARY KEY); +-- +ok +== +INSERT INTO test VALUES ('abc'); +-- +ok +== +INSERT INTO test VALUES ('def'); +-- +ok +== +SELECT * FROM test WHERE x > 'z'; +-- +ok +== +INSERT INTO test VALUES ('abcd'); +-- +ok +== +SELECT x FROM test WHERE x > 'abce'; +-- +ok +== +INSERT INTO test VALUES ('abcd'), ('abde'); +-- +ok +== +CREATE TABLE test (x USMALLINT PRIMARY KEY); +-- +ok +== +INSERT INTO test SELECT i FROM range(1, 20) tbl(i); +-- +ok +== +SELECT x FROM test WHERE x > 20; +-- +ok +== +INSERT INTO test VALUES (256); +-- +ok +== +INSERT INTO test SELECT i FROM range(1, 135) tbl(i); +-- +ok +== +SELECT x FROM test WHERE x > 135; +-- +ok +== +INSERT INTO test VALUES (256), (257); +-- +ok +== diff --git a/parser/testdata/corpus/sql/index/art/scan/test_art_scan_coverage.test b/parser/testdata/corpus/sql/index/art/scan/test_art_scan_coverage.test new file mode 100644 index 0000000..0cbaf29 --- /dev/null +++ b/parser/testdata/corpus/sql/index/art/scan/test_art_scan_coverage.test @@ -0,0 +1,137 @@ +# source: test/sql/index/art/scan/test_art_scan_coverage.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +CREATE TABLE tab0(pk INTEGER PRIMARY KEY, col0 INTEGER, col1 FLOAT, col2 TEXT, col3 INTEGER, col4 FLOAT, col5 TEXT) +-- +ok +== +INSERT INTO tab0 VALUES(0,25,74.4,'vvcgn',47,57.68,'ymlye') +-- +ok +== +INSERT INTO tab0 VALUES(1,72,81.64,'zsnbm',42,74.55,'tzagd') +-- +ok +== +INSERT INTO tab0 VALUES(2,45,38.39,'dmsso',87,29.20,'ywydk') +-- +ok +== +INSERT INTO tab0 VALUES(3,81,97.79,'tdbjm',48,89.67,'hvaol') +-- +ok +== +INSERT INTO tab0 VALUES(4,17,18.5,'ddcya',66,87.1,'ndulx') +-- +ok +== +INSERT INTO tab0 VALUES(5,46,83.75,'khqpe',31,31.98,'hzpio') +-- +ok +== +INSERT INTO tab0 VALUES(6,85,8.45,'ugwie',30,22.61,'klsxt') +-- +ok +== +INSERT INTO tab0 VALUES(7,36,54.34,'pflrv',18,61.89,'vrltg') +-- +ok +== +INSERT INTO tab0 VALUES(8,47,41.84,'plpkl',76,65.31,'yzivj') +-- +ok +== +INSERT INTO tab0 VALUES(9,76,63.21,'uakya',80,80.58,'ocfgj') +-- +ok +== +CREATE TABLE tab1(pk INTEGER PRIMARY KEY, col0 INTEGER, col1 FLOAT, col2 TEXT, col3 INTEGER, col4 FLOAT, col5 TEXT) +-- +ok +== +CREATE INDEX idx_tab1_0 on tab1 (col0) +-- +ok +== +CREATE INDEX idx_tab1_1 on tab1 (col1) +-- +ok +== +CREATE INDEX idx_tab1_3 on tab1 (col3) +-- +ok +== +CREATE INDEX idx_tab1_4 on tab1 (col4) +-- +ok +== +INSERT INTO tab1 SELECT * FROM tab0 +-- +ok +== +DELETE FROM tab1 WHERE col3 = 54 AND col1 <= 76.83 +-- +ok +== +SELECT pk FROM tab1 WHERE col3 = 54 AND col1 <= 76.83 +-- +ok +== +SELECT pk FROM tab1 WHERE NOT (col3 = 54 AND col1 <= 76.83) +-- +ok +== +DELETE FROM tab1 WHERE (col4 > 71.47) OR col0 IN (98,26,25,60) +-- +ok +== +SELECT pk FROM tab1 WHERE (col4 > 71.47) OR col0 IN (98,26,25,60) +-- +ok +== +SELECT pk FROM tab1 WHERE NOT ((col4 > 71.47) OR col0 IN (98,26,25,60)) +-- +ok +== +DELETE FROM tab1 WHERE ((col0 > 32) AND col0 < 87) +-- +ok +== +SELECT pk FROM tab1 WHERE ((col0 > 32) AND col0 < 87) +-- +ok +== +CREATE TABLE t0_varchar(c0 VARCHAR); +-- +ok +== +INSERT INTO t0_varchar(c0) VALUES ('a'), ('a'); +-- +ok +== +CREATE INDEX t0i0_idx ON t0_varchar(c0 ); +-- +ok +== +SELECT c0 FROM t0_varchar WHERE t0_varchar.c0 <= 'a'; +-- +ok +== +CREATE TABLE t0_scan(c0 DATE); +-- +ok +== +INSERT INTO t0_scan(c0) VALUES ('1970-01-02'), ('1970-01-02'), ('1970-01-03'); +-- +ok +== +CREATE INDEX t0i0 ON t0_scan(c0 DESC); +-- +ok +== +SELECT c0 FROM t0_scan WHERE '1970-01-03' >= t0_scan.c0 ORDER BY c0; +-- +ok +== diff --git a/parser/testdata/corpus/sql/index/art/scan/test_art_scan_duplicate_filters.test b/parser/testdata/corpus/sql/index/art/scan/test_art_scan_duplicate_filters.test new file mode 100644 index 0000000..4ac36ed --- /dev/null +++ b/parser/testdata/corpus/sql/index/art/scan/test_art_scan_duplicate_filters.test @@ -0,0 +1,63 @@ +# source: test/sql/index/art/scan/test_art_scan_duplicate_filters.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +CREATE TABLE t_1 (fIdx VARCHAR, sIdx UUID,); +-- +ok +== +CREATE TABLE t_3 (fIdx VARCHAR, sIdx UUID); +-- +ok +== +CREATE TABLE t_4 (sIdx UUID); +-- +ok +== +CREATE TABLE t_5 (sIdx UUID); +-- +ok +== +CREATE UNIQUE INDEX _pk_idx_t_5 ON t_5 (sIdx); +-- +ok +== +INSERT INTO t_4 (sIdx) VALUES +('1381e0ce-6b3e-43f5-9536-5e7af3a512a5'::UUID), +('6880cdba-09f5-3c4f-8eb8-391aefdd8052'::UUID), +('a3e876dd-5e50-3af7-9649-689fd938daeb'::UUID), +('e0abc0d3-63be-41d8-99ca-b1269ed153a8'::UUID); +-- +ok +== +INSERT INTO t_5 (sIdx) VALUES +('a3e876dd-5e50-3af7-9649-689fd938daeb'::UUID), +('e0abc0d3-63be-41d8-99ca-b1269ed153a8'::UUID), +('91c79790-5828-45f2-ad88-50e9b541cc05'::UUID), +('1381e0ce-6b3e-43f5-9536-5e7af3a512a5'::UUID), +('d9f29fa5-2051-3ea4-9d9e-15c3698b4bb8'::UUID), +('6880cdba-09f5-3c4f-8eb8-391aefdd8052'::UUID), +('3239280c-2204-3e60-b3a1-3ad3acc8fd59'::UUID), +('2fced822-342d-344a-aa34-2707e593be52'::UUID); +-- +ok +== +WITH + cte_5 AS ( + SELECT sIdx FROM t_4 ANTI JOIN t_3 USING (sIdx) + ), + cte_6 AS MATERIALIZED ( + SELECT + COALESCE(cte_5.sIdx, t_1.sIdx) AS sIdx, + COALESCE(t_1.fIdx, cte_5.sIdx::VARCHAR) AS fIdx, + FROM cte_5 FULL JOIN t_1 USING (sIdx) + ), + cte_7 AS ( + SELECT t_5.sIdx, FROM t_5 + WHERE sIdx IN (SELECT sIdx FROM cte_6) + ) +SELECT fIdx, FROM cte_6 JOIN cte_7 USING (sIdx) ORDER BY fIdx; +-- +ok +== diff --git a/parser/testdata/corpus/sql/index/art/scan/test_art_scan_normal_to_nested.test b/parser/testdata/corpus/sql/index/art/scan/test_art_scan_normal_to_nested.test new file mode 100644 index 0000000..ff6038b --- /dev/null +++ b/parser/testdata/corpus/sql/index/art/scan/test_art_scan_normal_to_nested.test @@ -0,0 +1,37 @@ +# source: test/sql/index/art/scan/test_art_scan_normal_to_nested.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +CREATE TABLE integers (i BIGINT); +-- +ok +== +CREATE INDEX idx_integers ON integers (i); +-- +ok +== +INSERT INTO integers (i) VALUES ('1'), ('-1'), ('1'); +-- +ok +== +SELECT i FROM integers WHERE i <= 0; +-- +ok +== +CREATE TABLE t0(c1 TIMESTAMP); +-- +ok +== +INSERT INTO t0(c1) VALUES ('2020-02-29 12:00:00'), ('1969-12-09 09:26:38'), ('2020-02-29 12:00:00'); +-- +ok +== +CREATE INDEX i0 ON t0(c1); +-- +ok +== +SELECT c1 FROM t0 WHERE c1 <= '2007-07-07 07:07:07'; +-- +ok +== diff --git a/parser/testdata/corpus/sql/index/art/scan/test_art_scan_thresholds.test b/parser/testdata/corpus/sql/index/art/scan/test_art_scan_thresholds.test new file mode 100644 index 0000000..171f195 --- /dev/null +++ b/parser/testdata/corpus/sql/index/art/scan/test_art_scan_thresholds.test @@ -0,0 +1,41 @@ +# source: test/sql/index/art/scan/test_art_scan_thresholds.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +SET index_scan_max_count = 1; +-- +ok +== +INSERT INTO integers SELECT 42 FROM range(1000); +-- +ok +== +INSERT INTO integers SELECT 43 FROM range(10000); +-- +ok +== +CREATE INDEX idx ON integers(i); +-- +ok +== +EXPLAIN ANALYZE SELECT i FROM integers WHERE i = 42; +-- +ok +== +SET index_scan_percentage = 0.000001; +-- +ok +== +SET index_scan_max_count = 4000; +-- +ok +== +INSERT INTO integers SELECT 4242 FROM range(4000); +-- +ok +== +EXPLAIN ANALYZE SELECT i FROM integers WHERE i = 4242; +-- +ok +== diff --git a/parser/testdata/corpus/sql/index/art/scan/test_hash_join_in_filter_index_scan.test b/parser/testdata/corpus/sql/index/art/scan/test_hash_join_in_filter_index_scan.test new file mode 100644 index 0000000..2bce1e5 --- /dev/null +++ b/parser/testdata/corpus/sql/index/art/scan/test_hash_join_in_filter_index_scan.test @@ -0,0 +1,35 @@ +# source: test/sql/index/art/scan/test_hash_join_in_filter_index_scan.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +CREATE TABLE random_orders AS ( + (SELECT o_orderkey FROM orders + OFFSET 100 + LIMIT 3) + UNION + (SELECT o_orderkey FROM orders + OFFSET (SELECT COUNT(*) FROM orders) / 2 + LIMIT 3) + UNION + (SELECT o_orderkey FROM orders + OFFSET (SELECT COUNT(*) FROM orders) / 2 + 100000 + LIMIT 3)); +-- +ok +== +CREATE TABLE orders_shuffled AS FROM orders ORDER BY random(); +-- +ok +== +EXPLAIN ANALYZE +SELECT o_orderkey FROM orders_shuffled WHERE o_orderkey IN ( + SELECT UNNEST(LIST(o_orderkey)) FROM random_orders +) ORDER BY ALL; +-- +ok +== +ALTER TABLE orders_shuffled ADD PRIMARY KEY (o_orderkey); +-- +ok +== diff --git a/parser/testdata/corpus/sql/index/art/scan/test_in_filter_index_scan.test b/parser/testdata/corpus/sql/index/art/scan/test_in_filter_index_scan.test new file mode 100644 index 0000000..833c07e --- /dev/null +++ b/parser/testdata/corpus/sql/index/art/scan/test_in_filter_index_scan.test @@ -0,0 +1,65 @@ +# source: test/sql/index/art/scan/test_in_filter_index_scan.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +CREATE TABLE tbl AS SELECT range AS i FROM range(500000); +-- +ok +== +ALTER TABLE tbl ADD PRIMARY KEY(i); +-- +ok +== +EXPLAIN ANALYZE DELETE FROM tbl WHERE i IN (3, 50, 299, 123); +-- +ok +== +EXPLAIN ANALYZE SELECT i FROM tbl WHERE i IN (2, 42, 100, 42, 101); +-- +ok +== +SELECT i FROM tbl WHERE i IN (2, 42, 100, 42, 101) ORDER BY i; +-- +ok +== +EXPLAIN ANALYZE SELECT i FROM tbl WHERE i IN (2, 42, 100, 42, 101) AND i != 42 AND i <= 100; +-- +ok +== +SELECT i FROM tbl WHERE i IN (2, 42, 100, 42, 101) AND i != 42 AND i <= 100 ORDER BY i; +-- +ok +== +EXPLAIN ANALYZE SELECT i FROM tbl WHERE i IN (2, 42, 100, 42, 101) AND i = 42 AND i <= 100; +-- +ok +== +SELECT i FROM tbl WHERE i IN (2, 42, 100, 42, 101) AND i = 42 AND i <= 100 ORDER BY i; +-- +ok +== +EXPLAIN ANALYZE SELECT i FROM tbl WHERE i IN (2, 42, 100, 42, 101) AND i < 101 AND i >= 42; +-- +ok +== +SELECT i FROM tbl WHERE i IN (2, 42, 100, 42, 101) AND i < 101 AND i >= 42 ORDER BY i; +-- +ok +== +EXPLAIN ANALYZE SELECT i FROM tbl WHERE i IN (2, 42, 100, 42, 101) AND i > 42 AND i >= 42; +-- +ok +== +SELECT i FROM tbl WHERE i IN (2, 42, 100, 42, 101) AND i > 42 AND i >= 42 ORDER BY i; +-- +ok +== +EXPLAIN ANALYZE SELECT i FROM tbl WHERE i IN (2, 42, 100, 42, 101) AND i > 42 AND i IN (56, 200, 2, 100); +-- +ok +== +SELECT i FROM tbl WHERE i IN (2, 42, 100, 42, 101) AND i > 42 AND i IN (56, 200, 2, 100) ORDER BY i; +-- +ok +== diff --git a/parser/testdata/corpus/sql/index/art/scan/test_not_distinct_index_scan.test b/parser/testdata/corpus/sql/index/art/scan/test_not_distinct_index_scan.test new file mode 100644 index 0000000..b40ca97 --- /dev/null +++ b/parser/testdata/corpus/sql/index/art/scan/test_not_distinct_index_scan.test @@ -0,0 +1,74 @@ +# source: test/sql/index/art/scan/test_not_distinct_index_scan.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +CREATE INDEX idx_i ON tbl(i); +-- +ok +== +EXPLAIN ANALYZE SELECT count(*) FROM tbl WHERE i IS NOT DISTINCT FROM 499995; +-- +ok +== +SELECT count(*) FROM tbl WHERE i IS NOT DISTINCT FROM 499995; +-- +ok +== +SELECT i FROM tbl WHERE i IS NOT DISTINCT FROM 499995; +-- +ok +== +EXPLAIN ANALYZE SELECT i FROM tbl WHERE i IS NOT DISTINCT FROM NULL; +-- +ok +== +SELECT count(*) FROM tbl WHERE i IS NOT DISTINCT FROM NULL; +-- +ok +== +CREATE TABLE nulls AS SELECT CASE WHEN range % 5 = 0 THEN NULL ELSE range END AS i FROM range(500000); +-- +ok +== +CREATE INDEX idx_nulls ON nulls(i); +-- +ok +== +EXPLAIN ANALYZE SELECT count(*) FROM nulls WHERE i IS NOT DISTINCT FROM 499997; +-- +ok +== +SELECT count(*) FROM nulls WHERE i IS NOT DISTINCT FROM 499997; +-- +ok +== +SELECT count(*) FROM nulls WHERE i IS NOT DISTINCT FROM 499995; +-- +ok +== +EXPLAIN ANALYZE SELECT count(*) FROM nulls WHERE NOT (i IS NOT DISTINCT FROM 499997); +-- +ok +== +SELECT count(*) FROM nulls WHERE NOT (i IS NOT DISTINCT FROM 499997); +-- +ok +== +EXPLAIN ANALYZE SELECT count(*) FROM nulls WHERE (i IS NOT DISTINCT FROM 499997) = false; +-- +ok +== +SELECT count(*) FROM nulls WHERE (i IS NOT DISTINCT FROM 499997) = false; +-- +ok +== +SELECT count(*) FROM nulls WHERE (i IS NOT DISTINCT FROM 499997) IS NULL; +-- +ok +== +SELECT i, i IS NOT DISTINCT FROM 7 AS not_distinct_from, i = 7 AS equals +FROM nulls WHERE i IS NULL OR i = 7 ORDER BY i NULLS LAST LIMIT 3; +-- +ok +== diff --git a/parser/testdata/corpus/sql/index/art/scan/test_random_uuid.test b/parser/testdata/corpus/sql/index/art/scan/test_random_uuid.test new file mode 100644 index 0000000..3dd43e0 --- /dev/null +++ b/parser/testdata/corpus/sql/index/art/scan/test_random_uuid.test @@ -0,0 +1,65 @@ +# source: test/sql/index/art/scan/test_random_uuid.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +create or replace table t as select id: uuid(), v: i from generate_series(1, 700000) s(i); +-- +ok +== +create unique index uid on t(id); +-- +ok +== +set variable u1 = uuid(); +-- +ok +== +set variable u2 = uuid(); +-- +ok +== +set variable u3 = uuid(); +-- +ok +== +set variable u4 = uuid(); +-- +ok +== +start transaction; +-- +ok +== +insert into t select * replace (getvariable('u1') as id) from t using sample 1 rows; +-- +ok +== +select * from t where id = getvariable('u1'); +-- +ok +== +insert into t select * replace (getvariable('u2') as id) from t using sample 1 rows; +-- +ok +== +select * from t where id = getvariable('u2'); +-- +ok +== +insert into t select * replace (getvariable('u3') as id) from t using sample 1 rows; +-- +ok +== +select * from t where id = getvariable('u4'); +-- +ok +== +select * from t where id = getvariable('u3'); +-- +ok +== +drop index uid; +-- +ok +== diff --git a/parser/testdata/corpus/sql/index/art/storage/test_art_auto_checkpoint.test b/parser/testdata/corpus/sql/index/art/storage/test_art_auto_checkpoint.test new file mode 100644 index 0000000..74b02c1 --- /dev/null +++ b/parser/testdata/corpus/sql/index/art/storage/test_art_auto_checkpoint.test @@ -0,0 +1,33 @@ +# source: test/sql/index/art/storage/test_art_auto_checkpoint.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +PRAGMA wal_autocheckpoint='400KB'; +-- +ok +== +CREATE TABLE tbl AS SELECT range AS i FROM range(40000); +-- +ok +== +SELECT used_blocks FROM pragma_database_size(); +-- +ok +== +CREATE INDEX idx ON tbl(i); +-- +ok +== +SELECT used_blocks > 0 FROM pragma_database_size(); +-- +ok +== +CREATE TABLE tbl (i INTEGER PRIMARY KEY); +-- +ok +== +INSERT INTO tbl SELECT range FROM range(40000); +-- +ok +== diff --git a/parser/testdata/corpus/sql/index/art/storage/test_art_buffered_replays_chunk_edges.test b/parser/testdata/corpus/sql/index/art/storage/test_art_buffered_replays_chunk_edges.test new file mode 100644 index 0000000..b83493f --- /dev/null +++ b/parser/testdata/corpus/sql/index/art/storage/test_art_buffered_replays_chunk_edges.test @@ -0,0 +1,61 @@ +# source: test/sql/index/art/storage/test_art_buffered_replays_chunk_edges.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +CREATE UNIQUE INDEX idx_tbl_i ON tbl(i); +-- +ok +== +INSERT INTO tbl SELECT r FROM range(0, 251) t(r); +-- +ok +== +DELETE FROM tbl WHERE i BETWEEN 0 AND 250; +-- +ok +== +INSERT INTO tbl SELECT r FROM range(251, 2049) t(r); +-- +ok +== +DELETE FROM tbl WHERE i BETWEEN 251 AND 2048; +-- +ok +== +INSERT INTO tbl SELECT r FROM range(2049, 4096) t(r); +-- +ok +== +DELETE FROM tbl WHERE i BETWEEN 2049 AND 4095; +-- +ok +== +INSERT INTO tbl VALUES (5000); +-- +ok +== +INSERT INTO tbl VALUES (6000); +-- +ok +== +DELETE FROM tbl WHERE i = 5000; +-- +ok +== +EXPLAIN ANALYZE SELECT i FROM tbl WHERE i = 5000; +-- +ok +== +SELECT i FROM tbl WHERE i = 5000; +-- +ok +== +EXPLAIN ANALYZE SELECT i FROM tbl WHERE i = 6000; +-- +ok +== +SELECT i FROM tbl WHERE i = 6000; +-- +ok +== diff --git a/parser/testdata/corpus/sql/index/art/storage/test_art_buffered_replays_interleaved.test b/parser/testdata/corpus/sql/index/art/storage/test_art_buffered_replays_interleaved.test new file mode 100644 index 0000000..056d4cb --- /dev/null +++ b/parser/testdata/corpus/sql/index/art/storage/test_art_buffered_replays_interleaved.test @@ -0,0 +1,29 @@ +# source: test/sql/index/art/storage/test_art_buffered_replays_interleaved.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +CREATE UNIQUE INDEX idx_i ON tbl (i); +-- +ok +== +INSERT INTO tbl SELECT r FROM range({i} * 10000, {i} * 10000 + 3000) t(r); +-- +error: Parser Error: syntax error at or near "}" +== +DELETE FROM tbl WHERE i >= {i} * 10000 AND i < {i} * 10000 + 2500; +-- +error: Parser Error: syntax error at or near "}" +== +INSERT INTO tbl VALUES (12501); +-- +ok +== +SELECT i FROM tbl WHERE i = 12501; +-- +ok +== +SELECT i FROM tbl WHERE i = 1; +-- +ok +== diff --git a/parser/testdata/corpus/sql/index/art/storage/test_art_buffered_replays_interval_merging.test b/parser/testdata/corpus/sql/index/art/storage/test_art_buffered_replays_interval_merging.test new file mode 100644 index 0000000..064129f --- /dev/null +++ b/parser/testdata/corpus/sql/index/art/storage/test_art_buffered_replays_interval_merging.test @@ -0,0 +1,97 @@ +# source: test/sql/index/art/storage/test_art_buffered_replays_interval_merging.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +INSERT INTO tbl SELECT r FROM range({i} * 10000, {i} * 10000 + 2001) t(r); +-- +error: Parser Error: syntax error at or near "}" +== +INSERT INTO tbl SELECT r FROM range({i} * 10000 + 2001, {i} * 10000 + 4001) t(r); +-- +error: Parser Error: syntax error at or near "}" +== +INSERT INTO tbl SELECT r FROM range({i} * 10000 + 4001, {i} * 10000 + 5001) t(r); +-- +error: Parser Error: syntax error at or near "}" +== +INSERT INTO tbl VALUES (60000); +-- +ok +== +INSERT INTO tbl VALUES (60001); +-- +ok +== +EXPLAIN ANALYZE SELECT i FROM tbl WHERE i = 60000; +-- +ok +== +SELECT i FROM tbl WHERE i = 60000; +-- +ok +== +EXPLAIN ANALYZE SELECT i FROM tbl WHERE i = 60001; +-- +ok +== +SELECT i FROM tbl WHERE i = 60001; +-- +ok +== +EXPLAIN ANALYZE SELECT i FROM tbl WHERE i = {val} * 10000 + 1000; +-- +error: Parser Error: syntax error at or near "}" +== +SELECT i FROM tbl WHERE i = {val} * 10000 + 1000; +-- +error: Parser Error: syntax error at or near "}" +== +EXPLAIN ANALYZE SELECT i FROM tbl WHERE i = 3000; +-- +ok +== +SELECT i FROM tbl WHERE i = 3000; +-- +ok +== +EXPLAIN ANALYZE SELECT i FROM tbl WHERE i = 13000; +-- +ok +== +SELECT i FROM tbl WHERE i = 13000; +-- +ok +== +EXPLAIN ANALYZE SELECT i FROM tbl WHERE i = 23000; +-- +ok +== +SELECT i FROM tbl WHERE i = 23000; +-- +ok +== +EXPLAIN ANALYZE SELECT i FROM tbl WHERE i = 4500; +-- +ok +== +SELECT i FROM tbl WHERE i = 4500; +-- +ok +== +EXPLAIN ANALYZE SELECT i FROM tbl WHERE i = 14500; +-- +ok +== +SELECT i FROM tbl WHERE i = 14500; +-- +ok +== +EXPLAIN ANALYZE SELECT i FROM tbl WHERE i = 24500; +-- +ok +== +SELECT i FROM tbl WHERE i = 24500; +-- +ok +== diff --git a/parser/testdata/corpus/sql/index/art/storage/test_art_buffered_replays_multi_col.test b/parser/testdata/corpus/sql/index/art/storage/test_art_buffered_replays_multi_col.test new file mode 100644 index 0000000..7958b70 --- /dev/null +++ b/parser/testdata/corpus/sql/index/art/storage/test_art_buffered_replays_multi_col.test @@ -0,0 +1,63 @@ +# source: test/sql/index/art/storage/test_art_buffered_replays_multi_col.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +CREATE TABLE tbl( + col1 INTEGER, + col2 INTEGER, + idx_col INTEGER, + gen_col INTEGER GENERATED ALWAYS AS (col1 + col2) VIRTUAL, + col5 VARCHAR +); +-- +ok +== +CREATE UNIQUE INDEX idx_tbl_idx_col ON tbl(idx_col); +-- +ok +== +INSERT INTO tbl (col1, col2, idx_col, col5) SELECT r, r * 2, r, 'val' || r::VARCHAR FROM range(0, 1001) t(r); +-- +ok +== +DELETE FROM tbl WHERE idx_col % 2 = 0; +-- +ok +== +EXPLAIN ANALYZE SELECT idx_col FROM tbl WHERE idx_col = {i} * 2; +-- +error: Parser Error: syntax error at or near "}" +== +SELECT EXISTS (SELECT 1 FROM tbl WHERE idx_col = {i} * 2); +-- +error: Parser Error: syntax error at or near "}" +== +EXPLAIN ANALYZE SELECT idx_col FROM tbl WHERE idx_col = {i} * 2 + 1; +-- +error: Parser Error: syntax error at or near "}" +== +SELECT EXISTS (SELECT 1 FROM tbl WHERE idx_col = {i} * 2 + 1); +-- +error: Parser Error: syntax error at or near "}" +== +INSERT INTO tbl (col1, col2, idx_col, col5) VALUES ({i} * 2 + 1, {i} * 4 + 2, {i} * 2 + 1, 'duplicate' || ({i} * 2 + 1)::VARCHAR); +-- +error: Parser Error: syntax error at or near "}" +== +EXPLAIN ANALYZE SELECT idx_col FROM tbl WHERE idx_col = 0; +-- +ok +== +SELECT idx_col FROM tbl WHERE idx_col = 0; +-- +ok +== +EXPLAIN ANALYZE SELECT idx_col FROM tbl WHERE idx_col = 10; +-- +ok +== +SELECT idx_col FROM tbl WHERE idx_col = 10; +-- +ok +== diff --git a/parser/testdata/corpus/sql/index/art/storage/test_art_checkpoint.test b/parser/testdata/corpus/sql/index/art/storage/test_art_checkpoint.test new file mode 100644 index 0000000..698cb85 --- /dev/null +++ b/parser/testdata/corpus/sql/index/art/storage/test_art_checkpoint.test @@ -0,0 +1,25 @@ +# source: test/sql/index/art/storage/test_art_checkpoint.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +CREATE TABLE integers (i INTEGER PRIMARY KEY); +-- +ok +== +INSERT INTO integers VALUES (1), (2), (3), (4), (5); +-- +ok +== +CREATE TABLE integers (i INTEGER); +-- +ok +== +INSERT INTO integers (SELECT range FROM range(512) UNION ALL SELECT 55); +-- +ok +== +SELECT total_blocks < 5 FROM pragma_database_size(); +-- +ok +== diff --git a/parser/testdata/corpus/sql/index/art/storage/test_art_duckdb_versions.test b/parser/testdata/corpus/sql/index/art/storage/test_art_duckdb_versions.test new file mode 100644 index 0000000..057e29e --- /dev/null +++ b/parser/testdata/corpus/sql/index/art/storage/test_art_duckdb_versions.test @@ -0,0 +1,93 @@ +# source: test/sql/index/art/storage/test_art_duckdb_versions.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +SELECT table_name, index_count FROM duckdb_tables() ORDER BY table_name; +-- +ok +== +SELECT index_name, table_name FROM duckdb_indexes() ORDER BY index_name; +-- +ok +== +SELECT table_name, constraint_type FROM duckdb_constraints() ORDER BY ALL; +-- +ok +== +SELECT id, name FROM pk_tbl ORDER BY id; +-- +ok +== +SELECT id FROM pk_tbl WHERE id = 2; +-- +ok +== +SELECT i FROM idx_tbl WHERE i = 11 +-- +ok +== +EXPORT DATABASE '{TEST_DIR}/export_index_db' (FORMAT CSV) +-- +ok +== +IMPORT DATABASE '{TEST_DIR}/export_index_db' +-- +ok +== +INSERT INTO idx_tbl SELECT range, range, range FROM range(300000); +-- +ok +== +SELECT used_blocks > 2621440 / get_block_size('test_art_import') FROM pragma_database_size(); +-- +ok +== +CREATE INDEX ART_index ON idx_tbl(i); +-- +ok +== +CREATE INDEX idx_1 ON idx_tbl(i); +-- +ok +== +SELECT i, j, k FROM idx_tbl WHERE i = 110 ORDER BY ALL; +-- +ok +== +DROP INDEX idx_1; +-- +ok +== +DROP INDEX idx_2; +-- +ok +== +DROP INDEX ART_index; +-- +ok +== +DROP TABLE fk_tbl; +-- +ok +== +DROP TABLE idx_tbl; +-- +ok +== +DROP TABLE pk_tbl; +-- +ok +== +SELECT + CASE WHEN ( + CASE WHEN get_block_size('test_art_import') = 16384 + THEN used_blocks < 3 + ELSE used_blocks < 2 END + ) + THEN NULL + ELSE T END +FROM pragma_database_size() T; +-- +ok +== diff --git a/parser/testdata/corpus/sql/index/art/storage/test_art_import.test b/parser/testdata/corpus/sql/index/art/storage/test_art_import.test new file mode 100644 index 0000000..cd31421 --- /dev/null +++ b/parser/testdata/corpus/sql/index/art/storage/test_art_import.test @@ -0,0 +1,29 @@ +# source: test/sql/index/art/storage/test_art_import.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +CREATE TABLE tracking("nflId" VARCHAR , "frameId" INTEGER, "gameId" INTEGER, "playId" INTEGER); +-- +ok +== +INSERT INTO tracking values ('a', 0,0,0); +-- +ok +== +CREATE INDEX nflid_idx ON tracking (nflid) +-- +ok +== +CREATE UNIQUE INDEX tracking_key_idx ON tracking (gameId, playId, frameId, nflId) +-- +ok +== +EXPORT DATABASE '{TEST_DIR}/index'; +-- +ok +== +IMPORT DATABASE '{TEST_DIR}/index' +-- +ok +== diff --git a/parser/testdata/corpus/sql/index/art/storage/test_art_import_export.test b/parser/testdata/corpus/sql/index/art/storage/test_art_import_export.test new file mode 100644 index 0000000..adb7463 --- /dev/null +++ b/parser/testdata/corpus/sql/index/art/storage/test_art_import_export.test @@ -0,0 +1,22 @@ +# source: test/sql/index/art/storage/test_art_import_export.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +CREATE TABLE raw( + "year" SMALLINT, + "month" TINYINT, + "day" TINYINT, + "customer_ID" BIGINT +); +-- +ok +== +INSERT INTO raw VALUES (1, 1, 1, 1); +-- +ok +== +CREATE UNIQUE INDEX customer_year_month_idx ON raw (customer_ID, year, month); +-- +ok +== diff --git a/parser/testdata/corpus/sql/index/art/storage/test_art_mem_limit.test b/parser/testdata/corpus/sql/index/art/storage/test_art_mem_limit.test new file mode 100644 index 0000000..eace012 --- /dev/null +++ b/parser/testdata/corpus/sql/index/art/storage/test_art_mem_limit.test @@ -0,0 +1,17 @@ +# source: test/sql/index/art/storage/test_art_mem_limit.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +SET memory_limit = '10MB'; +-- +ok +== +CREATE TABLE tbl AS SELECT range AS id FROM range(200000); +-- +ok +== +FROM duckdb_memory(); +-- +ok +== diff --git a/parser/testdata/corpus/sql/index/art/storage/test_art_names.test b/parser/testdata/corpus/sql/index/art/storage/test_art_names.test new file mode 100644 index 0000000..430ffec --- /dev/null +++ b/parser/testdata/corpus/sql/index/art/storage/test_art_names.test @@ -0,0 +1,55 @@ +# source: test/sql/index/art/storage/test_art_names.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +CREATE TABLE tbl (i INTEGER PRIMARY KEY, j INTEGER UNIQUE); +-- +ok +== +CREATE INDEX PRIMARY_tbl_0 ON tbl(i); +-- +ok +== +CREATE INDEX UNIQUE_tbl_1 ON tbl(j); +-- +ok +== +INSERT INTO tbl SELECT range, range FROM range (3000); +-- +ok +== +INSERT INTO tbl VALUES (4000, 20); +-- +ok +== +INSERT INTO tbl VALUES (20, 4000); +-- +ok +== +CREATE TABLE fk_tbl (i INTEGER, j INTEGER, + FOREIGN KEY (i) REFERENCES tbl(i), + FOREIGN KEY (j) REFERENCES tbl(j)); +-- +ok +== +INSERT INTO fk_tbl SELECT range, range FROM range (3000); +-- +ok +== +INSERT INTO fk_tbl VALUES (4000, 20); +-- +ok +== +INSERT INTO fk_tbl VALUES (20, 4000); +-- +ok +== +CREATE INDEX FOREIGN_fk_tbl_0 ON fk_tbl(i); +-- +ok +== +CREATE INDEX FOREIGN_fk_tbl_1 ON fk_tbl(j); +-- +ok +== diff --git a/parser/testdata/corpus/sql/index/art/storage/test_art_readonly.test b/parser/testdata/corpus/sql/index/art/storage/test_art_readonly.test new file mode 100644 index 0000000..df82b92 --- /dev/null +++ b/parser/testdata/corpus/sql/index/art/storage/test_art_readonly.test @@ -0,0 +1,21 @@ +# source: test/sql/index/art/storage/test_art_readonly.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +CREATE INDEX idx_drop ON tbl(i); +-- +ok +== +CREATE INDEX idx ON tbl (i); +-- +ok +== +DROP INDEX idx_drop +-- +ok +== +SELECT index_name FROM duckdb_indexes(); +-- +ok +== diff --git a/parser/testdata/corpus/sql/index/art/storage/test_art_storage.test b/parser/testdata/corpus/sql/index/art/storage/test_art_storage.test new file mode 100644 index 0000000..107bdea --- /dev/null +++ b/parser/testdata/corpus/sql/index/art/storage/test_art_storage.test @@ -0,0 +1,78 @@ +# source: test/sql/index/art/storage/test_art_storage.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +CREATE TABLE integers(i integer,j integer) +-- +ok +== +INSERT INTO integers VALUES (1,1),(2,2),(3,3),(4,4),(5,5), +-- +ok +== +SELECT j FROM integers where i = 3; +-- +ok +== +CREATE TABLE tbl_deser_scan(id INTEGER); +-- +ok +== +INSERT INTO tbl_deser_scan SELECT range FROM range(100000); +-- +ok +== +INSERT INTO tbl_deser_scan SELECT 424242 FROM range(5); +-- +ok +== +INSERT INTO tbl_deser_scan SELECT 424243 FROM range(5); +-- +ok +== +INSERT INTO tbl_deser_scan SELECT 1 FROM range(5); +-- +ok +== +CREATE INDEX idx_deser_scan ON tbl_deser_scan(id); +-- +ok +== +SELECT id FROM tbl_deser_scan WHERE id >= 424242; +-- +ok +== +CREATE TABLE max_row_id AS +SELECT max(rowid) AS id FROM tbl_deser_scan WHERE id = 424242; +-- +ok +== +DELETE FROM tbl_deser_scan WHERE rowid = (SELECT MAX(id) FROM max_row_id); +-- +ok +== +INSERT INTO tbl_deser_scan VALUES (1); +-- +ok +== +CREATE MACRO m(x, y := 7) AS x + y; +-- +ok +== +CREATE TABLE tbl_m (x integer, y varchar); +-- +ok +== +CREATE UNIQUE INDEX idx_m on tbl_m (m(tbl_m.x)); +-- +ok +== +insert into tbl_m VALUES (10, 'hello'); +-- +ok +== +insert into tbl_m VALUES (10, 'world'); +-- +ok +== diff --git a/parser/testdata/corpus/sql/index/art/storage/test_art_storage_long_prefixes.test b/parser/testdata/corpus/sql/index/art/storage/test_art_storage_long_prefixes.test new file mode 100644 index 0000000..705178a --- /dev/null +++ b/parser/testdata/corpus/sql/index/art/storage/test_art_storage_long_prefixes.test @@ -0,0 +1,25 @@ +# source: test/sql/index/art/storage/test_art_storage_long_prefixes.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +SET wal_autocheckpoint = '10GB'; +-- +ok +== +CREATE TABLE history(id TEXT, type TEXT, PRIMARY KEY(id, type)); +-- +ok +== +INSERT INTO history(id, type) VALUES ('5_create_aaaaaaaaaaa_mapping', 'sql'); +-- +ok +== +INSERT INTO history(id, type) VALUES ('m0001_initialize', 'sql'); +-- +ok +== +INSERT INTO history(id, type) VALUES ('m0005_create_aaaaaaaaaaa_mapping_table', 'sql'); +-- +ok +== diff --git a/parser/testdata/corpus/sql/index/art/storage/test_art_storage_multi_checkpoint.test b/parser/testdata/corpus/sql/index/art/storage/test_art_storage_multi_checkpoint.test new file mode 100644 index 0000000..ca567d4 --- /dev/null +++ b/parser/testdata/corpus/sql/index/art/storage/test_art_storage_multi_checkpoint.test @@ -0,0 +1,21 @@ +# source: test/sql/index/art/storage/test_art_storage_multi_checkpoint.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +INSERT INTO pk_integers VALUES (1) +-- +ok +== +CREATE TABLE pk_integers2(i INTEGER PRIMARY KEY) +-- +ok +== +INSERT INTO pk_integers2 VALUES (1) +-- +ok +== +SELECT i FROM pk_integers WHERE i = 1; +-- +ok +== diff --git a/parser/testdata/corpus/sql/index/art/storage/test_art_wal_checkpoint_minimal.test b/parser/testdata/corpus/sql/index/art/storage/test_art_wal_checkpoint_minimal.test new file mode 100644 index 0000000..b66c695 --- /dev/null +++ b/parser/testdata/corpus/sql/index/art/storage/test_art_wal_checkpoint_minimal.test @@ -0,0 +1,29 @@ +# source: test/sql/index/art/storage/test_art_wal_checkpoint_minimal.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +CREATE TABLE minimal_tbl(i INTEGER); +-- +ok +== +CREATE UNIQUE INDEX idx_minimal ON minimal_tbl(i); +-- +ok +== +INSERT INTO minimal_tbl VALUES (42); +-- +ok +== +INSERT INTO minimal_tbl VALUES (43); +-- +ok +== +INSERT INTO minimal_tbl VALUES (44); +-- +ok +== +DELETE FROM minimal_tbl where i = 42 +-- +ok +== diff --git a/parser/testdata/corpus/sql/index/art/storage/test_art_wal_replay_drop_table.test b/parser/testdata/corpus/sql/index/art/storage/test_art_wal_replay_drop_table.test new file mode 100644 index 0000000..df65bc8 --- /dev/null +++ b/parser/testdata/corpus/sql/index/art/storage/test_art_wal_replay_drop_table.test @@ -0,0 +1,41 @@ +# source: test/sql/index/art/storage/test_art_wal_replay_drop_table.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +INSERT INTO test SELECT range + 42 FROM range(100); +-- +ok +== +CREATE TABLE alter_test (a INTEGER); +-- +ok +== +INSERT INTO alter_test SELECT range + 42 FROM range(100); +-- +ok +== +CREATE INDEX other_idx ON test(a); +-- +ok +== +INSERT INTO test VALUES (0), (1); +-- +ok +== +INSERT INTO alter_test VALUES (0), (1); +-- +ok +== +CREATE UNIQUE INDEX i_index ON test(a); +-- +ok +== +ALTER TABLE alter_test ADD PRIMARY KEY(a); +-- +ok +== +DROP TABLE alter_test; +-- +ok +== diff --git a/parser/testdata/corpus/sql/index/art/storage/test_art_wal_replay_in_tx.test b/parser/testdata/corpus/sql/index/art/storage/test_art_wal_replay_in_tx.test new file mode 100644 index 0000000..0b6004c --- /dev/null +++ b/parser/testdata/corpus/sql/index/art/storage/test_art_wal_replay_in_tx.test @@ -0,0 +1,49 @@ +# source: test/sql/index/art/storage/test_art_wal_replay_in_tx.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +CREATE TABLE drop_test (a INTEGER); +-- +ok +== +INSERT INTO drop_test SELECT range + 42 FROM range(100); +-- +ok +== +INSERT INTO drop_test VALUES (0), (1); +-- +ok +== +CREATE INDEX drop_idx ON drop_test(a); +-- +ok +== +DROP INDEX drop_idx; +-- +ok +== +DELETE FROM test WHERE a = 1; +-- +ok +== +DELETE FROM alter_test WHERE a = 1; +-- +ok +== +INSERT INTO test VALUES (0); +-- +ok +== +INSERT INTO alter_test VALUES (0); +-- +ok +== +INSERT INTO alter_test VALUES (1); +-- +ok +== +CREATE INDEX drop_idx ON test(a); +-- +ok +== diff --git a/parser/testdata/corpus/sql/index/art/storage/test_art_wal_replay_with_buffer.test b/parser/testdata/corpus/sql/index/art/storage/test_art_wal_replay_with_buffer.test new file mode 100644 index 0000000..5f22391 --- /dev/null +++ b/parser/testdata/corpus/sql/index/art/storage/test_art_wal_replay_with_buffer.test @@ -0,0 +1,25 @@ +# source: test/sql/index/art/storage/test_art_wal_replay_with_buffer.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +CREATE TABLE tbl (u_2 UNION("string" VARCHAR, "bool" BOOLEAN)) +-- +ok +== +CREATE UNIQUE INDEX idx_u_2_1 ON tbl ((u_2.string)); +-- +ok +== +INSERT INTO tbl VALUES ('helloo'); +-- +ok +== +INSERT INTO tbl VALUES ('hellooo'); +-- +ok +== +SELECT * FROM tbl ORDER BY ALL; +-- +ok +== diff --git a/parser/testdata/corpus/sql/index/art/storage/test_art_wal_replay_with_buffer_concurrent.test b/parser/testdata/corpus/sql/index/art/storage/test_art_wal_replay_with_buffer_concurrent.test new file mode 100644 index 0000000..f601282 --- /dev/null +++ b/parser/testdata/corpus/sql/index/art/storage/test_art_wal_replay_with_buffer_concurrent.test @@ -0,0 +1,29 @@ +# source: test/sql/index/art/storage/test_art_wal_replay_with_buffer_concurrent.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +CREATE UNIQUE INDEX idx_1 ON tbl ((u_2.string)); +-- +ok +== +CREATE UNIQUE INDEX idx_2 ON tbl ((u_2.string)); +-- +ok +== +CREATE UNIQUE INDEX idx_3 ON tbl ((u_2.string)); +-- +ok +== +CREATE UNIQUE INDEX idx_4 ON tbl ((u_2.string)); +-- +ok +== +CREATE UNIQUE INDEX idx_5 ON tbl ((u_2.string)); +-- +ok +== +INSERT INTO tbl VALUES ('hellooo_{threadid}'); +-- +ok +== diff --git a/parser/testdata/corpus/sql/index/art/test_art_empty_close_range.test b/parser/testdata/corpus/sql/index/art/test_art_empty_close_range.test new file mode 100644 index 0000000..91c75ea --- /dev/null +++ b/parser/testdata/corpus/sql/index/art/test_art_empty_close_range.test @@ -0,0 +1,13 @@ +# source: test/sql/index/art/test_art_empty_close_range.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +CREATE TABLE t0(c0 DOUBLE UNIQUE); +-- +ok +== +SELECT c0 FROM t0 WHERE (c0 - 0 BETWEEN 0 AND 0) AND (c0 - 0 = c0); +-- +ok +== diff --git a/parser/testdata/corpus/sql/index/art/test_art_tx_update_key.test b/parser/testdata/corpus/sql/index/art/test_art_tx_update_key.test new file mode 100644 index 0000000..f26a1f7 --- /dev/null +++ b/parser/testdata/corpus/sql/index/art/test_art_tx_update_key.test @@ -0,0 +1,25 @@ +# source: test/sql/index/art/test_art_tx_update_key.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +CREATE TABLE test_table (id INTEGER PRIMARY KEY) +-- +ok +== +INSERT INTO test_table VALUES (1) +-- +ok +== +SELECT id FROM test_table LIMIT 1 +-- +ok +== +UPDATE test_table SET id = 1 WHERE id = 1 +-- +ok +== +SELECT rowid FROM test_table LIMIT 1 +-- +ok +== diff --git a/parser/testdata/corpus/sql/index/art/test_index_key_rebind.test b/parser/testdata/corpus/sql/index/art/test_index_key_rebind.test new file mode 100644 index 0000000..bfcde3c --- /dev/null +++ b/parser/testdata/corpus/sql/index/art/test_index_key_rebind.test @@ -0,0 +1,33 @@ +# source: test/sql/index/art/test_index_key_rebind.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +CREATE TABLE t(a INTEGER); +-- +ok +== +CREATE INDEX idx ON t USING ART(a); +-- +ok +== +INSERT INTO t VALUES (1), (2), (3); +-- +ok +== +PREPARE stmt AS SELECT index_key({'table': 't'}, 'idx', CAST(random() * 0 AS INTEGER) + 42); +-- +ok +== +EXECUTE stmt; +-- +ok +== +DROP INDEX idx; +-- +ok +== +EXECUTE stmt +-- +ok +== diff --git a/parser/testdata/corpus/sql/index/art/types/test_art_boolean.test b/parser/testdata/corpus/sql/index/art/types/test_art_boolean.test new file mode 100644 index 0000000..3007f97 --- /dev/null +++ b/parser/testdata/corpus/sql/index/art/types/test_art_boolean.test @@ -0,0 +1,17 @@ +# source: test/sql/index/art/types/test_art_boolean.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +CREATE TABLE t0(c0 BOOLEAN, c1 INT) +-- +ok +== +CREATE INDEX i0 ON t0(c1, c0) +-- +ok +== +INSERT INTO t0(c1) VALUES (0) +-- +ok +== diff --git a/parser/testdata/corpus/sql/index/art/types/test_art_coverage_types.test b/parser/testdata/corpus/sql/index/art/types/test_art_coverage_types.test new file mode 100644 index 0000000..b52b4e2 --- /dev/null +++ b/parser/testdata/corpus/sql/index/art/types/test_art_coverage_types.test @@ -0,0 +1,109 @@ +# source: test/sql/index/art/types/test_art_coverage_types.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +CREATE TABLE duplicate_id (id UINT32, id2 INT64); +-- +ok +== +INSERT INTO duplicate_id SELECT range, range FROM range (0, 2048, 1); +-- +ok +== +INSERT INTO duplicate_id VALUES (2047, 2047); +-- +ok +== +CREATE UNIQUE INDEX idx ON duplicate_id(id, id2); +-- +ok +== +DROP TABLE duplicate_id; +-- +ok +== +CREATE TABLE int128_first (id INT128, id2 INT128); +-- +ok +== +INSERT INTO int128_first SELECT range, range FROM range(5000); +-- +ok +== +CREATE UNIQUE INDEX idx_1 ON int128_first(id, id2); +-- +ok +== +CREATE TABLE uint8_first (id UINT8, id2 UINT8); +-- +ok +== +INSERT INTO uint8_first SELECT range, range FROM range(128); +-- +ok +== +CREATE INDEX idx_2 ON uint8_first(id, id2); +-- +ok +== +CREATE TABLE uint64_first (id UINT64, id2 UINT32, id3 UINT64, id4 FLOAT); +-- +ok +== +INSERT INTO uint64_first SELECT range, range, range, 0.456 + range FROM range(5000); +-- +ok +== +CREATE INDEX idx_3 ON uint64_first(id, id2, id3, id4); +-- +ok +== +CREATE TABLE int128_point AS SELECT range::INT128 AS id FROM range(5000); +-- +ok +== +CREATE INDEX idx_int128_point ON int128_point(id); +-- +ok +== +SELECT id FROM int128_point WHERE id = 2048; +-- +ok +== +CREATE TABLE uint64_point AS SELECT range::UINT64 AS id FROM range(5000); +-- +ok +== +CREATE INDEX idx_uint64_point ON uint64_point(id); +-- +ok +== +SELECT id FROM uint64_point WHERE id = 2048; +-- +ok +== +CREATE TABLE uint32_point AS SELECT range::UINT32 AS id FROM range(5000); +-- +ok +== +CREATE INDEX idx_uint32_point ON uint32_point(id); +-- +ok +== +SELECT id FROM uint32_point WHERE id = 2048; +-- +ok +== +CREATE TABLE uint8_point AS SELECT range::UINT8 AS id FROM range(128); +-- +ok +== +CREATE INDEX idx_uint8_point ON uint8_point(id); +-- +ok +== +SELECT id FROM uint8_point WHERE id = 100; +-- +ok +== diff --git a/parser/testdata/corpus/sql/index/art/types/test_art_double.test b/parser/testdata/corpus/sql/index/art/types/test_art_double.test new file mode 100644 index 0000000..c267120 --- /dev/null +++ b/parser/testdata/corpus/sql/index/art/types/test_art_double.test @@ -0,0 +1,29 @@ +# source: test/sql/index/art/types/test_art_double.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +CREATE TABLE numbers(i DOUBLE) +-- +ok +== +INSERT INTO numbers VALUES (CAST(0 AS DOUBLE)) +-- +ok +== +INSERT INTO numbers VALUES (CAST(-0 AS DOUBLE)) +-- +ok +== +CREATE INDEX i_index ON numbers(i) +-- +ok +== +SELECT COUNT(i) FROM numbers WHERE i = CAST(0 AS DOUBLE) +-- +ok +== +SELECT COUNT(i) FROM numbers WHERE i = CAST(-0 AS DOUBLE) +-- +ok +== diff --git a/parser/testdata/corpus/sql/index/art/types/test_art_expression_key.test b/parser/testdata/corpus/sql/index/art/types/test_art_expression_key.test new file mode 100644 index 0000000..e3c5c68 --- /dev/null +++ b/parser/testdata/corpus/sql/index/art/types/test_art_expression_key.test @@ -0,0 +1,45 @@ +# source: test/sql/index/art/types/test_art_expression_key.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +CREATE TABLE integers(i BIGINT, j INTEGER, k VARCHAR, l BIGINT) +-- +ok +== +CREATE INDEX i_index ON integers using art((j+l)) +-- +ok +== +INSERT INTO integers VALUES (10, 1, 'hello', 4), (11, 2, 'world', 6) +-- +ok +== +SELECT * FROM integers WHERE j+l=5 +-- +ok +== +UPDATE integers SET j=5, l=l WHERE j=1 +-- +ok +== +UPDATE integers SET j=5 WHERE j=5 +-- +ok +== +SELECT * FROM integers WHERE j+l=9 +-- +ok +== +DELETE FROM integers WHERE j+l=8 +-- +ok +== +DELETE FROM integers WHERE j+l=9 +-- +ok +== +SELECT COUNT(*) FROM integers WHERE j+l>0 +-- +ok +== diff --git a/parser/testdata/corpus/sql/index/art/types/test_art_integer_types.test b/parser/testdata/corpus/sql/index/art/types/test_art_integer_types.test new file mode 100644 index 0000000..2ca0883 --- /dev/null +++ b/parser/testdata/corpus/sql/index/art/types/test_art_integer_types.test @@ -0,0 +1,89 @@ +# source: test/sql/index/art/types/test_art_integer_types.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +CREATE TABLE integers(i TINYINT, j SMALLINT, k INTEGER, l BIGINT) +-- +ok +== +CREATE INDEX i_index1 ON integers(i) +-- +ok +== +CREATE INDEX i_index2 ON integers(j) +-- +ok +== +CREATE INDEX i_index3 ON integers(k) +-- +ok +== +CREATE INDEX i_index4 ON integers(l) +-- +ok +== +SELECT i FROM integers WHERE i > 0 +-- +ok +== +SELECT j FROM integers WHERE j < 0 +-- +ok +== +SELECT k FROM integers WHERE k >= 0 +-- +ok +== +SELECT l FROM integers WHERE l <= 0 +-- +ok +== +INSERT INTO integers VALUES (1,1,1,1) +-- +ok +== +INSERT INTO integers VALUES (2,2,2,2) +-- +ok +== +INSERT INTO integers VALUES (3,3,3,3) +-- +ok +== +INSERT INTO integers VALUES (4,4,4,4) +-- +ok +== +INSERT INTO integers VALUES (5,5,5,5) +-- +ok +== +SELECT i FROM integers WHERE i > 0::TINYINT ORDER BY i +-- +ok +== +SELECT j FROM integers WHERE j <= 2::SMALLINT ORDER BY j +-- +ok +== +SELECT k FROM integers WHERE k >= -100000::INTEGER ORDER BY k +-- +ok +== +SELECT k FROM integers WHERE k >= 100000::INTEGER ORDER BY k +-- +ok +== +SELECT k FROM integers WHERE k >= 100000::INTEGER AND k <= 100001::INTEGER ORDER BY k +-- +ok +== +SELECT l FROM integers WHERE l <= 1000000000::BIGINT ORDER BY i +-- +ok +== +SELECT l FROM integers WHERE l <= -1000000000::BIGINT ORDER BY i +-- +ok +== diff --git a/parser/testdata/corpus/sql/index/art/types/test_art_real.test b/parser/testdata/corpus/sql/index/art/types/test_art_real.test new file mode 100644 index 0000000..05f25b0 --- /dev/null +++ b/parser/testdata/corpus/sql/index/art/types/test_art_real.test @@ -0,0 +1,25 @@ +# source: test/sql/index/art/types/test_art_real.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +CREATE TABLE numbers(i REAL) +-- +ok +== +INSERT INTO numbers VALUES (CAST(0 AS REAL)) +-- +ok +== +INSERT INTO numbers VALUES (CAST(-0 AS REAL)) +-- +ok +== +SELECT COUNT(i) FROM numbers WHERE i = CAST(0 AS REAL) +-- +ok +== +SELECT COUNT(i) FROM numbers WHERE i = CAST(-0 AS REAL) +-- +ok +== diff --git a/parser/testdata/corpus/sql/index/art/types/test_art_real_pk.test b/parser/testdata/corpus/sql/index/art/types/test_art_real_pk.test new file mode 100644 index 0000000..a397d0f --- /dev/null +++ b/parser/testdata/corpus/sql/index/art/types/test_art_real_pk.test @@ -0,0 +1,25 @@ +# source: test/sql/index/art/types/test_art_real_pk.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +CREATE TABLE numbers(i REAL PRIMARY KEY, j INTEGER) +-- +ok +== +INSERT INTO numbers VALUES (3.45, 4), (3.45, 5) +-- +ok +== +INSERT INTO numbers VALUES (3.45, 4), (2.2, 5) +-- +ok +== +INSERT INTO numbers VALUES (6, 6), (3.45, 4); +-- +ok +== +INSERT INTO numbers VALUES (6, 6); +-- +ok +== diff --git a/parser/testdata/corpus/sql/index/art/types/test_art_union.test b/parser/testdata/corpus/sql/index/art/types/test_art_union.test new file mode 100644 index 0000000..1ed34ba --- /dev/null +++ b/parser/testdata/corpus/sql/index/art/types/test_art_union.test @@ -0,0 +1,117 @@ +# source: test/sql/index/art/types/test_art_union.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +CREATE TABLE tbl ( + u_2 UNION("string" VARCHAR, "bool" BOOLEAN), + u_1 UNION("string" VARCHAR), + i INTEGER, + u_list UNION("int" INTEGER, "list" INTEGER[], "bool" BOOLEAN)); +-- +ok +== +INSERT INTO tbl VALUES + ('hello', 'world', 42, [1, 2, 3]), + (NULL, NULL, NULL, NULL), + (true, NULL, 44, 45), + (false, 'wazzup', false, [1]); +-- +ok +== +CREATE INDEX idx_u_2 ON tbl (u_2); +-- +ok +== +CREATE INDEX idx_u_1 ON tbl (u_1); +-- +ok +== +CREATE INDEX idx_i ON tbl (i); +-- +ok +== +DROP INDEX idx_i; +-- +ok +== +CREATE INDEX idx_u_list ON tbl (u_list); +-- +ok +== +CREATE INDEX idx_u_list ON tbl (i, u_list); +-- +ok +== +CREATE UNIQUE INDEX idx_u_2_2 ON tbl ((u_2.bool)); +-- +ok +== +CREATE UNIQUE INDEX idx_u_1 ON tbl ((u_1.string)); +-- +ok +== +CREATE UNIQUE INDEX idx_list_1 ON tbl ((u_list.int)); +-- +ok +== +CREATE UNIQUE INDEX idx_list_2 ON tbl ((u_list.list)); +-- +ok +== +CREATE UNIQUE INDEX idx_list_3 ON tbl ((u_list.bool)); +-- +ok +== +INSERT INTO tbl VALUES ('helloo', 'worldd', 43, [1, 2, 3, 4]); +-- +ok +== +SELECT u_1.string FROM tbl WHERE u_2 = 'helloo'; +-- +ok +== +INSERT INTO tbl VALUES ('helloo', 'nop', 7, true); +-- +ok +== +DROP INDEX idx_u_2_1; +-- +ok +== +DROP INDEX idx_u_2_2; +-- +ok +== +DROP INDEX idx_u_1; +-- +ok +== +DROP INDEX idx_list_1; +-- +ok +== +DROP INDEX idx_list_3; +-- +ok +== +CREATE UNIQUE INDEX idx_c_1 ON tbl ((u_2.string), (u_1.string)); +-- +ok +== +CREATE INDEX idx_c_fail ON tbl ((u_2.string), u_list); +-- +ok +== +CREATE UNIQUE INDEX idx_c_2 ON tbl ((u_list.int), (u_1.string), (u_2.bool)); +-- +ok +== +INSERT INTO tbl VALUES ('sunshine', 'love', 85, true); +-- +ok +== +SELECT u_list.bool FROM tbl WHERE u_1.string = 'love'; +-- +ok +== diff --git a/parser/testdata/corpus/sql/index/art/types/test_art_varchar.test b/parser/testdata/corpus/sql/index/art/types/test_art_varchar.test new file mode 100644 index 0000000..899d817 --- /dev/null +++ b/parser/testdata/corpus/sql/index/art/types/test_art_varchar.test @@ -0,0 +1,44 @@ +# source: test/sql/index/art/types/test_art_varchar.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +CREATE TABLE strings(i varchar); +-- +ok +== +CREATE INDEX i_index ON strings(i); +-- +ok +== +INSERT INTO strings VALUES ('test'), ('test1'), ('vest1'), ('somesuperbigstring'), ('somesuperbigstring1'), + ('somesuperbigstring2'), ('somesuperbigstring'), ('maybesomesuperbigstring'), + ('maybesomesuperbigstringmaybesomesuperbigstringmaybesomesuperbigstringmaybesomesuperbigstringmaybesomesuperbigstringmaybesomesuperbigstringmaybesomesuperbigstring'), + ('maybesomesuperbigstringmaybesomesuperbigstringmaybesomesuperbigstringmaybesomesuperbigstringmaybesomesuperbigstringmaybesomesuperbigstringmaybesomesuperbigstring2'); +-- +ok +== +SELECT COUNT(i) FROM strings WHERE i = 'test'; +-- +ok +== +SELECT COUNT(i) FROM strings WHERE i = 'somesuperbigstring'; +-- +ok +== +SELECT COUNT(i) FROM strings WHERE i = 'maybesomesuperbigstringmaybesomesuperbigstringmaybesomesuperbigstringmaybesomesuperbigstringmaybesomesuperbigstringmaybesomesuperbigstringmaybesomesuperbigstring'; +-- +ok +== +SELECT COUNT(i) FROM strings WHERE i = 'maybesomesuperbigstringmaybesomesuperbigstringmaybesomesuperbigstringmaybesomesuperbigstringmaybesomesuperbigstringmaybesomesuperbigstringmaybesomesuperbigstring2'; +-- +ok +== +SELECT COUNT(i) FROM strings WHERE i >= 'somesuperbigstring' and i <='somesuperbigstringz'; +-- +ok +== +SELECT COUNT(i) FROM strings WHERE i = 'somesuperthisdoesnotexist'; +-- +ok +== diff --git a/parser/testdata/corpus/sql/index/art/vacuum/test_art_vacuum_rollback.test b/parser/testdata/corpus/sql/index/art/vacuum/test_art_vacuum_rollback.test new file mode 100644 index 0000000..acc9a46 --- /dev/null +++ b/parser/testdata/corpus/sql/index/art/vacuum/test_art_vacuum_rollback.test @@ -0,0 +1,29 @@ +# source: test/sql/index/art/vacuum/test_art_vacuum_rollback.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +CREATE TABLE t{i}(i INTEGER UNIQUE); +-- +error: Parser Error: syntax error at or near "{" +== +INSERT INTO t{i} SELECT CASE WHEN i%2<>0 THEN NULL ELSE i END FROM range(10000) t(i); +-- +error: Parser Error: syntax error at or near "{" +== +INSERT INTO t{i} FROM range(10000, 10077); +-- +error: Parser Error: syntax error at or near "{" +== +INSERT INTO t7 VALUES (42); +-- +ok +== +SELECT COUNT(i) - (CASE WHEN {i}==7 THEN 1 ELSE 0 END) FROM t{i} +-- +error: Parser Error: syntax error at or near "}" +== +INSERT INTO t{i} FROM range(20000, 30000); +-- +error: Parser Error: syntax error at or near "{" +== diff --git a/parser/testdata/corpus/sql/index/create_index_options.test b/parser/testdata/corpus/sql/index/create_index_options.test new file mode 100644 index 0000000..8b9de39 --- /dev/null +++ b/parser/testdata/corpus/sql/index/create_index_options.test @@ -0,0 +1,17 @@ +# source: test/sql/index/create_index_options.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +CREATE TABlE t1 (foo INT) +-- +ok +== +CREATE INDEX i3 ON t1 USING random_index_method (foo) WITH (my_option = 2, is_cool); +-- +ok +== +CREATE INDEX i3 ON t1 USING random_index_method (foo) WITH (my_option = getenv('some_env_variable'), is_cool); +-- +ok +== diff --git a/parser/testdata/corpus/sql/insert/insert_by_name.test b/parser/testdata/corpus/sql/insert/insert_by_name.test new file mode 100644 index 0000000..5d798fe --- /dev/null +++ b/parser/testdata/corpus/sql/insert/insert_by_name.test @@ -0,0 +1,158 @@ +# source: test/sql/insert/insert_by_name.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +INSERT INTO integers BY NAME SELECT 42 AS j +-- +ok +== +INSERT INTO integers BY NAME SELECT 84 AS i +-- +ok +== +INSERT INTO integers BY NAME SELECT 99 AS j, 9 AS i +-- +ok +== +INSERT INTO integers BY POSITION SELECT 1 AS j, 10 AS i +-- +ok +== +CREATE TABLE "My Table"("My Column 1" INT, "My Column 2" INT); +-- +ok +== +INSERT INTO "My Table" BY NAME SELECT 1 AS "My Column 2" +-- +ok +== +FROM "My Table" +-- +ok +== +INSERT INTO integers BY NAME SELECT 1 AS xxx +-- +ok +== +INSERT INTO integers BY NAME SELECT 1 AS i, 2 AS i +-- +ok +== +INSERT INTO integers (i, i) SELECT 1, 2 +-- +ok +== +INSERT INTO integers BY NAME SELECT 1 AS rowid +-- +ok +== +INSERT INTO tbl BY NAME SELECT 1 AS total_price +-- +ok +== +INSERT INTO integers BY NAME VALUES (42, 84); +-- +ok +== +INSERT INTO integers BY NAME (i) SELECT 1 AS j +-- +ok +== +INSERT INTO integers BY POSITION VALUES (42, 84); +-- +ok +== +CREATE TABLE tbl2 (a INTEGER, b INTEGER PRIMARY KEY); +-- +ok +== +INSERT INTO tbl2 BY NAME (SELECT 22 AS b); +-- +ok +== +FROM tbl2 +-- +ok +== +INSERT OR REPLACE INTO tbl2 BY NAME (SELECT 22 AS b); +-- +ok +== +INSERT OR REPLACE INTO tbl2 BY NAME (SELECT 22 AS b, 1 as a); +-- +ok +== +CREATE TABLE struct_defaults_by_name( + i ROW( + a INT, + b INT, + c INT + ) DEFAULT ( + { + 'a': 7 + } + ), + j INT DEFAULT 42, + k INT DEFAULT 99 +); +-- +ok +== +INSERT INTO struct_defaults_by_name BY NAME SELECT {'b': 12} AS i, 10 AS k; +-- +ok +== +INSERT INTO struct_defaults_by_name BY NAME SELECT {'a': 11} AS i; +-- +ok +== +SELECT * FROM struct_defaults_by_name ORDER BY k, i.a NULLS LAST +-- +ok +== +CREATE TABLE nested_struct_defaults_by_name( + i ROW( + a INT, + n ROW( + x INT, + y INT, + z INT + ), + b INT + ) DEFAULT ( + { + 'n': { + 'y': 3 + } + } + ), + j INT DEFAULT 42 +); +-- +ok +== +INSERT INTO nested_struct_defaults_by_name BY NAME SELECT {'n': {'x': 10}} AS i; +-- +ok +== +SELECT * FROM nested_struct_defaults_by_name +-- +ok +== +CREATE TABLE tbl3 (id INTEGER PRIMARY KEY); +-- +ok +== +INSERT INTO tbl3 SELECT * FROM range(1000000) t(id); +-- +ok +== +INSERT OR REPLACE INTO tbl3 BY NAME SELECT * FROM range(1000000) t(id); +-- +ok +== +SELECT COUNT(*) FROM tbl3; +-- +ok +== diff --git a/parser/testdata/corpus/sql/insert/insert_from_many_grouping_sets.test b/parser/testdata/corpus/sql/insert/insert_from_many_grouping_sets.test new file mode 100644 index 0000000..76f8e9d --- /dev/null +++ b/parser/testdata/corpus/sql/insert/insert_from_many_grouping_sets.test @@ -0,0 +1,37 @@ +# source: test/sql/insert/insert_from_many_grouping_sets.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +CREATE TABLE integers AS SELECT i, i%2 as j FROM generate_series(0,999999,1) tbl(i); +-- +ok +== +CREATE TABLE integers2 AS SELECT * FROM integers GROUP BY GROUPING SETS ((), (i), (i, j), (j)); +-- +ok +== +SELECT SUM(i), SUM(j), COUNT(*), COUNT(i), COUNT(j) FROM integers; +-- +ok +== +SELECT SUM(i), SUM(j), COUNT(*), COUNT(i), COUNT(j) FROM integers2; +-- +ok +== +DROP TABLE integers2; +-- +ok +== +CREATE TABLE integers AS SELECT case when i%2=0 then null else i end AS i, i%2 as j FROM generate_series(0,999999,1) tbl(i); +-- +ok +== +SELECT SUM(i), SUM(j), COUNT(*), COUNT(i), COUNT(j) FROM integers +-- +ok +== +SELECT SUM(i), SUM(j), COUNT(*), COUNT(i), COUNT(j) FROM integers2 +-- +ok +== diff --git a/parser/testdata/corpus/sql/insert/insert_query_node.test b/parser/testdata/corpus/sql/insert/insert_query_node.test new file mode 100644 index 0000000..f9dee6e --- /dev/null +++ b/parser/testdata/corpus/sql/insert/insert_query_node.test @@ -0,0 +1,106 @@ +# source: test/sql/insert/insert_query_node.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +INSERT INTO t (a, b, c) VALUES (3, 'foo', 3.5); +-- +ok +== +SELECT * FROM t WHERE a = 3; +-- +ok +== +INSERT INTO t VALUES (4, 'bar', 4.5) RETURNING a, b, c; +-- +ok +== +WITH vals AS (SELECT 5 AS a, 'cte' AS b, 5.5 AS c) +INSERT INTO t SELECT * FROM vals RETURNING a; +-- +ok +== +SELECT * FROM t WHERE a = 5; +-- +ok +== +CREATE TABLE t2(x INT DEFAULT 42, y TEXT DEFAULT 'default'); +-- +ok +== +INSERT INTO t2 DEFAULT VALUES; +-- +ok +== +CREATE TABLE t3(a INT, b TEXT, c DOUBLE); +-- +ok +== +INSERT INTO t3 SELECT * FROM t WHERE a <= 2; +-- +ok +== +SELECT * FROM t3 ORDER BY a; +-- +ok +== +CREATE TABLE myschema.t4(x INT); +-- +ok +== +INSERT INTO myschema.t4 VALUES (1), (2), (3); +-- +ok +== +SELECT * FROM myschema.t4; +-- +ok +== +CREATE TABLE t5(id INT PRIMARY KEY, val TEXT); +-- +ok +== +INSERT INTO t5 VALUES (1, 'original'); +-- +ok +== +INSERT OR REPLACE INTO t5 VALUES (1, 'replaced'); +-- +ok +== +SELECT * FROM t5; +-- +ok +== +CREATE TABLE t6(a INT, b TEXT, c DOUBLE); +-- +ok +== +INSERT INTO t6 BY NAME SELECT 3.14 AS c, 'hello' AS b, 42 AS a; +-- +ok +== +SELECT * FROM t6; +-- +ok +== +CREATE TABLE t7(id INT PRIMARY KEY, val TEXT); +-- +ok +== +INSERT INTO t7 VALUES (1, 'first'); +-- +ok +== +INSERT INTO t7 VALUES (1, 'duplicate') ON CONFLICT DO NOTHING; +-- +ok +== +SELECT * FROM t7; +-- +ok +== +INSERT INTO t7 VALUES (1, 'updated') ON CONFLICT (id) DO UPDATE SET val = excluded.val; +-- +ok +== diff --git a/parser/testdata/corpus/sql/insert/insert_rollback.test b/parser/testdata/corpus/sql/insert/insert_rollback.test new file mode 100644 index 0000000..e6061d5 --- /dev/null +++ b/parser/testdata/corpus/sql/insert/insert_rollback.test @@ -0,0 +1,9 @@ +# source: test/sql/insert/insert_rollback.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +INSERT INTO integers VALUES (0), (1), (2) +-- +ok +== diff --git a/parser/testdata/corpus/sql/insert/null_values.test b/parser/testdata/corpus/sql/insert/null_values.test new file mode 100644 index 0000000..c54677d --- /dev/null +++ b/parser/testdata/corpus/sql/insert/null_values.test @@ -0,0 +1,21 @@ +# source: test/sql/insert/null_values.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +INSERT INTO integers SELECT i FROM range(100) tbl(i); +-- +ok +== +INSERT INTO integers SELECT NULL FROM range(100) tbl(i); +-- +ok +== +SELECT COUNT(i), SUM(i), MIN(i), MAX(i), COUNT(*) FROM integers +-- +ok +== +SELECT SUM(CASE WHEN i IS NULL THEN 1 ELSE 0 END) FROM integers +-- +ok +== diff --git a/parser/testdata/corpus/sql/insert/test_big_insert.test b/parser/testdata/corpus/sql/insert/test_big_insert.test new file mode 100644 index 0000000..6a9e388 --- /dev/null +++ b/parser/testdata/corpus/sql/insert/test_big_insert.test @@ -0,0 +1,29 @@ +# source: test/sql/insert/test_big_insert.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +INSERT INTO integers VALUES (0), (1), (2), (3), (4), (5), (6), (7), (8), (9), (0), (1), (2), (3), (4), (5), (6), (7), (8), (9), (0), (1), (2), (3), (4), (5), (6), (7), (8), (9), (0), (1), (2), (3), (4), (5), (6), (7), (8), (9), (0), (1), (2), (3), (4), (5), (6), (7), (8), (9), (0), (1), (2), (3), (4), (5), (6), (7), (8), (9), (0), (1), (2), (3), (4), (5), (6), (7), (8), (9), (0), (1), (2), (3), (4), (5), (6), (7), (8), (9), (0), (1), (2), (3), (4), (5), (6), (7), (8), (9), (0), (1), (2), (3), (4), (5), (6), (7), (8), (9), (0), (1), (2), (3), (4), (5), (6), (7), (8), (9), (0), (1), (2), (3), (4), (5), (6), (7), (8), (9), (0), (1), (2), (3), (4), (5), (6), (7), (8), (9), (0), (1), (2), (3), (4), (5), (6), (7), (8), (9), (0), (1), (2), (3), (4), (5), (6), (7), (8), (9), (0), (1), (2), (3), (4), (5), (6), (7), (8), (9), (0), (1), (2), (3), (4), (5), (6), (7), (8), (9), (0), (1), (2), (3), (4), (5), (6), (7), (8), (9), (0), (1), (2), (3), (4), (5), (6), (7), (8), (9), (0), (1), (2), (3), (4), (5), (6), (7), (8), (9), (0), (1), (2), (3), (4), (5), (6), (7), (8), (9), (0), (1), (2), (3), (4), (5), (6), (7), (8), (9), (0), (1), (2), (3), (4), (5), (6), (7), (8), (9), (0), (1), (2), (3), (4), (5), (6), (7), (8), (9), (0), (1), (2), (3), (4), (5), (6), (7), (8), (9), (0), (1), (2), (3), (4), (5), (6), (7), (8), (9), (0), (1), (2), (3), (4), (5), (6), (7), (8), (9), (0), (1), (2), (3), (4), (5), (6), (7), (8), (9), (0), (1), (2), (3), (4), (5), (6), (7), (8), (9), (0), (1), (2), (3), (4), (5), (6), (7), (8), (9), (0), (1), (2), (3), (4), (5), (6), (7), (8), (9), (0), (1), (2), (3), (4), (5), (6), (7), (8), (9), (0), (1), (2), (3), (4), (5), (6), (7), (8), (9), (0), (1), (2), (3), (4), (5), (6), (7), (8), (9), (0), (1), (2), (3), (4), (5), (6), (7), (8), (9), (0), (1), (2), (3), (4), (5), (6), (7), (8), (9), (0), (1), (2), (3), (4), (5), (6), (7), (8), (9), (0), (1), (2), (3), (4), (5), (6), (7), (8), (9), (0), (1), (2), (3), (4), (5), (6), (7), (8), (9), (0), (1), (2), (3), (4), (5), (6), (7), (8), (9), (0), (1), (2), (3), (4), (5), (6), (7), (8), (9), (0), (1), (2), (3), (4), (5), (6), (7), (8), (9), (0), (1), (2), (3), (4), (5), (6), (7), (8), (9), (0), (1), (2), (3), (4), (5), (6), (7), (8), (9), (0), (1), (2), (3), (4), (5), (6), (7), (8), (9), (0), (1), (2), (3), (4), (5), (6), (7), (8), (9), (0), (1), (2), (3), (4), (5), (6), (7), (8), (9), (0), (1), (2), (3), (4), (5), (6), (7), (8), (9), (0), (1), (2), (3), (4), (5), (6), (7), (8), (9), (0), (1), (2), (3), (4), (5), (6), (7), (8), (9), (0), (1), (2), (3), (4), (5), (6), (7), (8), (9), (0), (1), (2), (3), (4), (5), (6), (7), (8), (9), (0), (1), (2), (3), (4), (5), (6), (7), (8), (9), (0), (1), (2), (3), (4), (5), (6), (7), (8), (9), (0), (1), (2), (3), (4), (5), (6), (7), (8), (9), (0), (1), (2), (3), (4), (5), (6), (7), (8), (9), (0), (1), (2), (3), (4), (5), (6), (7), (8), (9), (0), (1), (2), (3), (4), (5), (6), (7), (8), (9), (0), (1), (2), (3), (4), (5), (6), (7), (8), (9), (0), (1), (2), (3), (4), (5), (6), (7), (8), (9), (0), (1), (2), (3), (4), (5), (6), (7), (8), (9), (0), (1), (2), (3), (4), (5), (6), (7), (8), (9), (0), (1), (2), (3), (4), (5), (6), (7), (8), (9), (0), (1), (2), (3), (4), (5), (6), (7), (8), (9), (0), (1), (2), (3), (4), (5), (6), (7), (8), (9), (0), (1), (2), (3), (4), (5), (6), (7), (8), (9), (0), (1), (2), (3), (4), (5), (6), (7), (8), (9), (0), (1), (2), (3), (4), (5), (6), (7), (8), (9), (0), (1), (2), (3), (4), (5), (6), (7), (8), (9), (0), (1), (2), (3), (4), (5), (6), (7), (8), (9), (0), (1), (2), (3), (4), (5), (6), (7), (8), (9), (0), (1), (2), (3), (4), (5), (6), (7), (8), (9), (0), (1), (2), (3), (4), (5), (6), (7), (8), (9), (0), (1), (2), (3), (4), (5), (6), (7), (8), (9), (0), (1), (2), (3), (4), (5), (6), (7), (8), (9), (0), (1), (2), (3), (4), (5), (6), (7), (8), (9), (0), (1), (2), (3), (4), (5), (6), (7), (8), (9), (0), (1), (2), (3), (4), (5), (6), (7), (8), (9), (0), (1), (2), (3), (4), (5), (6), (7), (8), (9), (0), (1), (2), (3), (4), (5), (6), (7), (8), (9), (0), (1), (2), (3), (4), (5), (6), (7), (8), (9), (0), (1), (2), (3), (4), (5), (6), (7), (8), (9), (0), (1), (2), (3), (4), (5), (6), (7), (8), (9), (0), (1), (2), (3), (4), (5), (6), (7), (8), (9), (0), (1), (2), (3), (4), (5), (6), (7), (8), (9), (0), (1), (2), (3), (4), (5), (6), (7), (8), (9), (0), (1), (2), (3), (4), (5), (6), (7), (8), (9), (0), (1), (2), (3), (4), (5), (6), (7), (8), (9), (0), (1), (2), (3), (4), (5), (6), (7), (8), (9), (0), (1), (2), (3), (4), (5), (6), (7), (8), (9), (0), (1), (2), (3), (4), (5), (6), (7), (8), (9), (0), (1), (2), (3), (4), (5), (6), (7), (8), (9), (0), (1), (2), (3), (4), (5), (6), (7), (8), (9), (0), (1), (2), (3), (4), (5), (6), (7), (8), (9), (0), (1), (2), (3), (4), (5), (6), (7), (8), (9), (0), (1), (2), (3), (4), (5), (6), (7), (8), (9), (0), (1), (2), (3), (4), (5), (6), (7), (8), (9), (0), (1), (2), (3), (4), (5), (6), (7), (8), (9), (0), (1), (2), (3), (4), (5), (6), (7), (8), (9), (0), (1), (2), (3), (4), (5), (6), (7), (8), (9), (0), (1), (2), (3), (4), (5), (6), (7), (8), (9), (0), (1), (2), (3), (4), (5), (6), (7), (8), (9), (0), (1), (2), (3), (4), (5), (6), (7), (8), (9), (0), (1), (2), (3), (4), (5), (6), (7), (8), (9), (0), (1), (2), (3), (4), (5), (6), (7), (8), (9), (0), (1), (2), (3), (4), (5), (6), (7), (8), (9), (0), (1), (2), (3), (4), (5), (6), (7), (8), (9), (0), (1), (2), (3), (4), (5), (6), (7), (8), (9), (0), (1), (2), (3), (4), (5), (6), (7), (8), (9), (0), (1), (2), (3), (4), (5), (6), (7), (8), (9), (0), (1), (2), (3), (4), (5), (6), (7), (8), (9), (0), (1), (2), (3), (4), (5), (6), (7), (8), (9), (0), (1), (2), (3), (4), (5), (6), (7), (8), (9), (0), (1), (2), (3), (4), (5), (6), (7), (8), (9), (0), (1), (2), (3), (4), (5), (6), (7), (8), (9), (0), (1), (2), (3), (4), (5), (6), (7), (8), (9), (0), (1), (2), (3), (4), (5), (6), (7), (8), (9), (0), (1), (2), (3), (4), (5), (6), (7), (8), (9), (0), (1), (2), (3), (4), (5), (6), (7), (8), (9), (0), (1), (2), (3), (4), (5), (6), (7), (8), (9), (0), (1), (2), (3), (4), (5), (6), (7), (8), (9), (0), (1), (2), (3), (4), (5), (6), (7), (8), (9), (0), (1), (2), (3), (4), (5), (6), (7), (8), (9), (0), (1), (2), (3), (4), (5), (6), (7), (8), (9), (0), (1), (2), (3), (4), (5), (6), (7), (8), (9), (0), (1), (2), (3), (4), (5), (6), (7), (8), (9), (0), (1), (2), (3), (4), (5), (6), (7), (8), (9), (0), (1), (2), (3), (4), (5), (6), (7), (8), (9), (0), (1), (2), (3), (4), (5), (6), (7), (8), (9), (0), (1), (2), (3), (4), (5), (6), (7), (8), (9), (0), (1), (2), (3), (4), (5), (6), (7), (8), (9), (0), (1), (2), (3), (4), (5), (6), (7), (8), (9), (0), (1), (2), (3), (4), (5), (6), (7), (8), (9), (0), (1), (2), (3), (4), (5), (6), (7), (8), (9), (0), (1), (2), (3), (4), (5), (6), (7), (8), (9), (0), (1), (2), (3), (4), (5), (6), (7), (8), (9), (0), (1), (2), (3), (4), (5), (6), (7), (8), (9), (0), (1), (2), (3), (4), (5), (6), (7), (8), (9), (0), (1), (2), (3), (4), (5), (6), (7), (8), (9), (0), (1), (2), (3), (4), (5), (6), (7), (8), (9), (0), (1), (2), (3), (4), (5), (6), (7), (8), (9), (0), (1), (2), (3), (4), (5), (6), (7), (8), (9), (0), (1), (2), (3), (4), (5), (6), (7), (8), (9), (0), (1), (2), (3), (4), (5), (6), (7), (8), (9), (0), (1), (2), (3), (4), (5), (6), (7), (8), (9), (0), (1), (2), (3), (4), (5), (6), (7), (8), (9), (0), (1), (2), (3), (4), (5), (6), (7), (8), (9), (0), (1), (2), (3), (4), (5), (6), (7), (8), (9), (0), (1), (2), (3), (4), (5), (6), (7), (8), (9), (0), (1), (2), (3), (4), (5), (6), (7), (8), (9), (0), (1), (2), (3), (4), (5), (6), (7), (8), (9), (0), (1), (2), (3), (4), (5), (6), (7), (8), (9), (0), (1), (2), (3), (4), (5), (6), (7), (8), (9), (0), (1), (2), (3), (4), (5), (6), (7), (8), (9), (0), (1), (2), (3), (4), (5), (6), (7), (8), (9), (0), (1), (2), (3), (4), (5), (6), (7), (8), (9), (0), (1), (2), (3), (4), (5), (6), (7), (8), (9), (0), (1), (2), (3), (4), (5), (6), (7), (8), (9), (0), (1), (2), (3), (4), (5), (6), (7), (8), (9), (0), (1), (2), (3), (4), (5), (6), (7), (8), (9), (0), (1), (2), (3), (4), (5), (6), (7), (8), (9), (0), (1), (2), (3), (4), (5), (6), (7), (8), (9), (0), (1), (2), (3), (4), (5), (6), (7), (8), (9), (0), (1), (2), (3), (4), (5), (6), (7), (8), (9), (0), (1), (2), (3), (4), (5), (6), (7), (8), (9), (0), (1), (2), (3), (4), (5), (6), (7), (8), (9), (0), (1), (2), (3), (4), (5), (6), (7), (8), (9), (0), (1), (2), (3), (4), (5), (6), (7), (8), (9), (0), (1), (2), (3), (4), (5), (6), (7), (8), (9), (0), (1), (2), (3), (4), (5), (6), (7), (8), (9), (0), (1), (2), (3), (4), (5), (6), (7), (8), (9), (0), (1), (2), (3), (4), (5), (6), (7), (8), (9), (0), (1), (2), (3), (4), (5), (6), (7), (8), (9), (0), (1), (2), (3), (4), (5), (6), (7), (8), (9), (0), (1), (2), (3), (4), (5), (6), (7), (8), (9), (0), (1), (2), (3), (4), (5), (6), (7), (8), (9), (0), (1), (2), (3), (4), (5), (6), (7), (8), (9), (0), (1), (2), (3), (4), (5), (6), (7), (8), (9), (0), (1), (2), (3), (4), (5), (6), (7), (8), (9), (0), (1), (2), (3), (4), (5), (6), (7), (8), (9), (0), (1), (2), (3), (4), (5), (6), (7), (8), (9), (0), (1), (2), (3), (4), (5), (6), (7), (8), (9), (0), (1), (2), (3), (4), (5), (6), (7), (8), (9), (0), (1), (2), (3), (4), (5), (6), (7), (8), (9), (0), (1), (2), (3), (4), (5), (6), (7), (8), (9), (0), (1), (2), (3), (4), (5), (6), (7), (8), (9), (0), (1), (2), (3), (4), (5), (6), (7), (8), (9), (0), (1), (2), (3), (4), (5), (6), (7), (8), (9), (0), (1), (2), (3), (4), (5), (6), (7), (8), (9), (0), (1), (2), (3), (4), (5), (6), (7), (8), (9), (0), (1), (2), (3), (4), (5), (6), (7), (8), (9), (0), (1), (2), (3), (4), (5), (6), (7), (8), (9), (0), (1), (2), (3), (4), (5), (6), (7), (8), (9), (0), (1), (2), (3), (4), (5), (6), (7), (8), (9), (0), (1), (2), (3), (4), (5), (6), (7), (8), (9), (0), (1), (2), (3), (4), (5), (6), (7), (8), (9), (0), (1), (2), (3), (4), (5), (6), (7), (8), (9), (0), (1), (2), (3), (4), (5), (6), (7), (8), (9), (0), (1), (2), (3), (4), (5), (6), (7), (8), (9), (0), (1), (2), (3), (4), (5), (6), (7), (8), (9), (0), (1), (2), (3), (4), (5), (6), (7), (8), (9), (0), (1), (2), (3), (4), (5), (6), (7), (8), (9), (0), (1), (2), (3), (4), (5), (6), (7), (8), (9), (0), (1), (2), (3), (4), (5), (6), (7), (8), (9), (0), (1), (2), (3), (4), (5), (6), (7), (8), (9) +-- +ok +== +INSERT INTO integers SELECT * FROM integers; +-- +ok +== +INSERT INTO integers VALUES (3, 4), (4, 3); +-- +ok +== +INSERT INTO integers VALUES (DEFAULT, 4); +-- +ok +== +INSERT INTO integers VALUES (DEFAULT+1, 4); +-- +ok +== +INSERT INTO integers (i) SELECT j FROM integers; +-- +ok +== diff --git a/parser/testdata/corpus/sql/insert/test_insert.test b/parser/testdata/corpus/sql/insert/test_insert.test new file mode 100644 index 0000000..2fb53fe --- /dev/null +++ b/parser/testdata/corpus/sql/insert/test_insert.test @@ -0,0 +1,25 @@ +# source: test/sql/insert/test_insert.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +CREATE TABLE i2 AS SELECT 1 AS i FROM integers WHERE i % 2 <> 0 +-- +ok +== +SELECT * FROM i2 ORDER BY 1 +-- +ok +== +UPDATE i2 SET i=NULL +-- +ok +== +CREATE TABLE IF NOT EXISTS presentations(presentation_date Date NOT NULL UNIQUE, author VARCHAR NOT NULL, title VARCHAR NOT NULL, bio VARCHAR, abstract VARCHAR, zoom_link VARCHAR); +-- +ok +== +insert into presentations values ('2020-05-29', 'Eduardo Pena', 'Analytical Query Processing Based on Continuous Compression of Intermediates', NULL, 'Modern in-memory column-stores are widely accepted as the adequate database architecture for the efficient processing of complex analytical queries over large relational data volumes. These systems keep their entire data in main memory and typically employ lightweight compression to address the bottleneck between main memory and CPU. Numerous lightweight compression algorithms have been proposed in the past years, but none of them is suitable in all cases. While lightweight compression is already well established for base data, the efficient representation of intermediate results generated during query processing has attracted insufficient attention so far, although in in-memory systems, accessing intermeFdiates is as expensive as accessing base data. Thus, our vision is a continuous use of lightweight compression for all intermediates in a query execution plan, whereby a suitable compression algorithm should be selected for each intermediate. In this talk, I will provide an overview of our research in the context of this vision, including an experimental survey of lightweight compression algorithms, our compression-enabled processing model, and our compression-aware query optimization strategies.', 'https://zoom.us/j/7845983526'); +-- +ok +== diff --git a/parser/testdata/corpus/sql/insert/test_insert_invalid.test b/parser/testdata/corpus/sql/insert/test_insert_invalid.test new file mode 100644 index 0000000..8fd1728 --- /dev/null +++ b/parser/testdata/corpus/sql/insert/test_insert_invalid.test @@ -0,0 +1,45 @@ +# source: test/sql/insert/test_insert_invalid.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +CREATE TABLE strings(i STRING) +-- +ok +== +INSERT INTO strings VALUES ('�(') +-- +ok +== +SELECT * FROM strings WHERE i = '�(' +-- +ok +== +CREATE TABLE a(i integer, j integer) +-- +ok +== +INSERT INTO a VALUES (1, 2) +-- +ok +== +INSERT INTO a VALUES (1) +-- +ok +== +INSERT INTO a VALUES (1,2,3) +-- +ok +== +INSERT INTO a VALUES (1,2),(3) +-- +error: Parser Error: VALUES lists must all be the same length, expected 2 entries but found a list with 1 entry +== +INSERT INTO a VALUES (1,2),(3,4,5) +-- +error: Parser Error: VALUES lists must all be the same length, expected 2 entries but found a list with 3 entries +== +INSERT INTO a SELECT 42 +-- +ok +== diff --git a/parser/testdata/corpus/sql/insert/test_insert_invalid.test.metadata.json b/parser/testdata/corpus/sql/insert/test_insert_invalid.test.metadata.json new file mode 100644 index 0000000..e022523 --- /dev/null +++ b/parser/testdata/corpus/sql/insert/test_insert_invalid.test.metadata.json @@ -0,0 +1,6 @@ +{ + "todo": { + "0c668fe32f2ac46c": "transformer-raised parser error: upstream rejects in the transformer, not the grammar; expected to clear as transformers land (milestones 3-5)", + "cdd5ec719e153c6e": "transformer-raised parser error: upstream rejects in the transformer, not the grammar; expected to clear as transformers land (milestones 3-5)" + } +} diff --git a/parser/testdata/corpus/sql/insert/test_insert_query.test b/parser/testdata/corpus/sql/insert/test_insert_query.test new file mode 100644 index 0000000..ada7d71 --- /dev/null +++ b/parser/testdata/corpus/sql/insert/test_insert_query.test @@ -0,0 +1,13 @@ +# source: test/sql/insert/test_insert_query.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +INSERT INTO integers SELECT 42 +-- +ok +== +INSERT INTO integers SELECT CAST(NULL AS VARCHAR) +-- +ok +== diff --git a/parser/testdata/corpus/sql/insert/test_insert_type.test b/parser/testdata/corpus/sql/insert/test_insert_type.test new file mode 100644 index 0000000..11e8ea3 --- /dev/null +++ b/parser/testdata/corpus/sql/insert/test_insert_type.test @@ -0,0 +1,29 @@ +# source: test/sql/insert/test_insert_type.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +CREATE TABLE strings(a VARCHAR) +-- +ok +== +INSERT INTO integers VALUES (3), (4), (NULL) +-- +ok +== +INSERT INTO strings SELECT * FROM integers +-- +ok +== +SELECT * FROM strings +-- +ok +== +UPDATE strings SET a=13 WHERE a='3' +-- +ok +== +SELECT * FROM strings ORDER BY cast(a AS INTEGER) +-- +ok +== diff --git a/parser/testdata/corpus/sql/insert/unaligned_interleaved_appends.test b/parser/testdata/corpus/sql/insert/unaligned_interleaved_appends.test new file mode 100644 index 0000000..643fe87 --- /dev/null +++ b/parser/testdata/corpus/sql/insert/unaligned_interleaved_appends.test @@ -0,0 +1,25 @@ +# source: test/sql/insert/unaligned_interleaved_appends.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +INSERT INTO integers SELECT * FROM range(0, 5) +-- +ok +== +INSERT INTO integers SELECT * FROM range(0, 17) +-- +ok +== +INSERT INTO integers SELECT * FROM range(0, 1007) +-- +ok +== +INSERT INTO integers SELECT * FROM range(0, 3020) +-- +ok +== +INSERT INTO integers SELECT * FROM range(0, 3) +-- +ok +== diff --git a/parser/testdata/corpus/sql/join/asof/test_asof_empty_right.test b/parser/testdata/corpus/sql/join/asof/test_asof_empty_right.test new file mode 100644 index 0000000..74c1ea9 --- /dev/null +++ b/parser/testdata/corpus/sql/join/asof/test_asof_empty_right.test @@ -0,0 +1,26 @@ +# source: test/sql/join/asof/test_asof_empty_right.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +select lefttable.x, righttable.y +from (select 1 as x) lefttable +asof left join (select 1 as x, 1 as y limit 0) righttable +on lefttable.x >= righttable.x; +-- +ok +== +select lefttable.x, righttable.y +from (select 1 as x limit 0) lefttable +asof left join (select 1 as x, 1 as y) righttable +on lefttable.x >= righttable.x; +-- +ok +== +select lefttable.x, righttable.y +from (select 1 as x) lefttable +asof join (select 1 as x, 1 as y limit 0) righttable +on lefttable.x >= righttable.x; +-- +ok +== diff --git a/parser/testdata/corpus/sql/join/asof/test_asof_join.test b/parser/testdata/corpus/sql/join/asof/test_asof_join.test new file mode 100644 index 0000000..7b47a6b --- /dev/null +++ b/parser/testdata/corpus/sql/join/asof/test_asof_join.test @@ -0,0 +1,97 @@ +# source: test/sql/join/asof/test_asof_join.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +CREATE TABLE events0 (begin DOUBLE, value INTEGER); +-- +ok +== +INSERT INTO events0 VALUES + (1, 0), + (3, 1), + (6, 2), + (8, 3) +; +-- +ok +== +create table prices("when" timestamp, symbol int, price int); +-- +ok +== +insert into prices values ('2020-01-01 00:00:00', 1, 42); +-- +ok +== +create table trades("when" timestamp, symbol int); +-- +ok +== +insert into trades values ('2020-01-01 00:00:03', 1); +-- +ok +== +PRAGMA asof_loop_join_threshold = {threshold}; +-- +error: Parser Error: syntax error at or near "}" +== +SELECT t.*, p.price +FROM trades t ASOF JOIN prices p + ON t.symbol = p.symbol AND t.when >= p.when; +-- +ok +== +EXPLAIN +SELECT t.*, p.price +FROM trades t ASOF JOIN prices p + ON t.symbol IS NOT DISTINCT FROM p.symbol AND t.when >= p.when; +-- +ok +== +SELECT p.ts, e.value +FROM range(0,10) p(ts) ASOF JOIN events0 e +ON 1 = 1 AND p.ts >= e.begin +ORDER BY p.ts ASC +-- +ok +== +WITH samples AS ( + SELECT col0 AS starts, col1 AS ends + FROM (VALUES + (5, 9), + (10, 13), + (14, 20), + (21, 23) + ) +) +SELECT + s1.starts as s1_starts, + s2.starts as s2_starts, +FROM samples AS s1 ASOF JOIN samples as s2 ON s2.ends >= (s1.ends - 5) +WHERE s1_starts <> s2_starts +ORDER BY ALL +-- +ok +== +SELECT p.ts, e.value +FROM range(0,10) p(ts) ASOF JOIN events0 e +ON p.ts <> e.begin +ORDER BY p.ts ASC +-- +ok +== +SELECT p.ts, e.value +FROM range(0,10) p(ts) ASOF JOIN events0 e +ON p.ts = e.begin +ORDER BY p.ts ASC +-- +ok +== +SELECT p.ts, e.value +FROM range(0,10) p(ts) ASOF JOIN events0 e +ON p.ts >= e.begin AND p.ts >= e.value +ORDER BY p.ts ASC +-- +ok +== diff --git a/parser/testdata/corpus/sql/join/asof/test_asof_join_doubles.test b/parser/testdata/corpus/sql/join/asof/test_asof_join_doubles.test new file mode 100644 index 0000000..e62b3ed --- /dev/null +++ b/parser/testdata/corpus/sql/join/asof/test_asof_join_doubles.test @@ -0,0 +1,213 @@ +# source: test/sql/join/asof/test_asof_join_doubles.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +PRAGMA asof_loop_join_threshold=0; +-- +ok +== +SELECT p.ts, e.value +FROM + range(0,10) p(ts) +JOIN ( + SELECT value, begin, + LEAD(begin, 1, 'infinity'::DOUBLE) OVER (ORDER BY begin ASC) AS end + FROM events0 +) e +ON p.ts >= e.begin AND p.ts < e.end +ORDER BY p.ts ASC +-- +ok +== +SELECT p.ts, e.value +FROM range(0,10) p(ts) ASOF JOIN events0 e +ON p.ts >= e.begin +ORDER BY p.ts ASC +-- +ok +== +SELECT p.begin, e.value +FROM range(0,10) p(begin) ASOF JOIN events0 e +USING (begin) +ORDER BY p.begin ASC +-- +ok +== +SELECT p.ts, e.value +FROM + range(0,10) p(ts) +LEFT JOIN ( + SELECT value, begin, + LEAD(begin, 1, 'infinity'::DOUBLE) OVER (ORDER BY begin ASC) AS end + FROM events0 +) e +ON p.ts >= e.begin AND p.ts < e.end +ORDER BY p.ts ASC NULLS FIRST +-- +ok +== +SELECT p.ts, e.value +FROM range(0,10) p(ts) ASOF LEFT JOIN events0 e +ON p.ts >= e.begin +ORDER BY p.ts ASC NULLS FIRST +-- +ok +== +SELECT p.begin, e.value +FROM range(0,10) p(begin) ASOF LEFT JOIN events0 e +USING (begin) +ORDER BY p.begin ASC NULLS FIRST +-- +ok +== +INSERT INTO events0 VALUES (10, 4); +-- +ok +== +SELECT p.ts, e.value +FROM + range(0,10) p(ts) +RIGHT JOIN ( + SELECT value, begin, + LEAD(begin, 1, 'infinity'::DOUBLE) OVER (ORDER BY begin ASC) AS end + FROM events0 +) e +ON p.ts >= e.begin AND p.ts < e.end +ORDER BY p.ts ASC NULLS LAST +-- +ok +== +SELECT p.ts, e.value +FROM range(0,10) p(ts) ASOF RIGHT JOIN events0 e +ON p.ts >= e.begin +ORDER BY p.ts ASC NULLS LAST +-- +ok +== +SELECT p.begin, e.value +FROM range(0,10) p(begin) ASOF RIGHT JOIN events0 e +USING (begin) +ORDER BY p.begin ASC NULLS LAST +-- +ok +== +CREATE TABLE events (key INTEGER, begin DOUBLE, value INTEGER); +-- +ok +== +INSERT INTO events VALUES + (1, 1, 0), + (1, 3, 1), + (1, 6, 2), + (1, 8, 3), + (2, 0, 10), + (2, 7, 20), + (2, 11, 30), +; +-- +ok +== +CREATE TABLE probes AS + SELECT key, ts + FROM range(1,3) k(key) CROSS JOIN range(0,10) t(ts) +-- +ok +== +SELECT p.key, p.ts, e.value +FROM + probes p +JOIN ( + SELECT key, value, begin, + LEAD(begin, 1, 'infinity'::DOUBLE) OVER (PARTITION BY key ORDER BY begin ASC) AS end + FROM events +) e +ON p.key = e.key AND p.ts >= e.begin AND p.ts < e.end +ORDER BY 1, 2 ASC +-- +ok +== +SELECT p.key, p.ts, e.value +FROM probes p ASOF JOIN events e + ON p.key = e.key AND p.ts >= e.begin +ORDER BY 1, 2 ASC +-- +ok +== +SELECT p.key, p.begin, e.value +FROM + (SELECT key, ts AS begin FROM probes) p +ASOF JOIN + events e +USING (key, begin) +ORDER BY 1, 2 ASC +-- +ok +== +SELECT p.key, p.ts, e.value +FROM + probes p +LEFT JOIN ( + SELECT key, value, begin, + LEAD(begin, 1, 'infinity'::DOUBLE) OVER (PARTITION BY key ORDER BY begin ASC) AS end + FROM events +) e +ON p.key = e.key AND p.ts >= e.begin AND p.ts < e.end +ORDER BY 1, 2 ASC NULLS FIRST +-- +ok +== +SELECT p.key, p.ts, e.value +FROM probes p ASOF LEFT JOIN events e + ON p.key = e.key AND p.ts >= e.begin +ORDER BY 1, 2, 3 ASC NULLS FIRST +-- +ok +== +SELECT p.key, p.begin, e.value +FROM + (SELECT key, ts AS begin FROM probes) p +ASOF LEFT JOIN + events e +USING (key, begin) +ORDER BY 1, 2 ASC NULLS FIRST +-- +ok +== +SELECT p.key, p.ts, e.value +FROM + probes p +RIGHT JOIN ( + SELECT key, value, begin, + LEAD(begin, 1, 'infinity'::DOUBLE) OVER (PARTITION BY key ORDER BY begin ASC) AS end + FROM events +) e +ON p.key = e.key AND p.ts >= e.begin AND p.ts < e.end +ORDER BY 1 ASC NULLS FIRST, 2 +-- +ok +== +SELECT p.key, p.ts, e.value +FROM probes p ASOF RIGHT JOIN events e + ON p.key = e.key AND p.ts >= e.begin +ORDER BY 1 ASC NULLS FIRST, 2 +-- +ok +== +SELECT p.key, p.begin, e.value +FROM + (SELECT key, ts AS begin FROM probes) p +ASOF RIGHT JOIN + events e +USING (key, begin) +ORDER BY 1 ASC NULLS FIRST, 2 +-- +ok +== +SELECT p.ts, e.value +FROM range(0,10) p(ts) ASOF JOIN (from events0 where value < 0) e +ON p.ts >= e.begin +ORDER BY p.ts ASC +-- +ok +== diff --git a/parser/testdata/corpus/sql/join/asof/test_asof_join_filter_pushdown.test b/parser/testdata/corpus/sql/join/asof/test_asof_join_filter_pushdown.test new file mode 100644 index 0000000..1e52593 --- /dev/null +++ b/parser/testdata/corpus/sql/join/asof/test_asof_join_filter_pushdown.test @@ -0,0 +1,75 @@ +# source: test/sql/join/asof/test_asof_join_filter_pushdown.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +CREATE TABLE left_table (id INTEGER, ts TIMESTAMP, symbol VARCHAR, price DECIMAL); +-- +ok +== +INSERT INTO left_table VALUES +(1, '2024-01-01 10:00:00', 'A', 150.00), +(2, '2024-01-01 10:05:00', 'A', 151.00), +(3, '2024-01-01 10:10:00', 'B', 380.00); +-- +ok +== +CREATE TABLE right_table (id INTEGER, ts TIMESTAMP, symbol VARCHAR, bid DECIMAL, active BOOLEAN); +-- +ok +== +INSERT INTO right_table VALUES +(1, '2024-01-01 09:59:00', 'A', 149.50, true), +(2, '2024-01-01 10:04:00', 'A', 150.50, false), +(3, '2024-01-01 10:09:00', 'B', 379.00, true); +-- +ok +== +SELECT * FROM left_table l +ASOF JOIN right_table r +ON l.symbol = r.symbol AND l.ts >= r.ts AND l.price > 150 AND r.active = true; +-- +ok +== +SELECT * FROM left_table l +ASOF JOIN right_table r +ON l.symbol = r.symbol AND l.ts >= r.ts AND r.active = true; +-- +ok +== +SELECT * FROM left_table l +ASOF JOIN right_table r +ON l.symbol = r.symbol AND l.ts >= r.ts AND true; +-- +ok +== +SELECT * FROM left_table l +ASOF JOIN right_table r +ON l.symbol = r.symbol AND l.ts >= r.ts AND false; +-- +ok +== +SELECT * FROM left_table l +ASOF JOIN right_table r +ON l.symbol = r.symbol AND l.ts >= r.ts AND l.price + r.bid > 300; +-- +ok +== +SELECT * FROM left_table l +ASOF LEFT JOIN right_table r +ON l.symbol = r.symbol AND l.ts >= r.ts AND l.price > 150; +-- +ok +== +SELECT * FROM left_table l +ASOF LEFT JOIN right_table r +ON l.symbol = r.symbol AND l.ts >= r.ts AND r.active = true; +-- +ok +== +SELECT * FROM left_table l +ASOF LEFT JOIN right_table r +ON l.symbol = r.symbol AND l.ts >= r.ts AND l.price + r.bid > 300; +-- +ok +== diff --git a/parser/testdata/corpus/sql/join/asof/test_asof_join_inequalities.test b/parser/testdata/corpus/sql/join/asof/test_asof_join_inequalities.test new file mode 100644 index 0000000..a21d195 --- /dev/null +++ b/parser/testdata/corpus/sql/join/asof/test_asof_join_inequalities.test @@ -0,0 +1,100 @@ +# source: test/sql/join/asof/test_asof_join_inequalities.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +CREATE TABLE events0 AS + SELECT '2023-03-21 13:00:00'::TIMESTAMP + INTERVAL (range) HOUR AS begin, range AS value + FROM range(0, 4); +-- +ok +== +INSERT INTO events0 VALUES + (NULL, -10), + ('infinity', 9), + ('-infinity', -1) +; +-- +ok +== +CREATE TABLE probe0 AS + SELECT * + FROM range('2023-03-21 12:00:00'::TIMESTAMP, '2023-03-21 22:00:00'::TIMESTAMP, INTERVAL 1 HOUR) p(begin) +; +-- +ok +== +INSERT INTO probe0 VALUES + (NULL), + ('infinity') +; +-- +ok +== +PRAGMA debug_asof_iejoin={debug} +-- +error: Parser Error: syntax error at or near "}" +== +SELECT p.begin, e.begin, e.value +FROM probe0 p ASOF JOIN events0 e +ON p.begin > e.begin +ORDER BY ALL ASC +-- +ok +== +SELECT p.begin, e.begin, e.value +FROM probe0 p ASOF LEFT JOIN events0 e +ON p.begin > e.begin +ORDER BY ALL ASC +-- +ok +== +SELECT p.begin, e.begin, e.value +FROM probe0 p ASOF RIGHT JOIN events0 e +ON p.begin > e.begin +ORDER BY ALL ASC +-- +ok +== +SELECT p.begin, e.begin, e.value +FROM probe0 p ASOF JOIN events0 e +ON p.begin <= e.begin +ORDER BY ALL ASC +-- +ok +== +SELECT p.begin, e.begin, e.value +FROM probe0 p ASOF LEFT JOIN events0 e +ON p.begin <= e.begin +ORDER BY ALL ASC +-- +ok +== +SELECT p.begin, e.begin, e.value +FROM probe0 p ASOF RIGHT JOIN events0 e +ON p.begin <= e.begin +ORDER BY ALL ASC +-- +ok +== +SELECT p.begin, e.begin, e.value +FROM probe0 p ASOF JOIN events0 e +ON p.begin < e.begin +ORDER BY ALL ASC +-- +ok +== +SELECT p.begin, e.begin, e.value +FROM probe0 p ASOF LEFT JOIN events0 e +ON p.begin < e.begin +ORDER BY ALL ASC +-- +ok +== +SELECT p.begin, e.begin, e.value +FROM probe0 p ASOF RIGHT JOIN events0 e +ON p.begin < e.begin +ORDER BY ALL ASC +-- +ok +== diff --git a/parser/testdata/corpus/sql/join/asof/test_asof_join_integers.test b/parser/testdata/corpus/sql/join/asof/test_asof_join_integers.test new file mode 100644 index 0000000..c744aa7 --- /dev/null +++ b/parser/testdata/corpus/sql/join/asof/test_asof_join_integers.test @@ -0,0 +1,69 @@ +# source: test/sql/join/asof/test_asof_join_integers.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +CREATE TABLE events0 (begin INTEGER, value INTEGER); +-- +ok +== +INSERT INTO events0 VALUES + (NULL, -1), + (1, 0), + (3, 1), + (6, 2), + (8, 3), + (999999, 9) +; +-- +ok +== +CREATE TABLE probe0 AS + SELECT range::INTEGER AS begin + FROM range(0,10) +; +-- +ok +== +SELECT p.begin, e.value +FROM probe0 p ASOF JOIN events0 e +ON p.begin >= e.begin +ORDER BY p.begin ASC +-- +ok +== +SELECT p.begin, e.value +FROM probe0 p ASOF JOIN events0 e +USING (begin) +ORDER BY p.begin ASC +-- +ok +== +SELECT p.begin, e.value +FROM probe0 p ASOF LEFT JOIN events0 e +ON p.begin >= e.begin +ORDER BY p.begin ASC +-- +ok +== +SELECT p.begin, e.value +FROM probe0 p ASOF LEFT JOIN events0 e +USING (begin) +ORDER BY p.begin ASC +-- +ok +== +SELECT p.begin, e.value +FROM probe0 p ASOF RIGHT JOIN events0 e +ON p.begin >= e.begin +ORDER BY ALL +-- +ok +== +SELECT p.begin, e.value +FROM probe0 p ASOF RIGHT JOIN events0 e +USING (begin) +ORDER BY ALL +-- +ok +== diff --git a/parser/testdata/corpus/sql/join/asof/test_asof_join_nulls.test b/parser/testdata/corpus/sql/join/asof/test_asof_join_nulls.test new file mode 100644 index 0000000..476e6a1 --- /dev/null +++ b/parser/testdata/corpus/sql/join/asof/test_asof_join_nulls.test @@ -0,0 +1,69 @@ +# source: test/sql/join/asof/test_asof_join_nulls.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +PRAGMA asof_loop_join_threshold = 0; +-- +ok +== +CREATE TABLE null_trades(id INTEGER, symbol VARCHAR, venue INTEGER, ts INTEGER); +-- +ok +== +INSERT INTO null_trades VALUES + (1, NULL, 1, 5), + (2, NULL, 1, 1), + (3, 'A', NULL, 5), + (4, 'A', 1, NULL); +-- +ok +== +CREATE TABLE null_prices(id INTEGER, symbol VARCHAR, venue INTEGER, ts INTEGER); +-- +ok +== +INSERT INTO null_prices VALUES + (10, NULL, 1, 3), + (20, 'A', NULL, 3), + (30, 'A', 1, 3); +-- +ok +== +SELECT t.id, p.id +FROM null_trades t ASOF LEFT JOIN null_prices p + ON t.symbol IS NOT DISTINCT FROM p.symbol AND t.ts >= p.ts +WHERE t.id = 1; +-- +ok +== +SELECT t.id, p.id +FROM null_trades t ASOF LEFT JOIN null_prices p + ON t.symbol IS NOT DISTINCT FROM p.symbol AND t.ts <= p.ts +WHERE t.id = 2; +-- +ok +== +SELECT t.id, p.id +FROM (VALUES (1, NULL::INTEGER, 1)) t(id, symbol, ts) +ASOF LEFT JOIN (VALUES (40, NULL::INTEGER, 65537)) p(id, symbol, ts) + ON t.symbol IS NOT DISTINCT FROM p.symbol AND t.ts <= p.ts; +-- +ok +== +SELECT t.id, p.id +FROM null_trades t ASOF LEFT JOIN null_prices p + ON t.symbol IS NOT DISTINCT FROM p.symbol + AND t.venue = p.venue + AND t.ts >= p.ts +WHERE t.id = 3; +-- +ok +== +SELECT t.id, p.id +FROM null_trades t ASOF LEFT JOIN null_prices p + ON t.symbol IS NOT DISTINCT FROM p.symbol AND t.ts >= p.ts +WHERE t.id = 4; +-- +ok +== diff --git a/parser/testdata/corpus/sql/join/asof/test_asof_join_predicates.test b/parser/testdata/corpus/sql/join/asof/test_asof_join_predicates.test new file mode 100644 index 0000000..68c90b4 --- /dev/null +++ b/parser/testdata/corpus/sql/join/asof/test_asof_join_predicates.test @@ -0,0 +1,114 @@ +# source: test/sql/join/asof/test_asof_join_predicates.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +CREATE TABLE tt1 (i INTEGER, j VARCHAR); +-- +ok +== + INSERT INTO tt1 VALUES + (2, 'A'), + (4, 'B'), + (5, 'A'); +-- +ok +== +CREATE TABLE tt2 (i INTEGER, j VARCHAR, k VARCHAR); +-- +ok +== +INSERT INTO tt2 VALUES + (1, 'A', 'I'), + (3, 'B', 'II'); +-- +ok +== +explain +SELECT tt1.i, tt2.k + FROM tt1 + ASOF JOIN tt2 ON + tt1.j = tt2.j AND tt1.i >= tt2.i + ORDER BY tt1.i; +-- +ok +== +SELECT tt1.i, tt2.k + FROM tt1 + ASOF JOIN tt2 ON + (tt1.j = tt2.j OR tt1.j = tt2.j) AND tt1.i >= tt2.i + ORDER BY tt1.i; +-- +ok +== +create table l (id integer, date timestamp, item varchar); +-- +ok +== +insert into l values + (0, '2025-01-01', 'A'); +-- +ok +== +create table r (id integer, date timestamp, item varchar, valuei double); +-- +ok +== +insert into r values + (0, '2025-01-01', 'A', 8.0), + (0, '2025-01-01', 'B', 12.0); +-- +ok +== +explain +select + l.id, + l.date, + l.item as litem, + r.item as ritem, + valuei +from l +asof left join r + on l.id = r.id and l.date >= r.date + and (l.item = r.item or l.item = '*'); +-- +ok +== +select + l.id, + l.date, + l.item as litem, + r.item as ritem, + valuei +from l +asof left join r + on l.id = r.id and l.date >= r.date + and (l.item = r.item or l.item = '*'); +-- +ok +== +create temp table tbl1 as + select unnest(range(1000)) % 10 as x, '2022-01-01'::timestamp + to_days(unnest(range(1000))) as ts; +-- +ok +== +create temp table tbl2 as + select unnest(range(1000)) % 10 as x, '2022-01-01'::timestamp + to_hours(unnest(range(1000))) as ts; +-- +ok +== +explain +from tbl1 asof join +tbl2 on tbl1.x = tbl2.x + and tbl1.ts >= tbl2.ts + and (tbl1.ts - tbl2.ts) < interval '1' hours; +-- +ok +== +from tbl1 asof join +tbl2 on tbl1.x = tbl2.x + and tbl1.ts >= tbl2.ts + and (tbl1.ts - tbl2.ts) < interval '1' hours; +-- +ok +== diff --git a/parser/testdata/corpus/sql/join/asof/test_asof_join_prefix.test b/parser/testdata/corpus/sql/join/asof/test_asof_join_prefix.test new file mode 100644 index 0000000..6b8914a --- /dev/null +++ b/parser/testdata/corpus/sql/join/asof/test_asof_join_prefix.test @@ -0,0 +1,200 @@ +# source: test/sql/join/asof/test_asof_join_prefix.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +PRAGMA debug_asof_iejoin=False +-- +ok +== +CREATE TABLE prices_int("when" TIMESTAMP, symbol INTEGER, price INTEGER); +-- +ok +== +INSERT INTO prices_int VALUES + ('2020-01-01 00:00:00', 1, 42), + ('2020-01-01 00:00:00', 2, 55), + +-- +ok +== +CREATE TABLE trades_int("when" timestamp, symbol INTEGER); +-- +ok +== +INSERT INTO trades_int VALUES + ('2020-01-01 00:00:03', 1), + ('2020-01-01 00:00:03', 3), +-- +ok +== +SELECT t.*, p.price +FROM trades_int t ASOF JOIN prices_int p + ON t.symbol = p.symbol AND t.when >= p.when; +-- +ok +== +CREATE TABLE prices_varchar("when" TIMESTAMP, symbol VARCHAR, price INTEGER); +-- +ok +== +INSERT INTO prices_varchar VALUES + ('2020-01-01 00:00:00', 'APPL', 42), + ('2020-01-01 00:00:00', 'MEL', 55), + +-- +ok +== +CREATE TABLE trades_varchar("when" timestamp, symbol VARCHAR); +-- +ok +== +INSERT INTO trades_varchar VALUES + ('2020-01-01 00:00:03', 'APPL'), + ('2020-01-01 00:00:03', 'VCT'), +-- +ok +== +SELECT t.*, p.price +FROM trades_varchar t ASOF JOIN prices_varchar p + ON t.symbol = p.symbol AND t.when >= p.when; +-- +ok +== +CREATE TABLE prices_struct("when" TIMESTAMP, symbol STRUCT(ticker VARCHAR, exchange INTEGER), price INTEGER); +-- +ok +== +INSERT INTO prices_struct VALUES + ('2020-01-01 00:00:00', {'ticker': 'APPL', 'exchange': 1}, 42), + ('2020-01-01 00:00:00', {'ticker': 'MEL', 'exchange': 2}, 55), + +-- +ok +== +CREATE TABLE trades_struct("when" timestamp, symbol STRUCT(ticker VARCHAR, exchange INTEGER)); +-- +ok +== +INSERT INTO trades_struct VALUES + ('2020-01-01 00:00:03', {'ticker': 'APPL', 'exchange': 1}), + ('2020-01-01 00:00:03', {'ticker': 'VCT', 'exchange': 2}), +-- +ok +== +SELECT t.*, p.price +FROM trades_struct t ASOF JOIN prices_struct p + ON t.symbol = p.symbol AND t.when >= p.when; +-- +ok +== +CREATE TABLE prices_list("when" TIMESTAMP, symbol INTEGER[], price INTEGER); +-- +ok +== +INSERT INTO prices_list VALUES + ('2020-01-01 00:00:00', [1, 0], 42), + ('2020-01-01 00:00:00', [2, 0], 55), + +-- +ok +== +CREATE TABLE trades_list("when" timestamp, symbol INTEGER[]); +-- +ok +== +INSERT INTO trades_list VALUES + ('2020-01-01 00:00:03', [1, 0]), + ('2020-01-01 00:00:03', [2, 1]), +-- +ok +== +SELECT t.*, p.price +FROM trades_list t ASOF JOIN prices_list p + ON t.symbol = p.symbol AND t.when >= p.when; +-- +ok +== +CREATE TABLE prices_array("when" TIMESTAMP, symbol INTEGER[2], price INTEGER); +-- +ok +== +INSERT INTO prices_array VALUES + ('2020-01-01 00:00:00', [1, 0], 42), + ('2020-01-01 00:00:00', [2, 0], 55), + +-- +ok +== +CREATE TABLE trades_array("when" timestamp, symbol INTEGER[2]); +-- +ok +== +INSERT INTO trades_array VALUES + ('2020-01-01 00:00:03', [1, 0]), + ('2020-01-01 00:00:03', [2, 1]), +-- +ok +== +SELECT t.*, p.price +FROM trades_array t ASOF JOIN prices_array p + ON t.symbol = p.symbol AND t.when >= p.when; +-- +ok +== +CREATE TABLE prices_nested("when" TIMESTAMP, symbol STRUCT(ticker VARCHAR[], exchange INTEGER), price INTEGER); +-- +ok +== +INSERT INTO prices_nested VALUES + ('2020-01-01 00:00:00', {'ticker': ['APPL', 'Apple Inc'], 'exchange': 1}, 42), + ('2020-01-01 00:00:00', {'ticker': ['MEL', 'Meridian Energy'], 'exchange': 2}, 55), + +-- +ok +== +CREATE TABLE trades_nested("when" timestamp, symbol STRUCT(ticker VARCHAR[], exchange INTEGER)); +-- +ok +== +INSERT INTO trades_nested VALUES + ('2020-01-01 00:00:03', {'ticker': ['APPL', 'Apple Inc'], 'exchange': 1}), + ('2020-01-01 00:00:03', {'ticker': ['VCT', 'Vector Ltd'], 'exchange': 2}), +-- +ok +== +SELECT t.*, p.price +FROM trades_nested t ASOF JOIN prices_nested p + ON t.symbol = p.symbol AND t.when >= p.when; +-- +ok +== +CREATE TABLE prices_multiple("when" TIMESTAMP, symbol VARCHAR, exchange INTEGER, price INTEGER); +-- +ok +== +INSERT INTO prices_multiple VALUES + ('2020-01-01 00:00:00', 'APPL', 1, 42), + ('2020-01-01 00:00:00', 'MEL', 2, 55), + +-- +ok +== +CREATE TABLE trades_multiple("when" timestamp, symbol VARCHAR, exchange INTEGER); +-- +ok +== +INSERT INTO trades_multiple VALUES + ('2020-01-01 00:00:03', 'APPL', 1), + ('2020-01-01 00:00:03', 'MEL', 3), +-- +ok +== +SELECT t.*, p.price +FROM trades_multiple t ASOF JOIN prices_multiple p + ON t.symbol = p.symbol + AND t.exchange = p.exchange + AND t.when >= p.when +-- +ok +== diff --git a/parser/testdata/corpus/sql/join/asof/test_asof_join_pushdown.test b/parser/testdata/corpus/sql/join/asof/test_asof_join_pushdown.test new file mode 100644 index 0000000..5ecf7cc --- /dev/null +++ b/parser/testdata/corpus/sql/join/asof/test_asof_join_pushdown.test @@ -0,0 +1,174 @@ +# source: test/sql/join/asof/test_asof_join_pushdown.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +CREATE OR REPLACE TABLE right_pushdown(time INTEGER, value FLOAT); +-- +ok +== +INSERT INTO right_pushdown VALUES + (0, 0), + (1, NULL), +; +-- +ok +== +CREATE TABLE issue13899(seq_no INT, amount DECIMAL(10,2)); +-- +ok +== +INSERT INTO issue13899 VALUES + (1,1.00), + (2,null), + (3,null), + (4,null), + (5,2.00), + (6,null), + (7,null), + (8,3.00), + (9,null), + (10,null), + (11,5.00); +-- +ok +== +SELECT + d1.time, + d2.time, + d1.value, + d2.value +FROM right_pushdown d1 +ASOF JOIN ( + SELECT * FROM right_pushdown WHERE value is not NULL + ) d2 + ON d1.time >= d2.time +ORDER BY ALL; +-- +ok +== +SELECT + d1.time, + d2.time, + d1.value, + d2.value +FROM right_pushdown d1 +ASOF LEFT JOIN ( + SELECT * FROM right_pushdown WHERE value is not NULL + ) d2 + ON d1.time >= d2.time +ORDER BY ALL; +-- +ok +== +CREATE OR REPLACE TABLE issue12215 AS + SELECT col0 AS starts, col1 AS ends + FROM (VALUES + (5, 9), + (10, 13), + (14, 20), + (21, 23) + ); +-- +ok +== +SELECT + s1.starts as s1_starts, + s2.starts as s2_starts, +FROM issue12215 AS s1 +ASOF JOIN issue12215 as s2 + ON s2.ends >= (s1.ends - 5) +WHERE s1_starts <> s2_starts +ORDER BY ALL +-- +ok +== +WITH t as ( + SELECT + t1.col0 AS left_val, + t2.col0 AS right_val, + FROM + (VALUES (0), (5), (10), (15)) AS t1 + ASOF JOIN (VALUES (1), (6), (11), (16)) AS t2 + ON t2.col0 > t1.col0 +) +SELECT * +FROM t +WHERE right_val BETWEEN 3 AND 12 +ORDER BY ALL +-- +ok +== +WITH t as ( + SELECT + t1.col0 AS left_val, + t2.col0 AS right_val, + FROM + (VALUES (0), (5), (10), (15)) AS t1 + ASOF LEFT JOIN (VALUES (1), (6), (11), (16)) AS t2 + ON t2.col0 > t1.col0 +) +SELECT * +FROM t +WHERE right_val BETWEEN 3 AND 12 +ORDER BY ALL +-- +ok +== +select + a.seq_no, + a.amount, + b.amount +from issue13899 as a +asof join issue13899 as b + on a.seq_no>=b.seq_no + and b.amount is not null +ORDER BY 1 +-- +ok +== +WITH t1 AS ( +FROM (VALUES (1,2),(2,4)) t1(id, value) +), +t2 AS ( +FROM (VALUES (1,3)) t2(id, value) +) +FROM t1 +ASOF LEFT JOIN t2 + ON t1.id <= t2.id +ORDER BY 1 +-- +ok +== +WITH t1 AS ( +FROM (VALUES (1,2),(2,4)) t1(id, value) +), +t2 AS ( +FROM (VALUES (1,3)) t2(id, value) +) +FROM t1 +ASOF LEFT JOIN t2 + ON t1.id >= t2.id AND t1.id = 1 +ORDER BY 1 +-- +ok +== +WITH t1 AS ( + FROM VALUES + (1::INT, '2020-01-01 00:00:00'::TIMESTAMP), + (2, '2020-01-02 00:00:00') + AS t1(a, b) +), t2 AS ( + FROM VALUES + (1::INT, '2020-01-01 00:01:00'::TIMESTAMP), + (2, '2020-01-02 00:00:00') + t2(c, d) +) +SELECT * +FROM t1 +ASOF JOIN t2 + ON t1 = (b == t2.d) + AND t1.b >= t2.d - INTERVAL '1' SECOND; +-- +ok +== diff --git a/parser/testdata/corpus/sql/join/asof/test_asof_join_setops.test b/parser/testdata/corpus/sql/join/asof/test_asof_join_setops.test new file mode 100644 index 0000000..4d91227 --- /dev/null +++ b/parser/testdata/corpus/sql/join/asof/test_asof_join_setops.test @@ -0,0 +1,69 @@ +# source: test/sql/join/asof/test_asof_join_setops.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +CREATE TABLE a(d INTEGER); +-- +ok +== +INSERT INTO a VALUES (1), (2); +-- +ok +== +CREATE TABLE b(d INTEGER); +-- +ok +== +CREATE TABLE r AS SELECT * FROM a; +-- +ok +== +SELECT * FROM (SELECT * FROM a EXCEPT ALL SELECT * FROM b) t0 +ASOF LEFT JOIN r t1 ON t0.d >= t1.d +ORDER BY ALL; +-- +ok +== +SELECT * FROM (SELECT * FROM a INTERSECT ALL SELECT * FROM a) t0 +ASOF LEFT JOIN r t1 ON t0.d >= t1.d +ORDER BY ALL; +-- +ok +== +SELECT * FROM r t1 +ASOF LEFT JOIN (SELECT * FROM a EXCEPT ALL SELECT * FROM b) t0 ON t1.d >= t0.d +ORDER BY ALL; +-- +ok +== +SELECT * FROM r t1 +ASOF LEFT JOIN (SELECT * FROM a INTERSECT ALL SELECT * FROM a) t0 ON t1.d >= t0.d +ORDER BY ALL; +-- +ok +== +SELECT * FROM (SELECT * FROM a EXCEPT ALL SELECT * FROM b) t0 +ASOF LEFT JOIN (SELECT * FROM a INTERSECT ALL SELECT * FROM a) t1 ON t0.d >= t1.d +ORDER BY ALL; +-- +ok +== +SELECT * FROM (SELECT * FROM a EXCEPT ALL SELECT * FROM b) t0 +ASOF JOIN r t1 ON t0.d >= t1.d +ORDER BY ALL; +-- +ok +== +SELECT * FROM (SELECT * FROM a EXCEPT ALL SELECT * FROM b) t0 +ASOF LEFT JOIN r t1 ON t0.d >= t1.d AND (t0.d + t1.d) > 1 +ORDER BY ALL; +-- +ok +== +SELECT * FROM (SELECT * FROM a EXCEPT ALL SELECT 1) t0 +ASOF LEFT JOIN r t1 ON t0.d >= t1.d +ORDER BY ALL; +-- +ok +== diff --git a/parser/testdata/corpus/sql/join/asof/test_asof_join_subquery.test b/parser/testdata/corpus/sql/join/asof/test_asof_join_subquery.test new file mode 100644 index 0000000..9d6c36b --- /dev/null +++ b/parser/testdata/corpus/sql/join/asof/test_asof_join_subquery.test @@ -0,0 +1,33 @@ +# source: test/sql/join/asof/test_asof_join_subquery.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +CREATE TABLE events (begin DOUBLE, value INTEGER); +-- +ok +== +INSERT INTO events VALUES + (1, 0), + (3, 1), + (6, 2), + (8, 3) +; +-- +ok +== +SELECT begin, value IN ( + SELECT e1.value + FROM ( + SELECT * + FROM events e1 + WHERE e1.value = events.value) e1 + ASOF JOIN + range(1, 10) tbl(begin) + USING (begin) + ) +FROM events +ORDER BY ALL; +-- +ok +== diff --git a/parser/testdata/corpus/sql/join/asof/test_asof_join_timestamps.test b/parser/testdata/corpus/sql/join/asof/test_asof_join_timestamps.test new file mode 100644 index 0000000..67cb0a7 --- /dev/null +++ b/parser/testdata/corpus/sql/join/asof/test_asof_join_timestamps.test @@ -0,0 +1,61 @@ +# source: test/sql/join/asof/test_asof_join_timestamps.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +INSERT INTO events0 VALUES + (NULL, -1), + ('infinity', 9) +; +-- +ok +== +CREATE TABLE asof_nulls ( + time TIMESTAMP, + value FLOAT +); +-- +ok +== +INSERT INTO asof_nulls (time, value) VALUES ('2025-07-15 00:00:00', 42); +-- +ok +== +INSERT INTO asof_nulls (time, value) VALUES ('2025-07-15 01:00:00', null); +-- +ok +== +SELECT p.begin, e.value +FROM probe0 p ASOF LEFT JOIN (SELECT * FROM events0 WHERE log(value + 5) > 10) e +ON p.begin >= e.begin +ORDER BY p.begin ASC +-- +ok +== +SELECT p.begin, e.value +FROM probe0 p ASOF RIGHT JOIN (SELECT * FROM events0 WHERE log(value + 5) > 10) e +ON p.begin >= e.begin +ORDER BY p.begin ASC +-- +ok +== +SELECT p.begin +FROM probe0 p ASOF SEMI JOIN events0 e +ON p.begin >= e.begin +ORDER BY p.begin ASC +-- +ok +== +SELECT p.begin +FROM probe0 p ASOF ANTI JOIN events0 e +ON p.begin >= e.begin +ORDER BY p.begin ASC +-- +ok +== +SELECT time_series.time, asof_nulls.value +FROM (VALUES ('2025-07-15 02:00:00'::TIMESTAMP)) as time_series(time) +ASOF LEFT JOIN asof_nulls ON asof_nulls.time <= time_series.time; +-- +ok +== diff --git a/parser/testdata/corpus/sql/join/asof/test_asof_join_types.test b/parser/testdata/corpus/sql/join/asof/test_asof_join_types.test new file mode 100644 index 0000000..079dd34 --- /dev/null +++ b/parser/testdata/corpus/sql/join/asof/test_asof_join_types.test @@ -0,0 +1,56 @@ +# source: test/sql/join/asof/test_asof_join_types.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +INSERT INTO left_table VALUES + (1, '2024-01-01 10:00:00', 'A', 150.00), + (2, '2024-01-01 10:05:00', 'A', 151.00), + (3, '2024-01-01 10:10:00', 'B', 380.00); +-- +ok +== +INSERT INTO right_table VALUES + (1, '2024-01-01 09:59:00', 'A', 149.50, true), + (2, '2024-01-01 10:04:00', 'A', 150.50, false), + (3, '2024-01-01 10:09:00', 'B', 379.00, true); +-- +ok +== +SELECT * +FROM left_table l +ASOF SEMI JOIN right_table r + ON l.symbol = r.symbol + AND l.ts >= r.ts + AND l.price + r.bid > 300 +ORDER BY 1 +-- +ok +== +SELECT * +FROM left_table l +ASOF ANTI JOIN right_table r + ON l.symbol = r.symbol + AND l.ts >= r.ts + AND l.price + r.bid > 300; +-- +ok +== +SELECT * +FROM left_table l +ASOF RIGHT JOIN right_table r + ON l.symbol = r.symbol + AND l.ts >= r.ts + AND l.price + r.bid > 300 +-- +ok +== +SELECT * +FROM left_table l +ASOF FULL JOIN right_table r + ON l.symbol = r.symbol + AND l.ts >= r.ts + AND l.price + r.bid > 300; +-- +ok +== diff --git a/parser/testdata/corpus/sql/join/asof/test_asof_join_varchar.test b/parser/testdata/corpus/sql/join/asof/test_asof_join_varchar.test new file mode 100644 index 0000000..162b3f0 --- /dev/null +++ b/parser/testdata/corpus/sql/join/asof/test_asof_join_varchar.test @@ -0,0 +1,27 @@ +# source: test/sql/join/asof/test_asof_join_varchar.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +CREATE TABLE events0 (begin VARCHAR, value INTEGER); +-- +ok +== +INSERT INTO events0 VALUES + (NULL, -1), + (1, 0), + (3, 1), + (6, 2), + (8, 3), + ('infinity', 9) +; +-- +ok +== +CREATE TABLE probe0 AS + SELECT range::VARCHAR AS begin + FROM range(0,10) +; +-- +ok +== diff --git a/parser/testdata/corpus/sql/join/asof/test_asof_limit.test b/parser/testdata/corpus/sql/join/asof/test_asof_limit.test new file mode 100644 index 0000000..8f70756 --- /dev/null +++ b/parser/testdata/corpus/sql/join/asof/test_asof_limit.test @@ -0,0 +1,34 @@ +# source: test/sql/join/asof/test_asof_limit.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +WITH trades AS ( + SELECT + 'AAPL' AS symbol, + TIMESTAMP '2024-01-01 10:00:00' + idx * INTERVAL 10 SECONDS AS trade_time, + 100 AS quantity + FROM range(64) AS trade_rows(idx) -- hangs; change to 63 to succeed +), +quotes AS ( + SELECT + 'AAPL' AS symbol, + TIMESTAMP '2024-01-01 09:59:50' + idx * INTERVAL 10 SECONDS AS quote_time, + 150.0 AS price + FROM range(64) AS quote_rows(idx) +) +SELECT + t.symbol, + t.trade_time, + t.quantity, + q.quote_time, + q.price, + t.quantity * q.price AS notional +FROM trades AS t +ASOF LEFT JOIN quotes AS q + ON t.symbol = q.symbol + AND t.trade_time >= q.quote_time +LIMIT 5; +-- +ok +== diff --git a/parser/testdata/corpus/sql/join/asof/test_asof_semi_anti_mark.test b/parser/testdata/corpus/sql/join/asof/test_asof_semi_anti_mark.test new file mode 100644 index 0000000..8042989 --- /dev/null +++ b/parser/testdata/corpus/sql/join/asof/test_asof_semi_anti_mark.test @@ -0,0 +1,39 @@ +# source: test/sql/join/asof/test_asof_semi_anti_mark.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +INSERT INTO left_table VALUES + (1, '2024-01-01 10:00:00', 'A', 150.00), + (2, '2024-01-01 10:05:00', 'A', 151.00), + (3, '2024-01-01 10:10:00', 'B', 380.00); +-- +ok +== +INSERT INTO right_table VALUES + (1, '2024-01-01 09:59:00', 'A', 149.50, true), + (2, '2024-01-01 10:04:00', 'A', 150.50, false), + (3, '2024-01-01 10:09:00', 'B', 379.00, true); +-- +ok +== +SELECT * +FROM left_table l +ASOF SEMI JOIN right_table r + ON l.symbol = r.symbol + AND l.ts >= r.ts + AND l.price + r.bid > 300 +ORDER BY 1 +-- +ok +== +SELECT * +FROM left_table l +ASOF ANTI JOIN right_table r + ON l.symbol = r.symbol + AND l.ts >= r.ts + AND l.price + r.bid > 300 +ORDER BY 1 +-- +ok +== diff --git a/parser/testdata/corpus/sql/join/cross_product/test_cross_product.test b/parser/testdata/corpus/sql/join/cross_product/test_cross_product.test new file mode 100644 index 0000000..826cf80 --- /dev/null +++ b/parser/testdata/corpus/sql/join/cross_product/test_cross_product.test @@ -0,0 +1,21 @@ +# source: test/sql/join/cross_product/test_cross_product.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +INSERT INTO test VALUES (11, 1), (12, 2); +-- +ok +== +SELECT * FROM test t1, test t2 ORDER BY 1, 2, 3, 4; +-- +ok +== +SELECT COUNT(*) FROM test t1, range(2000) t2 +-- +ok +== +SELECT COUNT(*) FROM range(2000) t1, test t2 +-- +ok +== diff --git a/parser/testdata/corpus/sql/join/empty_joins.test b/parser/testdata/corpus/sql/join/empty_joins.test new file mode 100644 index 0000000..3b58992 --- /dev/null +++ b/parser/testdata/corpus/sql/join/empty_joins.test @@ -0,0 +1,105 @@ +# source: test/sql/join/empty_joins.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +CREATE TABLE integers AS SELECT i FROM range(10) tbl(i) +-- +ok +== +CREATE TABLE integers2 AS SELECT i FROM range(10) tbl(i) +-- +ok +== +CREATE VIEW integers_empty AS SELECT * FROM integers WHERE rowid>100 +-- +ok +== +CREATE VIEW integers2_empty AS SELECT * FROM integers WHERE rowid>100 +-- +ok +== +CREATE VIEW empty_join AS SELECT * FROM integers JOIN integers2_empty USING (i) +-- +ok +== +SELECT COUNT(*) FROM integers_empty JOIN integers2 USING (i) +-- +ok +== +SELECT COUNT(*) FROM integers_empty JOIN integers2 ON (integers_empty.i>integers2.i) +-- +ok +== +SELECT COUNT(*) FROM integers_empty JOIN integers2 ON (integers_empty.i<>integers2.i) +-- +ok +== +SELECT COUNT(*) FROM integers_empty JOIN integers2 ON (integers_empty.i<>integers2.i OR integers_empty.i+1<>integers2.i) +-- +ok +== +SELECT * FROM integers_empty JOIN integers2 USING (i) +-- +ok +== +SELECT COUNT(*) FROM integers_empty LEFT JOIN integers2 USING (i) +-- +ok +== +SELECT * FROM integers_empty LEFT JOIN integers2 USING (i) +-- +ok +== +SELECT COUNT(*) FROM integers_empty RIGHT JOIN integers2 USING (i) +-- +ok +== +SELECT COUNT(*) FROM integers_empty FULL OUTER JOIN integers2 USING (i) +-- +ok +== +SELECT COUNT(*) FROM integers JOIN integers2_empty USING (i) +-- +ok +== +SELECT * FROM integers JOIN integers2_empty USING (i) +-- +ok +== +SELECT COUNT(*) FROM integers LEFT JOIN integers2_empty USING (i) +-- +ok +== +SELECT COUNT(*) FROM integers RIGHT JOIN integers2_empty USING (i) +-- +ok +== +SELECT * FROM integers RIGHT JOIN integers2_empty USING (i) +-- +ok +== +SELECT COUNT(*) FROM integers FULL OUTER JOIN integers2_empty USING (i) +-- +ok +== +SELECT integers.*, integers2_empty.* FROM integers FULL OUTER JOIN integers2_empty USING (i) +-- +ok +== +SELECT COUNT(*) FROM integers JOIN empty_join USING (i) +-- +ok +== +SELECT COUNT(*) FROM integers LEFT JOIN empty_join USING (i) +-- +ok +== +SELECT COUNT(*) FROM integers RIGHT JOIN empty_join USING (i) +-- +ok +== +SELECT COUNT(*) FROM integers FULL OUTER JOIN empty_join USING (i) +-- +ok +== diff --git a/parser/testdata/corpus/sql/join/full_outer/full_outer_join_cache.test b/parser/testdata/corpus/sql/join/full_outer/full_outer_join_cache.test new file mode 100644 index 0000000..e078348 --- /dev/null +++ b/parser/testdata/corpus/sql/join/full_outer/full_outer_join_cache.test @@ -0,0 +1,21 @@ +# source: test/sql/join/full_outer/full_outer_join_cache.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +CREATE TABLE smalltable AS SELECT 1::INTEGER a; +-- +ok +== +CREATE TABLE bigtable AS SELECT a::INTEGER a FROM generate_series(0, 9999, 1) tbl(a), generate_series(0, 9, 1) tbl2(b); +-- +ok +== +SELECT COUNT(*) FROM bigtable FULL OUTER JOIN smalltable USING (a) +-- +ok +== +SELECT COUNT(*) FROM bigtable RIGHT OUTER JOIN smalltable USING (a) +-- +ok +== diff --git a/parser/testdata/corpus/sql/join/full_outer/full_outer_join_union.test b/parser/testdata/corpus/sql/join/full_outer/full_outer_join_union.test new file mode 100644 index 0000000..c56fb17 --- /dev/null +++ b/parser/testdata/corpus/sql/join/full_outer/full_outer_join_union.test @@ -0,0 +1,63 @@ +# source: test/sql/join/full_outer/full_outer_join_union.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +INSERT INTO integers VALUES (1, 1), (3, 3); +-- +ok +== +CREATE TABLE integers2(k INTEGER, l INTEGER); +-- +ok +== +INSERT INTO integers2 VALUES (1, 10), (2, 20); +-- +ok +== +SELECT i, j, k, l FROM integers FULL OUTER JOIN integers2 ON integers.i=integers2.k +UNION ALL +SELECT i, j, k, l FROM integers FULL OUTER JOIN integers2 ON integers.i=integers2.k +ORDER BY i +-- +ok +== +SELECT i, j, k, l FROM integers FULL OUTER JOIN integers2 ON integers.i=integers2.k +UNION +SELECT i, j, k, l FROM integers FULL OUTER JOIN integers2 ON integers.i=integers2.k +ORDER BY i +-- +ok +== +SELECT i, j, k, l FROM integers FULL OUTER JOIN integers2 ON integers.i=integers2.k +UNION +SELECT i+1, j, k, l FROM integers FULL OUTER JOIN integers2 ON integers.i=integers2.k +UNION +SELECT i+2, j, k, l FROM integers FULL OUTER JOIN integers2 ON integers.i=integers2.k +UNION +SELECT i+3, j, k, l FROM integers FULL OUTER JOIN integers2 ON integers.i=integers2.k +UNION +SELECT i+4, j, k, l FROM integers FULL OUTER JOIN integers2 ON integers.i=integers2.k +ORDER BY 1,2,3,4 +-- +ok +== +SELECT DISTINCT * FROM ( +SELECT i, j, k, l FROM integers FULL OUTER JOIN integers2 ON integers.i=integers2.k +UNION ALL +SELECT i, j, k, l FROM integers FULL OUTER JOIN integers2 ON integers.i=integers2.k) tbl +ORDER BY i +-- +ok +== +CREATE VIEW v1 AS +SELECT i, j, k, l FROM integers FULL OUTER JOIN integers2 ON integers.i=integers2.k +UNION ALL +SELECT i, j, k, l FROM integers FULL OUTER JOIN integers2 ON integers.i=integers2.k +-- +ok +== +SELECT * FROM v1 FULL OUTER JOIN v1 v2 USING (i, j) ORDER BY 1, 2, 3, 4, 5, 6 +-- +ok +== diff --git a/parser/testdata/corpus/sql/join/full_outer/test_full_outer_join.test b/parser/testdata/corpus/sql/join/full_outer/test_full_outer_join.test new file mode 100644 index 0000000..388cb9e --- /dev/null +++ b/parser/testdata/corpus/sql/join/full_outer/test_full_outer_join.test @@ -0,0 +1,33 @@ +# source: test/sql/join/full_outer/test_full_outer_join.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +INSERT INTO integers VALUES (1, 1), (3, 3) +-- +ok +== +CREATE TABLE integers2(k INTEGER, l INTEGER) +-- +ok +== +INSERT INTO integers2 VALUES (1, 10), (2, 20) +-- +ok +== +SELECT i, j, k, l FROM integers FULL OUTER JOIN integers2 ON integers.i=integers2.k ORDER BY i +-- +ok +== +SELECT i, j, k, l FROM integers FULL OUTER JOIN integers2 ON integers.i=integers2.k AND integers.j > integers2.l ORDER BY 1, 2, 3, 4 +-- +ok +== +SELECT i, j, k, l FROM integers FULL OUTER JOIN (SELECT k, l::VARCHAR AS l FROM integers2) integers2 ON integers.i=integers2.k ORDER BY 1, 2, 3, 4 +-- +ok +== +SELECT i, j, k, l FROM integers FULL OUTER JOIN (SELECT * FROM integers2 WHERE 1=0) integers2 ON integers.i=integers2.k ORDER BY 1, 2, 3, 4 +-- +ok +== diff --git a/parser/testdata/corpus/sql/join/full_outer/test_full_outer_join_complex.test b/parser/testdata/corpus/sql/join/full_outer/test_full_outer_join_complex.test new file mode 100644 index 0000000..c07ac42 --- /dev/null +++ b/parser/testdata/corpus/sql/join/full_outer/test_full_outer_join_complex.test @@ -0,0 +1,21 @@ +# source: test/sql/join/full_outer/test_full_outer_join_complex.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +INSERT INTO integers VALUES (1, 1) +-- +ok +== +INSERT INTO integers2 VALUES (1, 10) +-- +ok +== +SELECT i, j, k, l FROM integers FULL OUTER JOIN integers2 ON integers.i+integers2.k+9<>integers.j+integers2.l ORDER BY 1, 2, 3, 4 +-- +ok +== +SELECT i, j, k, l FROM integers FULL OUTER JOIN (SELECT * FROM integers2 WHERE 1=0) integers2 ON integers.i+integers2.k+9<>integers.j+integers2.l ORDER BY 1, 2, 3, 4 +-- +ok +== diff --git a/parser/testdata/corpus/sql/join/full_outer/test_full_outer_join_inequality.test b/parser/testdata/corpus/sql/join/full_outer/test_full_outer_join_inequality.test new file mode 100644 index 0000000..b339fe5 --- /dev/null +++ b/parser/testdata/corpus/sql/join/full_outer/test_full_outer_join_inequality.test @@ -0,0 +1,13 @@ +# source: test/sql/join/full_outer/test_full_outer_join_inequality.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +SELECT i, j, k, l FROM integers FULL OUTER JOIN integers2 ON integers.i<>integers2.k ORDER BY 1, 2, 3, 4 +-- +ok +== +SELECT i, j, k, l FROM integers FULL OUTER JOIN (SELECT * FROM integers2 WHERE 1=0) integers2 ON integers.i<>integers2.k ORDER BY 1, 2, 3, 4 +-- +ok +== diff --git a/parser/testdata/corpus/sql/join/full_outer/test_full_outer_join_issue_4252.test b/parser/testdata/corpus/sql/join/full_outer/test_full_outer_join_issue_4252.test new file mode 100644 index 0000000..81b116e --- /dev/null +++ b/parser/testdata/corpus/sql/join/full_outer/test_full_outer_join_issue_4252.test @@ -0,0 +1,173 @@ +# source: test/sql/join/full_outer/test_full_outer_join_issue_4252.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +CREATE TABLE test (x INT, y INT); +-- +ok +== +INSERT INTO test VALUES (1, 1), (2, 2), (3, 3); +-- +ok +== +SELECT * FROM (SELECT a2.x FROM (SELECT x FROM test WHERE x > 3) AS a1 FULL OUTER JOIN (SELECT x FROM test WHERE x = 1) AS a2 ON a1.x = a2.x) AS a3 FULL OUTER JOIN (SELECT 1 AS x) AS a4 ON a3.x = a4.x; +-- +ok +== +CREATE TABLE df1(day DATE, value INTEGER, organization VARCHAR); +INSERT INTO df1 VALUES + ('2022-01-01', 10, 'org1'), + ('2022-01-05', 20, 'org2'), + ('2022-01-10', 30, 'org3'); +-- +ok +== +CREATE TABLE df2(day DATE, value INTEGER, organization VARCHAR); +INSERT INTO df2 VALUES + ('2022-01-01', 100, 'org1'), + ('2022-09-01', 200, 'org2'), + ('2022-03-01', 300, 'org3'); +-- +ok +== +CREATE TABLE df3(day DATE, value INTEGER, organization VARCHAR); +INSERT INTO df3 VALUES + ('2022-01-02', 1000, 'org1'), + ('2022-02-03', 2000, 'org2'), + ('2022-04-01', 3000, 'org3'); +-- +ok +== +SELECT + coalesce(anon_1.month, anon_2.month) AS month, + coalesce(coalesce(CAST(anon_1.value AS REAL), 0.0) + coalesce(CAST(anon_2.value AS REAL), 0.0), 0.0) AS value +FROM ( + SELECT coalesce(anon_3.month, anon_4.month) AS month, + coalesce(coalesce(CAST(anon_3.value AS REAL), 0.0) + coalesce(CAST(anon_4.value AS REAL), 0.0), 0.0) AS value + FROM ( + SELECT month AS month, sum(anon_5.value) AS value + FROM ( + SELECT date_trunc('month', day) AS month, coalesce(sum(value), 0.0) AS value + FROM df1 + WHERE day >= CAST('2022-01-01 00:00:00' AS DATE) + AND day <= CAST('2022-01-31 00:00:00' AS DATE) + AND (organization ILIKE 'org4') + GROUP BY date_trunc('month', day) + ) AS anon_5 + GROUP BY GROUPING SETS((month)) + ) AS anon_3 + FULL OUTER JOIN ( + SELECT month AS month, sum(anon_6.value) AS value + FROM ( + SELECT date_trunc('month', day) AS month, coalesce(sum(value), 0.0) AS value + FROM df2 + WHERE day >= CAST('2022-01-01 00:00:00' AS DATE) + AND day <= CAST('2022-01-31 00:00:00' AS DATE) + GROUP BY date_trunc('month', day) + ) AS anon_6 + GROUP BY GROUPING SETS((month)) + ) AS anon_4 ON anon_3.month = anon_4.month +) AS anon_1 +FULL OUTER JOIN ( + SELECT month AS month, sum(anon_7.value) AS value + FROM ( + SELECT date_trunc('month', day) AS month, coalesce(sum(value), 0.0) AS value + FROM df3 + WHERE day >= CAST('2022-01-01 00:00:00' AS DATE) + AND day <= CAST('2022-01-31 00:00:00' AS DATE) + GROUP BY date_trunc('month', day) + ) AS anon_7 + GROUP BY GROUPING SETS((month)) +) AS anon_2 ON anon_1.month = anon_2.month +-- +ok +== +SELECT + coalesce(anon_1.month, anon_2.month) AS month, + coalesce(coalesce(CAST(anon_1.value AS REAL), 0.0) + coalesce(CAST(anon_2.value AS REAL), 0.0), 0.0) AS value +FROM ( + SELECT coalesce(anon_3.month, anon_4.month) AS month, + coalesce(coalesce(CAST(anon_3.value AS REAL), 0.0) + coalesce(CAST(anon_4.value AS REAL), 0.0), 0.0) AS value + FROM ( + SELECT month AS month, sum(anon_5.value) AS value + FROM ( + SELECT date_trunc('month', day) AS month, coalesce(sum(value), 0.0) AS value + FROM df1 + WHERE day >= CAST('2022-01-01 00:00:00' AS DATE) + AND day <= CAST('2022-01-31 00:00:00' AS DATE) + AND (organization ILIKE 'org1') + GROUP BY date_trunc('month', day) + ) AS anon_5 + GROUP BY GROUPING SETS((month)) + ) AS anon_3 + FULL OUTER JOIN ( + SELECT month AS month, sum(anon_6.value) AS value + FROM ( + SELECT date_trunc('month', day) AS month, coalesce(sum(value), 0.0) AS value + FROM df2 + WHERE day >= CAST('2022-01-01 00:00:00' AS DATE) + AND day <= CAST('2022-01-31 00:00:00' AS DATE) + GROUP BY date_trunc('month', day) + ) AS anon_6 + GROUP BY GROUPING SETS((month)) + ) AS anon_4 ON anon_3.month = anon_4.month +) AS anon_1 +FULL OUTER JOIN ( + SELECT month AS month, sum(anon_7.value) AS value + FROM ( + SELECT date_trunc('month', day) AS month, coalesce(sum(value), 0.0) AS value + FROM df3 + WHERE day >= CAST('2022-01-01 00:00:00' AS DATE) + AND day <= CAST('2022-01-31 00:00:00' AS DATE) + GROUP BY date_trunc('month', day) + ) AS anon_7 + GROUP BY GROUPING SETS((month)) +) AS anon_2 ON anon_1.month = anon_2.month +-- +ok +== +SELECT + coalesce(anon_1.month, anon_2.month) AS month, + coalesce(coalesce(CAST(anon_1.value AS REAL), 0.0) + coalesce(CAST(anon_2.value AS REAL), 0.0), 0.0) AS value +FROM ( + SELECT coalesce(anon_3.month, anon_4.month) AS month, + coalesce(coalesce(CAST(anon_3.value AS REAL), 0.0) + coalesce(CAST(anon_4.value AS REAL), 0.0), 0.0) AS value + FROM ( + SELECT month AS month, sum(anon_6.value) AS value + FROM ( + SELECT date_trunc('month', day) AS month, coalesce(sum(value), 0.0) AS value + FROM df2 + WHERE day >= CAST('2022-01-01 00:00:00' AS DATE) + AND day <= CAST('2022-01-31 00:00:00' AS DATE) + GROUP BY date_trunc('month', day) + ) AS anon_6 + GROUP BY GROUPING SETS((month)) + ) AS anon_3 + FULL OUTER JOIN ( + SELECT month AS month, sum(anon_5.value) AS value + FROM ( + SELECT date_trunc('month', day) AS month, coalesce(sum(value), 0.0) AS value + FROM df1 + WHERE day >= CAST('2022-01-01 00:00:00' AS DATE) + AND day <= CAST('2022-01-31 00:00:00' AS DATE) + AND (organization ILIKE 'org4') + GROUP BY date_trunc('month', day) + ) AS anon_5 + GROUP BY GROUPING SETS((month)) + ) AS anon_4 ON anon_3.month = anon_4.month +) AS anon_1 +FULL OUTER JOIN ( + SELECT month AS month, sum(anon_7.value) AS value + FROM ( + SELECT date_trunc('month', day) AS month, coalesce(sum(value), 0.0) AS value + FROM df3 + WHERE day >= CAST('2022-01-01 00:00:00' AS DATE) + AND day <= CAST('2022-01-31 00:00:00' AS DATE) + GROUP BY date_trunc('month', day) + ) AS anon_7 + GROUP BY GROUPING SETS((month)) +) AS anon_2 ON anon_1.month = anon_2.month +-- +ok +== diff --git a/parser/testdata/corpus/sql/join/full_outer/test_full_outer_join_range.test b/parser/testdata/corpus/sql/join/full_outer/test_full_outer_join_range.test new file mode 100644 index 0000000..da0bb18 --- /dev/null +++ b/parser/testdata/corpus/sql/join/full_outer/test_full_outer_join_range.test @@ -0,0 +1,13 @@ +# source: test/sql/join/full_outer/test_full_outer_join_range.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +SELECT i, j, k, l FROM integers FULL OUTER JOIN integers2 ON integers.i 5 +GROUP BY n.n_name ORDER BY n.n_name +-- +ok +== +CREATE TABLE nation_list AS SELECT i AS nk, ['NATION_' || (i % 5)] AS n_names FROM range(25) t(i) +-- +ok +== +SELECT n.n_names[1] AS nm, COUNT(*) AS cnt +FROM nation_list n JOIN customer c ON n.nk = c.nk JOIN orders o ON o.ck = c.ck +GROUP BY nm ORDER BY nm +-- +ok +== +CREATE TABLE nation_tiny AS SELECT i AS nk, (i % 5)::TINYINT AS n_t FROM range(25) t(i) +-- +ok +== +SELECT n.n_t, COUNT(*) AS cnt +FROM nation_tiny n JOIN customer c ON n.nk = c.nk JOIN orders o ON o.ck = c.ck +GROUP BY n.n_t ORDER BY n.n_t +-- +ok +== +CREATE TABLE orders_null_probe AS +SELECT i AS ok, CASE WHEN i < 100 THEN NULL ELSE (i % 2000) * 1000 END AS ck FROM range(8000) t(i) +-- +ok +== +SELECT n.n_name, COUNT(*) AS cnt +FROM nation n JOIN customer c ON n.nk = c.nk JOIN orders_null_probe o ON o.ck = c.ck +GROUP BY n.n_name ORDER BY n.n_name +-- +ok +== +CREATE TABLE customer_null_key AS +SELECT CASE WHEN i < 100 THEN NULL ELSE i * 1000 END AS ck, i % 25 AS nk FROM range(2000) t(i) +-- +ok +== +SELECT n.n_name, COUNT(*) AS cnt +FROM nation n JOIN customer_null_key c ON n.nk = c.nk JOIN orders o ON o.ck = c.ck +GROUP BY n.n_name ORDER BY n.n_name +-- +ok +== +CREATE TABLE nation_gap (nk INTEGER, n_name VARCHAR) +-- +ok +== +INSERT INTO nation_gap VALUES (0, 'A'), (1, 'B'), (2, 'A'), (5, 'C'), (6, NULL) +-- +ok +== +CREATE TABLE customer_gap AS +SELECT i * 1000 AS ck, (CASE WHEN i % 7 IN (3, 4) THEN 9 ELSE i % 7 END) AS nk FROM range(2000) t(i) +-- +ok +== +CREATE TABLE orders_gap AS SELECT i AS ok, (i % 2000) * 1000 AS ck FROM range(8000) t(i) +-- +ok +== +SELECT n.n_name, COUNT(*) AS cnt +FROM nation_gap n JOIN customer_gap c ON n.nk = c.nk JOIN orders_gap o ON o.ck = c.ck +GROUP BY n.n_name ORDER BY n.n_name NULLS FIRST +-- +ok +== +SELECT u.n_name, COUNT(*) AS cnt +FROM (SELECT c.ck, n.n_name FROM nation n JOIN customer c ON n.nk = c.nk WHERE 1=0) u +JOIN orders o ON o.ck = u.ck +GROUP BY u.n_name ORDER BY u.n_name +-- +ok +== +CREATE TABLE other_flat AS SELECT i * 1000 + 500 AS ck, 'FLAT_' || (i % 5) AS n_name FROM range(2000) t(i) +-- +ok +== +CREATE TABLE probe_mixed AS SELECT i * 500 AS pk FROM range(8000) t(i) +-- +ok +== +SELECT u.n_name, COUNT(*) AS cnt +FROM probe_mixed p JOIN ( + SELECT c.ck AS ck, n.n_name FROM nation n JOIN customer c ON n.nk = c.nk + UNION ALL + SELECT o.ck, o.n_name FROM other_flat o +) u ON p.pk = u.ck +GROUP BY u.n_name ORDER BY u.n_name +-- +ok +== +ATTACH '{TEST_DIR}/hash_join_dict_surviving.db' AS sdb +-- +ok +== +CREATE TABLE sdb.dim (k VARCHAR, name VARCHAR) +-- +ok +== +INSERT INTO sdb.dim SELECT 'K_' || i, 'NAME_' || (i % 5) FROM range(5000) t(i) +-- +ok +== +CREATE TABLE sdb.fact (id INTEGER, k VARCHAR) +-- +ok +== +INSERT INTO sdb.fact SELECT i, 'K_' || (i % 5000) FROM range(20000) t(i) +-- +ok +== +CHECKPOINT sdb +-- +ok +== +SELECT d.name, COUNT(*) AS cnt FROM sdb.fact f JOIN sdb.dim d ON f.k = d.k GROUP BY d.name ORDER BY d.name +-- +ok +== +PRAGMA force_compression='auto' +-- +ok +== +CREATE TABLE dim AS SELECT 'KEY_' || i AS d_key, 'LABEL_' || (i % 5) AS d_label FROM range(100) t(i) +-- +ok +== +CREATE TABLE fact1 AS SELECT 'KEY_' || (i % 100) AS f1_dkey, 'CUST_' || i AS f1_ckey FROM range(262200) t(i) +-- +ok +== +CREATE TABLE fact2 AS SELECT 'CUST_' || (i % 262200) AS f2_ckey FROM range(524400) t(i) +-- +ok +== +SELECT d.d_label, COUNT(*) AS cnt +FROM dim d JOIN fact1 f1 ON d.d_key = f1.f1_dkey JOIN fact2 f2 ON f1.f1_ckey = f2.f2_ckey +GROUP BY d.d_label ORDER BY d.d_label +-- +ok +== diff --git a/parser/testdata/corpus/sql/join/hash_join/hash_join_dictionary_probe.test b/parser/testdata/corpus/sql/join/hash_join/hash_join_dictionary_probe.test new file mode 100644 index 0000000..02caa19 --- /dev/null +++ b/parser/testdata/corpus/sql/join/hash_join/hash_join_dictionary_probe.test @@ -0,0 +1,204 @@ +# source: test/sql/join/hash_join/hash_join_dictionary_probe.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +CREATE OR REPLACE TABLE dim (k VARCHAR PRIMARY KEY, name VARCHAR); +-- +ok +== +INSERT INTO dim VALUES ('A','Alpha'), ('B','Beta'), ('C','Gamma'), ('D','Delta') +-- +ok +== +CREATE OR REPLACE TABLE fact (id INTEGER, k VARCHAR) +-- +ok +== +INSERT INTO fact SELECT i, CASE i%4 WHEN 0 THEN 'A' WHEN 1 THEN 'B' WHEN 2 THEN 'C' ELSE 'D' END FROM range(5000) t(i) +-- +ok +== +SELECT count(*) FROM fact f JOIN dim d ON f.k = d.k +-- +ok +== +SELECT d.name, count(*) FROM fact f JOIN dim d ON f.k = d.k GROUP BY d.name ORDER BY d.name +-- +ok +== +SELECT count(*) FROM fact f JOIN dim d ON f.k IS NOT DISTINCT FROM d.k +-- +ok +== +INSERT INTO fact VALUES (10001, 'X'), (10002, 'Y'), (10003, 'Z') +-- +ok +== +INSERT INTO fact VALUES (10004, NULL), (10005, NULL) +-- +ok +== +CREATE OR REPLACE TABLE dim_nd AS SELECT * FROM dim +-- +ok +== +INSERT INTO dim_nd VALUES (NULL, 'Null') +-- +ok +== +SELECT d.name, count(*) FROM fact f JOIN dim_nd d ON f.k IS NOT DISTINCT FROM d.k GROUP BY d.name ORDER BY d.name +-- +ok +== +CREATE OR REPLACE TABLE dim_dup (k VARCHAR, v INTEGER) +-- +ok +== +INSERT INTO dim_dup VALUES ('A',1),('A',2),('B',10),('B',20),('B',30),('C',100) +-- +ok +== +SELECT count(*) FROM fact f JOIN dim_dup d ON f.k = d.k +-- +ok +== +SELECT d.k, sum(d.v) FROM fact f JOIN dim_dup d ON f.k = d.k GROUP BY d.k ORDER BY d.k +-- +ok +== +SELECT count(*) FROM fact f LEFT JOIN dim d ON f.k = d.k WHERE d.name IS NULL +-- +ok +== +INSERT INTO dim VALUES ('E','Epsilon') +-- +ok +== +SELECT d.name, count(f.id) FROM fact f RIGHT JOIN dim d ON f.k = d.k GROUP BY d.name ORDER BY d.name +-- +ok +== +SELECT count(*) FROM fact f WHERE f.k IN (SELECT k FROM dim WHERE name IN ('Alpha','Beta')) +-- +ok +== +SELECT count(*) FROM fact f ANTI JOIN dim d ON f.k = d.k +-- +ok +== +SELECT coalesce(d.name, '') AS dim_name, count(*) AS rows +FROM fact f FULL OUTER JOIN dim d ON f.k = d.k +GROUP BY dim_name ORDER BY dim_name +-- +ok +== +SELECT in_dim, count(*) FROM ( + SELECT f.id, f.k IN (SELECT k FROM dim WHERE name IN ('Alpha','Beta')) AS in_dim FROM fact f +) GROUP BY in_dim ORDER BY in_dim NULLS FIRST +-- +ok +== +SELECT count(*) FROM dim WHERE k IN (SELECT k FROM fact WHERE k IS NOT NULL) +-- +ok +== +SELECT count(*) FROM dim d ANTI JOIN fact f ON d.k = f.k +-- +ok +== +SELECT count(*) FROM ( + SELECT f.id, (SELECT d.name FROM dim d WHERE d.k = f.k) AS dim_name FROM fact f +) WHERE dim_name IS NOT NULL +-- +ok +== +CREATE OR REPLACE TABLE fact2 (id INTEGER, k VARCHAR, t INTEGER) +-- +ok +== +INSERT INTO fact2 SELECT id, k, id % 3 FROM fact WHERE k IS NOT NULL +-- +ok +== +CREATE OR REPLACE TABLE dim2 (k VARCHAR, t INTEGER, name VARCHAR) +-- +ok +== +INSERT INTO dim2 VALUES ('A',0,'A0'),('A',1,'A1'),('B',2,'B2') +-- +ok +== +SELECT count(*) FROM fact2 f JOIN dim2 d ON f.k = d.k AND f.t = d.t +-- +ok +== +SELECT count(*) FROM fact f JOIN dim d ON lower(f.k) = lower(d.k) +-- +ok +== +CREATE OR REPLACE TABLE fact_s (k STRUCT(a VARCHAR)) +-- +ok +== +INSERT INTO fact_s SELECT {'a': CASE i%4 WHEN 0 THEN 'A' WHEN 1 THEN 'B' WHEN 2 THEN 'C' ELSE 'D' END} +FROM range(5000) t(i) +-- +ok +== +CREATE OR REPLACE TABLE dim_s (k STRUCT(a VARCHAR), name VARCHAR) +-- +ok +== +INSERT INTO dim_s VALUES ({'a':'A'},'Alpha'),({'a':'B'},'Beta') +-- +ok +== +SELECT count(*) FROM fact_s f JOIN dim_s d ON f.k = d.k +-- +ok +== +SET debug_force_external=true +-- +ok +== +SET debug_force_external=false +-- +ok +== +ATTACH ':memory:' AS mem +-- +ok +== +CREATE TABLE mem.dim AS SELECT * FROM dim +-- +ok +== +CREATE TABLE mem.fact AS SELECT id, k FROM fact LIMIT 100 +-- +ok +== +SELECT count(*) FROM mem.fact f JOIN mem.dim d ON f.k = d.k +-- +ok +== +CREATE TABLE mem.dim_i (k INTEGER PRIMARY KEY, name VARCHAR) +-- +ok +== +INSERT INTO mem.dim_i VALUES (1,'one'),(2,'two'),(3,'three') +-- +ok +== +CREATE TABLE mem.fact_i (k INTEGER) +-- +ok +== +INSERT INTO mem.fact_i SELECT (i % 3) + 1 FROM range(300) t(i) +-- +ok +== +SELECT count(*) FROM mem.fact_i f JOIN mem.dim_i d ON f.k = d.k +-- +ok +== diff --git a/parser/testdata/corpus/sql/join/hash_join/hash_join_residual_predicates.test b/parser/testdata/corpus/sql/join/hash_join/hash_join_residual_predicates.test new file mode 100644 index 0000000..14823e3 --- /dev/null +++ b/parser/testdata/corpus/sql/join/hash_join/hash_join_residual_predicates.test @@ -0,0 +1,311 @@ +# source: test/sql/join/hash_join/hash_join_residual_predicates.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +set disabled_optimizers to 'build_side_probe_side'; +-- +ok +== +INSERT INTO orders VALUES + (1, 100, 'O', 50.00, '1996-01-01', '5-LOW', 'Clerk#000000001', 0, 'pending'), + (2, 100, 'F', 150.00, '1996-01-02', '1-URGENT', 'Clerk#000000002', 0, 'completed'), + (3, 200, 'F', 200.00, '1996-01-03', '2-HIGH', 'Clerk#000000003', 0, 'completed'), + (4, 300, 'O', 80.00, '1996-01-04', '3-MEDIUM', 'Clerk#000000004', 0, 'pending'), + (5, 400, 'F', 300.00, '1996-01-05', '4-NOT SPECIFIED', 'Clerk#000000005', 0, 'completed'); +-- +ok +== +INSERT INTO lineitem VALUES + (1, 100, 1, 1, 10.00, 100.00, 0.05, 0.02, 'N', 'O', '1996-01-10', '1996-01-15', '1996-01-20', 'DELIVER IN PERSON', 'TRUCK', 'test comment 1'), + (2, 100, 2, 1, 20.00, 200.00, 0.05, 0.02, 'N', 'O', '1996-01-11', '1996-01-16', '1996-01-21', 'TAKE BACK RETURN', 'MAIL', 'test comment 2'), + (3, 200, 3, 1, 30.00, 300.00, 0.05, 0.02, 'N', 'F', '1996-01-12', '1996-01-17', '1996-01-22', 'DELIVER IN PERSON', 'SHIP', 'test comment 3'), + (4, 300, 4, 1, 15.00, 150.00, 0.05, 0.02, 'N', 'O', '1996-01-13', '1996-01-18', '1996-01-23', 'NONE', 'AIR', 'test comment 4'), + (5, 500, 5, 1, 25.00, 250.00, 0.05, 0.02, 'N', 'F', '1996-01-14', '1996-01-19', '1996-01-24', 'COLLECT COD', 'RAIL', 'test comment 5'); +-- +ok +== +EXPLAIN SELECT * FROM orders o +INNER JOIN lineitem l ON o.o_orderkey = l.l_orderkey + AND o.o_totalprice + l.l_extendedprice > 250; +-- +ok +== +SELECT o.o_orderkey, o.o_custkey, o.o_totalprice, l.l_orderkey, l.l_partkey, l.l_quantity, l.l_extendedprice +FROM orders o +INNER JOIN lineitem l ON o.o_orderkey = l.l_orderkey + AND o.o_totalprice + l.l_extendedprice > 250; +-- +ok +== +EXPLAIN SELECT * FROM orders o +INNER JOIN lineitem l ON o.o_orderkey = l.l_orderkey + AND o.o_totalprice < l.l_extendedprice + AND o.o_totalprice + l.l_extendedprice > 250; +-- +ok +== +SELECT o.o_orderkey, o.o_custkey, o.o_totalprice, l.l_orderkey, l.l_partkey, l.l_quantity, l.l_extendedprice +FROM orders o +INNER JOIN lineitem l ON o.o_orderkey = l.l_orderkey + AND o.o_totalprice < l.l_extendedprice + AND o.o_totalprice + l.l_extendedprice > 250; +-- +ok +== +EXPLAIN SELECT * FROM orders o +LEFT JOIN lineitem l ON o.o_orderkey = l.l_orderkey + AND o.o_totalprice + l.l_extendedprice > 250; +-- +ok +== +SELECT o.o_orderkey, o.o_custkey, o.o_totalprice, l.l_orderkey, l.l_partkey, l.l_quantity, l.l_extendedprice +FROM orders o +LEFT JOIN lineitem l ON o.o_orderkey = l.l_orderkey + AND o.o_totalprice + l.l_extendedprice > 250; +-- +ok +== +EXPLAIN SELECT * FROM orders o +LEFT JOIN lineitem l ON o.o_orderkey = l.l_orderkey + AND o.o_orderstatus != 'O'; +-- +ok +== +SELECT o.o_orderkey, o.o_custkey, o.o_totalprice, o.o_orderstatus, l.l_orderkey, l.l_partkey, l.l_quantity, l.l_extendedprice +FROM orders o +LEFT JOIN lineitem l ON o.o_orderkey = l.l_orderkey + AND o.o_orderstatus != 'O'; +-- +ok +== +EXPLAIN SELECT * FROM orders o +RIGHT JOIN lineitem l ON o.o_orderkey = l.l_orderkey + AND o.o_totalprice + l.l_extendedprice > 250; +-- +ok +== +SELECT o.o_orderkey, o.o_custkey, o.o_totalprice, l.l_orderkey, l.l_partkey, l.l_quantity, l.l_extendedprice +FROM orders o +RIGHT JOIN lineitem l ON o.o_orderkey = l.l_orderkey + AND o.o_totalprice + l.l_extendedprice > 250; +-- +ok +== +EXPLAIN SELECT * FROM orders o +RIGHT JOIN lineitem l ON o.o_orderkey = l.l_orderkey + AND l.l_shipmode != 'TRUCK'; +-- +ok +== +SELECT o.o_orderkey, o.o_custkey, o.o_totalprice, l.l_orderkey, l.l_partkey, l.l_quantity, l.l_extendedprice +FROM orders o +RIGHT JOIN lineitem l ON o.o_orderkey = l.l_orderkey + AND l.l_shipmode != 'TRUCK'; +-- +ok +== +EXPLAIN SELECT * FROM orders o +FULL OUTER JOIN lineitem l ON o.o_orderkey = l.l_orderkey + AND o.o_totalprice + l.l_extendedprice > 250; +-- +ok +== +SELECT o.o_orderkey, o.o_custkey, o.o_totalprice, l.l_orderkey, l.l_partkey, l.l_quantity, l.l_extendedprice +FROM orders o +FULL OUTER JOIN lineitem l ON o.o_orderkey = l.l_orderkey + AND o.o_totalprice + l.l_extendedprice > 250; +-- +ok +== +EXPLAIN SELECT * FROM orders o +FULL OUTER JOIN lineitem l ON o.o_orderkey = l.l_orderkey + AND o.o_totalprice > 100 AND l.l_shipmode = 'SHIP'; +-- +ok +== +SELECT o.o_orderkey, o.o_custkey, o.o_totalprice, l.l_orderkey, l.l_partkey, l.l_quantity, l.l_extendedprice +FROM orders o +FULL OUTER JOIN lineitem l ON o.o_orderkey = l.l_orderkey + AND o.o_totalprice > 100 AND l.l_shipmode = 'SHIP'; +-- +ok +== +EXPLAIN SELECT * FROM orders o +SEMI JOIN lineitem l ON o.o_orderkey = l.l_orderkey + AND o.o_totalprice + l.l_extendedprice > 250; +-- +ok +== +SELECT o.o_orderkey, o.o_custkey, o.o_totalprice, o.o_orderstatus +FROM orders o +SEMI JOIN lineitem l ON o.o_orderkey = l.l_orderkey + AND o.o_totalprice + l.l_extendedprice > 250; +-- +ok +== +EXPLAIN SELECT * FROM orders o +ANTI JOIN lineitem l ON o.o_orderkey = l.l_orderkey + AND o.o_totalprice + l.l_extendedprice > 250; +-- +ok +== +SELECT o.o_orderkey, o.o_custkey, o.o_totalprice, o.o_orderstatus +FROM orders o +ANTI JOIN lineitem l ON o.o_orderkey = l.l_orderkey + AND o.o_totalprice + l.l_extendedprice > 250; +-- +ok +== +EXPLAIN SELECT * FROM orders o +ANTI JOIN lineitem l ON o.o_orderkey = l.l_orderkey + AND o.o_orderstatus != 'O'; +-- +ok +== +SELECT o.o_orderkey, o.o_custkey, o.o_totalprice, o.o_orderstatus +FROM orders o +ANTI JOIN lineitem l ON o.o_orderkey = l.l_orderkey + AND o.o_orderstatus != 'O'; +-- +ok +== +EXPLAIN SELECT o.o_orderkey, o.o_totalprice, + (SELECT l.l_shipmode FROM lineitem l + WHERE l.l_orderkey = o.o_orderkey + AND l.l_orderkey + o.o_totalprice > 250) +FROM orders o; +-- +ok +== +SELECT o.o_orderkey, o.o_totalprice, + (SELECT l.l_shipmode FROM lineitem l + WHERE l.l_orderkey = o.o_orderkey + AND l.l_orderkey + o.o_totalprice > 250) +FROM orders o; +-- +ok +== +INSERT INTO lineitem VALUES (5, 200, 10, 2, 30.00, 300.00, 0.05, 0.02, 'N', 'F', '1996-01-12', '1996-01-17', '1996-01-22', 'DELIVER IN PERSON', 'SHIP', 'duplicate'); +-- +ok +== +DELETE FROM lineitem WHERE l_comment = 'duplicate'; +-- +ok +== +EXPLAIN SELECT * FROM orders o +WHERE o.o_orderkey NOT IN ( + SELECT l.l_orderkey + FROM lineitem l + WHERE l.l_orderkey = o.o_orderkey + AND o.o_totalprice + l.l_extendedprice > 250 +); +-- +ok +== +SELECT o.o_orderkey, o.o_custkey, o.o_totalprice, o.o_orderstatus +FROM orders o +WHERE o.o_orderkey NOT IN ( + SELECT l.l_orderkey + FROM lineitem l + WHERE l.l_orderkey = o.o_orderkey + AND o.o_totalprice + l.l_extendedprice > 250 +); +-- +ok +== +SELECT COUNT(*) FROM lineitem l +INNER JOIN orders o ON l.l_orderkey = o.o_orderkey + AND l.l_quantity + l.l_extendedprice + l.l_discount > o.o_totalprice; +-- +ok +== +SELECT COUNT(*) FROM lineitem l +INNER JOIN orders o ON l.l_orderkey = o.o_orderkey + AND l.l_extendedprice > o.o_totalprice + o.o_custkey + o.o_shippriority; +-- +ok +== +SELECT COUNT(*) FROM lineitem l +INNER JOIN orders o ON l.l_orderkey = o.o_orderkey + AND l.l_quantity + l.l_extendedprice > o.o_totalprice + AND l.l_quantity + o.o_totalprice > 100; +-- +ok +== +SELECT COUNT(*) FROM lineitem l +INNER JOIN orders o ON l.l_orderkey = o.o_orderkey + AND l.l_partkey + l.l_suppkey * 10 + o.o_custkey > 200 + AND l.l_discount * 100 + (l.l_commitdate::DATE - o.o_orderdate::DATE) > o.o_shippriority + 10; +-- +ok +== +CREATE TABLE residual_empty_probe(a INTEGER, payload INTEGER); +-- +ok +== +CREATE TABLE residual_empty_build(a INTEGER, c INTEGER); +-- +ok +== +INSERT INTO residual_empty_probe VALUES (1, 10), (2, -1); +-- +ok +== +SET disabled_optimizers TO 'build_side_probe_side'; +-- +ok +== +EXPLAIN SELECT p.a, b.c +FROM residual_empty_probe p +LEFT JOIN residual_empty_build b ON p.a = b.a AND p.payload > 0 +ORDER BY ALL; +-- +ok +== +SELECT p.a, b.c +FROM residual_empty_probe p +LEFT JOIN residual_empty_build b ON p.a = b.a AND p.payload > 0 +ORDER BY ALL; +-- +ok +== +CREATE TABLE l(k INTEGER, v INTEGER); +-- +ok +== +CREATE TABLE r(k INTEGER, v INTEGER); +-- +ok +== +INSERT INTO l VALUES + (1, 1), + (-1, 5), + (2, 1); +-- +ok +== +INSERT INTO r VALUES + (1, 5), + (-1, 0), + (1, 1); +-- +ok +== +SELECT * +FROM l ANTI JOIN r + ON l.k = r.k + AND l.v + r.v > 2 +ORDER BY k; +-- +ok +== +SELECT * +FROM l SEMI JOIN r + ON l.k = r.k + AND l.v + r.v > 2 +ORDER BY k; +-- +ok +== diff --git a/parser/testdata/corpus/sql/join/iejoin/iejoin_issue_6861.test b/parser/testdata/corpus/sql/join/iejoin/iejoin_issue_6861.test new file mode 100644 index 0000000..c866b90 --- /dev/null +++ b/parser/testdata/corpus/sql/join/iejoin/iejoin_issue_6861.test @@ -0,0 +1,74 @@ +# source: test/sql/join/iejoin/iejoin_issue_6861.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +CREATE TABLE test(x INT); +-- +ok +== +SET merge_join_threshold=0 +-- +ok +== +SET nested_loop_join_threshold=0; +-- +ok +== +SELECT * +FROM test AS a, test AS b +WHERE (a.x BETWEEN b.x AND b.x); +-- +ok +== +INSERT INTO test(x) VALUES (1), (2), (3), (NULL), (NULL), (NULL); +-- +ok +== +CREATE TABLE all_null AS SELECT * FROM test; +-- +ok +== +UPDATE all_null SET x=(NULL); +-- +ok +== +EXPLAIN +SELECT * +FROM all_null AS a, all_null AS b +WHERE (a.x BETWEEN b.x AND b.x); +-- +ok +== +SELECT * +FROM all_null AS a, all_null AS b +WHERE (a.x BETWEEN b.x AND b.x); +-- +ok +== +EXPLAIN +SELECT * +FROM test AS a, all_null AS b +WHERE (a.x BETWEEN b.x AND b.x); +-- +ok +== +SELECT * +FROM test AS a, all_null AS b +WHERE (a.x BETWEEN b.x AND b.x); +-- +ok +== +EXPLAIN +SELECT * +FROM all_null AS a, test AS b +WHERE (a.x BETWEEN b.x AND b.x); +-- +ok +== +SELECT * +FROM all_null AS a, test AS b +WHERE (a.x BETWEEN b.x AND b.x); +-- +ok +== diff --git a/parser/testdata/corpus/sql/join/iejoin/iejoin_issue_7278.test b/parser/testdata/corpus/sql/join/iejoin/iejoin_issue_7278.test new file mode 100644 index 0000000..ae15390 --- /dev/null +++ b/parser/testdata/corpus/sql/join/iejoin/iejoin_issue_7278.test @@ -0,0 +1,98 @@ +# source: test/sql/join/iejoin/iejoin_issue_7278.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +create table calendar as + SELECT + start_ts, + start_ts + interval '12 hours' as end_ts, + date_part('year',start_ts)::bigint * 100 + date_part('week',start_ts)::bigint as yyyyww + FROM generate_series(TIMESTAMP '2023-01-01 06:00:00', TIMESTAMP '2023-06-01 00:00:00', INTERVAL '12 hours') tbl(start_ts) +; +-- +ok +== +create table snapshot_data as + select + TIMESTAMP '2023-03-01 08:00:00' as snapshot_ts, + 1 as snapshot_value + from generate_series(1,1000) t(i) +; +-- +ok +== +create table cal_last_13 as( + select * from calendar where yyyyww in (SELECT yyyyww + FROM calendar) +); +-- +ok +== +explain +select + count(*) +from snapshot_data data +join cal_last_13 cal + on data.snapshot_ts >= cal.start_ts + and data.snapshot_ts <= cal.end_ts +-- +ok +== +select + count(*) +from snapshot_data data +join cal_last_13 cal + on data.snapshot_ts >= cal.start_ts + and data.snapshot_ts <= cal.end_ts +-- +ok +== +create or replace table cal_last_13 as ( + select * from calendar where yyyyww in (SELECT yyyyww + FROM calendar) + union all + select * from calendar where yyyyww in (SELECT yyyyww + FROM calendar) +); +-- +ok +== +create or replace table cal_last_13 as ( + select * from calendar where yyyyww in (SELECT yyyyww + FROM calendar) + union all + select * from calendar where yyyyww in (SELECT yyyyww + FROM calendar) + union all + select * from calendar where yyyyww in (SELECT yyyyww + FROM calendar) +); +-- +ok +== +explain +select + count(*) +from snapshot_data data +join cal_last_13 cal + on data.snapshot_ts >= cal.start_ts + and data.snapshot_ts <= cal.end_ts +join cal_last_13 cal2 + on data.snapshot_ts >= cal2.start_ts + and data.snapshot_ts <= cal2.end_ts +-- +ok +== +select + count(*) +from snapshot_data data +join cal_last_13 cal + on data.snapshot_ts >= cal.start_ts + and data.snapshot_ts <= cal.end_ts +join cal_last_13 cal2 + on data.snapshot_ts >= cal2.start_ts + and data.snapshot_ts <= cal2.end_ts +-- +ok +== diff --git a/parser/testdata/corpus/sql/join/iejoin/merge_join_switch.test b/parser/testdata/corpus/sql/join/iejoin/merge_join_switch.test new file mode 100644 index 0000000..1cf4f72 --- /dev/null +++ b/parser/testdata/corpus/sql/join/iejoin/merge_join_switch.test @@ -0,0 +1,42 @@ +# source: test/sql/join/iejoin/merge_join_switch.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +CREATE TABLE bigtbl AS FROM range(1000) t(i); +-- +ok +== +CREATE TABLE smalltbl AS SELECT i AS low, i + 1 AS high FROM range(100) t(i); +-- +ok +== +PRAGMA explain_output = 'PHYSICAL_ONLY'; +-- +ok +== +EXPLAIN SELECT COUNT(*) FROM bigtbl JOIN smalltbl ON (bigtbl.i BETWEEN low AND high) +-- +ok +== +SET merge_join_threshold=1000 +-- +ok +== +SET nested_loop_join_threshold=1000 +-- +ok +== +SET prefer_range_joins=true +-- +ok +== +EXPLAIN +SELECT COUNT(*) FROM bigtbl JOIN smalltbl ON (bigtbl.i BETWEEN low AND high AND bigtbl.i IS NOT DISTINCT FROM high - low) +-- +ok +== +SELECT COUNT(*) FROM bigtbl JOIN smalltbl ON (bigtbl.i BETWEEN low AND high AND bigtbl.i IS NOT DISTINCT FROM high - low) +-- +ok +== diff --git a/parser/testdata/corpus/sql/join/iejoin/predicate_expressions.test b/parser/testdata/corpus/sql/join/iejoin/predicate_expressions.test new file mode 100644 index 0000000..c861bfb --- /dev/null +++ b/parser/testdata/corpus/sql/join/iejoin/predicate_expressions.test @@ -0,0 +1,99 @@ +# source: test/sql/join/iejoin/predicate_expressions.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +create table calendar as SELECT * +FROM range(DATE '2022-01-01', DATE '2024-02-01', INTERVAL '1' MONTH); +-- +ok +== +create table scd2 as +select + range as range_start, + case when date_part('year', range) < 2023 then range + interval 4 month - interval 1 day end as range_end, + n +from calendar +cross join generate_series(1, 85) as n +-- +ok +== +create table scd2_non_null as +select + range as range_start, + case when date_part('year', range) < 2023 then range + interval 4 month - interval 1 day else '2099-01-01' end as range_end, + n +from calendar +cross join generate_series(1, 85) as n +-- +ok +== +explain +select + range, + count(*) as n +from scd2_non_null +inner join calendar + on range between range_start and ifnull(range_end,'2099-01-01') +group by range +order by range +-- +ok +== +select + range, + count(*) as n +from scd2_non_null +inner join calendar + on range between range_start and ifnull(range_end,'2099-01-01') +group by range +order by range +-- +ok +== +explain +select + range, + count(*) as n +from scd2 +inner join calendar + on range <= ifnull(range_end,'2099-01-01') and range_start <= range +group by range +order by range +-- +ok +== +select + range, + count(*) as n +from scd2 +inner join calendar + on range <= ifnull(range_end,'2099-01-01') and range_start <= range +group by range +order by range +-- +ok +== +explain +select + range, + count(*) as n +from scd2 +inner join calendar + on range between range_start and ifnull(range_end,'2099-01-01') +group by range +order by range +-- +ok +== +select + range, + count(*) as n +from scd2 +inner join calendar + on range between range_start and ifnull(range_end,'2099-01-01') +group by range +order by range +-- +ok +== diff --git a/parser/testdata/corpus/sql/join/iejoin/test_countzeros.test b/parser/testdata/corpus/sql/join/iejoin/test_countzeros.test new file mode 100644 index 0000000..2710931 --- /dev/null +++ b/parser/testdata/corpus/sql/join/iejoin/test_countzeros.test @@ -0,0 +1,49 @@ +# source: test/sql/join/iejoin/test_countzeros.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +set merge_join_threshold=0; +-- +ok +== +set prefer_range_joins=True; +-- +ok +== +create or replace table states as + select + i // 100 as k, + '2024-01-01'::TIMESTAMP + INTERVAL (i // 1) seconds as b, + b + INTERVAL 1 second as e, + from range(100_000) as tbl(i); +-- +ok +== +with joined as ( + select lhs.k l, rhs.k r + from states lhs + inner join states rhs + on lhs.b < rhs.e + and rhs.b < lhs.e + and lhs.k = rhs.k +) +select count(*) +from joined +-- +ok +== +explain +with joined as ( + select lhs.k l, rhs.k r + from states lhs + inner join states rhs + on lhs.b < rhs.e + and rhs.b < lhs.e + and lhs.k = rhs.k +) +select count(*) +from joined +-- +ok +== diff --git a/parser/testdata/corpus/sql/join/iejoin/test_ieantijoin.test b/parser/testdata/corpus/sql/join/iejoin/test_ieantijoin.test new file mode 100644 index 0000000..85c8354 --- /dev/null +++ b/parser/testdata/corpus/sql/join/iejoin/test_ieantijoin.test @@ -0,0 +1,239 @@ +# source: test/sql/join/iejoin/test_ieantijoin.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +CREATE TABLE left_small( + id INTEGER, + start DATE, + stop DATE, + symbol VARCHAR, + price DECIMAL +); +-- +ok +== +INSERT INTO left_small VALUES + (1, '2026-01-01', '2026-01-02', 'A', 150.00), + (2, '2026-01-02', '2026-01-03', 'A', 151.00), + (3, '2026-01-03', '2026-01-04', 'B', 380.00), + (4, '2026-01-05', NULL, 'C', 410.0), + (5, NULL, '2026-01-06', 'C', 420.0); +-- +ok +== +CREATE TABLE right_small ( + id INTEGER, + start DATE, + stop DATE, + symbol VARCHAR, + bid DECIMAL, + active BOOLEAN +); +-- +ok +== +INSERT INTO right_small VALUES + (1, '2026-01-01', '2026-01-03', 'A', 149.50, true), + (2, '2026-01-03', '2026-01-04', 'A', 150.50, false), + (3, '2026-01-04', '2026-01-05', 'B', 379.00, true); +-- +ok +== +EXPLAIN +SELECT l.id, l.start, l.stop +FROM left_small l +ANTI JOIN right_small r + ON l.start < r.stop + AND r.start < l.stop +ORDER BY 1 +-- +ok +== +EXPLAIN +SELECT l.id, l.start, l.stop +FROM left_small l +ANTI JOIN right_small r + ON l.start < r.stop + AND r.start < l.stop + AND l.symbol = r.symbol +ORDER BY 1 +-- +ok +== +EXPLAIN +SELECT l.id, l.start, l.stop +FROM left_small l +ANTI JOIN right_small r + ON l.start < r.stop + AND r.start < l.stop + AND l.price + r.bid > 300 +ORDER BY 1 +-- +ok +== +EXPLAIN +SELECT l.id, l.start, l.stop +FROM left_small l +ANTI JOIN right_small r + ON l.start < r.stop + AND r.start < l.stop + AND l.symbol = r.symbol + AND l.price + r.bid > 300 +ORDER BY 1 +-- +ok +== +SET prefer_range_joins={prefer} +-- +error: Parser Error: syntax error at or near "}" +== +SELECT l.id, l.start, l.stop +FROM left_small l +ANTI JOIN right_small r + ON l.start < r.stop + AND r.start < l.stop +ORDER BY 1 +-- +ok +== +SELECT l.id, l.start, l.stop +FROM left_small l +ANTI JOIN right_small r + ON l.start < r.stop + AND r.start < l.stop + AND l.symbol = r.symbol +ORDER BY 1 +-- +ok +== +SELECT l.id, l.start, l.stop +FROM left_small l +ANTI JOIN right_small r + ON l.start < r.stop + AND r.start < l.stop + AND l.price + r.bid > 300 +ORDER BY 1 +-- +ok +== +SELECT l.id, l.start, l.stop +FROM left_small l +ANTI JOIN right_small r + ON l.start < r.stop + AND r.start < l.stop + AND l.symbol = r.symbol + AND l.price + r.bid > 300 +ORDER BY 1 +-- +ok +== +CREATE OR REPLACE TABLE wide_ranges AS ( + SELECT + id, + '2026-01-01'::TIMESTAMP + INTERVAL (id * 5 * 2048 // 7) SECONDS AS start, + '2026-01-01'::TIMESTAMP + INTERVAL ((id + 1) * 5 * 2048 // 7) SECONDS AS stop, + CHR(65 + (id % 26)::INTEGER) AS symbol, + 149.5 + id * 5 * 2048 / 700.0 AS price, + FROM range(8) tbl(id) +); +-- +ok +== +UPDATE wide_ranges SET start = NULL WHERE id = 6; +-- +ok +== +UPDATE wide_ranges SET stop = NULL WHERE id = 7; +-- +ok +== +CREATE OR REPLACE TABLE narrow_ranges AS ( + SELECT + id, + '2026-01-01'::TIMESTAMP + INTERVAL (id + 15 * 2048 // 7) SECONDS AS start, + start + INTERVAL 1 SECOND AS stop, + CHR(65 + (id % 26)::INTEGER) AS symbol, + 150.0 + id / 100.0 AS bid, + (id % 2)::BOOLEAN AS active, + FROM range(2048*5) tbl(id) +); +-- +ok +== +EXPLAIN +FROM wide_ranges l +ANTI JOIN narrow_ranges r + ON l.start < r.stop + AND r.start < l.stop +ORDER BY id; +-- +ok +== +EXPLAIN +FROM wide_ranges l +ANTI JOIN narrow_ranges r + ON l.start < r.stop + AND r.start < l.stop + AND r.symbol = l.symbol +ORDER BY id; +-- +ok +== +EXPLAIN +FROM wide_ranges l +ANTI JOIN narrow_ranges r + ON l.start < r.stop + AND r.start < l.stop + AND l.price + r.bid < 400 +ORDER BY id; +-- +ok +== +EXPLAIN +FROM wide_ranges l +ANTI JOIN narrow_ranges r + ON l.start < r.stop + AND r.start < l.stop + AND r.symbol = l.symbol + AND l.price + r.bid < 375 +ORDER BY id; +-- +ok +== +FROM wide_ranges l +ANTI JOIN narrow_ranges r + ON l.start < r.stop + AND r.start < l.stop +ORDER BY id; +-- +ok +== +FROM wide_ranges l +ANTI JOIN narrow_ranges r + ON l.start < r.stop + AND r.start < l.stop + AND r.symbol = l.symbol +ORDER BY id; +-- +ok +== +FROM wide_ranges l +ANTI JOIN narrow_ranges r + ON l.start < r.stop + AND r.start < l.stop + AND l.price + r.bid < 400 +ORDER BY id; +-- +ok +== +FROM wide_ranges l +ANTI JOIN narrow_ranges r + ON l.start < r.stop + AND r.start < l.stop + AND r.symbol = l.symbol + AND l.price + r.bid < 375 +ORDER BY id; +-- +ok +== diff --git a/parser/testdata/corpus/sql/join/iejoin/test_iejoin.test b/parser/testdata/corpus/sql/join/iejoin/test_iejoin.test new file mode 100644 index 0000000..7f26786 --- /dev/null +++ b/parser/testdata/corpus/sql/join/iejoin/test_iejoin.test @@ -0,0 +1,118 @@ +# source: test/sql/join/iejoin/test_iejoin.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +WITH test AS ( + SELECT + i AS id, + i AS begin, + i + 10 AS end, + i % 2 AS p1, + i % 3 AS p2 + FROM range(0, 10) tbl(i) +) +SELECT lhs.id, rhs.id +FROM test lhs, test rhs +WHERE lhs.begin < rhs.end + AND rhs.begin < lhs.end + AND lhs.p1 <> rhs.p1 + AND lhs.p2 <> rhs.p2 +ORDER BY ALL +-- +ok +== +WITH test AS ( + SELECT + i AS id, + i AS begin, + i + 10 AS end, + i % 2 AS p1, + i % 3 AS p2 + FROM range(0, 10) tbl(i) +), +sub AS ( + SELECT lhs.id AS lid, rhs.id AS rid + FROM test lhs, test rhs + WHERE lhs.begin < rhs.end + AND rhs.begin < lhs.end + AND lhs.p1 <> rhs.p1 + AND lhs.p2 <> rhs.p2 + ORDER BY ALL +) +SELECT MIN(lid), MAX(rid) +FROM sub +-- +ok +== +WITH RECURSIVE t AS +( + SELECT 1 AS x, 0 AS begin, 4 AS end +UNION ALL + SELECT lhs.x + 1 AS x, + GREATEST(lhs.begin, rhs.begin) as begin, + LEAST(lhs.end, rhs.end) AS end + FROM t lhs, t rhs + WHERE lhs.begin + 1 < rhs.end - 1 + AND rhs.begin + 1 < lhs.end - 1 + AND lhs.x < 3 +) +SELECT COUNT(*) FROM t +-- +ok +== +CREATE TABLE issue3486 AS +SELECT generate_series as ts from generate_series(timestamp '2020-01-01', timestamp '2021-01-01', interval 1 day); +-- +ok +== +WITH data_table AS ( + SELECT epoch(ts) as ts + FROM issue3486 + WHERE ts IS NOT NULL + ), + S AS ( + SELECT + min(ts) as minVal, + max(ts) as maxVal, + (max(ts) - min(ts)) as range + FROM data_table + ), + buckets AS ( + SELECT + range as bucket, + (range) * (select range FROM S) / 40 + (select minVal from S) as low, + (range + 1) * (select range FROM S) / 40 + (select minVal from S) as high + FROM range(0, 40, 1) + ) + SELECT + bucket, + low, + high, + count(data_table.ts) as count + FROM buckets + LEFT JOIN data_table ON (data_table.ts >= low AND data_table.ts < high) + GROUP BY bucket, low, high + ORDER BY bucket; +-- +ok +== +create table test_big as select range i, range + 100_000 j, 'hello' k from range (20_000) +-- +ok +== +create table test_small as select range i, range + 100_000 j, 'hello' k from range (0,20_000,10) +-- +ok +== +select * +from test_small t1 +join test_small t2 +on (t1.i = t2.j) +join test_small t3 +on (true) +join test_big t4 +on (t3.i < t4.i and t3.j > t4.j) +-- +ok +== diff --git a/parser/testdata/corpus/sql/join/iejoin/test_iejoin_east_west.test b/parser/testdata/corpus/sql/join/iejoin/test_iejoin_east_west.test new file mode 100644 index 0000000..da1a5e2 --- /dev/null +++ b/parser/testdata/corpus/sql/join/iejoin/test_iejoin_east_west.test @@ -0,0 +1,89 @@ +# source: test/sql/join/iejoin/test_iejoin_east_west.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +CREATE TABLE east AS SELECT * FROM (VALUES + ('r1', 100, 140, 12, 2), + ('r2', 101, 100, 12, 8), + ('r3', 103, 90, 5, 4) +) east(rid, id, dur, rev, cores) +-- +ok +== +CREATE TABLE west AS SELECT * FROM (VALUES + ('s1', 404, 100, 6, 4), + ('s2', 498, 140, 11, 2), + ('s3', 676, 80, 10, 1), + ('s4', 742, 90, 5, 4) +) west(rid, t_id, time, cost, cores) +-- +ok +== +EXPLAIN +SELECT s1.rid, s2.rid +FROM west s1, west s2 +WHERE s1.time > s2.time +ORDER BY 1, 2 +-- +ok +== +SELECT s1.rid, s2.rid +FROM west s1, west s2 +WHERE s1.time > s2.time +ORDER BY 1, 2 +-- +ok +== +EXPLAIN +SELECT s1.rid, s2.rid +FROM west s1, west s2 +WHERE s1.time > s2.time AND s1.cost < s2.cost +ORDER BY 1, 2 +-- +ok +== +SELECT s1.rid, s2.rid +FROM west s1, west s2 +WHERE s1.time > s2.time AND s1.cost < s2.cost +ORDER BY 1, 2 +-- +ok +== +EXPLAIN +SELECT east.rid, west.rid +FROM east, west +WHERE east.dur < west.time AND east.rev > west.cost +ORDER BY 1, 2 +-- +ok +== +SELECT east.rid, west.rid +FROM east, west +WHERE east.dur < west.time AND east.rev > west.cost +ORDER BY 1, 2 +-- +ok +== +CREATE TABLE weststr AS ( + SELECT rid, time::VARCHAR AS time, cost::VARCHAR as cost + FROM west +); +-- +ok +== +EXPLAIN +SELECT s1.rid, s2.rid +FROM weststr s1, weststr s2 +WHERE s1.time > s2.time AND s1.cost < s2.cost +ORDER BY 1, 2 +-- +ok +== +SELECT s1.rid, s2.rid +FROM weststr s1, weststr s2 +WHERE s1.time > s2.time AND s1.cost < s2.cost +ORDER BY 1, 2 +-- +ok +== diff --git a/parser/testdata/corpus/sql/join/iejoin/test_iejoin_events.test b/parser/testdata/corpus/sql/join/iejoin/test_iejoin_events.test new file mode 100644 index 0000000..277645f --- /dev/null +++ b/parser/testdata/corpus/sql/join/iejoin/test_iejoin_events.test @@ -0,0 +1,43 @@ +# source: test/sql/join/iejoin/test_iejoin_events.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +CREATE TABLE events AS ( + SELECT *, + "start" + INTERVAL (CASE WHEN random() < 0.1 THEN 120 ELSE (5 + round(random() * 50, 0)::BIGINT) END) MINUTE + AS "end" + FROM ( + SELECT id, + 'Event ' || id::VARCHAR as "name", + (5 + round(random() * 5000, 0)::BIGINT) AS audience, + '1992-01-01'::TIMESTAMP + + INTERVAL (round(random() * 40 * 365, 0)::BIGINT) DAY + + INTERVAL (round(random() * 23, 0)::BIGINT) HOUR + AS "start", + 'Sponsor ' || (1 + round(random() * 10, 0)::BIGINT) AS sponsor + FROM range(1, 1000) tbl(id) + ) q +); +-- +ok +== +EXPLAIN +SELECT COUNT(*) FROM ( + SELECT r.id, s.id + FROM events r, events s + WHERE r.start <= s.end AND r.end >= s.start + AND r.id <> s.id +) q2; +-- +ok +== +SELECT COUNT(*) FROM ( + SELECT r.id, s.id + FROM events r, events s + WHERE r.start <= s.end AND r.end >= s.start + AND r.id <> s.id +) q2; +-- +ok +== diff --git a/parser/testdata/corpus/sql/join/iejoin/test_iejoin_null_keys.test b/parser/testdata/corpus/sql/join/iejoin/test_iejoin_null_keys.test new file mode 100644 index 0000000..0b5e510 --- /dev/null +++ b/parser/testdata/corpus/sql/join/iejoin/test_iejoin_null_keys.test @@ -0,0 +1,65 @@ +# source: test/sql/join/iejoin/test_iejoin_null_keys.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +SET nested_loop_join_threshold=0 +-- +ok +== +create table tt (x int, y int, z int); +-- +ok +== +insert into tt select nullif(r % 3, 0), nullif (r % 5, 0), r from range(10) tbl(r); +-- +ok +== +EXPLAIN +select * +from tt t1 left join tt t2 +on t1.x < t2.x and t1.y < t2.y +order by t1.x nulls first, t1.y nulls first, t1.z, t2.x, t2.y, t2.z; +-- +ok +== +select * +from tt t1 left join tt t2 +on t1.x < t2.x and t1.y < t2.y +order by t1.x nulls first, t1.y nulls first, t1.z, t2.x, t2.y, t2.z; +-- +ok +== +pragma disable_optimizer; +-- +ok +== +create table tt2 (x int); +-- +ok +== +insert into tt2 select * from range(10); +-- +ok +== +explain +select t1.x, t1.y +from ( + select (case when x < 100 then null else 99 end) x, (case when x < 100 then 99 else 99 end) y + from tt2 +) t1 left join tt2 t2 +on t1.x < t2.x and t1.y < t2.x +order by t1.x nulls first, t1.y nulls first; +-- +ok +== +select t1.x, t1.y +from ( + select (case when x < 100 then null else 99 end) x, (case when x < 100 then 99 else 99 end) y + from tt2 +) t1 left join tt2 t2 +on t1.x < t2.x and t1.y < t2.x +order by t1.x nulls first, t1.y nulls first; +-- +ok +== diff --git a/parser/testdata/corpus/sql/join/iejoin/test_iejoin_overlaps.test b/parser/testdata/corpus/sql/join/iejoin/test_iejoin_overlaps.test new file mode 100644 index 0000000..120fc49 --- /dev/null +++ b/parser/testdata/corpus/sql/join/iejoin/test_iejoin_overlaps.test @@ -0,0 +1,31 @@ +# source: test/sql/join/iejoin/test_iejoin_overlaps.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +EXPLAIN +SELECT t1.x, t2.x +FROM 'test/sql/join/iejoin/overlap.left.csv' t1, 'test/sql/join/iejoin/overlap.right.csv' t2 +WHERE t1.x < t2.x AND t1.y > t2.y; +-- +ok +== +SELECT t1.x, t2.x +FROM 'test/sql/join/iejoin/overlap.left.csv' t1, 'test/sql/join/iejoin/overlap.right.csv' t2 +WHERE t1.x < t2.x AND t1.y > t2.y; +-- +ok +== +SELECT t1.x, t2.x +FROM 'test/sql/join/iejoin/overlap.left.csv' t1, 'test/sql/join/iejoin/overlap.right.csv' t2 +WHERE t1.y > t2.y AND t1.x < t2.x; +-- +ok +== +EXPLAIN +SELECT t1.x, t2.x +FROM 'test/sql/join/iejoin/overlap.left.csv' t1, 'test/sql/join/iejoin/overlap.right.csv' t2 +WHERE t1.y > t2.y AND t1.x < t2.x; +-- +ok +== diff --git a/parser/testdata/corpus/sql/join/iejoin/test_iejoin_predicate.test b/parser/testdata/corpus/sql/join/iejoin/test_iejoin_predicate.test new file mode 100644 index 0000000..010884a --- /dev/null +++ b/parser/testdata/corpus/sql/join/iejoin/test_iejoin_predicate.test @@ -0,0 +1,97 @@ +# source: test/sql/join/iejoin/test_iejoin_predicate.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +create or replace table tleft as + select + i as k100, + '2024-01-01'::TIMESTAMP + INTERVAL (i) seconds as b100, + b100 + INTERVAL 1 second as e100, + from range(10) as tbl(i); +-- +ok +== +select l.k100 as lid, r.k100 as rid +from tleft l +inner join tleft r +on l.b100 < r.e100 +and r.b100 < l.e100 +and l.k100 + r.k100 < 10 +order by 1 +-- +ok +== +explain +select l.k100 as lid, r.k100 as rid +from tleft l +left join tleft r +on l.b100 < r.e100 +and r.b100 < l.e100 +and l.k100 + r.k100 < 10 +order by 1 +-- +ok +== +select l.k100 as lid, r.k100 as rid +from tleft l +left join tleft r +on l.b100 < r.e100 +and r.b100 < l.e100 +and l.k100 + r.k100 < 10 +order by 1 +-- +ok +== +explain +select l.k100 as lid, r.k100 as rid +from tleft l +right join tleft r +on l.b100 < r.e100 +and r.b100 < l.e100 +and l.k100 + r.k100 < 10 +order by 2 +-- +ok +== +select l.k100 as lid, r.k100 as rid +from tleft l +right join tleft r +on l.b100 < r.e100 +and r.b100 < l.e100 +and l.k100 + r.k100 < 10 +order by 2 +-- +ok +== +explain +select l.k100 as lid, r.k100 as rid +from tleft l +full join tleft r +on l.b100 < r.e100 +and r.b100 < l.e100 +and l.k100 + r.k100 < 10 +order by all +-- +ok +== +select l.k100 as lid, r.k100 as rid +from tleft l +full join tleft r +on l.b100 < r.e100 +and r.b100 < l.e100 +and l.k100 + r.k100 < 10 +order by all +-- +ok +== +SELECT count(*) +FROM range(1000) r(i), + range(1000) d(j) +WHERE d.j >= r.i-1 + AND d.j <= r.i+1 + AND d.j%3 >= r.i%3 + AND d.j%3 <= r.i%3; +-- +ok +== diff --git a/parser/testdata/corpus/sql/join/iejoin/test_iesemijoin.test b/parser/testdata/corpus/sql/join/iejoin/test_iesemijoin.test new file mode 100644 index 0000000..3a6fe34 --- /dev/null +++ b/parser/testdata/corpus/sql/join/iejoin/test_iesemijoin.test @@ -0,0 +1,186 @@ +# source: test/sql/join/iejoin/test_iesemijoin.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +INSERT INTO left_small VALUES + (1, '2026-01-01', '2026-01-02', 'A', 150.00), + (2, '2026-01-02', '2026-01-03', 'A', 151.00), + (3, '2026-01-03', '2026-01-04', 'B', 380.00); +-- +ok +== +EXPLAIN +SELECT l.id, l.start, l.stop +FROM left_small l +SEMI JOIN right_small r + ON l.start < r.stop + AND r.start < l.stop +ORDER BY 1 +-- +ok +== +EXPLAIN +SELECT l.id, l.start, l.stop +FROM left_small l +SEMI JOIN right_small r + ON l.start < r.stop + AND r.start < l.stop + AND l.symbol = r.symbol +ORDER BY 1 +-- +ok +== +EXPLAIN +SELECT l.id, l.start, l.stop +FROM left_small l +SEMI JOIN right_small r + ON l.start < r.stop + AND r.start < l.stop + AND l.price + r.bid > 300 +ORDER BY 1 +-- +ok +== +EXPLAIN +SELECT l.id, l.start, l.stop +FROM left_small l +SEMI JOIN right_small r + ON l.start < r.stop + AND r.start < l.stop + AND l.symbol = r.symbol + AND l.price + r.bid > 300 +ORDER BY 1 +-- +ok +== +SELECT l.id, l.start, l.stop +FROM left_small l +SEMI JOIN right_small r + ON l.start < r.stop + AND r.start < l.stop +ORDER BY 1 +-- +ok +== +SELECT l.id, l.start, l.stop +FROM left_small l +SEMI JOIN right_small r + ON l.start < r.stop + AND r.start < l.stop + AND l.symbol = r.symbol +ORDER BY 1 +-- +ok +== +SELECT l.id, l.start, l.stop +FROM left_small l +SEMI JOIN right_small r + ON l.start < r.stop + AND r.start < l.stop + AND l.price + r.bid > 300 +ORDER BY 1 +-- +ok +== +SELECT l.id, l.start, l.stop +FROM left_small l +SEMI JOIN right_small r + ON l.start < r.stop + AND r.start < l.stop + AND l.symbol = r.symbol + AND l.price + r.bid > 300 +ORDER BY 1 +-- +ok +== +CREATE OR REPLACE TABLE wide_ranges AS ( + SELECT + id, + '2026-01-01'::TIMESTAMP + INTERVAL (id * 5 * 2048 // 7) SECONDS AS start, + '2026-01-01'::TIMESTAMP + INTERVAL ((id + 1) * 5 * 2048 // 7) SECONDS AS stop, + CHR(65 + (id % 26)::INTEGER) AS symbol, + 149.5 + id * 5 * 2048 / 700.0 AS price, + FROM range(6) tbl(id) +); +-- +ok +== +CREATE OR REPLACE TABLE narrow_ranges AS ( + SELECT + id, + '2026-01-01'::TIMESTAMP + INTERVAL (id) SECONDS AS start, + start + INTERVAL 1 SECOND AS stop, + CHR(65 + (id % 26)::INTEGER) AS symbol, + 150.0 + id / 100.0 AS bid, + (id % 2)::BOOLEAN AS active, + FROM range(2048*5) tbl(id) +); +-- +ok +== +EXPLAIN +FROM wide_ranges l +SEMI JOIN narrow_ranges r + ON l.start < r.stop + AND r.start < l.stop +ORDER BY id; +-- +ok +== +EXPLAIN +FROM wide_ranges l +SEMI JOIN narrow_ranges r + ON l.start < r.stop + AND r.start < l.stop + AND r.symbol = l.symbol +ORDER BY id; +-- +ok +== +EXPLAIN +FROM wide_ranges l +SEMI JOIN narrow_ranges r + ON l.start < r.stop + AND r.start < l.stop + AND l.price + r.bid > 180 +ORDER BY id; +-- +ok +== +FROM wide_ranges l +SEMI JOIN narrow_ranges r + ON l.start < r.stop + AND r.start < l.stop +ORDER BY id; +-- +ok +== +FROM wide_ranges l +SEMI JOIN narrow_ranges r + ON l.start < r.stop + AND r.start < l.stop + AND r.symbol = l.symbol +ORDER BY id; +-- +ok +== +FROM wide_ranges l +SEMI JOIN narrow_ranges r + ON l.start < r.stop + AND r.start < l.stop + AND l.price + r.bid < 400 +ORDER BY id; +-- +ok +== +FROM wide_ranges l +SEMI JOIN narrow_ranges r + ON l.start < r.stop + AND r.start < l.stop + AND r.symbol = l.symbol + AND l.price + r.bid < 375 +ORDER BY id; +-- +ok +== diff --git a/parser/testdata/corpus/sql/join/inner/empty_tinyint_column.test b/parser/testdata/corpus/sql/join/inner/empty_tinyint_column.test new file mode 100644 index 0000000..8c9b8e6 --- /dev/null +++ b/parser/testdata/corpus/sql/join/inner/empty_tinyint_column.test @@ -0,0 +1,25 @@ +# source: test/sql/join/inner/empty_tinyint_column.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +CREATE TABLE t1(c0 INT4, c1 VARCHAR); +-- +ok +== +CREATE TABLE t2(c0 TINYINT, PRIMARY KEY(c0)); +-- +ok +== +INSERT INTO t1(c0) VALUES (14161972); +-- +ok +== +INSERT INTO t1(c0, c1) VALUES (-1.438515327E9, 4.43806148E8); +-- +ok +== +SELECT * FROM t1 INNER JOIN t2 ON t1.c0 = t2.c0; +-- +ok +== diff --git a/parser/testdata/corpus/sql/join/inner/equality_join_limits.test b/parser/testdata/corpus/sql/join/inner/equality_join_limits.test new file mode 100644 index 0000000..66a2359 --- /dev/null +++ b/parser/testdata/corpus/sql/join/inner/equality_join_limits.test @@ -0,0 +1,85 @@ +# source: test/sql/join/inner/equality_join_limits.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +CREATE TABLE u(u_k0 TINYINT); +-- +ok +== +INSERT INTO u VALUES (-128), (127); +-- +ok +== +SELECT t_k0, u_k0 FROM t, u WHERE t_k0 = u_k0; +-- +ok +== +DROP TABLE u; +-- +ok +== +CREATE TABLE u(u_k0 SMALLINT); +-- +ok +== +INSERT INTO u VALUES (-32768), (32767); +-- +ok +== +CREATE TABLE u(u_k0 INTEGER); +-- +ok +== +INSERT INTO u VALUES (-2147483648), (2147483647); +-- +ok +== +CREATE TABLE u(u_k0 BIGINT); +-- +ok +== +INSERT INTO u VALUES (-9223372036854775808), (9223372036854775807); +-- +ok +== +CREATE TABLE u(u_k0 HUGEINT); +-- +ok +== +INSERT INTO u VALUES (-170141183460469231731687303715884105728), (170141183460469231731687303715884105727); +-- +ok +== +CREATE TABLE u(u_k0 UTINYINT); +-- +ok +== +INSERT INTO u VALUES (0), (255); +-- +ok +== +CREATE TABLE u(u_k0 USMALLINT); +-- +ok +== +INSERT INTO u VALUES (0), (65535); +-- +ok +== +CREATE TABLE u(u_k0 UINTEGER); +-- +ok +== +INSERT INTO u VALUES (0), (4294967295); +-- +ok +== +CREATE TABLE u(u_k0 UBIGINT); +-- +ok +== +INSERT INTO u VALUES (0), (18446744073709551615); +-- +ok +== diff --git a/parser/testdata/corpus/sql/join/inner/join_cache.test b/parser/testdata/corpus/sql/join/inner/join_cache.test new file mode 100644 index 0000000..04ecbb3 --- /dev/null +++ b/parser/testdata/corpus/sql/join/inner/join_cache.test @@ -0,0 +1,25 @@ +# source: test/sql/join/inner/join_cache.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +CREATE TABLE bigtable AS SELECT a::INTEGER a FROM generate_series(0, 10000, 1) tbl(a), generate_series(0, 9, 1) tbl2(b); +-- +ok +== +SELECT COUNT(*) FROM bigtable JOIN smalltable USING (a) +-- +ok +== +SELECT COUNT(*) FROM bigtable JOIN smalltable USING (a) JOIN smalltable t3 USING (a) +-- +ok +== +SELECT COUNT(*) FROM bigtable JOIN smalltable USING (a) JOIN smalltable t3 USING (a) JOIN smalltable t4 USING (a); +-- +ok +== +SELECT * FROM bigtable JOIN smalltable USING (a) +-- +ok +== diff --git a/parser/testdata/corpus/sql/join/inner/join_cross_product.test b/parser/testdata/corpus/sql/join/inner/join_cross_product.test new file mode 100644 index 0000000..7f726fc --- /dev/null +++ b/parser/testdata/corpus/sql/join/inner/join_cross_product.test @@ -0,0 +1,49 @@ +# source: test/sql/join/inner/join_cross_product.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +create table t1(i integer); +-- +ok +== +create table t2(j integer); +-- +ok +== +create table t3(k integer); +-- +ok +== +create table t4(l integer); +-- +ok +== +insert into t1 values (1); +-- +ok +== +insert into t2 values (1); +-- +ok +== +insert into t3 values (2), (3); +-- +ok +== +insert into t4 values (2), (3); +-- +ok +== +select * from t1 join t2 on (i=j), t3 join t4 on (k=l) order by 1, 2, 3, 4; +-- +ok +== +select * from t1 join t2 on (i=j), t3 join t4 on (i+k=j+l) +-- +ok +== +select * from t1 join t2 on (i=j), lateral (select * from t3 join t4 on (i+k=j+l)) t(x); +-- +ok +== diff --git a/parser/testdata/corpus/sql/join/inner/list_join.test b/parser/testdata/corpus/sql/join/inner/list_join.test new file mode 100644 index 0000000..915e275 --- /dev/null +++ b/parser/testdata/corpus/sql/join/inner/list_join.test @@ -0,0 +1,17 @@ +# source: test/sql/join/inner/list_join.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +CREATE TABLE test (id INTEGER, l VARCHAR[]); +-- +ok +== +INSERT INTO test SELECT i, case when (i/1000)%2=0 then ARRAY[1::VARCHAR, 1::VARCHAR, 1::VARCHAR] else ARRAY[2::VARCHAR, 2::VARCHAR] end FROM generate_series(0, 1999, 1) tbl(i); +-- +ok +== +SELECT * FROM test AS t1 LEFT JOIN test AS t2 ON t1.id=t2.id WHERE t1.l!=t2.l or t1.id!=t2.id; +-- +ok +== diff --git a/parser/testdata/corpus/sql/join/inner/not_between_is_null.test b/parser/testdata/corpus/sql/join/inner/not_between_is_null.test new file mode 100644 index 0000000..1fa99c4 --- /dev/null +++ b/parser/testdata/corpus/sql/join/inner/not_between_is_null.test @@ -0,0 +1,22 @@ +# source: test/sql/join/inner/not_between_is_null.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +CREATE TABLE t1(c0 INT); +CREATE TABLE t2(c0 INT); +-- +ok +== +INSERT INTO t1(c0) VALUES (-18), (NULL); +-- +ok +== +INSERT INTO t2(c0) VALUES (NULL); +-- +ok +== +SELECT * FROM t1 INNER JOIN t2 ON ((t1.c0 NOT BETWEEN t2.c0 AND t2.c0) IS NULL); +-- +ok +== diff --git a/parser/testdata/corpus/sql/join/inner/right_semi_dict_emission_dead_end.test b/parser/testdata/corpus/sql/join/inner/right_semi_dict_emission_dead_end.test new file mode 100644 index 0000000..ad69fd2 --- /dev/null +++ b/parser/testdata/corpus/sql/join/inner/right_semi_dict_emission_dead_end.test @@ -0,0 +1,49 @@ +# source: test/sql/join/inner/right_semi_dict_emission_dead_end.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +CREATE TABLE big (f BOOLEAN, s VARCHAR); +-- +ok +== +INSERT INTO big SELECT (i % 3) = 0, ['a', '', 'dup', 'zzz'][(i % 4) + 1] FROM generate_series(1, 30) t(i); +-- +ok +== +CREATE VIEW v AS SELECT MAX(f) OVER (PARTITION BY s) AS f, s FROM big; +-- +ok +== +CREATE TABLE p (pb BOOLEAN); +-- +ok +== +INSERT INTO p VALUES (TRUE), (TRUE), (NULL); +-- +ok +== +SELECT COUNT(*) FROM p WHERE p.pb IN (SELECT x.f FROM v x JOIN v y ON x.s = y.s CROSS JOIN v z); +-- +ok +== +SET disabled_optimizers='build_side_probe_side'; +-- +ok +== +INSERT INTO p VALUES (FALSE); +-- +ok +== +SELECT COUNT(*) FROM p WHERE p.pb NOT IN (SELECT x.f FROM v x JOIN v y ON x.s = y.s); +-- +ok +== +SELECT COUNT(*) FROM p WHERE EXISTS (SELECT 1 FROM v x WHERE x.f = p.pb); +-- +ok +== +SELECT COUNT(*) FROM p WHERE p.pb IN (SELECT f FROM v); +-- +ok +== diff --git a/parser/testdata/corpus/sql/join/inner/test_eq_ineq_join.test b/parser/testdata/corpus/sql/join/inner/test_eq_ineq_join.test new file mode 100644 index 0000000..142d5e2 --- /dev/null +++ b/parser/testdata/corpus/sql/join/inner/test_eq_ineq_join.test @@ -0,0 +1,85 @@ +# source: test/sql/join/inner/test_eq_ineq_join.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +CREATE TABLE test2 (a INTEGER, c INTEGER); +-- +ok +== +INSERT INTO test2 VALUES (11, 1), (12, 1), (13, 4) +-- +ok +== +SELECT test.a, b, c FROM test, test2 WHERE test.a = test2.a AND test.b <> test2.c ORDER BY test.a; +-- +ok +== +SELECT test.a, b, c FROM test, test2 WHERE test.a = test2.a AND test.b < test2.c ORDER BY test.a; +-- +ok +== +SELECT test.a, b, c FROM test, test2 WHERE test.a = test2.a AND test.b <= test2.c ORDER BY test.a; +-- +ok +== +SELECT test.a, b, c FROM test, test2 WHERE test.a = test2.a AND test.b > test2.c ORDER BY test.a; +-- +ok +== +SELECT test.a, b, c FROM test, test2 WHERE test.a = test2.a AND test.b >= test2.c ORDER BY test.a; +-- +ok +== +DROP TABLE test2; +-- +ok +== +CREATE TABLE test (a INTEGER, b INTEGER, str VARCHAR); +-- +ok +== +INSERT INTO test VALUES (11, 1, 'a'), (12, 2, 'b'), (13, 3, 'c') +-- +ok +== +CREATE TABLE test2 (a INTEGER, c INTEGER, str2 VARCHAR); +-- +ok +== +INSERT INTO test2 VALUES (11, 1, 'd'), (12, 1, 'e'), (13, 4, 'f') +-- +ok +== +SELECT * FROM test WHERE EXISTS(SELECT * FROM test2 WHERE test.a=test2.a AND test.b<>test2.c) order by 2; +-- +ok +== +SELECT * FROM test WHERE EXISTS(SELECT * FROM test2 WHERE test.a=test2.a AND test.b<>test2.c) AND NOT EXISTS(SELECT * FROM test2 WHERE test.a=test2.a AND test.btest2.c); +-- +ok +== +SELECT * FROM test WHERE EXISTS(SELECT * FROM test2 WHERE test.a=test2.a AND test.b<>test2.c) AND test.a > 11 order by b; +-- +ok +== +SELECT * FROM test WHERE NOT EXISTS(SELECT * FROM test2 WHERE test.a=test2.a AND test.b14) AND NOT EXISTS(SELECT * FROM test2 WHERE test.a=test2.a AND test.b>test2.c AND test2.a<10) order by 1; +-- +ok +== +SELECT * FROM test WHERE NOT EXISTS(SELECT * FROM test2 WHERE test.a=test2.a AND test.btest2.c AND test2.a=12) order by 1; +-- +ok +== +SELECT * FROM test WHERE EXISTS(SELECT * FROM test2 WHERE test.a=test2.a AND test.b<>test2.c) AND test.a < 13; +-- +ok +== diff --git a/parser/testdata/corpus/sql/join/inner/test_inner_join_filter_pushdown.test b/parser/testdata/corpus/sql/join/inner/test_inner_join_filter_pushdown.test new file mode 100644 index 0000000..57ea467 --- /dev/null +++ b/parser/testdata/corpus/sql/join/inner/test_inner_join_filter_pushdown.test @@ -0,0 +1,81 @@ +# source: test/sql/join/inner/test_inner_join_filter_pushdown.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +CREATE TABLE left_table (id INTEGER, val INTEGER, amount INTEGER); +-- +ok +== +INSERT INTO left_table VALUES (1, 1, 50), (2, 1, 75), (3, 2, 60), (4, 2, 90), (5, 3, 100); +-- +ok +== +CREATE TABLE right_table (id INTEGER, category INTEGER, budget INTEGER); +-- +ok +== +INSERT INTO right_table VALUES (1, 1, 1000), (2, 2, 2000), (3, 1, 1500); +-- +ok +== +SELECT * FROM left_table l +INNER JOIN right_table r ON l.id = r.id AND l.val > 1 AND r.category = 1; +-- +ok +== +SELECT * FROM left_table l +INNER JOIN right_table r ON l.id = r.id AND r.category = 1; +-- +ok +== +SELECT * FROM left_table l +INNER JOIN right_table r ON l.id = r.id AND l.val > 1; +-- +ok +== +SELECT * FROM left_table l +INNER JOIN right_table r ON l.id = r.id AND true; +-- +ok +== +SELECT * FROM left_table l +INNER JOIN right_table r ON l.id = r.id AND false; +-- +ok +== +SELECT * FROM left_table l +INNER JOIN right_table r ON l.id = r.id AND l.amount + r.budget > 1100; +-- +ok +== +CREATE TABLE ordered_probe(flag BOOLEAN, ord INTEGER); +-- +ok +== +INSERT INTO ordered_probe VALUES (true, 1), (true, 2), (false, 3); +-- +ok +== +CREATE TABLE boolean_keys(flag_key BOOLEAN); +-- +ok +== +INSERT INTO boolean_keys VALUES (false); +-- +ok +== +WITH c AS ( + SELECT flag FROM ordered_probe ORDER BY ord OFFSET 2 +) +SELECT * FROM c INNER JOIN boolean_keys ON flag = flag_key; +-- +ok +== +WITH c AS ( + SELECT flag FROM ordered_probe ORDER BY ord LIMIT 1 +) +SELECT * FROM c INNER JOIN boolean_keys ON flag = flag_key; +-- +ok +== diff --git a/parser/testdata/corpus/sql/join/inner/test_join.test b/parser/testdata/corpus/sql/join/inner/test_join.test new file mode 100644 index 0000000..bab94aa --- /dev/null +++ b/parser/testdata/corpus/sql/join/inner/test_join.test @@ -0,0 +1,61 @@ +# source: test/sql/join/inner/test_join.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +CREATE TABLE test2 (b INTEGER, c INTEGER); +-- +ok +== +INSERT INTO test2 VALUES (1, 10), (1, 20), (2, 30) +-- +ok +== +SELECT a, test.b, c FROM test, test2 WHERE test.b = test2.b ORDER BY c; +-- +ok +== +SELECT b FROM test, test2 WHERE test.b > test2.b; +-- +ok +== +SELECT a, test.b, c FROM test, test2 WHERE test.b=test2.b AND test.a-1=test2.c +-- +ok +== +SELECT a, (SELECT test.a), c FROM test, test2 WHERE test.b = test2.b ORDER BY c; +-- +ok +== +SELECT a, test.b, c FROM test INNER JOIN test2 ON test.b = test2.b ORDER BY c; +-- +ok +== +SELECT a, test.b, c FROM test INNER JOIN test2 ON test2.b = test.b ORDER BY c; +-- +ok +== +SELECT a, test.b, c FROM test INNER JOIN test2 ON test2.b = test.b and test.b = 2; +-- +ok +== +SELECT a, test.b, c FROM test INNER JOIN test2 ON test2.b = test.b and 2 = 2 ORDER BY c; +-- +ok +== +SELECT a, test.b, c FROM test INNER JOIN test2 ON test.b = 2 ORDER BY c; +-- +ok +== +SELECT a, test.b, c FROM test INNER JOIN test2 ON NULL = 2; +-- +ok +== +SELECT * FROM (VALUES (1)) tbl(i) JOIN (VALUES (1)) tbl2(j) ON (i=j); +-- +ok +== +SELECT * FROM (VALUES (1), (2)) tbl(i) JOIN (VALUES (1), (2)) tbl2(j) ON (i=j) WHERE i+j=2; +-- +ok +== diff --git a/parser/testdata/corpus/sql/join/inner/test_join_duplicates.test b/parser/testdata/corpus/sql/join/inner/test_join_duplicates.test new file mode 100644 index 0000000..fa001d1 --- /dev/null +++ b/parser/testdata/corpus/sql/join/inner/test_join_duplicates.test @@ -0,0 +1,17 @@ +# source: test/sql/join/inner/test_join_duplicates.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +CREATE TABLE test2 AS SELECT * FROM repeat(1, 10*1024) t1(b), (SELECT 10) t2(c); +-- +ok +== +SELECT COUNT(*) FROM test2; +-- +ok +== +SELECT COUNT(*) FROM test INNER JOIN test2 ON test.b=test2.b +-- +ok +== diff --git a/parser/testdata/corpus/sql/join/inner/test_join_filter_precedence.test b/parser/testdata/corpus/sql/join/inner/test_join_filter_precedence.test new file mode 100644 index 0000000..6bd17af --- /dev/null +++ b/parser/testdata/corpus/sql/join/inner/test_join_filter_precedence.test @@ -0,0 +1,172 @@ +# source: test/sql/join/inner/test_join_filter_precedence.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +SET disabled_optimizers = 'join_order,build_side_probe_side,compressed_materialization'; +-- +ok +== +CREATE TABLE single_probe AS +SELECT (1000000000000 + i)::BIGINT AS k, (i % 7)::INTEGER AS g +FROM range(100000) t(i); +-- +ok +== +CREATE TABLE single_build AS +SELECT 1000000000042::BIGINT AS k, i::INTEGER AS g +FROM range(10) t(i); +-- +ok +== +EXPLAIN ANALYZE +SELECT count(*) +FROM single_probe p +JOIN single_build b + ON p.k = b.k + AND p.g >= b.g; +-- +ok +== +SET dynamic_or_filter_threshold=1000; +-- +ok +== +CREATE TABLE exact_prf_probe AS +SELECT (1000000000000 + i)::BIGINT AS k, (i % 7)::INTEGER AS g +FROM range(100000) t(i); +-- +ok +== +CREATE TABLE exact_prf_build AS +SELECT (1000000000000 + i * 2)::BIGINT AS k, (i % 7)::INTEGER AS g +FROM range(6) t(i); +-- +ok +== +EXPLAIN ANALYZE +SELECT count(*) +FROM exact_prf_probe p +JOIN exact_prf_build b + ON p.k = b.k + AND p.g >= b.g; +-- +ok +== +CREATE TABLE in_filter_probe AS +SELECT (-1000000000000 + i * 20000000)::BIGINT AS k, (i % 7)::INTEGER AS g +FROM range(100000) t(i); +-- +ok +== +CREATE TABLE in_filter_build(k BIGINT, g INTEGER); +-- +ok +== +INSERT INTO in_filter_build VALUES (-900000000000, 0), (0, 0), (900000000000, 0); +-- +ok +== +EXPLAIN ANALYZE +SELECT count(*) +FROM in_filter_probe p +JOIN in_filter_build b + ON p.k = b.k + AND p.g >= b.g; +-- +ok +== +SET dynamic_or_filter_threshold=0; +-- +ok +== +CREATE TABLE bloom_probe AS +SELECT (-1000000000000 + i * 20000000)::BIGINT AS k, (i % 7)::INTEGER AS g +FROM range(100000) t(i); +-- +ok +== +CREATE TABLE bloom_build AS +SELECT (-1000000000000 + i * 20000000000)::BIGINT AS k, 0::INTEGER AS g +FROM range(100) t(i); +-- +ok +== +EXPLAIN ANALYZE +SELECT count(*) +FROM bloom_probe p +JOIN bloom_build b + ON p.k = b.k + AND p.g >= b.g; +-- +ok +== +CREATE TABLE inequality_probe AS +SELECT (-1000000000000 + i * 20000000)::BIGINT AS k, (i % 7)::INTEGER AS g +FROM range(100000) t(i); +-- +ok +== +CREATE TABLE inequality_build AS +SELECT (-1000000000000 + i * 20000000000)::BIGINT AS k, 0::INTEGER AS g +FROM range(100) t(i); +-- +ok +== +EXPLAIN ANALYZE +SELECT count(*) +FROM inequality_probe p +JOIN inequality_build b + ON p.k >= b.k + AND p.g = b.g; +-- +ok +== +CREATE TABLE dense_probe AS +SELECT (1000000000000 + i)::HUGEINT AS k, (i % 7)::INTEGER AS g +FROM range(100000) t(i); +-- +ok +== +CREATE TABLE dense_build AS +SELECT (1000000000000 + i)::HUGEINT AS k, 0::INTEGER AS g +FROM range(10) t(i); +-- +ok +== +EXPLAIN ANALYZE +SELECT count(*) +FROM dense_probe p +JOIN dense_build b + ON p.k = b.k + AND p.g >= b.g; +-- +ok +== +CREATE TABLE multi_probe AS +SELECT (-1000000000000 + i * 20000000)::BIGINT AS k1, + (-3000000000000 + i * 60000000)::BIGINT AS k2 +FROM range(100000) t(i); +-- +ok +== +CREATE TABLE multi_build AS +SELECT (-1000000000000 + i * 20000000000)::BIGINT AS k1, + (-3000000000000 + i * 60000000000)::BIGINT AS k2 +FROM range(100) t(i); +-- +ok +== +EXPLAIN ANALYZE +SELECT count(*) +FROM multi_probe p +JOIN multi_build b + ON p.k1 = b.k1 + AND p.k2 = b.k2; +-- +ok +== +SET disabled_optimizers = ''; +-- +ok +== diff --git a/parser/testdata/corpus/sql/join/inner/test_join_is_distinct.test b/parser/testdata/corpus/sql/join/inner/test_join_is_distinct.test new file mode 100644 index 0000000..6556e9e --- /dev/null +++ b/parser/testdata/corpus/sql/join/inner/test_join_is_distinct.test @@ -0,0 +1,219 @@ +# source: test/sql/join/inner/test_join_is_distinct.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +CREATE TABLE tbl (col0 INTEGER, col1 INTEGER); +-- +ok +== +INSERT INTO tbl VALUES (1, 0), (1, 1); +-- +ok +== +SELECT x.col1, y.col1 FROM tbl x JOIN tbl y +ON x.col0 = y.col0 AND (x.col1 IS DISTINCT FROM y.col1) +ORDER BY x.col1; +-- +ok +== +SELECT x.col1, y.col1 FROM tbl x JOIN tbl y +ON x.col0 = y.col0 AND x.col1 != y.col1 +ORDER BY x.col1; +-- +ok +== +CREATE TABLE tbl_s (col0 STRUCT(x INTEGER), col1 STRUCT(x INTEGER)); +-- +ok +== +INSERT INTO tbl_s VALUES ({x: 1}, {x: 0}), ({x: 1}, {x: 1}); +-- +ok +== +SELECT x.col1, y.col1 FROM tbl_s x JOIN tbl_s y +ON x.col0 = y.col0 AND (x.col1 IS DISTINCT FROM y.col1) +ORDER BY x.col1; +-- +ok +== +SELECT x.col1, y.col1 FROM tbl_s x JOIN tbl_s y +ON x.col0 = y.col0 AND x.col1 != y.col1 +ORDER BY x.col1; +-- +ok +== +CREATE TABLE tbl_l (col0 INTEGER[], col1 INTEGER[]); +-- +ok +== +INSERT INTO tbl_l VALUES ([1], [0]), ([1], [1]); +-- +ok +== +SELECT x.col1, y.col1 FROM tbl_l x JOIN tbl_l y +ON x.col0 = y.col0 AND (x.col1 IS DISTINCT FROM y.col1) +ORDER BY x.col1; +-- +ok +== +SELECT x.col1, y.col1 FROM tbl_l x JOIN tbl_l y +ON x.col0 = y.col0 AND x.col1 != y.col1 +ORDER BY x.col1; +-- +ok +== +WITH abc AS ( + SELECT * FROM ( + VALUES (1, 'x'), (1, 'x'), (1, '0'), (1, '0') + ) AS tbl(col0, col1) +) +SELECT x.col0 AS c1, x.col1 AS c2, y.col0 AS c3, y.col1 AS c4 +FROM abc x JOIN abc y ON x.col0 = y.col0 + AND (x.col1 IS DISTINCT FROM y.col1) +ORDER BY c1, c2, c3, c4; +-- +ok +== +CREATE TABLE tbl_null (col0 INTEGER, col1 INTEGER); +-- +ok +== +INSERT INTO tbl_null VALUES (1, 0), (1, 1), (1, NULL), (NULL, 1), (0, NULL), (NULL, 0), (NULL, NULL); +-- +ok +== +SELECT x.col1, y.col1 FROM tbl_null x JOIN tbl_null y +ON x.col0 = y.col0 AND (x.col1 IS DISTINCT FROM y.col1) +ORDER BY x.col1, y.col1; +-- +ok +== +SELECT x.col1, y.col1 FROM tbl_null x JOIN tbl_null y +ON x.col0 = y.col0 AND x.col1 != y.col1 +ORDER BY x.col1; +-- +ok +== +SELECT x.col1, y.col1 FROM tbl_null x JOIN tbl_null y +ON x.col0 = y.col0 AND (x.col1 IS NOT DISTINCT FROM y.col1) +ORDER BY x.col1; +-- +ok +== +SELECT x.col1, y.col1 FROM tbl_null x JOIN tbl_null y +ON x.col0 = y.col0 AND x.col1 = y.col1 +ORDER BY x.col1; +-- +ok +== +CREATE TABLE tbl_s_null (col0 STRUCT(x INTEGER), col1 STRUCT(x INTEGER)); +-- +ok +== +INSERT INTO tbl_s_null VALUES ({x: 1}, {x: 0}), ({x: 1}, {x: 1}), ({x: 1}, NULL), ({x: 1}, {x: NULL}); +-- +ok +== +SELECT x.col1, y.col1 FROM tbl_s_null x JOIN tbl_s_null y +ON x.col0 = y.col0 AND (x.col1 IS DISTINCT FROM y.col1) +ORDER BY x.col1, y.col1 NULLS LAST; +-- +ok +== +SELECT x.col1, y.col1 FROM tbl_s_null x JOIN tbl_s_null y +ON x.col0 = y.col0 AND x.col1 != y.col1 +ORDER BY x.col1.x, y.col1.x NULLS LAST; +-- +ok +== +SELECT x.col1, y.col1 FROM tbl_s_null x JOIN tbl_s_null y +ON x.col0 = y.col0 AND x.col1 > y.col1 +ORDER BY x.col1.x, y.col1.x NULLS LAST; +-- +ok +== +SELECT x.col1, y.col1 FROM tbl_s_null x JOIN tbl_s_null y +ON x.col0 = y.col0 AND (x.col1 IS NOT DISTINCT FROM y.col1) +ORDER BY x.col1; +-- +ok +== +SELECT x.col1, y.col1 FROM tbl_s_null x JOIN tbl_s_null y +ON x.col0 = y.col0 AND x.col1 = y.col1 +ORDER BY x.col1; +-- +ok +== +CREATE TABLE tbl_l_null (col0 INTEGER[], col1 INTEGER[]); +-- +ok +== +INSERT INTO tbl_l_null VALUES ([1], [0]), ([1], [1]), ([1], NULL), ([1], [NULL]); +-- +ok +== +SELECT x.col1, y.col1 FROM tbl_l_null x JOIN tbl_l_null y +ON x.col0 = y.col0 AND (x.col1 IS DISTINCT FROM y.col1) +ORDER BY x.col1, y.col1; +-- +ok +== +SELECT x.col1, y.col1 FROM tbl_l_null x JOIN tbl_l_null y +ON x.col0 = y.col0 AND x.col1 != y.col1 +ORDER BY x.col1, y.col1 NULLS LAST; +-- +ok +== +SELECT x.col1, y.col1 FROM tbl_l_null x JOIN tbl_l_null y +ON x.col0 = y.col0 AND (x.col1 IS NOT DISTINCT FROM y.col1) +ORDER BY x.col1; +-- +ok +== +SELECT x.col1, y.col1 FROM tbl_l_null x JOIN tbl_l_null y +ON x.col0 = y.col0 AND x.col1 = y.col1 +ORDER BY x.col1; +-- +ok +== +create table tb1 as select range*2 as a from range(100); +-- +ok +== +create table tb2 as select range*4 as a from range(100); +-- +ok +== +insert into tb2 (select NULL from range(20)); +-- +ok +== +insert into tb1 (select NULL from range(20)); +-- +ok +== +SELECT count(*) FROM tb1 AS lhs ANTI JOIN tb2 AS rhs ON (lhs.a IS DISTINCT FROM rhs.a); +-- +ok +== +create or replace table tb1 as select range*2 as a, range*50 as b from range(2); +-- +ok +== +create or replace table tb2 as select range*4 as a, range*500 as b from range(2); +-- +ok +== +insert into tb2 (select NULL, NULL from range(2)); +-- +ok +== +insert into tb1 (select NULL, NULL from range(2)); +-- +ok +== +SELECT lhs.a, rhs.a FROM tb1 AS lhs LEFT JOIN tb2 AS rhs ON (lhs.a IS DISTINCT FROM rhs.a) ORDER BY ALL; +-- +ok +== diff --git a/parser/testdata/corpus/sql/join/inner/test_join_is_not_distinct.test b/parser/testdata/corpus/sql/join/inner/test_join_is_not_distinct.test new file mode 100644 index 0000000..5cf3c83 --- /dev/null +++ b/parser/testdata/corpus/sql/join/inner/test_join_is_not_distinct.test @@ -0,0 +1,91 @@ +# source: test/sql/join/inner/test_join_is_not_distinct.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +SELECT x.col1, y.col1 FROM tbl x JOIN tbl y +ON x.col0 = y.col0 AND (x.col1 IS NOT DISTINCT FROM y.col1) +ORDER BY x.col1; +-- +ok +== +SELECT x.col1, y.col1 FROM tbl x JOIN tbl y +ON x.col0 = y.col0 AND x.col1 = y.col1 +ORDER BY x.col1; +-- +ok +== +SELECT x.col1, y.col1 FROM tbl_s x JOIN tbl_s y +ON x.col0 = y.col0 AND (x.col1 IS NOT DISTINCT FROM y.col1) +ORDER BY x.col1; +-- +ok +== +SELECT x.col1, y.col1 FROM tbl_s x JOIN tbl_s y +ON x.col0 = y.col0 AND x.col1 = y.col1 +ORDER BY x.col1; +-- +ok +== +SELECT x.col1, y.col1 FROM tbl_l x JOIN tbl_l y +ON x.col0 = y.col0 AND (x.col1 IS NOT DISTINCT FROM y.col1) +ORDER BY x.col1; +-- +ok +== +SELECT x.col1, y.col1 FROM tbl_l x JOIN tbl_l y +ON x.col0 = y.col0 AND x.col1 = y.col1 +ORDER BY x.col1; +-- +ok +== +WITH abc AS ( + SELECT * FROM ( + VALUES (1, 'x'), (1, 'x'), (1, '0'), (1, '0') + ) AS tbl(col0, col1) +) +SELECT x.col0 AS c1, x.col1 AS c2, y.col0 AS c3, y.col1 AS c4 +FROM abc x JOIN abc y ON x.col0 = y.col0 + AND (x.col1 IS NOT DISTINCT FROM y.col1) +ORDER BY c1, c2, c3, c4; +-- +ok +== +SELECT x.col1, y.col1 FROM tbl_null x JOIN tbl_null y +ON x.col0 = y.col0 AND (x.col1 IS NOT DISTINCT FROM y.col1) +ORDER BY x.col1, y.col1; +-- +ok +== +SELECT x.col1, y.col1 FROM tbl_s_null x JOIN tbl_s_null y +ON x.col0 = y.col0 AND (x.col1 IS NOT DISTINCT FROM y.col1) +ORDER BY x.col1, y.col1 NULLS LAST; +-- +ok +== +SELECT x.col1, y.col1 FROM tbl_s_null x JOIN tbl_s_null y +ON x.col0 = y.col0 AND x.col1 = y.col1 +ORDER BY x.col1.x, y.col1.x NULLS LAST; +-- +ok +== +SELECT x.col1, y.col1 FROM tbl_l_null x JOIN tbl_l_null y +ON x.col0 = y.col0 AND (x.col1 IS NOT DISTINCT FROM y.col1) +ORDER BY x.col1, y.col1; +-- +ok +== +SELECT x.col1, y.col1 FROM tbl_l_null x JOIN tbl_l_null y +ON x.col0 = y.col0 AND x.col1 = y.col1 +ORDER BY x.col1, y.col1 NULLS LAST; +-- +ok +== +SELECT count(*) FROM tb1 AS lhs ANTI JOIN tb2 AS rhs ON (lhs.a IS NOT DISTINCT FROM rhs.a); +-- +ok +== +SELECT lhs.a, rhs.a FROM tb1 AS lhs LEFT JOIN tb2 AS rhs ON (lhs.a IS NOT DISTINCT FROM rhs.a) ORDER BY ALL; +-- +ok +== diff --git a/parser/testdata/corpus/sql/join/inner/test_lt_join.test b/parser/testdata/corpus/sql/join/inner/test_lt_join.test new file mode 100644 index 0000000..b91da33 --- /dev/null +++ b/parser/testdata/corpus/sql/join/inner/test_lt_join.test @@ -0,0 +1,25 @@ +# source: test/sql/join/inner/test_lt_join.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +create table a AS SELECT i FROM range(1, 2001, 1) t1(i) +-- +ok +== +select count(*) from a, (SELECT 2000 AS j) b where i < j +-- +ok +== +select count(*) from a, (SELECT 2000 AS j) b where i <= j +-- +ok +== +select count(*) from a, (SELECT 1 AS j) b where i > j +-- +ok +== +select count(*) from a, (SELECT 1 AS j) b where i >= j +-- +ok +== diff --git a/parser/testdata/corpus/sql/join/inner/test_prefix_range_filter_non_utf8.test b/parser/testdata/corpus/sql/join/inner/test_prefix_range_filter_non_utf8.test new file mode 100644 index 0000000..5295e34 --- /dev/null +++ b/parser/testdata/corpus/sql/join/inner/test_prefix_range_filter_non_utf8.test @@ -0,0 +1,33 @@ +# source: test/sql/join/inner/test_prefix_range_filter_non_utf8.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +SET disabled_optimizers = 'join_order,build_side_probe_side'; +-- +ok +== +COPY ( + SELECT CASE WHEN i < 5 THEN 'ascii' || lpad(i::VARCHAR, 3, '0') + ELSE chr(26085) || chr(26412) || chr(35486) || lpad(i::VARCHAR, 4, '0') + END AS k, + (i % 3)::INTEGER AS g + FROM range(10) t(i) +) TO '{TEST_DIR}/prf_non_utf8_probe.parquet' (ROW_GROUP_SIZE 5); +-- +ok +== +CREATE OR REPLACE TABLE prf_build_non_utf8 (k VARCHAR, g INTEGER, payload INTEGER); +-- +ok +== +INSERT INTO prf_build_non_utf8 VALUES ('a', 0, 1), ('z', 0, 2), ('m', 1, 3); +-- +ok +== +SELECT count(*) +FROM read_parquet('{TEST_DIR}/prf_non_utf8_probe.parquet') p +JOIN prf_build_non_utf8 b ON p.k = b.k AND p.g >= b.g; +-- +ok +== diff --git a/parser/testdata/corpus/sql/join/inner/test_prefix_range_filter_pushdown.test b/parser/testdata/corpus/sql/join/inner/test_prefix_range_filter_pushdown.test new file mode 100644 index 0000000..5b7ef6c --- /dev/null +++ b/parser/testdata/corpus/sql/join/inner/test_prefix_range_filter_pushdown.test @@ -0,0 +1,375 @@ +# source: test/sql/join/inner/test_prefix_range_filter_pushdown.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +CREATE OR REPLACE TABLE probe AS +SELECT i::BIGINT AS k, (i % 7)::INTEGER AS g +FROM range(0, 100000) t(i); +-- +ok +== +CREATE OR REPLACE TABLE build AS +SELECT (i * 2)::BIGINT AS k, (i % 7)::INTEGER AS g +FROM range(0, 30000) t(i); +-- +ok +== +CREATE OR REPLACE TABLE probe_perfect_hash AS +SELECT (1000000000000 + i)::BIGINT AS k +FROM range(0, 100000) t(i); +-- +ok +== +CREATE OR REPLACE TABLE build_perfect_hash AS +SELECT (1000000000000 + i)::BIGINT AS k +FROM range(1000, 2000) t(i); +-- +ok +== +EXPLAIN ANALYZE +SELECT count(*) +FROM probe_perfect_hash p +JOIN build_perfect_hash b + ON p.k = b.k; +-- +ok +== +EXPLAIN ANALYZE +SELECT count(*) +FROM probe p +JOIN build b + ON p.k = b.k + AND p.g >= b.g; +-- +ok +== +SELECT count(*) +FROM probe p +JOIN build b + ON p.k = b.k + AND p.g >= b.g; +-- +ok +== +CREATE OR REPLACE TABLE probe_with_null AS +SELECT i::BIGINT AS k, (i % 7)::INTEGER AS g +FROM range(0, 20480) t(i) +UNION ALL +SELECT NULL::BIGINT as k, (i % 7)::INTEGER AS g +FROM range(20480, 24576) t2(i) +UNION ALL +SELECT i::BIGINT AS k, (i % 7)::INTEGER AS g +FROM range(24576, 100000) t3(i) +-- +ok +== +SELECT count(*) +FROM probe_with_null p +JOIN build b + ON p.k = b.k + AND p.g >= b.g; +-- +ok +== +CREATE OR REPLACE TABLE probe_timestamp AS +SELECT make_timestamp(i * 1000) AS k, (i % 7)::INTEGER AS g +FROM range(0, 100000) t(i); +-- +ok +== +CREATE OR REPLACE TABLE build_timestamp AS +SELECT make_timestamp(i * 2000) AS k, (i % 7)::INTEGER AS g +FROM range(0, 30000) t(i); +-- +ok +== +EXPLAIN ANALYZE +SELECT count(*) +FROM probe_timestamp p +JOIN build_timestamp b + ON p.k = b.k + AND p.g >= b.g; +-- +ok +== +CREATE OR REPLACE TABLE probe_varchar AS +SELECT lpad((i // 3)::VARCHAR, 8, '0') AS k, (i % 7)::INTEGER AS g +FROM range(0, 100000) t(i); +-- +ok +== +CREATE OR REPLACE TABLE build_varchar AS +SELECT lpad(i::VARCHAR, 8, '0') AS k, (i % 7)::INTEGER AS g +FROM range(0, 30000) t(i); +-- +ok +== +SELECT count(*) +FROM probe_varchar p +JOIN build_varchar b + ON p.k = b.k + AND p.g >= b.g; +-- +ok +== +CREATE OR REPLACE TABLE probe_hugeint AS +SELECT i::HUGEINT AS k, (i % 7)::INTEGER AS g +FROM range(0, 100000) t(i); +-- +ok +== +CREATE OR REPLACE TABLE build_hugeint AS +SELECT (i * 2)::HUGEINT AS k, (i % 7)::INTEGER AS g +FROM range(0, 30000) t(i); +-- +ok +== +EXPLAIN ANALYZE +SELECT count(*) +FROM probe_hugeint p +JOIN build_hugeint b + ON p.k = b.k + AND p.g >= b.g; +-- +ok +== +EXPLAIN ANALYZE +SELECT count(*) +FROM probe p +JOIN build b + ON p.k IS NOT DISTINCT FROM b.k + AND p.g >= b.g; +-- +ok +== +CREATE OR REPLACE TABLE prf_probe_small ( + id INTEGER, + k {type}, + g {type} +); +-- +error: Parser Error: syntax error at or near "{" +== +INSERT INTO prf_probe_small VALUES + (1, -3, 1), + (2, -1, 5), + (3, 0, 0), + (4, 2, 2), + (5, 7, 1), + (6, NULL, 4), + (7, 9, NULL), + (8, 11, 3), + (9, 12, 6); +-- +ok +== +CREATE OR REPLACE TABLE prf_build_small ( + k {type}, + g {type}, + payload INTEGER +); +-- +error: Parser Error: syntax error at or near "{" +== +INSERT INTO prf_build_small VALUES + (-3, 0, 100), + (-1, 4, 101), + (-1, 6, 102), + (0, 0, 103), + (2, 3, 104), + (7, 1, 105), + (11, 4, 106), + (11, 2, 107), + (NULL, 0, 108), + (12, NULL, 109); +-- +ok +== +SELECT p.id, p.k, p.g, b.payload +FROM prf_probe_small p +JOIN prf_build_small b + ON p.k = b.k + AND p.g >= b.g +ORDER BY ALL; +-- +ok +== +SET disabled_optimizers = 'join_filter_pushdown'; +-- +ok +== +CREATE OR REPLACE TABLE prf_probe_string ( + id INTEGER, + k VARCHAR, + g INTEGER +); +-- +ok +== +INSERT INTO prf_probe_string VALUES + (1, 'ab', 1), + (2, 'abc', 2), + (3, 'abcd0', 3), + (4, 'abcd1', 4), + (5, 'abcd9', 8), + (6, 'abce0', 5), + (7, '', 5), + (8, NULL, 1), + (9, 'zzzz', NULL), + (10, 'zzzzzz', 4); +-- +ok +== +CREATE OR REPLACE TABLE prf_build_string ( + k VARCHAR, + g INTEGER, + payload INTEGER +); +-- +ok +== +INSERT INTO prf_build_string VALUES + ('ab', 0, 100), + ('abc', 2, 101), + ('abcd0', 4, 102), + ('abcd1', 3, 103), + ('abce0', 6, 104), + ('', 6, 105), + ('zzzzzz', 4, 106), + (NULL, 0, 107), + ('abcd2', 1, 108); +-- +ok +== +SELECT p.id, p.k, p.g, b.payload +FROM prf_probe_string p +JOIN prf_build_string b + ON p.k = b.k + AND p.g >= b.g +ORDER BY ALL; +-- +ok +== +CREATE OR REPLACE TABLE prf_probe_string_nul ( + id INTEGER, + k VARCHAR, + g INTEGER +); +-- +ok +== +INSERT INTO prf_probe_string_nul VALUES + (1, 'ab' || chr(0) || 'd', 2), + (2, 'ab' || chr(0) || 'x', 3), + (3, 'ab', 4), + (4, 'zzzz', 5); +-- +ok +== +CREATE OR REPLACE TABLE prf_build_string_nul ( + k VARCHAR, + g INTEGER, + payload INTEGER +); +-- +ok +== +INSERT INTO prf_build_string_nul VALUES + ('ab' || chr(0) || 'd', 1, 200), + ('ab' || chr(0) || 'x', 4, 201), + ('ab', 2, 202); +-- +ok +== +SELECT p.id, hex(p.k), p.g, b.payload +FROM prf_probe_string_nul p +JOIN prf_build_string_nul b + ON p.k = b.k + AND p.g >= b.g +ORDER BY ALL; +-- +ok +== +CREATE OR REPLACE TABLE prf_probe_span ( + id INTEGER, + k BIGINT, + g INTEGER +); +-- +ok +== +INSERT INTO prf_probe_span VALUES + (1, 0, 0), + (2, 1, 0), + (3, 1048576, 5), + (4, 1048577, 5), + (5, 2097152, 2), + (6, 3145728, 9); +-- +ok +== +CREATE OR REPLACE TABLE prf_build_span ( + k BIGINT, + g INTEGER, + payload INTEGER +); +-- +ok +== +INSERT INTO prf_build_span VALUES + (0, 0, 10), + (1048576, 3, 11), + (2097152, 4, 12), + (3145728, 10, 13); +-- +ok +== +SELECT p.id, p.k, p.g, b.payload +FROM prf_probe_span p +JOIN prf_build_span b + ON p.k = b.k + AND p.g >= b.g +ORDER BY ALL; +-- +ok +== +ATTACH ':memory:' AS prf_row_group_bug (ROW_GROUP_SIZE 2); +-- +ok +== +CREATE OR REPLACE TABLE prf_row_group_bug.prf_probe_small ( + k SMALLINT, + g SMALLINT +); +-- +ok +== +INSERT INTO prf_row_group_bug.prf_probe_small VALUES + (1, 0), (2, 0), + (3, 0), (4, 0), + (5, 0), (6, 0); +-- +ok +== +CREATE OR REPLACE TABLE prf_build_row_group_bug ( + k SMALLINT, + g SMALLINT +); +-- +ok +== +INSERT INTO prf_build_row_group_bug VALUES + (-2, 0), + (5, 0), + (6, 0); +-- +ok +== +SELECT b.k, p.k +FROM prf_row_group_bug.prf_probe_small p +RIGHT JOIN prf_build_row_group_bug b USING (k) +ORDER BY ALL; +-- +ok +== diff --git a/parser/testdata/corpus/sql/join/inner/test_prefix_range_filter_pushdown_strinline.test b/parser/testdata/corpus/sql/join/inner/test_prefix_range_filter_pushdown_strinline.test new file mode 100644 index 0000000..b4ae73d --- /dev/null +++ b/parser/testdata/corpus/sql/join/inner/test_prefix_range_filter_pushdown_strinline.test @@ -0,0 +1,213 @@ +# source: test/sql/join/inner/test_prefix_range_filter_pushdown_strinline.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +CREATE OR REPLACE TABLE probe_varchar AS +SELECT lpad(i::VARCHAR, 8, '0') AS k, (i % 11)::INTEGER AS g +FROM range(0, 100000) t(i); +-- +ok +== +EXPLAIN ANALYZE +SELECT count(*) +FROM probe_varchar p +JOIN build_varchar b + ON p.k = b.k + AND p.g >= b.g; +-- +ok +== +CREATE OR REPLACE TABLE prf_probe_string (k VARCHAR, g INTEGER, id INTEGER); +-- +ok +== +INSERT INTO prf_probe_string VALUES + ('', 0, 1), + ('a', 0, 2), + ('ab', 1, 3), + ('abc', 0, 4), + ('abcd', 0, 5), + ('abcd0', 0, 6), + ('abcd9', 1, 7), + ('abce', 0, 8), + ('zzzz', 0, 9), + (NULL, 0, 10); +-- +ok +== +CREATE OR REPLACE TABLE prf_build_string (k VARCHAR, g INTEGER, payload INTEGER); +-- +ok +== +INSERT INTO prf_build_string VALUES + ('', 0, 100), + ('a', 0, 101), + ('ab', 0, 102), + ('abc', 0, 103), + ('abcd', 0, 104), + ('abcd1', 0, 105), + ('abcf', 0, 106), + (NULL, 0, 107), + ('abcd2', 1, 108); +-- +ok +== +EXPLAIN ANALYZE +SELECT count(*) +FROM prf_probe_string p +JOIN prf_build_string b + ON p.k = b.k + AND p.g >= b.g; +-- +ok +== +CREATE OR REPLACE TABLE prf_probe_string_long AS +SELECT * FROM (VALUES + ('aaab_long_probe_0001', 0, 1), + ('aaac_long_probe_0002', 0, 2), + ('aaad_long_probe_0003', 1, 3), + ('zzzz_long_probe_9999', 0, 4), + (NULL, 0, 5) +) AS t(k, g, id); +-- +ok +== +CREATE OR REPLACE TABLE prf_build_string_long AS +SELECT * FROM (VALUES + ('aaab_long_build_1001', 0, 100), + ('aaac_long_build_1002', 0, 101), + ('aaad_long_build_1003', 0, 102), + ('aaaz_long_build_1999', 0, 103), + (NULL, 0, 104) +) AS t(k, g, payload); +-- +ok +== +EXPLAIN ANALYZE +SELECT count(*) +FROM prf_probe_string_long p +JOIN prf_build_string_long b + ON p.k = b.k + AND p.g >= b.g; +-- +ok +== +CREATE OR REPLACE TABLE prf_probe_string_long_single AS +SELECT * FROM (VALUES + ('aaab_long_single_value_0001', 0, 1), + ('aaab_long_single_value_0001', 1, 2), + ('zzzz_long_single_value_9999', 0, 3), + (NULL, 0, 4) +) AS t(k, g, id); +-- +ok +== +CREATE OR REPLACE TABLE prf_build_string_long_single AS +SELECT * FROM (VALUES + ('aaab_long_single_value_0001', 0, 200), + ('aaab_long_single_value_0001', 1, 201), + (NULL, 0, 202) +) AS t(k, g, payload); +-- +ok +== +EXPLAIN ANALYZE +SELECT count(*) +FROM prf_probe_string_long_single p +JOIN prf_build_string_long_single b + ON p.k = b.k + AND p.g >= b.g; +-- +ok +== +CREATE OR REPLACE TABLE prf_probe_string_long_same_prefix AS +SELECT * FROM (VALUES + ('aaaa_probe_suffix_0001', 0, 1), + ('aaaa_probe_suffix_0002', 1, 2), + ('zzzz_probe_suffix_9999', 0, 3), + (NULL, 0, 4) +) AS t(k, g, id); +-- +ok +== +CREATE OR REPLACE TABLE prf_build_string_long_same_prefix AS +SELECT * FROM (VALUES + ('aaaa_build_suffix_1001', 0, 300), + ('aaaa_build_suffix_2002', 0, 301), + ('aaaa_build_suffix_3003', 1, 302), + (NULL, 0, 303) +) AS t(k, g, payload); +-- +ok +== +EXPLAIN ANALYZE +SELECT count(*) +FROM prf_probe_string_long_same_prefix p +JOIN prf_build_string_long_same_prefix b + ON p.k = b.k + AND p.g >= b.g; +-- +ok +== +ATTACH '{TEST_DIR}/prf_string_nul_stats.db' AS prf_string_nul_stats (ROW_GROUP_SIZE 2048); +-- +ok +== +CREATE OR REPLACE TABLE prf_string_nul_stats.prf_probe_string_nul_stats ( + id INTEGER NOT NULL, + k VARCHAR NOT NULL, + g INTEGER NOT NULL +); +-- +ok +== +INSERT INTO prf_string_nul_stats.prf_probe_string_nul_stats +SELECT i AS id, + CASE + WHEN i < 2048 THEN 'aa' || lpad(i::VARCHAR, 8, '0') + ELSE 'ab' || chr(0) || 'd' + END AS k, + CASE + WHEN i < 2048 THEN 0 + ELSE 2 + END AS g +FROM range(4096) t(i); +-- +ok +== +CHECKPOINT prf_string_nul_stats; +-- +ok +== +CREATE OR REPLACE TABLE prf_build_string_nul_stats ( + k VARCHAR, + g INTEGER, + payload INTEGER +); +-- +ok +== +INSERT INTO prf_build_string_nul_stats VALUES + ('ab' || chr(0) || 'd', 1, 300), + ('ab' || chr(0) || 'x', 1, 301); +-- +ok +== +EXPLAIN ANALYZE +SELECT count(*) +FROM prf_string_nul_stats.prf_probe_string_nul_stats p +JOIN prf_build_string_nul_stats b + ON p.k = b.k + AND p.g >= b.g; +-- +ok +== +SELECT count(*) +FROM prf_string_nul_stats.prf_probe_string_nul_stats p +JOIN prf_build_string_nul_stats b + ON p.k = b.k + AND p.g >= b.g; +-- +ok +== diff --git a/parser/testdata/corpus/sql/join/inner/test_range_join.test b/parser/testdata/corpus/sql/join/inner/test_range_join.test new file mode 100644 index 0000000..cca3894 --- /dev/null +++ b/parser/testdata/corpus/sql/join/inner/test_range_join.test @@ -0,0 +1,49 @@ +# source: test/sql/join/inner/test_range_join.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +SELECT test.b, test2.b FROM test, test2 WHERE test.btest2.c AND test.b <= test2.b +-- +ok +== +INSERT INTO test VALUES (11, NULL), (NULL, 1) +-- +ok +== +INSERT INTO test2 VALUES (1, NULL), (NULL, 10) +-- +ok +== +PRAGMA debug_force_external=true; +-- +ok +== +CREATE TABLE issue4419 (x INT, y VARCHAR); +-- +ok +== +INSERT INTO issue4419 VALUES (1, 'sssssssssssssssssueufuheuooefef'); +-- +ok +== +INSERT INTO issue4419 VALUES (2, 'sssssssssssssssssueufuheuooefesffff'); +-- +ok +== +INSERT INTO issue4419 VALUES (2, 'sssssssssssssssssueufuheuooefesffffsssssssieiffih'); +-- +ok +== +SELECT * FROM issue4419 t1 INNER JOIN issue4419 t2 ON t1.x < t2.x; +-- +ok +== diff --git a/parser/testdata/corpus/sql/join/inner/test_unequal_join.test b/parser/testdata/corpus/sql/join/inner/test_unequal_join.test new file mode 100644 index 0000000..aa1be13 --- /dev/null +++ b/parser/testdata/corpus/sql/join/inner/test_unequal_join.test @@ -0,0 +1,41 @@ +# source: test/sql/join/inner/test_unequal_join.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +SELECT test.b, test2.b FROM test, test2 WHERE test.b <> test2.b ORDER BY test.b, test2.b +-- +ok +== +SELECT test.b, test2.b FROM test, test2 WHERE test.b <> test2.b AND test.b <> 1 AND test2.b <> 2 ORDER BY test.b, test2.b +-- +ok +== +INSERT INTO test VALUES (NULL, NULL) +-- +ok +== +INSERT INTO test2 VALUES (NULL, NULL) +-- +ok +== +create table a (i integer) +-- +ok +== +insert into a values ('28579'),('16098'),('25281'),('28877'),('18048'),('26820'),('26971'),('22812'),('11757'),('21851'),('27752'),('28354'),('29843'),('28828'),('16668'),('20534'),('28222'),('24244'),('28877'),('20150'),('23451'),('23683'),('20419'),('28048'),('24244'),('28605'),('25752'),('24466'),('26557'),('16098'),('29454'),('24854'),('13298'),('29584'),('13394'),('24843'),('22477'),('14593'),('24244'),('28722'),('25124'),('16668'),('26787'),('28877'),('27752'),('28482'),('24408'),('25752'),('24136'),('28222'),('17683'),('24244'),('19275'),('21087'),('26594'),('22293'),('25281'),('12898'),('23451'),('12898'),('21757'),('20965'),('25709'),('26614'),('10399'),('28773'),('11933'),('29584'),('29003'),('26871'),('17746'),('24092'),('26192'),('19310'),('10965'),('29275'),('20191'),('29101'),('28059'),('29584'),('20399'),('24338'),('26192'),('25124'),('28605'),('13003'),('16668'),('23511'),('26534'),('24107') +-- +ok +== +create table b (j integer) +-- +ok +== +insert into b values ('31904'),('31904'),('31904'),('31904'),('35709'),('31904'),('31904'),('35709'),('31904'),('31904'),('31904'),('31904') +-- +ok +== +select count(*) from a,b where i <> j +-- +ok +== diff --git a/parser/testdata/corpus/sql/join/inner/test_unequal_join_duplicates.test b/parser/testdata/corpus/sql/join/inner/test_unequal_join_duplicates.test new file mode 100644 index 0000000..3a867b8 --- /dev/null +++ b/parser/testdata/corpus/sql/join/inner/test_unequal_join_duplicates.test @@ -0,0 +1,17 @@ +# source: test/sql/join/inner/test_unequal_join_duplicates.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +CREATE TABLE test (b INTEGER); +-- +ok +== +CREATE TABLE test2 AS SELECT * FROM repeat(1, 10*1024) t1(b); +-- +ok +== +SELECT COUNT(*) FROM test INNER JOIN test2 ON test.b<>test2.b +-- +ok +== diff --git a/parser/testdata/corpus/sql/join/inner/test_using_chain.test b/parser/testdata/corpus/sql/join/inner/test_using_chain.test new file mode 100644 index 0000000..50504b7 --- /dev/null +++ b/parser/testdata/corpus/sql/join/inner/test_using_chain.test @@ -0,0 +1,73 @@ +# source: test/sql/join/inner/test_using_chain.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +CREATE TABLE t1 (a INTEGER, b INTEGER) +-- +ok +== +INSERT INTO t1 VALUES (1, 2) +-- +ok +== +CREATE TABLE t2 (b INTEGER, c INTEGER) +-- +ok +== +INSERT INTO t2 VALUES (2, 3) +-- +ok +== +CREATE TABLE t3 (c INTEGER, d INTEGER) +-- +ok +== +INSERT INTO t3 VALUES (3, 4) +-- +ok +== +SELECT * FROM t1 JOIN t2 USING (b) JOIN t3 USING (c) ORDER BY 1, 2, 3, 4; +-- +ok +== +SELECT * FROM t1 JOIN t2 USING (c) +-- +ok +== +SELECT * FROM t1 JOIN t2 USING (a) +-- +ok +== +DROP TABLE t2 +-- +ok +== +DROP TABLE t3 +-- +ok +== +CREATE TABLE t1 (a INTEGER, b INTEGER, c INTEGER) +-- +ok +== +INSERT INTO t1 VALUES (1, 2, 2) +-- +ok +== +CREATE TABLE t2 (b INTEGER, c INTEGER, d INTEGER, e INTEGER) +-- +ok +== +INSERT INTO t2 VALUES (2, 2, 3, 4) +-- +ok +== +CREATE TABLE t3 (d INTEGER, e INTEGER) +-- +ok +== +SELECT * FROM t1 JOIN t2 USING (b, c) JOIN t3 USING (d, e); +-- +ok +== diff --git a/parser/testdata/corpus/sql/join/inner/test_using_join.test b/parser/testdata/corpus/sql/join/inner/test_using_join.test new file mode 100644 index 0000000..fdef5e6 --- /dev/null +++ b/parser/testdata/corpus/sql/join/inner/test_using_join.test @@ -0,0 +1,77 @@ +# source: test/sql/join/inner/test_using_join.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +CREATE TABLE t1 (a INTEGER, b INTEGER, c INTEGER); +-- +ok +== +INSERT INTO t1 VALUES (1,2,3); +-- +ok +== +CREATE TABLE t2 (a INTEGER, b INTEGER, c INTEGER); +-- +ok +== +INSERT INTO t2 VALUES (1,2,3), (2,2,4), (1,3,4); +-- +ok +== +SELECT * FROM t1 JOIN t2 USING(a) JOIN t2 t2b USING (a) ORDER BY 1, 2, 3, 4, 5, 6, 7; +-- +ok +== +SELECT t2.a, t2.b, t2.c FROM t1 JOIN t2 USING(a) ORDER BY t2.b +-- +ok +== +SELECT t2.a, t2.b, t2.c FROM t1 JOIN t2 USING(b) ORDER BY t2.c +-- +ok +== +SELECT t2.a, t2.b, t2.c FROM t1 JOIN t2 USING(a,b) +-- +ok +== +SELECT t2.a, t2.b, t2.c FROM t1 JOIN t2 USING(a,b,c) +-- +ok +== +SELECT a+1 FROM t1 JOIN t2 USING(a) ORDER BY a +-- +ok +== +SELECT t2.a, t2.b, t2.c FROM t1 JOIN t2 USING(a+b) +-- +error: Parser Error: syntax error at or near "+" +== +SELECT t2.a, t2.b, t2.c FROM t1 JOIN t2 USING("") +-- +error: Parser Error: zero-length delimited identifier +== +SELECT t2.a, t2.b, t2.c FROM t1 JOIN t2 USING(d) +-- +ok +== +SELECT t2.a, t2.b, t2.c FROM t1 JOIN t2 USING(t1.a) +-- +error: Parser Error: syntax error at or near "." +== +SELECT * FROM t1 JOIN t2 USING(a,b) +-- +ok +== +SELECT * FROM t1 JOIN t2 USING(a) JOIN t2 t2b USING (b); +-- +ok +== +select * from (values (1)) tbl(i) join ((values (1)) tbl2(i) join (values (1)) tbl3(i) on tbl2.i=tbl3.i) using (i) +-- +ok +== +SELECT * FROM t1 JOIN t2 USING(a) JOIN t2 t2b USING (a) ORDER BY 1, 2, 3, 4, 5, 6, 7 +-- +ok +== diff --git a/parser/testdata/corpus/sql/join/inner/test_varchar_join.test b/parser/testdata/corpus/sql/join/inner/test_varchar_join.test new file mode 100644 index 0000000..f4ed6b2 --- /dev/null +++ b/parser/testdata/corpus/sql/join/inner/test_varchar_join.test @@ -0,0 +1,25 @@ +# source: test/sql/join/inner/test_varchar_join.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +select * from (select NULL::varchar as b) sq1, (select 'asdf' as b) sq2 where sq1.b = sq2.b; +-- +ok +== +select * from (select 42 as a, NULL::varchar as b) sq1, (select 42 as a, 'asdf' as b) sq2 where sq1.b <> sq2.b; +-- +ok +== +select * from (select 42 as a, NULL::varchar as b) sq1, (select 42 as a, 'asdf' as b) sq2 where sq1.a=sq2.a and sq1.b <> sq2.b; +-- +ok +== +select * from (select 42 as a, 'asdf' as b) sq2, (select 42 as a, NULL::varchar as b) sq1 where sq1.b <> sq2.b; +-- +ok +== +select * from (select 42 as a, 'asdf' as b) sq2, (select 42 as a, NULL::varchar as b) sq1 where sq1.a=sq2.a and sq1.b <> sq2.b; +-- +ok +== diff --git a/parser/testdata/corpus/sql/join/left_outer/left_join_issue_1172.test b/parser/testdata/corpus/sql/join/left_outer/left_join_issue_1172.test new file mode 100644 index 0000000..59effd7 --- /dev/null +++ b/parser/testdata/corpus/sql/join/left_outer/left_join_issue_1172.test @@ -0,0 +1,62 @@ +# source: test/sql/join/left_outer/left_join_issue_1172.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +drop table if exists t1; +-- +ok +== +drop table if exists t2; +-- +ok +== +create table t1 (id string); +-- +ok +== +create table t2 (id string); +-- +ok +== +insert into t1 values +(NULL); +-- +ok +== +insert into t2 values (1), (1); +-- +ok +== +select * from t1 left join t2 on t1.id = t2.id; +-- +ok +== +select * from t1 left join t2 on t1.id > t2.id; +-- +ok +== +select * from t1 left join t2 on t1.id <> t2.id; +-- +ok +== +insert into t2 values (NULL), (NULL); +-- +ok +== +insert into t1 (id) values (1), (1), (NULL); +-- +ok +== +insert into t2 (id) values (1), (1), (1), (1), (1), (1); +-- +ok +== +select * from t1 left join t2 on t1.id = t2.id order by 1, 2; +-- +ok +== +insert into t2 (id) values (1); +-- +ok +== diff --git a/parser/testdata/corpus/sql/join/left_outer/left_join_issue_15316.test b/parser/testdata/corpus/sql/join/left_outer/left_join_issue_15316.test new file mode 100644 index 0000000..fcce8c5 --- /dev/null +++ b/parser/testdata/corpus/sql/join/left_outer/left_join_issue_15316.test @@ -0,0 +1,49 @@ +# source: test/sql/join/left_outer/left_join_issue_15316.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +CREATE OR REPLACE TABLE big_table AS +SELECT i.range AS col1, + CAST(random() * 1000 AS INTEGER) AS col2 +FROM range(100) i; +-- +ok +== +CREATE OR REPLACE TABLE single_col_table AS +SELECT i.range AS col1 +FROM range(50) i; +-- +ok +== +explain SELECT * +FROM big_table c +LEFT OUTER JOIN single_col_table hd ON hd.col1=c.col1 +AND ( + FALSE +); +-- +ok +== +CREATE TABLE integers1 AS SELECT * FROM (VALUES (1), (2), (3)) tbl(i); +-- +ok +== +CREATE TABLE integers2 AS SELECT * FROM (VALUES (1, '1'), (2, '2'), (3, '3')) tbl(i, s); +-- +ok +== +CREATE TABLE integers3 AS SELECT * FROM (VALUES (1, '4'), (2, '5'), (3, '6')) tbl(i, s); +-- +ok +== +SELECT + i1.i AS i1_i, + i2.s, + i3.i AS i3_i +FROM + integers1 i1 +LEFT OUTER JOIN (integers2 i2 LEFT OUTER JOIN integers3 i3 ON i2.i = i3.i) on false; +-- +ok +== diff --git a/parser/testdata/corpus/sql/join/left_outer/left_join_issue_23805.test b/parser/testdata/corpus/sql/join/left_outer/left_join_issue_23805.test new file mode 100644 index 0000000..71d31b0 --- /dev/null +++ b/parser/testdata/corpus/sql/join/left_outer/left_join_issue_23805.test @@ -0,0 +1,33 @@ +# source: test/sql/join/left_outer/left_join_issue_23805.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +CREATE TABLE t (id VARCHAR, c2 INTEGER); +-- +ok +== +CREATE TABLE t3 (id VARCHAR); +-- +ok +== +INSERT INTO t VALUES ('match', 42), ('other', 7); +-- +ok +== +INSERT INTO t3 VALUES ('match'), ('missing'); +-- +ok +== +SELECT + t3.id, + b.c2 AS m1, + b.c2 AS m2 +FROM t3 +CROSS JOIN (SELECT 42 AS x) t2 +LEFT JOIN t a ON t3.id = a.id +LEFT JOIN t b ON t3.id = b.id +LEFT JOIN t c ON t3.id = c.id; +-- +ok +== diff --git a/parser/testdata/corpus/sql/join/left_outer/left_join_issue_6341.test b/parser/testdata/corpus/sql/join/left_outer/left_join_issue_6341.test new file mode 100644 index 0000000..97776d9 --- /dev/null +++ b/parser/testdata/corpus/sql/join/left_outer/left_join_issue_6341.test @@ -0,0 +1,33 @@ +# source: test/sql/join/left_outer/left_join_issue_6341.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +CREATE TABLE foo (ts TIMESTAMP); +-- +ok +== +CREATE TABLE bar (ts TIMESTAMP); +-- +ok +== +INSERT INTO foo VALUES ('2023-01-01 00:00:00'); +-- +ok +== +INSERT INTO foo VALUES ('2023-01-01 00:00:01'); +-- +ok +== +SELECT foo.ts foo, bar.ts bar FROM foo LEFT JOIN bar ON foo.ts = bar.ts; +-- +ok +== +SELECT foo.ts foo, bar.ts bar FROM foo LEFT JOIN bar ON foo.ts < bar.ts; +-- +ok +== +SELECT foo.ts foo, bar.ts bar FROM foo LEFT JOIN bar ON foo.ts > bar.ts; +-- +ok +== diff --git a/parser/testdata/corpus/sql/join/left_outer/left_join_issue_7905.test b/parser/testdata/corpus/sql/join/left_outer/left_join_issue_7905.test new file mode 100644 index 0000000..33e3f09 --- /dev/null +++ b/parser/testdata/corpus/sql/join/left_outer/left_join_issue_7905.test @@ -0,0 +1,54 @@ +# source: test/sql/join/left_outer/left_join_issue_7905.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +CREATE TABLE a(a1 VARCHAR); +-- +ok +== +CREATE TABLE b( + b1 VARCHAR, + b2 TIMESTAMP, + b3 TIMESTAMP, + b4 VARCHAR, + b5 VARCHAR, + b6 VARCHAR, + b7 TIMESTAMP, + b8 TIMESTAMP, + b9 VARCHAR, + b10 VARCHAR, + b11 VARCHAR, + b12 VARCHAR, + b13 VARCHAR, + b14 VARCHAR, +); +-- +ok +== +INSERT INTO b VALUES (NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL); +-- +ok +== +CREATE TABLE c( + c1 VARCHAR, +); +-- +ok +== +CREATE TABLE d( + d1 VARCHAR, + d2 VARCHAR, +); +-- +ok +== +SELECT * +FROM a +LEFT JOIN b ON b.b14 = a.a1 +LEFT JOIN c ON b.b13 = c.c1 + LEFT JOIN d ON b.b12 = d.d1 + WHERE d.d2 IN (''); +-- +ok +== diff --git a/parser/testdata/corpus/sql/join/left_outer/non_foldable_left_join.test b/parser/testdata/corpus/sql/join/left_outer/non_foldable_left_join.test new file mode 100644 index 0000000..97b5347 --- /dev/null +++ b/parser/testdata/corpus/sql/join/left_outer/non_foldable_left_join.test @@ -0,0 +1,9 @@ +# source: test/sql/join/left_outer/non_foldable_left_join.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +select * from range(1) tbl(i) left join range(2) tbl2(j) on (i=j) where j+random()<0; +-- +ok +== diff --git a/parser/testdata/corpus/sql/join/left_outer/test_left_join_filter_pushdown.test b/parser/testdata/corpus/sql/join/left_outer/test_left_join_filter_pushdown.test new file mode 100644 index 0000000..cc3881a --- /dev/null +++ b/parser/testdata/corpus/sql/join/left_outer/test_left_join_filter_pushdown.test @@ -0,0 +1,39 @@ +# source: test/sql/join/left_outer/test_left_join_filter_pushdown.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +INSERT INTO left_table VALUES (1, 1, 50), (2, 1, 75), (3, 2, 60), (4, 2, 90), (5, 99, 100); +-- +ok +== +SELECT * FROM left_table l +LEFT JOIN right_table r ON l.id = r.id AND l.val > 1 AND r.category = 1; +-- +ok +== +SELECT * FROM left_table l +LEFT JOIN right_table r ON l.id = r.id AND r.category = 1; +-- +ok +== +SELECT * FROM left_table l +LEFT JOIN right_table r ON l.id = r.id AND l.val > 1; +-- +ok +== +SELECT * FROM left_table l +LEFT JOIN right_table r ON l.id = r.id AND true; +-- +ok +== +SELECT * FROM left_table l +LEFT JOIN right_table r ON l.id = r.id AND false; +-- +ok +== +SELECT * FROM left_table l +LEFT JOIN right_table r ON l.id = r.id AND l.amount + r.budget > 1100; +-- +ok +== diff --git a/parser/testdata/corpus/sql/join/left_outer/test_left_join_on_true.test b/parser/testdata/corpus/sql/join/left_outer/test_left_join_on_true.test new file mode 100644 index 0000000..5353301 --- /dev/null +++ b/parser/testdata/corpus/sql/join/left_outer/test_left_join_on_true.test @@ -0,0 +1,78 @@ +# source: test/sql/join/left_outer/test_left_join_on_true.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +WITH t AS ( + SELECT 1 AS r, [{n:1}, {n:2}] AS s + UNION + SELECT 2 AS r, [{n:3}, {n:4}] AS s +) +SELECT r, s1.s.n FROM t +LEFT JOIN UNNEST(s) AS s1(s) ON TRUE +ORDER BY 1, 2 +-- +ok +== +WITH t AS ( + SELECT 1 AS r, ARRAY[1, 2, 3] AS a + UNION SELECT 2 AS r, ARRAY[4] AS a + UNION SELECT 4 AS r, ARRAY[] AS a +) +SELECT r, a.value +FROM t +LEFT JOIN UNNEST(a) AS a(value) ON TRUE +ORDER BY 1, 2 +-- +ok +== +WITH t AS ( + SELECT 1 AS r, ARRAY[1, 2, 3] AS a + UNION SELECT 2 AS r, ARRAY[4] AS a + UNION SELECT 4 AS r, ARRAY[]::INTEGER[] AS a +) +SELECT r, a.value +FROM t +LEFT JOIN UNNEST(a) AS a(value) ON TRUE AND a.value IS NULL +ORDER BY 1, 2 +-- +ok +== +WITH t AS ( + SELECT 1 AS r, ARRAY[1, 2, 3] AS a + UNION SELECT 2 AS r, ARRAY[4] AS a + UNION SELECT 4 AS r, ARRAY[] AS a +) +SELECT r, a.value +FROM t +LEFT JOIN UNNEST(a) AS a(value) ON (1 = 1) AND TRUE AND list_contains([2, 3], 2) +ORDER BY 1, 2 +-- +ok +== +WITH t AS ( + SELECT 1 AS r, [{n:1}, {n:2}] AS s + UNION + SELECT 2 AS r, [{n:3}, {n:4}] AS s +) +SELECT r, s1.s.n FROM t +LEFT JOIN UNNEST(s) AS s1(s) ON FALSE +-- +ok +== +INSERT INTO integers VALUES (1, 2), (2, 3), (3, 4) +-- +ok +== +SELECT * FROM integers LEFT OUTER JOIN integers2 ON TRUE AND integers.i=integers2.k AND TRUE ORDER BY i +-- +ok +== +SELECT * FROM integers LEFT OUTER JOIN integers2 ON TRUE AND integers.i=integers2.k AND FALSE ORDER BY i +-- +ok +== +SELECT * FROM integers LEFT OUTER JOIN integers2 ON TRUE ORDER BY i +-- +ok +== diff --git a/parser/testdata/corpus/sql/join/left_outer/test_left_outer.test b/parser/testdata/corpus/sql/join/left_outer/test_left_outer.test new file mode 100644 index 0000000..42d5ebb --- /dev/null +++ b/parser/testdata/corpus/sql/join/left_outer/test_left_outer.test @@ -0,0 +1,89 @@ +# source: test/sql/join/left_outer/test_left_outer.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +SELECT * FROM integers LEFT OUTER JOIN integers2 ON integers.i=integers2.k ORDER BY i +-- +ok +== +SELECT * FROM integers2 RIGHT OUTER JOIN integers ON integers.i=integers2.k ORDER BY i +-- +ok +== +SELECT * FROM integers LEFT OUTER JOIN integers2 ON integers.i=integers2.k WHERE k IS NOT NULL ORDER BY i +-- +ok +== +SELECT * FROM integers LEFT OUTER JOIN integers2 ON integers.i=integers2.k AND integers2.k IS NOT NULL ORDER BY i +-- +ok +== +SELECT * FROM integers LEFT OUTER JOIN integers2 ON i=1 ORDER BY i, k; +-- +ok +== +SELECT * FROM integers LEFT OUTER JOIN integers2 ON 1=1 ORDER BY i, k; +-- +ok +== +SELECT * FROM integers LEFT OUTER JOIN (SELECT * FROM integers2 WHERE 1<>1) tbl2 ON 1=2 ORDER BY i; +-- +ok +== +SELECT * FROM integers LEFT OUTER JOIN integers2 ON 1=2 ORDER BY i; +-- +ok +== +SELECT * FROM integers LEFT OUTER JOIN integers2 ON NULL<>NULL ORDER BY i; +-- +ok +== +SELECT * FROM integers LEFT OUTER JOIN integers2 ON l=20 ORDER BY i, k; +-- +ok +== +SELECT * FROM integers LEFT OUTER JOIN integers2 ON l>0 ORDER BY i, k; +-- +ok +== +SELECT * FROM integers LEFT OUTER JOIN integers2 ON i=1 OR l=20 ORDER BY i, k; +-- +ok +== +SELECT * FROM integers LEFT OUTER JOIN integers2 ON i=4 OR l=17 ORDER BY i; +-- +ok +== +SELECT * FROM integers LEFT OUTER JOIN integers2 ON i+l=21 ORDER BY i; +-- +ok +== +SELECT * FROM integers LEFT OUTER JOIN integers2 ON i+l>12 ORDER BY i, k; +-- +ok +== +SELECT * FROM integers LEFT OUTER JOIN integers2 ON integers.i 3 OR f.fk IS NULL +-- +ok +== +SELECT COUNT(*) - COUNT(d.label) FROM big_fact f LEFT JOIN big_dim d ON f.fk = d.id +-- +ok +== +SELECT SUM(f.fk) FROM big_fact f LEFT JOIN big_dim d ON f.fk = d.id +-- +ok +== diff --git a/parser/testdata/corpus/sql/join/natural/natural_join.test b/parser/testdata/corpus/sql/join/natural/natural_join.test new file mode 100644 index 0000000..4ad918d --- /dev/null +++ b/parser/testdata/corpus/sql/join/natural/natural_join.test @@ -0,0 +1,206 @@ +# source: test/sql/join/natural/natural_join.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +CREATE TABLE t2 (a INTEGER, c INTEGER) +-- +ok +== +INSERT INTO t2 VALUES (1, 3), (2, 4) +-- +ok +== +SELECT * FROM t1 NATURAL JOIN t2 +-- +ok +== +SELECT t1.a, t1.b, t2.c FROM t1 NATURAL JOIN t2 +-- +ok +== +SELECT t1.a, t1.b, t2.c FROM t1 NATURAL JOIN t2 ORDER BY t2.a +-- +ok +== +CREATE TABLE t3 (a INTEGER, b INTEGER, c INTEGER) +-- +ok +== +INSERT INTO t3 VALUES (1, 2, 3) +-- +ok +== +SELECT * FROM t1 NATURAL JOIN t3 +-- +ok +== +SELECT * FROM t3 NATURAL JOIN t2 +-- +ok +== +SELECT * FROM t1 NATURAL JOIN t2 NATURAL JOIN t3 +-- +ok +== +CREATE TABLE issue24045_a(x INTEGER); +-- +ok +== +CREATE TABLE issue24045_b(x INTEGER); +-- +ok +== +CREATE TABLE issue24045_c(x INTEGER); +-- +ok +== +CREATE TABLE issue24045_d(y INTEGER); +-- +ok +== +INSERT INTO issue24045_a VALUES (1); +-- +ok +== +INSERT INTO issue24045_c VALUES (1); +-- +ok +== +INSERT INTO issue24045_d VALUES (9); +-- +ok +== +SELECT issue24045_c.x, issue24045_d.y +FROM issue24045_a NATURAL LEFT JOIN issue24045_b +NATURAL JOIN issue24045_c +RIGHT JOIN issue24045_d ON true +-- +ok +== +select * from (values (1)) tbl(a) natural join (values (1), (2)) tbl2(b) order by 1, 2 +-- +ok +== +select * from (values (1)) tbl(a) natural join (values (1)) tbl2(a) natural join (values (1)) tbl3(a) + natural join (values (1)) tbl4(a) natural join (values (1)) tbl5(a) +-- +ok +== +select * from (select 42) tbl(a) natural join (select 42) tbl2(a) +-- +ok +== +select (select * from (select 42) tbl(a) natural join (select 42) tbl2(a)) +-- +ok +== +select * +from + (select 42, 43, 44, 45, 46, 47, 48, 49, 50, 51, 52) tbl1(a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11) + natural join + (select 42, 43, 44, 45, 46, 47, 48, 49, 50, 51, 52) tbl2(a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11); +-- +ok +== +CREATE TABLE sqlancer_t0(c0 DOUBLE, c1 DOUBLE); +-- +ok +== +INSERT INTO sqlancer_t0 VALUES +(0.000000, -1570504255.000000), +(0.000000, -1570504255.000000), +(0.000000, -1570504255.000000), +(0.000000, -1570504255.000000), +(0.000000, 1.000000), +(0.000000, 0.543647), +(0.000000, NULL), +(0.000000, 1.000000), +(0.000000, 1.000000), +(0.000000, 0.000000), +(0.000000, 1617540830.000000), +(0.000000, NULL), +(0.000000, NULL), +(0.000000, NULL), +(0.000000, 0.497659), +(0.000000, -1367407567.000000), +(0.000000, NULL), +(0.000000, NULL), +(0.000000, NULL), +(0.000000, NULL), +(0.000000, NULL), +(0.000000, -547966124.000000), +(0.000000, NULL), +(0.000000, -1417028911.000000), +(0.000000, 277394703.000000), +(0.000000, NULL), +(0.000000, NULL), +(0.000000, NULL), +(0.000000, NULL), +(0.000000, NULL) +; +-- +ok +== +CREATE VIEW sqlancer_v0(c0, c1) AS SELECT sqlancer_t0.c0, ((sqlancer_t0.rowid)//(-1694294358)) +FROM sqlancer_t0 +ORDER BY TIMESTAMP '1970-01-08 16:19:01' ASC; +-- +ok +== +SELECT DISTINCT sqlancer_v0.c1, sqlancer_t0.rowid +FROM sqlancer_v0 NATURAL FULL JOIN sqlancer_t0 +ORDER BY 2 ASC; +-- +ok +== +SELECT DISTINCT sqlancer_v0.c1, sqlancer_t0.rowid +FROM sqlancer_v0 NATURAL FULL JOIN sqlancer_t0 WHERE sqlancer_t0.c0 +UNION +SELECT DISTINCT sqlancer_v0.c1, sqlancer_t0.rowid +FROM sqlancer_v0 NATURAL FULL JOIN sqlancer_t0 +WHERE (NOT sqlancer_t0.c0) +UNION +SELECT DISTINCT sqlancer_v0.c1, sqlancer_t0.rowid +FROM sqlancer_v0 NATURAL FULL JOIN sqlancer_t0 +WHERE ((sqlancer_t0.c0) IS NULL) +ORDER BY 2 ASC; +-- +ok +== +select (select * from (select 42) tbl(a) natural join (select 42) tbl(a)) +-- +ok +== +CREATE TABLE t0(c0 DATE, c1 DATE DEFAULT('0.5868720116119102'), c2 INT1, PRIMARY KEY(c1, c2, c0)); +-- +ok +== +CREATE TABLE t1(c0 DATETIME, c1 DATE DEFAULT(TIMESTAMP '1970-01-11 02:37:59'), PRIMARY KEY(c0)); +-- +ok +== +CREATE VIEW v0(c0) AS SELECT false FROM t1, t0 HAVING 1689380428; +-- +ok +== +SELECT COUNT(t1.rowid) FROM t1, v0 NATURAL RIGHT JOIN t0; +-- +ok +== +SELECT COUNT(t1.rowid) FROM t1, v0 RIGHT JOIN t0 ON v0.c0=t0.c0; +-- +ok +== +SELECT COUNT(t1.rowid) FROM t1, v0 RIGHT JOIN t0 ON t1.c1=t0.c1 AND v0.c0=t0.c0; +-- +ok +== +select * from (values (1)) t1(i) join (values (1)) t2(i) on (t1.i=t2.i) natural join (values (1)) t3(i); +-- +ok +== +select * from (values (1)) t1(i) natural join ((values (1)) t2(i) join (values (1)) t3(i) on (t2.i=t3.i)) +-- +ok +== diff --git a/parser/testdata/corpus/sql/join/nearest/nearest_basic.test b/parser/testdata/corpus/sql/join/nearest/nearest_basic.test new file mode 100644 index 0000000..ce1d33b --- /dev/null +++ b/parser/testdata/corpus/sql/join/nearest/nearest_basic.test @@ -0,0 +1,174 @@ +# source: test/sql/join/nearest/nearest_basic.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +CREATE TABLE users(user_id INT, name VARCHAR, embedding FLOAT[3]); +-- +ok +== +INSERT INTO users VALUES (1,'Alice',[1,0,0]),(2,'Bob',[0,1,0]),(3,'Carol',[0.2,0.3,0.9]); +-- +ok +== +CREATE TABLE products(product_id VARCHAR, name VARCHAR, price INT, country VARCHAR, embedding FLOAT[3]); +-- +ok +== +INSERT INTO products VALUES + ('P1','Trail running shoes',120,'EU',[0.9,0.1,0.1]), + ('P2','Hiking boots',180,'EU',[0.8,0.2,0.0]), + ('P3','Office shoes',95,'US',[0.1,0.9,0.1]), + ('P4','Sandals',45,'US',[0.0,0.8,0.2]), + ('P5','Running shoes',110,'EU',[0.5,0.5,0.0]); +-- +ok +== +SELECT q.user_id, q.name, t.product_id, t.name AS product FROM users q + INNER JOIN products t APPROX NEAREST 2 BY SIMILARITY array_cosine_similarity(q.embedding, t.embedding) + ORDER BY q.user_id, t.product_id; +-- +ok +== +SELECT t.product_id FROM (SELECT [1.0,0.0,0.0]::FLOAT[3] AS embedding) q + INNER JOIN products t EXACT NEAREST 3 BY DISTANCE array_distance(q.embedding, t.embedding) + ORDER BY t.product_id; +-- +ok +== +SELECT count(*) FROM ( + SELECT t.product_id FROM (SELECT [1.0,0.0,0.0]::FLOAT[3] AS embedding) q + INNER JOIN products t APPROX NEAREST 3 BY DISTANCE array_distance(q.embedding, t.embedding) + EXCEPT + SELECT t.product_id FROM (SELECT [1.0,0.0,0.0]::FLOAT[3] AS embedding) q + INNER JOIN products t EXACT NEAREST 3 BY DISTANCE array_distance(q.embedding, t.embedding) +); +-- +ok +== +SELECT q.user_id, t.product_id, t.price FROM users q + INNER JOIN (SELECT * FROM products WHERE country='EU') AS t + APPROX NEAREST 2 BY SIMILARITY array_cosine_similarity(q.embedding, t.embedding) + ORDER BY q.user_id, t.product_id; +-- +ok +== +SELECT q.user_id, t.product_id FROM users q + INNER JOIN products t NEAREST BY DISTANCE array_distance(q.embedding, t.embedding) + ORDER BY q.user_id; +-- +ok +== +CREATE TABLE empty_products(product_id VARCHAR, embedding FLOAT[3]); +-- +ok +== +SELECT q.user_id, t.product_id FROM users q + INNER JOIN empty_products t NEAREST 2 BY DISTANCE array_distance(q.embedding, t.embedding) + ORDER BY q.user_id; +-- +ok +== +SELECT q.user_id, t.product_id FROM users q + LEFT OUTER JOIN empty_products t NEAREST 2 BY DISTANCE array_distance(q.embedding, t.embedding) + ORDER BY q.user_id; +-- +ok +== +SELECT q.user_id, products.product_id FROM users q + INNER JOIN products NEAREST 1 BY DISTANCE array_distance(q.embedding, products.embedding) + ORDER BY q.user_id; +-- +ok +== +SELECT q.user_id, products.product_id FROM users q + INNER JOIN products APPROX NEAREST 1 BY SIMILARITY array_cosine_similarity(q.embedding, products.embedding) + ORDER BY q.user_id; +-- +ok +== +CREATE TABLE dup_users(user_id INT, embedding FLOAT[3]); +-- +ok +== +INSERT INTO dup_users VALUES (1,[1,0,0]),(1,[1,0,0]); +-- +ok +== +SELECT q.user_id, t.product_id FROM dup_users q + INNER JOIN products t NEAREST 1 BY DISTANCE array_distance(q.embedding, t.embedding) + ORDER BY t.product_id; +-- +ok +== +CREATE TABLE lnums(id INT, x INT); +-- +ok +== +INSERT INTO lnums VALUES (1,10),(2,20); +-- +ok +== +CREATE TABLE rnums(y INT); +-- +ok +== +INSERT INTO rnums VALUES (11),(19),(25),(100); +-- +ok +== +SELECT q.id, t.y FROM lnums q + INNER JOIN rnums t NEAREST 2 BY DISTANCE abs(q.x - t.y) + ORDER BY q.id, t.y; +-- +ok +== +SELECT count(*) FROM lnums q + INNER JOIN rnums t NEAREST 1 BY DISTANCE t.y; +-- +ok +== +CREATE TABLE rnull(y INT); +-- +ok +== +INSERT INTO rnull VALUES (11),(NULL),(19),(NULL),(100); +-- +ok +== +SELECT q.id, t.y FROM lnums q + INNER JOIN rnull t NEAREST 2 BY DISTANCE abs(q.x - t.y) + ORDER BY q.id, t.y; +-- +ok +== +CREATE TABLE all_null(y INT); +-- +ok +== +INSERT INTO all_null VALUES (NULL),(NULL); +-- +ok +== +SELECT q.id, t.y FROM lnums q + INNER JOIN all_null t NEAREST 2 BY DISTANCE abs(q.x - t.y) + ORDER BY q.id; +-- +ok +== +SELECT q.id, t.y FROM lnums q + LEFT OUTER JOIN all_null t NEAREST 2 BY DISTANCE abs(q.x - t.y) + ORDER BY q.id; +-- +ok +== +SELECT t.y FROM (SELECT 0 AS k) q + INNER JOIN rnums t NEAREST 1 BY SIMILARITY t.y; +-- +ok +== +SELECT t.y FROM (SELECT 0 AS k) q + INNER JOIN rnums t NEAREST 1 BY DISTANCE t.y; +-- +ok +== diff --git a/parser/testdata/corpus/sql/join/nearest/nearest_errors.test b/parser/testdata/corpus/sql/join/nearest/nearest_errors.test new file mode 100644 index 0000000..6f3eeff --- /dev/null +++ b/parser/testdata/corpus/sql/join/nearest/nearest_errors.test @@ -0,0 +1,49 @@ +# source: test/sql/join/nearest/nearest_errors.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +CREATE TABLE u(e FLOAT[3]); +-- +ok +== +CREATE TABLE p(e FLOAT[3]); +-- +ok +== +SELECT 1 FROM u q RIGHT JOIN p t NEAREST 1 BY DISTANCE array_distance(q.e, t.e) +-- +error: Parser Error: NEAREST BY only supports INNER and LEFT OUTER joins, not RIGHT +== +SELECT 1 FROM u q FULL OUTER JOIN p t NEAREST 1 BY DISTANCE array_distance(q.e, t.e) +-- +error: Parser Error: NEAREST BY only supports INNER and LEFT OUTER joins, not FULL +== +SELECT 1 FROM u q SEMI JOIN p t NEAREST 1 BY DISTANCE array_distance(q.e, t.e) +-- +error: Parser Error: NEAREST BY only supports INNER and LEFT OUTER joins, not SEMI +== +SELECT 1 FROM u q ANTI JOIN p t NEAREST 1 BY DISTANCE array_distance(q.e, t.e) +-- +error: Parser Error: NEAREST BY only supports INNER and LEFT OUTER joins, not ANTI +== +SELECT 1 FROM u q JOIN p t NEAREST 0 BY DISTANCE array_distance(q.e, t.e) +-- +error: Parser Error: NEAREST expects a positive integer literal, got "0" +== +SELECT 1 FROM u q JOIN p t NEAREST 1.5 BY DISTANCE array_distance(q.e, t.e) +-- +error: Parser Error: NEAREST expects a positive integer literal, got "1.5" +== +SELECT 1 FROM u q JOIN p t NEAREST -1 BY DISTANCE array_distance(q.e, t.e) +-- +error: Parser Error: syntax error at or near "-" +== +SELECT 1 FROM u q JOIN p t NEAREST 1 array_distance(q.e, t.e) +-- +error: Parser Error: syntax error at or near "array_distance" +== +SELECT 1 FROM u q JOIN p t NEAREST 1 BY array_distance(q.e, t.e) +-- +error: Parser Error: syntax error at or near "array_distance" +== diff --git a/parser/testdata/corpus/sql/join/nearest/nearest_errors.test.metadata.json b/parser/testdata/corpus/sql/join/nearest/nearest_errors.test.metadata.json new file mode 100644 index 0000000..292424e --- /dev/null +++ b/parser/testdata/corpus/sql/join/nearest/nearest_errors.test.metadata.json @@ -0,0 +1,10 @@ +{ + "todo": { + "07e88975ac7f20a0": "transformer-raised parser error: upstream rejects in the transformer, not the grammar; expected to clear as transformers land (milestones 3-5)", + "21b4e00cd5ee9574": "transformer-raised parser error: upstream rejects in the transformer, not the grammar; expected to clear as transformers land (milestones 3-5)", + "27d1471e2bc2db2c": "transformer-raised parser error: upstream rejects in the transformer, not the grammar; expected to clear as transformers land (milestones 3-5)", + "64c6e59cc6f48b32": "transformer-raised parser error: upstream rejects in the transformer, not the grammar; expected to clear as transformers land (milestones 3-5)", + "c0c3d3d824ff120d": "transformer-raised parser error: upstream rejects in the transformer, not the grammar; expected to clear as transformers land (milestones 3-5)", + "f89b2ba88a720463": "transformer-raised parser error: upstream rejects in the transformer, not the grammar; expected to clear as transformers land (milestones 3-5)" + } +} diff --git a/parser/testdata/corpus/sql/join/nearest/nearest_parser.test b/parser/testdata/corpus/sql/join/nearest/nearest_parser.test new file mode 100644 index 0000000..c8a8377 --- /dev/null +++ b/parser/testdata/corpus/sql/join/nearest/nearest_parser.test @@ -0,0 +1,70 @@ +# source: test/sql/join/nearest/nearest_parser.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +CREATE TABLE nearest(approx INT, exact INT, distance INT, similarity INT); +-- +ok +== +INSERT INTO nearest VALUES (1, 2, 3, 4); +-- +ok +== +SELECT approx, exact, distance, similarity FROM nearest ORDER BY nearest.approx; +-- +ok +== +SELECT 5 AS nearest, 6 AS approx, 7 AS exact; +-- +ok +== +CREATE TABLE users(user_id INT, embedding FLOAT[3]); +-- +ok +== +INSERT INTO users VALUES (1,[1,0,0]),(2,[0,1,0]); +-- +ok +== +CREATE TABLE products(product_id VARCHAR, embedding FLOAT[3]); +-- +ok +== +INSERT INTO products VALUES ('P1',[0.9,0.1,0.1]),('P2',[0.1,0.9,0.1]),('P3',[0.5,0.5,0.0]); +-- +ok +== +( + SELECT q.user_id, t.product_id FROM users q + INNER JOIN products t NEAREST 2 BY DISTANCE array_distance(q.embedding, t.embedding) + EXCEPT + SELECT q.user_id, t.product_id FROM users q + INNER JOIN (SELECT * FROM products ORDER BY array_distance(q.embedding, products.embedding) LIMIT 2) t ON TRUE +) +UNION ALL +( + SELECT q.user_id, t.product_id FROM users q + INNER JOIN (SELECT * FROM products ORDER BY array_distance(q.embedding, products.embedding) LIMIT 2) t ON TRUE + EXCEPT + SELECT q.user_id, t.product_id FROM users q + INNER JOIN products t NEAREST 2 BY DISTANCE array_distance(q.embedding, t.embedding) +); +-- +ok +== +SELECT count(*) FROM users q + INNER JOIN products NEAREST 1 BY DISTANCE array_distance(q.embedding, products.embedding); +-- +ok +== +SELECT count(*) FROM users q + INNER JOIN (SELECT embedding AS temb FROM products) NEAREST 1 BY DISTANCE array_distance(q.embedding, temb); +-- +ok +== +SELECT count(*) FROM (SELECT 1 AS a) q + INNER JOIN (VALUES (10),(20),(30)) NEAREST 2 BY DISTANCE abs(col0 - q.a); +-- +ok +== diff --git a/parser/testdata/corpus/sql/join/nearest/nearest_storage.test b/parser/testdata/corpus/sql/join/nearest/nearest_storage.test new file mode 100644 index 0000000..0b7adbc --- /dev/null +++ b/parser/testdata/corpus/sql/join/nearest/nearest_storage.test @@ -0,0 +1,82 @@ +# source: test/sql/join/nearest/nearest_storage.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +ATTACH '{TEST_DIR}/nearest_latest.db' AS latest_db (STORAGE_VERSION 'latest'); +-- +ok +== +CREATE TABLE latest_db.users(user_id INT, embedding FLOAT[3]); +-- +ok +== +INSERT INTO latest_db.users VALUES (1,[1,0,0]),(2,[0,1,0]); +-- +ok +== +CREATE TABLE latest_db.products(product_id VARCHAR, embedding FLOAT[3]); +-- +ok +== +INSERT INTO latest_db.products VALUES ('P1',[0.9,0.1,0.1]),('P2',[0.1,0.9,0.1]),('P3',[0.5,0.5,0.0]); +-- +ok +== +CREATE VIEW latest_db.nearest_view AS + SELECT q.user_id, t.product_id FROM latest_db.users q + INNER JOIN latest_db.products t APPROX NEAREST 2 BY SIMILARITY array_cosine_similarity(q.embedding, t.embedding); +-- +ok +== +SELECT sql LIKE '%APPROX NEAREST 2 BY SIMILARITY%' FROM duckdb_views() WHERE view_name = 'nearest_view'; +-- +ok +== +SELECT count(*) FROM latest_db.nearest_view; +-- +ok +== +CREATE VIEW latest_db.default_view AS + SELECT q.user_id, t.product_id FROM latest_db.users q + INNER JOIN latest_db.products t NEAREST 2 BY DISTANCE array_distance(q.embedding, t.embedding); +-- +ok +== +SELECT sql LIKE '%EXACT NEAREST 2 BY DISTANCE%' FROM duckdb_views() WHERE view_name = 'default_view'; +-- +ok +== +ATTACH '{TEST_DIR}/nearest_old.db' AS old_db (STORAGE_VERSION 'v1.4.0'); +-- +ok +== +CREATE TABLE old_db.users AS SELECT * FROM latest_db.users; +-- +ok +== +CREATE TABLE old_db.products AS SELECT * FROM latest_db.products; +-- +ok +== +CREATE VIEW old_db.nearest_view AS + SELECT q.user_id, t.product_id FROM old_db.users q + INNER JOIN old_db.products t NEAREST 2 BY DISTANCE array_distance(q.embedding, t.embedding); +-- +ok +== +CREATE MACRO old_db.nearest_macro() AS TABLE + SELECT q.user_id, t.product_id FROM old_db.users q + INNER JOIN old_db.products t NEAREST 2 BY DISTANCE array_distance(q.embedding, t.embedding); +-- +ok +== +CREATE VIEW old_db.regular_view AS + SELECT q.user_id, t.product_id FROM old_db.users q INNER JOIN old_db.products t ON (TRUE); +-- +ok +== +SELECT count(*) FROM old_db.regular_view; +-- +ok +== diff --git a/parser/testdata/corpus/sql/join/non_inner_decorrelation_regressions.test b/parser/testdata/corpus/sql/join/non_inner_decorrelation_regressions.test new file mode 100644 index 0000000..6eaa68c --- /dev/null +++ b/parser/testdata/corpus/sql/join/non_inner_decorrelation_regressions.test @@ -0,0 +1,337 @@ +# source: test/sql/join/non_inner_decorrelation_regressions.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +SELECT l.a, r.b, (SELECT l.a + r.b) AS z +FROM (VALUES (1), (2)) l(a) +FULL OUTER JOIN (VALUES (10), (20)) r(b) + ON EXISTS (SELECT 1 WHERE l.a = 1 AND r.b = 10) +ORDER BY ALL; +-- +ok +== +SELECT l.a, r.b +FROM (VALUES (1), (2)) l(a) +FULL OUTER JOIN (VALUES (10), (20)) r(b) + ON EXISTS (SELECT 1 WHERE l.a = 1 AND r.b = 10) +WHERE EXISTS (SELECT 1 WHERE l.a + r.b = 11) +ORDER BY ALL; +-- +ok +== +SELECT l.a, r.b, x.z +FROM (VALUES (1), (2)) l(a) +FULL OUTER JOIN (VALUES (10), (20)) r(b) + ON EXISTS (SELECT 1 WHERE l.a = 1 AND r.b = 10) +LEFT JOIN LATERAL (SELECT l.a + r.b AS z) x ON true +ORDER BY ALL; +-- +ok +== +SELECT l.a, r.b, s.c +FROM (VALUES (1), (2)) l(a) +FULL OUTER JOIN (VALUES (10), (20)) r(b) + ON EXISTS (SELECT 1 WHERE l.a = 1 AND r.b = 10) +LEFT JOIN (VALUES (100), (200)) s(c) + ON EXISTS (SELECT 1 WHERE l.a = 1 AND s.c = 100) +ORDER BY ALL; +-- +ok +== +SELECT l.a, r.b +FROM (VALUES (1), (2)) l(a) +FULL OUTER JOIN (VALUES (10), (20)) r(b) + ON EXISTS (SELECT 1 WHERE l.a = 1 AND r.b = 10) +SEMI JOIN (VALUES (100), (200)) s(c) + ON EXISTS (SELECT 1 WHERE l.a = 1 AND s.c = 100) +ORDER BY ALL; +-- +ok +== +SELECT l.a, r.b +FROM (VALUES (1), (2)) l(a) +FULL OUTER JOIN (VALUES (10), (20)) r(b) + ON EXISTS (SELECT 1 WHERE l.a = 1 AND r.b = 10) +ANTI JOIN (VALUES (100), (200)) s(c) + ON EXISTS (SELECT 1 WHERE l.a = 1 AND s.c = 100) +ORDER BY ALL; +-- +ok +== +SELECT o.x, EXISTS ( + SELECT * + FROM (VALUES (1)) l(a) + SEMI JOIN (VALUES (2)) r(b) + ON l.a = 1 AND o.x = 10 +) AS ex +FROM (VALUES (10), (20)) o(x) +ORDER BY o.x; +-- +ok +== +SELECT o.x, EXISTS ( + SELECT * + FROM (VALUES (1)) l(a) + ANTI JOIN (VALUES (2)) r(b) + ON l.a = 1 AND o.x = 10 +) AS ex +FROM (VALUES (10), (20)) o(x) +ORDER BY o.x; +-- +ok +== +WITH joined AS MATERIALIZED ( + SELECT l.a, r.b + FROM (VALUES (1), (2)) l(a) + FULL OUTER JOIN (VALUES (10), (20)) r(b) + ON EXISTS (SELECT 1 WHERE l.a = 1 AND r.b = 10) +) +SELECT joined.a, joined.b, x.z +FROM joined +LEFT JOIN LATERAL (SELECT joined.a + joined.b AS z) x ON true +ORDER BY ALL; +-- +ok +== +SELECT l.a, r.b, s.c, t.d +FROM ((VALUES (1), (2)) l(a) +FULL OUTER JOIN (VALUES (10), (20)) r(b) + ON EXISTS (SELECT 1 WHERE l.a = 1 AND r.b = 10)) +CROSS JOIN ((VALUES (3), (4)) s(c) +FULL OUTER JOIN (VALUES (30), (40)) t(d) + ON EXISTS (SELECT 1 WHERE s.c = 3 AND t.d = 30)) +ORDER BY ALL; +-- +ok +== +SELECT l.a, r.b, s.c, (SELECT coalesce(l.a, r.b, s.c)) AS first_value +FROM ((VALUES (1), (2)) l(a) +FULL OUTER JOIN (VALUES (10), (20)) r(b) + ON EXISTS (SELECT 1 WHERE l.a = 1 AND r.b = 10)) +FULL OUTER JOIN (VALUES (100), (200)) s(c) + ON EXISTS (SELECT 1 WHERE l.a = 1 AND s.c = 100) +ORDER BY ALL; +-- +ok +== +SELECT o.x, EXISTS ( + SELECT * + FROM (VALUES (1)) l(a) + WHERE o.x = ANY (SELECT r.b FROM (VALUES (10)) r(b)) +) AS ex +FROM (VALUES (10), (20)) o(x) +ORDER BY o.x; +-- +ok +== +SELECT q.cnt, x.v +FROM ( + SELECT count(*)::BIGINT AS cnt + FROM (VALUES (1), (2)) l(a) + FULL OUTER JOIN (VALUES (10), (20)) r(b) + ON EXISTS (SELECT 1 WHERE l.a = 1 AND r.b = 10) +) q +LEFT JOIN LATERAL (SELECT q.cnt + 1 AS v) x ON true; +-- +ok +== +SELECT q.a, q.b, q.rn, x.v +FROM ( + SELECT l.a, r.b, row_number() OVER (ORDER BY l.a NULLS LAST, r.b NULLS LAST) AS rn + FROM (VALUES (1), (2)) l(a) + FULL OUTER JOIN (VALUES (10), (20)) r(b) + ON EXISTS (SELECT 1 WHERE l.a = 1 AND r.b = 10) +) q +LEFT JOIN LATERAL (SELECT q.rn + coalesce(q.a, q.b) AS v) x ON true +ORDER BY q.rn; +-- +ok +== +SELECT q.a, q.b, x.v +FROM ( + SELECT l.a, r.b + FROM (VALUES (1), (2)) l(a) + FULL OUTER JOIN (VALUES (10), (20)) r(b) + ON EXISTS (SELECT 1 WHERE l.a = 1 AND r.b = 10) + UNION ALL + SELECT 9, 90 +) q +LEFT JOIN LATERAL (SELECT coalesce(q.a, 0) + coalesce(q.b, 0) AS v) x ON true +ORDER BY ALL; +-- +ok +== +SELECT o.x, EXISTS ( + SELECT * + FROM (VALUES (1)) l(a) + ANTI JOIN (VALUES (1)) r(b) + ON l.a = r.b AND o.x = 10 +) AS ex +FROM (VALUES (10), (20)) o(x) +ORDER BY o.x; +-- +ok +== +SELECT o.x +FROM (VALUES (10), (20)) o(x) +CROSS JOIN (VALUES (1)) l(a) +ANTI JOIN (VALUES (1)) r(b) + ON l.a = r.b AND o.x = 10 +ORDER BY o.x; +-- +ok +== +SELECT o.x, EXISTS ( + SELECT * + FROM (VALUES (1)) l(a) + ANTI JOIN (VALUES (2)) r(b) + ON l.a = r.b AND o.x = 10 +) AS ex +FROM (VALUES (10), (20)) o(x) +ORDER BY o.x; +-- +ok +== +SELECT o.x, EXISTS ( + SELECT * + FROM (VALUES (1)) l(a) + ANTI JOIN (VALUES (1), (1)) r(b) + ON l.a = r.b AND o.x = 10 +) AS ex +FROM (VALUES (10), (20)) o(x) +ORDER BY o.x; +-- +ok +== +SELECT o.x, EXISTS ( + SELECT * + FROM (VALUES (NULL::INTEGER)) l(a) + ANTI JOIN (VALUES (NULL::INTEGER)) r(b) + ON l.a IS NOT DISTINCT FROM r.b AND o.x = 10 +) AS ex +FROM (VALUES (10), (20)) o(x) +ORDER BY o.x; +-- +ok +== +SET debug_verify_column_bindings=true; +-- +ok +== +SELECT o.x, EXISTS ( + SELECT * + FROM (VALUES (1)) l(a) + SEMI JOIN (VALUES (1)) r(b) + ON l.a = r.b + o.x +) AS ex +FROM (VALUES (0), (1)) o(x) +ORDER BY o.x; +-- +ok +== +SELECT o.b, q.a, q.b +FROM (VALUES (1), (2)) o(b) +LEFT JOIN LATERAL ( + SELECT l.a, r.b + FROM LATERAL (SELECT b) l(a) + RIGHT JOIN (VALUES (1)) r(b) ON EXISTS ( + SELECT 1 WHERE l.a = r.b + ) +) q ON true +ORDER BY o.b; +-- +ok +== +SELECT * +FROM LATERAL (SELECT r.b) l(a) +RIGHT JOIN (VALUES (1)) r(b) ON EXISTS ( + SELECT 1 WHERE l.a = r.b +); +-- +ok +== +SELECT o.x, EXISTS ( + SELECT * + FROM (VALUES (1)) l(a) + ANTI JOIN (VALUES (1)) r(b) + ON l.a = r.b + o.x +) AS ex +FROM (VALUES (0), (1)) o(x) +ORDER BY o.x; +-- +ok +== +SELECT o.x, EXISTS ( + SELECT * + FROM (VALUES (1)) l(a) + LEFT JOIN (VALUES (1)) r(b) + ON l.a = r.b + o.x + WHERE r.b IS NOT NULL +) AS ex +FROM (VALUES (0), (1)) o(x) +ORDER BY o.x; +-- +ok +== +SET debug_verify_column_bindings=false; +-- +ok +== +SET delim_join_as_cte=true; +-- +ok +== +SET delim_join_as_cte=false; +-- +ok +== +WITH a(k, v) AS (VALUES (1, 10), (2, 20), (3, 30)), + p(flag) AS (VALUES (true), (false)), + b(k, v) AS (VALUES (1, 10), (2, 99), (4, 40)) +SELECT a.k, a.v, p.flag, b.k, b.v +FROM a +CROSS JOIN p +LEFT JOIN b ON b.k = a.k AND b.v = a.v AND p.flag +ORDER BY ALL; +-- +ok +== +WITH a(k, v) AS (VALUES (1, 10), (2, 20), (3, 30)), + b(k, v) AS (VALUES (1, 10), (2, 99)), + c(k, v) AS (VALUES (1, 15), (3, 35)), + d(k, v) AS (VALUES (3, 30), (2, 99)) +SELECT a.k, a.v, b.k, b.v +FROM a +LEFT JOIN b ON b.k = a.k AND b.v >= a.v AND a.v < 25 +SEMI JOIN c ON c.k = a.k AND (b.k IS NULL OR c.v > b.v) +ANTI JOIN d ON d.k = a.k AND (b.k IS NULL OR d.v = b.v) +ORDER BY ALL; +-- +ok +== +SET approximate_join_order_threshold={threshold}; +-- +error: Parser Error: syntax error at or near "}" +== +WITH a(k, v) AS (VALUES (1, 10), (2, 20), (3, 30)), + b(k, v) AS (VALUES (1, 10), (2, 99)), + c(k, v) AS (VALUES (1, 15), (3, 35)), + d(k, v) AS (VALUES (3, 30), (2, 99)), + e(x) AS (VALUES (7)), + f(y) AS (VALUES (8)) +SELECT a.k, a.v, b.k, b.v, e.x, f.y +FROM a +LEFT JOIN b ON b.k = a.k AND b.v >= a.v AND a.v < 25 +SEMI JOIN c ON c.k = a.k AND (b.k IS NULL OR c.v > b.v) +ANTI JOIN d ON d.k = a.k AND (b.k IS NULL OR d.v = b.v) +CROSS JOIN e +CROSS JOIN f +ORDER BY ALL; +-- +ok +== +PRAGMA disable_optimizer; +-- +ok +== diff --git a/parser/testdata/corpus/sql/join/non_inner_join_subquery.test b/parser/testdata/corpus/sql/join/non_inner_join_subquery.test new file mode 100644 index 0000000..f2b0d3d --- /dev/null +++ b/parser/testdata/corpus/sql/join/non_inner_join_subquery.test @@ -0,0 +1,112 @@ +# source: test/sql/join/non_inner_join_subquery.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +CREATE TABLE non_inner_l(i INTEGER, j INTEGER); +-- +ok +== +CREATE TABLE non_inner_r(i INTEGER, j INTEGER); +-- +ok +== +CREATE TABLE non_inner_s(i INTEGER, j INTEGER); +-- +ok +== +INSERT INTO non_inner_l VALUES (1, 10), (2, 20), (3, 30); +-- +ok +== +INSERT INTO non_inner_r VALUES (1, 100), (2, 200), (4, 400), (NULL, 999); +-- +ok +== +INSERT INTO non_inner_s VALUES (1, 10), (2, 20), (NULL, 99); +-- +ok +== +SELECT l.i, r.i +FROM non_inner_l l +LEFT JOIN non_inner_r r ON l.i IN (SELECT s.i FROM non_inner_s s WHERE s.i = l.i) +ORDER BY l.i, r.i NULLS LAST; +-- +ok +== +SELECT l.i, r.i +FROM non_inner_l l +LEFT JOIN non_inner_r r ON r.i IN (SELECT s.i FROM non_inner_s s WHERE s.i = r.i) +ORDER BY l.i, r.i NULLS LAST; +-- +ok +== +SELECT l.i, r.i +FROM non_inner_l l +LEFT JOIN non_inner_r r ON r.i = CASE + WHEN l.j >= 20 THEN (SELECT s.i FROM non_inner_s s WHERE s.i = l.i LIMIT 1) + ELSE NULL +END +ORDER BY l.i, r.i NULLS LAST; +-- +ok +== +SELECT l.i, r.i +FROM non_inner_l l +LEFT JOIN non_inner_r r ON l.i + (SELECT 1) = r.i + (SELECT 0) +ORDER BY l.i, r.i NULLS LAST; +-- +ok +== +SELECT l.i, r.i, r.j +FROM non_inner_l l +LEFT JOIN non_inner_r r ON r.i IS NULL OR (r.i = l.i AND l.i NOT IN (SELECT i FROM non_inner_s)) +ORDER BY l.i, r.i NULLS LAST, r.j NULLS LAST; +-- +ok +== +SELECT l.i, r.i, r.j, nested.i +FROM non_inner_l l +LEFT JOIN non_inner_r r ON EXISTS ( + SELECT 1 FROM non_inner_s s WHERE s.i = l.i AND s.j * 10 = r.j +) +LEFT JOIN non_inner_s nested ON FALSE +ORDER BY l.i, r.i NULLS LAST, r.j NULLS LAST; +-- +ok +== +SELECT l.i, r.i, r.j +FROM non_inner_l l +FULL OUTER JOIN non_inner_r r ON l.i = (SELECT MIN(i) FROM non_inner_s) +ORDER BY l.i, r.i NULLS LAST, r.j NULLS LAST; +-- +ok +== +SELECT l.i, r.i, r.j +FROM non_inner_l l +FULL OUTER JOIN non_inner_r r ON l.i IN (SELECT s.i FROM non_inner_s s WHERE s.i = l.i) +ORDER BY l.i NULLS LAST, r.i NULLS LAST, r.j NULLS LAST; +-- +ok +== +SELECT l.i, r.i, r.j +FROM non_inner_l l +FULL OUTER JOIN non_inner_r r ON r.i IN (SELECT s.i FROM non_inner_s s WHERE s.i = r.i) +ORDER BY l.i NULLS LAST, r.i NULLS LAST, r.j NULLS LAST; +-- +ok +== +SELECT l.i, r.i, r.j +FROM non_inner_l l +RIGHT JOIN non_inner_r r ON l.i IN (SELECT s.i FROM non_inner_s s WHERE s.i = l.i) +ORDER BY l.i NULLS LAST, r.i NULLS LAST, r.j NULLS LAST; +-- +ok +== +SELECT l.i, r.i, r.j +FROM non_inner_l l +RIGHT JOIN non_inner_r r ON r.i IN (SELECT s.i FROM non_inner_s s WHERE s.i = r.i) +ORDER BY l.i NULLS LAST, r.i NULLS LAST, r.j NULLS LAST; +-- +ok +== diff --git a/parser/testdata/corpus/sql/join/non_inner_join_subquery_binding.test b/parser/testdata/corpus/sql/join/non_inner_join_subquery_binding.test new file mode 100644 index 0000000..46522cc --- /dev/null +++ b/parser/testdata/corpus/sql/join/non_inner_join_subquery_binding.test @@ -0,0 +1,232 @@ +# source: test/sql/join/non_inner_join_subquery_binding.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +SELECT * +FROM (VALUES (1)) l(a) +LEFT JOIN (VALUES (2)) r(a) +ON EXISTS ( + SELECT 1 + WHERE a = l.a + AND r.a = 2 +); +-- +ok +== +SELECT * +FROM (VALUES (1)) l(a) +LEFT JOIN (VALUES (2)) r(a) +ON a = 1 +AND EXISTS ( + SELECT 1 + WHERE l.a = r.a +); +-- +ok +== +SELECT * +FROM (VALUES ('a')) l(v) +LEFT JOIN (VALUES ('A')) r(v) +ON EXISTS ( + SELECT 1 + WHERE lower(v) = l.v + AND r.v = 'A' +); +-- +ok +== +SELECT l.v, r.v +FROM (VALUES ('a')) l(v) +LEFT JOIN (VALUES ('A')) r(v) +ON EXISTS ( + SELECT 1 + WHERE l.v.lower() = 'a' + AND r.v.lower() = 'a' +); +-- +ok +== +SELECT * +FROM (VALUES (1, 1)) l(x, a) +LEFT JOIN (VALUES (2, 1)) r(x, b) +ON list_transform([1], lambda x: x)[1] = 1 +AND EXISTS ( + SELECT 1 + WHERE l.a = r.b +); +-- +ok +== +SELECT l.a, r.b +FROM (VALUES ({'v': 10}, 1)) l(x, a) +LEFT JOIN (VALUES ({'v': 20}, 1)) r(x, b) +ON list_transform([{'v': 1}], lambda x: x.v)[1] = 1 +AND EXISTS ( + SELECT 1 + WHERE l.a = r.b +); +-- +ok +== +CREATE MACRO join_extract(x) AS x.v; +-- +ok +== +SELECT * +FROM (VALUES (1, 1)) l(x, a) +LEFT JOIN (VALUES (2, 1)) r(x, b) +ON join_extract({'v': 1}) = 1 +AND EXISTS ( + SELECT 1 + WHERE l.a = r.b +); +-- +ok +== +SELECT * +FROM (VALUES (1, 1)) l(a, x) +LEFT JOIN (VALUES (2, 1)) r(b, y) +ON #1 = 1 +AND #3 = 2 +AND EXISTS ( + SELECT 1 + WHERE l.x = r.y +); +-- +ok +== +SELECT * +FROM (VALUES (1, 1)) l(a, x) +RIGHT JOIN (VALUES (2, 1)) r(b, y) +ON #1 = 1 +AND #3 = 2 +AND EXISTS ( + SELECT 1 + WHERE l.x = r.y +); +-- +ok +== +SELECT * +FROM (VALUES (1, 1)) l(a, x) +LEFT JOIN (VALUES (2, 1)) r(b, y) +ON #5 = 1 +AND EXISTS ( + SELECT 1 + WHERE l.x = r.y +); +-- +ok +== +SELECT * +FROM (VALUES ({'v': 1})) l(s) +LEFT JOIN (VALUES ({'v': 2})) r(s) +ON EXISTS ( + SELECT 1 + WHERE s.v = l.s.v + AND r.s.v = 2 +); +-- +ok +== +SELECT s.v, r.s.v +FROM (VALUES (1)) s(v) +LEFT JOIN (VALUES ({'v': 2})) r(s) +ON EXISTS ( + SELECT 1 + WHERE s.v = 1 + AND r.s.v = 2 +); +-- +ok +== +SELECT l.s.v, s.v +FROM (VALUES ({'v': 1})) l(s) +LEFT JOIN (VALUES (2)) s(v) +ON EXISTS ( + SELECT 1 + WHERE l.s.v = 1 + AND s.v = 2 +); +-- +ok +== +SELECT a.x, r.x +FROM ((VALUES (1)) a(x) JOIN (VALUES (1)) b(x) USING (x)) +LEFT JOIN (VALUES (1)) r(x) +ON EXISTS ( + SELECT 1 + WHERE x = r.x +); +-- +ok +== +SELECT l.x, a.x +FROM (VALUES (1)) l(x) +LEFT JOIN ((VALUES (1)) a(x) JOIN (VALUES (1)) b(x) USING (x)) +ON EXISTS ( + SELECT 1 + WHERE l.x = x +); +-- +ok +== +SELECT * +FROM ((VALUES (1)) a(x) JOIN (VALUES (1)) b(x) USING (x)) +LEFT JOIN ((VALUES (1)) c(x) JOIN (VALUES (1)) d(x) USING (x)) +ON EXISTS ( + SELECT 1 + WHERE x = 1 + AND a.x = c.x +); +-- +ok +== +CREATE TABLE update_target(i INTEGER); +-- +ok +== +INSERT INTO update_target VALUES (1), (2); +-- +ok +== +UPDATE update_target t +SET i = t.i + 10 +FROM (VALUES (1)) l(a) +FULL JOIN (VALUES (1)) r(b) + ON l.a = r.b + AND EXISTS ( + SELECT 1 + WHERE l.a = r.b +); +-- +ok +== +SELECT i FROM update_target ORDER BY i; +-- +ok +== +CREATE TABLE delete_target(i INTEGER); +-- +ok +== +INSERT INTO delete_target VALUES (1), (2); +-- +ok +== +DELETE FROM delete_target t +USING (VALUES (1)) l(a) +FULL JOIN (VALUES (1)) r(b) + ON l.a = r.b + AND EXISTS ( + SELECT 1 + WHERE l.a = r.b +); +-- +ok +== +SELECT count(*) FROM delete_target; +-- +ok +== diff --git a/parser/testdata/corpus/sql/join/pair_dependent_full_outer_join_subquery.test b/parser/testdata/corpus/sql/join/pair_dependent_full_outer_join_subquery.test new file mode 100644 index 0000000..171f7a6 --- /dev/null +++ b/parser/testdata/corpus/sql/join/pair_dependent_full_outer_join_subquery.test @@ -0,0 +1,751 @@ +# source: test/sql/join/pair_dependent_full_outer_join_subquery.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +CREATE TABLE pair_l(a INTEGER, x INTEGER); +-- +ok +== +CREATE TABLE pair_r(b INTEGER, y INTEGER); +-- +ok +== +CREATE TABLE pair_s(a INTEGER, b INTEGER); +-- +ok +== +INSERT INTO pair_l VALUES (1, 10), (1, 11), (2, 20), (3, 30); +-- +ok +== +INSERT INTO pair_r VALUES (10, 100), (20, 200), (30, 300), (40, 400); +-- +ok +== +INSERT INTO pair_s VALUES (1, 10), (1, 20), (2, 20), (NULL, 30), (3, NULL); +-- +ok +== +SELECT l.a, r.b +FROM pair_l l +FULL OUTER JOIN pair_r r ON EXISTS ( + SELECT 1 FROM pair_s s WHERE s.a = l.a AND s.b = r.b +) +ORDER BY l.a NULLS LAST, r.b NULLS LAST; +-- +ok +== +SELECT l.a, r.b +FROM pair_l l +FULL OUTER JOIN pair_r r ON r.b IN ( + SELECT s.b FROM pair_s s WHERE s.a = l.a +) +ORDER BY l.a NULLS LAST, r.b NULLS LAST; +-- +ok +== +SELECT l.a, r.b +FROM pair_l l +FULL OUTER JOIN pair_r r ON r.b = ANY ( + SELECT s.b FROM pair_s s WHERE s.a = l.a +) +ORDER BY l.a NULLS LAST, r.b NULLS LAST; +-- +ok +== +SELECT l.a, r.b +FROM pair_l l +FULL OUTER JOIN pair_r r ON r.b <> ALL ( + SELECT s.b FROM pair_s s WHERE s.a = l.a +) +ORDER BY l.a NULLS LAST, r.b NULLS LAST; +-- +ok +== +SELECT l.a, r.b +FROM pair_l l +FULL OUTER JOIN pair_r r ON NOT EXISTS ( + SELECT 1 FROM pair_s s WHERE s.a = l.a AND s.b = r.b +) +ORDER BY l.a NULLS LAST, r.b NULLS LAST; +-- +ok +== +CREATE TABLE pair_nested_l(a INTEGER); +-- +ok +== +CREATE TABLE pair_nested_r(b INTEGER); +-- +ok +== +CREATE TABLE pair_nested_s(a INTEGER, b INTEGER); +-- +ok +== +INSERT INTO pair_nested_l VALUES (1), (2), (3); +-- +ok +== +INSERT INTO pair_nested_r VALUES (10), (20), (30); +-- +ok +== +INSERT INTO pair_nested_s VALUES (1, 10), (2, 20); +-- +ok +== +SELECT l.a, r.b +FROM pair_nested_l l +FULL OUTER JOIN pair_nested_r r ON EXISTS ( + SELECT 1 WHERE EXISTS ( + SELECT 1 FROM pair_nested_s s WHERE s.a = l.a AND s.b = r.b + ) +) +ORDER BY ALL; +-- +ok +== +CREATE SEQUENCE pair_full_volatile_seq START 1; +-- +ok +== +SELECT count(*), currval('pair_full_volatile_seq') +FROM (VALUES (1, 1), (2, 1)) l(lid, a) +FULL OUTER JOIN (VALUES (10, 1), (20, 1)) r(rid, b) ON EXISTS ( + SELECT 1 + WHERE l.a = r.b + AND nextval('pair_full_volatile_seq') > 100 +); +-- +ok +== +SELECT l.a, r.b +FROM pair_nested_l l +FULL OUTER JOIN pair_nested_r r ON EXISTS ( + WITH c AS ( + SELECT s.b + FROM pair_nested_s s + WHERE s.a = l.a + ) + SELECT 1 + FROM c + WHERE c.b = r.b +) +ORDER BY ALL; +-- +ok +== +CREATE TABLE pair_split_l(a INTEGER); +-- +ok +== +CREATE TABLE pair_split_r(b INTEGER); +-- +ok +== +INSERT INTO pair_split_l VALUES (1), (2); +-- +ok +== +INSERT INTO pair_split_r VALUES (10), (20); +-- +ok +== +SELECT l.a, r.b +FROM pair_nested_l l +FULL OUTER JOIN pair_nested_r r ON EXISTS ( + SELECT 1 + WHERE EXISTS ( + SELECT 1 FROM pair_split_l sl WHERE sl.a = l.a + ) + AND EXISTS ( + SELECT 1 FROM pair_split_r sr WHERE sr.b = r.b + ) +) +ORDER BY l.a NULLS LAST, r.b NULLS LAST; +-- +ok +== +SELECT l.a, r.b +FROM pair_nested_l l +FULL OUTER JOIN pair_nested_r r ON EXISTS ( + SELECT 1 + WHERE EXISTS ( + SELECT 1 FROM pair_split_l sl WHERE sl.a = l.a + ) + OR EXISTS ( + SELECT 1 FROM pair_split_r sr WHERE sr.b = r.b + ) +) +ORDER BY l.a NULLS LAST, r.b NULLS LAST; +-- +ok +== +CREATE TABLE pair_nested_local_t(c INTEGER); +-- +ok +== +CREATE TABLE pair_nested_local_s(a INTEGER, b INTEGER, c INTEGER); +-- +ok +== +INSERT INTO pair_nested_local_t VALUES (5); +-- +ok +== +INSERT INTO pair_nested_local_s VALUES (1, 10, 5), (2, 20, 5); +-- +ok +== +SELECT l.a, r.b +FROM pair_nested_l l +FULL OUTER JOIN pair_nested_r r ON EXISTS ( + SELECT 1 + FROM pair_nested_local_t t + WHERE EXISTS ( + SELECT 1 + FROM pair_nested_local_s s + WHERE s.a = l.a + AND s.b = r.b + AND s.c = t.c + ) +) +ORDER BY ALL; +-- +ok +== +SELECT l.a, r.b +FROM pair_nested_l l +FULL OUTER JOIN pair_nested_r r ON EXISTS ( + SELECT 1 + FROM pair_nested_local_t t + WHERE EXISTS ( + SELECT 1 + WHERE EXISTS ( + SELECT 1 + FROM pair_nested_local_s s + WHERE s.a = l.a + AND s.b = r.b + AND s.c = t.c + ) + ) +) +ORDER BY ALL; +-- +ok +== +CREATE TABLE pair_nested_outer_o(x INTEGER); +-- +ok +== +INSERT INTO pair_nested_outer_o VALUES (5); +-- +ok +== +SELECT * +FROM pair_nested_outer_o o +WHERE EXISTS ( + SELECT 1 + FROM pair_nested_l l + FULL OUTER JOIN pair_nested_r r ON EXISTS ( + SELECT 1 + FROM pair_nested_local_s s + WHERE s.a = l.a + AND s.b = r.b + AND s.c = o.x + ) +); +-- +ok +== +SELECT * +FROM pair_nested_outer_o o +WHERE EXISTS ( + SELECT 1 + FROM pair_nested_l l + FULL OUTER JOIN pair_nested_r r ON EXISTS ( + SELECT 1 + FROM pair_nested_local_t t + WHERE EXISTS ( + SELECT 1 + FROM pair_nested_local_s s + WHERE s.a = l.a + AND s.b = r.b + AND s.c = t.c + AND s.c = o.x + ) + ) +); +-- +ok +== +CREATE TABLE pair_decor_l(a INTEGER); +-- +ok +== +CREATE TABLE pair_decor_r(b INTEGER); +-- +ok +== +CREATE TABLE pair_decor_s(a INTEGER, b INTEGER); +-- +ok +== +INSERT INTO pair_decor_l VALUES (1), (2), (3); +-- +ok +== +INSERT INTO pair_decor_r VALUES (10), (20), (30); +-- +ok +== +INSERT INTO pair_decor_s VALUES (1, 20), (1, 10), (2, 20); +-- +ok +== +SELECT l.a, r.b +FROM pair_decor_l l +FULL OUTER JOIN pair_decor_r r ON EXISTS ( + SELECT 1 + FROM ( + SELECT s.b + FROM pair_decor_s s + WHERE s.a = l.a + ORDER BY s.b + LIMIT 1 + ) q + WHERE q.b = r.b +) +ORDER BY ALL; +-- +ok +== +SELECT l.a, r.b +FROM pair_decor_l l +FULL OUTER JOIN pair_decor_r r ON EXISTS ( + SELECT s.a + FROM pair_decor_s s + WHERE s.a = l.a + AND s.b = r.b + GROUP BY s.a + HAVING count(*) > 0 +) +ORDER BY ALL; +-- +ok +== +SELECT l.a, r.b +FROM pair_decor_l l +FULL OUTER JOIN pair_decor_r r ON EXISTS ( + SELECT 1 + FROM ( + SELECT s.b, row_number() OVER (PARTITION BY s.a ORDER BY s.b) rn + FROM pair_decor_s s + WHERE s.a = l.a + ) q + WHERE q.b = r.b + AND q.rn = 1 +) +ORDER BY ALL; +-- +ok +== +CREATE TABLE pair_nested_full_l(a INTEGER); +-- +ok +== +CREATE TABLE pair_nested_full_m(b INTEGER); +-- +ok +== +CREATE TABLE pair_nested_full_r(c INTEGER); +-- +ok +== +CREATE TABLE pair_nested_full_s1(a INTEGER, b INTEGER); +-- +ok +== +CREATE TABLE pair_nested_full_s2(a INTEGER, c INTEGER); +-- +ok +== +INSERT INTO pair_nested_full_l VALUES (1), (2); +-- +ok +== +INSERT INTO pair_nested_full_m VALUES (10), (20); +-- +ok +== +INSERT INTO pair_nested_full_r VALUES (100), (200); +-- +ok +== +INSERT INTO pair_nested_full_s1 VALUES (1, 10); +-- +ok +== +INSERT INTO pair_nested_full_s2 VALUES (1, 100), (2, 200); +-- +ok +== +SELECT l.a, m.b, r.c +FROM pair_nested_full_l l +FULL OUTER JOIN pair_nested_full_m m ON EXISTS ( + SELECT 1 + FROM pair_nested_full_s1 s + WHERE s.a = l.a + AND s.b = m.b +) +FULL OUTER JOIN pair_nested_full_r r ON EXISTS ( + SELECT 1 + FROM pair_nested_full_s2 s + WHERE s.a = l.a + AND s.c = r.c +) +ORDER BY ALL; +-- +ok +== +SELECT l.a, l.x, r.b, r.y, count(*)::INTEGER +FROM pair_l l +FULL OUTER JOIN pair_r r ON EXISTS ( + SELECT 1 FROM pair_s s WHERE s.a = l.a AND s.b = r.b +) +GROUP BY ALL +ORDER BY ALL; +-- +ok +== +SELECT l.a, l.x, r.b, r.y, count(*)::INTEGER +FROM pair_l l +FULL OUTER JOIN pair_r r ON r.b = ( + SELECT max(s.b) FROM pair_s s WHERE s.a = l.a AND s.b <= r.b +) +GROUP BY ALL +ORDER BY ALL; +-- +ok +== +SELECT l.a, l.x, r.b, r.y, count(*)::INTEGER +FROM pair_l l +FULL OUTER JOIN pair_r r ON l.x > 10 AND r.b IN ( + SELECT s.b FROM pair_s s WHERE s.a = l.a +) +GROUP BY ALL +ORDER BY ALL; +-- +ok +== +SELECT l.a, l.x, r.b, r.y, count(*)::INTEGER +FROM pair_l l +FULL OUTER JOIN pair_r r ON r.b NOT IN ( + SELECT s.b FROM pair_s s WHERE s.a = l.a +) +GROUP BY ALL +ORDER BY ALL; +-- +ok +== +CREATE TABLE pair_dup_l(a INTEGER, x INTEGER); +-- +ok +== +CREATE TABLE pair_dup_r(b INTEGER, y INTEGER); +-- +ok +== +CREATE TABLE pair_dup_s(a INTEGER, b INTEGER); +-- +ok +== +INSERT INTO pair_dup_l VALUES (1, 10), (1, 10), (1, 11); +-- +ok +== +INSERT INTO pair_dup_r VALUES (10, 100), (10, 100), (20, 200), (30, 300); +-- +ok +== +INSERT INTO pair_dup_s VALUES (1, 10), (1, 10), (1, 20); +-- +ok +== +SELECT l.a, l.x, r.b, r.y, count(*)::INTEGER +FROM pair_dup_l l +FULL OUTER JOIN pair_dup_r r ON EXISTS ( + SELECT 1 FROM pair_dup_s s WHERE s.a = l.a AND s.b = r.b +) +GROUP BY ALL +ORDER BY ALL; +-- +ok +== +PRAGMA enable_optimizer; +-- +ok +== +CREATE TABLE pair_l_order(a INTEGER, x INTEGER); +-- +ok +== +CREATE TABLE pair_r_order(b INTEGER, y INTEGER); +-- +ok +== +CREATE TABLE pair_s_order(x INTEGER, b INTEGER); +-- +ok +== +INSERT INTO pair_l_order VALUES (1, 10), (2, 20); +-- +ok +== +INSERT INTO pair_r_order VALUES (10, 100), (20, 200), (30, 300); +-- +ok +== +INSERT INTO pair_s_order VALUES (10, 10), (20, 20); +-- +ok +== +SELECT l.a, l.x, r.b, r.y +FROM pair_l_order l +FULL OUTER JOIN pair_r_order r ON EXISTS ( + SELECT 1 FROM pair_s_order s WHERE s.x = l.x AND s.b = r.b +) +ORDER BY ALL; +-- +ok +== +CREATE TABLE pair_s_null(a INTEGER, b INTEGER); +-- +ok +== +INSERT INTO pair_s_null VALUES (1, 10), (1, 20), (1, NULL); +-- +ok +== +SELECT l.a, l.x, r.b, r.y, count(*)::INTEGER +FROM pair_dup_l l +FULL OUTER JOIN pair_dup_r r ON r.b NOT IN ( + SELECT s.b FROM pair_s_null s WHERE s.a = l.a +) +GROUP BY ALL +ORDER BY ALL; +-- +ok +== +CREATE TABLE pair_rowid_l(a INTEGER); +-- +ok +== +CREATE TABLE pair_rowid_r(b INTEGER); +-- +ok +== +CREATE TABLE pair_rowid_s(a INTEGER, b INTEGER); +-- +ok +== +INSERT INTO pair_rowid_l VALUES (1), (2); +-- +ok +== +INSERT INTO pair_rowid_r VALUES (10), (20); +-- +ok +== +INSERT INTO pair_rowid_s VALUES (1, 10); +-- +ok +== +SELECT l.rowid, l.a, r.rowid, r.b +FROM pair_rowid_l l +FULL OUTER JOIN pair_rowid_r r ON EXISTS ( + SELECT 1 FROM pair_rowid_s s WHERE s.a = l.a AND s.b = r.b +) +ORDER BY ALL; +-- +ok +== +CREATE TABLE pair_rowid_match_s(lrid BIGINT, rrid BIGINT); +-- +ok +== +INSERT INTO pair_rowid_match_s VALUES (0, 0); +-- +ok +== +SELECT l.rowid, l.a, r.rowid, r.b +FROM pair_rowid_l l +FULL OUTER JOIN pair_rowid_r r ON EXISTS ( + SELECT 1 + FROM pair_rowid_match_s s + WHERE s.lrid = l.rowid + AND s.rrid = r.rowid +) +ORDER BY ALL; +-- +ok +== +CREATE TABLE pair_generated_l(a INTEGER, x INTEGER GENERATED ALWAYS AS (a + 1)); +-- +ok +== +CREATE TABLE pair_generated_r(b INTEGER, y INTEGER); +-- +ok +== +CREATE TABLE pair_generated_s(a INTEGER, b INTEGER); +-- +ok +== +INSERT INTO pair_generated_l(a) VALUES (1), (2); +-- +ok +== +INSERT INTO pair_generated_r VALUES (10, 100), (20, 200), (30, 300); +-- +ok +== +INSERT INTO pair_generated_s VALUES (1, 10), (2, 20); +-- +ok +== +SELECT l.a, l.x, r.b, r.y +FROM pair_generated_l l +FULL OUTER JOIN pair_generated_r r ON EXISTS ( + SELECT 1 FROM pair_generated_s s WHERE s.a = l.a AND s.b = r.b +) +ORDER BY ALL; +-- +ok +== +CREATE TABLE pair_generated_match_s(x INTEGER, b INTEGER); +-- +ok +== +INSERT INTO pair_generated_match_s VALUES (2, 10), (3, 20); +-- +ok +== +SELECT l.a, l.x, r.b +FROM pair_generated_l l +FULL OUTER JOIN pair_generated_r r ON EXISTS ( + SELECT 1 + FROM pair_generated_match_s s + WHERE s.x = l.x + AND s.b = r.b +) +ORDER BY ALL; +-- +ok +== +SELECT l.a, l.x, r.b, r.y +FROM (SELECT * FROM pair_l WHERE x >= 10) l +FULL OUTER JOIN (SELECT * FROM pair_r WHERE y >= 100) r ON EXISTS ( + SELECT 1 FROM pair_s s WHERE s.a = l.a AND s.b = r.b +) +ORDER BY ALL; +-- +ok +== +CREATE TABLE pair_sparse_l(x INTEGER, a INTEGER); +-- +ok +== +CREATE TABLE pair_sparse_r(y INTEGER, b INTEGER); +-- +ok +== +CREATE TABLE pair_sparse_s(a INTEGER, b INTEGER); +-- +ok +== +INSERT INTO pair_sparse_l VALUES (100, 1), (200, 2), (300, 3); +-- +ok +== +INSERT INTO pair_sparse_r VALUES (1000, 10), (2000, 20), (3000, 30); +-- +ok +== +INSERT INTO pair_sparse_s VALUES (1, 10), (2, 20); +-- +ok +== +SELECT l.a, r.b +FROM (SELECT a FROM pair_sparse_l) l +FULL OUTER JOIN (SELECT b FROM pair_sparse_r) r ON EXISTS ( + SELECT 1 + FROM pair_sparse_s s + WHERE s.a = l.a + AND s.b = r.b +) +ORDER BY l.a NULLS LAST, r.b NULLS LAST; +-- +ok +== +SELECT l.a, r.b +FROM pair_l l +FULL OUTER JOIN pair_r r ON EXISTS ( + SELECT 1 FROM pair_s s WHERE s.a = l.a AND s.b = r.b +) AND random() >= 0 +ORDER BY l.a NULLS LAST, r.b NULLS LAST; +-- +ok +== +SELECT l.a, r.b +FROM pair_l l +FULL OUTER JOIN pair_r r ON EXISTS ( + SELECT 1 FROM pair_s s WHERE s.a = l.a AND s.b = r.b AND random() >= 0 +) +ORDER BY l.a NULLS LAST, r.b NULLS LAST; +-- +ok +== +SELECT 'semi' AS j, l.a, l.x +FROM pair_l l +SEMI JOIN pair_r r ON EXISTS ( + SELECT 1 + FROM pair_s s + WHERE s.a = l.a + AND s.b = r.b + AND random() >= 0 +) +UNION ALL +SELECT 'anti' AS j, l.a, l.x +FROM pair_l l +ANTI JOIN pair_r r ON EXISTS ( + SELECT 1 + FROM pair_s s + WHERE s.a = l.a + AND s.b = r.b + AND random() >= 0 +) +ORDER BY j, l.a, l.x; +-- +ok +== +SELECT l.a, r.b +FROM pair_nested_l l +FULL OUTER JOIN pair_nested_r r ON EXISTS ( + SELECT 1 + FROM pair_nested_local_t t + WHERE EXISTS ( + SELECT 1 + FROM pair_nested_local_s s + WHERE s.a = l.a + AND s.b = r.b + AND s.c = t.c + AND random() >= 0 + ) +) +ORDER BY ALL; +-- +ok +== diff --git a/parser/testdata/corpus/sql/join/pair_dependent_full_outer_join_subquery_bindings.test b/parser/testdata/corpus/sql/join/pair_dependent_full_outer_join_subquery_bindings.test new file mode 100644 index 0000000..c80081b --- /dev/null +++ b/parser/testdata/corpus/sql/join/pair_dependent_full_outer_join_subquery_bindings.test @@ -0,0 +1,721 @@ +# source: test/sql/join/pair_dependent_full_outer_join_subquery_bindings.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +CREATE TABLE pair_multi_l(a INTEGER); +-- +ok +== +CREATE TABLE pair_multi_l2(c INTEGER); +-- +ok +== +CREATE TABLE pair_multi_r(b INTEGER); +-- +ok +== +CREATE TABLE pair_multi_s(a INTEGER, b INTEGER, c INTEGER); +-- +ok +== +INSERT INTO pair_multi_l VALUES (1), (2); +-- +ok +== +INSERT INTO pair_multi_l2 VALUES (5); +-- +ok +== +INSERT INTO pair_multi_r VALUES (10), (20), (30); +-- +ok +== +INSERT INTO pair_multi_s VALUES (1, 10, 5), (2, 20, 5); +-- +ok +== +SELECT l.a, l2.c, r.b +FROM pair_multi_l l +JOIN pair_multi_l2 l2 ON true +FULL OUTER JOIN pair_multi_r r ON EXISTS ( + SELECT 1 + FROM pair_multi_s s + WHERE s.a = l.a + AND s.b = r.b + AND s.c = l2.c +) +ORDER BY ALL; +-- +ok +== +SELECT * +FROM pair_multi_l l +JOIN pair_multi_l2 l2 ON true +FULL OUTER JOIN pair_multi_r r ON EXISTS ( + SELECT 1 + FROM pair_multi_s s + WHERE s.a = l.a + AND s.b = r.b + AND s.c = l2.c +) +ORDER BY ALL; +-- +ok +== +SET disabled_optimizers='projection_pullup'; +-- +ok +== +SELECT l.a, r.b, r2.c +FROM pair_multi_l l +FULL OUTER JOIN ( + pair_multi_r r + JOIN pair_multi_l2 r2 ON true +) ON EXISTS ( + SELECT 1 + FROM pair_multi_s s + WHERE s.a = l.a + AND s.b = r.b + AND s.c = r2.c +) +ORDER BY ALL; +-- +ok +== +SELECT l.a, l2.c, r.b, r2.c +FROM pair_multi_l l +JOIN pair_multi_l2 l2 ON true +FULL OUTER JOIN ( + pair_multi_r r + JOIN pair_multi_l2 r2 ON true +) ON EXISTS ( + SELECT 1 + FROM pair_multi_s s + WHERE s.a = l.a + AND s.b = r.b + AND s.c = l2.c + AND s.c = r2.c +) +ORDER BY ALL; +-- +ok +== +CREATE TABLE pair_multi_quant_s(a INTEGER, b INTEGER, c INTEGER); +-- +ok +== +INSERT INTO pair_multi_quant_s VALUES (1, 10, 5), (1, NULL, 5), (2, 20, 5); +-- +ok +== +SELECT l.a, l2.c, r.b +FROM pair_multi_l l +JOIN pair_multi_l2 l2 ON true +FULL OUTER JOIN pair_multi_r r ON r.b NOT IN ( + SELECT s.b + FROM pair_multi_quant_s s + WHERE s.a = l.a + AND s.c = l2.c +) +ORDER BY ALL; +-- +ok +== +CREATE TABLE pair_multi_l3(d INTEGER); +-- +ok +== +CREATE TABLE pair_multi_s3(a INTEGER, b INTEGER, c INTEGER, d INTEGER); +-- +ok +== +INSERT INTO pair_multi_l3 VALUES (7); +-- +ok +== +INSERT INTO pair_multi_s3 VALUES (1, 10, 5, 7), (2, 20, 5, 7); +-- +ok +== +SELECT l.a, l2.c, l3.d, r.b +FROM pair_multi_l l +JOIN pair_multi_l2 l2 ON true +JOIN pair_multi_l3 l3 ON true +FULL OUTER JOIN pair_multi_r r ON EXISTS ( + SELECT 1 + FROM pair_multi_s3 s + WHERE s.a = l.a + AND s.b = r.b + AND s.c = l2.c + AND s.d = l3.d +) +ORDER BY ALL; +-- +ok +== +SELECT l.a, r.b +FROM ( + SELECT a FROM pair_multi_l WHERE a = 1 + UNION ALL + SELECT a FROM pair_multi_l WHERE a = 2 +) l +FULL OUTER JOIN ( + SELECT b FROM pair_multi_r WHERE b <= 20 + UNION ALL + SELECT b FROM pair_multi_r WHERE b = 30 +) r ON EXISTS ( + SELECT 1 + FROM pair_multi_s s + WHERE s.a = l.a + AND s.b = r.b +) +ORDER BY ALL; +-- +ok +== +CREATE TABLE pair_complex_l(a INTEGER, tags INTEGER[], st STRUCT(v INTEGER)); +-- +ok +== +CREATE TABLE pair_complex_r(b INTEGER, m MAP(INTEGER, INTEGER)); +-- +ok +== +CREATE TABLE pair_complex_s(a INTEGER, b INTEGER); +-- +ok +== +INSERT INTO pair_complex_l VALUES (1, [1, 2], {'v': 10}), (2, [2, 3], {'v': 20}), (3, [3, 4], {'v': 30}); +-- +ok +== +INSERT INTO pair_complex_r VALUES (10, map([1], [10])), (20, map([2], [20])), (30, map([3], [30])); +-- +ok +== +INSERT INTO pair_complex_s VALUES (1, 10), (2, 20); +-- +ok +== +SELECT l.a, r.b +FROM pair_complex_l l +FULL OUTER JOIN pair_complex_r r ON EXISTS ( + SELECT 1 + FROM pair_complex_s s + WHERE s.a = l.a + AND s.b = r.b +) +ORDER BY l.a NULLS LAST, r.b NULLS LAST; +-- +ok +== +SELECT l.a, l.tags::VARCHAR, l.st::VARCHAR, r.b, r.m::VARCHAR +FROM pair_complex_l l +FULL OUTER JOIN pair_complex_r r ON EXISTS ( + SELECT 1 + FROM pair_complex_s s + WHERE s.a = l.a + AND s.b = r.b +) +ORDER BY l.a NULLS LAST, r.b NULLS LAST; +-- +ok +== +SELECT l.a, r.b +FROM (VALUES (1), (2)) l(a) +FULL OUTER JOIN range(10, 40, 10) r(b) ON EXISTS ( + SELECT 1 + FROM pair_multi_s s + WHERE s.a = l.a + AND s.b = r.b +) +ORDER BY ALL; +-- +ok +== +CREATE TABLE pair_using_l(k INTEGER, a INTEGER); +-- +ok +== +CREATE TABLE pair_using_l2(k INTEGER, c INTEGER); +-- +ok +== +CREATE TABLE pair_using_s(a INTEGER, b INTEGER, c INTEGER); +-- +ok +== +INSERT INTO pair_using_l VALUES (1, 1), (2, 2); +-- +ok +== +INSERT INTO pair_using_l2 VALUES (1, 5), (2, 6); +-- +ok +== +INSERT INTO pair_using_s VALUES (1, 10, 5), (2, 20, 6); +-- +ok +== +SELECT l.a, l.c, r.b +FROM (pair_using_l JOIN pair_using_l2 USING (k)) l +FULL OUTER JOIN pair_multi_r r ON EXISTS ( + SELECT 1 + FROM pair_using_s s + WHERE s.a = l.a + AND s.b = r.b + AND s.c = l.c +) +ORDER BY ALL; +-- +ok +== +CREATE TABLE pair_multi_agg_s(a INTEGER, b INTEGER, cnt BIGINT); +-- +ok +== +INSERT INTO pair_multi_agg_s VALUES (1, 10, 1), (2, 20, 1); +-- +ok +== +SELECT l.a, l.cnt, r.b +FROM (SELECT a, count(*) AS cnt FROM pair_multi_l GROUP BY a) l +FULL OUTER JOIN pair_multi_r r ON EXISTS ( + SELECT 1 + FROM pair_multi_agg_s s + WHERE s.a = l.a + AND s.b = r.b + AND s.cnt = l.cnt +) +ORDER BY ALL; +-- +ok +== +CREATE TABLE pair_multi_window_s(a INTEGER, b INTEGER, rn BIGINT); +-- +ok +== +INSERT INTO pair_multi_window_s VALUES (1, 10, 1), (2, 20, 2); +-- +ok +== +SELECT l.a, l.rn, r.b +FROM (SELECT a, row_number() OVER (ORDER BY a) AS rn FROM pair_multi_l) l +FULL OUTER JOIN pair_multi_r r ON EXISTS ( + SELECT 1 + FROM pair_multi_window_s s + WHERE s.a = l.a + AND s.b = r.b + AND s.rn = l.rn +) +ORDER BY ALL; +-- +ok +== +CREATE TABLE pair_null_l(a INTEGER); +-- +ok +== +CREATE TABLE pair_null_r(b INTEGER); +-- +ok +== +CREATE TABLE pair_null_s(a INTEGER, b INTEGER); +-- +ok +== +INSERT INTO pair_null_l VALUES (NULL), (1), (2); +-- +ok +== +INSERT INTO pair_null_r VALUES (NULL), (10), (20); +-- +ok +== +INSERT INTO pair_null_s VALUES (NULL, NULL), (1, 10); +-- +ok +== +SELECT l.a, r.b +FROM pair_null_l l +FULL OUTER JOIN pair_null_r r ON EXISTS ( + SELECT 1 + FROM pair_null_s s + WHERE s.a IS NOT DISTINCT FROM l.a + AND s.b IS NOT DISTINCT FROM r.b +) +ORDER BY ALL; +-- +ok +== +CREATE TABLE pair_empty_l(a INTEGER); +-- +ok +== +CREATE TABLE pair_empty_r(b INTEGER); +-- +ok +== +CREATE TABLE pair_empty_s(a INTEGER, b INTEGER); +-- +ok +== +INSERT INTO pair_empty_l VALUES (1), (2); +-- +ok +== +INSERT INTO pair_empty_s VALUES (1, 10); +-- +ok +== +SELECT l.a, r.b +FROM pair_empty_l l +FULL OUTER JOIN pair_empty_r r ON EXISTS ( + SELECT 1 + FROM pair_empty_s s + WHERE s.a = l.a + AND s.b = r.b +) +ORDER BY ALL; +-- +ok +== +INSERT INTO pair_empty_r VALUES (10), (20); +-- +ok +== +DELETE FROM pair_empty_l; +-- +ok +== +CREATE TABLE pair_multi_dup_l(a INTEGER); +-- +ok +== +CREATE TABLE pair_multi_dup_l2(c INTEGER); +-- +ok +== +CREATE TABLE pair_multi_dup_r(b INTEGER); +-- +ok +== +CREATE TABLE pair_multi_dup_s(a INTEGER, b INTEGER, c INTEGER); +-- +ok +== +INSERT INTO pair_multi_dup_l VALUES (1), (1); +-- +ok +== +INSERT INTO pair_multi_dup_l2 VALUES (5); +-- +ok +== +INSERT INTO pair_multi_dup_r VALUES (10), (10), (20); +-- +ok +== +INSERT INTO pair_multi_dup_s VALUES (1, 10, 5); +-- +ok +== +SELECT l.a, l2.c, r.b, count(*)::INTEGER +FROM pair_multi_dup_l l +JOIN pair_multi_dup_l2 l2 ON true +FULL OUTER JOIN pair_multi_dup_r r ON EXISTS ( + SELECT 1 + FROM pair_multi_dup_s s + WHERE s.a = l.a + AND s.b = r.b + AND s.c = l2.c +) +GROUP BY ALL +ORDER BY ALL; +-- +ok +== +CREATE TABLE pair_dup_unmatched_l(a INTEGER); +-- +ok +== +CREATE TABLE pair_dup_unmatched_r(b INTEGER); +-- +ok +== +CREATE TABLE pair_dup_unmatched_s(a INTEGER, b INTEGER); +-- +ok +== +INSERT INTO pair_dup_unmatched_l VALUES (1), (1), (2); +-- +ok +== +INSERT INTO pair_dup_unmatched_r VALUES (10), (20), (20); +-- +ok +== +INSERT INTO pair_dup_unmatched_s VALUES (1, 10); +-- +ok +== +SELECT l.a, r.b, count(*)::INTEGER +FROM pair_dup_unmatched_l l +FULL OUTER JOIN pair_dup_unmatched_r r ON EXISTS ( + SELECT 1 + FROM pair_dup_unmatched_s s + WHERE s.a = l.a + AND s.b = r.b +) +GROUP BY ALL +ORDER BY ALL; +-- +ok +== +CREATE TABLE pair_null_dup_l(a INTEGER); +-- +ok +== +CREATE TABLE pair_null_dup_r(b INTEGER); +-- +ok +== +CREATE TABLE pair_null_dup_s(a INTEGER, b INTEGER); +-- +ok +== +INSERT INTO pair_null_dup_l VALUES (NULL), (NULL), (1); +-- +ok +== +INSERT INTO pair_null_dup_r VALUES (NULL), (10); +-- +ok +== +INSERT INTO pair_null_dup_s VALUES (NULL, NULL); +-- +ok +== +SELECT l.a, r.b, count(*)::INTEGER +FROM pair_null_dup_l l +FULL OUTER JOIN pair_null_dup_r r ON EXISTS ( + SELECT 1 + FROM pair_null_dup_s s + WHERE s.a IS NOT DISTINCT FROM l.a + AND s.b IS NOT DISTINCT FROM r.b +) +GROUP BY ALL +ORDER BY ALL; +-- +ok +== +CREATE TABLE pair_multi_both_l(id INTEGER, a INTEGER); +-- +ok +== +CREATE TABLE pair_multi_both_l2(lid INTEGER, z INTEGER); +-- +ok +== +CREATE TABLE pair_multi_both_r(id INTEGER, b INTEGER); +-- +ok +== +CREATE TABLE pair_multi_both_r2(rid INTEGER, w INTEGER); +-- +ok +== +CREATE TABLE pair_multi_both_s(a INTEGER, b INTEGER, z INTEGER, w INTEGER); +-- +ok +== +INSERT INTO pair_multi_both_l VALUES (1, 1), (2, 1), (3, 2), (4, NULL); +-- +ok +== +INSERT INTO pair_multi_both_l2 VALUES (1, 5), (2, 5), (3, 6), (4, 7); +-- +ok +== +INSERT INTO pair_multi_both_r VALUES (10, 10), (11, 10), (12, 20), (13, NULL); +-- +ok +== +INSERT INTO pair_multi_both_r2 VALUES (10, 50), (11, 50), (12, 60), (13, 70); +-- +ok +== +INSERT INTO pair_multi_both_s VALUES (1, 10, 5, 50), (2, 20, 6, 60), (NULL, NULL, 7, 70), (1, 20, 5, 60); +-- +ok +== +WITH left_side AS ( + SELECT l.id AS lid, l.a, l2.z + FROM pair_multi_both_l l + JOIN pair_multi_both_l2 l2 ON l.id = l2.lid +), right_side AS ( + SELECT r.id AS rid, r.b, r2.w + FROM pair_multi_both_r r + JOIN pair_multi_both_r2 r2 ON r.id = r2.rid +), actual AS ( + SELECT l.id AS lid, l.a, l2.z, r.id AS rid, r.b, r2.w + FROM pair_multi_both_l l + JOIN pair_multi_both_l2 l2 ON l.id = l2.lid + FULL OUTER JOIN ( + pair_multi_both_r r + JOIN pair_multi_both_r2 r2 ON r.id = r2.rid + ) ON EXISTS ( + SELECT 1 + FROM pair_multi_both_s s + WHERE s.a IS NOT DISTINCT FROM l.a + AND s.b IS NOT DISTINCT FROM r.b + AND s.z IS NOT DISTINCT FROM l2.z + AND s.w IS NOT DISTINCT FROM r2.w + ) +), manual_matches AS ( + SELECT l.lid, l.a, l.z, r.rid, r.b, r.w + FROM left_side l, right_side r + WHERE EXISTS ( + SELECT 1 + FROM pair_multi_both_s s + WHERE s.a IS NOT DISTINCT FROM l.a + AND s.b IS NOT DISTINCT FROM r.b + AND s.z IS NOT DISTINCT FROM l.z + AND s.w IS NOT DISTINCT FROM r.w + ) +), manual AS ( + SELECT * FROM manual_matches + UNION ALL + SELECT l.lid, l.a, l.z, NULL::INTEGER, NULL::INTEGER, NULL::INTEGER + FROM left_side l + WHERE NOT EXISTS ( + SELECT 1 + FROM right_side r + WHERE EXISTS ( + SELECT 1 + FROM pair_multi_both_s s + WHERE s.a IS NOT DISTINCT FROM l.a + AND s.b IS NOT DISTINCT FROM r.b + AND s.z IS NOT DISTINCT FROM l.z + AND s.w IS NOT DISTINCT FROM r.w + ) + ) + UNION ALL + SELECT NULL::INTEGER, NULL::INTEGER, NULL::INTEGER, r.rid, r.b, r.w + FROM right_side r + WHERE NOT EXISTS ( + SELECT 1 + FROM left_side l + WHERE EXISTS ( + SELECT 1 + FROM pair_multi_both_s s + WHERE s.a IS NOT DISTINCT FROM l.a + AND s.b IS NOT DISTINCT FROM r.b + AND s.z IS NOT DISTINCT FROM l.z + AND s.w IS NOT DISTINCT FROM r.w + ) + ) +), a_minus_m AS ( + SELECT * FROM actual EXCEPT ALL SELECT * FROM manual +), m_minus_a AS ( + SELECT * FROM manual EXCEPT ALL SELECT * FROM actual +) +SELECT 'full_multi_layout', (SELECT count(*) FROM a_minus_m), (SELECT count(*) FROM m_minus_a); +-- +ok +== +WITH left_side AS ( + SELECT l.id AS lid, l.a, l2.z + FROM pair_multi_both_l l + JOIN pair_multi_both_l2 l2 ON l.id = l2.lid +), right_side AS ( + SELECT r.id AS rid, r.b, r2.w + FROM pair_multi_both_r r + JOIN pair_multi_both_r2 r2 ON r.id = r2.rid +), actual AS ( + SELECT l.id AS lid, l.a, l2.z + FROM pair_multi_both_l l + JOIN pair_multi_both_l2 l2 ON l.id = l2.lid + SEMI JOIN ( + pair_multi_both_r r + JOIN pair_multi_both_r2 r2 ON r.id = r2.rid + ) ON EXISTS ( + SELECT 1 + FROM pair_multi_both_s s + WHERE s.a IS NOT DISTINCT FROM l.a + AND s.b IS NOT DISTINCT FROM r.b + AND s.z IS NOT DISTINCT FROM l2.z + AND s.w IS NOT DISTINCT FROM r2.w + ) +), manual AS ( + SELECT l.lid, l.a, l.z + FROM left_side l + WHERE EXISTS ( + SELECT 1 + FROM right_side r + WHERE EXISTS ( + SELECT 1 + FROM pair_multi_both_s s + WHERE s.a IS NOT DISTINCT FROM l.a + AND s.b IS NOT DISTINCT FROM r.b + AND s.z IS NOT DISTINCT FROM l.z + AND s.w IS NOT DISTINCT FROM r.w + ) + ) +), a_minus_m AS ( + SELECT * FROM actual EXCEPT ALL SELECT * FROM manual +), m_minus_a AS ( + SELECT * FROM manual EXCEPT ALL SELECT * FROM actual +) +SELECT 'semi_multi_layout', (SELECT count(*) FROM a_minus_m), (SELECT count(*) FROM m_minus_a); +-- +ok +== +WITH left_side AS ( + SELECT l.id AS lid, l.a, l2.z + FROM pair_multi_both_l l + JOIN pair_multi_both_l2 l2 ON l.id = l2.lid +), right_side AS ( + SELECT r.id AS rid, r.b, r2.w + FROM pair_multi_both_r r + JOIN pair_multi_both_r2 r2 ON r.id = r2.rid +), actual AS ( + SELECT l.id AS lid, l.a, l2.z + FROM pair_multi_both_l l + JOIN pair_multi_both_l2 l2 ON l.id = l2.lid + ANTI JOIN ( + pair_multi_both_r r + JOIN pair_multi_both_r2 r2 ON r.id = r2.rid + ) ON EXISTS ( + SELECT 1 + FROM pair_multi_both_s s + WHERE s.a IS NOT DISTINCT FROM l.a + AND s.b IS NOT DISTINCT FROM r.b + AND s.z IS NOT DISTINCT FROM l2.z + AND s.w IS NOT DISTINCT FROM r2.w + ) +), manual AS ( + SELECT l.lid, l.a, l.z + FROM left_side l + WHERE NOT EXISTS ( + SELECT 1 + FROM right_side r + WHERE EXISTS ( + SELECT 1 + FROM pair_multi_both_s s + WHERE s.a IS NOT DISTINCT FROM l.a + AND s.b IS NOT DISTINCT FROM r.b + AND s.z IS NOT DISTINCT FROM l.z + AND s.w IS NOT DISTINCT FROM r.w + ) + ) +), a_minus_m AS ( + SELECT * FROM actual EXCEPT ALL SELECT * FROM manual +), m_minus_a AS ( + SELECT * FROM manual EXCEPT ALL SELECT * FROM actual +) +SELECT 'anti_multi_layout', (SELECT count(*) FROM a_minus_m), (SELECT count(*) FROM m_minus_a); +-- +ok +== diff --git a/parser/testdata/corpus/sql/join/pair_dependent_full_outer_join_subquery_cte.test b/parser/testdata/corpus/sql/join/pair_dependent_full_outer_join_subquery_cte.test new file mode 100644 index 0000000..1ed9cbd --- /dev/null +++ b/parser/testdata/corpus/sql/join/pair_dependent_full_outer_join_subquery_cte.test @@ -0,0 +1,146 @@ +# source: test/sql/join/pair_dependent_full_outer_join_subquery_cte.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +PREPARE pair_prepared_full AS +SELECT l.a, r.b +FROM (SELECT * FROM pair_l WHERE x >= $1) l +FULL OUTER JOIN pair_r r ON EXISTS ( + SELECT 1 + FROM pair_s s + WHERE s.a = l.a + AND s.b = r.b + AND s.a <= $2 +) +ORDER BY l.a NULLS LAST, r.b NULLS LAST; +-- +ok +== +EXECUTE pair_prepared_full(20, 2); +-- +ok +== +CREATE SEQUENCE pair_effect_seq START 1; +-- +ok +== +CREATE TABLE pair_effect_l(a INTEGER); +-- +ok +== +CREATE TABLE pair_effect_r(b BIGINT); +-- +ok +== +INSERT INTO pair_effect_l VALUES (1), (2); +-- +ok +== +INSERT INTO pair_effect_r VALUES (1), (2), (3); +-- +ok +== +WITH q AS ( + SELECT count(*)::INTEGER AS count_value + FROM (SELECT a, nextval('pair_effect_seq') AS v FROM pair_effect_l) l + FULL OUTER JOIN pair_effect_r r ON EXISTS ( + SELECT 1 WHERE l.v = r.b + ) +) +SELECT count_value, currval('pair_effect_seq') FROM q; +-- +ok +== +CREATE TABLE pair_list_domain_l(v INTEGER[], payload INTEGER); +-- +ok +== +CREATE TABLE pair_list_domain_r(v INTEGER[], payload INTEGER); +-- +ok +== +CREATE TABLE pair_list_domain_s(lv INTEGER[], rv INTEGER[]); +-- +ok +== +INSERT INTO pair_list_domain_l VALUES ([1, 2], 1), ([1, 2], 2), ([3], 3); +-- +ok +== +INSERT INTO pair_list_domain_r VALUES ([10], 10), ([20], 20); +-- +ok +== +INSERT INTO pair_list_domain_s VALUES ([1, 2], [10]); +-- +ok +== +SELECT l.payload, r.payload +FROM pair_list_domain_l l +FULL OUTER JOIN pair_list_domain_r r ON EXISTS ( + SELECT 1 + FROM pair_list_domain_s s + WHERE s.lv = l.v + AND s.rv = r.v +); +-- +ok +== +CREATE TABLE pair_unique_domain_l(a INTEGER, x INTEGER); +-- +ok +== +CREATE TABLE pair_unique_domain_r(b INTEGER, y INTEGER); +-- +ok +== +CREATE TABLE pair_unique_domain_s(a INTEGER, b INTEGER); +-- +ok +== +INSERT INTO pair_unique_domain_l VALUES (1, 5), (1, 7), (2, 9), (3, 11); +-- +ok +== +INSERT INTO pair_unique_domain_r VALUES (10, 100), (10, 110), (20, 200), (30, 300); +-- +ok +== +INSERT INTO pair_unique_domain_s VALUES (1, 10), (2, 20); +-- +ok +== +SELECT l.a, l.x, r.b, r.y +FROM (SELECT a, max(x)::INTEGER AS x FROM pair_unique_domain_l GROUP BY a) l +FULL OUTER JOIN (SELECT b, max(y)::INTEGER AS y FROM pair_unique_domain_r GROUP BY b) r ON EXISTS ( + SELECT 1 + FROM pair_unique_domain_s s + WHERE s.a = l.a + AND s.b = r.b +); +-- +ok +== +EXPLAIN SELECT l.a, l.x, r.b, r.y +FROM pair_unique_domain_l l +FULL OUTER JOIN pair_unique_domain_r r ON EXISTS ( + SELECT 1 + FROM pair_unique_domain_s s + WHERE s.a = l.a + AND s.b = r.b +); +-- +ok +== +EXPLAIN SELECT l.a, l.x, r.b, r.y +FROM (SELECT a, max(x)::INTEGER AS x FROM pair_unique_domain_l GROUP BY a) l +FULL OUTER JOIN (SELECT b, max(y)::INTEGER AS y FROM pair_unique_domain_r GROUP BY b) r ON EXISTS ( + SELECT 1 + FROM pair_unique_domain_s s + WHERE s.a = l.a + AND s.b = r.b +); +-- +ok +== diff --git a/parser/testdata/corpus/sql/join/pair_dependent_join_subquery.test b/parser/testdata/corpus/sql/join/pair_dependent_join_subquery.test new file mode 100644 index 0000000..7d1ba78 --- /dev/null +++ b/parser/testdata/corpus/sql/join/pair_dependent_join_subquery.test @@ -0,0 +1,736 @@ +# source: test/sql/join/pair_dependent_join_subquery.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +SELECT l.a, l.x, r.b +FROM pair_l l +LEFT JOIN pair_r r ON EXISTS ( + SELECT 1 FROM pair_s s WHERE s.a = l.a AND s.b = r.b +) +ORDER BY l.x, r.b NULLS LAST; +-- +ok +== +SELECT l.a, l.x, r.b, r.y +FROM pair_l l +RIGHT JOIN pair_r r ON EXISTS ( + SELECT 1 FROM pair_s s WHERE s.a = l.a AND s.b = r.b +) +ORDER BY ALL; +-- +ok +== +SELECT l.a, l.x, r.b +FROM pair_l l +LEFT JOIN pair_r r ON l.a IN ( + SELECT s.a FROM pair_s s WHERE s.b = r.b +) +ORDER BY l.x, r.b NULLS LAST; +-- +ok +== +SELECT l.a, l.x, r.b +FROM pair_l l +LEFT JOIN pair_r r ON r.b IN ( + SELECT s.b FROM pair_s s WHERE s.a = l.a +) +ORDER BY l.x, r.b NULLS LAST; +-- +ok +== +SELECT l.a, l.x, r.b +FROM pair_l l +LEFT JOIN pair_r r ON l.x > 10 AND r.b IN ( + SELECT s.b FROM pair_s s WHERE s.a = l.a +) +ORDER BY l.x, r.b NULLS LAST; +-- +ok +== +SELECT l.a, l.x, r.b +FROM pair_l l +LEFT JOIN pair_r r ON r.b NOT IN ( + SELECT s.b FROM pair_s s WHERE s.a = l.a +) +ORDER BY l.a, l.x, r.b NULLS LAST; +-- +ok +== +SELECT l.a, l.x, r.b +FROM pair_l l +LEFT JOIN pair_r r ON r.b = ( + SELECT max(s.b) FROM pair_s s WHERE s.a = l.a AND s.b <= r.b +) +ORDER BY l.a, l.x, r.b NULLS LAST; +-- +ok +== +SELECT l.a, l.x, r.b +FROM pair_l l +LEFT JOIN pair_r r ON CASE WHEN l.x > 10 THEN r.b ELSE NULL END = ( + SELECT s.b FROM pair_s s WHERE s.a = l.a AND s.b = r.b LIMIT 1 +) +ORDER BY l.a, l.x, r.b NULLS LAST; +-- +ok +== +SELECT l.a, l.x, r.b, r.y +FROM pair_l l +FULL OUTER JOIN pair_r r ON EXISTS ( + SELECT 1 FROM pair_s s WHERE s.a = l.a AND s.b = r.b +) OR l.x * 10 = r.y +ORDER BY ALL; +-- +ok +== +SELECT l.a, l.x +FROM pair_l l +SEMI JOIN pair_r r ON EXISTS ( + SELECT 1 FROM pair_s s WHERE s.a = l.a AND s.b = r.b +) OR l.x * 10 = r.y +ORDER BY ALL; +-- +ok +== +SELECT l.a, l.x +FROM pair_l l +ANTI JOIN pair_r r ON EXISTS ( + SELECT 1 FROM pair_s s WHERE s.a = l.a AND s.b = r.b +) OR l.x * 10 = r.y +ORDER BY ALL; +-- +ok +== +SELECT l.a, l.x, count(r.b) +FROM pair_l l +LEFT JOIN pair_r r ON EXISTS ( + SELECT 1 FROM pair_s s WHERE s.b = r.b +) +GROUP BY l.a, l.x +ORDER BY ALL; +-- +ok +== +CREATE TABLE pair_left_multi_l2(c INTEGER); +-- +ok +== +CREATE TABLE pair_left_multi_r2(c INTEGER); +-- +ok +== +CREATE TABLE pair_left_multi_s(a INTEGER, b INTEGER, c INTEGER); +-- +ok +== +INSERT INTO pair_left_multi_l2 VALUES (5); +-- +ok +== +INSERT INTO pair_left_multi_r2 VALUES (5), (6); +-- +ok +== +INSERT INTO pair_left_multi_s VALUES (1, 10, 5), (2, 20, 5); +-- +ok +== +SELECT l.a, r.b, r2.c +FROM pair_l l +LEFT JOIN (pair_r r JOIN pair_left_multi_r2 r2 ON true) ON EXISTS ( + SELECT 1 + FROM pair_left_multi_s s + WHERE s.a = l.a + AND s.b = r.b + AND s.c = r2.c +) +ORDER BY l.a, r.b NULLS LAST, r2.c NULLS LAST; +-- +ok +== +SELECT l.a, l2.c, r.b +FROM (pair_l l JOIN pair_left_multi_l2 l2 ON true) +LEFT JOIN pair_r r ON EXISTS ( + SELECT 1 + FROM pair_left_multi_s s + WHERE s.a = l.a + AND s.b = r.b + AND s.c = l2.c +) +ORDER BY l.a, l2.c, r.b NULLS LAST; +-- +ok +== +CREATE TABLE pair_left_nested_t(c INTEGER); +-- +ok +== +INSERT INTO pair_left_nested_t VALUES (5); +-- +ok +== +SELECT l.a, l.x, r.b +FROM pair_l l +LEFT JOIN pair_r r ON EXISTS ( + SELECT 1 + FROM pair_left_nested_t t + WHERE EXISTS ( + SELECT 1 + FROM pair_left_multi_s s + WHERE s.a = l.a + AND s.b = r.b + AND s.c = t.c + ) +) +ORDER BY l.a, l.x, r.b NULLS LAST; +-- +ok +== +SELECT l.a, l.x, r.b +FROM pair_l l +LEFT JOIN pair_r r ON EXISTS ( + SELECT 1 + FROM pair_left_nested_t t + WHERE EXISTS ( + SELECT 1 + WHERE EXISTS ( + SELECT 1 + FROM pair_left_multi_s s + WHERE s.a = l.a + AND s.b = r.b + AND s.c = t.c + ) + ) +) +ORDER BY l.a, l.x, r.b NULLS LAST; +-- +ok +== +SELECT l.a, l.x +FROM pair_l l +SEMI JOIN pair_r r ON EXISTS ( + SELECT 1 + FROM pair_left_nested_t t + WHERE EXISTS ( + SELECT 1 + WHERE EXISTS ( + SELECT 1 + FROM pair_left_multi_s s + WHERE s.a = l.a + AND s.b = r.b + AND s.c = t.c + ) + ) +) +ORDER BY ALL; +-- +ok +== +SELECT l.a, l.x +FROM pair_l l +ANTI JOIN pair_r r ON EXISTS ( + SELECT 1 + FROM pair_left_nested_t t + WHERE EXISTS ( + SELECT 1 + WHERE EXISTS ( + SELECT 1 + FROM pair_left_multi_s s + WHERE s.a = l.a + AND s.b = r.b + AND s.c = t.c + ) + ) +) +ORDER BY ALL; +-- +ok +== +CREATE TABLE pair_left_dup_l(a INTEGER); +-- +ok +== +CREATE TABLE pair_left_dup_r(b INTEGER); +-- +ok +== +CREATE TABLE pair_left_dup_s(a INTEGER, b INTEGER); +-- +ok +== +INSERT INTO pair_left_dup_l VALUES (1), (1), (2), (3); +-- +ok +== +INSERT INTO pair_left_dup_r VALUES (10), (10), (20); +-- +ok +== +INSERT INTO pair_left_dup_s VALUES (1, 10), (2, 20); +-- +ok +== +SELECT l.a, r.b, count(*)::INTEGER +FROM pair_left_dup_l l +LEFT JOIN pair_left_dup_r r ON EXISTS ( + SELECT 1 + FROM pair_left_dup_s s + WHERE s.a = l.a + AND s.b = r.b +) +GROUP BY ALL +ORDER BY ALL; +-- +ok +== +SELECT l.a, count(*)::INTEGER +FROM pair_left_dup_l l +SEMI JOIN pair_left_dup_r r ON EXISTS ( + SELECT 1 + FROM pair_left_dup_s s + WHERE s.a = l.a + AND s.b = r.b +) +GROUP BY ALL +ORDER BY ALL; +-- +ok +== +SELECT l.a, count(*)::INTEGER +FROM pair_left_dup_l l +ANTI JOIN pair_left_dup_r r ON EXISTS ( + SELECT 1 + FROM pair_left_dup_s s + WHERE s.a = l.a + AND s.b = r.b +) +GROUP BY ALL +ORDER BY ALL; +-- +ok +== +CREATE TABLE pair_left_null_l(a INTEGER); +-- +ok +== +CREATE TABLE pair_left_null_r(b INTEGER); +-- +ok +== +CREATE TABLE pair_left_null_s(a INTEGER, b INTEGER); +-- +ok +== +INSERT INTO pair_left_null_l VALUES (NULL), (NULL), (1), (2); +-- +ok +== +INSERT INTO pair_left_null_r VALUES (NULL), (10), (20); +-- +ok +== +INSERT INTO pair_left_null_s VALUES (NULL, NULL), (1, 10); +-- +ok +== +SELECT l.a, r.b, count(*)::INTEGER +FROM pair_left_null_l l +LEFT JOIN pair_left_null_r r ON EXISTS ( + SELECT 1 + FROM pair_left_null_s s + WHERE s.a IS NOT DISTINCT FROM l.a + AND s.b IS NOT DISTINCT FROM r.b +) +GROUP BY ALL +ORDER BY ALL; +-- +ok +== +CREATE TABLE pair_left_rowid_l(a INTEGER); +-- +ok +== +CREATE TABLE pair_left_rowid_r(b INTEGER); +-- +ok +== +CREATE TABLE pair_left_rowid_s(lrid BIGINT, rrid BIGINT); +-- +ok +== +INSERT INTO pair_left_rowid_l VALUES (1), (2); +-- +ok +== +INSERT INTO pair_left_rowid_r VALUES (10), (20); +-- +ok +== +INSERT INTO pair_left_rowid_s VALUES (0, 0); +-- +ok +== +SELECT l.rowid, l.a, r.rowid, r.b +FROM pair_left_rowid_l l +LEFT JOIN pair_left_rowid_r r ON EXISTS ( + SELECT 1 + FROM pair_left_rowid_s s + WHERE s.lrid = l.rowid + AND s.rrid = r.rowid +) +ORDER BY ALL; +-- +ok +== +CREATE SEQUENCE pair_left_effect_seq START 1; +-- +ok +== +CREATE TABLE pair_left_effect_l(a INTEGER); +-- +ok +== +CREATE TABLE pair_left_effect_r(b BIGINT); +-- +ok +== +INSERT INTO pair_left_effect_l VALUES (1), (2); +-- +ok +== +INSERT INTO pair_left_effect_r VALUES (1), (2), (3); +-- +ok +== +WITH q AS ( + SELECT count(*)::INTEGER AS count_value + FROM (SELECT a, nextval('pair_left_effect_seq') AS v FROM pair_left_effect_l) l + LEFT JOIN pair_left_effect_r r ON EXISTS ( + SELECT 1 WHERE l.v = r.b + ) +) +SELECT count_value, currval('pair_left_effect_seq') FROM q; +-- +ok +== +CREATE SEQUENCE pair_exists_effect_seq START 1; +-- +ok +== +WITH q AS ( + SELECT count(*)::INTEGER AS count_value + FROM (SELECT a, nextval('pair_exists_effect_seq') AS v FROM pair_left_effect_l) l + SEMI JOIN pair_left_effect_r r ON EXISTS ( + SELECT 1 WHERE l.v = r.b + ) +) +SELECT count_value, currval('pair_exists_effect_seq') FROM q; +-- +ok +== +CREATE SEQUENCE pair_anti_effect_seq START 1; +-- +ok +== +WITH q AS ( + SELECT count(*)::INTEGER AS count_value + FROM (SELECT a, nextval('pair_anti_effect_seq') AS v FROM pair_left_effect_l) l + ANTI JOIN pair_left_effect_r r ON EXISTS ( + SELECT 1 WHERE l.v = r.b + ) +) +SELECT count_value, currval('pair_anti_effect_seq') FROM q; +-- +ok +== +CREATE SEQUENCE pair_exists_right_effect_seq START 1; +-- +ok +== +WITH q AS ( + SELECT count(*)::INTEGER AS count_value + FROM pair_left_effect_l l + SEMI JOIN (SELECT b, nextval('pair_exists_right_effect_seq') AS v FROM pair_left_effect_r) r ON EXISTS ( + SELECT 1 WHERE l.a = r.v + ) +) +SELECT count_value, currval('pair_exists_right_effect_seq') FROM q; +-- +ok +== +CREATE SEQUENCE pair_anti_right_effect_seq START 1; +-- +ok +== +WITH q AS ( + SELECT count(*)::INTEGER AS count_value + FROM pair_left_effect_l l + ANTI JOIN (SELECT b, nextval('pair_anti_right_effect_seq') AS v FROM pair_left_effect_r) r ON EXISTS ( + SELECT 1 WHERE l.a = r.v + ) +) +SELECT count_value, currval('pair_anti_right_effect_seq') FROM q; +-- +ok +== +SELECT l.a, l.x, r.b +FROM pair_l l +RIGHT JOIN pair_r r ON EXISTS ( + SELECT 1 FROM pair_s s WHERE s.a = l.a AND s.b = r.b +) +ORDER BY r.b, l.x NULLS LAST; +-- +ok +== +SELECT l.a, l.x, r.b +FROM pair_l l +RIGHT JOIN pair_r r ON EXISTS ( + SELECT 1 + FROM pair_left_nested_t t + WHERE EXISTS ( + SELECT 1 + FROM pair_left_multi_s s + WHERE s.a = l.a + AND s.b = r.b + AND s.c = t.c + ) +) +ORDER BY r.b, l.x NULLS LAST; +-- +ok +== +SELECT l.a, l.x, r.b +FROM pair_l l +RIGHT JOIN pair_r r ON EXISTS ( + SELECT 1 + FROM pair_left_nested_t t + WHERE EXISTS ( + SELECT 1 + WHERE EXISTS ( + SELECT 1 + FROM pair_left_multi_s s + WHERE s.a = l.a + AND s.b = r.b + AND s.c = t.c + ) + ) +) +ORDER BY r.b, l.x NULLS LAST; +-- +ok +== +SELECT * +FROM pair_l l +RIGHT JOIN pair_r r ON EXISTS ( + SELECT 1 FROM pair_s s WHERE s.a = l.a AND s.b = r.b +) +ORDER BY r.b, l.x NULLS LAST; +-- +ok +== +CREATE TABLE pair_right_corr_outer_l(a INTEGER); +-- +ok +== +CREATE TABLE pair_right_corr_outer_r(b INTEGER); +-- +ok +== +CREATE TABLE pair_right_corr_l(a INTEGER, x INTEGER); +-- +ok +== +CREATE TABLE pair_right_corr_r(b INTEGER); +-- +ok +== +CREATE TABLE pair_right_corr_s(a INTEGER, b INTEGER); +-- +ok +== +INSERT INTO pair_right_corr_outer_l VALUES (1), (2), (4); +-- +ok +== +INSERT INTO pair_right_corr_outer_r VALUES (10), (20), (99); +-- +ok +== +INSERT INTO pair_right_corr_l VALUES (1, 10), (1, 11), (2, 20), (3, 30); +-- +ok +== +INSERT INTO pair_right_corr_r VALUES (10), (20), (30); +-- +ok +== +INSERT INTO pair_right_corr_s VALUES (1, 10), (1, 20), (2, 20), (3, 30); +-- +ok +== +SELECT o.a, q.a, q.x, q.b +FROM pair_right_corr_outer_l o +LEFT JOIN LATERAL ( + SELECT l.a, l.x, r.b + FROM (SELECT * FROM pair_right_corr_l WHERE pair_right_corr_l.a = o.a) l + RIGHT JOIN pair_right_corr_r r ON EXISTS ( + SELECT 1 + FROM pair_right_corr_s s + WHERE s.a = l.a + AND s.b = r.b + ) +) q ON true +ORDER BY ALL; +-- +ok +== +SELECT o.b, q.a, q.x, q.b +FROM pair_right_corr_outer_r o +LEFT JOIN LATERAL ( + SELECT l.a, l.x, r.b + FROM pair_right_corr_l l + RIGHT JOIN (SELECT * FROM pair_right_corr_r WHERE pair_right_corr_r.b = o.b) r ON EXISTS ( + SELECT 1 + FROM pair_right_corr_s s + WHERE s.a = l.a + AND s.b = r.b + ) +) q ON true +ORDER BY ALL; +-- +ok +== +CREATE TABLE pair_state_l(a INTEGER); +-- +ok +== +CREATE TABLE pair_state_r(b INTEGER); +-- +ok +== +INSERT INTO pair_state_l VALUES (1), (2), (4); +-- +ok +== +INSERT INTO pair_state_r VALUES (2), (3); +-- +ok +== +SELECT l.a, r.b +FROM pair_state_l l +LEFT JOIN pair_state_r r ON EXISTS ( + WITH RECURSIVE walk(n) AS ( + SELECT l.a + UNION ALL + SELECT n + 1 FROM walk WHERE n < r.b + ) + SELECT 1 FROM walk WHERE n = r.b +) +ORDER BY ALL; +-- +ok +== +SELECT l.a, r.b +FROM pair_state_l l +LEFT JOIN pair_state_r r ON EXISTS ( + (SELECT 1 WHERE l.a = r.b) + UNION ALL + (SELECT 1 WHERE l.a + 1 = r.b) +) +ORDER BY ALL; +-- +ok +== +SELECT l.a, r.b +FROM pair_state_l l +LEFT JOIN pair_state_r r ON EXISTS ( + (SELECT l.a) + INTERSECT + (SELECT r.b) +) +ORDER BY ALL; +-- +ok +== +CREATE SEQUENCE pair_volatile_left_seq START 1; +-- +ok +== +CREATE TEMP TABLE pair_volatile_left_result AS +SELECT l.lid, r.rid +FROM (VALUES (1, 1), (2, 1)) l(lid, a) +LEFT JOIN (VALUES (10, 1), (20, 1)) r(rid, b) ON EXISTS ( + SELECT 1 + WHERE l.a = r.b + AND nextval('pair_volatile_left_seq') = 2 +); +-- +ok +== +SELECT count(*), count(rid), currval('pair_volatile_left_seq') +FROM pair_volatile_left_result; +-- +ok +== +CREATE SEQUENCE pair_volatile_right_seq START 1; +-- +ok +== +CREATE TEMP TABLE pair_volatile_right_result AS +SELECT l.lid, r.rid +FROM (VALUES (1, 1), (2, 1)) l(lid, a) +RIGHT JOIN (VALUES (10, 1), (20, 1)) r(rid, b) ON EXISTS ( + SELECT 1 + WHERE l.a = r.b + AND nextval('pair_volatile_right_seq') = 2 +); +-- +ok +== +SELECT count(*), count(lid), currval('pair_volatile_right_seq') +FROM pair_volatile_right_result; +-- +ok +== +CREATE SEQUENCE pair_volatile_semi_seq START 1; +-- +ok +== +SELECT count(*), currval('pair_volatile_semi_seq') +FROM (VALUES (1, 1), (2, 1)) l(lid, a) +SEMI JOIN (VALUES (10, 1), (20, 1)) r(rid, b) ON EXISTS ( + SELECT 1 + WHERE l.a = r.b + AND nextval('pair_volatile_semi_seq') > 100 +); +-- +ok +== +CREATE SEQUENCE pair_volatile_anti_seq START 1; +-- +ok +== +SELECT count(*), currval('pair_volatile_anti_seq') +FROM (VALUES (1, 1), (2, 1)) l(lid, a) +ANTI JOIN (VALUES (10, 1), (20, 1)) r(rid, b) ON EXISTS ( + SELECT 1 + WHERE l.a = r.b + AND nextval('pair_volatile_anti_seq') > 100 +); +-- +ok +== +CREATE SEQUENCE pair_volatile_any_seq START 1; +-- +ok +== +SELECT count(*), currval('pair_volatile_any_seq') +FROM (VALUES (1, 1), (2, 1)) l(lid, a) +LEFT JOIN (VALUES (10, 1), (20, 1)) r(rid, b) ON l.a = ANY ( + SELECT r.b + WHERE nextval('pair_volatile_any_seq') > 100 +); +-- +ok +== diff --git a/parser/testdata/corpus/sql/join/pair_dependent_outer_reference_subquery.test b/parser/testdata/corpus/sql/join/pair_dependent_outer_reference_subquery.test new file mode 100644 index 0000000..77603fc --- /dev/null +++ b/parser/testdata/corpus/sql/join/pair_dependent_outer_reference_subquery.test @@ -0,0 +1,363 @@ +# source: test/sql/join/pair_dependent_outer_reference_subquery.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +SELECT outer_l.x, q.a, q.b +FROM pair_l outer_l +LEFT JOIN LATERAL ( + SELECT l.a, r.b + FROM pair_l l + LEFT JOIN pair_r r ON EXISTS ( + SELECT 1 + FROM pair_s s + WHERE s.a = l.a + AND s.b = r.b + AND s.a = outer_l.a + ) + WHERE l.x = outer_l.x +) q ON true +ORDER BY outer_l.x, q.a, q.b NULLS LAST; +-- +ok +== +SELECT o.x, EXISTS ( + SELECT * + FROM (VALUES (1, 1)) l(k, a) + SEMI JOIN (VALUES (1, 1)) r(k, b) + ON l.k = r.k + AND l.a = r.b + o.x +) AS ex +FROM (VALUES (0), (1)) o(x) +ORDER BY o.x; +-- +ok +== +SELECT o.x, EXISTS ( + SELECT * + FROM (VALUES (1, 1)) l(k, a) + ANTI JOIN (VALUES (1, 1)) r(k, b) + ON l.k = r.k + AND l.a = r.b + o.x +) AS ex +FROM (VALUES (0), (1)) o(x) +ORDER BY o.x; +-- +ok +== +SELECT outer_l.x, q.a, q.x +FROM pair_l outer_l +LEFT JOIN LATERAL ( + SELECT l.a, l.x + FROM pair_l l + SEMI JOIN pair_r r ON EXISTS ( + SELECT 1 + FROM pair_s s + WHERE s.a = l.a + AND s.b = r.b + AND s.a = outer_l.a + ) + WHERE l.x = outer_l.x +) q ON true +ORDER BY outer_l.x, q.a NULLS LAST, q.x NULLS LAST; +-- +ok +== +SELECT outer_l.x, q.a, q.x +FROM pair_l outer_l +LEFT JOIN LATERAL ( + SELECT l.a, l.x + FROM pair_l l + ANTI JOIN pair_r r ON EXISTS ( + SELECT 1 + FROM pair_s s + WHERE s.a = l.a + AND s.b = r.b + AND s.a = outer_l.a + ) + WHERE l.x = outer_l.x +) q ON true +ORDER BY outer_l.x, q.a NULLS LAST, q.x NULLS LAST; +-- +ok +== +SELECT outer_l.x, q.lx, q.b +FROM pair_l outer_l +LEFT JOIN LATERAL ( + SELECT l.x AS lx, r.b + FROM (SELECT * FROM pair_l WHERE pair_l.a = outer_l.a) l + LEFT JOIN pair_r r ON EXISTS ( + SELECT 1 + FROM pair_s s + WHERE s.a = l.a + AND s.b = r.b + ) +) q ON true +ORDER BY outer_l.x, q.lx, q.b NULLS LAST; +-- +ok +== +SELECT outer_r.y, q.a, q.x, q.b +FROM pair_r outer_r +LEFT JOIN LATERAL ( + SELECT l.a, l.x, r.b + FROM pair_l l + LEFT JOIN (SELECT * FROM pair_r WHERE pair_r.b = outer_r.b) r ON EXISTS ( + SELECT 1 + FROM pair_s s + WHERE s.a = l.a + AND s.b = r.b + ) +) q ON true +ORDER BY outer_r.y, q.a, q.x, q.b NULLS LAST; +-- +ok +== +SELECT outer_r.b, q.a, q.x, q.b +FROM pair_r outer_r +LEFT JOIN LATERAL ( + WITH cr AS (SELECT b FROM pair_r WHERE pair_r.b = outer_r.b) + SELECT l.a, l.x, cr.b + FROM pair_l l + LEFT JOIN cr ON EXISTS ( + SELECT 1 + FROM pair_s s + WHERE s.a = l.a + AND s.b = cr.b + ) +) q ON true +ORDER BY outer_r.b, q.a, q.x, q.b NULLS LAST; +-- +ok +== +SELECT outer_l.a, q.a, q.x, q.b +FROM pair_right_corr_outer_l outer_l +LEFT JOIN LATERAL ( + WITH cl AS (SELECT a, x FROM pair_l WHERE pair_l.a = outer_l.a) + SELECT cl.a, cl.x, r.b + FROM cl + LEFT JOIN pair_r r ON EXISTS ( + SELECT 1 + FROM pair_s s + WHERE s.a = cl.a + AND s.b = r.b + ) +) q ON true +ORDER BY outer_l.a, q.a, q.x, q.b NULLS LAST; +-- +ok +== +SELECT outer_r.b, q.a, q.x, q.b +FROM pair_r outer_r +LEFT JOIN LATERAL ( + WITH cr AS (SELECT b, y FROM pair_r WHERE pair_r.b = outer_r.b) + SELECT l.a, l.x, cr.b + FROM pair_l l + RIGHT JOIN cr ON EXISTS ( + SELECT 1 + FROM pair_s s + WHERE s.a = l.a + AND s.b = cr.b + ) +) q ON true +ORDER BY outer_r.b, q.a, q.x, q.b NULLS LAST; +-- +ok +== +SELECT outer_l.a, q.a, q.x, q.b +FROM pair_right_corr_outer_l outer_l +LEFT JOIN LATERAL ( + WITH cl AS MATERIALIZED ( + SELECT a, x + FROM pair_l + WHERE EXISTS ( + SELECT 1 + WHERE pair_l.a = outer_l.a + ) + ) + SELECT l.a, l.x, r.b + FROM cl l + LEFT JOIN pair_r r ON EXISTS ( + SELECT 1 + FROM pair_s s + WHERE s.a = l.a + AND s.b = r.b + ) +) q ON true +ORDER BY outer_l.a, q.a, q.x, q.b NULLS LAST; +-- +ok +== +SELECT outer_l.a, q.a, q.x +FROM pair_right_corr_outer_l outer_l +LEFT JOIN LATERAL ( + WITH cl AS (SELECT a, x FROM pair_l WHERE pair_l.a = outer_l.a) + SELECT cl.a, cl.x + FROM cl + SEMI JOIN pair_r r ON EXISTS ( + SELECT 1 + FROM pair_s s + WHERE s.a = cl.a + AND s.b = r.b + ) +) q ON true +ORDER BY outer_l.a, q.a, q.x; +-- +ok +== +SELECT outer_l.a, q.a, q.x +FROM pair_right_corr_outer_l outer_l +LEFT JOIN LATERAL ( + WITH cl AS (SELECT a, x FROM pair_l WHERE pair_l.a = outer_l.a) + SELECT cl.a, cl.x + FROM cl + ANTI JOIN pair_r r ON EXISTS ( + SELECT 1 + FROM pair_s s + WHERE s.a = cl.a + AND s.b = r.b + ) +) q ON true +ORDER BY outer_l.a, q.a, q.x; +-- +ok +== +SELECT outer_r.b, q.a, q.x +FROM pair_r outer_r +LEFT JOIN LATERAL ( + WITH cr AS (SELECT b FROM pair_r WHERE pair_r.b = outer_r.b) + SELECT l.a, l.x + FROM pair_l l + SEMI JOIN cr ON EXISTS ( + SELECT 1 + FROM pair_s s + WHERE s.a = l.a + AND s.b = cr.b + ) +) q ON true +ORDER BY outer_r.b, q.a, q.x; +-- +ok +== +SELECT outer_r.b, q.a, q.x +FROM pair_r outer_r +LEFT JOIN LATERAL ( + WITH cr AS (SELECT b FROM pair_r WHERE pair_r.b = outer_r.b) + SELECT l.a, l.x + FROM pair_l l + ANTI JOIN cr ON EXISTS ( + SELECT 1 + FROM pair_s s + WHERE s.a = l.a + AND s.b = cr.b + ) +) q ON true +ORDER BY outer_r.b, q.a, q.x; +-- +ok +== +SELECT outer_r.b, q.flag +FROM pair_r outer_r +LEFT JOIN LATERAL ( + WITH cr AS (SELECT b FROM pair_r WHERE pair_r.b = outer_r.b) + SELECT 1 AS flag + FROM (SELECT 1) ll + SEMI JOIN cr ON EXISTS ( + SELECT 1 + FROM pair_s s + WHERE s.b = cr.b + ) +) q ON true +ORDER BY outer_r.b, q.flag; +-- +ok +== +CREATE TABLE pair_outer_nested_o(x INTEGER); +-- +ok +== +INSERT INTO pair_outer_nested_o VALUES (5), (6); +-- +ok +== +SELECT o.x, q.a, q.lx, q.b +FROM pair_outer_nested_o o +LEFT JOIN LATERAL ( + SELECT l.a, l.x AS lx, r.b + FROM pair_l l + LEFT JOIN pair_r r ON EXISTS ( + SELECT 1 + FROM pair_left_nested_t t + WHERE EXISTS ( + SELECT 1 + FROM pair_left_multi_s s + WHERE s.a = l.a + AND s.b = r.b + AND s.c = t.c + AND s.c = o.x + ) + ) +) q ON true +ORDER BY o.x, q.a, q.lx, q.b NULLS LAST; +-- +ok +== +SELECT o.x, q.a, q.lx, q.b +FROM pair_outer_nested_o o +LEFT JOIN LATERAL ( + SELECT l.a, l.x AS lx, r.b + FROM pair_l l + LEFT JOIN pair_r r ON EXISTS ( + SELECT 1 + FROM pair_left_nested_t t + WHERE EXISTS ( + SELECT 1 + WHERE EXISTS ( + SELECT 1 + FROM pair_left_multi_s s + WHERE s.a = l.a + AND s.b = r.b + AND s.c = t.c + AND s.c = o.x + ) + ) + ) +) q ON true +ORDER BY o.x, q.a, q.lx, q.b NULLS LAST; +-- +ok +== +SELECT outer_l.x, q.a, q.b +FROM pair_l outer_l +LEFT JOIN LATERAL ( + SELECT l.a, r.b + FROM pair_l l + FULL OUTER JOIN pair_r r ON EXISTS ( + SELECT 1 + FROM pair_s s + WHERE s.a = l.a + AND s.b = r.b + AND s.a = outer_l.a + ) + WHERE l.x = outer_l.x +) q ON true +ORDER BY outer_l.x, q.a, q.b NULLS LAST; +-- +ok +== +SELECT outer_l.x, q.a, q.b +FROM pair_l outer_l +LEFT JOIN LATERAL ( + SELECT l.a, r.b + FROM pair_l l + LEFT JOIN pair_r r ON l.a = outer_l.a AND r.b IN ( + SELECT s.b + FROM pair_s s + WHERE s.a = l.a + ) + WHERE l.x = outer_l.x +) q ON true +ORDER BY outer_l.x, q.a, q.b NULLS LAST; +-- +ok +== diff --git a/parser/testdata/corpus/sql/join/pair_dependent_volatile_subquery.test b/parser/testdata/corpus/sql/join/pair_dependent_volatile_subquery.test new file mode 100644 index 0000000..f79d975 --- /dev/null +++ b/parser/testdata/corpus/sql/join/pair_dependent_volatile_subquery.test @@ -0,0 +1,35 @@ +# source: test/sql/join/pair_dependent_volatile_subquery.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +SET disabled_optimizers='filter_pullup'; +-- +ok +== +CREATE SEQUENCE pair_volatile_any_no_pullup_seq START 1; +-- +ok +== +SELECT count(*), count(rid), currval('pair_volatile_any_no_pullup_seq') +FROM (VALUES (1, 1), (2, 1)) l(lid, a) +LEFT JOIN (VALUES (10, 1), (20, 1)) r(rid, b) ON l.a = ANY ( + SELECT r.b + WHERE nextval('pair_volatile_any_no_pullup_seq') = 2 +); +-- +ok +== +CREATE SEQUENCE pair_volatile_not_in_no_pullup_seq START 1; +-- +ok +== +SELECT count(*), count(rid), currval('pair_volatile_not_in_no_pullup_seq') +FROM (VALUES (1, 1), (2, 1)) l(lid, a) +LEFT JOIN (VALUES (10, 1), (20, 1)) r(rid, b) ON l.a NOT IN ( + SELECT r.b + WHERE nextval('pair_volatile_not_in_no_pullup_seq') = 2 +); +-- +ok +== diff --git a/parser/testdata/corpus/sql/join/positional/issue20086.test b/parser/testdata/corpus/sql/join/positional/issue20086.test new file mode 100644 index 0000000..1c805b1 --- /dev/null +++ b/parser/testdata/corpus/sql/join/positional/issue20086.test @@ -0,0 +1,21 @@ +# source: test/sql/join/positional/issue20086.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +CREATE UNIQUE INDEX t0i0 ON t0(c0, c1); +-- +ok +== +INSERT INTO t0 VALUES (1,0), (-1,NULL); +-- +ok +== +UPDATE t0 SET c1 = NULL WHERE c0 = 1; +-- +ok +== +SELECT * FROM t1 POSITIONAL JOIN t0 WHERE (t1.c0 > t0.c1) IS NULL; +-- +ok +== diff --git a/parser/testdata/corpus/sql/join/positional/test_positional_join.test b/parser/testdata/corpus/sql/join/positional/test_positional_join.test new file mode 100644 index 0000000..d0574b2 --- /dev/null +++ b/parser/testdata/corpus/sql/join/positional/test_positional_join.test @@ -0,0 +1,107 @@ +# source: test/sql/join/positional/test_positional_join.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +CREATE TABLE two (a INTEGER, b INTEGER); +-- +ok +== +INSERT INTO two VALUES (11, 1), (12, 2); +-- +ok +== +CREATE TABLE three AS + SELECT * FROM (VALUES + (11, 1), + (12, 2), + (13, 3) + ) tbl(a, b); +-- +ok +== +CREATE TABLE threek AS + SELECT * FROM generate_series(0, 3001) tbl(id); +-- +ok +== +SELECT * +FROM two t1 POSITIONAL JOIN two t2 +-- +ok +== +SELECT * +FROM threek t1 POSITIONAL JOIN threek t2 +WHERE t1.id <> t2.id +-- +ok +== +SELECT * +FROM two t1 POSITIONAL JOIN three t2 +-- +ok +== +SELECT * +FROM three t1 POSITIONAL JOIN two t2 +-- +ok +== +SELECT COUNT(a), COUNT(id) +FROM three POSITIONAL JOIN threek +-- +ok +== +SELECT COUNT(id), COUNT(a) +FROM threek POSITIONAL JOIN three +-- +ok +== +SELECT * +FROM + (SELECT * FROM two WHERE a % 2 = 0) t1 + POSITIONAL JOIN + (SELECT * FROM two WHERE a % 2 = 1) t2 +-- +ok +== +SELECT * +FROM + (SELECT * FROM threek WHERE id % 2 = 0) t1 + POSITIONAL JOIN + (SELECT * FROM threek WHERE id % 2 = 1) t2 +WHERE t1.id + 1 <> t2.id +-- +ok +== +SELECT * +FROM + (SELECT * FROM three WHERE a % 2 = 1) t1 + POSITIONAL JOIN + (SELECT * FROM two WHERE a % 2 = 0) t2 +-- +ok +== +SELECT * +FROM + (SELECT * FROM two WHERE a % 2 = 0) t1 + POSITIONAL JOIN + (SELECT * FROM three WHERE a % 2 = 1) t2 +-- +ok +== +SELECT COUNT(t1.id), COUNT(t2.id) +FROM + (SELECT * FROM threek WHERE id % 2 = 0) t1 + POSITIONAL JOIN + (SELECT * FROM threek WHERE id % 3 = 0) t2 +-- +ok +== +SELECT COUNT(t1.id), COUNT(t2.id) +FROM + (SELECT * FROM threek WHERE id % 3 = 0) t2 + POSITIONAL JOIN + (SELECT * FROM threek WHERE id % 2 = 0) t1 +-- +ok +== diff --git a/parser/testdata/corpus/sql/join/pushdown/pushdown_generated_columns.test b/parser/testdata/corpus/sql/join/pushdown/pushdown_generated_columns.test new file mode 100644 index 0000000..c96ad12 --- /dev/null +++ b/parser/testdata/corpus/sql/join/pushdown/pushdown_generated_columns.test @@ -0,0 +1,17 @@ +# source: test/sql/join/pushdown/pushdown_generated_columns.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +INSERT INTO unit2 SELECT i, 20 FROM range(1000) t(i); +-- +ok +== +SELECT * FROM unit2 JOIN (VALUES (2000)) t(total_profit) USING (total_profit); +-- +ok +== +SELECT * FROM unit2 JOIN (VALUES (2000)) t(total_profit) ON (t.total_profit = unit2.total_profit AND t.total_profit=unit2.also_total_profit); +-- +ok +== diff --git a/parser/testdata/corpus/sql/join/pushdown/pushdown_join_types.test b/parser/testdata/corpus/sql/join/pushdown/pushdown_join_types.test new file mode 100644 index 0000000..420ccea --- /dev/null +++ b/parser/testdata/corpus/sql/join/pushdown/pushdown_join_types.test @@ -0,0 +1,46 @@ +# source: test/sql/join/pushdown/pushdown_join_types.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +CREATE TABLE integers AS SELECT CASE WHEN i%2=0 THEN NULL ELSE i END i FROM range(1000) t(i) +-- +ok +== +SELECT * FROM integers JOIN (SELECT MAX(i) AS max_i FROM integers) ON i=max_i +-- +ok +== +SELECT * FROM integers RIGHT JOIN (SELECT MAX(i) AS max_i FROM integers) ON i=max_i +-- +ok +== +SELECT COUNT(*), COUNT(max_i) IS NOT NULL FROM ( +SELECT * FROM integers LEFT JOIN (SELECT MAX(i) AS max_i FROM integers) ON i=max_i +) +-- +ok +== +SELECT COUNT(*), COUNT(max_i) IS NOT NULL FROM ( +SELECT * FROM integers FULL OUTER JOIN (SELECT MAX(i) AS max_i FROM integers) ON i=max_i +) +-- +ok +== +SELECT * FROM integers WHERE i=(SELECT MAX(i) FROM integers) +-- +ok +== +SELECT * FROM integers WHERE i IN (SELECT MAX(i) FROM integers) +-- +ok +== +SELECT * FROM integers WHERE i IN (997, 999) +-- +ok +== +SELECT COUNT(*), SUM(CASE WHEN in_result THEN 1 ELSE 0 END) FROM +(SELECT i IN (SELECT MAX(i) FROM integers) AS in_result FROM integers) +-- +ok +== diff --git a/parser/testdata/corpus/sql/join/pushdown/pushdown_many_joins.test b/parser/testdata/corpus/sql/join/pushdown/pushdown_many_joins.test new file mode 100644 index 0000000..e14f014 --- /dev/null +++ b/parser/testdata/corpus/sql/join/pushdown/pushdown_many_joins.test @@ -0,0 +1,37 @@ +# source: test/sql/join/pushdown/pushdown_many_joins.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +CREATE TABLE bigtbl AS SELECT i%2 AS small_key, i%10 AS medium_key, i AS val FROM range(10000) t(i) ORDER BY small_key, medium_key +-- +ok +== +CREATE TABLE smalltbl AS SELECT i small_key FROM range(2) t(i) +-- +ok +== +CREATE TABLE mediumtbl AS SELECT i medium_key FROM range(10) t(i) +-- +ok +== +SELECT COUNT(*) FROM bigtbl JOIN smalltbl USING (small_key) JOIN mediumtbl USING (medium_key) +-- +ok +== +SELECT COUNT(*) FROM bigtbl JOIN (FROM smalltbl WHERE small_key=1) smalltbl USING (small_key) JOIN mediumtbl USING (medium_key) +-- +ok +== +SELECT COUNT(*) FROM bigtbl JOIN smalltbl USING (small_key) JOIN (FROM mediumtbl WHERE medium_key=1) mediumtbl USING (medium_key) +-- +ok +== +SELECT COUNT(*) FROM bigtbl JOIN (FROM smalltbl WHERE small_key=1) smalltbl USING (small_key) JOIN (FROM mediumtbl WHERE medium_key=1) mediumtbl USING (medium_key) +-- +ok +== +SELECT COUNT(*) FROM bigtbl JOIN (FROM smalltbl WHERE small_key=1) smalltbl USING (small_key) JOIN (FROM mediumtbl WHERE medium_key=1) mediumtbl ON (mediumtbl.medium_key=smalltbl.small_key) +-- +ok +== diff --git a/parser/testdata/corpus/sql/join/right_outer/right_join_complex_null.test b/parser/testdata/corpus/sql/join/right_outer/right_join_complex_null.test new file mode 100644 index 0000000..10d69c9 --- /dev/null +++ b/parser/testdata/corpus/sql/join/right_outer/right_join_complex_null.test @@ -0,0 +1,37 @@ +# source: test/sql/join/right_outer/right_join_complex_null.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +CREATE TABLE t0(c0 DATE, PRIMARY KEY(c0)); +-- +ok +== +CREATE TABLE t1(c0 VARCHAR DEFAULT(DATE '1969-12-10'), c1 DOUBLE DEFAULT(0.16338108651823613)); +-- +ok +== +INSERT INTO t1(c1) VALUES (true); +-- +ok +== +INSERT INTO t1(c0) VALUES (TIMESTAMP '1969-12-13 07:02:08'); +-- +ok +== +INSERT INTO t0(c0) VALUES (DATE '1970-01-01'), (TIMESTAMP '1969-12-13 17:49:43'); +-- +ok +== +SELECT MAX('a') FROM t0 JOIN t1 ON ((t0.c0)<=(((NULL)-(t1.rowid))::DATE)); +-- +ok +== +SELECT MAX('a') FROM t0 RIGHT JOIN t1 ON ((t0.c0)<=(((NULL)-(t1.rowid))::DATE)); +-- +ok +== +SELECT MAX(agg0) FROM (SELECT MAX('a') AS agg0 FROM t0 RIGHT JOIN t1 ON ((t0.c0)<=(((NULL)-(t1.rowid)))) WHERE t1.c0 UNION ALL SELECT MAX('a') AS agg0 FROM t0 RIGHT JOIN t1 ON ((t0.c0)<=(((NULL)-(t1.rowid)))) WHERE (NOT t1.c0) UNION ALL SELECT MAX('a') AS agg0 FROM t0 RIGHT JOIN t1 ON ((t0.c0)<=(((NULL)-(t1.rowid)))) WHERE ((t1.c0) IS NULL)) as asdf; +-- +ok +== diff --git a/parser/testdata/corpus/sql/join/right_outer/test_right_join_filter_pushdown.test b/parser/testdata/corpus/sql/join/right_outer/test_right_join_filter_pushdown.test new file mode 100644 index 0000000..2f93db7 --- /dev/null +++ b/parser/testdata/corpus/sql/join/right_outer/test_right_join_filter_pushdown.test @@ -0,0 +1,51 @@ +# source: test/sql/join/right_outer/test_right_join_filter_pushdown.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +CREATE TABLE left_table (id INTEGER, val INTEGER); +-- +ok +== +INSERT INTO left_table VALUES (1, 1), (2, 1), (3, 2); +-- +ok +== +CREATE TABLE right_table (id INTEGER, category INTEGER); +-- +ok +== +INSERT INTO right_table VALUES (1, 1), (2, 2), (3, 1), (4, 1); +-- +ok +== +SELECT * FROM left_table l +RIGHT JOIN right_table r ON l.id = r.id AND l.val > 1 AND r.category = 1; +-- +ok +== +SELECT * FROM left_table l +RIGHT JOIN right_table r ON l.id = r.id AND r.category = 1; +-- +ok +== +SELECT * FROM left_table l +RIGHT JOIN right_table r ON l.id = r.id AND l.val > 1; +-- +ok +== +SELECT * FROM left_table l +RIGHT JOIN right_table r ON l.id = r.id AND true; +-- +ok +== +SELECT * FROM left_table l +RIGHT JOIN right_table r ON l.id = r.id AND false; +-- +ok +== +SELECT * FROM left_table l +RIGHT JOIN right_table r ON l.id = r.id AND l.val + r.category > 2; +-- +ok +== diff --git a/parser/testdata/corpus/sql/join/right_outer/test_right_outer.test b/parser/testdata/corpus/sql/join/right_outer/test_right_outer.test new file mode 100644 index 0000000..3580592 --- /dev/null +++ b/parser/testdata/corpus/sql/join/right_outer/test_right_outer.test @@ -0,0 +1,73 @@ +# source: test/sql/join/right_outer/test_right_outer.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +SELECT integers.*, integers2.* FROM integers2 RIGHT OUTER JOIN integers ON integers.i=integers2.k ORDER BY i +-- +ok +== +SELECT integers.*, integers2.* FROM integers2 RIGHT OUTER JOIN integers ON integers.i=integers2.k WHERE k IS NOT NULL ORDER BY i +-- +ok +== +SELECT integers.*, integers2.* FROM integers2 RIGHT OUTER JOIN integers ON integers.i=integers2.k AND integers2.k IS NOT NULL ORDER BY i +-- +ok +== +SELECT integers.*, integers2.* FROM integers2 RIGHT OUTER JOIN integers ON i=1 ORDER BY i, k; +-- +ok +== +SELECT integers.*, integers2.* FROM integers2 RIGHT OUTER JOIN integers ON 1=1 ORDER BY i, k; +-- +ok +== +SELECT integers.*, integers2.* FROM integers2 RIGHT OUTER JOIN integers ON 1=2 ORDER BY i; +-- +ok +== +SELECT integers.*, integers2.* FROM integers2 RIGHT OUTER JOIN integers ON NULL<>NULL ORDER BY i; +-- +ok +== +SELECT integers.*, integers2.* FROM integers2 RIGHT OUTER JOIN integers ON l=20 ORDER BY i, k; +-- +ok +== +SELECT integers.*, integers2.* FROM integers2 RIGHT OUTER JOIN integers ON l>0 ORDER BY i, k; +-- +ok +== +SELECT integers.*, integers2.* FROM integers2 RIGHT OUTER JOIN integers ON i=1 OR l=20 ORDER BY i, k; +-- +ok +== +SELECT integers.*, integers2.* FROM integers2 RIGHT OUTER JOIN integers ON i=4 OR l=17 ORDER BY i; +-- +ok +== +SELECT integers.*, integers2.* FROM integers2 RIGHT OUTER JOIN integers ON i+l=21 ORDER BY i; +-- +ok +== +SELECT integers.*, integers2.* FROM integers2 RIGHT OUTER JOIN integers ON i+l>12 ORDER BY i, k; +-- +ok +== +SELECT integers.*, integers2.* FROM integers2 RIGHT OUTER JOIN integers ON integers.i 5; +-- +ok +== +SELECT * FROM left_table ANTI JOIN right_table ON ([left_table.a, left_table.b] = [right_table.a, right_table.b]); +-- +ok +== +SELECT * FROM left_table ANTI JOIN (SELECT a as foo from right_table where b = 1) buzz ON left_table.a = buzz.foo +-- +ok +== +SELECT * FROM left_table ANTI JOIN right_table ON left_table.a = right_table.a WHERE right_table.a < 43; +-- +ok +== +INSERT INTO left_table VALUES (43, 1, 5), (43, 1, 5), (43, 1, 5), (43, 1, 5); +-- +ok +== +SELECT * FROM left_table ANTI JOIN right_table ON (left_table.a = right_table.a); +-- +ok +== +CREATE TABLE other (a INTEGER, b INTEGER); +-- +ok +== +INSERT INTO other VALUES (42, 1), (43, 1); +-- +ok +== +SELECT * FROM left_table +ANTI JOIN (select right_table.a FROM right_table JOIN other ON (other.a = right_table.a)) joined_right_table +ON left_table.a = joined_right_table.a; +-- +ok +== +DELETE FROM left_table where c=5; +-- +ok +== +SELECT * FROM left_table ANTI JOIN right_table USING (a); +-- +ok +== +SELECT * FROM left_table NATURAL ANTI JOIN right_table; +-- +ok +== +SELECT * FROM left_table +NATURAL ANTI JOIN (select right_table.a FROM right_table JOIN other ON (other.a = right_table.a)) joined_right_table; +-- +ok +== +SELECT * FROM left_table ANTI JOIN right_table ON (left_table.a <> right_table.a) ORDER BY a, c; +-- +ok +== +SELECT * FROM left_table ANTI JOIN right_table ON (left_table.a > right_table.a); +-- +ok +== +SELECT * from left_table, right_table; +-- +ok +== +SELECT * FROM left_table ANTI JOIN right_table ON (left_table.a + right_table.a = 85 OR left_table.a + right_table.b = 84) order by left_table.a, left_table.c; +-- +ok +== +INSERT INTO right_table VALUES (1, 42), (1, 42); +-- +ok +== +INSERT INTO left_table VALUES (42, 1, 5), (42, 1, 5), (42, 1, 5), (2000, 20000, 200000); +-- +ok +== +SELECT a as outer_a, (SELECT MAX(right_table.b) FROM right_table where right_table.a != outer_a) right_table_b FROM left_table ANTI JOIN right_table ON (left_table.a = right_table.a) Order by outer_a, right_table_b; +-- +ok +== +INSERT INTO right_table VALUES (1, 20); +-- +ok +== +SELECT a as outer_a, (SELECT MAX(b) FROM right_table where right_table.a != outer_a) right_table_b FROM left_table ANTI JOIN right_table ON (left_table.a = right_table.a) Order by outer_a, right_table_b; +-- +ok +== +SELECT a as outer_a, (SELECT b FROM right_table where right_table.a != outer_a) right_table_b FROM left_table ANTI JOIN right_table ON (left_table.a = right_table.a) Order by outer_a, right_table_b; +-- +ok +== diff --git a/parser/testdata/corpus/sql/join/semianti/mix_equality_inequality.test b/parser/testdata/corpus/sql/join/semianti/mix_equality_inequality.test new file mode 100644 index 0000000..839638f --- /dev/null +++ b/parser/testdata/corpus/sql/join/semianti/mix_equality_inequality.test @@ -0,0 +1,49 @@ +# source: test/sql/join/semianti/mix_equality_inequality.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +WITH cte1 AS MATERIALIZED ( + SELECT + 'col1' AS col1, + UNNEST( + [TIMESTAMPTZ '2025-01-01 00:00:11+00', TIMESTAMPTZ '2025-01-01 00:00:41+00'] + ) AS col2 +), +cte2 AS ( + SELECT + 'col1' AS col1, + TIMESTAMPTZ '2025-01-01 00:00:40+00' AS col2, + 'col3' AS col3, +) +SELECT + * +FROM + cte1 ANTI + JOIN cte2 ON cte1.col1 = cte2.col1 + AND cte1.col2 > cte2.col2; +-- +ok +== +WITH cte1 AS MATERIALIZED ( + SELECT + 'col1' AS col1, + UNNEST( + [TIMESTAMPTZ '2025-01-01 00:00:11+00', TIMESTAMPTZ '2025-01-01 00:00:41+00'] + ) AS col2 +), +cte2 AS ( + SELECT + 'col1' AS col1, + TIMESTAMPTZ '2025-01-01 00:00:40+00' AS col2, + 'col3' AS col3, +) +SELECT + * +FROM + cte1 SEMI + JOIN cte2 ON cte1.col1 = cte2.col1 + AND cte1.col2 > cte2.col2; +-- +ok +== diff --git a/parser/testdata/corpus/sql/join/semianti/plan_blockwise_NL_join_with_mutliple_conditions.test b/parser/testdata/corpus/sql/join/semianti/plan_blockwise_NL_join_with_mutliple_conditions.test new file mode 100644 index 0000000..967f694 --- /dev/null +++ b/parser/testdata/corpus/sql/join/semianti/plan_blockwise_NL_join_with_mutliple_conditions.test @@ -0,0 +1,63 @@ +# source: test/sql/join/semianti/plan_blockwise_NL_join_with_mutliple_conditions.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +create table t1 as select * from values (1, 2), (2, 4), (3, 8), (6, 25), (1, 25) t(a, b); +-- +ok +== +create table t2 as select * from values (4), (5) t(b); +-- +ok +== +select * from t1 semi join t2 on t1.a < t2.b and t1.b > t2.b order by all; +-- +ok +== +select * from t1 anti join t2 on t1.a < t2.b and t1.b < t2.b order by all; +-- +ok +== +Explain select * from t1 anti join t2 on t1.a < t2.b and t1.b < t2.b order by all; +-- +ok +== +select * from t1 semi join t2 on t1.a < t2.b or t1.b < t2.b order by all; +-- +ok +== +select * from t1 semi join t2 on (t1.a < t2.b and t1.b < t2.b) or (t1.a < t2.b and t1.b = 4) order by all; +-- +ok +== +select * from t1 semi join t2 on (t1.a < t2.b or t1.b < t2.b) and (t1.a = 1 or t1.b = 4) order by all; +-- +ok +== +CREATE TABLE flattened ("start" varchar, "end" varchar); +-- +ok +== +insert into flattened values ('2023-03-15T00:00:00Z', '2023-03-20T00:00:00Z'); +-- +ok +== +create table input_table as select * from VALUES +('1', '2023-03-14T00:00:00Z', 2), +('2', '2023-03-15T00:00:00Z', 4), +('3', '2023-03-16T00:00:00Z', 7), +('4', '2023-03-17T00:00:00Z', 3), +('5', '2023-03-18T00:00:00Z', 2), +('6', '2023-03-19T23:59:59Z', 4), +('7', '2023-03-20T00:00:00Z', 7), +('8', '2023-03-21T00:00:00Z', 3) t(user_id, timestamp, value); +-- +ok +== +SELECT * FROM input_table +ANTI JOIN flattened +ON input_table."timestamp" >= flattened.start AND input_table."timestamp" < flattened.end; +-- +ok +== diff --git a/parser/testdata/corpus/sql/join/semianti/right_anti.test b/parser/testdata/corpus/sql/join/semianti/right_anti.test new file mode 100644 index 0000000..9d015a9 --- /dev/null +++ b/parser/testdata/corpus/sql/join/semianti/right_anti.test @@ -0,0 +1,80 @@ +# source: test/sql/join/semianti/right_anti.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +SET profiling_renderer_settings = MAP {'expand_all': 'true'}; +-- +ok +== +INSERT INTO left_table VALUES (42, 1, 1), (43, 1, 1), (42, 1, 1), (41, 1, 1), (41, 2, 2), (41, 7, 7); +-- +ok +== +INSERT INTO right_table select 41, range as b from range(375); +-- +ok +== +EXPLAIN ANALYZE SELECT * FROM left_table ANTI JOIN right_table ON left_table.a = right_table.a; +-- +ok +== +explain analyze SELECT * FROM left_table ANTI JOIN right_table ON left_table.a = right_table.a WHERE a > 5; +-- +ok +== +explain analyze SELECT * FROM left_table ANTI JOIN right_table ON ([left_table.a, left_table.b] = [right_table.a, right_table.b]); +-- +ok +== +explain analyze SELECT * FROM left_table ANTI JOIN (SELECT a as foo from right_table where b > 5) buzz ON left_table.a = buzz.foo +-- +ok +== +EXPLAIN ANALYZE SELECT * FROM left_table +ANTI JOIN (select right_table.a FROM right_table JOIN other ON (other.a = right_table.a)) joined_right_table +ON left_table.a = joined_right_table.a; +-- +ok +== +EXPLAIN ANALYZE SELECT * FROM left_table ANTI JOIN right_table USING (a); +-- +ok +== +explain analyze SELECT * FROM left_table NATURAL ANTI JOIN right_table; +-- +ok +== +EXPLAIN ANALYZE SELECT * FROM left_table +NATURAL ANTI JOIN (select right_table.a FROM right_table JOIN other ON (other.a = right_table.a)) joined_right_table; +-- +ok +== +EXPLAIN ANALYZE SELECT * FROM left_table ANTI JOIN right_table ON (left_table.a <> right_table.a) ORDER BY a, c; +-- +ok +== +EXPLAIN ANALYZE SELECT * FROM left_table ANTI JOIN right_table ON (left_table.a > right_table.a); +-- +ok +== +explain analyze SELECT * FROM left_table ANTI JOIN right_table ON (left_table.a + right_table.a = 85 OR left_table.a + right_table.b = 84) order by left_table.a, left_table.c; +-- +ok +== +explain analyze SELECT a as outer_a, (SELECT MAX(right_table.b) FROM right_table where right_table.a != outer_a) right_table_b FROM left_table ANTI JOIN right_table ON (left_table.a = right_table.a) Order by outer_a, right_table_b; +-- +ok +== +explain analyze SELECT a as outer_a, (SELECT MAX(b) FROM right_table where right_table.a != outer_a) right_table_b FROM left_table ANTI JOIN right_table ON (left_table.a = right_table.a) Order by outer_a, right_table_b; +-- +ok +== +explain analyze SELECT a as outer_a, (SELECT right_table.b FROM right_table where right_table.a != outer_a) right_table_b FROM left_table ANTI JOIN right_table ON (left_table.a = right_table.a) Order by outer_a, right_table_b; +-- +ok +== +explain analyze SELECT a as outer_a, (SELECT b FROM right_table where right_table.a != outer_a) right_table_b FROM left_table ANTI JOIN right_table ON (left_table.a = right_table.a) Order by outer_a, right_table_b; +-- +ok +== diff --git a/parser/testdata/corpus/sql/join/semianti/right_semi.test b/parser/testdata/corpus/sql/join/semianti/right_semi.test new file mode 100644 index 0000000..4c83358 --- /dev/null +++ b/parser/testdata/corpus/sql/join/semianti/right_semi.test @@ -0,0 +1,72 @@ +# source: test/sql/join/semianti/right_semi.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +INSERT INTO left_table VALUES (41, 1, 1), (42, 1, 1), (42, 1, 1), (43, 1, 1), (45, 2, 2), (46, 7, 7); +-- +ok +== +EXPLAIN ANALYZE SELECT * FROM left_table SEMI JOIN right_table ON left_table.a = right_table.a; +-- +ok +== +explain analyze SELECT * FROM left_table SEMI JOIN right_table ON left_table.a = right_table.a WHERE a > 5; +-- +ok +== +explain analyze SELECT * FROM left_table SEMI JOIN right_table ON ([left_table.a, left_table.b] = [right_table.a, right_table.b]); +-- +ok +== +explain analyze SELECT * FROM left_table SEMI JOIN (SELECT a as foo from right_table where b > 1) buzz ON left_table.a = buzz.foo +-- +ok +== +EXPLAIN ANALYZE SELECT * FROM left_table +SEMI JOIN (select right_table.a FROM right_table JOIN other ON (other.a = right_table.a)) joined_right_table +ON left_table.a = joined_right_table.a; +-- +ok +== +EXPLAIN ANALYZE SELECT * FROM left_table SEMI JOIN right_table USING (a); +-- +ok +== +explain analyze SELECT * FROM left_table NATURAL SEMI JOIN right_table; +-- +ok +== +EXPLAIN ANALYZE SELECT * FROM left_table +NATURAL SEMI JOIN (select right_table.a FROM right_table JOIN other ON (other.a = right_table.a)) joined_right_table; +-- +ok +== +EXPLAIN ANALYZE SELECT * FROM left_table SEMI JOIN right_table ON (left_table.a <> right_table.a) ORDER BY a, c; +-- +ok +== +EXPLAIN ANALYZE SELECT * FROM left_table SEMI JOIN right_table ON (left_table.a > right_table.a); +-- +ok +== +explain analyze SELECT * FROM left_table SEMI JOIN right_table ON (left_table.a + right_table.a = 85 OR left_table.a + right_table.b = 84) order by left_table.a, left_table.c; +-- +ok +== +explain analyze SELECT a as outer_a, (SELECT MAX(right_table.b) FROM right_table where right_table.a != outer_a) right_table_b FROM left_table SEMI JOIN right_table ON (left_table.a = right_table.a) Order by outer_a, right_table_b; +-- +ok +== +explain analyze SELECT a as outer_a, (SELECT MAX(b) FROM right_table where right_table.a != outer_a) right_table_b FROM left_table SEMI JOIN right_table ON (left_table.a = right_table.a) Order by outer_a, right_table_b; +-- +ok +== +explain analyze SELECT a as outer_a, (SELECT right_table.b FROM right_table where right_table.a != outer_a) right_table_b FROM left_table SEMI JOIN right_table ON (left_table.a = right_table.a) Order by outer_a, right_table_b; +-- +ok +== +explain analyze SELECT a as outer_a, (SELECT b FROM right_table where right_table.a != outer_a) right_table_b FROM left_table SEMI JOIN right_table ON (left_table.a = right_table.a) Order by outer_a, right_table_b; +-- +ok +== diff --git a/parser/testdata/corpus/sql/join/semianti/semijoin.test b/parser/testdata/corpus/sql/join/semianti/semijoin.test new file mode 100644 index 0000000..004bebb --- /dev/null +++ b/parser/testdata/corpus/sql/join/semianti/semijoin.test @@ -0,0 +1,76 @@ +# source: test/sql/join/semianti/semijoin.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +SELECT * FROM left_table SEMI JOIN right_table ON left_table.a = right_table.a; +-- +ok +== +SELECT * FROM left_table SEMI JOIN right_table ON left_table.a = right_table.a WHERE a > 5; +-- +ok +== +SELECT * FROM left_table SEMI JOIN right_table ON ([left_table.a, left_table.b] = [right_table.a, right_table.b]); +-- +ok +== +SELECT * FROM left_table SEMI JOIN (SELECT a as foo from right_table where b = 1) buzz ON left_table.a = buzz.foo +-- +ok +== +SELECT * FROM left_table SEMI JOIN right_table ON left_table.a = right_table.a WHERE right_table.a < 43; +-- +ok +== +INSERT INTO left_table VALUES (42, 1, 5), (42, 1, 5), (42, 1, 5), (42, 1, 5); +-- +ok +== +SELECT * FROM left_table SEMI JOIN right_table ON (left_table.a = right_table.a); +-- +ok +== +SELECT * FROM left_table +SEMI JOIN (select right_table.a FROM right_table JOIN other ON (other.a = right_table.a)) joined_right_table +ON left_table.a = joined_right_table.a; +-- +ok +== +SELECT * FROM left_table SEMI JOIN right_table USING (a); +-- +ok +== +SELECT * FROM left_table NATURAL SEMI JOIN right_table; +-- +ok +== +SELECT * FROM left_table +NATURAL SEMI JOIN (select right_table.a FROM right_table JOIN other ON (other.a = right_table.a)) joined_right_table; +-- +ok +== +SELECT * FROM left_table SEMI JOIN right_table ON (left_table.a <> right_table.a) ORDER BY a, c; +-- +ok +== +SELECT * FROM left_table SEMI JOIN right_table ON (left_table.a > right_table.a); +-- +ok +== +SELECT * FROM left_table SEMI JOIN right_table ON (left_table.a + right_table.a = 85 OR left_table.a + right_table.b = 84) order by left_table.a, left_table.c; +-- +ok +== +SELECT * FROM left_table SEMI JOIN right_table ON ((left_table.a = NULL AND right_table.a = NULL) OR left_table.a = right_table.a) order by left_table.a, left_table.c; +-- +ok +== +SELECT a as outer_a, (SELECT ANY_VALUE(b) FROM right_table where right_table.a != outer_a) right_table_b FROM left_table SEMI JOIN right_table ON (left_table.a = right_table.a) Order by outer_a, right_table_b; +-- +ok +== +SELECT a as outer_a, (SELECT b FROM right_table where right_table.a != outer_a) right_table_b FROM left_table SEMI JOIN right_table ON (left_table.a = right_table.a) Order by outer_a, right_table_b; +-- +ok +== diff --git a/parser/testdata/corpus/sql/join/semianti/test_semianti_join_filter_pushdown.test b/parser/testdata/corpus/sql/join/semianti/test_semianti_join_filter_pushdown.test new file mode 100644 index 0000000..09db8f6 --- /dev/null +++ b/parser/testdata/corpus/sql/join/semianti/test_semianti_join_filter_pushdown.test @@ -0,0 +1,59 @@ +# source: test/sql/join/semianti/test_semianti_join_filter_pushdown.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +CREATE TABLE empty_table (id INTEGER, category INTEGER); +-- +ok +== +SELECT * FROM left_table l +SEMI JOIN right_table r ON l.id = r.id AND l.val > 1 AND r.category = 1; +-- +ok +== +SELECT * FROM left_table l +SEMI JOIN right_table r ON l.id = r.id AND r.category = 1; +-- +ok +== +SELECT * FROM left_table l +SEMI JOIN right_table r ON l.id = r.id AND l.val > 1; +-- +ok +== +SELECT * FROM left_table l +SEMI JOIN empty_table e ON l.id = e.id; +-- +ok +== +SELECT * FROM left_table l +ANTI JOIN right_table r ON l.id = r.id AND l.val > 1 AND r.category = 1; +-- +ok +== +SELECT * FROM left_table l +ANTI JOIN right_table r ON l.id = r.id AND r.category = 1; +-- +ok +== +SELECT * FROM left_table l +ANTI JOIN right_table r ON l.id = r.id AND l.val = 1; +-- +ok +== +SELECT * FROM left_table l +ANTI JOIN empty_table e ON l.id = e.id; +-- +ok +== +SELECT * FROM left_table l +SEMI JOIN right_table r ON l.id = r.id AND l.amount + r.budget > 1100; +-- +ok +== +SELECT * FROM left_table l +ANTI JOIN right_table r ON l.id = r.id AND l.amount + r.budget > 1100; +-- +ok +== diff --git a/parser/testdata/corpus/sql/join/semianti/test_simple_anti_join.test b/parser/testdata/corpus/sql/join/semianti/test_simple_anti_join.test new file mode 100644 index 0000000..ce5408d --- /dev/null +++ b/parser/testdata/corpus/sql/join/semianti/test_simple_anti_join.test @@ -0,0 +1,46 @@ +# source: test/sql/join/semianti/test_simple_anti_join.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +CREATE TABLE t1(c1 VARCHAR); +-- +ok +== +INSERT INTO t1(c1) VALUES (NULL); +-- +ok +== +select * FROM t1 WHERE NOT EXISTS (SELECT 1 FROM t0 WHERE null); +-- +ok +== +select * FROM t1 WHERE EXISTS (SELECT 1 FROM t0 WHERE ((t0.c0) != (t1.c1))); +-- +ok +== +select * FROM t1 WHERE NOT EXISTS (SELECT 1 FROM t0 WHERE ((t0.c0)!=(t1.c1))); -- wrong, no row +-- +ok +== +create table lineitem (l_orderkey int, l_suppkey int, l_partkey int); +-- +ok +== +insert into lineitem values (1,1,42),(1,2,43),(3,3,44),(4,5,45),(5,5,46),(6,5,47); +-- +ok +== +select * from lineitem l1 where exists ( + select * from lineitem l2 + where + l2.l_orderkey = l1.l_orderkey + and l2.l_suppkey <> l1.l_suppkey +); +-- +ok +== +select c0, EXISTS (select * from t1 where c1 != c0) from t0; +-- +ok +== diff --git a/parser/testdata/corpus/sql/join/set_operators/test_set_operator_reordering_with_delim_joins.test b/parser/testdata/corpus/sql/join/set_operators/test_set_operator_reordering_with_delim_joins.test new file mode 100644 index 0000000..9e8ecf6 --- /dev/null +++ b/parser/testdata/corpus/sql/join/set_operators/test_set_operator_reordering_with_delim_joins.test @@ -0,0 +1,24 @@ +# source: test/sql/join/set_operators/test_set_operator_reordering_with_delim_joins.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +create or replace table xx as select w from (values ('a'),('b'),('c'),('d'),('e')) t(w); +-- +ok +== +select w from (from xx limit 4) +CROSS JOIN (select 1 as f1) p +WHERE + w IN ( + SELECT 'a' + UNION -- with 'UNION ALL' it works also using 'limit 4' + SELECT 'b' + UNION + SELECT 'c' WHERE p.f1 = 1 + UNION + SELECT 'd' WHERE p.f1 = 1 +); +-- +ok +== diff --git a/parser/testdata/corpus/sql/join/test_complex_join_expr.test b/parser/testdata/corpus/sql/join/test_complex_join_expr.test new file mode 100644 index 0000000..e17b6d1 --- /dev/null +++ b/parser/testdata/corpus/sql/join/test_complex_join_expr.test @@ -0,0 +1,29 @@ +# source: test/sql/join/test_complex_join_expr.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +INSERT INTO test VALUES (4, 1), (2, 2) +-- +ok +== +INSERT INTO test2 VALUES (1, 2), (3, 0) +-- +ok +== +SELECT * FROM test JOIN test2 ON test.a+test2.c=test.b+test2.b +-- +ok +== +SELECT * FROM test LEFT JOIN test2 ON test.a+test2.c=test.b+test2.b ORDER BY 1 +-- +ok +== +SELECT * FROM test RIGHT JOIN test2 ON test.a+test2.c=test.b+test2.b ORDER BY 1 +-- +ok +== +SELECT * FROM test FULL OUTER JOIN test2 ON test.a+test2.c=test.b+test2.b ORDER BY 1 +-- +ok +== diff --git a/parser/testdata/corpus/sql/join/test_complex_range_join.test b/parser/testdata/corpus/sql/join/test_complex_range_join.test new file mode 100644 index 0000000..1b8d341 --- /dev/null +++ b/parser/testdata/corpus/sql/join/test_complex_range_join.test @@ -0,0 +1,188 @@ +# source: test/sql/join/test_complex_range_join.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +WITH lhs(i, j, k) AS (VALUES + (100, 10, 1), + (200, 20, 2) +), +rhs(p, q, r) AS (VALUES + (100, 10, 1), + (200, 20, 2) +) +SELECT lhs.*, rhs.* +FROM lhs, rhs +WHERE i <= p AND j <> q AND k IS DISTINCT FROM r +-- +ok +== +WITH lhs(i, j, k) AS (VALUES + (100, 10, 1), + (200, 20, 2) +), +rhs(p, q, r) AS (VALUES + (100, 10, 1), + (200, 20, 2) +) +SELECT lhs.*, rhs.* +FROM lhs, rhs +WHERE i <= p AND k >= r AND j <= q +ORDER BY i +-- +ok +== +CREATE TABLE wide AS ( + SELECT + i, + 10 * (i + 0) AS c0, + 10 * (i + 1) AS c1, + 10 * (i + 2) AS c2, + 10 * (i + 3) AS c3, + 10 * (i + 4) AS c4, + 10 * (i + 5) AS c5, + 10 * (i + 6) AS c6, + 10 * (i + 7) AS c7, + 10 * (i + 8) AS c8, + 10 * (i + 9) AS c9 + FROM range(1, 10) tbl(i) +); +-- +ok +== +SELECT * FROM wide; +-- +ok +== +CREATE TABLE limits AS ( + SELECT 100 + (i * 17 % 100) AS z + FROM range(1, 10) tbl(i) +); +-- +ok +== +SELECT z FROM limits; +-- +ok +== +SELECT i, z +FROM wide, limits +WHERE c0 < z + AND c1 < z + AND c2 < z + AND c3 < z + AND c4 < z + AND c5 < z + AND c6 < z + AND c7 < z + AND c8 < z + AND c9 < z +ORDER BY 1, 2 +-- +ok +== +CREATE TABLE wide_nulls AS ( + SELECT i, c0, c1, c2, + CASE WHEN i % 7 = 0 THEN NULL ELSE c3 END AS c3, + c4, c5, c6, c7, + CASE WHEN i % 5 = 0 THEN NULL ELSE c8 END AS c8, + c9 + FROM wide +); +-- +ok +== +SELECT * FROM wide_nulls; +-- +ok +== +CREATE TABLE limits_nulls AS ( + SELECT CASE WHEN z % 9 = 0 THEN NULL ELSE z END AS z + FROM limits +); +-- +ok +== +SELECT * FROM limits_nulls; +-- +ok +== +SELECT i, z +FROM wide_nulls, limits_nulls +WHERE c0 < z + AND c1 < z + AND c2 < z + AND c3 < z + AND c4 < z + AND c5 < z + AND c6 < z + AND c7 < z + AND c8 < z + AND c9 < z +ORDER BY 1, 2 +-- +ok +== +SELECT i, z +FROM wide, limits +WHERE z BETWEEN c8 AND c9 +ORDER BY 1, 2; +-- +ok +== +SELECT i, z +FROM wide_nulls, limits_nulls +WHERE z BETWEEN c8 AND c9 +ORDER BY 1, 2; +-- +ok +== +SELECT i, z +FROM wide, limits +WHERE z NOT BETWEEN c8 AND c9 +ORDER BY 1, 2; +-- +ok +== +SELECT i, z +FROM wide_nulls, limits_nulls +WHERE z NOT BETWEEN c8 AND c9 +ORDER BY 1, 2; +-- +ok +== +SELECT lhs.i, rhs.i +FROM wide_nulls lhs, wide_nulls rhs +WHERE lhs.c3 < rhs.c0 + AND lhs.c8 IS DISTINCT FROM rhs.c3 +ORDER BY 1, 2; +-- +ok +== +EXPLAIN +SELECT lhs.i, rhs.i +FROM wide_nulls lhs, wide_nulls rhs +WHERE lhs.c3 < rhs.c0 + AND lhs.c8 IS DISTINCT FROM rhs.c3 +ORDER BY 1, 2; +-- +ok +== +CREATE TABLE many_bounds AS ( + SELECT * FROM (VALUES (2000, 4000)) tbl(lo, hi) +); +-- +ok +== +CREATE TABLE many_values AS ( + SELECT * from range(10 * 1024) tbl(val) +); +-- +ok +== +SELECT COUNT(*) +FROM many_values, many_bounds +WHERE val BETWEEN lo AND hi; +-- +ok +== diff --git a/parser/testdata/corpus/sql/join/test_join_always_true_conditions.test b/parser/testdata/corpus/sql/join/test_join_always_true_conditions.test new file mode 100644 index 0000000..e2a1a91 --- /dev/null +++ b/parser/testdata/corpus/sql/join/test_join_always_true_conditions.test @@ -0,0 +1,76 @@ +# source: test/sql/join/test_join_always_true_conditions.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +INSERT INTO left_table VALUES (1, 10), (2, 20); +-- +ok +== +INSERT INTO right_table VALUES (1, 100), (2, 200); +-- +ok +== +SELECT * FROM left_table l +INNER JOIN right_table r ON TRUE; +-- +ok +== +SELECT * FROM left_table l +LEFT JOIN right_table r ON TRUE; +-- +ok +== +SELECT * FROM left_table l +RIGHT JOIN right_table r ON TRUE; +-- +ok +== +SELECT * FROM left_table l +FULL OUTER JOIN right_table r ON TRUE; +-- +ok +== +SELECT * FROM left_table l +SEMI JOIN right_table r ON TRUE; +-- +ok +== +SELECT * FROM left_table l +SEMI JOIN empty_table e ON TRUE; +-- +ok +== +SELECT * FROM left_table l +ANTI JOIN right_table r ON TRUE; +-- +ok +== +SELECT * FROM left_table l +ANTI JOIN empty_table e ON TRUE; +-- +ok +== +CREATE TABLE stats_table (category INTEGER, tag INTEGER); +-- +ok +== +INSERT INTO stats_table VALUES (100, 1); +-- +ok +== +SELECT * FROM left_table l +ANTI JOIN (SELECT * FROM stats_table WHERE tag % 7 = 3) e ON l.val <= e.category; +-- +ok +== +SELECT * FROM left_table l +JOIN (SELECT * FROM stats_table WHERE tag % 7 = 3) e ON l.val <= e.category; +-- +ok +== +SELECT * FROM left_table l +SEMI JOIN (SELECT * FROM stats_table WHERE tag % 7 = 3) e ON l.val <= e.category; +-- +ok +== diff --git a/parser/testdata/corpus/sql/join/test_join_by.test b/parser/testdata/corpus/sql/join/test_join_by.test new file mode 100644 index 0000000..0e6d4cf --- /dev/null +++ b/parser/testdata/corpus/sql/join/test_join_by.test @@ -0,0 +1,85 @@ +# source: test/sql/join/test_join_by.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +CREATE TABLE t1(a INTEGER); +-- +ok +== +INSERT INTO t1 VALUES (1), (2), (3), (NULL); +-- +ok +== +CREATE TABLE t2(b INTEGER); +-- +ok +== +INSERT INTO t2 VALUES (2), (3), (NULL); +-- +ok +== +SELECT a, __mark_join_marker FROM t1 JOIN BY (TYPE mark) t2 ON (a = b) ORDER BY a NULLS LAST; +-- +ok +== +SELECT a, a IN (SELECT b FROM t2) FROM t1 ORDER BY a NULLS LAST; +-- +ok +== +SELECT a FROM t1 JOIN BY (TYPE semi) t2 ON (a = b) ORDER BY a NULLS LAST; +-- +ok +== +SELECT a FROM t1 JOIN BY (TYPE anti) t2 ON (a = b) ORDER BY a NULLS LAST; +-- +ok +== +SELECT a, b FROM t1 JOIN BY (TYPE single) t2 ON (a = b) ORDER BY a NULLS LAST; +-- +ok +== +SELECT count(*) FROM t1 JOIN BY (TYPE inner) t2 ON (a = b); +-- +ok +== +SELECT count(*) FROM t1 JOIN BY (TYPE left) t2 ON (a = b); +-- +ok +== +SELECT count(*) FROM t1 JOIN BY (TYPE full) t2 ON (a = b); +-- +ok +== +SELECT a FROM t1 JOIN BY (TYPE SeMi) t2 ON (a = b) ORDER BY a NULLS LAST; +-- +ok +== +SELECT a, __mark_join_marker FROM t1 JOIN BY (TYPE mark_join) t2 ON (a = b) ORDER BY a NULLS LAST; +-- +ok +== +SELECT count(*) FROM t1 JOIN BY (TYPE semi) (SELECT b AS a FROM t2) USING (a); +-- +ok +== +SELECT * FROM t1 JOIN BY (TYPE bogus) t2 ON (a = b); +-- +ok +== +SELECT * FROM t1 JOIN BY (TYPE invalid) t2 ON (a = b); +-- +error: Parser Error: "invalid" is not a valid join type for JOIN BY +== +CREATE TABLE mark(mark INTEGER, single INTEGER); +-- +ok +== +INSERT INTO mark VALUES (1, 2); +-- +ok +== +SELECT mark, single FROM mark; +-- +ok +== diff --git a/parser/testdata/corpus/sql/join/test_join_by.test.metadata.json b/parser/testdata/corpus/sql/join/test_join_by.test.metadata.json new file mode 100644 index 0000000..5326472 --- /dev/null +++ b/parser/testdata/corpus/sql/join/test_join_by.test.metadata.json @@ -0,0 +1,5 @@ +{ + "todo": { + "08dbeb99d6085f3a": "transformer-raised parser error: upstream rejects in the transformer, not the grammar; expected to clear as transformers land (milestones 3-5)" + } +} diff --git a/parser/testdata/corpus/sql/join/test_join_on_aggregates.test b/parser/testdata/corpus/sql/join/test_join_on_aggregates.test new file mode 100644 index 0000000..b87f5cf --- /dev/null +++ b/parser/testdata/corpus/sql/join/test_join_on_aggregates.test @@ -0,0 +1,21 @@ +# source: test/sql/join/test_join_on_aggregates.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +SELECT * FROM (SELECT SUM(i) AS x FROM integers) a, (SELECT SUM(i) AS x FROM integers) b WHERE a.x=b.x; +-- +ok +== +CREATE TABLE groups(i INTEGER, j INTEGER) +-- +ok +== +INSERT INTO groups VALUES (1, 1), (2, 1), (3, 2), (NULL, 2) +-- +ok +== +SELECT a.j,a.x,a.y,b.y FROM (SELECT j, MIN(i) AS y, SUM(i) AS x FROM groups GROUP BY j) a, (SELECT j, MIN(i) AS y, SUM(i) AS x FROM groups GROUP BY j) b WHERE a.j=b.j AND a.x=b.x ORDER BY a.j; +-- +ok +== diff --git a/parser/testdata/corpus/sql/join/test_merge_join_predicate.test b/parser/testdata/corpus/sql/join/test_merge_join_predicate.test new file mode 100644 index 0000000..8637045 --- /dev/null +++ b/parser/testdata/corpus/sql/join/test_merge_join_predicate.test @@ -0,0 +1,71 @@ +# source: test/sql/join/test_merge_join_predicate.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +explain +select l.k100 as lid, r.k100 as rid +from tleft l +left join tleft r +on l.b100 < r.e100 +and l.k100 + r.k100 < 10 +order by 1 +-- +ok +== +select l.k100 as lid, r.k100 as rid +from tleft l +inner join tleft r +on l.b100 < r.e100 +and l.k100 + r.k100 < 10 +order by all +-- +ok +== +select l.k100 as lid, r.k100 as rid +from tleft l +left join tleft r +on l.b100 < r.e100 +and l.k100 + r.k100 < 10 +order by all +-- +ok +== +explain +select l.k100 as lid, r.k100 as rid +from tleft l +right join tleft r +on r.b100 < l.e100 +and l.k100 + r.k100 < 10 +order by 2 +-- +ok +== +select l.k100 as lid, r.k100 as rid +from tleft l +right join tleft r +on r.b100 < l.e100 +and l.k100 + r.k100 < 10 +order by 2, 1 +-- +ok +== +explain +select l.k100 as lid, r.k100 as rid +from tleft l +full join tleft r +on l.b100 < r.e100 +and l.k100 + r.k100 < 10 +order by all +-- +ok +== +select l.k100 as lid, r.k100 as rid +from tleft l +full join tleft r +on l.b100 < r.e100 +and l.k100 + r.k100 < 10 +order by all +-- +ok +== diff --git a/parser/testdata/corpus/sql/join/test_nested_inequality.test b/parser/testdata/corpus/sql/join/test_nested_inequality.test new file mode 100644 index 0000000..19c51eb --- /dev/null +++ b/parser/testdata/corpus/sql/join/test_nested_inequality.test @@ -0,0 +1,93 @@ +# source: test/sql/join/test_nested_inequality.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +CREATE VIEW list_int AS +SELECT i, i%2 as i2, [i, i + 1, i + 2] as l3 +FROM range(10) tbl(i); +-- +ok +== +select lhs.*, rhs.* +from list_int lhs, list_int rhs +where lhs.i2 = rhs.i2 and lhs.l3 <> rhs.l3 +order by lhs.i, rhs.i; +-- +ok +== +select lhs.*, rhs.* +from list_int lhs, list_int rhs +where lhs.i2 = rhs.i2 and lhs.l3 <= rhs.l3 +order by lhs.i, rhs.i; +-- +ok +== +select lhs.*, rhs.* +from list_int lhs, list_int rhs +where lhs.i2 = rhs.i2 and lhs.l3 < rhs.l3 +order by lhs.i, rhs.i; +-- +ok +== +select lhs.*, rhs.* +from list_int lhs, list_int rhs +where lhs.i2 = rhs.i2 and lhs.l3 >= rhs.l3 +order by lhs.i, rhs.i; +-- +ok +== +select lhs.*, rhs.* +from list_int lhs, list_int rhs +where lhs.i2 = rhs.i2 and lhs.l3 > rhs.l3 +order by lhs.i, rhs.i; +-- +ok +== +CREATE TABLE issue23927(s STRUCT(a INT)); +-- +ok +== +INSERT INTO issue23927 VALUES + ({'a': 1}), + ({'a': 2}), + (NULL), + (NULL), + ({'a': NULL}) +; +-- +ok +== +SELECT issue23927.s, sub0.s +FROM issue23927 +INNER JOIN issue23927 AS sub0 +ON (issue23927.s <= sub0.s) +ORDER BY ALL; +-- +ok +== +SELECT (issue23927.s < issue23927.s) +FROM issue23927 +INNER JOIN issue23927 AS sub0 +ON (issue23927.s <= sub0.s); +-- +ok +== +SELECT issue23927.s, sub0.s +FROM issue23927 +INNER JOIN issue23927 AS sub0 +ON (issue23927.s <= sub0.s) +WHERE NOT (issue23927.s < issue23927.s) +ORDER BY ALL; +-- +ok +== +SELECT issue23927.s, sub0.s +FROM issue23927 +INNER JOIN issue23927 AS sub0 +ON (issue23927.s <= sub0.s) +WHERE (issue23927.s < issue23927.s) IS NULL +ORDER BY ALL; +-- +ok +== diff --git a/parser/testdata/corpus/sql/join/test_predicate_binding.test b/parser/testdata/corpus/sql/join/test_predicate_binding.test new file mode 100644 index 0000000..9a0191a --- /dev/null +++ b/parser/testdata/corpus/sql/join/test_predicate_binding.test @@ -0,0 +1,49 @@ +# source: test/sql/join/test_predicate_binding.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +CREATE TABLE b (id BIGINT, name VARCHAR, created_at VARCHAR); +-- +ok +== +INSERT INTO b VALUES (-3, 'a', 'a'), (NULL, 'b', 'b'); +-- +ok +== +CREATE TABLE empt AS SELECT * FROM b WHERE 1 = 0; +-- +ok +== +CREATE VIEW t AS + SELECT id, name, created_at + FROM b + ANTI JOIN empt + ON TRUE; +-- +ok +== +SELECT t5.created_at +FROM (SELECT 'YEAR' AS c0 + FROM t AS t1 + INNER JOIN t AS t2 + ON t1.created_at <= t2.created_at + WHERE COALESCE(t1.id, t2.id) IS NOT NULL +) AS sq4 +INNER JOIN t AS t5 +ON sq4.c0 = t5.created_at; +-- +ok +== +SELECT t5.created_at +FROM (SELECT 'YEAR' AS c0 + FROM t AS t1 + INNER JOIN t AS t2 + ON t1.created_at = t2.created_at + WHERE COALESCE(t1.id, t2.id) IS NOT NULL +) AS sq4 +INNER JOIN t AS t5 +ON sq4.c0 = t5.created_at; +-- +ok +== diff --git a/parser/testdata/corpus/sql/join/test_string_payload.test b/parser/testdata/corpus/sql/join/test_string_payload.test new file mode 100644 index 0000000..4c82080 --- /dev/null +++ b/parser/testdata/corpus/sql/join/test_string_payload.test @@ -0,0 +1,25 @@ +# source: test/sql/join/test_string_payload.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +CREATE TABLE test1 (i INT, s1 VARCHAR, s2 VARCHAR) +-- +ok +== +INSERT INTO test1 VALUES (1, 'thisisareallylongstring', 'thisisareallylongstringtoo') +-- +ok +== +CREATE TABLE test2 (i INT, s1 VARCHAR, s2 VARCHAR) +-- +ok +== +INSERT INTO test2 VALUES (1, 'longstringsarecool', 'coolerthanshortstrings') +-- +ok +== +SELECT t1.i, t1.s1, t1.s2, t2.s1, t2.s2 FROM test1 t1, test2 t2 WHERE t1.i = t2.i +-- +ok +== diff --git a/parser/testdata/corpus/sql/json/copy_geojson.test b/parser/testdata/corpus/sql/json/copy_geojson.test new file mode 100644 index 0000000..75d9a34 --- /dev/null +++ b/parser/testdata/corpus/sql/json/copy_geojson.test @@ -0,0 +1,249 @@ +# source: test/sql/json/copy_geojson.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +CREATE TABLE places (id INTEGER, name VARCHAR, geom GEOMETRY); +-- +ok +== +INSERT INTO places VALUES (1, 'alpha', 'POINT(1 2)'), (2, 'beta', 'LINESTRING(0 0, 1 1)'), (3, NULL, NULL); +-- +ok +== +COPY places TO '{TEST_DIR}/places.geojson' (FORMAT GEOJSON); +-- +ok +== +SELECT replace(replace(trim(content, chr(10)), chr(10), ' '), chr(9), '') FROM read_text('{TEST_DIR}/places.geojson'); +-- +ok +== +COPY places TO '{TEST_DIR}/places.geojsonl' (FORMAT GEOJSON, ARRAY false); +-- +ok +== +SELECT replace(replace(trim(content, chr(10)), chr(10), ' '), chr(9), '') FROM read_text('{TEST_DIR}/places.geojsonl'); +-- +ok +== +COPY places TO '{TEST_DIR}/places_l.tmp' (FORMAT GEOJSONL); +-- +ok +== +SELECT content = (SELECT content FROM read_text('{TEST_DIR}/places.geojsonl')) FROM read_text('{TEST_DIR}/places_l.tmp'); +-- +ok +== +COPY places TO '{TEST_DIR}/places_inferred.geojsonl'; +-- +ok +== +SELECT content = (SELECT content FROM read_text('{TEST_DIR}/places.geojsonl')) FROM read_text('{TEST_DIR}/places_inferred.geojsonl'); +-- +ok +== +COPY places TO '{TEST_DIR}/places_l_array.tmp' (FORMAT GEOJSONL, ARRAY true); +-- +ok +== +SELECT content = (SELECT content FROM read_text('{TEST_DIR}/places.geojson')) FROM read_text('{TEST_DIR}/places_l_array.tmp'); +-- +ok +== +COPY places TO '{TEST_DIR}/inferred.geojson'; +-- +ok +== +SELECT count(*) FROM read_json('{TEST_DIR}/inferred.geojson'); +-- +ok +== +SELECT id, name, ST_AsText(geometry) FROM read_json('{TEST_DIR}/places.geojson') ORDER BY id; +-- +ok +== +SELECT id, name, ST_AsText(geometry) FROM read_json('{TEST_DIR}/places.geojsonl') ORDER BY id; +-- +ok +== +CREATE TABLE places2 (geometry GEOMETRY, id INTEGER, name VARCHAR); +-- +ok +== +COPY places2 FROM '{TEST_DIR}/places.geojson' (FORMAT GEOJSON); +-- +ok +== +SELECT id, name, ST_AsText(geometry) FROM places2 ORDER BY id; +-- +ok +== +CREATE TABLE places3 (geometry GEOMETRY, id INTEGER, name VARCHAR); +-- +ok +== +COPY places3 FROM '{TEST_DIR}/places.geojsonl' (FORMAT GEOJSON); +-- +ok +== +SELECT id, name, ST_AsText(geometry) FROM places3 ORDER BY id; +-- +ok +== +COPY (SELECT 'POINT(7 8)'::GEOMETRY AS g) TO '{TEST_DIR}/only_geom.geojsonl' (FORMAT GEOJSON, ARRAY false); +-- +ok +== +SELECT replace(replace(trim(content, chr(10)), chr(10), ' '), chr(9), '') FROM read_text('{TEST_DIR}/only_geom.geojsonl'); +-- +ok +== +COPY (SELECT DATE '2024-03-05' AS d, TIMESTAMP '2024-03-05 06:07:08' AS ts, 'POINT(1 2)'::GEOMETRY AS g) +TO '{TEST_DIR}/formats.geojsonl' (FORMAT GEOJSON, ARRAY false, DATEFORMAT '%d-%m-%Y', TIMESTAMPFORMAT '%H:%M:%S'); +-- +ok +== +SELECT replace(replace(trim(content, chr(10)), chr(10), ' '), chr(9), '') FROM read_text('{TEST_DIR}/formats.geojsonl'); +-- +ok +== +COPY (SELECT 1 AS part, 'POINT(1 2)'::GEOMETRY AS g UNION ALL SELECT 2, 'POINT(3 4)'::GEOMETRY) +TO '{TEST_DIR}/geojson_parts' (FORMAT GEOJSON, PARTITION_BY ('part')); +-- +ok +== +SELECT filename, replace(replace(trim(content, chr(10)), chr(10), ' '), chr(9), '') +FROM read_text('{TEST_DIR}/geojson_parts/*/*.geojson') ORDER BY filename; +-- +ok +== +COPY (SELECT 'POINT(1 2)'::GEOMETRY AS g, {pt: 'POINT(3 4)'::GEOMETRY} AS s) +TO '{TEST_DIR}/nested_geom.geojsonl' (FORMAT GEOJSON, ARRAY false); +-- +ok +== +SELECT replace(replace(trim(content, chr(10)), chr(10), ' '), chr(9), '') FROM read_text('{TEST_DIR}/nested_geom.geojsonl'); +-- +ok +== +CREATE TABLE ids (id VARCHAR, name VARCHAR, geom GEOMETRY); +-- +ok +== +INSERT INTO ids VALUES ('F-1', 'a', 'POINT(1 2)'), ('F-2', 'b', 'LINESTRING(0 0, 3 4)'); +-- +ok +== +COPY ids TO '{TEST_DIR}/ids.geojsonl' (FORMAT GEOJSON, ARRAY false); +-- +ok +== +SELECT replace(replace(trim(content, chr(10)), chr(10), ' '), chr(9), '') FROM read_text('{TEST_DIR}/ids.geojsonl'); +-- +ok +== +SELECT id, name, ST_AsText(geometry) FROM read_json('{TEST_DIR}/ids.geojsonl') ORDER BY id; +-- +ok +== +COPY ids TO '{TEST_DIR}/ids_named.geojsonl' (FORMAT GEOJSON, ARRAY false, ID_COLUMN name); +-- +ok +== +SELECT replace(replace(trim(content, chr(10)), chr(10), ' '), chr(9), '') FROM read_text('{TEST_DIR}/ids_named.geojsonl'); +-- +ok +== +COPY ids TO '{TEST_DIR}/ids_none.geojsonl' (FORMAT GEOJSON, ARRAY false, ID_COLUMN NULL); +-- +ok +== +SELECT replace(replace(trim(content, chr(10)), chr(10), ' '), chr(9), '') FROM read_text('{TEST_DIR}/ids_none.geojsonl'); +-- +ok +== +COPY ids TO '{TEST_DIR}/ids_bbox.geojsonl' (FORMAT GEOJSON, ARRAY false, BBOX true); +-- +ok +== +SELECT replace(replace(trim(content, chr(10)), chr(10), ' '), chr(9), '') FROM read_text('{TEST_DIR}/ids_bbox.geojsonl'); +-- +ok +== +SELECT ST_AsText(geometry), bbox FROM read_json('{TEST_DIR}/ids_bbox.geojsonl') ORDER BY id; +-- +ok +== +COPY (SELECT unnest(['POINT Z(1 2 3)'::GEOMETRY, 'POINT EMPTY'::GEOMETRY, NULL::GEOMETRY]) AS g) +TO '{TEST_DIR}/bbox_edges.geojsonl' (FORMAT GEOJSON, ARRAY false, BBOX true); +-- +ok +== +SELECT replace(replace(trim(content, chr(10)), chr(10), ' '), chr(9), '') FROM read_text('{TEST_DIR}/bbox_edges.geojsonl'); +-- +ok +== +COPY (SELECT 'POINT(1 2)'::GEOMETRY AS centroid, 'LINESTRING(0 0, 3 4)'::GEOMETRY AS outline) +TO '{TEST_DIR}/geom_pick.geojsonl' (FORMAT GEOJSON, ARRAY false, GEOMETRY_COLUMN outline); +-- +ok +== +SELECT replace(replace(trim(content, chr(10)), chr(10), ' '), chr(9), '') FROM read_text('{TEST_DIR}/geom_pick.geojsonl'); +-- +ok +== +COPY (SELECT 1 AS id, 'POINT(1 2)'::GEOMETRY AS g) +TO '{TEST_DIR}/unlocated.geojsonl' (FORMAT GEOJSON, ARRAY false, GEOMETRY_COLUMN NULL); +-- +ok +== +SELECT replace(replace(trim(content, chr(10)), chr(10), ' '), chr(9), '') FROM read_text('{TEST_DIR}/unlocated.geojsonl'); +-- +ok +== +COPY (SELECT 1 AS id, 'x' AS name) +TO '{TEST_DIR}/no_geom_ok.geojsonl' (FORMAT GEOJSON, ARRAY false, GEOMETRY_COLUMN NULL); +-- +ok +== +SELECT replace(replace(trim(content, chr(10)), chr(10), ' '), chr(9), '') FROM read_text('{TEST_DIR}/no_geom_ok.geojsonl'); +-- +ok +== +COPY (SELECT 1 AS id, 'x' AS name) TO '{TEST_DIR}/no_geom.geojson' (FORMAT GEOJSON); +-- +ok +== +COPY ids TO '{TEST_DIR}/bad_id.geojson' (FORMAT GEOJSON, ID_COLUMN nope); +-- +ok +== +COPY ids TO '{TEST_DIR}/bad_geom.geojson' (FORMAT GEOJSON, GEOMETRY_COLUMN name); +-- +ok +== +COPY ids TO '{TEST_DIR}/same_col.geojson' (FORMAT GEOJSON, ID_COLUMN geom); +-- +ok +== +COPY ids TO '{TEST_DIR}/opt.json' (FORMAT JSON, ID_COLUMN id); +-- +ok +== +COPY ids TO '{TEST_DIR}/opt.json' (FORMAT JSON, BBOX true); +-- +ok +== +COPY ids TO '{TEST_DIR}/opt.json' (FORMAT JSON, GEOMETRY_COLUMN geom); +-- +ok +== +COPY places TO '{TEST_DIR}/bad_option.geojson' (FORMAT GEOJSON, NONSENSE 1); +-- +ok +== +SELECT __internal_json_copy_to_geojson(1, NULL, NULL, NULL, NULL, false); +-- +ok +== diff --git a/parser/testdata/corpus/sql/json/copy_json_null_options.test b/parser/testdata/corpus/sql/json/copy_json_null_options.test new file mode 100644 index 0000000..42ec32e --- /dev/null +++ b/parser/testdata/corpus/sql/json/copy_json_null_options.test @@ -0,0 +1,73 @@ +# source: test/sql/json/copy_json_null_options.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +COPY (SELECT 1 AS a) TO '{TEST_DIR}/test_null_use_tmp_file.csv' (FORMAT CSV, use_tmp_file NULL); +-- +ok +== +COPY (SELECT 1 AS a) TO '{TEST_DIR}/test_null_dateformat.json' (FORMAT JSON, dateformat NULL); +-- +ok +== +COPY (SELECT 1 AS a) TO '{TEST_DIR}/test_null_date_format.json' (FORMAT JSON, date_format NULL); +-- +ok +== +COPY (SELECT 1 AS a) TO '{TEST_DIR}/test_null_timestampformat.json' (FORMAT JSON, timestampformat NULL); +-- +ok +== +COPY (SELECT 1 AS a) TO '{TEST_DIR}/test_null_timestamp_format.json' (FORMAT JSON, timestamp_format NULL); +-- +ok +== +COPY (SELECT 1 AS a) TO '{TEST_DIR}/test_null_array.json' (FORMAT JSON, array NULL); +-- +ok +== +COPY (SELECT 1 AS a) TO '{TEST_DIR}/test_null_file_extension.json' (FORMAT JSON, file_extension NULL); +-- +ok +== +COPY (SELECT 1 AS a) TO '{TEST_DIR}/test_null_use_tmp_file.json' (FORMAT JSON, use_tmp_file NULL); +-- +ok +== +COPY (SELECT 1 AS a) TO '{TEST_DIR}/test_null_encoding.json' (FORMAT JSON, encoding NULL); +-- +ok +== +COPY (SELECT 1 AS a) TO '{TEST_DIR}/test_null_compression.json' (FORMAT JSON, compression NULL); +-- +ok +== +COPY (SELECT 1 AS a) TO '{TEST_DIR}/test_null_filename_pattern.json' (FORMAT JSON, filename_pattern NULL); +-- +ok +== +COPY (SELECT 1 AS a) TO '{TEST_DIR}/test_bool_dateformat.json' (FORMAT JSON, dateformat TRUE); +-- +ok +== +COPY (SELECT 1 AS a) TO '{TEST_DIR}/test_double_timestampformat.json' (FORMAT JSON, timestampformat 1.5); +-- +ok +== +COPY (SELECT 1 AS a) TO '{TEST_DIR}/test_integer_file_extension.json' (FORMAT JSON, file_extension 42); +-- +ok +== +COPY (SELECT 1 AS a) TO '{TEST_DIR}/test_list_dateformat.json' (FORMAT JSON, dateformat [1, 2, 3]); +-- +ok +== +COPY (SELECT 1 AS a) TO '{TEST_DIR}/test_struct_file_extension.json' (FORMAT JSON, file_extension {'a': 1}); +-- +ok +== +COPY (SELECT 1 AS a) TO '{TEST_DIR}/test_bool_filename_pattern.json' (FORMAT JSON, filename_pattern FALSE); +-- +ok +== diff --git a/parser/testdata/corpus/sql/json/copy_json_partition_by.test b/parser/testdata/corpus/sql/json/copy_json_partition_by.test new file mode 100644 index 0000000..4395bb9 --- /dev/null +++ b/parser/testdata/corpus/sql/json/copy_json_partition_by.test @@ -0,0 +1,80 @@ +# source: test/sql/json/copy_json_partition_by.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +COPY (SELECT i AS part, 'v' || i AS val FROM range(2) t(i)) +TO '{TEST_DIR}/json_partition_basic' (FORMAT JSON, PARTITION_BY (part)); +-- +ok +== +SELECT filename, trim(content, chr(10)) +FROM read_text('{TEST_DIR}/json_partition_basic/*/*.json') ORDER BY filename; +-- +ok +== +COPY (SELECT i AS part, 'v' || i AS val FROM range(2) t(i)) +TO '{TEST_DIR}/json_partition_written' (FORMAT JSON, PARTITION_BY (part), WRITE_PARTITION_COLUMNS true); +-- +ok +== +SELECT filename, trim(content, chr(10)) +FROM read_text('{TEST_DIR}/json_partition_written/*/*.json') ORDER BY filename; +-- +ok +== +COPY (SELECT i AS a, i + 10 AS b, 'v' || i AS val FROM range(2) t(i)) +TO '{TEST_DIR}/json_partition_multi' (FORMAT JSON, PARTITION_BY (a, b)); +-- +ok +== +SELECT filename, trim(content, chr(10)) +FROM read_text('{TEST_DIR}/json_partition_multi/*/*/*.json') ORDER BY filename; +-- +ok +== +COPY (SELECT DATE '2024-01-01' AS d, i AS val FROM range(2) t(i)) +TO '{TEST_DIR}/json_partition_dateformat' (FORMAT JSON, PARTITION_BY (val), dateformat '%Y/%m/%d'); +-- +ok +== +SELECT filename, trim(content, chr(10)) +FROM read_text('{TEST_DIR}/json_partition_dateformat/*/*.json') ORDER BY filename; +-- +ok +== +COPY (SELECT 1 AS a, 2 AS b) +TO '{TEST_DIR}/json_partition_all' (FORMAT JSON, PARTITION_BY (a, b)); +-- +ok +== +COPY (SELECT 1 AS a, 2 AS b) +TO '{TEST_DIR}/json_partition_star' (FORMAT JSON, PARTITION_BY '*'); +-- +ok +== +COPY (SELECT 1 AS a, 2 AS b) +TO '{TEST_DIR}/json_partition_star_written' (FORMAT JSON, PARTITION_BY '*', WRITE_PARTITION_COLUMNS); +-- +ok +== +SELECT filename, trim(content, chr(10)) +FROM read_text('{TEST_DIR}/json_partition_star_written/*/*/*.json') ORDER BY filename; +-- +ok +== +COPY (SELECT DATE '2024-01-02' AS d, 42 AS v) +TO '{TEST_DIR}/json_partition_date_dir' (FORMAT JSON, PARTITION_BY (d), dateformat '%Y/%m/%d'); +-- +ok +== +SELECT filename, trim(content, chr(10)) +FROM read_text('{TEST_DIR}/json_partition_date_dir/*/*.json') ORDER BY filename; +-- +ok +== +COPY (SELECT 1 AS a, 2 AS b) +TO '{TEST_DIR}/json_partition_bad_wpc' (FORMAT JSON, PARTITION_BY (a), WRITE_PARTITION_COLUMNS (true, false)); +-- +ok +== diff --git a/parser/testdata/corpus/sql/json/issues/internal_issue2732.test b/parser/testdata/corpus/sql/json/issues/internal_issue2732.test new file mode 100644 index 0000000..b5a63b6 --- /dev/null +++ b/parser/testdata/corpus/sql/json/issues/internal_issue2732.test @@ -0,0 +1,9 @@ +# source: test/sql/json/issues/internal_issue2732.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +select * from read_json('{DATA_DIR}/json/internal_2732.json', map_inference_threshold=0); +-- +ok +== diff --git a/parser/testdata/corpus/sql/json/issues/internal_issue3146.test b/parser/testdata/corpus/sql/json/issues/internal_issue3146.test new file mode 100644 index 0000000..5dbcde3 --- /dev/null +++ b/parser/testdata/corpus/sql/json/issues/internal_issue3146.test @@ -0,0 +1,17 @@ +# source: test/sql/json/issues/internal_issue3146.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +COPY (SELECT '{}') TO '{TEST_DIR}/empty_object.json' (FORMAT CSV, HEADER FALSE) +-- +ok +== +SELECT typeof(json) FROM '{TEST_DIR}/empty_object.json' +-- +ok +== +SELECT typeof(json) FROM read_json('{TEST_DIR}/empty_object.json', map_inference_threshold=-1) +-- +ok +== diff --git a/parser/testdata/corpus/sql/json/issues/internal_issue3197.test b/parser/testdata/corpus/sql/json/issues/internal_issue3197.test new file mode 100644 index 0000000..3fd823e --- /dev/null +++ b/parser/testdata/corpus/sql/json/issues/internal_issue3197.test @@ -0,0 +1,9 @@ +# source: test/sql/json/issues/internal_issue3197.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +from '{DATA_DIR}/json/internal_3197.json' +-- +ok +== diff --git a/parser/testdata/corpus/sql/json/issues/internal_issue391.test b/parser/testdata/corpus/sql/json/issues/internal_issue391.test new file mode 100644 index 0000000..b06fb57 --- /dev/null +++ b/parser/testdata/corpus/sql/json/issues/internal_issue391.test @@ -0,0 +1,17 @@ +# source: test/sql/json/issues/internal_issue391.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +create table test as select {i: range}::JSON j from range(10) +-- +ok +== +select min(j), max(j) from test +-- +ok +== +summarize test +-- +ok +== diff --git a/parser/testdata/corpus/sql/json/issues/internal_issue4014.test b/parser/testdata/corpus/sql/json/issues/internal_issue4014.test new file mode 100644 index 0000000..2c914df --- /dev/null +++ b/parser/testdata/corpus/sql/json/issues/internal_issue4014.test @@ -0,0 +1,9 @@ +# source: test/sql/json/issues/internal_issue4014.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +FROM read_json('{DATA_DIR}/json/internal_4014.json', map_inference_threshold=0); +-- +ok +== diff --git a/parser/testdata/corpus/sql/json/issues/internal_issue4389.test b/parser/testdata/corpus/sql/json/issues/internal_issue4389.test new file mode 100644 index 0000000..69fd017 --- /dev/null +++ b/parser/testdata/corpus/sql/json/issues/internal_issue4389.test @@ -0,0 +1,21 @@ +# source: test/sql/json/issues/internal_issue4389.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +CREATE TABLE todos (userId UBIGINT, id UBIGINT, title VARCHAR, completed BOOLEAN); +-- +ok +== +insert into todos values (42, 42, 'duck', true) +-- +ok +== +copy todos to '{TEST_DIR}/todos.json' (ARRAY) +-- +ok +== +copy todos from '{TEST_DIR}/todos.json' +-- +ok +== diff --git a/parser/testdata/corpus/sql/json/issues/internal_issue4403.test b/parser/testdata/corpus/sql/json/issues/internal_issue4403.test new file mode 100644 index 0000000..baeaeec --- /dev/null +++ b/parser/testdata/corpus/sql/json/issues/internal_issue4403.test @@ -0,0 +1,9 @@ +# source: test/sql/json/issues/internal_issue4403.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +SELECT * FROM read_json('{DATA_DIR}/json/example_n.ndjson', columns={id: NULL::VARCHAR, name: NULL::VARCHAR}) +-- +ok +== diff --git a/parser/testdata/corpus/sql/json/issues/internal_issue4794.test b/parser/testdata/corpus/sql/json/issues/internal_issue4794.test new file mode 100644 index 0000000..912af3b --- /dev/null +++ b/parser/testdata/corpus/sql/json/issues/internal_issue4794.test @@ -0,0 +1,9 @@ +# source: test/sql/json/issues/internal_issue4794.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +FROM read_json('{DATA_DIR}/json/format_string_key.json'); +-- +ok +== diff --git a/parser/testdata/corpus/sql/json/issues/internal_issue5288.test b/parser/testdata/corpus/sql/json/issues/internal_issue5288.test new file mode 100644 index 0000000..648f1be --- /dev/null +++ b/parser/testdata/corpus/sql/json/issues/internal_issue5288.test @@ -0,0 +1,9 @@ +# source: test/sql/json/issues/internal_issue5288.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +create table foo2 (bar JSON using compression 'zstd'); +-- +ok +== diff --git a/parser/testdata/corpus/sql/json/issues/issue10751and11152.test b/parser/testdata/corpus/sql/json/issues/issue10751and11152.test new file mode 100644 index 0000000..2ad6bb9 --- /dev/null +++ b/parser/testdata/corpus/sql/json/issues/issue10751and11152.test @@ -0,0 +1,25 @@ +# source: test/sql/json/issues/issue10751and11152.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +create or replace table json_test as select * from read_json_auto('{DATA_DIR}/json/10751.json', format = 'newline_delimited'); +-- +ok +== +create table json_test as select * from read_json_auto('{DATA_DIR}/json/10751.json', format = 'newline_delimited', ignore_errors=true); +-- +ok +== +select * from json_test; +-- +ok +== +FROM read_json_auto('{DATA_DIR}/json/11152.json'); +-- +ok +== +FROM read_json_auto('{DATA_DIR}/json/11152.json', ignore_errors=true); +-- +ok +== diff --git a/parser/testdata/corpus/sql/json/issues/issue10784.test b/parser/testdata/corpus/sql/json/issues/issue10784.test new file mode 100644 index 0000000..2bd946f --- /dev/null +++ b/parser/testdata/corpus/sql/json/issues/issue10784.test @@ -0,0 +1,17 @@ +# source: test/sql/json/issues/issue10784.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +SELECT * FROM read_json_auto('{DATA_DIR}/json/arr.json', columns={'v':'VARCHAR','k':'VARCHAR'}); +-- +ok +== +SELECT * FROM read_json_auto('{DATA_DIR}/json/arr.json', columns={'v':'VARCHAR','k':'VARCHAR'}, ignore_errors=true); +-- +ok +== +SELECT * FROM read_json_auto('{DATA_DIR}/json/arr.json', columns={'v':'VARCHAR'}); +-- +ok +== diff --git a/parser/testdata/corpus/sql/json/issues/issue10866.test b/parser/testdata/corpus/sql/json/issues/issue10866.test new file mode 100644 index 0000000..c08827a --- /dev/null +++ b/parser/testdata/corpus/sql/json/issues/issue10866.test @@ -0,0 +1,13 @@ +# source: test/sql/json/issues/issue10866.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +copy (select '{"col": 277447099861456945273576150847928801582}') to '{TEST_DIR}/10866.json' (format csv, quote '', header 0) +-- +ok +== +select col, hex(col) from read_json('{TEST_DIR}/10866.json', columns={col: 'uhugeint'}) +-- +ok +== diff --git a/parser/testdata/corpus/sql/json/issues/issue11804.test b/parser/testdata/corpus/sql/json/issues/issue11804.test new file mode 100644 index 0000000..efaba65 --- /dev/null +++ b/parser/testdata/corpus/sql/json/issues/issue11804.test @@ -0,0 +1,28 @@ +# source: test/sql/json/issues/issue11804.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +select json_type(JSON 'null') = 'NULL'; +-- +ok +== +select json_type(JSON '{"a": null}', '/a') = 'NULL'; +-- +ok +== +select json_type(JSON '{"a": null}', '$.a') = 'NULL'; +-- +ok +== +SELECT + json_type (json '{"a":1,"b":null}', p), + json_type (json '{"a":1,"b":null}', 'b') +FROM (VALUES ('b')) AS t (p); +-- +ok +== +select unnest(json_type(JSON '{"a": null}', ['$.a', '$.a'])) = 'NULL'; +-- +ok +== diff --git a/parser/testdata/corpus/sql/json/issues/issue12188.test b/parser/testdata/corpus/sql/json/issues/issue12188.test new file mode 100644 index 0000000..c2375ca --- /dev/null +++ b/parser/testdata/corpus/sql/json/issues/issue12188.test @@ -0,0 +1,17 @@ +# source: test/sql/json/issues/issue12188.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +SELECT typeof(field1), typeof(field2) FROM '{DATA_DIR}/parquet-testing/parquet_with_json.parquet' LIMIT 1 +-- +ok +== +COPY (SELECT * FROM read_ndjson('{DATA_DIR}/json/12188.ndjson', maximum_depth=1)) TO '{TEMP_DIR}/my.parquet'; +-- +ok +== +SELECT typeof(field1), typeof(field2) FROM '{TEMP_DIR}/my.parquet' LIMIT 1 +-- +ok +== diff --git a/parser/testdata/corpus/sql/json/issues/issue12861.test b/parser/testdata/corpus/sql/json/issues/issue12861.test new file mode 100644 index 0000000..5047c3d --- /dev/null +++ b/parser/testdata/corpus/sql/json/issues/issue12861.test @@ -0,0 +1,33 @@ +# source: test/sql/json/issues/issue12861.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +create table tbl (test struct(one bigint, two varchar)); +-- +ok +== +insert into tbl values ({'one': 1, 'two': 2}), (null) +-- +ok +== +copy tbl to '{TEST_DIR}/fewnulls.json' +-- +ok +== +insert into tbl select null from range(9) +-- +ok +== +copy tbl to '{TEST_DIR}/manynulls.json' +-- +ok +== +select typeof(test) from '{TEST_DIR}/fewnulls.json' limit 1 +-- +ok +== +select typeof(test) from '{TEST_DIR}/manynulls.json' limit 1 +-- +ok +== diff --git a/parser/testdata/corpus/sql/json/issues/issue13212.test b/parser/testdata/corpus/sql/json/issues/issue13212.test new file mode 100644 index 0000000..261bd71 --- /dev/null +++ b/parser/testdata/corpus/sql/json/issues/issue13212.test @@ -0,0 +1,21 @@ +# source: test/sql/json/issues/issue13212.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +copy (select range::int64 as id, range::varchar as name from range(0)) to '{TEST_DIR}/t1.json.gz' (format json, compression gzip) +-- +ok +== +copy (select id, name from values (1, 'bob'), (2, 'tom') tbl(id, name)) to '{TEST_DIR}/t2.json.gz' (format json, compression gzip) +-- +ok +== +SELECT * FROM read_ndjson_auto(['{TEST_DIR}/t1.json.gz', '{TEST_DIR}/t2.json.gz']); +-- +ok +== +SELECT * FROM read_ndjson(['{TEST_DIR}/t1.json.gz', '{TEST_DIR}/t2.json.gz'], columns={id: 'int64', name: 'varchar'}); +-- +ok +== diff --git a/parser/testdata/corpus/sql/json/issues/issue13725.test b/parser/testdata/corpus/sql/json/issues/issue13725.test new file mode 100644 index 0000000..6786896 --- /dev/null +++ b/parser/testdata/corpus/sql/json/issues/issue13725.test @@ -0,0 +1,29 @@ +# source: test/sql/json/issues/issue13725.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +select * +from read_json_objects('{DATA_DIR}/json/13725/month=*/*.json', hive_partitioning = true, format = auto, hive_types = {'month': int}, filename = true) +where month = 7; +-- +ok +== +select count(*) +from read_json_objects('{DATA_DIR}/json/13725/month=*/*.json', hive_partitioning = true, format = auto, hive_types = {'month': int}, filename = true) +where month = 7; +-- +ok +== +select * +from read_json('{DATA_DIR}/json/13725/month=*/*.json', hive_partitioning = true, format = auto, hive_types = {'month': int}, filename = true) +where month = 7; +-- +ok +== +select count(*) +from read_json('{DATA_DIR}/json/13725/month=*/*.json', hive_partitioning = true, format = auto, hive_types = {'month': int}, filename = true) +where month = 7; +-- +ok +== diff --git a/parser/testdata/corpus/sql/json/issues/issue13948.test b/parser/testdata/corpus/sql/json/issues/issue13948.test new file mode 100644 index 0000000..9babb22 --- /dev/null +++ b/parser/testdata/corpus/sql/json/issues/issue13948.test @@ -0,0 +1,65 @@ +# source: test/sql/json/issues/issue13948.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +SELECT '{"Status / SubStatus": "test"}' -> 'Status / SubStatus'; +-- +ok +== +WITH path AS ( + SELECT 'Status / SubStatus' p +) +SELECT '{"Status / SubStatus": "test"}' -> p +FROM path +-- +ok +== +SELECT '{"\"Status / SubStatus\"": "test"}' -> '"Status / SubStatus"'; +-- +ok +== +WITH path AS ( + SELECT NULL p +) +SELECT '{"\"Status / SubStatus\"": "test"}' -> p +FROM path +-- +ok +== +SELECT '{"Status / SubStatus": "test"}' -> '$."Status / SubStatus"'; +-- +ok +== +WITH path AS ( + SELECT '$."Status / SubStatus"' p +) +SELECT '{"Status / SubStatus": "test"}' -> p +FROM path +-- +ok +== +SELECT '[1, 2, 3]'->0 +-- +ok +== +WITH path AS ( + SELECT 0 p +) +SELECT '[1, 2, 3]' -> p +FROM path +-- +ok +== +SELECT '[1, 2, 3]'->'0' +-- +ok +== +WITH path AS ( + SELECT '0' p +) +SELECT '[1, 2, 3]' -> p +FROM path +-- +ok +== diff --git a/parser/testdata/corpus/sql/json/issues/issue14167.test b/parser/testdata/corpus/sql/json/issues/issue14167.test new file mode 100644 index 0000000..f7d4bb1 --- /dev/null +++ b/parser/testdata/corpus/sql/json/issues/issue14167.test @@ -0,0 +1,9 @@ +# source: test/sql/json/issues/issue14167.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +select columns.v4_c6 from read_ndjson_auto('{DATA_DIR}/json/14167.json'); +-- +ok +== diff --git a/parser/testdata/corpus/sql/json/issues/issue14245.test b/parser/testdata/corpus/sql/json/issues/issue14245.test new file mode 100644 index 0000000..2353c56 --- /dev/null +++ b/parser/testdata/corpus/sql/json/issues/issue14245.test @@ -0,0 +1,9 @@ +# source: test/sql/json/issues/issue14245.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +SELECT '{ "foo": ["bar", "baz"], "": 0 }' -> '/' +-- +ok +== diff --git a/parser/testdata/corpus/sql/json/issues/issue14259.test b/parser/testdata/corpus/sql/json/issues/issue14259.test new file mode 100644 index 0000000..438adc1 --- /dev/null +++ b/parser/testdata/corpus/sql/json/issues/issue14259.test @@ -0,0 +1,9 @@ +# source: test/sql/json/issues/issue14259.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +from '{DATA_DIR}/json/issue14259.json' +-- +ok +== diff --git a/parser/testdata/corpus/sql/json/issues/issue15038.test b/parser/testdata/corpus/sql/json/issues/issue15038.test new file mode 100644 index 0000000..764b417 --- /dev/null +++ b/parser/testdata/corpus/sql/json/issues/issue15038.test @@ -0,0 +1,57 @@ +# source: test/sql/json/issues/issue15038.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +SELECT to_json(1::HUGEINT << 100) +-- +ok +== +SELECT (1::HUGEINT << 100)::JSON +-- +ok +== +SELECT to_json(1::UHUGEINT << 100) +-- +ok +== +SELECT (1::UHUGEINT << 100)::JSON +-- +ok +== +SELECT to_json((1::UHUGEINT << 100)::DECIMAL(38,0)) +-- +ok +== +SELECT (1::UHUGEINT << 100)::DECIMAL(38,0)::JSON +-- +ok +== +SELECT to_json((1::HUGEINT << 100)::BIGNUM) +-- +ok +== +SELECT (1::HUGEINT << 100)::BIGNUM::JSON +-- +ok +== +WITH t1 AS ( + SELECT 9007199254740993 AS id + UNION ALL + SELECT 1.2 AS id +) +SELECT to_json(id) AS json_objects +FROM t1 AS t; +-- +ok +== +WITH t1 AS ( + SELECT 9007199254740993 AS id + UNION ALL + SELECT 1.2 AS id +) +SELECT id::JSON AS json_objects +FROM t1 AS t; +-- +ok +== diff --git a/parser/testdata/corpus/sql/json/issues/issue15601.test b/parser/testdata/corpus/sql/json/issues/issue15601.test new file mode 100644 index 0000000..92ce5b8 --- /dev/null +++ b/parser/testdata/corpus/sql/json/issues/issue15601.test @@ -0,0 +1,13 @@ +# source: test/sql/json/issues/issue15601.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +FROM '{DATA_DIR}/json/15601/fragment*.json' +-- +ok +== +FROM '{DATA_DIR}/json/15601/bunch_of_key_collisions.json' +-- +ok +== diff --git a/parser/testdata/corpus/sql/json/issues/issue16568.test b/parser/testdata/corpus/sql/json/issues/issue16568.test new file mode 100644 index 0000000..455066a --- /dev/null +++ b/parser/testdata/corpus/sql/json/issues/issue16568.test @@ -0,0 +1,9 @@ +# source: test/sql/json/issues/issue16568.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +select count(*) from '{DATA_DIR}/json/sample_utf8_bom.json' +-- +ok +== diff --git a/parser/testdata/corpus/sql/json/issues/issue16570.test b/parser/testdata/corpus/sql/json/issues/issue16570.test new file mode 100644 index 0000000..b2f4f88 --- /dev/null +++ b/parser/testdata/corpus/sql/json/issues/issue16570.test @@ -0,0 +1,13 @@ +# source: test/sql/json/issues/issue16570.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +with cte as ( + select '{"a":1}'::JSON as j +) +select typeof(j[2:3]), typeof(substring(j, 2, 3)) +from cte +-- +ok +== diff --git a/parser/testdata/corpus/sql/json/issues/issue16684.test b/parser/testdata/corpus/sql/json/issues/issue16684.test new file mode 100644 index 0000000..03b7454 --- /dev/null +++ b/parser/testdata/corpus/sql/json/issues/issue16684.test @@ -0,0 +1,21 @@ +# source: test/sql/json/issues/issue16684.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +copy (select '00000000000000000000000000000000' md5) to '{TEST_DIR}/issue16684.json' +-- +ok +== +select md5, typeof(md5) from '{TEST_DIR}/issue16684.json' +-- +ok +== +copy (select '00000000-0000-0000-0000-000000000000' id) to '{TEST_DIR}/issue16684.json' +-- +ok +== +select id, typeof(id) from '{TEST_DIR}/issue16684.json' +-- +ok +== diff --git a/parser/testdata/corpus/sql/json/issues/issue16968.test b/parser/testdata/corpus/sql/json/issues/issue16968.test new file mode 100644 index 0000000..07423b1 --- /dev/null +++ b/parser/testdata/corpus/sql/json/issues/issue16968.test @@ -0,0 +1,21 @@ +# source: test/sql/json/issues/issue16968.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +select from_hex('aa')::json; +-- +ok +== +select json(from_hex('aa')); +-- +ok +== +select '1101'::BIT::JSON +-- +ok +== +select json('1101'::BIT) +-- +ok +== diff --git a/parser/testdata/corpus/sql/json/issues/issue17135.test b/parser/testdata/corpus/sql/json/issues/issue17135.test new file mode 100644 index 0000000..0d1c9be --- /dev/null +++ b/parser/testdata/corpus/sql/json/issues/issue17135.test @@ -0,0 +1,45 @@ +# source: test/sql/json/issues/issue17135.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +copy (select * from (values ('{"id":9223372036854775808}'))) to '{TEST_DIR}/ubigint.json' (format csv, quote '', header 0) +-- +ok +== +select typeof(id), id from read_json('{TEST_DIR}/ubigint.json') +-- +ok +== +copy (select * from (values ('{"id":18446744073709551615}'))) to '{TEST_DIR}/ubigint_max.json' (format csv, quote '', header 0) +-- +ok +== +select typeof(id), id from read_json('{TEST_DIR}/ubigint_max.json') +-- +ok +== +select json_structure('{"id":9223372036854775808}') +-- +ok +== +select json_structure('{"id":42}') +-- +ok +== +copy (select * from (values ('{"id":42}'))) to '{TEST_DIR}/bigint.json' (format csv, quote '', header 0) +-- +ok +== +select typeof(id), id from read_json('{TEST_DIR}/bigint.json') +-- +ok +== +copy (select * from (values ('{"id":-5}'), ('{"id":9223372036854775808}'))) to '{TEST_DIR}/mixed.json' (format csv, quote '', header 0) +-- +ok +== +select typeof(id), id from read_json('{TEST_DIR}/mixed.json') +-- +ok +== diff --git a/parser/testdata/corpus/sql/json/issues/issue18301.test b/parser/testdata/corpus/sql/json/issues/issue18301.test new file mode 100644 index 0000000..fb8dc4f --- /dev/null +++ b/parser/testdata/corpus/sql/json/issues/issue18301.test @@ -0,0 +1,33 @@ +# source: test/sql/json/issues/issue18301.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +SET threads = 2; +-- +ok +== +CREATE OR REPLACE TABLE cricket_staging AS +SELECT * FROM read_json('{DATA_DIR}/json/18301/*.json', filename=true) +WHERE 1=0; +-- +ok +== +TRUNCATE cricket_staging; +-- +ok +== +INSERT INTO cricket_staging +SELECT * FROM read_json('{DATA_DIR}/json/18301/*.json', + union_by_name=true, + filename=true +); +-- +ok +== +SELECT info->>'$.outcome.by' as outcome_by +FROM cricket_staging +WHERE info->>'$.city' = 'Colombo'; +-- +ok +== diff --git a/parser/testdata/corpus/sql/json/issues/issue19357.test b/parser/testdata/corpus/sql/json/issues/issue19357.test new file mode 100644 index 0000000..fefacbb --- /dev/null +++ b/parser/testdata/corpus/sql/json/issues/issue19357.test @@ -0,0 +1,17 @@ +# source: test/sql/json/issues/issue19357.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +SELECT TO_JSON({'key_1': 'one'}) AS WITHOUT_KEEP_NULL +-- +ok +== +SELECT JSON_OBJECT('key_1', 'one', 'key_2', NULL) AS KEEP_NULL_1 +-- +ok +== +SELECT JSON_OBJECT('key_1', 'one', NULL, 'two') AS KEEP_NULL_2 +-- +ok +== diff --git a/parser/testdata/corpus/sql/json/issues/issue19366.test b/parser/testdata/corpus/sql/json/issues/issue19366.test new file mode 100644 index 0000000..6a49d0b --- /dev/null +++ b/parser/testdata/corpus/sql/json/issues/issue19366.test @@ -0,0 +1,17 @@ +# source: test/sql/json/issues/issue19366.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +copy ( + select + 'TEST' AS "key", + {Attributes: '{}'::MAP(VARCHAR, JSON), Nodes: {hardware: NULL::JSON, networking: NULL::JSON, software: NULL::JSON}, "Table": '{}'::MAP(VARCHAR, JSON)} AS "value" +) to '{TEST_DIR}/19366.parquet' (PARQUET_VERSION V2) +-- +ok +== +from '{TEST_DIR}/19366.parquet'; +-- +ok +== diff --git a/parser/testdata/corpus/sql/json/issues/issue22764.test b/parser/testdata/corpus/sql/json/issues/issue22764.test new file mode 100644 index 0000000..c7c4878 --- /dev/null +++ b/parser/testdata/corpus/sql/json/issues/issue22764.test @@ -0,0 +1,11 @@ +# source: test/sql/json/issues/issue22764.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +SELECT json_deserialize_sql($json$ +{"error":false,"statements":[{"node":{"type":"SELECT_NODE","modifiers":[],"cte_map":{"map":[]},"select_list":[null,{"class":"CONSTANT","type":"VALUE_CONSTANT","alias":"","query_location":7,"value":{"type":{"id":"INTEGER","type_info":null},"is_null":false,"value":42}}],"from_table":{"type":"EMPTY","alias":"","sample":null,"query_location":18446744073709551615},"where_clause":null,"group_expressions":[],"group_sets":[],"aggregate_handling":"STANDARD_HANDLING","having":null,"sample":null,"qualify":null},"named_param_map":[]}]} +$json$); +-- +error: Parser Error: Error parsing json: null expression found in json +== diff --git a/parser/testdata/corpus/sql/json/issues/issue22764.test.metadata.json b/parser/testdata/corpus/sql/json/issues/issue22764.test.metadata.json new file mode 100644 index 0000000..2150006 --- /dev/null +++ b/parser/testdata/corpus/sql/json/issues/issue22764.test.metadata.json @@ -0,0 +1,5 @@ +{ + "todo": { + "c23202e0f507dfbc": "transformer-raised parser error: upstream rejects in the transformer, not the grammar; expected to clear as transformers land (milestones 3-5)" + } +} diff --git a/parser/testdata/corpus/sql/json/issues/issue23114.test b/parser/testdata/corpus/sql/json/issues/issue23114.test new file mode 100644 index 0000000..dd34d09 --- /dev/null +++ b/parser/testdata/corpus/sql/json/issues/issue23114.test @@ -0,0 +1,21 @@ +# source: test/sql/json/issues/issue23114.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +SELECT json_object(CAST(NULL AS VARCHAR), 'two'); +-- +ok +== +SELECT json_object('key', NULL); +-- +ok +== +SELECT json_group_object(k, v) FROM (VALUES ('ok', 'one'), (NULL, 'two')) t(k, v); +-- +ok +== +SELECT json_group_object(k, v) FROM (VALUES ('ok', 'one'), ('two', NULL)) t(k, v); +-- +ok +== diff --git a/parser/testdata/corpus/sql/json/issues/issue6722.test b/parser/testdata/corpus/sql/json/issues/issue6722.test new file mode 100644 index 0000000..9feacb6 --- /dev/null +++ b/parser/testdata/corpus/sql/json/issues/issue6722.test @@ -0,0 +1,13 @@ +# source: test/sql/json/issues/issue6722.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +FROM '{DATA_DIR}/json/duplicate_column_names.json' +-- +ok +== +DESCRIBE FROM '{DATA_DIR}/json/duplicate_column_names.json' +-- +ok +== diff --git a/parser/testdata/corpus/sql/json/issues/issue8695.test b/parser/testdata/corpus/sql/json/issues/issue8695.test new file mode 100644 index 0000000..f3865c6 --- /dev/null +++ b/parser/testdata/corpus/sql/json/issues/issue8695.test @@ -0,0 +1,29 @@ +# source: test/sql/json/issues/issue8695.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +SELECT MAX(JSON_ARRAY_LENGTH(filter_keystage))::int - 1 FROM read_json_auto('{DATA_DIR}/json/filter_keystage.ndjson'); +-- +ok +== +WITH RECURSIVE nums AS ( + SELECT 0 AS n + UNION ALL + SELECT n + 1 FROM nums + WHERE n < 5 +) +SELECT * FROM nums; +-- +ok +== +WITH RECURSIVE nums AS ( + SELECT 0 AS n + UNION ALL + SELECT n + 1 FROM nums + WHERE n < (SELECT MAX(JSON_ARRAY_LENGTH(filter_keystage))::int - 1 FROM read_json_auto('{DATA_DIR}/json/filter_keystage.ndjson')) +) +SELECT * FROM nums; +-- +ok +== diff --git a/parser/testdata/corpus/sql/json/issues/large_quoted_string_constant.test b/parser/testdata/corpus/sql/json/issues/large_quoted_string_constant.test new file mode 100644 index 0000000..42d467c --- /dev/null +++ b/parser/testdata/corpus/sql/json/issues/large_quoted_string_constant.test @@ -0,0 +1,87 @@ +# source: test/sql/json/issues/large_quoted_string_constant.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +CREATE TABLE j2 (id INT, json VARCHAR, src VARCHAR); +-- +ok +== +INSERT INTO j2(id,json,src) + VALUES(3,'[ + { + "id": "0001", + "type": "donut", + "name": "Cake", + "ppu": 0.55, + "batters": + { + "batter": + [ + { "id": "1001", "type": "Regular" }, + { "id": "1002", "type": "Chocolate" }, + { "id": "1003", "type": "Blueberry" }, + { "id": "1004", "type": "Devil''s Food" } + ] + }, + "topping": + [ + { "id": "5001", "type": "None" }, + { "id": "5002", "type": "Glazed" }, + { "id": "5005", "type": "Sugar" }, + { "id": "5007", "type": "Powdered Sugar" }, + { "id": "5006", "type": "Chocolate with Sprinkles" }, + { "id": "5003", "type": "Chocolate" }, + { "id": "5004", "type": "Maple" } + ] + }, + { + "id": "0002", + "type": "donut", + "name": "Raised", + "ppu": 0.55, + "batters": + { + "batter": + [ + { "id": "1001", "type": "Regular" } + ] + }, + "topping": + [ + { "id": "5001", "type": "None" }, + { "id": "5002", "type": "Glazed" }, + { "id": "5005", "type": "Sugar" }, + { "id": "5003", "type": "Chocolate" }, + { "id": "5004", "type": "Maple" } + ] + }, + { + "id": "0003", + "type": "donut", + "name": "Old Fashioned", + "ppu": 0.55, + "batters": + { + "batter": + [ + { "id": "1001", "type": "Regular" }, + { "id": "1002", "type": "Chocolate" } + ] + }, + "topping": + [ + { "id": "5001", "type": "None" }, + { "id": "5002", "type": "Glazed" }, + { "id": "5003", "type": "Chocolate" }, + { "id": "5004", "type": "Maple" } + ] + } + ]','https://adobe.github.io/Spry/samples/data_region/JSONDataSetSample.html'); +-- +ok +== +SELECT len(json) FROM j2; +-- +ok +== diff --git a/parser/testdata/corpus/sql/json/issues/map_inference_threshold_internal_exception.test b/parser/testdata/corpus/sql/json/issues/map_inference_threshold_internal_exception.test new file mode 100644 index 0000000..f29e321 --- /dev/null +++ b/parser/testdata/corpus/sql/json/issues/map_inference_threshold_internal_exception.test @@ -0,0 +1,13 @@ +# source: test/sql/json/issues/map_inference_threshold_internal_exception.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +SELECT * FROM read_json('{DATA_DIR}/json/internal_3813.json', map_inference_threshold=10); +-- +ok +== +FROM read_json('{DATA_DIR}/json/issue_22827.json', map_inference_threshold=1); +-- +ok +== diff --git a/parser/testdata/corpus/sql/json/issues/read_json_memory_usage.test b/parser/testdata/corpus/sql/json/issues/read_json_memory_usage.test new file mode 100644 index 0000000..ed9d24e --- /dev/null +++ b/parser/testdata/corpus/sql/json/issues/read_json_memory_usage.test @@ -0,0 +1,17 @@ +# source: test/sql/json/issues/read_json_memory_usage.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +SET memory_limit='200MiB'; +-- +ok +== +SELECT * FROM read_json_objects('{DATA_DIR}/json/example_rn.ndjson', format='nd'); +-- +ok +== +SET memory_limit='50MiB'; +-- +ok +== diff --git a/parser/testdata/corpus/sql/json/issues/test_json_temp_8062.test b/parser/testdata/corpus/sql/json/issues/test_json_temp_8062.test new file mode 100644 index 0000000..c0855ba --- /dev/null +++ b/parser/testdata/corpus/sql/json/issues/test_json_temp_8062.test @@ -0,0 +1,17 @@ +# source: test/sql/json/issues/test_json_temp_8062.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +CREATE TEMP TABLE j1(x json); +-- +ok +== +INSERT INTO j1(x) VALUES ('[1, 2, 3]'); +-- +ok +== +SELECT * FROM j1; +-- +ok +== diff --git a/parser/testdata/corpus/sql/json/scalar/json_nested_casts.test b/parser/testdata/corpus/sql/json/scalar/json_nested_casts.test new file mode 100644 index 0000000..a5d7bc6 --- /dev/null +++ b/parser/testdata/corpus/sql/json/scalar/json_nested_casts.test @@ -0,0 +1,374 @@ +# source: test/sql/json/scalar/json_nested_casts.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +create table t2(blobs json[]) +-- +ok +== +insert into t2 values(json('[1,2]')); +-- +ok +== +select cast(json('[1,2]') as json[]); +-- +ok +== +select cast(['boom'] as json[]); +-- +ok +== +select cast(['[1, 2]', '[3, 4]'] as json[]); +-- +ok +== +SELECT {'a': '[1, 2]'}::ROW(a JSON) +-- +ok +== +SELECT {'a': 42, 'b': '[1, 2]'}::ROW(a JSON, b JSON) +-- +ok +== +SELECT {'a': 42, 'b': '[1, 2]'}::ROW(a JSON, b INT[]) +-- +ok +== +SELECT {'a': 'boom', 'b': '[1, 2]'}::ROW(a JSON, b INT[]) +-- +ok +== +SELECT '{a: [1, 2]}'::ROW(a JSON) +-- +ok +== +SELECT MAP(['42'], ['88'])::MAP(JSON, JSON) +-- +ok +== +SELECT '{42=88}'::MAP(JSON, JSON) +-- +ok +== +SELECT '42'::UNION(u JSON) +-- +ok +== +SELECT '42'::UNION(u VARCHAR)::UNION(u JSON) +-- +ok +== +SELECT ['42']::UNION(u JSON)[] +-- +ok +== +SELECT '42'::UNION(u VARCHAR)::JSON +-- +ok +== +SELECT TRY_CAST('{"duck":42' AS JSON) +-- +ok +== +SELECT {duck: 42}::JSON +-- +ok +== +SELECT '{"duck":42}'::JSON::STRUCT(duck INTEGER) +-- +ok +== +SELECT ['duck']::JSON +-- +ok +== +SELECT '["duck"]'::JSON::VARCHAR[] +-- +ok +== +SELECT MAP(['duck'], [42])::JSON +-- +ok +== +SELECT '{"duck":42}'::JSON::MAP(VARCHAR, INTEGER) +-- +ok +== +SELECT '{"duck":42}'::JSON::STRUCT(goose INTEGER) +-- +ok +== +SELECT '["a", "b", "c"]'::JSON::INT[] +-- +ok +== +SELECT '{"duck":42}'::JSON::MAP(INTEGER, INTEGER) +-- +ok +== +SELECT TRY_CAST('{"duck":42}'::JSON AS STRUCT(goose INTEGER)) +-- +ok +== +SELECT TRY_CAST('["a", "b", "c"]'::JSON AS INT[]) +-- +ok +== +SELECT TRY_CAST('{"duck":42}'::JSON AS MAP(INTEGER, INTEGER)) +-- +ok +== +SELECT TRY_CAST('{"42":"duck"}'::JSON AS MAP(INTEGER, INTEGER)) +-- +ok +== +CREATE TABLE structs (v STRUCT(duck INTEGER)) +-- +ok +== +CREATE TABLE lists (v VARCHAR[]) +-- +ok +== +CREATE table maps (v MAP(VARCHAR, INTEGER)) +-- +ok +== +INSERT INTO structs VALUES ('{"duck":42}'::JSON) +-- +ok +== +INSERT INTO lists VALUES ('["duck"]'::JSON) +-- +ok +== +INSERT INTO maps VALUES ('{"duck":42}'::JSON) +-- +ok +== +SELECT * FROM structs +-- +ok +== +SELECT * FROM lists +-- +ok +== +SELECT * FROM maps +-- +ok +== +CREATE TABLE jsons (j JSON) +-- +ok +== +INSERT INTO jsons SELECT * FROM structs +-- +ok +== +INSERT INTO jsons SELECT * FROM lists +-- +ok +== +INSERT INTO jsons SELECT * FROM maps +-- +ok +== +SELECT * FROM jsons +-- +ok +== +create type small_enum as enum ('DUCK_DUCK_ENUM', 'GOOSE'); +-- +ok +== +select bool, + tinyint, + smallint, + int, + bigint, + hugeint, + uhugeint, + utinyint, + usmallint, + uint, + ubigint, + date, + time, + timestamp, + timestamp_s, + timestamp_ms, + timestamp_ns, + time_tz, + timestamp_tz, + float, + double, + dec_4_1, + dec_9_4, + dec_18_6::DOUBLE as dec_18_6, + dec38_10::DOUBLE as dec38_10, + uuid, + interval, + small_enum, + int_array, + double_array, + date_array, + timestamp_array, + timestamptz_array, + varchar_array, + nested_int_array, + struct, + struct_of_arrays, + array_of_structs, + map, +from test_all_types() +-- +ok +== +create table all_types_json as +select bool::JSON as bool, + tinyint::JSON as tinyint, + smallint::JSON as smallint, + int::JSON as int, + bigint::JSON as bigint, + hugeint::JSON as hugeint, + uhugeint::JSON as uhugeint, + utinyint::JSON as utinyint, + usmallint::JSON as usmallint, + uint::JSON as uint, + ubigint::JSON as ubigint, + date::JSON as date, + time::JSON as time, + timestamp::JSON as timestamp, + timestamp_s::JSON as timestamp_s, + timestamp_ms::JSON as timestamp_ms, + timestamp_ns::JSON as timestamp_ns, + time_tz::JSON as time_tz, + timestamp_tz::JSON as timestamp_tz, + float::JSON as float, + double::JSON as double, + dec_4_1::JSON as dec_4_1, + dec_9_4::JSON as dec_9_4, + dec_18_6::DOUBLE::JSON as dec_18_6, + dec38_10::DOUBLE::JSON as dec38_10, + uuid::JSON as uuid, + interval::JSON as interval, + small_enum::JSON as small_enum, + int_array::JSON as int_array, + double_array::JSON as double_array, + date_array::JSON as date_array, + timestamp_array::JSON as timestamp_array, + timestamptz_array::JSON as timestamptz_array, + varchar_array::JSON as varchar_array, + nested_int_array::JSON as nested_int_array, + struct::JSON as struct, + struct_of_arrays::JSON as struct_of_arrays, + array_of_structs::JSON as array_of_structs, + map::JSON as map, +from test_all_types() +-- +ok +== +create table roundtrip as +select bool::BOOLEAN as bool, + tinyint::TINYINT as tinyint, + smallint::SMALLINT as smallint, + int::INTEGER as int, + bigint::BIGINT as bigint, + hugeint::HUGEINT as hugeint, + uhugeint::UHUGEINT as uhugeint, + utinyint::UTINYINT as utinyint, + usmallint::USMALLINT as usmallint, + uint::UINTEGER as uint, + ubigint::UBIGINT as ubigint, + date::DATE as date, + time::TIME as time, + timestamp::TIMESTAMP as timestamp, + timestamp_s::TIMESTAMP_S as timestamp_s, + timestamp_ms::TIMESTAMP_MS as timestamp_ms, + timestamp_ns::TIMESTAMP_NS as timestamp_ns, + time_tz::TIME WITH TIME ZONE as time_tz, + timestamp_tz::TIMESTAMP WITH TIME ZONE as timestamp_tz, + float::FLOAT as float, + double::DOUBLE as double, + dec_4_1::DECIMAL(4,1) as dec_4_1, + dec_9_4::DECIMAL(9,4) as dec_9_4, + dec_18_6::DOUBLE as dec_18_6, + dec38_10::DOUBLE as dec38_10, + uuid::UUID as uuid, + interval::INTERVAL as interval, + small_enum::small_enum as small_enum, + int_array::INTEGER[] as int_array, + double_array::DOUBLE[] as double_array, + date_array::DATE[] as date_array, + timestamp_array::TIMESTAMP[] as timestamp_array, + timestamptz_array::TIMESTAMP WITH TIME ZONE[] as timestamptz_array, + varchar_array::VARCHAR[] as varchar_array, + nested_int_array::INTEGER[][] as nested_int_array, + struct::STRUCT(a INTEGER, b VARCHAR) as struct, + struct_of_arrays::STRUCT(a INTEGER[], b VARCHAR[]) as struct_of_arrays, + array_of_structs::STRUCT(a INTEGER, b VARCHAR)[] as array_of_structs, + map::MAP(VARCHAR, VARCHAR) as map +from all_types_json +-- +ok +== +select * from roundtrip +-- +ok +== +select v from test_vector_types(null::int[], all_flat={all_flat}) tbl(v) +-- +error: Parser Error: syntax error at or near "}" +== +select v::JSON::INT[] from test_vector_types(null::int[], all_flat={all_flat}) tbl(v) +-- +error: Parser Error: syntax error at or near "}" +== +select v from test_vector_types(NULL::ROW(i INTEGER, j VARCHAR), all_flat={all_flat}) tbl(v) +-- +error: Parser Error: syntax error at or near "}" +== +select v::JSON::ROW(i INTEGER, j VARCHAR) from test_vector_types(NULL::ROW(i INTEGER, j VARCHAR), all_flat={all_flat}) tbl(v) +-- +error: Parser Error: syntax error at or near "}" +== +select ''::JSON +-- +ok +== +select ' '::JSON +-- +ok +== +select chr(0)::JSON +-- +ok +== +select ('duck' || chr(0))::JSON +-- +ok +== +select '[{"some_key":"some_v}alue"}]'::json[]; +-- +ok +== +with cte1 as (select 'a' as a), +cte2 as (select array_agg(cte1::json) as value from cte1) +select value::json[] from cte2; +-- +ok +== +with cte1 as ( + select array_agg({duck:42}::json) json_list_value + from range(5_000) +), cte2 as ( + select '[' || string_agg('{"duck":42}', ', ') || ']' string_value + from range(5_000) +) +select json_list_value::varchar = string_value, json_list_value = string_value::json[] +from cte1, cte2 +-- +ok +== diff --git a/parser/testdata/corpus/sql/json/scalar/test_geojson_cast.test b/parser/testdata/corpus/sql/json/scalar/test_geojson_cast.test new file mode 100644 index 0000000..1637b73 --- /dev/null +++ b/parser/testdata/corpus/sql/json/scalar/test_geojson_cast.test @@ -0,0 +1,61 @@ +# source: test/sql/json/scalar/test_geojson_cast.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +SELECT ST_AsText('{"type":"Point","coordinates":[1,2]}'::JSON::GEOMETRY); +-- +ok +== +SELECT ST_AsText('{"type":"Polygon","coordinates":[[[0,0],[1,0],[1,1],[0,0]]]}'::JSON::GEOMETRY); +-- +ok +== +SELECT ST_AsText('"POINT(9 9)"'::JSON::GEOMETRY); +-- +ok +== +SELECT '{"type":"Point","coordinates":[1,2]}'::JSON::GEOMETRY::VARCHAR; +-- +ok +== +CREATE TABLE mixed (j JSON); +-- +ok +== +INSERT INTO mixed VALUES ('{"type":"Point","coordinates":[1,2]}'), ('"LINESTRING(0 0, 1 1)"'), (NULL); +-- +ok +== +SELECT ST_AsText(j::GEOMETRY) FROM mixed; +-- +ok +== +SELECT to_json('POINT(1 2)'::GEOMETRY); +-- +ok +== +SELECT 'POINT(1 2)'::GEOMETRY::JSON; +-- +ok +== +SELECT to_json({a: 1, g: 'POINT(3 4)'::GEOMETRY}); +-- +ok +== +SELECT to_json(['POINT(1 2)'::GEOMETRY, 'POINT(3 4)'::GEOMETRY]); +-- +ok +== +SELECT to_json(NULL::GEOMETRY); +-- +ok +== +SELECT ST_AsText(from_json('{"g":{"type":"Point","coordinates":[5,6]}}', '{"g":"GEOMETRY"}').g); +-- +ok +== +SELECT '{"type":"Point","coordinates":["a","b"]}'::JSON::GEOMETRY; +-- +ok +== diff --git a/parser/testdata/corpus/sql/json/scalar/test_json_array_length.test b/parser/testdata/corpus/sql/json/scalar/test_json_array_length.test new file mode 100644 index 0000000..47efef9 --- /dev/null +++ b/parser/testdata/corpus/sql/json/scalar/test_json_array_length.test @@ -0,0 +1,45 @@ +# source: test/sql/json/scalar/test_json_array_length.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +create table test (j varchar) +-- +ok +== +insert into test values ('{}'), ('[]'), ('[1, 2, 3]') +-- +ok +== +select json_array_length(j) from test +-- +ok +== +select json_array_length(j, '$[1]') from test +-- +ok +== +SELECT json_array_length('[1,2,3,4]'); +-- +ok +== +SELECT json_array_length('[1,2,3,4]', '$'); +-- +ok +== +SELECT json_array_length('[1,2,3,4]', '$[2]'); +-- +ok +== +SELECT json_array_length('{"one":[1,2,3]}'); +-- +ok +== +SELECT json_array_length('{"one":[1,2,3]}', '$.one'); +-- +ok +== +SELECT json_array_length('{"one":[1,2,3]}', '$.two'); +-- +ok +== diff --git a/parser/testdata/corpus/sql/json/scalar/test_json_arrow_expr.test b/parser/testdata/corpus/sql/json/scalar/test_json_arrow_expr.test new file mode 100644 index 0000000..51121af --- /dev/null +++ b/parser/testdata/corpus/sql/json/scalar/test_json_arrow_expr.test @@ -0,0 +1,19 @@ +# source: test/sql/json/scalar/test_json_arrow_expr.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +CREATE TABLE testjson AS SELECT JSON '{ "key" : "value" }' AS example; +-- +ok +== +SELECT (SELECT (example)->k AS v FROM (SELECT 'key' AS k) keys) +FROM testjson; +-- +ok +== +SELECT (SELECT json_extract(example, k) AS v FROM (SELECT 'key' AS k) keys) +FROM testjson; +-- +ok +== diff --git a/parser/testdata/corpus/sql/json/scalar/test_json_contains.test b/parser/testdata/corpus/sql/json/scalar/test_json_contains.test new file mode 100644 index 0000000..c5d9ee3 --- /dev/null +++ b/parser/testdata/corpus/sql/json/scalar/test_json_contains.test @@ -0,0 +1,65 @@ +# source: test/sql/json/scalar/test_json_contains.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +SELECT JSON_CONTAINS('{"a": 1, "b": 2, "c": {"d": 3}}', '{"c": {"d": 3}}') AS Result; +-- +ok +== +SELECT JSON_CONTAINS('{"a": 1, "b": 2, "c": {"d": 3}}', '"c": {"d": 3}') AS Result; +-- +ok +== +select json_contains('[1, 2]', '[]') +-- +ok +== +select json_contains('[1, 2]', '2'); +-- +ok +== +select json_contains('[1, 2]', '[1, 2]'); +-- +ok +== +select json_contains('[1, 2, 3]', '[1, 2]'); +-- +ok +== +select json_contains('[1, 2]', '[2, 1]'); +-- +ok +== +select json_contains('{"a": {"b": [{"c": 1, "d": 2}]}}', '{"d": 2}') +-- +ok +== +select json_contains('{"a": {"b": [{"c": 1, "d": 2}]}}', '{"c": 1}') +-- +ok +== +select json_contains('{"a": {"b": [{"c": 1, "d": 2}]}}', '{"c": 1, "d": 2}') +-- +ok +== +select json_contains('{"a": {"b": [{"c": 1, "d": 2}]}}', '[{"d": 2, "c": 1}]') +-- +ok +== +select json_contains('{"a": {"b": [{"c": 1, "d": 2}]}}', '{"a": {"b": []}}') +-- +ok +== +select json_contains('{"a": {"b": [{"c": 1, "d": 2}]}}', '[]') +-- +ok +== +select json_contains(json('{"key":"value"}'),json('{"blah":"value"}')) +-- +ok +== +select json_contains('{"a": {"b": 42}}', '{"a": 42}') +-- +ok +== diff --git a/parser/testdata/corpus/sql/json/scalar/test_json_create.test b/parser/testdata/corpus/sql/json/scalar/test_json_create.test new file mode 100644 index 0000000..27d33cc --- /dev/null +++ b/parser/testdata/corpus/sql/json/scalar/test_json_create.test @@ -0,0 +1,287 @@ +# source: test/sql/json/scalar/test_json_create.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +SELECT TRY_CAST('{{P{P{{{{ASD{AS{D{' AS JSON); +-- +ok +== +select json_quote({n: 42}) +-- +ok +== +select to_json({n: 42}) +-- +ok +== +select to_json(42::VARIANT) +-- +ok +== +select json_array(42::VARIANT) +-- +ok +== +select json_object('x', 42::VARIANT) +-- +ok +== +select [{'a': 1, 'b': [1]}::VARIANT]::JSON +-- +ok +== +select to_json({n: 42}, {extra: 'argument'}) +-- +ok +== +select to_json(union_value(n := 42)) +-- +ok +== +SELECT to_json(union_value(a := NULL)::UNION(a INTEGER, b VARCHAR)) +-- +ok +== +SELECT to_json(union_value(b := 'abc')::UNION(a INTEGER, b VARCHAR, c FLOAT)) +-- +ok +== +select to_json(i::UNION(a varchar, b bool)) from (VALUES (null), ('test')) tbl(i); +-- +ok +== +select to_json(null::UNION(a varchar, b bool)); +-- +ok +== +select json_object('duck', 42) +-- +ok +== +select json_object('duck', '{"goose": [1, 2, 3, 4, 5, 6, 7]}'::JSON) +-- +ok +== +select json_object('nested', {duck: 42}) +-- +ok +== +select json_object('nested', [{duck: 42}, NULL]) +-- +ok +== +select json_object('nested', map(['duck'], [42])) +-- +ok +== +select json_object('nested', map(['duck', 'goose'], [42, 7])) +-- +ok +== +select json_object('nested', map(['0', 'goose'], [42, 7])) +-- +ok +== +select json_object('nested', map(['duck', 'goose'], [NULL, 7])) +-- +ok +== +select json_object('nested', [1, 2, 3]) +-- +ok +== +select json_object('nested', {nested2: [1, 2, 3]}) +-- +ok +== +select json_object('nested', [{nested2: 1}, {nested2: 2}, {nested2: 3}]) +-- +ok +== +create table test (a int, b double, c varchar, d int[], e uinteger) +-- +ok +== +insert into test values + (0, 0.5, 'short', [0, 1, 2, 3, 4, 5, 6, 7, 9], 33), + (42, 1, 'looooooooooooooong', [], 42), + (-42, 0.42, 2, [1, 2, 3], 1111), + (777, 19.96, 'duck', NULL, 1), + (-777, 4.2, 'goose', [4, 2], NULL) +-- +ok +== +select json_quote(struct_pack(a := a, b := b, c := c, d := d, e := e)) from test +-- +ok +== +select json_array(a, b, c, d, e) from test +-- +ok +== +select json_object(a::varchar, a, b::varchar, b, c, c, 'd', d, 'e', e) from test +-- +ok +== +select json_object(d::varchar, d) from test where d is null +-- +ok +== +select json_object(e::varchar, e) from test where e is null +-- +ok +== +select json_quote(map(list(a), list(b))) from test +-- +ok +== +select json_quote(map(list(b), list(c))) from test +-- +ok +== +select json_quote(map(list(c), list(d))) from test +-- +ok +== +select json_quote(map(list(d), list(e))) from test +-- +ok +== +select json_quote(map(list(c), list(e))) from test +-- +ok +== +select row_to_json({a: 42}) +-- +ok +== +select row_to_json({a: 42}, false) +-- +ok +== +select row_to_json(NULL) +-- +ok +== +select row_to_json([42]) +-- +ok +== +select array_to_json([42]) +-- +ok +== +select array_to_json(array_value(42)) +-- +ok +== +select array_to_json([42], [21]) +-- +ok +== +select array_to_json(NULL) +-- +ok +== +select array_to_json({a: 42}) +-- +ok +== +SELECT json_array(1,json_object('abc',2.5,'def',null,'ghi','hello'),99); +-- +ok +== +SELECT json_object('a',1,'b',2.5,'c',null,'d','String Test'); +-- +ok +== +SELECT json_object('a',1,'b'); +-- +ok +== +SELECT json_array(1,2.5,null,'hello'); +-- +ok +== +SELECT json_array(1,'{"abc":2.5,"def":null,"ghi":hello}',99); +-- +ok +== +SELECT json_array(1,json_quote('{"abc":2.5,"def":null,"ghi":"hello"}'),99); +-- +ok +== +SELECT json_object('ex','[52,3.14159]'); +-- +ok +== +SELECT json_object('ex','[52,3.14159]'::JSON); +-- +ok +== +SELECT json_object('ex',json_array(52,3.14159)); +-- +ok +== +SELECT json_object('a',2,'c',4); +-- +ok +== +SELECT json_object('a',2,'c','{e:5}'); +-- +ok +== +SELECT json_object('a',2,'c',json_object('e',5)); +-- +ok +== +SELECT json_array(1,2,'3',4); +-- +ok +== +SELECT json_array('[1,2]'); +-- +ok +== +SELECT json_array(json_array(1,2)); +-- +ok +== +SELECT json_array(1,null,'3','[4,5]','{"six":7.7}'); +-- +ok +== +SELECT json_array(1,null,'3','[4,5]'::JSON,'{"six":7.7}'::JSON); +-- +ok +== +SELECT json_array( + -9223372036854775808,9223372036854775807,0,1,-1, + 0.0, 1.0, -1.0, -1e99, +2e100, + 'one','two','three', + 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, + 19, NULL, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, + 'abcdefghijklmnopqrstuvwyxzABCDEFGHIJKLMNOPQRSTUVWXYZ', + 'abcdefghijklmnopqrstuvwyxzABCDEFGHIJKLMNOPQRSTUVWXYZ', + 'abcdefghijklmnopqrstuvwyxzABCDEFGHIJKLMNOPQRSTUVWXYZ', + 99); +-- +ok +== +SELECT CAST((MAP([5, 3, 4], ['a', 'b', 'c']), 2) AS JSON); +-- +ok +== +SELECT to_json(row(1, 'a', [2, 3])); +-- +ok +== +SELECT '[1,"a"]'::JSON::TUPLE(INTEGER, VARCHAR); +-- +ok +== +SELECT row(1, 'a')::JSON::TUPLE(INTEGER, VARCHAR); +-- +ok +== diff --git a/parser/testdata/corpus/sql/json/scalar/test_json_deep_merge.test b/parser/testdata/corpus/sql/json/scalar/test_json_deep_merge.test new file mode 100644 index 0000000..06a65f6 --- /dev/null +++ b/parser/testdata/corpus/sql/json/scalar/test_json_deep_merge.test @@ -0,0 +1,223 @@ +# source: test/sql/json/scalar/test_json_deep_merge.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +SELECT json_deep_merge('{"a": 1}', '{"a": 2}') +-- +ok +== +SELECT json_deep_merge('{"a": 1}', '{"b": 2}') +-- +ok +== +SELECT json_deep_merge('{"a": {"c": 1}}', '{"a": {"d": 2}}') +-- +ok +== +SELECT json_deep_merge('{"a": {"b": 1}}', '{"a": {"b": 2}}') +-- +ok +== +SELECT json_deep_merge('{"a":1,"b":2}', '{"b":null}') +-- +ok +== +SELECT json_deep_merge('{"a":{"x":1,"y":2}}', '{"a":{"y":null,"z":3}}') +-- +ok +== +SELECT json_deep_merge('{"a":null}', '{"a":1}') +-- +ok +== +SELECT json_deep_merge('{"a":null}', '{"a":null}') +-- +ok +== +SELECT json_deep_merge('{"a":{"b":{"c":1}}}', '{"a":{"b":{"c":null}}}') +-- +ok +== +SELECT json_deep_merge('{"a":1}', '{"b":null}') +-- +ok +== +SELECT json_deep_merge('42', '{"a":null}') +-- +ok +== +SELECT json_deep_merge('42', '{"a":1,"b":null}') +-- +ok +== +SELECT json_deep_merge('[1, 2]', '[true, false]') +-- +ok +== +SELECT json_deep_merge('{"name": "x"}', '{"id": 47}') +-- +ok +== +SELECT json_deep_merge('1', 'true') +-- +ok +== +SELECT json_deep_merge('[1, 2]', '{"id": 47}') +-- +ok +== +SELECT json_deep_merge('"hello"', '"world"') +-- +ok +== +SELECT json_deep_merge('"hello"', 'null') +-- +ok +== +SELECT json_deep_merge('42', 'null') +-- +ok +== +SELECT json_deep_merge('[1,2]', 'null') +-- +ok +== +SELECT json_deep_merge('{"a":[1,2]}', '{"a":[3,4]}') +-- +ok +== +SELECT json_deep_merge('{ "a": 1, "b":2 }','{ "a": 3, "c":4 }') +-- +ok +== +SELECT json_deep_merge(NULL, '{"a":1}') +-- +ok +== +SELECT json_deep_merge('{"a":1}', NULL) +-- +ok +== +SELECT json_deep_merge(NULL, NULL) +-- +ok +== +SELECT json_deep_merge('{"a":1}', '{"b":2}', '{"c":3}') +-- +ok +== +SELECT json_deep_merge('{"a":1}', '{"a":null}', '{"b":2}') +-- +ok +== +SELECT json_deep_merge('{"a":1}', '{"a":null}', '{"a":2}') +-- +ok +== +SELECT json_deep_merge('{ "a": 1, "b":2 }','{ "a": 3, "c":4 }','{ "a": 5, "d":6 }') +-- +ok +== +SELECT json_deep_merge(NULL, '{"b":2}', '{"c":3}') +-- +ok +== +SELECT json_deep_merge('{"a":1}', NULL, '{"c":3}') +-- +ok +== +SELECT json_deep_merge('{"a":1}', '{"b":2}', NULL) +-- +ok +== +SELECT json_deep_merge('{"a":{"x":1,"y":2},"b":3}', '{"a":{"y":null,"z":4},"c":5}') +-- +ok +== +SELECT json_deep_merge('{}', '{}') +-- +ok +== +SELECT json_deep_merge('{"a":1}', '{}') +-- +ok +== +SELECT json_deep_merge('{}', '{"a":1}') +-- +ok +== +SELECT json_deep_merge('{"a":{"b":{"c":{"d":1}}}}', '{"a":{"b":{"c":{"e":2}}}}') +-- +ok +== +SELECT json_deep_merge('{"a":{"b":1},"c":{"d":2}}', '{"a":null,"c":{"d":null}}') +-- +ok +== +CREATE TABLE merge_data (id INTEGER, base JSON, patch JSON); +-- +ok +== +INSERT INTO merge_data VALUES + (1, '{"a":1,"b":2}', '{"b":null}'), + (2, '{"x":{"y":1}}', '{"x":{"y":null,"z":2}}'), + (3, NULL, '{"a":1}'); +-- +ok +== +SELECT id, json_deep_merge(base, patch) FROM merge_data ORDER BY id +-- +ok +== +SELECT json_merge_patch('{"a":1,"b":2}', '{"b":null}'), json_deep_merge('{"a":1,"b":2}', '{"b":null}') +-- +ok +== +SELECT json_merge_patch('{"a":{"x":1}}', '{"a":{"x":null}}'), json_deep_merge('{"a":{"x":1}}', '{"a":{"x":null}}') +-- +ok +== +SELECT json_deep_merge('{"a":1}', '{"a":{"b":2}}') +-- +ok +== +SELECT json_deep_merge('{"a":{"b":2}}', '{"a":1}') +-- +ok +== +SELECT json_deep_merge('{"a":{"x":1}}', '{"a":{"x":null,"y":2},"b":null}') +-- +ok +== +SELECT json_deep_merge('{"a":1}', 'null') +-- +ok +== +SELECT json_deep_merge('null', '{"a":1}') +-- +ok +== +SELECT json_deep_merge('null', 'null') +-- +ok +== +SELECT json_deep_merge('{"a":1}', 'null', '{"b":2}') +-- +ok +== +SELECT json_deep_merge('{"a":1}', NULL, '{"b":2}') +-- +ok +== +SELECT json_deep_merge('{"a":1}', '{"b":null}') FROM range(3) +-- +ok +== +SELECT json_deep_merge( + '{"columnName":"user_id","parentColumn":null}', + '{"columnName":null,"parentColumn":"accounts.id"}' +) +-- +ok +== diff --git a/parser/testdata/corpus/sql/json/scalar/test_json_dot_syntax.test b/parser/testdata/corpus/sql/json/scalar/test_json_dot_syntax.test new file mode 100644 index 0000000..61cc924 --- /dev/null +++ b/parser/testdata/corpus/sql/json/scalar/test_json_dot_syntax.test @@ -0,0 +1,161 @@ +# source: test/sql/json/scalar/test_json_dot_syntax.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +SELECT json_structure(json('{"duck":"goose"}').duck); +-- +ok +== +select json('{"foo": null}').foo +-- +ok +== +select json('{"foo": null}').foo.bar +-- +ok +== +select json('{"foo": null}')['foo'] +-- +ok +== +select json('{"foo": null}')['foo']['bar'] +-- +ok +== +select json('null') +-- +ok +== +select json('[null]')."0" +-- +ok +== +select json('{"my_field": {"my_nested_field": ["goose", "duck"]}}').my_field.my_nested_field."1" +-- +ok +== +select json('{"my_field": {"my_nested_field": ["goose", "duck"]}}').my_field.my_nested_field[1] +-- +ok +== +select ('{"my_field": {"my_nested_field": ["goose", "duck"]}}'::JSON).my_field.my_nested_field."1" +-- +ok +== +select ('{"my_field": {"my_nested_field": ["goose", "duck"]}}'::JSON).my_field.my_nested_field[1] +-- +ok +== +select ('{"my_field": {"my_nested_field": ["goose", "duck"]}}'::JSON).my_field.my_nested_field[-1] +-- +ok +== +select ('{"my_field": {"my_nested_field": ["goose", "duck"]}}'::JSON).my_field.my_nested_field[0:1] +-- +ok +== +select json('{"my_field": {"my_nested_field": ["goose", "duckduckduckduck"]}}').my_field.my_nested_field[1] +-- +ok +== +select ('{"my_field": {"my_nested_field": ["goose", "duckduckduckduck"]}}'::JSON).my_field.my_nested_field[1] +-- +ok +== +select json('[1, 2, 42]')."2" +-- +ok +== +select json('[1, 2, 42]')[2] +-- +ok +== +select json('[1, 2, 42]')[2]::text +-- +ok +== +SELECT json('{"a":2,"c":[4,5,{"f":7}]}').c +-- +ok +== +SELECT json('{"a":2,"c":[4,5,{"f":7}]}').c[2] +-- +ok +== +SELECT json('{"a":2,"c":[4,5,{"f":7}]}').c[2].f +-- +ok +== +SELECT json('{"a":2,"c":[4,5,{"f":7}]}').x +-- +ok +== +CREATE TABLE obj(x varchar); +-- +ok +== +INSERT INTO obj VALUES('{"a":1,"b":2}'); +-- +ok +== +SELECT json(x).b FROM obj; +-- +ok +== +SELECT json(x)."b" FROM obj; +-- +ok +== +CREATE TABLE t12(x varchar); +-- +ok +== +INSERT INTO t12(x) VALUES( +'{"settings": + {"layer2": + {"hapax.legomenon": + {"forceDisplay":true, + "transliterate":true, + "add.footnote":true, + "summary.report":true}, + "dis.legomenon": + {"forceDisplay":true, + "transliterate":false, + "add.footnote":false, + "summary.report":true}, + "tris.legomenon": + {"forceDisplay":true, + "transliterate":false, + "add.footnote":false, + "summary.report":false} + } + } + }'); +-- +ok +== +SELECT json(x).settings.layer2."tris.legomenon"."summary.report" FROM t12; +-- +ok +== +SELECT (x::JSON).settings.layer2."tris.legomenon"."summary.report" FROM t12; +-- +ok +== +SELECT json('{"foo": "bar"}').foo = 'bar'; +-- +ok +== +SELECT json('{"foo": "bar"}').foo = '"bar"'; +-- +ok +== +SELECT json('{"foo": 1}').foo = 1; +-- +ok +== +SELECT json('{"foo": "bar"}') = {foo: 'bar'} +-- +ok +== diff --git a/parser/testdata/corpus/sql/json/scalar/test_json_exists.test b/parser/testdata/corpus/sql/json/scalar/test_json_exists.test new file mode 100644 index 0000000..0698e70 --- /dev/null +++ b/parser/testdata/corpus/sql/json/scalar/test_json_exists.test @@ -0,0 +1,31 @@ +# source: test/sql/json/scalar/test_json_exists.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +SELECT json_exists('{"duck": null}', '$.duck') +-- +ok +== +with path AS ( + SELECT '$.duck' p +) +SELECT json_exists('{"duck": null}', p) FROM path +-- +ok +== +SELECT json_exists('{"duck": null}', '$.goose') +-- +ok +== +with path AS ( + SELECT '$.goose' p +) +SELECT json_exists('{"duck": null}', p) FROM path +-- +ok +== +SELECT json_exists('{"duck": null}', ['$.duck', '$.goose']) +-- +ok +== diff --git a/parser/testdata/corpus/sql/json/scalar/test_json_extract.test b/parser/testdata/corpus/sql/json/scalar/test_json_extract.test new file mode 100644 index 0000000..3edd7dc --- /dev/null +++ b/parser/testdata/corpus/sql/json/scalar/test_json_extract.test @@ -0,0 +1,272 @@ +# source: test/sql/json/scalar/test_json_extract.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +SELECT json_structure('{"duck":"goose"}'->'duck'); +-- +ok +== +select json_extract('{"foo": null}', '$.foo') +-- +ok +== +select json_extract('{"foo": null}', '$.foo.bar') +-- +ok +== +select json_extract('null', '$') +-- +ok +== +select json_extract('[null]', '$[0]') +-- +ok +== +select json_extract('{"my_field": {"my_nested_field": ["goose", "duck"]}}', '/my_field/my_nested_field/1') +-- +ok +== +select json_extract_path('{"my_field": {"my_nested_field": ["goose", "duck"]}}', '/my_field/my_nested_field/1') +-- +ok +== +select '{"my_field": {"my_nested_field": ["goose", "duck"]}}'::JSON->'/my_field/my_nested_field/1' +-- +ok +== +select json_extract_string('{"my_field": {"my_nested_field": ["goose", "duck"]}}', '/my_field/my_nested_field/1') +-- +ok +== +select json_extract_path_text('{"my_field": {"my_nested_field": ["goose", "duck"]}}', '/my_field/my_nested_field/1') +-- +ok +== +select '{"my_field": {"my_nested_field": ["goose", "duck"]}}'::JSON->>'/my_field/my_nested_field/1' +-- +ok +== +select json_extract('{"my_field": {"my_nested_field": ["goose", "duckduckduckduck"]}}', '/my_field/my_nested_field/1') +-- +ok +== +select '{"my_field": {"my_nested_field": ["goose", "duckduckduckduck"]}}'::JSON->'/my_field/my_nested_field/1' +-- +ok +== +select json_extract_string('{"my_field": {"my_nested_field": ["goose", "duckduckduckduck"]}}', '/my_field/my_nested_field/1') +-- +ok +== +select '{"my_field": {"my_nested_field": ["goose", "duckduckduckduck"]}}'::JSON->>'/my_field/my_nested_field/1' +-- +ok +== +select json_extract('[1, 2, 42]', 2) +-- +ok +== +select json_extract_string('[1, 2, 42]', 2) +-- +ok +== +select '{"my_field": {"my_nested_field": ["goose", "duck"]}}'::JSON->'my_field'->'my_nested_field'->>1 +-- +ok +== +SELECT json_extract('{"a":2,"c":[4,5,{"f":7}]}', '$'); +-- +ok +== +SELECT json_extract('{"a":2,"c":[4,5,{"f":7}]}', '$.c'); +-- +ok +== +SELECT json_extract('{"a":2,"c":[4,5,{"f":7}]}', '$.c[2]'); +-- +ok +== +SELECT json_extract('{"a":2,"c":[4,5,{"f":7}]}', '$.c[2].f'); +-- +ok +== +SELECT json_extract('{"a":2,"c":[4,5,{"f":7}]}', '$.x'); +-- +ok +== +with tbl as ( + select '{"a":2,"c":[4,5],"f":7}' j, ['$.c','$.a'] p +) +SELECT json_extract(j, p); +-- +ok +== +SELECT json_extract('{"a":2,"c":[4,5],"f":7}', ['$.c','$.a']); +-- +ok +== +SELECT json_extract('{"a":2,"c":[4,5,{"f":7}]}', ['$.x', '$.a']); +-- +ok +== +SELECT json_extract(NULL, ['$.x', '$.a']); +-- +ok +== +CREATE TABLE t1(j varchar); +-- +ok +== +INSERT INTO t1(j) VALUES('{"a":1,"b":[1,[2,3],4],"c":99}'); +-- +ok +== +SELECT json_extract(j, '$.b[#]') FROM t1; +-- +ok +== +SELECT json_extract(j, '$.b[#-0]') a, a = json_extract(j, '$.b[-0]') FROM t1; +-- +ok +== +SELECT json_extract(j, '$.b[#-1]') a, a = json_extract(j, '$.b[-1]') FROM t1; +-- +ok +== +SELECT json_extract(j, '$.b[#-2]') a, a = json_extract(j, '$.b[-2]') FROM t1; +-- +ok +== +SELECT json_extract(j, '$.b[#-02]') a, a = json_extract(j, '$.b[-02]') FROM t1; +-- +ok +== +SELECT json_extract(j, '$.b[#-3]') a, a = json_extract(j, '$.b[-3]') FROM t1; +-- +ok +== +SELECT json_extract(j, '$.b[#-4]'), json_extract(j, '$.b[-4]') FROM t1; +-- +ok +== +SELECT json_extract(j, '$.b[#-2][#-1]') a, a = json_extract(j, '$.b[-2][-1]') FROM t1; +-- +ok +== +SELECT j::JSON->'$.b[#-2][#-1]' a, a = (j::JSON->'$.b[-2][-1]') FROM t1; +-- +ok +== +SELECT json_extract(j, ['$.b[0]', '$.b[#-1]']) a, a = json_extract(j, ['$.b[0]', '$.b[-1]']) FROM t1; +-- +ok +== +SELECT j::JSON->['$.b[0]', '$.b[#-1]'] a, a = (j::JSON->['$.b[0]', '$.b[-1]']) FROM t1; +-- +ok +== +SELECT json_extract(j, '$.a[#-1]'), json_extract(j, '$.a[-1]') FROM t1; +-- +ok +== +SELECT json_extract(j, '$.b[#-000001]') a, a = json_extract(j, '$.b[-000001]') FROM t1; +-- +ok +== +SELECT j::JSON->'$.b[#-000001]' a, a = (j::JSON->'$.b[-000001]') FROM t1; +-- +ok +== +SELECT json_extract(j, '$.b[#-]') FROM t1; +-- +ok +== +SELECT json_extract(j, '$.b[-]') FROM t1; +-- +ok +== +SELECT json_extract(j, '$.b[#9]') FROM t1; +-- +ok +== +SELECT json_extract(j, '$.b[#+2]') FROM t1; +-- +ok +== +SELECT json_extract(j, '$.b[#-1') FROM t1; +-- +ok +== +SELECT json_extract(j, '$.b[#-1x]') FROM t1; +-- +ok +== +SELECT json_extract(x, '$.b') FROM obj; +-- +ok +== +SELECT json_extract(x, '$."b"') FROM obj; +-- +ok +== +SELECT json_extract(x, '$.settings.layer2."tris.legomenon"."summary.report"') FROM t12; +-- +ok +== +SELECT x::JSON->'$.settings.layer2."tris.legomenon"."summary.report"' FROM t12; +-- +ok +== +create table test5063 as select '{"a": 1, "b": 2}' js +-- +ok +== +prepare q1 as SELECT js->CAST(? AS STRING) FROM test5063 +-- +ok +== +execute q1('a') +-- +ok +== +select json_extract_string(json('{"j[so]n_\"key": 67}'), '$."j[so]n_\"key"'); +-- +ok +== +select '{"\"duck\"": 42}'->'$."\"duck\""'; +-- +ok +== +select '{"\"du\\ck\"": 42}'->'$."\"du\\ck\""'; +-- +ok +== +select '{"\"du\\ck\"": 42}'->'$."\"du\ck\""'; +-- +ok +== +select '{"du\\ck": 42}'->'$.du\ck'; +-- +ok +== +select '{"\"du\nck\"": 42}'->'$."\"du\nck\""'; +-- +ok +== +select '{"\"du\nck\"": 42}'->('$."\"du' || chr(10) || 'ck\""'); +-- +ok +== +select '{"duck":null}'->'$.duck' +-- +ok +== +select '{"duck":null}'->>'$.duck' +-- +ok +== +select json_extract('{"hello":1}', '') +-- +ok +== diff --git a/parser/testdata/corpus/sql/json/scalar/test_json_extract_input_types.test b/parser/testdata/corpus/sql/json/scalar/test_json_extract_input_types.test new file mode 100644 index 0000000..ff881c4 --- /dev/null +++ b/parser/testdata/corpus/sql/json/scalar/test_json_extract_input_types.test @@ -0,0 +1,66 @@ +# source: test/sql/json/scalar/test_json_extract_input_types.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +pragma enable_verification +-- +ok +== +CREATE TABLE tricky (v VARCHAR); +-- +ok +== +INSERT INTO tricky VALUES + ('{"a":1,"b":2}'), + ('{ "a" : 1 , "b" : [ 1 , 2 , 3 ] }'), + ('{"a":{"a":{"a":1}}}'), + ('{"x":"a\"b","a":"quoted \" inside"}'), + ('{"a\"b":1,"c":2}'), + ('{"a":"]}","b":"{["}'), + ('{"a":[[1,2],[3,[4,5]]],"b":{"c":[{"d":1}]}}'), + ('[1,"two",{"three":3},[4],null,true,false,1.5e2]'), + ('{"a":null,"b":false}'), + ('{"":1,"a":2}'), + ('{"a":1,"a":2}'), + ('{"日本":"語","a":"日本語"}'), + ('{"a": {"b" : [ {"c" : "d,e]}"} ] } }'), + (' {"a":1} '), + ('{"tail":"' || repeat('x', 100) || '","a":9}'), + ('true'), + ('[]'), + ('{}'), + ('{"a":nan,"b":inf}'), + ('{"a":NaN,"b":-Infinity}'), + ('{"a":"true","b":"null"}'); +-- +ok +== +SELECT count(*) FROM tricky WHERE json_extract(v, ['$.a', '$.b.c', '$[0]']) IS DISTINCT FROM json_extract(v::JSON, ['$.a', '$.b.c', '$[0]']) +-- +ok +== +SELECT ('{ "user" : { "name" : "a\"b" } }'::JSON)->>'$.user.name' +-- +ok +== +SELECT ('{"a":[10,20,30]}'::JSON)->'$.a[1]' +-- +ok +== +SELECT ('[1,2]'::JSON)->1 +-- +ok +== +SELECT ('1'::JSON)->'$' +-- +ok +== +SELECT ('{"a":{"b":"]}"}}'::JSON)->>'$.a.b' +-- +ok +== +SELECT ('{"a":[10,20,30]}'::JSON)->'$.a[#-1]' +-- +ok +== diff --git a/parser/testdata/corpus/sql/json/scalar/test_json_icu.test b/parser/testdata/corpus/sql/json/scalar/test_json_icu.test new file mode 100644 index 0000000..ea27dfa --- /dev/null +++ b/parser/testdata/corpus/sql/json/scalar/test_json_icu.test @@ -0,0 +1,17 @@ +# source: test/sql/json/scalar/test_json_icu.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +set calendar = 'gregorian'; +-- +ok +== +set timezone = 'Europe/Berlin'; +-- +ok +== +select '1992-09-20 11:30:00.987654321'::TIMESTAMPTZ::JSON j; +-- +ok +== diff --git a/parser/testdata/corpus/sql/json/scalar/test_json_insert.test b/parser/testdata/corpus/sql/json/scalar/test_json_insert.test new file mode 100644 index 0000000..ab49b74 --- /dev/null +++ b/parser/testdata/corpus/sql/json/scalar/test_json_insert.test @@ -0,0 +1,160 @@ +# source: test/sql/json/scalar/test_json_insert.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +SELECT json_insert('{"a":1}', '$.b', '2') +-- +ok +== +SELECT json_insert('{"a":1}', '$.a', '99') +-- +ok +== +SELECT json_insert('{"a":1}', '/b', '2') +-- +ok +== +SELECT json_insert('{"a":{"x":1}}', '$.a.y', '2') +-- +ok +== +SELECT json_insert('{"a":{"x":1}}', '$.a.x', '99') +-- +ok +== +SELECT json_insert('{}', '$.a.b.c', '1') +-- +ok +== +SELECT json_insert('[1,2,3]', '$[1]', '99') +-- +ok +== +SELECT json_insert('[1,2]', '/-', '3') +-- +ok +== +SELECT json_insert('[1,2]', '$[#]', '3') +-- +ok +== +SELECT json_insert('[1,2]', '$[2]', '3') +-- +ok +== +SELECT json_insert('[1,2]', '$[5]', '9') +-- +ok +== +SELECT json_insert('[{"a":1}]', '$[0].b', '2') +-- +ok +== +SELECT json_insert('{}', '$.s', '"hello"') +-- +ok +== +SELECT json_insert('{}', '$.n', 'null') +-- +ok +== +SELECT json_insert('{}', '$.obj', '{"x":1}') +-- +ok +== +SELECT json_insert('{"a":1}', '$', '2') +-- +ok +== +SELECT json_insert(NULL, '$.a', '1') +-- +ok +== +SELECT json_insert('{"a":1}', NULL, '1') +-- +ok +== +SELECT json_insert('{"a":1}', '$.a', NULL) +-- +ok +== +SELECT json_insert('{"a":1}', 'b', '2') +-- +ok +== +SELECT json_insert('{"a":1}', 'a', '9') +-- +ok +== +SELECT json_insert('{"a":1}', '$.b', '2'::JSON) +-- +ok +== +SELECT json_insert('{"a":1}', '$.b', '2') FROM range(3) +-- +ok +== +CREATE TABLE configs (id INTEGER, cfg JSON); +-- +ok +== +INSERT INTO configs VALUES + (1, '{"retries":5}'), + (2, '{"timeout":30}'), + (3, '{}'); +-- +ok +== +SELECT id, json_insert(cfg, '$.retries', '3') FROM configs ORDER BY id +-- +ok +== +SELECT json_normalize(json_insert('{"z":1}', '$.a', '2')) +-- +ok +== +SELECT json_insert('{"a\"b":1}', '$."a\"b"', '9') +-- +ok +== +SELECT json_insert('{"a\\":2}', '$."a\"b"', '9') +-- +ok +== +SELECT json_insert('[1,2]', '$[#-1]', '9') +-- +ok +== +SELECT json_insert('[1,2]', '$[#-0]', '9') +-- +ok +== +SELECT json_insert('[1,2]', '$[#-5]', '9') +-- +ok +== +SELECT json_insert('{"a":[1]}', '$.a[#]', '2') +-- +ok +== +SELECT json_insert('{"a":1}', '', '2') +-- +ok +== +SELECT json_insert('{"a":1}', '$not_a_path', '2') +-- +ok +== +SELECT json_insert('{"a":1}', '$.*', '9') +-- +ok +== +SELECT json_insert('{}', '$.a[0]', '1') +-- +ok +== +SELECT json_insert('{"a":[0]}', '$.a[1].b', '5') +-- +ok +== diff --git a/parser/testdata/corpus/sql/json/scalar/test_json_keys.test b/parser/testdata/corpus/sql/json/scalar/test_json_keys.test new file mode 100644 index 0000000..9303e9b --- /dev/null +++ b/parser/testdata/corpus/sql/json/scalar/test_json_keys.test @@ -0,0 +1,54 @@ +# source: test/sql/json/scalar/test_json_keys.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +select json_keys('{"duck": 42}'); +-- +ok +== +select json_keys('{"duck": 42, "goose": 43}'); +-- +ok +== +select json_keys('["duck", "goose"]'); +-- +ok +== +select json_keys(NULL) +-- +ok +== +select json_keys('{"duck": {"key1": 42}, "goose": {"key1": 42, "key2": 43}}', ['duck', 'goose']) +-- +ok +== +select typeof(json_keys('{"duck": {"key1": 42}, "goose": {"key1": 42, "key2": 43}}', '$.*')), + json_keys('{"duck": {"key1": 42}, "goose": {"key1": 42, "key2": 43}}', '$.*') +-- +ok +== +create table t1 as +select range, case when range % 2 = 0 then '{"duck": 42}' else '{"duck": 42, "goose": 43}' end j +from range(10000) +-- +ok +== +select range % 2 g, sum(length(json_keys(j))) c +from t1 +group by g +order by all +-- +ok +== +create table t2 as +select range, '{"duck": {"key1": 42}, "goose": {"key1": 42, "key2": 43}}' j +from range(10000) +-- +ok +== +select sum(list_sum([length(l) for l in json_keys(j, ['duck', 'goose'])])) s +from t2 +-- +ok +== diff --git a/parser/testdata/corpus/sql/json/scalar/test_json_merge_patch.test b/parser/testdata/corpus/sql/json/scalar/test_json_merge_patch.test new file mode 100644 index 0000000..c1808cb --- /dev/null +++ b/parser/testdata/corpus/sql/json/scalar/test_json_merge_patch.test @@ -0,0 +1,81 @@ +# source: test/sql/json/scalar/test_json_merge_patch.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +SELECT json_merge_patch('{"a": 1}', '{"a": 2}') +-- +ok +== +SELECT json_merge_patch('{"a": 1}', '{"b": 2}') +-- +ok +== +SELECT json_merge_patch('{"a": {"c": 1}}', '{"a": {"d": 2}}') +-- +ok +== +SELECT json_merge_patch('{"a": {"b": 1}}', '{"a": {"b": 2}}') +-- +ok +== +SELECT JSON_MERGE_PATCH('[1, 2]', '[true, false]'); +-- +ok +== +SELECT JSON_MERGE_PATCH('{"name": "x"}', '{"id": 47}'); +-- +ok +== +SELECT JSON_MERGE_PATCH('1', 'true'); +-- +ok +== +SELECT JSON_MERGE_PATCH('[1, 2]', '{"id": 47}'); +-- +ok +== +SELECT JSON_MERGE_PATCH('{ "a": 1, "b":2 }','{ "a": 3, "c":4 }'); +-- +ok +== +SELECT JSON_MERGE_PATCH('{ "a": 1, "b":2 }','{ "a": 3, "c":4 }','{ "a": 5, "d":6 }'); +-- +ok +== +SELECT JSON_MERGE_PATCH('{"a":1, "b":2}', '{"b":null}'); +-- +ok +== +SELECT JSON_MERGE_PATCH('{"a":{"x":1}}', '{"a":{"y":2}}'); +-- +ok +== +select json_merge_patch(NULL, '3') +-- +ok +== +select json_merge_patch('3', NULL) +-- +ok +== +select json_merge_patch(NULL, NULL) +-- +ok +== +select json_merge_patch('{"a":1}', '{"b":2}', '{"c":3}') +-- +ok +== +select json_merge_patch(NULL, '{"b":2}', '{"c":3}') +-- +ok +== +select json_merge_patch('{"a":1}', NULL, '{"c":3}') +-- +ok +== +select json_merge_patch('{"a":1}', '{"b":2}', NULL) +-- +ok +== diff --git a/parser/testdata/corpus/sql/json/scalar/test_json_merge_patch_diff.test b/parser/testdata/corpus/sql/json/scalar/test_json_merge_patch_diff.test new file mode 100644 index 0000000..1c10825 --- /dev/null +++ b/parser/testdata/corpus/sql/json/scalar/test_json_merge_patch_diff.test @@ -0,0 +1,213 @@ +# source: test/sql/json/scalar/test_json_merge_patch_diff.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +SELECT json_merge_patch_diff('{"a":1}', '{"a":2}') +-- +ok +== +SELECT json_merge_patch_diff('{"a":1}', '{"a":1,"b":2}') +-- +ok +== +SELECT json_merge_patch_diff('{"a":1,"b":2}', '{"a":1}') +-- +ok +== +SELECT json_merge_patch_diff('{"a":1}', '{"a":1}') +-- +ok +== +SELECT json_merge_patch_diff('{"a":1,"b":2,"c":3}', '{"a":1,"b":99,"d":4}') +-- +ok +== +SELECT json_merge_patch_diff('{"user":{"name":"Alice","age":30}}', '{"user":{"name":"Alice","age":31}}') +-- +ok +== +SELECT json_merge_patch_diff('{"a":{"x":1,"y":2}}', '{"a":{"x":1}}') +-- +ok +== +SELECT json_merge_patch_diff('{"a":{"x":1}}', '{"a":{"x":1,"y":2}}') +-- +ok +== +SELECT json_merge_patch_diff('{"a":{"b":{"c":1,"d":2}}}', '{"a":{"b":{"c":1,"d":3}}}') +-- +ok +== +SELECT json_merge_patch_diff('{"a":{"x":1},"b":2}', '{"b":2}') +-- +ok +== +SELECT json_merge_patch_diff('{"b":2}', '{"a":{"x":1},"b":2}') +-- +ok +== +SELECT json_merge_patch_diff('{"tags":[1,2]}', '{"tags":[3]}') +-- +ok +== +SELECT json_merge_patch_diff('{"tags":[1,2]}', '{"tags":[1,2]}') +-- +ok +== +SELECT json_merge_patch_diff('"hello"', '"world"') +-- +ok +== +SELECT json_merge_patch_diff('42', '99') +-- +ok +== +SELECT json_merge_patch_diff('true', 'false') +-- +ok +== +SELECT json_merge_patch_diff('{"a":1}', '42') +-- +ok +== +SELECT json_merge_patch_diff('42', '{"a":1}') +-- +ok +== +SELECT json_merge_patch_diff('"hello"', '"hello"') +-- +ok +== +SELECT json_merge_patch_diff('42', '42') +-- +ok +== +SELECT json_merge_patch_diff('true', 'true') +-- +ok +== +SELECT json_merge_patch_diff('null', 'null') +-- +ok +== +SELECT json_merge_patch_diff('[1,2,3]', '[1,2,3]') +-- +ok +== +SELECT json_merge_patch_diff('{"a":1}', '[1,2]') +-- +ok +== +SELECT json_merge_patch_diff(NULL, '{"a":1}') +-- +ok +== +SELECT json_merge_patch_diff('{"a":1}', NULL) +-- +ok +== +SELECT json_merge_patch_diff(NULL, NULL) +-- +ok +== +SELECT json_merge_patch_diff('{}', '{}') +-- +ok +== +SELECT json_merge_patch_diff('{}', '{"a":1}') +-- +ok +== +SELECT json_merge_patch_diff('{"a":1}', '{}') +-- +ok +== +SELECT json_merge_patch_diff('{"a":1}', '{"a":null}') +-- +ok +== +SELECT json_merge_patch_diff('{"a":null}', '{"a":1}') +-- +ok +== +SELECT json_merge_patch_diff('{"a":null}', '{"a":null}') +-- +ok +== +SELECT json_merge_patch_diff('{"active":true}', '{"active":false}') +-- +ok +== +SELECT json_merge_patch_diff('{"name":"Alice"}', '{"name":"Bob"}') +-- +ok +== +SELECT json_merge_patch('{"a":1,"b":2,"c":3}', json_merge_patch_diff('{"a":1,"b":2,"c":3}', '{"a":1,"b":99,"d":4}')) = '{"a":1,"b":99,"d":4}' +-- +ok +== +SELECT json_merge_patch('{"user":{"name":"Alice","age":30}}', json_merge_patch_diff('{"user":{"name":"Alice","age":30}}', '{"user":{"name":"Alice","age":31}}')) = '{"user":{"name":"Alice","age":31}}' +-- +ok +== +SELECT json_merge_patch('{"a":1,"b":2}', json_merge_patch_diff('{"a":1,"b":2}', '{"a":1}')) = '{"a":1}' +-- +ok +== +SELECT json_merge_patch_diff('{"a":1}', '{"a":2}') FROM range(3) +-- +ok +== +CREATE TABLE versions (id INTEGER, old_state JSON, new_state JSON); +-- +ok +== +INSERT INTO versions VALUES + (1, '{"name":"Alice","age":30}', '{"name":"Alice","age":31}'), + (2, '{"a":1,"b":2}', '{"a":1}'), + (3, NULL, '{"new":true}'); +-- +ok +== +SELECT id, json_merge_patch_diff(old_state, new_state) FROM versions ORDER BY id +-- +ok +== +SELECT json_merge_patch_diff('{"a":{"x":1}}', '{"a":42}') +-- +ok +== +SELECT json_merge_patch_diff('{"a":42}', '{"a":{"x":1}}') +-- +ok +== +SELECT json_merge_patch_diff('{"a":{"b":{"c":{"d":1}}}}', '{"a":{"b":{"c":{"d":1}}}}') +-- +ok +== +SELECT json_merge_patch_diff('{"items":[{"a":1}]}', '{"items":[{"a":2}]}') +-- +ok +== +SELECT json_merge_patch_diff('{"arr":[1,2,3]}', '{"arr":[1,2,4]}') +-- +ok +== +SELECT json_merge_patch( + '{"a":1,"b":{"x":1,"y":2},"c":3,"d":{"e":5}}', + json_merge_patch_diff( + '{"a":1,"b":{"x":1,"y":2},"c":3,"d":{"e":5}}', + '{"a":1,"b":{"x":1,"z":3},"d":{"e":5,"f":6},"g":7}' + ) +) = '{"a":1,"b":{"x":1,"z":3},"d":{"e":5,"f":6},"g":7}' +-- +ok +== +SELECT json_merge_patch_diff( + '{"name":"Alice","age":30,"city":"NYC","score":100}', + '{"name":"Alice","age":31,"city":"SF","verified":true}' +) +-- +ok +== diff --git a/parser/testdata/corpus/sql/json/scalar/test_json_normalize.test b/parser/testdata/corpus/sql/json/scalar/test_json_normalize.test new file mode 100644 index 0000000..d4ff968 --- /dev/null +++ b/parser/testdata/corpus/sql/json/scalar/test_json_normalize.test @@ -0,0 +1,177 @@ +# source: test/sql/json/scalar/test_json_normalize.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +SELECT json_normalize('{"z":1,"a":2,"m":3}') +-- +ok +== +SELECT json_normalize('{"a":1,"b":2,"c":3}') +-- +ok +== +SELECT json_normalize('{"b":1,"a":2}') +-- +ok +== +SELECT json_normalize('{"b":{"z":1,"a":2},"a":3}') +-- +ok +== +SELECT json_normalize('{"c":{"b":{"z":1,"a":2},"a":3},"a":4}') +-- +ok +== +SELECT json_normalize('{"b":[3,1,2],"a":1}') +-- +ok +== +SELECT json_normalize('[{"z":1,"a":2},{"y":3,"b":4}]') +-- +ok +== +SELECT json_normalize('{"z":"hello","m":true,"a":null,"f":42,"c":[1,2]}') +-- +ok +== +SELECT json_normalize('{}') +-- +ok +== +SELECT json_normalize('[]') +-- +ok +== +SELECT json_normalize('"hello"') +-- +ok +== +SELECT json_normalize('42') +-- +ok +== +SELECT json_normalize('true') +-- +ok +== +SELECT json_normalize('null') +-- +ok +== +SELECT json_normalize(NULL) +-- +ok +== +SELECT json_normalize('{"z":{"y":{"x":{"w":{"v":{"b":2,"a":1}}}}}}') +-- +ok +== +SELECT json_normalize('[1,"two",{"c":3,"a":1},null,[5,6]]') +-- +ok +== +SELECT json_normalize('{"t":20,"s":19,"r":18,"q":17,"p":16,"o":15,"n":14,"m":13,"l":12,"k":11,"j":10,"i":9,"h":8,"g":7,"f":6,"e":5,"d":4,"c":3,"b":2,"a":1}') +-- +ok +== +SELECT json_normalize('{"zzz":3,"äbc":1,"abc":2}') +-- +ok +== +SELECT md5(json_normalize('{"z":1,"a":2}')) = md5(json_normalize('{"a":2,"z":1}')) +-- +ok +== +SELECT md5(json_normalize('{"b":{"z":1,"a":2},"a":3}')) = md5(json_normalize('{"a":3,"b":{"a":2,"z":1}}')) +-- +ok +== +SELECT json_normalize('{"a":1}') +-- +ok +== +SELECT json_normalize('{"b":{},"a":[]}') +-- +ok +== +SELECT json_normalize('{"2":2,"10":10,"1":1}') +-- +ok +== +SELECT json_normalize('[3,2,1]') +-- +ok +== +SELECT json_normalize('[[{"b":2,"a":1}],[{"d":4,"c":3}]]') +-- +ok +== +SELECT json_normalize('{"z":1,"a":2}'::JSON) +-- +ok +== +CREATE TABLE json_data (id INTEGER, data JSON); +-- +ok +== +INSERT INTO json_data VALUES (1, '{"z":1,"a":2}'), (2, '{"b":3,"a":4}'), (3, NULL); +-- +ok +== +SELECT id, json_normalize(data) FROM json_data ORDER BY id +-- +ok +== +CREATE TABLE json_pairs (id INTEGER, v1 JSON, v2 JSON); +-- +ok +== +INSERT INTO json_pairs VALUES (1, '{"z":1,"a":2}', '{"a":2,"z":1}'), (2, '{"b":{"z":1,"a":2},"a":3}', '{"a":3,"b":{"a":2,"z":1}}'); +-- +ok +== +SELECT id, md5(json_normalize(v1)) = md5(json_normalize(v2)) FROM json_pairs ORDER BY id +-- +ok +== +SELECT json_normalize('{ "z" : 1 , "a" : 2 }') +-- +ok +== +SELECT json_normalize('{"b":"hello world","a":"foo\"bar"}') +-- +ok +== +SELECT json_normalize('{"b":3.14,"a":2.72}') +-- +ok +== +SELECT json_normalize('{"b":-1,"a":-2}') +-- +ok +== +SELECT json_normalize('{"z":1,"a":2}') FROM range(3) +-- +ok +== +SELECT json_normalize('{"b":null,"a":1}') +-- +ok +== +SELECT json_normalize('{"b":{"z":null,"a":1},"a":null}') +-- +ok +== +SELECT json_normalize('{"a":2,"":1}') +-- +ok +== +SELECT json_normalize('{"abc":3,"ab":2,"a":1}') +-- +ok +== +SELECT json_normalize('{"b":{"c":[{"z":1,"a":2}]},"a":1}') +-- +ok +== diff --git a/parser/testdata/corpus/sql/json/scalar/test_json_path.test b/parser/testdata/corpus/sql/json/scalar/test_json_path.test new file mode 100644 index 0000000..3f07691 --- /dev/null +++ b/parser/testdata/corpus/sql/json/scalar/test_json_path.test @@ -0,0 +1,223 @@ +# source: test/sql/json/scalar/test_json_path.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +select json_extract('{"my_field": "duck"}', '') +-- +ok +== +select json_extract('{"my_field": "duck"}', '$.my_field') +-- +ok +== +select json_extract('[0, 1, 2]', '$[1]') +-- +ok +== +select json_extract('[[1]]', '$[0][0]') +-- +ok +== +create table test (j varchar, q varchar) +-- +ok +== +insert into test values ('{"my_field": {"my_nested_field": ["goose", "duck"]}}', '$.my_field.my_nested_field[0]') +-- +ok +== +select json_extract(j, '$.my_field.my_nested_field[]') from test +-- +ok +== +select json_extract(j, '$.my_field.my_nested_field[0]') from test +-- +ok +== +select json_extract(j, '$.my_field.my_nested_field[#-1]') from test +-- +ok +== +select json_extract(j, '$.my_field.my_nested_field[#-2]') from test +-- +ok +== +select json_extract(j, '$.my_field.my_nested_field[#-3]') from test +-- +ok +== +select json_extract(j, '$.my_field.my_nested_field[#]') from test +-- +ok +== +select json_extract(j, '$.my_field.my_nested_field[-1]') from test +-- +ok +== +select json_extract(j, '$.my_field.my_nested_field[-2]') from test +-- +ok +== +select json_extract(j, '$.my_field.my_nested_field[-3]') from test +-- +ok +== +select json_extract(j, q) from test +-- +ok +== +select json_extract('{"my_field": [{"my_nested_field": ["duck", "goose"]}]}', '$.my_field[0].my_nested_field[0]') +-- +ok +== +select json_extract('{"my_field": [{"my_nested_field": ["duck", "goose"]}]}', '$.my_field[#-1].my_nested_field[#-1]') +-- +ok +== +select json_extract(j, '$.my_field.my_nested_field.3') from test +-- +ok +== +with tbl as ( + select '[{"duck":42},{"duck":43}]' j, '$duck' p +) +select json_extract(j, p) from tbl +-- +ok +== +select json_extract('{"a": {"b": "c"}}', '$[]'); +-- +ok +== +select json_extract('{"a": {"b": "c"}}', '$[#'); +-- +ok +== +select json_extract(j, '$.my_field[my_nested_field[#-3]') from test +-- +ok +== +select json_extract(j, '$.my_field.my_nested_field[!]') from test +-- +ok +== +select json_extract('{"a": {"b": "c"}}', '$.a..'); +-- +ok +== +select json_extract('{"a": {"b": "c"}}', '$[['); +-- +ok +== +select json_extract('{"a": {"b": "c"}}', '$[.'); +-- +ok +== +select json_extract('{"a": {"b": "c"}}', '$]'); +-- +ok +== +select json_extract('[{"duck":42},{"duck":43}]', '$[*].duck') +-- +ok +== +select json_extract('{"duck":42, "goose":43}', '$.*'); +-- +ok +== +select json_extract('[{"duck":42},{"duck":43}]', '$[*.duck') +-- +ok +== +select json_extract('[{"duck":42},{"duck":43}]', '$*.duck') +-- +ok +== +select json_extract('{"duck":42, "goose":43}', '$.[*]'); +-- +ok +== +select json_extract('[{"duck":42},{"duck":43}]', '$.*') +-- +ok +== +select json_extract('{"duck":[42,43]}', '$.*[-1]') +-- +ok +== +select json_extract('[{"duck":42},{"duck":43}]', '$[*].*') +-- +ok +== +with tbl as ( + select '[{"duck":42},{"duck":43}]' j, '$[*].duck' p +) +select json_extract(j, p) from tbl +-- +ok +== +with tbl as ( + select '{"aaaaaaaaaaaa":1}' j, '$.aaaaaaaaaaaa.*' p +) +select json_extract(j, p) from tbl +-- +ok +== +with tbl as ( + select '{"aaaaaaaaaaaa":1}' j, '$.aaaaaaaaaaaa..' p +) +select json_extract(j, p) from tbl +-- +ok +== +select json_extract('[{"duck":42},{"goose":43}]', ['$[*].duck', '$[*].goose']) +-- +ok +== +select sum((to_json({duck:range})->'$.*')[1]::int) = sum(range) from range(10000) +-- +ok +== +select json_extract('[{"duck":null},{"duck":42},{"duck":null},{}]', '$[*].*') +-- +ok +== +select json_extract('{"a":{"b":1,"c":2},"d":["g","h",[{"b":5},{"x":42}]]}', '$..*') +-- +ok +== +select json_extract('{"a":{"b":1,"c":2},"d":["g","h",[{"b":5},{"x":42}]]}', '$.**') +-- +ok +== +select json_extract('{"a":{"b":1,"c":2},"d":["g","h",[{"b":5},{"x":42}]]}', '$..b') +-- +ok +== +select json_extract('{"a":{"b":1,"c":2},"d":["g","h",[{"b":5},{"x":42}]]}', '$..[0]') +-- +ok +== +with tbl as ( + select '[{"duck":42},{"duck":{"a":43,"b":null}}]' j +) +select json_extract(j, '$[*]..*') from tbl +-- +ok +== +with tbl as ( + select '{"duck":[{"goose":42},{"goose":43}],"goose":null}' j +) +select json_extract(j, '$.duck[*]..goose') from tbl +-- +ok +== +select json_extract(j,'$..[*]') from test +-- +ok +== +select json_extract('[[{"a":[1,2,3]}], [{"a":[4,5,6]}]]','$[*]..a[*]') +-- +ok +== diff --git a/parser/testdata/corpus/sql/json/scalar/test_json_path_prepared.test b/parser/testdata/corpus/sql/json/scalar/test_json_path_prepared.test new file mode 100644 index 0000000..87f8f32 --- /dev/null +++ b/parser/testdata/corpus/sql/json/scalar/test_json_path_prepared.test @@ -0,0 +1,53 @@ +# source: test/sql/json/scalar/test_json_path_prepared.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +PREPARE extract_stmt AS SELECT json_extract('{"a":1,"b":{"c":2}}', $1); +-- +ok +== +EXECUTE extract_stmt('$.a') +-- +ok +== +EXECUTE extract_stmt('$.b.c') +-- +ok +== +EXECUTE extract_stmt('/b/c') +-- +ok +== +PREPARE set_stmt AS SELECT json_set('{"a":1}', $1, '2'); +-- +ok +== +EXECUTE set_stmt('$.b') +-- +ok +== +EXECUTE set_stmt('$.a') +-- +ok +== +PREPARE remove_stmt AS SELECT json_remove('{"a":1,"b":2}', $1); +-- +ok +== +EXECUTE remove_stmt('$.a') +-- +ok +== +EXECUTE remove_stmt('$.c') +-- +ok +== +EXECUTE set_stmt('$not_a_path') +-- +ok +== +SELECT json_set('{"a":1}', (SELECT '$.b'), '2') +-- +ok +== diff --git a/parser/testdata/corpus/sql/json/scalar/test_json_pretty.test b/parser/testdata/corpus/sql/json/scalar/test_json_pretty.test new file mode 100644 index 0000000..ce08686 --- /dev/null +++ b/parser/testdata/corpus/sql/json/scalar/test_json_pretty.test @@ -0,0 +1,39 @@ +# source: test/sql/json/scalar/test_json_pretty.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +SELECT json_pretty('[1,2,{"a":43, "g":[true, true]}]') = '[ + 1, + 2, + { + "a": 43, + "g": [ + true, + true + ] + } +]' +-- +ok +== +SELECT json_pretty(NULL) +-- +ok +== +SELECT json_pretty('null'::json); +-- +ok +== +SELECT json_pretty('[1,2,null, {"a": null}, 42]'::json) = '[ + 1, + 2, + null, + { + "a": null + }, + 42 +]' +-- +ok +== diff --git a/parser/testdata/corpus/sql/json/scalar/test_json_remove.test b/parser/testdata/corpus/sql/json/scalar/test_json_remove.test new file mode 100644 index 0000000..af33982 --- /dev/null +++ b/parser/testdata/corpus/sql/json/scalar/test_json_remove.test @@ -0,0 +1,188 @@ +# source: test/sql/json/scalar/test_json_remove.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +SELECT json_remove('{"a":1,"b":2}', '$.a') +-- +ok +== +SELECT json_remove('{"a":1}', '$.b') +-- +ok +== +SELECT json_remove('{"a":1,"b":2}', '/a') +-- +ok +== +SELECT json_remove('{"a":{"x":1,"y":2}}', '$.a.x') +-- +ok +== +SELECT json_remove('{"a":{"x":1}}', '$.a.y') +-- +ok +== +SELECT json_remove('[1,2,3]', '$[1]') +-- +ok +== +SELECT json_remove('[1,2,3]', '$[0]') +-- +ok +== +SELECT json_remove('[1,2,3]', '$[2]') +-- +ok +== +SELECT json_remove('[1,2]', '$[5]') +-- +ok +== +SELECT json_remove('{"a":[1,[2,3],4]}', '/a/1/0') +-- +ok +== +SELECT json_remove('[{"a":1},{"b":2}]', '$[0]') +-- +ok +== +SELECT json_remove('{"a":1}', '$.a') +-- +ok +== +SELECT json_remove('{"a":1}', '$') +-- +ok +== +SELECT json_remove('{"a.b":1,"c":2}', '$."a.b"') +-- +ok +== +SELECT json_remove('{"a/b":1,"c":2}', '$."a/b"') +-- +ok +== +SELECT json_remove('{}', '$.a') +-- +ok +== +SELECT json_remove(NULL, '$.a') +-- +ok +== +SELECT json_remove('{"a":1}', NULL) +-- +ok +== +SELECT json_remove('{"a":1,"b":2}', 'a') +-- +ok +== +SELECT json_remove('{"a":1,"b":2}', '$.a') FROM range(3) +-- +ok +== +CREATE TABLE users (id INTEGER, profile JSON); +-- +ok +== +INSERT INTO users VALUES + (1, '{"name":"alice","password":"x1"}'), + (2, '{"name":"bob","password":"x2","admin":true}'), + (3, '{"name":"carol"}'); +-- +ok +== +SELECT id, json_remove(profile, '$.password') FROM users ORDER BY id +-- +ok +== +SELECT json_normalize(json_remove('{"z":1,"a":2}', '$.z')) +-- +ok +== +SELECT json_remove('{"a\"b":1,"a\\":2}', '$."a\"b"') +-- +ok +== +SELECT json_remove('{"a\\":1,"b":2}', '$."a\\"') +-- +ok +== +SELECT json_remove('{"a~b":1,"c":2}', '$."a~b"') +-- +ok +== +SELECT json_remove('{"":1,"a":2}', '$.""') +-- +ok +== +SELECT json_remove('{"":1,"a":2}', '/') +-- +ok +== +SELECT json_remove('[1,2,3]', '$[#-1]') +-- +ok +== +SELECT json_remove('[1,2,3]', '$[#-2]') +-- +ok +== +SELECT json_remove('[1,2]', '$[#]') +-- +ok +== +SELECT json_remove('[1,2]', '$[#-5]') +-- +ok +== +SELECT json_remove('[]', '$[#-1]') +-- +ok +== +SELECT json_remove('[1,2]', '$[#-18446744073709551617]') +-- +ok +== +SELECT json_remove('{"a":1}', '$not_a_path') +-- +ok +== +SELECT TRY(json_remove('{"a":1}', '$[#-')) +-- +ok +== +SELECT json_remove('{"a":[1,2]}', '$.a[*]') +-- +ok +== +SELECT json_remove('[1,2,3]', '$[-1]') +-- +ok +== +SELECT json_remove('{"a":1}', '') +-- +ok +== +SELECT json_remove('[1,2]', '$') +-- +ok +== +SELECT json_remove('{"a~b":1,"c":2}', '/a~0b') +-- +ok +== +SELECT json_remove('{"a/b":1,"c":2}', '/a~1b') +-- +ok +== +SELECT json_remove('{"a~b":1,"c":2}', 'a~b') +-- +ok +== +SELECT json_remove(d, '$.x') FROM (VALUES ('{"x":1,"y":2}'), (NULL)) t(d) +-- +ok +== diff --git a/parser/testdata/corpus/sql/json/scalar/test_json_replace.test b/parser/testdata/corpus/sql/json/scalar/test_json_replace.test new file mode 100644 index 0000000..7836870 --- /dev/null +++ b/parser/testdata/corpus/sql/json/scalar/test_json_replace.test @@ -0,0 +1,152 @@ +# source: test/sql/json/scalar/test_json_replace.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +SELECT json_replace('{"a":1}', '$.a', '99') +-- +ok +== +SELECT json_replace('{"a":1}', '$.b', '2') +-- +ok +== +SELECT json_replace('{"a":1}', '/a', '99') +-- +ok +== +SELECT json_replace('{"a":{"x":1}}', '$.a.x', '99') +-- +ok +== +SELECT json_replace('{"a":{"x":1}}', '$.a.y', '2') +-- +ok +== +SELECT json_replace('{}', '$.a.b', '1') +-- +ok +== +SELECT json_replace('[1,2,3]', '$[1]', '99') +-- +ok +== +SELECT json_replace('[1,2]', '$[5]', '9') +-- +ok +== +SELECT json_replace('[1,2]', '/-', '3') +-- +ok +== +SELECT json_replace('[1,2]', '$[#]', '3') +-- +ok +== +SELECT json_replace('{"a":1}', '$', '{"b":2}') +-- +ok +== +SELECT json_replace('{"a":{"x":1}}', '$.a', '42') +-- +ok +== +SELECT json_replace('{"s":1}', '$.s', '"hello"') +-- +ok +== +SELECT json_replace('{"a":1}', '$.a', 'null') +-- +ok +== +SELECT json_replace('{"a":1,"b":2,"c":3}', '$.b', '99') +-- +ok +== +SELECT json_replace('{"a":{"b":{"c":1}}}', '$.a.b.c', '99') +-- +ok +== +SELECT json_replace('{"a":[1,[2,3],4]}', '/a/1/0', '99') +-- +ok +== +SELECT json_replace(NULL, '$.a', '1') +-- +ok +== +SELECT json_replace('{"a":1}', NULL, '1') +-- +ok +== +SELECT json_replace('{"a":1}', '$.a', NULL) +-- +ok +== +SELECT json_replace('{"a":1}', 'a', '2') +-- +ok +== +SELECT json_replace('{"a":1}', '$.a', '2'::JSON) +-- +ok +== +SELECT json_replace('{"a":1}', '$.a', '2') FROM range(3) +-- +ok +== +CREATE TABLE events (id INTEGER, payload JSON); +-- +ok +== +INSERT INTO events VALUES + (1, '{"status":"old","x":1}'), + (2, '{"x":2}'), + (3, '{"status":"stale"}'); +-- +ok +== +SELECT id, json_replace(payload, '$.status', '"done"') FROM events ORDER BY id +-- +ok +== +SELECT json_normalize(json_replace('{"z":1,"a":2}', '$.z', '9')) +-- +ok +== +SELECT json_replace('{"a\"b":1,"a\\":2}', '$."a\"b"', '9') +-- +ok +== +SELECT json_replace('[1,2]', '$[#-1]', '9') +-- +ok +== +SELECT json_replace('{"a":[1,2,3]}', '$.a[#-2]', '9') +-- +ok +== +SELECT json_replace('[1,2]', '$[#-0]', '9') +-- +ok +== +SELECT json_replace('[]', '$[#-1]', '9') +-- +ok +== +SELECT json_replace('{"a":1}', '', '2') +-- +ok +== +SELECT json_replace('{"a":1}', '$not_a_path', '2') +-- +ok +== +SELECT json_replace('[1,2,3]', '$[-2]', '9') +-- +ok +== +SELECT json_replace('{}', '$.a[0]', '1') +-- +ok +== diff --git a/parser/testdata/corpus/sql/json/scalar/test_json_set.test b/parser/testdata/corpus/sql/json/scalar/test_json_set.test new file mode 100644 index 0000000..d2399e8 --- /dev/null +++ b/parser/testdata/corpus/sql/json/scalar/test_json_set.test @@ -0,0 +1,308 @@ +# source: test/sql/json/scalar/test_json_set.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +SELECT json_set('{"a":1}', '$.b', '2') +-- +ok +== +SELECT json_set('{"a":1}', '$.a', '99') +-- +ok +== +SELECT json_set('{"a":1}', '/b', '2') +-- +ok +== +SELECT json_set('{"a":{"x":1}}', '$.a.y', '2') +-- +ok +== +SELECT json_set('{"a":{"x":1}}', '$.a.x', '99') +-- +ok +== +SELECT json_set('{}', '$.a.b.c', '1') +-- +ok +== +SELECT json_set('[1,2,3]', '$[1]', '99') +-- +ok +== +SELECT json_set('[1,2]', '/-', '3') +-- +ok +== +SELECT json_set('[{"a":1}]', '$[0].b', '2') +-- +ok +== +SELECT json_set('{}', '$.s', '"hello"') +-- +ok +== +SELECT json_set('{}', '$.b', 'true') +-- +ok +== +SELECT json_set('{}', '$.n', 'null') +-- +ok +== +SELECT json_set('{}', '$.arr', '[1,2,3]') +-- +ok +== +SELECT json_set('{}', '$.obj', '{"x":1}') +-- +ok +== +SELECT json_set('{"a":1}', '$.a', '{"nested":true}') +-- +ok +== +SELECT json_set('{"a":{"x":1}}', '$.a', '42') +-- +ok +== +SELECT json_set('{"a":{"b":{"c":1}}}', '$.a.b.c', '99') +-- +ok +== +SELECT json_set('{"a":[1,[2,3],4]}', '/a/1/0', '99') +-- +ok +== +SELECT json_set(NULL, '$.a', '1') +-- +ok +== +SELECT json_set('{"a":1}', NULL, '1') +-- +ok +== +SELECT json_set('{"a":1}', '$.a', NULL) +-- +ok +== +SELECT json_set('{}', '$.a', '1') +-- +ok +== +SELECT json_set('{"a":1,"b":2,"c":3}', '$.b', '99') +-- +ok +== +SELECT json_set('{"a":1}', 'b', '2') +-- +ok +== +SELECT json_set('{"a":1}', '$.b', '2'::JSON) +-- +ok +== +SELECT json_set('{"a":1}', '$.b', '2') FROM range(3) +-- +ok +== +CREATE TABLE entities (id INTEGER, data JSON, path VARCHAR, val JSON); +-- +ok +== +INSERT INTO entities VALUES + (1, '{"a":1}', '$.b', '2'), + (2, '{"x":{"y":1}}', '$.x.z', '3'), + (3, '{"arr":[1,2]}', '/arr/-', '3'); +-- +ok +== +SELECT id, json_set(data, path, val) FROM entities ORDER BY id +-- +ok +== +SELECT json_set( + '{"typeName":"Column","attributes":{"name":"col1","dataType":"VARCHAR"}}', + '$.attributes.table', + '{"typeName":"Table","uniqueAttributes":{"qualifiedName":"t1"}}' +) +-- +ok +== +SELECT json_normalize(json_set('{"z":1}', '$.a', '2')) +-- +ok +== +SELECT json_set('{"a\"b":1,"a\\":2}', '$."a\"b"', '9') +-- +ok +== +SELECT json_set('{"a\\":1,"b":2}', '$."a\\"', '9') +-- +ok +== +SELECT json_set('{"":1,"a":2}', '$.""', '9') +-- +ok +== +SELECT json_set('{"":1,"a":2}', '/', '9') +-- +ok +== +SELECT json_set('{"a~b":1}', '$."a~b"', '9') +-- +ok +== +SELECT json_set('{}', '$.日本', '1') +-- +ok +== +SELECT json_set('{"a":1}', '$', '{"b":2}') +-- +ok +== +SELECT json_set('[1,2]', '$[#-1]', '9') +-- +ok +== +SELECT json_set('{"log":[{"v":1},{"v":2}]}', '$.log[#-1].v', '9') +-- +ok +== +SELECT json_set('[[1,2],[3,4]]', '$[#-1][#-1]', '9') +-- +ok +== +SELECT json_set('[1,2]', '$[#-0]', '9') +-- +ok +== +SELECT json_set('[1,2]', '$[2]', '9') +-- +ok +== +SELECT json_set('[1,2]', '$[#-5]', '9') +-- +ok +== +SELECT json_set('[]', '$[#-1]', '9') +-- +ok +== +SELECT json_set('{"a":{"x":1}}', '$.a[#-1]', '9') +-- +ok +== +SELECT json_set('[1,2]', '$[-1]', '9') +-- +ok +== +SELECT json_set('null', '$.a', '1') +-- +ok +== +SELECT json_set('1', '$.a', '2') +-- +ok +== +SELECT json_set('{"a":1}', '$.a.b', '2') +-- +ok +== +SELECT json_set('[1,2]', '$[#]', '3') +-- +ok +== +SELECT json_set('[1,2]', '$[#-]', '9') +-- +ok +== +SELECT json_set('[1,2]', '$[#-18446744073709551617]', '9') +-- +ok +== +SELECT json_set('{"a":1}', '$not_a_path', '2') +-- +ok +== +SELECT TRY(json_set('{}', '$not_a_path', '1')) +-- +ok +== +SELECT TRY(json_set('{"a":1}', '$.a[*]', '1')) +-- +ok +== +SELECT CASE WHEN false THEN json_set('{}', '$not_a_path', '1') ELSE '{}'::JSON END +-- +ok +== +SELECT json_set('{"a":[1,2]}', '$.a[*]', '9') +-- +ok +== +SELECT json_set('{}', '$.a[0]', '1') +-- +ok +== +SELECT json_set('{}', '$.a[0].b', '1') +-- +ok +== +SELECT json_set('{}', '$.a[2]', '1') +-- +ok +== +SELECT json_set('{}', '$.a[#]', '1') +-- +ok +== +SELECT json_set('{}', '$[0]', '1') +-- +ok +== +SELECT json_set('{"a":1}', '$.a[0]', '2') +-- +ok +== +SELECT json_set('{"a":[0]}', '$.a[1].b', '5') +-- +ok +== +SELECT json_set('[]', '$[#].b', '5') +-- +ok +== +SELECT json_set('{"a":[[1]]}', '$.a[0][0]', '9') +-- +ok +== +SELECT json_set('{}', '$."a.b".c', '1') +-- +ok +== +SELECT json_set('[1,2]', '$[9999999999999999999]', '9') +-- +ok +== +SELECT json_set('[1,2]', '$[1', '9') +-- +ok +== +SELECT json_set('{"a":1}', '', '2') +-- +ok +== +SELECT json_set(d, '$.a', '1') FROM (VALUES ('{"x":1}'), (NULL), ('{}')) t(d) +-- +ok +== +SELECT json_set('{bad', '$.a', '1') +-- +ok +== +SELECT json_set('{}', '$.a', '{bad') +-- +ok +== diff --git a/parser/testdata/corpus/sql/json/scalar/test_json_strip_nulls.test b/parser/testdata/corpus/sql/json/scalar/test_json_strip_nulls.test new file mode 100644 index 0000000..dba2469 --- /dev/null +++ b/parser/testdata/corpus/sql/json/scalar/test_json_strip_nulls.test @@ -0,0 +1,104 @@ +# source: test/sql/json/scalar/test_json_strip_nulls.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +SELECT json_strip_nulls('{"a":1,"b":null}') +-- +ok +== +SELECT json_strip_nulls('{"a":1,"b":null,"c":null,"d":2}') +-- +ok +== +SELECT json_strip_nulls('{"a":1,"b":2}') +-- +ok +== +SELECT json_strip_nulls('{"a":null,"b":null}') +-- +ok +== +SELECT json_strip_nulls('{"a":{"x":1,"y":null},"b":2}') +-- +ok +== +SELECT json_strip_nulls('{"a":{"b":{"c":null,"d":1}}}') +-- +ok +== +SELECT json_strip_nulls('{"a":{"x":null},"b":2}') +-- +ok +== +SELECT json_strip_nulls('{"a":[1,null,3]}') +-- +ok +== +SELECT json_strip_nulls('{"a":[{"x":1,"y":null},{"z":null}]}') +-- +ok +== +SELECT json_strip_nulls('[{"a":null,"b":1},{"c":null}]') +-- +ok +== +SELECT json_strip_nulls('"hello"') +-- +ok +== +SELECT json_strip_nulls('42') +-- +ok +== +SELECT json_strip_nulls('true') +-- +ok +== +SELECT json_strip_nulls('null') +-- +ok +== +SELECT json_strip_nulls(NULL) +-- +ok +== +SELECT json_strip_nulls('{}') +-- +ok +== +SELECT json_strip_nulls('[]') +-- +ok +== +SELECT json_strip_nulls('{"a":[{"b":null,"c":1}],"d":null}') +-- +ok +== +SELECT json_strip_nulls('{"a":{"b":{"c":null}}}') +-- +ok +== +SELECT json_strip_nulls('{"typeName":"Column","attributes":{"name":"col1","description":null,"parentColumn":null,"dataType":"VARCHAR"}}') +-- +ok +== +SELECT json_strip_nulls('{"a":null,"b":1}') FROM range(3) +-- +ok +== +INSERT INTO json_data VALUES + (1, '{"a":1,"b":null}'), + (2, '{"x":null,"y":null}'), + (3, NULL); +-- +ok +== +SELECT id, json_strip_nulls(data) FROM json_data ORDER BY id +-- +ok +== +SELECT json_normalize(json_strip_nulls('{"z":1,"a":null,"m":2}')) +-- +ok +== diff --git a/parser/testdata/corpus/sql/json/scalar/test_json_structure.test b/parser/testdata/corpus/sql/json/scalar/test_json_structure.test new file mode 100644 index 0000000..084a428 --- /dev/null +++ b/parser/testdata/corpus/sql/json/scalar/test_json_structure.test @@ -0,0 +1,142 @@ +# source: test/sql/json/scalar/test_json_structure.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +select json_structure('42') +-- +ok +== +select json_structure('4.2') +-- +ok +== +select json_structure('null') +-- +ok +== +select json_structure('true') +-- +ok +== +select json_structure('"duck"') +-- +ok +== +select json_structure('{"a": 42}') +-- +ok +== +select json_structure('{"a": 4.2}') +-- +ok +== +select json_structure('{"a": "42"}') +-- +ok +== +select json_structure('{"a": "looooooooooooooooong"}') +-- +ok +== +select json_structure('{"a": null}') +-- +ok +== +select json_structure('{"a": true}') +-- +ok +== +select json_structure('{"a": []}') +-- +ok +== +select json_structure('{"a": [42]}') +-- +ok +== +select json_structure('{"a": {"b": 42}}') +-- +ok +== +select json_structure('[null,null]') +-- +ok +== +select json_structure('[true,null,false]') +-- +ok +== +select json_structure('[true,null,false,1]') +-- +ok +== +select json_structure('[true,null,false,1,-1]') +-- +ok +== +select json_structure('[true,null,false,1,-1,0.42]') +-- +ok +== +select json_structure('[true,null,false,1,-1,0.42,"42"]') +-- +ok +== +select json_structure('[{"a": 42}, {"a": null}]') +-- +ok +== +select json_structure('[{"a": 42}, {"b": 4.2}]') +-- +ok +== +select json_structure('[{"a": [42, null]}, {"a": [7]}]') +-- +ok +== +select json_structure('[{"a": [{"b": 42}, {"b": null}]}, {"a": [{"b": 7}]}]') +-- +ok +== +select json_structure('[{"a": [{"b": 42}, {"b": null}]}, {"a": [{"c": 7}]}]') +-- +ok +== +select json_structure('[1, [1]]') +-- +ok +== +select json_structure('[1, {"a": 1}]') +-- +ok +== +select json_structure('[[1], {"a": 1}]') +-- +ok +== +select json_structure('{"a": 42, "a": 7}') +-- +ok +== +create table test (j json); +-- +ok +== +insert into test values + ('{"family": "anatidae", "species": ["duck", "goose", "swan", null], "coolness": 1000}'), + ('{"family": "canidae", "species": ["labrador", null, "bulldog", "shepherd"], "hair": true, "coolness": 999}'), + (NULL), + ('{"family": null, "species": null, "hair": null, "coolness": null}'), + ('{"family": "felidae", "species": ["tiger", "lion", null, "british shorthair"], "hair": true, "coolness": 999}') +-- +ok +== +select json_structure(j) from test +-- +ok +== +select json_structure('{"a": 1, "A": 1}'); +-- +ok +== diff --git a/parser/testdata/corpus/sql/json/scalar/test_json_transform.test b/parser/testdata/corpus/sql/json/scalar/test_json_transform.test new file mode 100644 index 0000000..e76653a --- /dev/null +++ b/parser/testdata/corpus/sql/json/scalar/test_json_transform.test @@ -0,0 +1,417 @@ +# source: test/sql/json/scalar/test_json_transform.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +select from_json('42', '"UBIGINT"') +-- +ok +== +select from_json_strict('42', '"UBIGINT"') +-- +ok +== +select from_json_strict('42', '"DATE"') +-- +ok +== +select json_transform('42', '42') +-- +ok +== +select json_transform('42', '"UBIGINT"') +-- +ok +== +select json_transform('4.2', '"DOUBLE"') +-- +ok +== +select json_transform('null', '"NULL"') +-- +ok +== +select json_transform('true', '"BOOLEAN"') +-- +ok +== +select json_transform('"duck"', '"VARCHAR"') +-- +ok +== +select json_transform('"duuuuuuuuuuuuuuuuck"', '"VARCHAR"') +-- +ok +== +select json_transform('{"a": 42}', '{"a":"UBIGINT"}') +-- +ok +== +select json_transform_strict('{"a": 42, "a":43}', '{"a":"UBIGINT"}') +-- +ok +== +select json_transform_strict('{}', '{"a":"UBIGINT"}') +-- +ok +== +select json_transform_strict('{}', '["UBIGINT"]') +-- +ok +== +select json_transform('[{}, [42]]', '[["UBIGINT"]]') +-- +ok +== +select json_transform('{"a": null}', '{"a":"UBIGINT"}') +-- +ok +== +select json_transform('{"a": 42}', '{"a":"NULL"}') +-- +ok +== +select json_transform('{"a": 42}', '{"a":"ARRAY"}') +-- +ok +== +select json_transform('[1,2,3]', '["UBIGINT", "BIGINT"]') +-- +ok +== +select list_sum(json_transform(range(5000)::JSON, '["UBIGINT"]'))::UBIGINT s +-- +ok +== +select json_transform('[1,2,3]', '["UBIGINT"]') +-- +ok +== +select json_transform('[1,2,3]', '["NULL"]') +-- +ok +== +select json_transform('[{"a": 42}, {"a": null}, {"a": 7}]', '[{"a": "UBIGINT"}]') +-- +ok +== +select json_transform('[{"a": 42}, {"a": null, "b": 33}, {"b": 7}]', '[{"a": "UBIGINT", "b": "UBIGINT"}]') +-- +ok +== +select json_transform(j, '{"family": "VARCHAR", "coolness": "UBIGINT", "species": ["VARCHAR"]}') from test +-- +ok +== +select json_transform('{"a": 4, "a": 2}', '{"a": "UBIGINT", "a": "UBIGINT"}') +-- +ok +== +select json_transform('{"a": {"duck": 42, "goose": 7}}', '{"a": "JSON"}') +-- +ok +== +select json_transform('42', '"{type}"') +-- +ok +== +select json_transform('42.42', '"{type}"') +-- +ok +== +select json_transform('"42"', '"{type}"') +-- +ok +== +select json_transform('true', '"{type}"') +-- +ok +== +select json_transform('false', '"{type}"') +-- +ok +== +select json_transform('[]', '"{type}"') +-- +ok +== +select json_transform('{}', '"{type}"') +-- +ok +== +select json_transform_strict('[]', '"{type}"') +-- +ok +== +select json_transform_strict('{}', '"{type}"') +-- +ok +== +select json_transform('null', '"{type}"') +-- +ok +== +select json_transform('-42', '"INTEGER"') +-- +ok +== +select json_transform('-42', '"UINTEGER"') +-- +ok +== +select json_transform_strict('-42', '"UINTEGER"') +-- +ok +== +select json_transform('42', '"VARCHAR"') +-- +ok +== +select json_transform('42', '"JSON"') +-- +ok +== +select json_transform('42', '"BLOB"') +-- +ok +== +select json_transform('-42', '"VARCHAR"') +-- +ok +== +select json_transform('42.42', '"VARCHAR"') +-- +ok +== +select json_transform('true', '"VARCHAR"') +-- +ok +== +select json_transform('[]', '"VARCHAR"') +-- +ok +== +select json_transform('{}', '"VARCHAR"') +-- +ok +== +select json_transform('null', '"VARCHAR"') +-- +ok +== +select json_transform('42', '"DECIMAL"') +-- +ok +== +select json_transform('42', '"DECIMAL(2)"') +-- +ok +== +select json_transform('42', '"DECIMAL(3,1)"') +-- +ok +== +select json_transform('-42', '"DECIMAL(3,1)"') +-- +ok +== +select json_transform('"42"', '"DECIMAL(3,1)"') +-- +ok +== +select json_transform('42.42', '"DECIMAL(4,2)"') +-- +ok +== +select json_transform('42.42', '"DECIMAL(10,2)"') +-- +ok +== +select json_transform('42.42', '"DECIMAL(20,2)"') +-- +ok +== +select json_transform('42.42', '"DECIMAL(38,2)"') +-- +ok +== +select json_transform('42.42', '"DECIMAL(38,17)"') +-- +ok +== +select json_transform('true', '"DECIMAL(3,1)"') +-- +ok +== +select json_transform('false', '"DECIMAL(3,1)"') +-- +ok +== +select json_transform('null', '"DECIMAL(3,1)"') +-- +ok +== +select json_transform('42', '"DECIMAL(2,1)"') +-- +ok +== +select json_transform('[]', '"DECIMAL(2,1)"') +-- +ok +== +select json_transform('{}', '"DECIMAL(2,1)"') +-- +ok +== +select json_transform_strict('42', '"DECIMAL(2,1)"') +-- +ok +== +select json_transform('42', '"DECIMAL(39)"') +-- +ok +== +select json_transform('42', '"DECIMAL(2,4)"') +-- +ok +== +select json_transform('42', '"DECIMAL(5,1,1)"') +-- +ok +== +select json_transform('"A0EEBC99-9C0B-4EF8-BB6D-6BB9BD380A11"', '"UUID"') +-- +ok +== +select json_transform('42', '"UUID"') +-- +ok +== +select json_transform_strict('42', '"UUID"') +-- +ok +== +select json_transform('-42', '"UUID"') +-- +ok +== +select json_transform('42.42', '"UUID"') +-- +ok +== +select json_transform('true', '"UUID"') +-- +ok +== +select json_transform('false', '"UUID"') +-- +ok +== +select json_transform('null', '"UUID"') +-- +ok +== +select json_transform('"1996-03-27"', '"DATE"') +-- +ok +== +select json_transform('"11:59:59"', '"TIME"') +-- +ok +== +select json_transform('42', '"DATE"') +-- +ok +== +select json_transform('-42', '"DATE"') +-- +ok +== +select json_transform('42.42', '"DATE"') +-- +ok +== +select json_transform('"42"', '"DATE"') +-- +ok +== +select json_transform('null', '"DATE"') +-- +ok +== +select json_transform('true', '"DATE"') +-- +ok +== +select json_transform('false', '"DATE"') +-- +ok +== +select json_transform('[]', '"DATE"') +-- +ok +== +select json_transform('{}', '"DATE"') +-- +ok +== +select json_transform_strict('false', '"DATE"') +-- +ok +== +select json_transform('"1996-03-27 11:59:59"', '"TIMESTAMP"') +-- +ok +== +select json_transform('"1996-03-27 11:59:59"', '"TIMESTAMP_MS"') +-- +ok +== +select json_transform('"1996-03-27 11:59:59"', '"TIMESTAMP_NS"') +-- +ok +== +select json_transform('"1996-03-27 11:59:59"', '"TIMESTAMP_S"') +-- +ok +== +select json_transform('null', '"TIMESTAMP"') +-- +ok +== +select json_transform('42', '"TIMESTAMP"') +-- +ok +== +select json_transform_strict('42', '"TIMESTAMP"') +-- +ok +== +CREATE OR REPLACE TYPE test_enum AS ENUM ('a', 'b', 'c'); +-- +ok +== +select json_transform('{"test": "a"}', '{"test": "test_enum"}') +-- +ok +== +select json_transform('{"test": ["a","b"]}', '{"test": "test_enum[]"}') +-- +ok +== +select json_transform('{"test": ["a","b"]}', '{"test": "test_enum[2]"}') +-- +ok +== +DROP TYPE test_enum; +-- +ok +== +select to_json(json_transform('{"a\u0000b":1}', '{"a\u0000b":"INTEGER"}')) +-- +ok +== +select to_json(json_transform_strict('{"a\u0000b":1}', '{"a\u0000b":"INTEGER"}')) +-- +ok +== diff --git a/parser/testdata/corpus/sql/json/scalar/test_json_type.test b/parser/testdata/corpus/sql/json/scalar/test_json_type.test new file mode 100644 index 0000000..c233d8f --- /dev/null +++ b/parser/testdata/corpus/sql/json/scalar/test_json_type.test @@ -0,0 +1,168 @@ +# source: test/sql/json/scalar/test_json_type.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +select json_type('{"str": 42}') +-- +ok +== +select json_type('[1, 2, 3]') +-- +ok +== +select json_type('"other"') +-- +ok +== +select json_type('42') +-- +ok +== +select json_type('NaN') +-- +ok +== +select json_type('null') +-- +ok +== +select json_type(NULL) +-- +ok +== +select json_type('{"str": 42}', 'str') +-- +ok +== +select json_type('{"str": "quack"}', 'str') +-- +ok +== +select json_type('{"str": "quack"}', 'str2') +-- +ok +== +select json_type('{"str": "quack"}', NULL) +-- +ok +== +select json_type(NULL, 'str') +-- +ok +== +select json_type('{"null": NaN}', 'null') +-- +ok +== +select json_type('{"null": nan}', 'null') +-- +ok +== +select json_type('{"null": Infinity}', 'null') +-- +ok +== +select json_type('{"null": -Infinity}', 'null') +-- +ok +== +create table test(json varchar, query varchar) +-- +ok +== +insert into test values + ('{"str": "quack", "int": 4, "double": 0.42, "bool": true, "arr": [], "nested": {"val": 1}}', '/nested/val'), + ('{"str": "woof", "int": -4, "double": -0.42, "bool": false, "arr": [0, 1, 2], "nested": {"val": 42}}', '/arr/2'), + ('{"str": null, "int": null, "double": null, "bool": null, "arr": null, "nested": null}', 'bool') +-- +ok +== +select json_type(json, 'str') from test +-- +ok +== +select json_type(json, 'int') from test +-- +ok +== +select json_type(json, 'double') from test +-- +ok +== +select json_type(json, 'bool') from test +-- +ok +== +select json_type(json, 'arr') from test +-- +ok +== +select json_type(json, '/arr/0') from test +-- +ok +== +select json_type(json, '/nested/val') from test +-- +ok +== +select json_type(json, ['str', '/nested/val']) from test +-- +ok +== +select json_type(json, query) from test +-- +ok +== +SELECT json_type('{"a":[2,3.5,true,false,null,"x"]}'); +-- +ok +== +SELECT json_type('{"a":[2,3.5,true,false,null,"x"]}','$'); +-- +ok +== +SELECT json_type('{"a":[2,3.5,true,false,null,"x"]}','$.a'); +-- +ok +== +SELECT json_type('{"a":[2,3.5,true,false,null,"x"]}','$.a[0]'); +-- +ok +== +SELECT json_type('{"a":[2,3.5,true,false,null,"x"]}','$.a[1]'); +-- +ok +== +SELECT json_type('{"a":[2,3.5,true,false,null,"x"]}','$.a[2]'); +-- +ok +== +SELECT json_type('{"a":[2,3.5,true,false,null,"x"]}','$.a[3]'); +-- +ok +== +SELECT json_type('{"a":[2,3.5,true,false,null,"x"]}','$.a[4]'); +-- +ok +== +SELECT json_type('{"a":[2,3.5,true,false,null,"x"]}','$.a[5]'); +-- +ok +== +SELECT json_type('{"a":[2,3.5,true,false,null,"x"]}','$.a[6]'); +-- +ok +== +select json_type(json_extract('{"duck":[1,2,3]}', '$..duck')) +-- +ok +== +select json_type(json_extract('{"a":{"duck":[1]},"b":{"duck":[2,3]}}', '$..duck')) +-- +ok +== +select json_type(json_extract('{"duck":[1,2,3]}', '$.duck[*]')) +-- +ok +== diff --git a/parser/testdata/corpus/sql/json/scalar/test_json_valid.test b/parser/testdata/corpus/sql/json/scalar/test_json_valid.test new file mode 100644 index 0000000..cf2b6b6 --- /dev/null +++ b/parser/testdata/corpus/sql/json/scalar/test_json_valid.test @@ -0,0 +1,497 @@ +# source: test/sql/json/scalar/test_json_valid.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +select json_valid('{"bla": inf}') +-- +ok +== +select json_valid('{"bla": infinity}') +-- +ok +== +CREATE TABLE j1(x varchar); +-- +ok +== +INSERT INTO j1(x) + VALUES('true'),('false'),('null'),('123'),('-234'),('34.5e+6'), + ('""'),('"\""'),('"\\"'),('"abcdefghijlmnopqrstuvwxyz"'), + ('[]'),('{}'),('[true,false,null,123,-234,34.5e+6,{},[]]'), + ('{"a":true,"b":{"c":false}}'); +-- +ok +== +SELECT * FROM j1 WHERE NOT json_valid(x); +-- +ok +== +SELECT json_valid('{"a":55,"b":72,}'); +-- +ok +== +SELECT json_valid('{"a":55,"b":72}'); +-- +ok +== +SELECT json_valid('["a",55,"b",72,]'); +-- +ok +== +SELECT json_valid('["a",55,"b",72]'); +-- +ok +== +SELECT json_valid('" \ "'); +-- +ok +== +SELECT json_valid('" \! "'); +-- +ok +== +SELECT json_valid('" \" "'); +-- +ok +== +SELECT json_valid('" \# "'); +-- +ok +== +SELECT json_valid('" \$ "'); +-- +ok +== +SELECT json_valid('" \% "'); +-- +ok +== +SELECT json_valid('" \& "'); +-- +ok +== +SELECT json_valid('" \'' "'); +-- +ok +== +SELECT json_valid('" \( "'); +-- +ok +== +SELECT json_valid('" \) "'); +-- +ok +== +SELECT json_valid('" \* "'); +-- +ok +== +SELECT json_valid('" \+ "'); +-- +ok +== +SELECT json_valid('" \, "'); +-- +ok +== +SELECT json_valid('" \- "'); +-- +ok +== +SELECT json_valid('" \. "'); +-- +ok +== +SELECT json_valid('" \/ "'); +-- +ok +== +SELECT json_valid('" \0 "'); +-- +ok +== +SELECT json_valid('" \1 "'); +-- +ok +== +SELECT json_valid('" \2 "'); +-- +ok +== +SELECT json_valid('" \3 "'); +-- +ok +== +SELECT json_valid('" \4 "'); +-- +ok +== +SELECT json_valid('" \5 "'); +-- +ok +== +SELECT json_valid('" \6 "'); +-- +ok +== +SELECT json_valid('" \7 "'); +-- +ok +== +SELECT json_valid('" \8 "'); +-- +ok +== +SELECT json_valid('" \9 "'); +-- +ok +== +SELECT json_valid('" \: "'); +-- +ok +== +SELECT json_valid('" \; "'); +-- +ok +== +SELECT json_valid('" \< "'); +-- +ok +== +SELECT json_valid('" \= "'); +-- +ok +== +SELECT json_valid('" \> "'); +-- +ok +== +SELECT json_valid('" \? "'); +-- +ok +== +SELECT json_valid('" \@ "'); +-- +ok +== +SELECT json_valid('" \A "'); +-- +ok +== +SELECT json_valid('" \B "'); +-- +ok +== +SELECT json_valid('" \C "'); +-- +ok +== +SELECT json_valid('" \D "'); +-- +ok +== +SELECT json_valid('" \E "'); +-- +ok +== +SELECT json_valid('" \F "'); +-- +ok +== +SELECT json_valid('" \G "'); +-- +ok +== +SELECT json_valid('" \H "'); +-- +ok +== +SELECT json_valid('" \I "'); +-- +ok +== +SELECT json_valid('" \J "'); +-- +ok +== +SELECT json_valid('" \K "'); +-- +ok +== +SELECT json_valid('" \L "'); +-- +ok +== +SELECT json_valid('" \M "'); +-- +ok +== +SELECT json_valid('" \N "'); +-- +ok +== +SELECT json_valid('" \O "'); +-- +ok +== +SELECT json_valid('" \P "'); +-- +ok +== +SELECT json_valid('" \Q "'); +-- +ok +== +SELECT json_valid('" \R "'); +-- +ok +== +SELECT json_valid('" \S "'); +-- +ok +== +SELECT json_valid('" \T "'); +-- +ok +== +SELECT json_valid('" \U "'); +-- +ok +== +SELECT json_valid('" \V "'); +-- +ok +== +SELECT json_valid('" \W "'); +-- +ok +== +SELECT json_valid('" \X "'); +-- +ok +== +SELECT json_valid('" \Y "'); +-- +ok +== +SELECT json_valid('" \Z "'); +-- +ok +== +SELECT json_valid('" \[ "'); +-- +ok +== +SELECT json_valid('" \\ "'); +-- +ok +== +SELECT json_valid('" \] "'); +-- +ok +== +SELECT json_valid('" \^ "'); +-- +ok +== +SELECT json_valid('" \_ "'); +-- +ok +== +SELECT json_valid('" \` "'); +-- +ok +== +SELECT json_valid('" \a "'); +-- +ok +== +SELECT json_valid('" \b "'); +-- +ok +== +SELECT json_valid('" \c "'); +-- +ok +== +SELECT json_valid('" \d "'); +-- +ok +== +SELECT json_valid('" \e "'); +-- +ok +== +SELECT json_valid('" \f "'); +-- +ok +== +SELECT json_valid('" \g "'); +-- +ok +== +SELECT json_valid('" \h "'); +-- +ok +== +SELECT json_valid('" \i "'); +-- +ok +== +SELECT json_valid('" \j "'); +-- +ok +== +SELECT json_valid('" \k "'); +-- +ok +== +SELECT json_valid('" \l "'); +-- +ok +== +SELECT json_valid('" \m "'); +-- +ok +== +SELECT json_valid('" \n "'); +-- +ok +== +SELECT json_valid('" \o "'); +-- +ok +== +SELECT json_valid('" \p "'); +-- +ok +== +SELECT json_valid('" \q "'); +-- +ok +== +SELECT json_valid('" \r "'); +-- +ok +== +SELECT json_valid('" \s "'); +-- +ok +== +SELECT json_valid('" \t "'); +-- +ok +== +SELECT json_valid('" \u "'); +-- +ok +== +SELECT json_valid('" \ua "'); +-- +ok +== +SELECT json_valid('" \uab "'); +-- +ok +== +SELECT json_valid('" \uabc "'); +-- +ok +== +SELECT json_valid('" \uabcd "'); +-- +ok +== +SELECT json_valid('" \uFEDC "'); +-- +ok +== +SELECT json_valid('" \u1234 "'); +-- +ok +== +SELECT json_valid('" \v "'); +-- +ok +== +SELECT json_valid('" \w "'); +-- +ok +== +SELECT json_valid('" \x "'); +-- +ok +== +SELECT json_valid('" \y "'); +-- +ok +== +SELECT json_valid('" \z "'); +-- +ok +== +SELECT json_valid('" \{ "'); +-- +ok +== +SELECT json_valid('" \| "'); +-- +ok +== +SELECT json_valid('" \} "'); +-- +ok +== +SELECT json_valid('" \~ "'); +-- +ok +== +SELECT json_valid('{"x":01}') +-- +ok +== +SELECT json_valid('{"x":-01}') +-- +ok +== +SELECT json_valid('{"x":0}') +-- +ok +== +SELECT json_valid('{"x":-0}') +-- +ok +== +SELECT json_valid('{"x":0.1}') +-- +ok +== +SELECT json_valid('{"x":-0.1}') +-- +ok +== +SELECT json_valid('{"x":0.0000}') +-- +ok +== +SELECT json_valid('{"x":-0.0000}') +-- +ok +== +SELECT json_valid('{"x":01.5}') +-- +ok +== +SELECT json_valid('{"x":-01.5}') +-- +ok +== +SELECT json_valid('{"x":00}') +-- +ok +== +SELECT json_valid('{"x":-00}') +-- +ok +== diff --git a/parser/testdata/corpus/sql/json/scalar/test_json_value.test b/parser/testdata/corpus/sql/json/scalar/test_json_value.test new file mode 100644 index 0000000..f13ffe3 --- /dev/null +++ b/parser/testdata/corpus/sql/json/scalar/test_json_value.test @@ -0,0 +1,124 @@ +# source: test/sql/json/scalar/test_json_value.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +select json_value('{"foo": null}', '$.foo') +-- +ok +== +select json_value('{"foo": null}', '$.foo.bar') +-- +ok +== +select json_value('null', '$') +-- +ok +== +select json_value('[null]', '$[0]') +-- +ok +== +select json_value('{"my_field": {"my_nested_field": ["goose", "duck"]}}', '/my_field/my_nested_field/1') +-- +ok +== +select json_value('{"my_field": {"my_nested_field": ["goose", "duckduckduckduck"]}}', '/my_field/my_nested_field/1') +-- +ok +== +select json_value('[1, 2, 42]', 2) +-- +ok +== +SELECT json_value('{"a":2,"c":[4,5,{"f":7}]}', '$'); +-- +ok +== +SELECT json_value('{"a":2,"c":[4,5,{"f":7}]}', '$.c'); +-- +ok +== +SELECT json_value('{"a":2,"c":[4,5,{"f":7}]}', '$.c[2]'); +-- +ok +== +SELECT json_value('{"a":2,"c":[4,5,{"f":7}]}', '$.c[2].f'); +-- +ok +== +SELECT json_value('{"a":2,"c":[4,5,{"f":7}]}', '$.x'); +-- +ok +== +with tbl as ( + select '{"a":2,"c":[4,5],"f":7}' j, ['$.c','$.a'] p +) +SELECT json_value(j, p); +-- +ok +== +SELECT json_value('{"a":2,"c":[4,5],"f":7}', ['$.c','$.a']); +-- +ok +== +SELECT json_value('{"a":2,"c":[4,5,{"f":7}]}', ['$.x', '$.a']); +-- +ok +== +SELECT json_value(NULL, ['$.x', '$.a']); +-- +ok +== +SELECT json_value(j, '$.b[#]') FROM t1; +-- +ok +== +SELECT json_value(j, '$.a[#-1]'), json_value(j, '$.a[-1]') FROM t1; +-- +ok +== +SELECT json_value(j, '$.b[#-000001]') a, a = json_value(j, '$.b[-000001]') FROM t1; +-- +ok +== +SELECT json_value(j, '$.b[#-]') FROM t1; +-- +ok +== +SELECT json_value(j, '$.b[-]') FROM t1; +-- +ok +== +SELECT json_value(j, '$.b[#9]') FROM t1; +-- +ok +== +SELECT json_value(j, '$.b[#+2]') FROM t1; +-- +ok +== +SELECT json_value(j, '$.b[#-1') FROM t1; +-- +ok +== +SELECT json_value(j, '$.b[#-1x]') FROM t1; +-- +ok +== +SELECT json_value(x, '$.b') FROM obj; +-- +ok +== +SELECT json_value(x, '$."b"') FROM obj; +-- +ok +== +SELECT json_value(x, '$.settings.layer2."tris.legomenon"."summary.report"') FROM t12; +-- +ok +== +SELECT json_value(x, '$.settings.layer2."tris.legomenon"') FROM t12; +-- +ok +== diff --git a/parser/testdata/corpus/sql/json/scalar/test_st_asgeojson.test b/parser/testdata/corpus/sql/json/scalar/test_st_asgeojson.test new file mode 100644 index 0000000..2aca355 --- /dev/null +++ b/parser/testdata/corpus/sql/json/scalar/test_st_asgeojson.test @@ -0,0 +1,79 @@ +# source: test/sql/json/scalar/test_st_asgeojson.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +CREATE TABLE types (geom GEOMETRY); +-- +ok +== +INSERT INTO types VALUES + ('POINT EMPTY'), + ('POINT(0 0)'), + ('LINESTRING EMPTY'), + ('LINESTRING(0 0, 1 1)'), + ('POLYGON EMPTY'), + ('POLYGON((0 0, 1 0, 1 1, 0 1, 0 0))'), + ('MULTIPOINT EMPTY'), + ('MULTIPOINT(0 0, 1 1)'), + ('MULTILINESTRING EMPTY'), + ('MULTILINESTRING((0 0, 1 1), (2 2, 3 3))'), + ('MULTIPOLYGON EMPTY'), + ('MULTIPOLYGON(((0 0, 1 0, 1 1, 0 1, 0 0)), ((2 2, 3 2, 3 3, 2 3, 2 2)))'), + ('GEOMETRYCOLLECTION EMPTY'), + ('GEOMETRYCOLLECTION(POINT(0 0), LINESTRING(0 0, 1 1))'); +-- +ok +== +SELECT ST_AsGeoJSON(geom) FROM types; +-- +ok +== +SELECT typeof(ST_AsGeoJSON('POINT(1 2)'::GEOMETRY)); +-- +ok +== +SELECT ST_AsGeoJSON('POINT(1 2)'::GEOMETRY)->>'$.type'; +-- +ok +== +SELECT ST_AsGeoJSON('POINT Z(1 2 3)'::GEOMETRY); +-- +ok +== +SELECT ST_AsGeoJSON('LINESTRING Z(1 2 3, 4 5 6)'::GEOMETRY); +-- +ok +== +SELECT ST_AsGeoJSON('POINT M(1 2 3)'::GEOMETRY); +-- +ok +== +SELECT ST_AsGeoJSON('POINT ZM(1 2 3 4)'::GEOMETRY); +-- +ok +== +SELECT ST_AsGeoJSON('LINESTRING M(1 2 3, 4 5 6)'::GEOMETRY); +-- +ok +== +SELECT ST_AsGeoJSON('GEOMETRYCOLLECTION(GEOMETRYCOLLECTION(POINT(1 2)))'::GEOMETRY); +-- +ok +== +SELECT ST_AsGeoJSON('MULTIPOINT(1 2, EMPTY, 3 4)'::GEOMETRY); +-- +ok +== +SELECT ST_AsGeoJSON(NULL::GEOMETRY); +-- +ok +== +SELECT ST_AsGeoJSON('POINT(-122.4194 37.7749)'::GEOMETRY); +-- +ok +== +SELECT ST_AsGeoJSON('not a geometry'); +-- +ok +== diff --git a/parser/testdata/corpus/sql/json/scalar/test_st_geomfromgeojson.test b/parser/testdata/corpus/sql/json/scalar/test_st_geomfromgeojson.test new file mode 100644 index 0000000..c65205e --- /dev/null +++ b/parser/testdata/corpus/sql/json/scalar/test_st_geomfromgeojson.test @@ -0,0 +1,101 @@ +# source: test/sql/json/scalar/test_st_geomfromgeojson.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +SELECT ST_AsText(ST_GeomFromGeoJSON(ST_AsGeoJSON(geom))) FROM types; +-- +ok +== +SELECT typeof(ST_GeomFromGeoJSON('{"type":"Point","coordinates":[1,2]}')); +-- +ok +== +SELECT ST_AsText(ST_GeomFromGeoJSON('{"type":"Point","coordinates":[1,2]}'::JSON)); +-- +ok +== +SELECT ST_AsText(ST_GeomFromGeoJSON('{"type":"Point","coordinates":[1,2]}'::VARCHAR)); +-- +ok +== +SELECT ST_AsText(ST_GeomFromGeoJSON('{"type":"Point","coordinates":[1.0,2.0,3.0]}')); +-- +ok +== +SELECT ST_AsText(ST_GeomFromGeoJSON('{"type":"LineString","coordinates":[[1.0,2.0,3.0],[4.0,5.0,6.0]]}')); +-- +ok +== +SELECT ST_AsText(ST_GeomFromGeoJSON('{"type":"Polygon","coordinates":[[[1.0,2.0,3.0],[4.0,5.0,6.0],[7.0,8.0,9.0],[1.0,2.0,3.0]]]}')); +-- +ok +== +SELECT ST_AsText(ST_GeomFromGeoJSON('{"type":"LineString","coordinates":[[1,2],[3,4,5]]}')); +-- +ok +== +SELECT ST_AsText(ST_GeomFromGeoJSON('{"type":"Point","coordinates":[1,2,3,4]}')); +-- +ok +== +SELECT ST_AsText(ST_GeomFromGeoJSON('{"type":"Point","coordinates":[1,2],"crs":{"type":"name"},"bbox":[0,0,1,1]}')); +-- +ok +== +SELECT ST_GeomFromGeoJSON(NULL); +-- +ok +== +SELECT ST_AsText(ST_GeomFromGeoJSON('{"type":"Point","coordinates":[-122.4194,37.7749]}')); +-- +ok +== +SELECT ST_GeomFromGeoJSON('{"type":"Nope","coordinates":[1,2]}'); +-- +ok +== +SELECT ST_GeomFromGeoJSON('{"coordinates":[1,2]}'); +-- +ok +== +SELECT ST_GeomFromGeoJSON('{"type":"Point"}'); +-- +ok +== +SELECT ST_GeomFromGeoJSON('{"type":"Point","coordinates":["a","b"]}'); +-- +ok +== +SELECT ST_GeomFromGeoJSON('{"type":"Point","coordinates":[1]}'); +-- +ok +== +SELECT ST_GeomFromGeoJSON('{"type":"Polygon","coordinates":[1,2]}'); +-- +ok +== +SELECT ST_GeomFromGeoJSON('{"type":"Polygon","coordinates":[[1,2],[3,4]]}'); +-- +ok +== +SELECT ST_GeomFromGeoJSON('{"type":"GeometryCollection"}'); +-- +ok +== +SELECT ST_GeomFromGeoJSON('[1,2]'); +-- +ok +== +SELECT ST_GeomFromGeoJSON('{"type":"Point","coordinates":' || repeat('[', 100000) || repeat(']', 100000) || '}'); +-- +ok +== +SELECT ST_GeomFromGeoJSON('{"type":"GeometryCollection","geometries":[' || repeat('{"type":"GeometryCollection","geometries":[', 100000) || '{"type":"Point","coordinates":[1,2]}' || repeat(']}', 100000) || ']}'); +-- +ok +== +SELECT ST_GeomFromGeoJSON('not json at all'); +-- +ok +== diff --git a/parser/testdata/corpus/sql/json/table/auto_glob_directory.test b/parser/testdata/corpus/sql/json/table/auto_glob_directory.test new file mode 100644 index 0000000..08b1e55 --- /dev/null +++ b/parser/testdata/corpus/sql/json/table/auto_glob_directory.test @@ -0,0 +1,13 @@ +# source: test/sql/json/table/auto_glob_directory.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +COPY (SELECT i%2 AS grp, i FROM range(1000) t(i)) TO '{TEST_DIR}/glob_dir_json' (FORMAT json, PER_THREAD_OUTPUT); +-- +ok +== +SELECT grp, COUNT(*) FROM read_json('{TEST_DIR}/glob_dir_json') GROUP BY ALL ORDER BY ALL +-- +ok +== diff --git a/parser/testdata/corpus/sql/json/table/json_empty_array.test b/parser/testdata/corpus/sql/json/table/json_empty_array.test new file mode 100644 index 0000000..9293464 --- /dev/null +++ b/parser/testdata/corpus/sql/json/table/json_empty_array.test @@ -0,0 +1,37 @@ +# source: test/sql/json/table/json_empty_array.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +select * from '{DATA_DIR}/json/empty.ndjson' +-- +ok +== +select * from '{DATA_DIR}/json/whitespace_only.json' +-- +ok +== +SELECT * FROM read_json_auto('{DATA_DIR}/json/empty_array.json') +-- +ok +== +SELECT * FROM read_json_auto('{DATA_DIR}/json/empty_no_newline.json') +-- +ok +== +SELECT * FROM read_json_auto('{DATA_DIR}/json/malformed/empty_array_malformed.json') +-- +ok +== +SELECT * FROM read_json_auto('{DATA_DIR}/json/malformed/empty_array_trailing.json', format='array') +-- +ok +== +SELECT * FROM read_json_auto('{DATA_DIR}/json/malformed/array_comma_malformed.json', format='array') +-- +ok +== +SELECT * FROM read_json_auto('{DATA_DIR}/json/array_of_empty_arrays.json', format='array') +-- +ok +== diff --git a/parser/testdata/corpus/sql/json/table/json_multi_file_reader.test b/parser/testdata/corpus/sql/json/table/json_multi_file_reader.test new file mode 100644 index 0000000..bb4839b --- /dev/null +++ b/parser/testdata/corpus/sql/json/table/json_multi_file_reader.test @@ -0,0 +1,85 @@ +# source: test/sql/json/table/json_multi_file_reader.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +create table test as SELECT i as i, to_json([i%4]) as j FROM range(0,20) as tbl(i) +-- +ok +== +COPY test TO '{TEMP_DIR}/json_part' (FORMAT csv, quote '', PARTITION_BY (j), HEADER 0); +-- +ok +== +select * exclude (filename), parse_filename(filename) as filename from read_json_auto('{DATA_DIR}/json/example_*.ndjson', filename=true) order by all +-- +ok +== +select *, parse_filename(filename) from read_json_auto('{DATA_DIR}/json/example_*.ndjson') order by all +-- +ok +== +select * from read_json_auto(['{DATA_DIR}/json/example_n.ndjson', '{DATA_DIR}/json/top_level_array.json'], union_by_name=true) order by all +-- +ok +== +SELECT j, count(*) FROM read_json_auto('{TEMP_DIR}/json_part/j=*/*.csv', HIVE_PARTITIONING=1) group by j order by j; +-- +ok +== +select * exclude (filename), parse_filename(filename) as filename from read_json_objects_auto('{DATA_DIR}/json/example_*.ndjson', filename=true) order by all +-- +ok +== +select * from read_json_objects_auto(['{DATA_DIR}/json/example_n.ndjson', '{DATA_DIR}/json/top_level_array.json'], union_by_name=true) order by all +-- +ok +== +select j, count(*) from read_json_objects_auto('{TEMP_DIR}/json_part/j=*/*.csv', HIVE_PARTITIONING=1) group by j order by j +-- +ok +== +SELECT j, count(*) +FROM read_json_auto('{TEMP_DIR}/json_part/j=*/*.csv', HIVE_PARTITIONING=1) +where j='[2]' +group by j +order by j; +-- +ok +== +SELECT j, count(*) +FROM read_json_auto('{TEMP_DIR}/json_part/j=*/*.csv', HIVE_PARTITIONING=1) +where j>'[2]' +group by j +order by j; +-- +ok +== +SELECT j, count(*) +FROM read_json_auto('{TEMP_DIR}/json_part/j=*/*.csv', HIVE_PARTITIONING=1) +where sqrt(j[2]::int) > 1.5 +group by j +order by j; +-- +ok +== +SELECT * FROM read_json_auto(['{DATA_DIR}/json/with_uuid.json', '{DATA_DIR}/json/example_n.ndjson']) +-- +ok +== +SELECT * FROM read_json_auto(['{DATA_DIR}/json/with_uuid.json', '{DATA_DIR}/json/example_n.ndjson'], sample_size=1, maximum_sample_files=1) +-- +ok +== +SELECT * FROM read_json_auto(['{DATA_DIR}/json/with_uuid.json', '{DATA_DIR}/json/example_n.ndjson'], sample_size=1, maximum_sample_files=99) +-- +ok +== +SELECT * FROM read_json_auto(['{DATA_DIR}/json/with_uuid.json', '{DATA_DIR}/json/example_n.ndjson'], sample_size=1, union_by_name=true) +-- +ok +== +SELECT * FROM read_json_auto(['{DATA_DIR}/json/with_uuid.json', '{DATA_DIR}/json/example_n.ndjson'], sample_size=6) +-- +ok +== diff --git a/parser/testdata/corpus/sql/json/table/json_table_in_out_fullkey_quoting.test b/parser/testdata/corpus/sql/json/table/json_table_in_out_fullkey_quoting.test new file mode 100644 index 0000000..334d989 --- /dev/null +++ b/parser/testdata/corpus/sql/json/table/json_table_in_out_fullkey_quoting.test @@ -0,0 +1,66 @@ +# source: test/sql/json/table/json_table_in_out_fullkey_quoting.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +SELECT fullkey, value FROM json_each('{"a.b": 1}') +-- +ok +== +SELECT json_extract('{"a.b": 1}', fullkey) FROM json_each('{"a.b": 1}') +-- +ok +== +SELECT key, fullkey, path FROM json_tree('{"a.b": {"c": [1, 2]}}') +-- +ok +== +SELECT count(*) +FROM json_tree('{"a.b": {"c": [1, 2]}}') +WHERE json_extract('{"a.b": {"c": [1, 2]}}', fullkey) IS DISTINCT FROM value +-- +ok +== +SELECT key, fullkey FROM json_each('{"x1": 1, "Ab": 2, "a_b": 3}') +-- +ok +== +SELECT key, fullkey FROM json_each('{"a.b": 1, "a b": 2, "0a": 3, "_x": 4, "*": 5, "a[0]": 6}') +-- +ok +== +SELECT key, fullkey FROM json_each('{"a\"b": 1}') +-- +ok +== +SELECT key, fullkey FROM json_each('{"a\\b": 1}') +-- +ok +== +SELECT key, fullkey FROM json_each('{"é": 1}') +-- +ok +== +SELECT key, fullkey FROM json_each('{"": 1}') +-- +ok +== +SELECT count(*) +FROM json_each('{"a.b": 1, "a b": 2, "0a": 3, "_x": 4, "a[0]": 6, "a\"b": 7, "a\\b": 8, "é": 9, "x1": 10}') +WHERE json_extract('{"a.b": 1, "a b": 2, "0a": 3, "_x": 4, "a[0]": 6, "a\"b": 7, "a\\b": 8, "é": 9, "x1": 10}', + fullkey) IS DISTINCT FROM value +-- +ok +== +SELECT key, fullkey FROM json_each('{"nested": {"a.b": 1}}', '$.nested') +-- +ok +== +SELECT json_extract('{"nested": {"a.b": 1}}', fullkey) FROM json_each('{"nested": {"a.b": 1}}', '$.nested') +-- +ok +== +SELECT key, fullkey, path FROM json_tree('[{"a.b": 42}]') +-- +ok +== diff --git a/parser/testdata/corpus/sql/json/table/multi_file_hang.test b/parser/testdata/corpus/sql/json/table/multi_file_hang.test new file mode 100644 index 0000000..3e0ef66 --- /dev/null +++ b/parser/testdata/corpus/sql/json/table/multi_file_hang.test @@ -0,0 +1,17 @@ +# source: test/sql/json/table/multi_file_hang.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +set threads=8 +-- +ok +== +from read_json('{DATA_DIR}/json/multi_file_hang/*.json', sample_size=1, maximum_sample_files=1) +-- +ok +== +SELECT * FROM read_json('{DATA_DIR}/json/fuzzer_hang.json', ignore_errors=true); +-- +ok +== diff --git a/parser/testdata/corpus/sql/json/table/read_geojson_errors.test b/parser/testdata/corpus/sql/json/table/read_geojson_errors.test new file mode 100644 index 0000000..c30d675 --- /dev/null +++ b/parser/testdata/corpus/sql/json/table/read_geojson_errors.test @@ -0,0 +1,37 @@ +# source: test/sql/json/table/read_geojson_errors.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +SELECT ST_AsText(geometry) FROM read_json('data/json/geojson/malformed.geojsonl'); +-- +ok +== +SELECT ST_AsText(geometry) FROM read_json('data/json/geojson/malformed.geojsonl', ignore_errors=true); +-- +ok +== +SELECT ST_AsText(geometry) FROM read_json('data/json/geojson/malformed.geojsonl', records='false', columns={geometry: 'GEOMETRY'}); +-- +ok +== +SELECT ST_AsText(geometry) FROM read_json('data/json/geojson/malformed.geojsonl', records='false', ignore_errors=true, columns={geometry: 'GEOMETRY'}); +-- +ok +== +COPY (SELECT '{"g":{"type":"Polygon","coordinates":[1,2]}}' AS c) TO '{TEST_DIR}/shallow.geojsonl' (FORMAT CSV, HEADER false, QUOTE '', ESCAPE ''); +-- +ok +== +SELECT g FROM read_json('{TEST_DIR}/shallow.geojsonl'); +-- +ok +== +COPY (SELECT '{"g":"NOT WKT"}' AS c) TO '{TEST_DIR}/badwkt.ndjson' (FORMAT CSV, HEADER false, QUOTE '', ESCAPE ''); +-- +ok +== +SELECT g FROM read_json('{TEST_DIR}/badwkt.ndjson', columns={g: 'GEOMETRY'}); +-- +ok +== diff --git a/parser/testdata/corpus/sql/json/table/read_geojson_featurecollection.test b/parser/testdata/corpus/sql/json/table/read_geojson_featurecollection.test new file mode 100644 index 0000000..6fdc002 --- /dev/null +++ b/parser/testdata/corpus/sql/json/table/read_geojson_featurecollection.test @@ -0,0 +1,97 @@ +# source: test/sql/json/table/read_geojson_featurecollection.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +SELECT ST_AsText(geometry), name, pop, area +FROM read_json('data/json/geojson/features.geojson'); +-- +ok +== +SELECT column_name, column_type +FROM (DESCRIBE SELECT * FROM read_json('data/json/geojson/features.geojson')); +-- +ok +== +SELECT count(*) FROM read_json('data/json/geojson/features.geojson'); +-- +ok +== +SELECT ST_AsText(geometry), name FROM 'data/json/geojson/features.geojson' LIMIT 2; +-- +ok +== +SELECT count(*) FROM 'data/json/geojson/features.geojsonl'; +-- +ok +== +SELECT name, pop FROM read_json('data/json/geojson/features.geojson') WHERE pop IS NOT NULL ORDER BY pop; +-- +ok +== +SELECT count(geometry) FROM read_json('data/json/geojson/features.geojson'); +-- +ok +== +SELECT name AS n, "type" FROM read_json('data/json/geojson/features.geojson'); +-- +ok +== +SELECT column_name, column_type +FROM (DESCRIBE SELECT * FROM read_json('data/json/geojson/features.geojson', geojson=false)); +-- +ok +== +COPY (SELECT content FROM read_text('data/json/geojson/features.geojson')) TO '{TEST_DIR}/fc_copy.json' (FORMAT CSV, HEADER false, QUOTE '', ESCAPE ''); +-- +ok +== +SELECT count(*) FROM read_json('{TEST_DIR}/fc_copy.json', geojson=true); +-- +ok +== +SELECT count(*) FROM read_json('{TEST_DIR}/fc_copy.json'); +-- +ok +== +COPY (SELECT '{"type":"Inventory","features":[{"a":1},{"a":2}]}' AS c) TO '{TEST_DIR}/not_fc.geojson' (FORMAT CSV, HEADER false, QUOTE '', ESCAPE ''); +-- +ok +== +SELECT column_name, column_type +FROM (DESCRIBE SELECT * FROM read_json('{TEST_DIR}/not_fc.geojson')); +-- +ok +== +COPY (SELECT '{"features":[{"type":"Feature","geometry":{"type":"Point","coordinates":[1,2]},"properties":{"k":1}}],"type":"FeatureCollection"}' AS c) TO '{TEST_DIR}/fc_reorder.geojson' (FORMAT CSV, HEADER false, QUOTE '', ESCAPE ''); +-- +ok +== +SELECT ST_AsText(geometry), k FROM read_json('{TEST_DIR}/fc_reorder.geojson'); +-- +ok +== +COPY (SELECT '{"type":"FeatureCollection","features":[]}' AS c) TO '{TEST_DIR}/fc_empty.geojson' (FORMAT CSV, HEADER false, QUOTE '', ESCAPE ''); +-- +ok +== +SELECT count(*) FROM read_json('{TEST_DIR}/fc_empty.geojson'); +-- +ok +== +COPY (SELECT '{"type":"FeatureCollection","features":[{"type":"Feature","geometry":{"type":"Point","coordinates":[1,2]},"properties":{"k":1}}],"bbox":[1.0,2.0,1.0,2.0],"name":"tail"}' AS c) TO '{TEST_DIR}/fc_trailing.geojson' (FORMAT CSV, HEADER false, QUOTE '', ESCAPE ''); +-- +ok +== +SELECT ST_AsText(geometry), k FROM read_json('{TEST_DIR}/fc_trailing.geojson'); +-- +ok +== +COPY (SELECT '{"type":"FeatureCollection","features":[],"bbox":[0.0,0.0,0.0,0.0],"name":"tail"}' AS c) TO '{TEST_DIR}/fc_empty_trailing.geojson' (FORMAT CSV, HEADER false, QUOTE '', ESCAPE ''); +-- +ok +== +SELECT count(*) FROM read_json('{TEST_DIR}/fc_empty_trailing.geojson'); +-- +ok +== diff --git a/parser/testdata/corpus/sql/json/table/read_geojson_ndjson.test b/parser/testdata/corpus/sql/json/table/read_geojson_ndjson.test new file mode 100644 index 0000000..eb1c578 --- /dev/null +++ b/parser/testdata/corpus/sql/json/table/read_geojson_ndjson.test @@ -0,0 +1,44 @@ +# source: test/sql/json/table/read_geojson_ndjson.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +SELECT id, ST_AsText(geometry), name FROM read_json('data/json/geojson/features.geojsonl') ORDER BY id; +-- +ok +== +SELECT column_name, column_type +FROM (DESCRIBE SELECT * FROM read_json('data/json/geojson/features.geojsonl')); +-- +ok +== +SELECT column_name, column_type +FROM (DESCRIBE SELECT * FROM read_json('data/json/geojson/geometries.geojsonl')); +-- +ok +== +SELECT ST_AsText(geometry) FROM read_json('data/json/geojson/geometries.geojsonl'); +-- +ok +== +SELECT ST_AsText(geometry) FROM read_json('data/json/geojson/geometries.geojsonl', geojson=false, records='false', columns={geometry: 'GEOMETRY'}); +-- +ok +== +SELECT id, ST_AsText(loc), tag FROM read_json('data/json/geojson/nested.ndjson', geojson=false, columns={id: 'INTEGER', loc: 'GEOMETRY', tag: 'VARCHAR'}); +-- +ok +== +SELECT column_name, column_type +FROM (DESCRIBE SELECT * FROM read_json('data/json/geojson/geometries.geojsonl', geojson=false)); +-- +ok +== +SELECT ST_AsText(geometry) FROM read_ndjson('data/json/geojson/geometries.geojsonl', geojson=true); +-- +ok +== +SELECT count(*) FROM read_json('data/json/geojson/features.geojsonl'); +-- +ok +== diff --git a/parser/testdata/corpus/sql/json/table/read_geojson_nested.test b/parser/testdata/corpus/sql/json/table/read_geojson_nested.test new file mode 100644 index 0000000..efba43c --- /dev/null +++ b/parser/testdata/corpus/sql/json/table/read_geojson_nested.test @@ -0,0 +1,77 @@ +# source: test/sql/json/table/read_geojson_nested.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +SELECT column_name, column_type +FROM (DESCRIBE SELECT * FROM read_json('data/json/geojson/nested.ndjson', geojson=true)); +-- +ok +== +SELECT id, ST_AsText(loc), tag FROM read_json('data/json/geojson/nested.ndjson', geojson=true) ORDER BY id; +-- +ok +== +SELECT column_name, column_type +FROM (DESCRIBE SELECT * FROM read_json('data/json/geojson/nested.ndjson')); +-- +ok +== +COPY (SELECT '{"id":1,"a":{"b":{"c":{"type":"Point","coordinates":[5,6]}}}}' AS c) TO '{TEST_DIR}/deep.geojsonl' (FORMAT CSV, HEADER false, QUOTE '', ESCAPE ''); +-- +ok +== +SELECT column_name, column_type +FROM (DESCRIBE SELECT * FROM read_json('{TEST_DIR}/deep.geojsonl')); +-- +ok +== +SELECT ST_AsText(a.b.c) FROM read_json('{TEST_DIR}/deep.geojsonl'); +-- +ok +== +COPY (SELECT '{"id":1,"g":[{"type":"Point","coordinates":[1,2]},{"type":"Point","coordinates":[3,4]}]}' AS c) TO '{TEST_DIR}/inlist.geojsonl' (FORMAT CSV, HEADER false, QUOTE '', ESCAPE ''); +-- +ok +== +SELECT column_name, column_type +FROM (DESCRIBE SELECT * FROM read_json('{TEST_DIR}/inlist.geojsonl')); +-- +ok +== +SELECT ST_AsText(g[1]) FROM read_json('{TEST_DIR}/inlist.geojsonl'); +-- +ok +== +SELECT column_name, column_type +FROM (DESCRIBE SELECT * FROM read_json('data/json/geojson/near_miss.ndjson', geojson=true)); +-- +ok +== +COPY (SELECT '{"g":{"type":"Point","coordinates":"1,2"}}' AS c) TO '{TEST_DIR}/badcoords.geojsonl' (FORMAT CSV, HEADER false, QUOTE '', ESCAPE ''); +-- +ok +== +SELECT column_name, column_type +FROM (DESCRIBE SELECT * FROM read_json('{TEST_DIR}/badcoords.geojsonl')); +-- +ok +== +COPY (SELECT '{"g":{"type":"point","coordinates":[1,2]}}' AS c) TO '{TEST_DIR}/lowercase.geojsonl' (FORMAT CSV, HEADER false, QUOTE '', ESCAPE ''); +-- +ok +== +SELECT column_name, column_type +FROM (DESCRIBE SELECT * FROM read_json('{TEST_DIR}/lowercase.geojsonl')); +-- +ok +== +COPY (SELECT unnest(['{"g":{"type":"Point","coordinates":[1,2]}}', '{"g":{"other":1}}']) AS c) TO '{TEST_DIR}/inconsistent.geojsonl' (FORMAT CSV, HEADER false, QUOTE '', ESCAPE ''); +-- +ok +== +SELECT column_name, column_type +FROM (DESCRIBE SELECT * FROM read_json('{TEST_DIR}/inconsistent.geojsonl')); +-- +ok +== diff --git a/parser/testdata/corpus/sql/json/table/read_geojson_pseudo_columns.test b/parser/testdata/corpus/sql/json/table/read_geojson_pseudo_columns.test new file mode 100644 index 0000000..8a19a1f --- /dev/null +++ b/parser/testdata/corpus/sql/json/table/read_geojson_pseudo_columns.test @@ -0,0 +1,94 @@ +# source: test/sql/json/table/read_geojson_pseudo_columns.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +SELECT column_name, column_type +FROM (DESCRIBE SELECT * FROM read_json('data/json/geojson/pseudo_columns.geojsonl')); +-- +ok +== +SELECT ST_AsText(geometry), id, bbox, id_1, name +FROM read_json('data/json/geojson/pseudo_columns.geojsonl') ORDER BY id; +-- +ok +== +SELECT id, id_1 FROM read_json('data/json/geojson/pseudo_columns.geojsonl') ORDER BY id; +-- +ok +== +SELECT id_1 FROM read_json('data/json/geojson/pseudo_columns.geojsonl') ORDER BY id_1; +-- +ok +== +SELECT id FROM read_json('data/json/geojson/pseudo_columns.geojsonl') ORDER BY id; +-- +ok +== +SELECT bbox[1] FROM read_json('data/json/geojson/pseudo_columns.geojsonl') ORDER BY 1; +-- +ok +== +SELECT column_name, column_type +FROM (DESCRIBE SELECT * FROM read_json('data/json/geojson/pseudo_columns_nasty.geojsonl')); +-- +ok +== +SELECT ST_AsText(geometry), id, id_1, id_1_1, name, geometry_1 +FROM read_json('data/json/geojson/pseudo_columns_nasty.geojsonl'); +-- +ok +== +CREATE TABLE features (geometry GEOMETRY, id VARCHAR, name VARCHAR); +-- +ok +== +COPY features FROM 'data/json/geojson/pseudo_columns.geojsonl' (FORMAT GEOJSON); +-- +ok +== +SELECT ST_AsText(geometry), id, name FROM features ORDER BY id; +-- +ok +== +CREATE TABLE boxes (geometry GEOMETRY, bbox DOUBLE[]); +-- +ok +== +COPY boxes FROM 'data/json/geojson/pseudo_columns.geojsonl' (FORMAT GEOJSON); +-- +ok +== +SELECT ST_AsText(geometry), bbox FROM boxes ORDER BY bbox; +-- +ok +== +SELECT column_name, column_type +FROM (DESCRIBE SELECT * FROM read_json('data/json/geojson/property_id.geojsonl')); +-- +ok +== +CREATE TABLE property_ids (geometry GEOMETRY, id VARCHAR, name VARCHAR); +-- +ok +== +COPY property_ids FROM 'data/json/geojson/property_id.geojsonl' (FORMAT GEOJSON); +-- +ok +== +SELECT ST_AsText(geometry), id, name FROM property_ids ORDER BY id; +-- +ok +== +CREATE TABLE feature_ids (geometry GEOMETRY, id VARCHAR, name VARCHAR); +-- +ok +== +COPY feature_ids FROM 'data/json/geojson/pseudo_columns.geojsonl' (FORMAT GEOJSON); +-- +ok +== +SELECT ST_AsText(geometry), id, name FROM feature_ids ORDER BY id; +-- +ok +== diff --git a/parser/testdata/corpus/sql/json/table/read_json.test b/parser/testdata/corpus/sql/json/table/read_json.test new file mode 100644 index 0000000..fe2f600 --- /dev/null +++ b/parser/testdata/corpus/sql/json/table/read_json.test @@ -0,0 +1,199 @@ +# source: test/sql/json/table/read_json.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +SELECT * FROM read_json('{DATA_DIR}/json/example_n.ndjson', auto_detect=false) +-- +ok +== +SELECT * FROM read_json('{DATA_DIR}/json/example_n.ndjson', columns={id: 'INTEGER', name: 'VARCHAR'}, format='array') +-- +ok +== +SELECT * FROM read_ndjson('{DATA_DIR}/json/example_n.ndjson', columns={id: 'INTEGER', name: 'VARCHAR'}) +-- +ok +== +SELECT * FROM read_ndjson('{DATA_DIR}/json/example_n.ndjson', columns={id: 'INTEGER'}) +-- +ok +== +SELECT * FROM read_ndjson('{DATA_DIR}/json/example_n.ndjson', columns={name: 'VARCHAR'}) +-- +ok +== +SELECT * FROM read_ndjson('{DATA_DIR}/json/unterminated_quotes.ndjson', columns={id: 'INTEGER', name: 'VARCHAR'}, ignore_errors=true) +-- +ok +== +SELECT * FROM read_ndjson('{DATA_DIR}/json/different_schemas.ndjson', columns={id: 'INTEGER', name: 'VARCHAR'}) +-- +ok +== +SELECT id FROM read_json('{DATA_DIR}/json/example_n.ndjson', columns={id: 'INTEGER', name: 'VARCHAR'}, format='unstructured') +-- +ok +== +SELECT name FROM read_json('{DATA_DIR}/json/example_n.ndjson', columns={id: 'INTEGER', name: 'VARCHAR'}, format='unstructured') +-- +ok +== +SELECT id FROM read_json('{DATA_DIR}/json/example_n.ndjson', columns={id: 'INTEGER', name: 'VARCHAR'}, format='newline_delimited') +-- +ok +== +SELECT name FROM read_ndjson('{DATA_DIR}/json/example_n.ndjson', columns={id: 'INTEGER', name: 'VARCHAR'}, format='nd') +-- +ok +== +SELECT * FROM read_json_auto('{DATA_DIR}/json/example_n.ndjson') +-- +ok +== +SELECT * FROM '{DATA_DIR}/json/example_n.ndjson' +-- +ok +== +SELECT * FROM read_json_auto('{DATA_DIR}/json/with_list.json', maximum_depth=0) +-- +ok +== +SELECT * FROM read_json_auto('{DATA_DIR}/json/with_list.json', maximum_depth=1) +-- +ok +== +SELECT * FROM read_json_auto('{DATA_DIR}/json/with_list.json', maximum_depth=2) +-- +ok +== +SELECT * FROM read_json_auto('{DATA_DIR}/json/with_list.json', maximum_depth=3) +-- +ok +== +SELECT id, typeof(name), unnest(name) FROM '{DATA_DIR}/json/with_list.json' +-- +ok +== +SELECT id, typeof(name), unnest(name) FROM read_json_auto('{DATA_DIR}/json/with_list.json', maximum_depth=2) +-- +ok +== +SELECT typeof(id), typeof(name) FROM read_json_auto('{DATA_DIR}/json/with_list.json', maximum_depth=1) +-- +ok +== +SELECT id, typeof(id) FROM '{DATA_DIR}/json/with_uuid.json' +-- +ok +== +select * from read_json('{DATA_DIR}/json/top_level_array.json', columns={conclusion: 'VARCHAR'}) +-- +ok +== +select * from read_json('{DATA_DIR}/json/top_level_array.json', auto_detect=true) +-- +ok +== +select * from read_json('{DATA_DIR}/json/top_level_array.json', columns={conclusion: 'VARCHAR'}, format='unstructured', records=true) +-- +ok +== +select * from read_json_auto('{DATA_DIR}/json/example_n.ndjson', format='array') +-- +ok +== +copy (select 42 duck from range(10000)) to '{TEMP_DIR}/my_file.json' (array true) +-- +ok +== +select count(*) from read_json('{TEMP_DIR}/my_file.json', columns={duck: 'INTEGER'}, format='array') +-- +ok +== +select sum(duck) = 42*10000 from read_json('{TEMP_DIR}/my_file.json', columns={duck: 'INTEGER'}, format='array') +-- +ok +== +select count(*) from '{TEMP_DIR}/my_file.json' +-- +ok +== +select sum(duck) = 42*10000 from '{TEMP_DIR}/my_file.json' +-- +ok +== +copy (select list(range) from range(10)) to '{TEMP_DIR}/my_file.json' (format csv, quote '', HEADER 0) +-- +ok +== +select * from '{TEMP_DIR}/my_file.json' +-- +ok +== +select * from read_json('{TEMP_DIR}/my_file.json', format='array', columns={range: 'INTEGER'}, records=true) +-- +ok +== +select * from read_json_auto('{TEMP_DIR}/my_file.json', format='array', records=true) +-- +ok +== +select * from read_json('{TEMP_DIR}/my_file.json', format='auto', records=false, auto_detect=true) +-- +ok +== +select * from read_json('{TEMP_DIR}/my_file.json', format='auto', records='false', auto_detect=false) +-- +ok +== +select * from read_json('{TEMP_DIR}/my_file.json', format='unstructured', records='false', auto_detect=true) +-- +ok +== +select * from read_json('{TEMP_DIR}/my_file.json', format='array', records='false', auto_detect=true) +-- +ok +== +select * from read_json('{TEMP_DIR}/my_file.json', format='array', records='auto', auto_detect=true) +-- +ok +== +select json_structure(json ->> '$.metadata') as structure, +from read_json('{DATA_DIR}/json/issue.json', format='array', columns={'json': 'JSON'}, maximum_object_size=104857600) +limit 1; +-- +ok +== +select json_structure(json ->> '$.metadata') as structure, +from read_json('{DATA_DIR}/json/issue.json', format='array', records='false', columns={'json': 'JSON'}, maximum_object_size=104857600) +limit 1; +-- +ok +== +select json_structure(my_json ->> '$.metadata') as structure, +from read_json('{DATA_DIR}/json/issue.json', format='unstructured', records='false', columns={'my_json': 'JSON'}, maximum_object_size=104857600) +limit 1; +-- +ok +== +pragma disable_verification +-- +ok +== +copy (select 42 this_is_a_very_long_field_name_yes_very_much_so from range(50000)) to '{TEMP_DIR}/my_file.json' (array true) +-- +ok +== +select sum(this_is_a_very_long_field_name_yes_very_much_so) = 42 * 50000 from '{TEMP_DIR}/my_file.json' +-- +ok +== +select * from read_json_auto('https://github.com/duckdb/duckdb-data/releases/download/v1.0/example_rn.ndjson'); +-- +ok +== +select count(*) from duckdb_external_file_cache() where path like '%example_rn.ndjson%'; +-- +ok +== diff --git a/parser/testdata/corpus/sql/json/table/read_json_dates.test b/parser/testdata/corpus/sql/json/table/read_json_dates.test new file mode 100644 index 0000000..399294d --- /dev/null +++ b/parser/testdata/corpus/sql/json/table/read_json_dates.test @@ -0,0 +1,365 @@ +# source: test/sql/json/table/read_json_dates.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +select * from read_json_auto('{DATA_DIR}/json/simple_timestamp.json', columns={"ts": "TIMESTAMP[]"}); +-- +ok +== +create table date_test as select '1996/03/27'::DATE d +-- +ok +== +create table timestamp_test as select '1996-03-27 07:42:33'::TIMESTAMP t +-- +ok +== +copy (select d from date_test) to '{TEMP_DIR}/my_file.json' (dateformat) +-- +ok +== +copy (select d from date_test) to '{TEMP_DIR}/my_file.json' (timestampformat) +-- +ok +== +copy date_test from '{DATA_DIR}/json/simple_timestamp.json' (dateformat) +-- +ok +== +copy date_test from '{DATA_DIR}/json/simple_timestamp.json' (timestampformat) +-- +ok +== +copy (select d from date_test) to '{TEMP_DIR}/my_file.json' (dateformat {date_format}) +-- +error: Parser Error: syntax error at or near "}" +== +select typeof(d), d from '{TEMP_DIR}/my_file.json' +-- +ok +== +select typeof(d), d from read_ndjson('{TEMP_DIR}/my_file.json', columns={d: 'DATE'}, dateformat={date_format}) +-- +error: Parser Error: syntax error at or near "}" +== +select typeof(d), d from read_ndjson('{TEMP_DIR}/my_file.json', columns={d: 'DATE'}, dateformat='%d-%Y-%m') +-- +ok +== +drop table if exists date_copy_test +-- +ok +== +create table date_copy_test (d date) +-- +ok +== +copy date_copy_test from '{TEMP_DIR}/my_file.json' (dateformat {date_format}) +-- +error: Parser Error: syntax error at or near "}" +== +select typeof(d), d from date_copy_test +-- +ok +== +copy (select t from timestamp_test) to '{TEMP_DIR}/my_file.json' (format json, timestampformat {a} {b} {c}) +-- +error: Parser Error: syntax error at or near "}" +== +select typeof(t), t from '{TEMP_DIR}/my_file.json' +-- +ok +== +select typeof(t), t from read_ndjson('{TEMP_DIR}/my_file.json', columns={t: 'TIMESTAMP'}, timestamp_format={a} {b} {c}) +-- +error: Parser Error: syntax error at or near "}" +== +select typeof(t), t from read_ndjson('{TEMP_DIR}/my_file.json', columns={t: 'TIMESTAMP'}, timestamp_format='%H:%M:%S%y-%m-%d') +-- +ok +== +drop table if exists timestamp_copy_test +-- +ok +== +create table timestamp_copy_test (t timestamp) +-- +ok +== +copy timestamp_copy_test from '{TEMP_DIR}/my_file.json' (format json, timestampformat {a} {b} {c}) +-- +error: Parser Error: syntax error at or near "}" +== +select typeof(t), t from timestamp_copy_test +-- +ok +== +select typeof(createdAt), createdAt from '{DATA_DIR}/json/timestamp_example.json' +-- +ok +== +copy (select * from (values ('{"ts":"2023-02-07T19:12:28.123Z"}'))) to '{TEMP_DIR}/iso8601_frac_z.json' (format csv, quote '', header 0) +-- +ok +== +select typeof(ts), ts from read_json_auto('{TEMP_DIR}/iso8601_frac_z.json') +-- +ok +== +copy (select * from (values ('{"ts":"2023-02-07T19:12:28+00:00"}'))) to '{TEMP_DIR}/iso8601_tz.json' (format csv, quote '', header 0) +-- +ok +== +select typeof(ts), ts from read_json_auto('{TEMP_DIR}/iso8601_tz.json') +-- +ok +== +copy (select * from (values ('{"ts":"2023-02-07T19:12:28.456+00:00"}'))) to '{TEMP_DIR}/iso8601_frac_tz.json' (format csv, quote '', header 0) +-- +ok +== +select typeof(ts), ts from read_json_auto('{TEMP_DIR}/iso8601_frac_tz.json') +-- +ok +== +copy (select * from (values ('{"ts":"2023-02-07T14:12:28+05:00"}'))) to '{TEMP_DIR}/iso8601_pos_offset.json' (format csv, quote '', header 0) +-- +ok +== +select typeof(ts), ts from read_json_auto('{TEMP_DIR}/iso8601_pos_offset.json') +-- +ok +== +copy (select * from (values ('{"ts":"2023-02-07T19:12:28.789-07:00"}'))) to '{TEMP_DIR}/iso8601_neg_offset.json' (format csv, quote '', header 0) +-- +ok +== +select typeof(ts), ts from read_json_auto('{TEMP_DIR}/iso8601_neg_offset.json') +-- +ok +== +copy (select * from (values ('{"ts1":"2026-04-01T06:01:00.010000+00:00", "ts2":"2026-04-02T06:03:00+00:01", "ts3":"2026-04-03T06:03:00Z", "ts4":"2026-04-04T06:04:00"}'))) to '{TEMP_DIR}/issue_22103.json' (format csv, quote '', header 0) +-- +ok +== +SELECT typeof(ts1), ts1, typeof(ts2), ts2, typeof(ts3), ts3, typeof(ts4), ts4 +FROM read_json_auto('{TEMP_DIR}/issue_22103.json') +-- +ok +== +copy (select * from (values ('{"ts": "2026-04-04T06:04:00", "ts_tz": "2026-04-04T06:04:00Z"}'))) to '{TEMP_DIR}/ts_explicit_fmt.json' (format csv, quote '', header 0) +-- +ok +== +SELECT typeof(ts), ts, typeof(ts_tz), ts_tz +FROM read_json_auto('{TEMP_DIR}/ts_explicit_fmt.json', timestamp_format='%Y-%m-%dT%H:%M:%S') +-- +ok +== +SELECT strptime('2026-04-01T06:03:00+00:01', '%Y-%m-%dT%H:%M:%S'); +-- +ok +== +SELECT strptime('2026-04-01T06:03:00Z', '%Y-%m-%dT%H:%M:%S'); +-- +ok +== +create table timestamptz_test as select '1996-03-27 07:42:33+00'::TIMESTAMPTZ t +-- +ok +== +copy (select t from timestamptz_test) to '{TEMP_DIR}/my_file.json' (format json, timestampformat '%Y-%m-%d') +-- +ok +== +select t from '{TEMP_DIR}/my_file.json' +-- +ok +== +copy ( + select + '2026-01-01T12:00:00Z'::TIMESTAMP as ts, + '2026-01-01T12:00:00Z'::TIMESTAMPTZ as tstz +) to '{TEMP_DIR}/my_file.json' (format json, timestampformat '%a') +-- +ok +== +select ts, tstz from read_json('{TEMP_DIR}/my_file.json') +-- +ok +== +copy (select '2026-01-01 12:00:00+05:00'::TIMESTAMPTZ as ts) to '{TEMP_DIR}/my_file.json' (timestampformat '%Y-%m-%d %z', format json); +-- +ok +== +select ts from '{TEMP_DIR}/my_file.json'; +-- +ok +== +COPY ( + SELECT + DATE '2026-01-02' AS d, + {'d': DATE '2026-01-02'} AS payload, + [DATE '2026-01-02'] AS date_list +) TO '{TEMP_DIR}/nested_dateformat.json' (FORMAT JSON, dateformat '%d/%m/%Y'); +-- +ok +== +SELECT + json_extract_string(json, '$.d') AS top_level, + json_extract_string(json, '$.payload.d') AS nested_struct, + json_extract_string(json, '$.date_list[0]') AS nested_list +FROM read_json_objects('{TEMP_DIR}/nested_dateformat.json'); +-- +ok +== +COPY ( + SELECT + TIMESTAMP '2026-01-02 03:04:05' AS ts, + {'ts': TIMESTAMP '2026-01-02 03:04:05'} AS payload, + TIMESTAMPTZ '2026-01-02 03:04:05+00' AS tstz, + {'tstz': TIMESTAMPTZ '2026-01-02 03:04:05+00'} AS payload_tz +) TO '{TEMP_DIR}/nested_timestampformat.json' (FORMAT JSON, timestampformat '%Y/%m/%d %H:%M'); +-- +ok +== +SELECT + json_extract_string(json, '$.ts') AS top_level_ts, + json_extract_string(json, '$.payload.ts') AS nested_ts +FROM read_json_objects('{TEMP_DIR}/nested_timestampformat.json'); +-- +ok +== +WITH copied AS ( + SELECT json FROM read_json_objects('{TEMP_DIR}/nested_timestampformat.json') +), +expected AS ( + SELECT strftime(TIMESTAMPTZ '2026-01-02 03:04:05+00', '%Y/%m/%d %H:%M') AS formatted +) +SELECT + json_extract_string(json, '$.tstz') = formatted AS top_level_tstz_matches, + json_extract_string(json, '$.payload_tz.tstz') = formatted AS nested_tstz_matches +FROM copied, expected; +-- +ok +== +COPY ( + SELECT + TIMESTAMP_NS '2026-01-02 03:04:05.123456789' AS ts_ns, + TIMESTAMP_MS '2026-01-02 03:04:05.123' AS ts_ms, + TIMESTAMP_S '2026-01-02 03:04:05' AS ts_s, + TIME '03:04:05' AS t +) TO '{TEMP_DIR}/timestampformat_timestamp_variants.json' (FORMAT JSON, timestampformat '%Y/%m/%d %H:%M'); +-- +ok +== +SELECT + json_extract_string(json, '$.ts_ns') AS ts_ns, + json_extract_string(json, '$.ts_ms') AS ts_ms, + json_extract_string(json, '$.ts_s') AS ts_s, + json_extract_string(json, '$.t') AS t +FROM read_json_objects('{TEMP_DIR}/timestampformat_timestamp_variants.json'); +-- +ok +== +COPY ( + SELECT + '2026-01-02 03:04:05.123456789+00'::TIMESTAMPTZ_NS AS tstz_ns, + {'tstz_ns': '2026-01-02 03:04:05.123456789+00'::TIMESTAMPTZ_NS} AS payload_tz_ns, + ['2026-01-02 03:04:05.123456789+00'::TIMESTAMPTZ_NS] AS tstz_ns_list +) TO '{TEMP_DIR}/timestampformat_timestamptz_ns.json' + (FORMAT JSON, timestampformat '%Y/%m/%d %H:%M:%S.%n'); +-- +ok +== +SELECT + json_extract_string(json, '$.tstz_ns') AS top_level_tstz_ns, + json_extract_string(json, '$.payload_tz_ns.tstz_ns') AS nested_tstz_ns, + json_extract_string(json, '$.tstz_ns_list[0]') AS list_tstz_ns +FROM read_json_objects('{TEMP_DIR}/timestampformat_timestamptz_ns.json'); +-- +ok +== +COPY ( + SELECT map([DATE '2026-01-02'], [DATE '2026-01-03']) AS m +) TO '{TEMP_DIR}/map_key_dateformat.json' (FORMAT JSON, dateformat '%d/%m/%Y'); +-- +ok +== +SELECT trim(content, chr(10)) +FROM read_text('{TEMP_DIR}/map_key_dateformat.json'); +-- +ok +== +COPY ( + SELECT map([TIMESTAMP_NS '2026-01-02 03:04:05.123456789'], [1]) AS m +) TO '{TEMP_DIR}/map_key_timestamp_ns_format.json' (FORMAT JSON, timestampformat '%Y/%m/%d %H:%M:%S.%n'); +-- +ok +== +SELECT trim(content, chr(10)) +FROM read_text('{TEMP_DIR}/map_key_timestamp_ns_format.json'); +-- +ok +== +COPY ( + SELECT DATE '2026-01-02' AS d, {'d': DATE '2026-01-02'} AS payload, 42 AS v +) TO '{TEMP_DIR}/nested_dateformat_partition' + (FORMAT JSON, PARTITION_BY (d), WRITE_PARTITION_COLUMNS, dateformat '%d/%m/%Y'); +-- +ok +== +SELECT filename, trim(content, chr(10)) +FROM read_text('{TEMP_DIR}/nested_dateformat_partition/*/*.json') ORDER BY filename; +-- +ok +== +COPY ( + SELECT DATE '2026-01-02' AS d, {'d': DATE '2026-01-02'} AS payload, 42 AS v +) TO '{TEMP_DIR}/nested_dateformat_partition_excluded' + (FORMAT JSON, PARTITION_BY (d), dateformat '%d/%m/%Y'); +-- +ok +== +SELECT filename, trim(content, chr(10)) +FROM read_text('{TEMP_DIR}/nested_dateformat_partition_excluded/*/*.json') ORDER BY filename; +-- +ok +== +COPY ( + SELECT '2026-01-02 03:04:05.123456789+00'::TIMESTAMPTZ_NS AS ts, 42 AS v +) TO '{TEMP_DIR}/timestamptz_ns_partition' + (FORMAT JSON, PARTITION_BY (ts), WRITE_PARTITION_COLUMNS, timestampformat '%Y/%m/%d %H:%M:%S.%n'); +-- +ok +== +SELECT filename, trim(content, chr(10)) +FROM read_text('{TEMP_DIR}/timestamptz_ns_partition/*/*.json') ORDER BY filename; +-- +ok +== +COPY ( + SELECT TIMESTAMP_NS '2026-01-02 03:04:05.123456789' AS ts, 42 AS v +) TO '{TEMP_DIR}/timestamp_ns_partition' + (FORMAT JSON, PARTITION_BY (ts), WRITE_PARTITION_COLUMNS, timestampformat '%Y/%m/%d %H:%M:%S.%n'); +-- +ok +== +SELECT filename, trim(content, chr(10)) +FROM read_text('{TEMP_DIR}/timestamp_ns_partition/*/*.json') ORDER BY filename; +-- +ok +== +CREATE TABLE t (ts TIMESTAMP[]) +-- +ok +== +COPY t FROM '{DATA_DIR}/json/simple_timestamp.json' (FORMAT JSON, TIMESTAMPFORMAT '%Q') +-- +ok +== +SELECT * FROM read_json('{DATA_DIR}/json/simple_timestamp.json', timestampformat='%Q') +-- +ok +== diff --git a/parser/testdata/corpus/sql/json/table/read_json_objects.test b/parser/testdata/corpus/sql/json/table/read_json_objects.test new file mode 100644 index 0000000..4aec261 --- /dev/null +++ b/parser/testdata/corpus/sql/json/table/read_json_objects.test @@ -0,0 +1,129 @@ +# source: test/sql/json/table/read_json_objects.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +select * from read_json_objects('{DATA_DIR}/json/unterminated_quotes.ndjson') +-- +ok +== +SELECT * FROM read_csv('{DATA_DIR}/json/example_n.ndjson', columns={'json': 'JSON'}, delim=NULL, header=0, quote=NULL, escape=NULL, auto_detect = false) +-- +ok +== +SELECT * FROM read_ndjson_objects('{DATA_DIR}/json/example_n.ndjson') +-- +ok +== +SELECT * FROM read_ndjson_objects('{DATA_DIR}/json/example_n.ndjson', records='false') +-- +ok +== +SELECT * FROM read_json_objects('{DATA_DIR}/json/example_n.ndjson', format='auto') +-- +ok +== +SELECT * FROM read_json_objects('{DATA_DIR}/json/example_r.ndjson', format='unstructured') +-- +ok +== +SELECT * FROM read_json_objects('{DATA_DIR}/json/example_r.ndjson', format='auto') +-- +ok +== +SELECT * FROM read_ndjson_objects('{DATA_DIR}/json/example_r.ndjson') +-- +ok +== +SELECT * FROM read_ndjson_objects('{DATA_DIR}/json/example_rn.ndjson') +-- +ok +== +SELECT * FROM read_ndjson_objects('{DATA_DIR}/json/example_rn.ndjson.gz') +-- +ok +== +SELECT * FROM read_json_objects('{DATA_DIR}/json/example_rn.ndjson.gz', format='nd') +-- +ok +== +SELECT count(*) from read_json_objects(['{DATA_DIR}/json/example_n.ndjson', '{DATA_DIR}/json/example_r.ndjson', '{DATA_DIR}/json/example_rn.ndjson'], format='auto') +-- +ok +== +SELECT count(*) from read_ndjson_objects(['{DATA_DIR}/json/example_n.ndjson', '{DATA_DIR}/json/example_rn.ndjson']) +-- +ok +== +SELECT count(*) from read_json_objects('{DATA_DIR}/json/example_*.ndjson', format='auto') +-- +ok +== +SELECT count(*) from read_ndjson_objects('{DATA_DIR}/json/example_*n.ndjson') +-- +ok +== +select * from read_json_objects('{DATA_DIR}/json/empty.ndjson') +-- +ok +== +select * from read_ndjson_objects('{DATA_DIR}/json/empty.ndjson') +-- +ok +== +select * from read_json_objects('{DATA_DIR}/json/unterminated_quotes.ndjson', format='nd') +-- +ok +== +select * from read_ndjson_objects('{DATA_DIR}/json/unterminated_quotes.ndjson') +-- +ok +== +select * from read_json_objects('{DATA_DIR}/json/unterminated_quotes.ndjson', format='auto', ignore_errors=true) +-- +ok +== +select * from read_json_objects('{DATA_DIR}/json/multiple_objects_per_line.ndjson', format='unstructured') +-- +ok +== +select * from read_ndjson_objects('{DATA_DIR}/json/multiple_objects_per_line.ndjson') +-- +ok +== +select * from read_json_objects('{DATA_DIR}/csv/tpcds_14.csv') +-- +ok +== +select * from read_ndjson_objects('{DATA_DIR}/csv/tpcds_14.csv') +-- +ok +== +select * from read_json_objects('{DATA_DIR}/parquet-testing/blob.parquet') +-- +ok +== +select * from read_ndjson_objects('{DATA_DIR}/parquet-testing/blob.parquet') +-- +ok +== +select * from read_json_objects('{DATA_DIR}/json/top_level_array.json') +-- +ok +== +select * from read_json_objects('{DATA_DIR}/json/top_level_array.json', format='auto') +-- +ok +== +select * from read_json_objects('{DATA_DIR}/json/top_level_array.json', format='nd') +-- +ok +== +select * from read_ndjson_objects('{DATA_DIR}/json/trailing_content.ndjson') +-- +ok +== +select * from read_ndjson_objects('{DATA_DIR}/json/trailing_content.ndjson', ignore_errors=true) +-- +ok +== diff --git a/parser/testdata/corpus/sql/json/table/read_json_union.test b/parser/testdata/corpus/sql/json/table/read_json_union.test new file mode 100644 index 0000000..a6d5ad4 --- /dev/null +++ b/parser/testdata/corpus/sql/json/table/read_json_union.test @@ -0,0 +1,25 @@ +# source: test/sql/json/table/read_json_union.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +SELECT data FROM read_ndjson('{DATA_DIR}/json/union.ndjson', columns={data: 'UNION(name VARCHAR, age INT, veteran BOOL)'}) +-- +ok +== +SELECT * FROM read_ndjson('{DATA_DIR}/json/malformed/union/bad_key.ndjson', columns={data: 'UNION(name VARCHAR, age INT, veteran BOOL)'}) +-- +ok +== +SELECT * FROM read_ndjson('{DATA_DIR}/json/malformed/union/empty_object.ndjson', columns={data: 'UNION(name VARCHAR, age INT, veteran BOOL)'}) +-- +ok +== +SELECT * FROM read_ndjson('{DATA_DIR}/json/malformed/union/non_object.ndjson', columns={data: 'UNION(name VARCHAR, age INT, veteran BOOL)'}) +-- +ok +== +SELECT * FROM read_ndjson('{DATA_DIR}/json/malformed/union/too_many_keys.ndjson', columns={data: 'UNION(name VARCHAR, age INT, veteran BOOL)'}) +-- +ok +== diff --git a/parser/testdata/corpus/sql/json/table/read_json_unnest_heterogeneous_struct.test b/parser/testdata/corpus/sql/json/table/read_json_unnest_heterogeneous_struct.test new file mode 100644 index 0000000..511be43 --- /dev/null +++ b/parser/testdata/corpus/sql/json/table/read_json_unnest_heterogeneous_struct.test @@ -0,0 +1,64 @@ +# source: test/sql/json/table/read_json_unnest_heterogeneous_struct.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +COPY ( + SELECT * FROM (VALUES + ('{"results": [{"name": "Alice", "age": 30}, {"name": "Bob", "company": "ACME"}, {"name": "Charlie", "score": 95.5, "tags": ["a","b"]}]}') + ) +) TO '{TEMP_DIR}/heterogeneous.json' (format csv, quote '', header 0); +-- +ok +== +SELECT typeof(results[1]) FROM read_json_auto('{TEMP_DIR}/heterogeneous.json'); +-- +ok +== +SELECT unnest.name, unnest.age, unnest.company, unnest.score, unnest.tags +FROM read_json_auto('{TEMP_DIR}/heterogeneous.json') t, UNNEST(t.results) +ORDER BY unnest.name; +-- +ok +== +COPY ( + SELECT * FROM (VALUES + ('{"response": {"service": {"data": {"items": [{"type": "person", "first_name": "John", "last_name": "Doe"}, {"type": "company", "company_name": "Widgets Inc", "registration_number": "12345"}, {"type": "person", "first_name": "Jane", "middle_name": "M", "last_name": "Smith"}]}}}}') + ) +) TO '{TEMP_DIR}/nested_heterogeneous.json' (format csv, quote '', header 0); +-- +ok +== +SELECT unnest.type +FROM read_json_auto('{TEMP_DIR}/nested_heterogeneous.json') t, + UNNEST(t.response.service.data.items) +ORDER BY unnest.type; +-- +ok +== +SELECT unnest.type, unnest.first_name, unnest.last_name, unnest.company_name +FROM read_json_auto('{TEMP_DIR}/nested_heterogeneous.json') t, + UNNEST(t.response.service.data.items) +ORDER BY unnest.type, unnest.first_name; +-- +ok +== +SELECT json_extract_string(item, '$.name') +FROM ( + SELECT UNNEST(CAST(results AS JSON[])) AS item + FROM read_json_auto('{TEMP_DIR}/heterogeneous.json') +) +ORDER BY 1; +-- +ok +== +SELECT json_extract_string(item, '$.type'), + COALESCE(json_extract_string(item, '$.first_name'), json_extract_string(item, '$.company_name')) +FROM ( + SELECT UNNEST(CAST(t.response.service.data.items AS JSON[])) AS item + FROM read_json_auto('{TEMP_DIR}/nested_heterogeneous.json') t +) +ORDER BY 1, 2; +-- +ok +== diff --git a/parser/testdata/corpus/sql/json/table/test_json_copy_zstd.test b/parser/testdata/corpus/sql/json/table/test_json_copy_zstd.test new file mode 100644 index 0000000..372567e --- /dev/null +++ b/parser/testdata/corpus/sql/json/table/test_json_copy_zstd.test @@ -0,0 +1,17 @@ +# source: test/sql/json/table/test_json_copy_zstd.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +create table my_range as select range as i from range(10) +-- +ok +== +copy (select range as i from range(10)) to '{TEMP_DIR}/my.json.zst' (COMPRESSION ZSTD) +-- +ok +== +select * from '{TEMP_DIR}/my.json.zst' +-- +ok +== diff --git a/parser/testdata/corpus/sql/json/table/test_json_nested_struct_projection_pushdown.test b/parser/testdata/corpus/sql/json/table/test_json_nested_struct_projection_pushdown.test new file mode 100644 index 0000000..747e958 --- /dev/null +++ b/parser/testdata/corpus/sql/json/table/test_json_nested_struct_projection_pushdown.test @@ -0,0 +1,41 @@ +# source: test/sql/json/table/test_json_nested_struct_projection_pushdown.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +COPY (SELECT {goose: 42, pigeon: 4.2, nested_duck: {nested_nested_duck: {goose: 42, pigeon: 4.2, nested_nested_nested_duck: {goose: 42, pigeon: 4.2}}, goose: 42, pigeon: 4.2}} AS duck) TO '{TEST_DIR}/nested.json' +-- +ok +== +SELECT duck.goose FROM '{TEST_DIR}/nested.json' +-- +ok +== +SELECT json.duck.goose FROM read_json('{TEST_DIR}/nested.json', records=false) +-- +ok +== +SELECT duck.nested_duck.goose FROM '{TEST_DIR}/nested.json' +-- +ok +== +SELECT json.duck.nested_duck.goose FROM read_json('{TEST_DIR}/nested.json', records=false) +-- +ok +== +SELECT duck.nested_duck.nested_nested_duck.goose FROM '{TEST_DIR}/nested.json' +-- +ok +== +SELECT json.duck.nested_duck.nested_nested_duck.goose FROM read_json('{TEST_DIR}/nested.json', records=false) +-- +ok +== +SELECT duck.nested_duck.nested_nested_duck.nested_nested_nested_duck.goose FROM '{TEST_DIR}/nested.json' +-- +ok +== +SELECT json.duck.nested_duck.nested_nested_duck.nested_nested_nested_duck.goose FROM read_json('{TEST_DIR}/nested.json', records=false) +-- +ok +== diff --git a/parser/testdata/corpus/sql/json/test_json_bool.test b/parser/testdata/corpus/sql/json/test_json_bool.test new file mode 100644 index 0000000..858a0d5 --- /dev/null +++ b/parser/testdata/corpus/sql/json/test_json_bool.test @@ -0,0 +1,13 @@ +# source: test/sql/json/test_json_bool.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +SELECT json_extract('{"key": true}', '$.key')::BOOLEAN +-- +ok +== +SELECT json_extract('{"key": false}', '$.key')::BOOLEAN +-- +ok +== diff --git a/parser/testdata/corpus/sql/json/test_json_cast.test b/parser/testdata/corpus/sql/json/test_json_cast.test new file mode 100644 index 0000000..b656d32 --- /dev/null +++ b/parser/testdata/corpus/sql/json/test_json_cast.test @@ -0,0 +1,161 @@ +# source: test/sql/json/test_json_cast.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +SELECT '1010'::BIT(4)::JSON::BIT(4) +-- +ok +== +SELECT 1::BIGNUM::JSON::BIGNUM +-- +ok +== +SELECT true::BOOLEAN::JSON::BOOLEAN +-- +ok +== +SELECT 1::TINYINT::JSON::TINYINT +-- +ok +== +SELECT 1::SMALLINT::JSON::SMALLINT +-- +ok +== +SELECT 1::INTEGER::JSON::INTEGER +-- +ok +== +SELECT 1::BIGINT::JSON::BIGINT +-- +ok +== +SELECT date '2024-01-01'::DATE::JSON::DATE +-- +ok +== +SELECT time '12:34:56'::TIME::JSON::TIME +-- +ok +== +SELECT '2024-06-01 00:00:00'::TIMESTAMP_S::JSON::TIMESTAMP_S +-- +ok +== +SELECT '2024-06-01 00:00:00'::TIMESTAMP_MS::JSON::TIMESTAMP_MS +-- +ok +== +SELECT '2024-06-01 00:00:00'::TIMESTAMP::JSON::TIMESTAMP +-- +ok +== +SELECT '2024-06-01 00:00:00'::TIMESTAMP_NS::JSON::TIMESTAMP_NS +-- +ok +== +SELECT 1::DECIMAL(10, 2)::JSON::DECIMAL(10, 2) +-- +ok +== +SELECT 1::FLOAT::JSON::FLOAT +-- +ok +== +SELECT 1::DOUBLE::JSON::DOUBLE +-- +ok +== +SELECT '"text"'::CHAR::JSON::CHAR +-- +ok +== +SELECT '"text"'::VARCHAR::JSON::VARCHAR +-- +ok +== +SELECT 'blob'::BLOB::JSON::BLOB +-- +ok +== +SELECT INTERVAL '1 day'::INTERVAL::JSON::INTERVAL +-- +ok +== +SELECT 1::UTINYINT::JSON::UTINYINT +-- +ok +== +SELECT 1::USMALLINT::JSON::USMALLINT +-- +ok +== +SELECT 1::UINTEGER::JSON::UINTEGER +-- +ok +== +SELECT 1::UBIGINT::JSON::UBIGINT +-- +ok +== +SELECT '2024-06-01 00:00:00+00'::TIMESTAMPTZ::JSON::TIMESTAMPTZ +-- +ok +== +SELECT '00:00:00+00'::TIMETZ::JSON::TIMETZ +-- +ok +== +SELECT '00:00:00'::TIME_NS::JSON::TIME_NS +-- +ok +== +SELECT 1::UHUGEINT::JSON::UHUGEINT +-- +ok +== +SELECT 1::HUGEINT::JSON::HUGEINT +-- +ok +== +SELECT '00000000-0000-0000-0000-000000000001'::UUID::JSON::UUID +-- +ok +== +SELECT 'POINT(0 1)'::GEOMETRY::JSON::GEOMETRY +-- +ok +== +SELECT {'a': 1}::JSON::STRUCT(a INTEGER) +-- +ok +== +SELECT [1]::JSON::INTEGER[] +-- +ok +== +SELECT map(ARRAY[1], ARRAY['one'])::JSON::MAP(INTEGER, VARCHAR) +-- +ok +== +SELECT 'sad'::mood::JSON +-- +ok +== +SELECT 'sad'::mood::JSON::mood; +-- +ok +== +SELECT 1::UNION(a INTEGER, b VARCHAR)::JSON::UNION(a INTEGER, b VARCHAR) +-- +ok +== +SELECT [1]::INT[1]::JSON::INT[1] +-- +ok +== +SELECT 'foo'::VARIANT::JSON::VARIANT +-- +ok +== diff --git a/parser/testdata/corpus/sql/json/test_json_copy_serialize_plan.test b/parser/testdata/corpus/sql/json/test_json_copy_serialize_plan.test new file mode 100644 index 0000000..bddd73e --- /dev/null +++ b/parser/testdata/corpus/sql/json/test_json_copy_serialize_plan.test @@ -0,0 +1,31 @@ +# source: test/sql/json/test_json_copy_serialize_plan.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +SELECT json_extract_string( + json_serialize_plan('COPY (SELECT DATE ''2026-01-02'' AS d) TO ''{TEMP_DIR}/serialize_copy_date'' (FORMAT JSON, dateformat ''%d/%m/%Y'')'), + '$.error' +); +-- +ok +== +SELECT json_extract_string( + json_serialize_plan('COPY (SELECT ''2026-01-02 03:04:05.123456789+00''::TIMESTAMPTZ_NS AS ts) TO ''{TEMP_DIR}/serialize_copy_tstz_ns'' (FORMAT JSON, timestampformat ''%Y/%m/%d %H:%M:%S.%n'')'), + '$.error' +); +-- +ok +== +COPY ( + SELECT {'d': DATE '2026-01-02', 'ts': TIMESTAMP_NS '2026-01-02 03:04:05.123456789'} AS payload +) TO '{TEMP_DIR}/serialize_copy_nested_payload.json' + (FORMAT JSON, dateformat '%d/%m/%Y', timestampformat '%Y/%m/%d %H:%M:%S.%n'); +-- +ok +== +SELECT trim(content, chr(10)) +FROM read_text('{TEMP_DIR}/serialize_copy_nested_payload.json') +-- +ok +== diff --git a/parser/testdata/corpus/sql/json/test_json_empty_object.test b/parser/testdata/corpus/sql/json/test_json_empty_object.test new file mode 100644 index 0000000..40701a7 --- /dev/null +++ b/parser/testdata/corpus/sql/json/test_json_empty_object.test @@ -0,0 +1,45 @@ +# source: test/sql/json/test_json_empty_object.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +select json_structure('{}') +-- +ok +== +select json_transform('{}', '{}') +-- +ok +== +copy (select '{"a": {}}') to '{TEST_DIR}/my.json' (FORMAT CSV, quote '', header 0) +-- +ok +== +select typeof(a) from '{TEST_DIR}/my.json' +-- +ok +== +select * from read_json('{TEST_DIR}/my.json', columns={a: 'STRUCT()'}) +-- +ok +== +copy (select unnest(['{"c1":"val11","c2":{"k1":"val11","k2":{}}}','{"c1":"val21","c2":{"k1":"val21","k2":{}}}'])) to '{TEST_DIR}/data.ndjson' (FORMAT CSV, quote '', header 0) +-- +ok +== +CREATE OR REPLACE TABLE tbl AS SELECT * FROM read_ndjson_auto('{TEST_DIR}/data.ndjson'); +-- +ok +== +select typeof(c1), typeof(c2) from tbl; +-- +ok +== +copy tbl to '{TEST_DIR}/data.parquet'; +-- +ok +== +select * from '{TEST_DIR}/data.parquet'; +-- +ok +== diff --git a/parser/testdata/corpus/sql/json/test_json_export.test b/parser/testdata/corpus/sql/json/test_json_export.test new file mode 100644 index 0000000..1a92250 --- /dev/null +++ b/parser/testdata/corpus/sql/json/test_json_export.test @@ -0,0 +1,37 @@ +# source: test/sql/json/test_json_export.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +create table text(i varchar); +-- +ok +== +insert into text values ('bla'); +-- +ok +== +export database '{TEST_DIR}/test_export' (FORMAT JSON); +-- +ok +== +drop table text; +-- +ok +== +select * from text; +-- +ok +== +COPY text TO '{TEST_DIR}/text.json' (ARRAY) +-- +ok +== +COPY text from '{TEST_DIR}/text.json' (ARRAY) +-- +ok +== +select * from '{TEST_DIR}/text.json'; +-- +ok +== diff --git a/parser/testdata/corpus/sql/json/test_json_geometry_format.test b/parser/testdata/corpus/sql/json/test_json_geometry_format.test new file mode 100644 index 0000000..dca89af --- /dev/null +++ b/parser/testdata/corpus/sql/json/test_json_geometry_format.test @@ -0,0 +1,61 @@ +# source: test/sql/json/test_json_geometry_format.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +SELECT current_setting('json_geometry_format'); +-- +ok +== +SELECT to_json('POINT(1 2)'::GEOMETRY), 'POINT(1 2)'::GEOMETRY::JSON; +-- +ok +== +SET json_geometry_format='geojson'; +-- +ok +== +SELECT to_json(['POINT(1 2)'::GEOMETRY, NULL::GEOMETRY]); +-- +ok +== +SELECT json_object('g', 'LINESTRING(0 0, 1 1)'::GEOMETRY); +-- +ok +== +COPY (SELECT 1 AS id, 'POINT(1 2)'::GEOMETRY AS g) TO '{TEST_DIR}/setting.json' (FORMAT JSON); +-- +ok +== +SELECT trim(content, chr(10)) FROM read_text('{TEST_DIR}/setting.json'); +-- +ok +== +SET json_geometry_format='GeoJSON'; +-- +ok +== +SET json_geometry_format='WKT'; +-- +ok +== +RESET json_geometry_format; +-- +ok +== +SET json_geometry_format='wkt'; +-- +ok +== +COPY (SELECT 'POINT(1 2)'::GEOMETRY AS g) TO '{TEST_DIR}/always.geojsonl' (FORMAT GEOJSON, ARRAY false); +-- +ok +== +SELECT trim(content, chr(10)) FROM read_text('{TEST_DIR}/always.geojsonl'); +-- +ok +== +SET json_geometry_format='bogus'; +-- +ok +== diff --git a/parser/testdata/corpus/sql/json/test_json_group_window_macro.test b/parser/testdata/corpus/sql/json/test_json_group_window_macro.test new file mode 100644 index 0000000..38b53cf --- /dev/null +++ b/parser/testdata/corpus/sql/json/test_json_group_window_macro.test @@ -0,0 +1,21 @@ +# source: test/sql/json/test_json_group_window_macro.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +CREATE TABLE t(g INT, k VARCHAR, v INT); +-- +ok +== +INSERT INTO t VALUES (1, 'a', 10), (1, 'b', 20), (2, 'c', 30); +-- +ok +== +SELECT DISTINCT json_group_object(k, v) OVER (PARTITION BY g) FROM t ORDER BY 1; +-- +ok +== +SELECT DISTINCT json_group_array(v) OVER (PARTITION BY g) FROM t ORDER BY 1; +-- +ok +== diff --git a/parser/testdata/corpus/sql/json/test_json_macros.test b/parser/testdata/corpus/sql/json/test_json_macros.test new file mode 100644 index 0000000..806524a --- /dev/null +++ b/parser/testdata/corpus/sql/json/test_json_macros.test @@ -0,0 +1,41 @@ +# source: test/sql/json/test_json_macros.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +create table t1 as select range + 10 n, range v from range(10) +-- +ok +== +select json_group_array(v) from t1 +-- +ok +== +select json_group_object(n, v) from t1 +-- +ok +== +select json_group_object(n, v) from t1 group by n % 2 order by all +-- +ok +== +insert into t1 values (0, NULL), (20, NULL), (21, NULL), (1, 10), (2, 11) +-- +ok +== +create table t2 (j json) +-- +ok +== +insert into t2 values ('{"a": 42}'), ('{"a": 42.42, "b": "duck"}') +-- +ok +== +select json_group_structure(j) from t2 +-- +ok +== +select json(' { "this" : "is", "a": [ "test" ] }') +-- +ok +== diff --git a/parser/testdata/corpus/sql/json/test_json_persistence.test b/parser/testdata/corpus/sql/json/test_json_persistence.test new file mode 100644 index 0000000..b3e19ae --- /dev/null +++ b/parser/testdata/corpus/sql/json/test_json_persistence.test @@ -0,0 +1,17 @@ +# source: test/sql/json/test_json_persistence.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +create table test (j json) +-- +ok +== +insert into test values ('{"duck": 42}'), (NULL), ('{"goose": 43}') +-- +ok +== +select typeof(j), j from test +-- +ok +== diff --git a/parser/testdata/corpus/sql/json/test_json_serialize_plan.test b/parser/testdata/corpus/sql/json/test_json_serialize_plan.test new file mode 100644 index 0000000..b048e42 --- /dev/null +++ b/parser/testdata/corpus/sql/json/test_json_serialize_plan.test @@ -0,0 +1,65 @@ +# source: test/sql/json/test_json_serialize_plan.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +SELECT json_copy_to_json({'d': DATE '2026-01-02'}, '%d/%m/%Y', NULL); +-- +ok +== +SELECT __internal_json_copy_to_json({'d': DATE '2026-01-02'}, '%d/%m/%Y', NULL); +-- +ok +== +CREATE TABLE tbl1 (i int); +-- +ok +== +SELECT json_serialize_plan('SELECT 1 + 2 FROM tbl1'); +-- +ok +== +SELECT json_serialize_plan('SELECT *, 1 + 2 FROM tbl1', skip_null := true, skip_empty := true); +-- +ok +== +SELECT json_serialize_plan('SELECT *, 1 + 2 FROM tbl1', skip_null := true, skip_empty := true, optimize := true); +-- +ok +== +SELECT plan::VARCHAR LIKE '%LOGICAL_CHUNK_GET%', plan::VARCHAR NOT LIKE '%"column_ids"%' +FROM ( + SELECT json_serialize_plan( + 'SELECT i FROM range(20) t(i) WHERE i IN (1, 3, 5, 7, 9, 11)', + skip_default := true, optimize := true + ) plan +); +-- +ok +== +SELECT column_name FROM (DESCRIBE SELECT 42 AS a, 84 AS b); +-- +ok +== +SELECT plan::VARCHAR LIKE '%LOGICAL_CHUNK_GET%', plan::VARCHAR LIKE '%"column_ids"%' +FROM ( + SELECT json_serialize_plan( + 'SELECT column_name FROM (DESCRIBE SELECT 42 AS a, 84 AS b)', + skip_default := true, optimize := true + ) plan +); +-- +ok +== +SELECT json_serialize_plan('SELECT AND LAUNCH ROCKETS WHERE 1 = 1'); +-- +ok +== +SELECT json_serialize_plan('SELECT * FROM nonexistent_table') LIKE '%Table with name nonexistent_table does not exist%'; +-- +ok +== +select json_serialize_plan('select blob ''\\x00'''); +-- +ok +== diff --git a/parser/testdata/corpus/sql/json/test_json_serialize_sql.test b/parser/testdata/corpus/sql/json/test_json_serialize_sql.test new file mode 100644 index 0000000..37bfe75 --- /dev/null +++ b/parser/testdata/corpus/sql/json/test_json_serialize_sql.test @@ -0,0 +1,140 @@ +# source: test/sql/json/test_json_serialize_sql.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +SET storage_compatibility_version='v1.0.0' +-- +ok +== +SELECT json_serialize_sql('SELECT 1 + 2 FROM tbl1'); +-- +ok +== +SELECT json_serialize_sql('SELECT *, 1 + 2 FROM tbl1', skip_null := true, skip_empty := true); +-- +ok +== +SELECT json_serialize_sql('SELECT * FROM (SELECT 1 + 2)', skip_null := true, skip_empty := true); +-- +ok +== +SELECT json_serialize_sql('SELECT * FROM (SELECT 1 + 2)', skip_default := true, skip_empty := true, skip_null := true, format := true); +-- +ok +== +SELECT json_serialize_sql('SELECT AND LAUNCH ROCKETS WHERE 1 = 1'); +-- +ok +== +SELECT json_deserialize_sql(json_serialize_sql('SELECT 1 + 2 FROM tbl1')); +-- +ok +== +SELECT json_deserialize_sql(json_serialize_sql('SELECT *, 1 + 2 FROM tbl1')); +-- +ok +== +SELECT json_deserialize_sql(json_serialize_sql('SELECT * FROM (SELECT 1 + 2)')); +-- +ok +== +SELECT json_deserialize_sql(json_serialize_sql('SELECT * FROM t1 JOIN t2 USING("$id")')); +-- +ok +== +SELECT json_deserialize_sql(json_serialize_sql('SELECT AND LAUNCH ROCKETS WHERE 1 = 1')); +-- +error: Parser Error: Error parsing json: parser: syntax error at or near "AND" +== +SELECT json_deserialize_sql(json_serialize_sql('SELECT 1e10000')); +-- +ok +== +SELECT * FROM json_execute_serialized_sql(json_serialize_sql('SELECT 1 + 2')); +-- +ok +== +INSERT INTO tbl2 VALUES (1, 2, 3), (4, 5, 6), (7, 8, 9); +-- +ok +== +SELECT * FROM json_execute_serialized_sql(json_serialize_sql('SELECT * FROM tbl2')); +-- +ok +== +SELECT * FROM json_execute_serialized_sql(json_serialize_sql('SELECT a + b + c FROM tbl2')); +-- +ok +== +PRAGMA json_execute_serialized_sql( + '{"error":false,"statements":[{"node":{"type":"SELECT_NODE","modifiers":[],"cte_map":{"map":[]},"select_list":[{"class":"FUNCTION","type":"FUNCTION","alias":"","function_name":"+","schema":"","children":[{"class":"FUNCTION","type":"FUNCTION","alias":"","function_name":"+","schema":"","children":[{"class":"COLUMN_REF","type":"COLUMN_REF","alias":"","column_names":["a"]},{"class":"COLUMN_REF","type":"COLUMN_REF","alias":"","column_names":["b"]}],"filter":null,"order_bys":{"type":"ORDER_MODIFIER","orders":[]},"distinct":false,"is_operator":true,"export_state":false,"catalog":""},{"class":"COLUMN_REF","type":"COLUMN_REF","alias":"","column_names":["c"]}],"filter":null,"order_bys":{"type":"ORDER_MODIFIER","orders":[]},"distinct":false,"is_operator":true,"export_state":false,"catalog":""}],"from_table":{"type":"BASE_TABLE","alias":"","sample":null,"schema_name":"","table_name":"tbl2","column_name_alias":[],"catalog_name":""},"where_clause":null,"group_expressions":[],"group_sets":[],"aggregate_handling":"STANDARD_HANDLING","having":null,"sample":null,"qualify":null}}]}' +) +-- +ok +== +select json_serialize_sql($$select '10'::blob$$); +-- +ok +== +SELECT * FROM json_execute_serialized_sql(json_serialize_sql('SELECT * FROM tbl2', skip_null := true, skip_empty := true)); +-- +ok +== +SELECT * FROM json_execute_serialized_sql(json_serialize_sql('WITH a(i) as (SELECT 1) SELECT a1.i as i1, a2.i as i2 FROM a as a1, a as a2')); +-- +ok +== +SELECT json_deserialize_sql('{ "statements": [ {"expression_class": "BOUND_COMPARISON"}]}'); +-- +error: Parser Error: Error parsing json: no select node found in json +== +SELECT * FROM json_execute_serialized_sql('{ "statements": [ {"expression_class": "BOUND_COMPARISON"}]}'); +-- +error: Parser Error: Error parsing json: no select node found in json +== +CREATE TEMP TABLE json_deserialize_filter_pushdown(j JSON); +-- +ok +== +INSERT INTO json_deserialize_filter_pushdown VALUES + ('{"error":false,"statements":[]}'::JSON), + (json_serialize_sql('SELECT 1')); +-- +ok +== +SELECT count(*) +FROM json_deserialize_filter_pushdown +WHERE json_exists(j, '$.statements[0]') + AND json_deserialize_sql(j) IS NOT NULL; +-- +ok +== +SELECT json_deserialize_sql('{"statements":[{"node":{"type":"SET_OPERATION_NODE","cte_map":{},"setop_type":"UNION","children":[null,null],"setop_all":false}}]}'); +-- +ok +== +SELECT json_deserialize_sql(json_serialize_sql('SELECT 1;SELECT 2')); +-- +ok +== +CREATE TABLE ms("$id" INT, month VARCHAR, amount INT); +-- +ok +== +INSERT INTO ms VALUES (1, 'JAN', 10); +-- +ok +== +SELECT json_deserialize_sql(json_serialize_sql('SELECT * FROM ms PIVOT (SUM(amount) FOR month IN (''JAN'') GROUP BY "$id")')); +-- +ok +== +SELECT * FROM json_execute_serialized_sql(json_serialize_sql('SELECT * FROM ms PIVOT (SUM(amount) FOR month IN (''JAN'') GROUP BY "$id")')); +-- +ok +== +PRAGMA json_execute_serialized_sql(NULL); +-- +ok +== diff --git a/parser/testdata/corpus/sql/json/test_json_serialize_sql.test.metadata.json b/parser/testdata/corpus/sql/json/test_json_serialize_sql.test.metadata.json new file mode 100644 index 0000000..bd56e72 --- /dev/null +++ b/parser/testdata/corpus/sql/json/test_json_serialize_sql.test.metadata.json @@ -0,0 +1,10 @@ +{ + "todo": { + "0beceefbc70a3a8d": "transformer-raised parser error: upstream rejects in the transformer, not the grammar; expected to clear as transformers land (milestones 3-5)", + "ebbdaa4a4b55e8d2": "transformer-raised parser error: upstream rejects in the transformer, not the grammar; expected to clear as transformers land (milestones 3-5)" + }, + "skip": { + "7b368bad1df6ae67": "nested parse at bind time: the inner SQL string is parsed by a function, the grammar never sees it", + "c8a31233b8e3f7f6": "nested parse at bind time: the inner SQL string is parsed by a function, the grammar never sees it" + } +} diff --git a/parser/testdata/corpus/sql/json/test_json_sqlite.test b/parser/testdata/corpus/sql/json/test_json_sqlite.test new file mode 100644 index 0000000..900479d --- /dev/null +++ b/parser/testdata/corpus/sql/json/test_json_sqlite.test @@ -0,0 +1,93 @@ +# source: test/sql/json/test_json_sqlite.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +INSERT INTO j1(x) +VALUES('true'),('false'),('null'),('123'),('-234'),('34.5e+6'), + ('""'),('"\""'),('"\\"'),('"abcdefghijlmnopqrstuvwxyz"'), + ('[]'),('{}'),('[true,false,null,123,-234,34.5e+6,{},[]]'), + ('{"a":true,"b":{"c":false}}'); +-- +ok +== +SELECT count(*) FROM j1 WHERE json_type(x) IN ('OBJECT','ARRAY'); +-- +ok +== + SELECT x FROM j1 + WHERE json_extract(x,'$')<>x + AND json_type(x) IN ('OBJECT','ARRAY'); +-- +ok +== +CREATE TABLE j2(id INTEGER PRIMARY KEY, json VARCHAR, src VARCHAR); +-- +ok +== +INSERT INTO j2(id,json,src) + VALUES(1,'{ + "firstName": "John", + "lastName": "Smith", + "isAlive": true, + "age": 25, + "address": { + "streetAddress": "21 2nd Street", + "city": "New York", + "state": "NY", + "postalCode": "10021-3100" + }, + "phoneNumbers": [ + { + "type": "home", + "number": "212 555-1234" + }, + { + "type": "office", + "number": "646 555-4567" + } + ], + "children": [], + "spouse": null + }','https://en.wikipedia.org/wiki/JSON'); +-- +ok +== +INSERT INTO j2(id,json,src) + VALUES(2, '{ + "id": "0001", + "type": "donut", + "name": "Cake", + "ppu": 0.55, + "batters": + { + "batter": + [ + { "id": "1001", "type": "Regular" }, + { "id": "1002", "type": "Chocolate" }, + { "id": "1003", "type": "Blueberry" }, + { "id": "1004", "type": "Devil''s Food" } + ] + }, + "topping": + [ + { "id": "5001", "type": "None" }, + { "id": "5002", "type": "Glazed" }, + { "id": "5005", "type": "Sugar" }, + { "id": "5007", "type": "Powdered Sugar" }, + { "id": "5006", "type": "Chocolate with Sprinkles" }, + { "id": "5003", "type": "Chocolate" }, + { "id": "5004", "type": "Maple" } + ] + }','https://adobe.github.io/Spry/samples/data_region/JSONDataSetSample.html'); +-- +ok +== +SELECT count(*) FROM j2; +-- +ok +== +SELECT id, json_valid(json), json_type(json) FROM j2 ORDER BY id; +-- +ok +== diff --git a/parser/testdata/corpus/sql/keywords/escaped_quotes_expressions.test b/parser/testdata/corpus/sql/keywords/escaped_quotes_expressions.test new file mode 100644 index 0000000..3cad395 --- /dev/null +++ b/parser/testdata/corpus/sql/keywords/escaped_quotes_expressions.test @@ -0,0 +1,65 @@ +# source: test/sql/keywords/escaped_quotes_expressions.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +CREATE SCHEMA "SCH""EMA"; +-- +ok +== +CREATE TYPE "EN""UM" AS ENUM('ALL'); +-- +ok +== +CREATE TABLE "SCH""EMA"."TA""BLE"("COL""UMN" "EN""UM"); +-- +ok +== +INSERT INTO "SCH""EMA"."TA""BLE" VALUES ('ALL'); +-- +ok +== +SELECT "COL""UMN" FROM "SCH""EMA"."TA""BLE"; +-- +ok +== +SELECT "TA""BLE"."COL""UMN" FROM "SCH""EMA"."TA""BLE"; +-- +ok +== +SELECT "SCH""EMA"."TA""BLE"."COL""UMN" FROM "SCH""EMA"."TA""BLE"; +-- +ok +== +DROP TABLE "SCH""EMA"."TA""BLE"; +-- +ok +== +CREATE TABLE "SCH""EMA"."TA""BLE"("COL""UMN" ROW("SO""ME" ROW("I""N" INTEGER))); +-- +ok +== +INSERT INTO "SCH""EMA"."TA""BLE" VALUES ({'so"me': {'i"n': 3}}); +-- +ok +== +SELECT "COL""UMN"."SO""ME"."I""N" FROM "SCH""EMA"."TA""BLE"; +-- +ok +== +SELECT "TA""BLE"."COL""UMN"."SO""ME"."I""N" FROM "SCH""EMA"."TA""BLE"; +-- +ok +== +SELECT "SCH""EMA"."TA""BLE"."COL""UMN"."SO""ME"."I""N" FROM "SCH""EMA"."TA""BLE"; +-- +ok +== +SELECT (("SCH""EMA"."TA""BLE"."COL""UMN")."SO""ME")."I""N" FROM "SCH""EMA"."TA""BLE"; +-- +ok +== +SELECT "SCH""EMA"."TA""BLE"."COL""UMN"['SO"ME']['I"N'] FROM "SCH""EMA"."TA""BLE"; +-- +ok +== diff --git a/parser/testdata/corpus/sql/keywords/keywords_in_expressions.test b/parser/testdata/corpus/sql/keywords/keywords_in_expressions.test new file mode 100644 index 0000000..4d53f1a --- /dev/null +++ b/parser/testdata/corpus/sql/keywords/keywords_in_expressions.test @@ -0,0 +1,69 @@ +# source: test/sql/keywords/keywords_in_expressions.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +CREATE TYPE "ENUM" AS ENUM('ALL'); +-- +ok +== +CREATE TABLE "SCHEMA"."TABLE"("COLUMN" "ENUM"); +-- +ok +== +CREATE TYPE E AS ENUM('ALL'); +-- +ok +== +CREATE TABLE "SCHEMA"."TABLE"("COLUMN" E); +-- +ok +== +INSERT INTO "SCHEMA"."TABLE" VALUES ('ALL'); +-- +ok +== +SELECT "COLUMN" FROM "SCHEMA"."TABLE"; +-- +ok +== +SELECT "TABLE"."COLUMN" FROM "SCHEMA"."TABLE"; +-- +ok +== +SELECT "SCHEMA"."TABLE"."COLUMN" FROM "SCHEMA"."TABLE"; +-- +ok +== +DROP TABLE "SCHEMA"."TABLE"; +-- +ok +== +CREATE TABLE "SCHEMA"."TABLE"("COLUMN" ROW("SOME" ROW("IN" INTEGER))); +-- +ok +== +INSERT INTO "SCHEMA"."TABLE" VALUES ({'some': {'in': 3}}); +-- +ok +== +SELECT "COLUMN"."SOME"."IN" FROM "SCHEMA"."TABLE"; +-- +ok +== +SELECT "TABLE"."COLUMN"."SOME"."IN" FROM "SCHEMA"."TABLE"; +-- +ok +== +SELECT "SCHEMA"."TABLE"."COLUMN"."SOME"."IN" FROM "SCHEMA"."TABLE"; +-- +ok +== +SELECT (("SCHEMA"."TABLE"."COLUMN")."SOME")."IN" FROM "SCHEMA"."TABLE"; +-- +ok +== +SELECT "SCHEMA"."TABLE"."COLUMN"['SOME']['IN'] FROM "SCHEMA"."TABLE"; +-- +ok +== diff --git a/parser/testdata/corpus/sql/limit/streaming_limit_pipeline_flush.test b/parser/testdata/corpus/sql/limit/streaming_limit_pipeline_flush.test new file mode 100644 index 0000000..dceba13 --- /dev/null +++ b/parser/testdata/corpus/sql/limit/streaming_limit_pipeline_flush.test @@ -0,0 +1,18 @@ +# source: test/sql/limit/streaming_limit_pipeline_flush.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +SELECT o.o_orderkey +FROM ( + SELECT l.o_orderkey + FROM orders l + LEFT JOIN lineitem li ON li.l_orderkey = l.o_orderkey + WHERE l.o_orderkey = 1 + LIMIT 1 +) AS filtered +JOIN orders o ON TRUE +WHERE o.o_orderkey = 1; +-- +ok +== diff --git a/parser/testdata/corpus/sql/limit/test_batch_limit_filters.test b/parser/testdata/corpus/sql/limit/test_batch_limit_filters.test new file mode 100644 index 0000000..f80df78 --- /dev/null +++ b/parser/testdata/corpus/sql/limit/test_batch_limit_filters.test @@ -0,0 +1,17 @@ +# source: test/sql/limit/test_batch_limit_filters.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +CREATE TABLE tbl AS SELECT concat('thisisastring', i) s FROM range(1_000_000) t(i) +-- +ok +== +FROM tbl WHERE s LIKE '%string999999%' LIMIT 5 +-- +ok +== +EXPLAIN FROM tbl WHERE s LIKE '%string999999%' LIMIT 5 +-- +ok +== diff --git a/parser/testdata/corpus/sql/limit/test_limit0.test b/parser/testdata/corpus/sql/limit/test_limit0.test new file mode 100644 index 0000000..5ecdb78 --- /dev/null +++ b/parser/testdata/corpus/sql/limit/test_limit0.test @@ -0,0 +1,21 @@ +# source: test/sql/limit/test_limit0.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +SELECT * FROM (SELECT SUM(i) FROM range(100000000000) tbl(i)) LIMIT 0; +-- +ok +== +PRAGMA explain_output='OPTIMIZED_ONLY' +-- +ok +== +EXPLAIN SELECT * FROM (SELECT SUM(i) FROM range(100000000000) tbl(i)) LIMIT 0; +-- +ok +== +EXPLAIN SELECT * FROM (SELECT SUM(i) FROM range(100000000000) tbl(i)) WHERE 1=0; +-- +ok +== diff --git a/parser/testdata/corpus/sql/limit/test_preserve_insertion_order.test b/parser/testdata/corpus/sql/limit/test_preserve_insertion_order.test new file mode 100644 index 0000000..fe58b32 --- /dev/null +++ b/parser/testdata/corpus/sql/limit/test_preserve_insertion_order.test @@ -0,0 +1,37 @@ +# source: test/sql/limit/test_preserve_insertion_order.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +CREATE TABLE integers AS SELECT 1 AS i FROM range(1000000) t(i) +-- +ok +== +SELECT MIN(i), MAX(i), COUNT(*) FROM integers +-- +ok +== +SELECT * FROM integers LIMIT 5 +-- +ok +== +SELECT * FROM integers LIMIT 5 OFFSET 500000 +-- +ok +== +CREATE TABLE integers2 AS SELECT * FROM range(1000000) tbl(i) +-- +ok +== +SELECT MIN(i), MAX(i), COUNT(*) FROM integers2 +-- +ok +== +SELECT * FROM integers2 WHERE i IN (337, 195723, 442578, 994375) +-- +ok +== +SELECT * FROM integers2 WHERE i IN (337, 195723, 442578, 994375) LIMIT 4 +-- +ok +== diff --git a/parser/testdata/corpus/sql/logging/enable_logging_file_no_path.test b/parser/testdata/corpus/sql/logging/enable_logging_file_no_path.test new file mode 100644 index 0000000..96e58ca --- /dev/null +++ b/parser/testdata/corpus/sql/logging/enable_logging_file_no_path.test @@ -0,0 +1,45 @@ +# source: test/sql/logging/enable_logging_file_no_path.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +CALL enable_logging(storage='memory') +-- +ok +== +SELECT value FROM duckdb_settings() WHERE name = 'logging_storage'; +-- +ok +== +CALL enable_logging('QueryLog', storage=file); +-- +ok +== +CALL enable_logging('QueryLog', storage=file, storage_path='{TEST_DIR}/issue9144.csv') +-- +ok +== +CALL enable_logging() +-- +ok +== +CALL enable_logging(storage='file', storage_path=''); +-- +ok +== +CALL enable_logging(storage='file', storage_path=NULL); +-- +ok +== +CALL enable_logging(storage_config:={path:''}); +-- +ok +== +SET logging_storage='file'; +-- +ok +== +SET logging_storage='FILE'; +-- +ok +== diff --git a/parser/testdata/corpus/sql/logging/file_system_logging_attach.test b/parser/testdata/corpus/sql/logging/file_system_logging_attach.test new file mode 100644 index 0000000..79bdc36 --- /dev/null +++ b/parser/testdata/corpus/sql/logging/file_system_logging_attach.test @@ -0,0 +1,28 @@ +# source: test/sql/logging/file_system_logging_attach.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +SET enable_logging=true; +-- +ok +== +SET logging_level='trace'; +-- +ok +== +ATTACH '{TEST_DIR}/filehandle_logging.db' AS db; +-- +ok +== +CREATE TABLE db.test AS SELECT 1; +-- +ok +== +SELECT scope, type, log_level, regexp_replace(message, '\"path\":.*filehandle_logging.db"', '"path":"filehandle_logging.db"') AS msg +FROM duckdb_logs +WHERE type = 'FileSystem' AND contains(msg, '"path":"filehandle_logging.db"') +ORDER BY timestamp +-- +ok +== diff --git a/parser/testdata/corpus/sql/logging/file_system_logging_attach_deadlock.test b/parser/testdata/corpus/sql/logging/file_system_logging_attach_deadlock.test new file mode 100644 index 0000000..8f6d11f --- /dev/null +++ b/parser/testdata/corpus/sql/logging/file_system_logging_attach_deadlock.test @@ -0,0 +1,13 @@ +# source: test/sql/logging/file_system_logging_attach_deadlock.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +SET memory_limit='1000kb'; +-- +ok +== +SELECT * FROM duckdb_logs; +-- +ok +== diff --git a/parser/testdata/corpus/sql/logging/http_log_timing.test b/parser/testdata/corpus/sql/logging/http_log_timing.test new file mode 100644 index 0000000..2cd292e --- /dev/null +++ b/parser/testdata/corpus/sql/logging/http_log_timing.test @@ -0,0 +1,39 @@ +# source: test/sql/logging/http_log_timing.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +CALL enable_logging('HTTP') +-- +ok +== +SET http_retries=2 +-- +ok +== +FROM "http://localhost:2338/test.csv" +-- +ok +== +SELECT + request.type, + request.duration_ms >= 0, + request.duration_ms <= 1000 * 1000, + request.request_body_length +FROM + duckdb_logs_parsed('HTTP') +WHERE + request.type='HEAD' +-- +ok +== +SELECT DISTINCT + response.status, + response.reason IS NOT NULL +FROM + duckdb_logs_parsed('HTTP') +WHERE + request.type='HEAD' +-- +ok +== diff --git a/parser/testdata/corpus/sql/logging/logging.test b/parser/testdata/corpus/sql/logging/logging.test new file mode 100644 index 0000000..3883e4e --- /dev/null +++ b/parser/testdata/corpus/sql/logging/logging.test @@ -0,0 +1,53 @@ +# source: test/sql/logging/logging.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +FROM duckdb_logs +-- +ok +== +DESCRIBE FROM duckdb_logs +-- +ok +== +set logging_level='debug'; +-- +ok +== +set enable_logging=true; +-- +ok +== +SELECT 1; +-- +ok +== +SELECT * EXCLUDE (context_id, timestamp, connection_id, transaction_id, query_id) FROM duckdb_logs +-- +ok +== +set enable_logging=false; +-- +ok +== +SELECT * EXCLUDE (context_id, timestamp, connection_id, transaction_id, query_id) FROM duckdb_logs where type = 'QueryLog' +-- +ok +== +set logging_storage='stdout'; +-- +ok +== +set logging_storage='memory'; +-- +ok +== +set logging_storage='quack'; +-- +ok +== +SELECT * EXCLUDE (timestamp, connection_id, transaction_id, query_id) FROM duckdb_logs +-- +ok +== diff --git a/parser/testdata/corpus/sql/logging/logging_buffer_size.test b/parser/testdata/corpus/sql/logging/logging_buffer_size.test new file mode 100644 index 0000000..0a5c722 --- /dev/null +++ b/parser/testdata/corpus/sql/logging/logging_buffer_size.test @@ -0,0 +1,69 @@ +# source: test/sql/logging/logging_buffer_size.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +CALL enable_logging('QueryLog', storage_config={'buffer_size': 10, 'only_flush_on_full_buffer': true}); +-- +ok +== +SELECT 1 as a; +-- +ok +== +SELECT count(*) FROM duckdb_logs +-- +ok +== +CALL enable_logging('', level='trace', storage='memory', storage_config={'buffer_size': 3000, 'only_flush_on_full_buffer': true}); +-- +ok +== +SELECT write_log('hello from the connection log scope', level := 'error', scope := 'connection') from range(0,2999); +-- +ok +== +SELECT count(*) FROM duckdb_logs() +-- +ok +== +SELECT write_log('hello from the connection log scope', level := 'error', scope := 'connection'); +-- +ok +== +SELECT count(*) FROM duckdb_logs() where type='' +-- +ok +== +SELECT count(*) FROM duckdb_log_contexts() +-- +ok +== +CALL enable_logging(level='trace', storage='memory', storage_config={'buffer_size': 20*2048}); +-- +ok +== +SELECT write_log('hello from the connection log scope', level := 'error', scope := 'connection') from range(0,40*2048); +-- +ok +== +FROM duckdb_logs() +-- +ok +== +CALL enable_logging(level='trace', storage='file', storage_config={'buffer_size': 20*2048, 'path': '{TEST_DIR}/logging_buffer_size'}); +-- +ok +== +CALL enable_logging(level='trace', storage='file', storage_config={'buffer_size': 0, 'path': '{TEST_DIR}/logging_buffer_size'}); +-- +ok +== +SELECT write_log('hello from the connection log scope', level := 'error', scope := 'connection') from range(0, 2048); +-- +ok +== +CALL enable_logging(level='trace', storage='file', storage_config={'buffer_size': -1, 'path': '{TEST_DIR}/logging_buffer_size'}); +-- +ok +== diff --git a/parser/testdata/corpus/sql/logging/logging_call_functions.test b/parser/testdata/corpus/sql/logging/logging_call_functions.test new file mode 100644 index 0000000..f5c0644 --- /dev/null +++ b/parser/testdata/corpus/sql/logging/logging_call_functions.test @@ -0,0 +1,77 @@ +# source: test/sql/logging/logging_call_functions.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +CREATE VIEW log_settings AS select name, value from duckdb_settings() where name in ['logging_level', 'logging_mode', 'logging_storage', 'enable_logging', 'enabled_log_types', 'disabled_log_types'] ORDER BY name +-- +ok +== +CALL enable_logging(); +-- +ok +== +FROM log_settings; +-- +ok +== +CALL enable_logging(level='DEBUG'); +-- +ok +== +CALL enable_logging('QueryLog'); +-- +ok +== +CALL enable_logging(['QueryLog', 'filesystem']); +-- +ok +== +SELECT name, list_sort(split(value, ',')) FROM log_settings; +-- +ok +== +CALL enable_logging('FileSystem', storage='file', storage_config={'path': '{TEST_DIR}/logging_call_functions_test_log'}); +-- +ok +== +CALL enable_logging(storage='file', storage_path='{TEST_DIR}/logging_call_functions'); +-- +ok +== +CALL enable_logging(storage_path='{TEST_DIR}/logging_call_functions'); +-- +ok +== +CALL enable_logging(hocus_pocus='this is bogus'); +-- +ok +== +CALL enable_logging(storage='file', level='DEBUG', storage_config={'hocus_pocus': 'this is bogus', 'path': '{TEST_DIR}/hi.csv'}); +-- +ok +== +CALL enable_logging(storage='memory', storage_config={'path': 'bla'}); +-- +ok +== +CALL enable_logging(storage_config='hi') +-- +ok +== +RESET logging_storage +-- +ok +== +CALL enable_logging(storage='file', storage_path='{TEST_DIR}/preserve_storage.log') +-- +ok +== +CALL enable_logging(storage_config:={path:'{TEST_DIR}/auto_promote.csv'}) +-- +ok +== +CALL enable_logging(storage_config:={aaaargh:'blaargh'}) +-- +ok +== diff --git a/parser/testdata/corpus/sql/logging/logging_context_ids.test b/parser/testdata/corpus/sql/logging/logging_context_ids.test new file mode 100644 index 0000000..8fbe10d --- /dev/null +++ b/parser/testdata/corpus/sql/logging/logging_context_ids.test @@ -0,0 +1,53 @@ +# source: test/sql/logging/logging_context_ids.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + + CALL enable_logging(); +-- +ok +== +set variable base_transaction_id = current_transaction_id() + 2 +-- +ok +== +set variable base_query_id = current_query_id() + 1 +-- +ok +== +SELECT write_log('hey1', log_type := 'test_logging_autocommit') +-- +ok +== +SELECT write_log('hey2', log_type := 'test_logging_autocommit') +-- +ok +== +SELECT + transaction_id - getvariable('base_transaction_id') as relative_transaction_id, + query_id - getvariable('base_query_id') as relative_query_id, +FROM duckdb_logs +WHERE + connection_id=current_connection_id() and + type='test_logging_autocommit'; +-- +ok +== +SELECT write_log('hey1', log_type := 'test_logging_transaction') +-- +ok +== +SELECT write_log('hey2', log_type := 'test_logging_transaction') +-- +ok +== +SELECT + transaction_id - getvariable('base_transaction_id') as relative_transaction_id, + query_id - getvariable('base_query_id') as query_id, +FROM duckdb_logs +WHERE + connection_id=current_connection_id() and + type='test_logging_transaction'; +-- +ok +== diff --git a/parser/testdata/corpus/sql/logging/logging_csv.test b/parser/testdata/corpus/sql/logging/logging_csv.test new file mode 100644 index 0000000..c69c3ff --- /dev/null +++ b/parser/testdata/corpus/sql/logging/logging_csv.test @@ -0,0 +1,100 @@ +# source: test/sql/logging/logging_csv.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +CALL enable_logging(['FileSystem'], storage='file', storage_config={'path': '{TEMP_DIR}/logging_csv_log.csv', 'normalize': false}); +-- +ok +== +FROM "{DATA_DIR}/csv/big_number.csv" +-- +ok +== +DESCRIBE FROM '{TEMP_DIR}/logging_csv_log.csv'; +-- +ok +== +SELECT + scope, + path: parse_duckdb_log_message('FileSystem', message)['path'], + op: parse_duckdb_log_message('FileSystem', message)['op'], +FROM "{TEMP_DIR}/logging_csv_log.csv" +WHERE path = '{DATA_DIR}/csv/big_number.csv'; +-- +ok +== +select count(*) FROM "{TEMP_DIR}/logging_csv_log.csv"; +-- +ok +== +CALL enable_logging(['FileSystem'], storage='file', storage_config={'path': '{TEMP_DIR}/logging_csv_logs_normalized', 'normalize': true}); +-- +ok +== +SELECT + context_id is not null, + path: parse_duckdb_log_message('FileSystem', message)['path'], + op: parse_duckdb_log_message('FileSystem', message)['op'], +FROM "{TEMP_DIR}/logging_csv_logs_normalized/duckdb_log_entries.csv" +WHERE path = '{DATA_DIR}/csv/big_number.csv'; +-- +ok +== +SELECT scope +FROM "{TEMP_DIR}/logging_csv_logs_normalized/duckdb_log_contexts.csv"; +-- +ok +== +DESCRIBE FROM '{TEMP_DIR}/logging_csv_logs_normalized/duckdb_log_entries.csv'; +-- +ok +== +DESCRIBE FROM '{TEMP_DIR}/logging_csv_logs_normalized/duckdb_log_contexts.csv'; +-- +ok +== +select count(*) FROM "{TEMP_DIR}/logging_csv_logs_normalized/duckdb_log_contexts.csv"; +-- +ok +== +select count(*) FROM "{TEMP_DIR}/logging_csv_logs_normalized/duckdb_log_entries.csv"; +-- +ok +== +CALL enable_logging(['FileSystem'], storage='stdout'); +-- +ok +== +CALL enable_logging(['FileSystem'], storage='stdout', storage_config={'buffer_size': 1000000}); +-- +ok +== +CALL enable_logging(['FileSystem'], storage='stdout', storage_config={'bla': 'bla'}); +-- +ok +== +CALL enable_logging(['FileSystem'], storage='stdout', storage_config={'path': './file.csv'}); +-- +ok +== +CALL enable_logging(['QueryLog'], storage='file', storage_config={'path': '{TEMP_DIR}/logging_csv_log.csv'}); +-- +ok +== +explain FROM duckdb_logs +-- +ok +== +CALL enable_logging(['QueryLog'], storage='file', storage_config={'path': '{TEMP_DIR}/logging_csv_log.csv', 'normalize': true}); +-- +ok +== +CALL enable_logging(['QueryLog'], storage='file', storage_config={'path': '{TEMP_DIR}/logging_csv_log_delim.csv', 'delim': ';'}); +-- +ok +== +SELECT message FROM read_csv('{TEMP_DIR}/logging_csv_log_delim.csv', delim=';'); +-- +ok +== diff --git a/parser/testdata/corpus/sql/logging/logging_file_bind_replace.test b/parser/testdata/corpus/sql/logging/logging_file_bind_replace.test new file mode 100644 index 0000000..793af3f --- /dev/null +++ b/parser/testdata/corpus/sql/logging/logging_file_bind_replace.test @@ -0,0 +1,53 @@ +# source: test/sql/logging/logging_file_bind_replace.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +CALL enable_logging(['QueryLog'], storage_path='{TEST_DIR}/logging_file_bind_replace_log.csv'); +-- +ok +== +SELECT 1 as a +-- +ok +== +FROM duckdb_logs_parsed('FileSystem'); +-- +ok +== +DESCRIBE FROM duckdb_logs; +-- +ok +== +SELECT message FROM duckdb_logs_parsed('QueryLog') WHERE starts_with(message, 'SELECT 1'); +-- +ok +== +SELECT message FROM duckdb_logs_parsed('querylog') WHERE starts_with(message, 'SELECT 1'); +-- +ok +== +CALL enable_logging(['QueryLog'], storage='file', storage_config={'path': '{TEST_DIR}/logging_file_bind_replace_normalized/', 'normalize': true}); +-- +ok +== +SELECT 1 as b +-- +ok +== +CALL enable_logging(['QueryLog'], storage='memory'); +-- +ok +== +SELECT 1 as c +-- +ok +== +CALL enable_logging(level='trace', storage='memory'); +-- +ok +== +SELECT 1 as d +-- +ok +== diff --git a/parser/testdata/corpus/sql/logging/logging_file_persistence.test b/parser/testdata/corpus/sql/logging/logging_file_persistence.test new file mode 100644 index 0000000..f764108 --- /dev/null +++ b/parser/testdata/corpus/sql/logging/logging_file_persistence.test @@ -0,0 +1,13 @@ +# source: test/sql/logging/logging_file_persistence.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +CALL enable_logging('FileSystem', storage='file', storage_config={'path': '{TEMP_DIR}/logging_file_persistence.csv'}); +-- +ok +== +FROM duckdb_logs; +-- +ok +== diff --git a/parser/testdata/corpus/sql/logging/logging_file_truncate_rewrite.test b/parser/testdata/corpus/sql/logging/logging_file_truncate_rewrite.test new file mode 100644 index 0000000..d959331 --- /dev/null +++ b/parser/testdata/corpus/sql/logging/logging_file_truncate_rewrite.test @@ -0,0 +1,17 @@ +# source: test/sql/logging/logging_file_truncate_rewrite.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +CALL enable_logging(['FileSystem'], storage='file', storage_config={'path': '{TEMP_DIR}/logging_truncate_rewrite.csv', 'normalize': false}); +-- +ok +== +SELECT COUNT(*) FROM "{TEMP_DIR}/logging_truncate_rewrite.csv"; +-- +ok +== +DESCRIBE FROM '{TEMP_DIR}/logging_truncate_rewrite.csv'; +-- +ok +== diff --git a/parser/testdata/corpus/sql/logging/logging_memory_after_truncate.test b/parser/testdata/corpus/sql/logging/logging_memory_after_truncate.test new file mode 100644 index 0000000..dc1df6e --- /dev/null +++ b/parser/testdata/corpus/sql/logging/logging_memory_after_truncate.test @@ -0,0 +1,25 @@ +# source: test/sql/logging/logging_memory_after_truncate.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +SET GLOBAL logging_level = 'INFO'; +-- +ok +== +SET GLOBAL logging_storage = 'memory'; +-- +ok +== +SET GLOBAL enable_logging = true; +-- +ok +== +LOAD invalid_extension; +-- +ok +== +SELECT COUNT(*) FROM duckdb_logs WHERE starts_with(message, 'Failed to load'); +-- +ok +== diff --git a/parser/testdata/corpus/sql/logging/logging_types.test b/parser/testdata/corpus/sql/logging/logging_types.test new file mode 100644 index 0000000..788684b --- /dev/null +++ b/parser/testdata/corpus/sql/logging/logging_types.test @@ -0,0 +1,33 @@ +# source: test/sql/logging/logging_types.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +CALL enable_logging('FileSystem'); +-- +ok +== +copy (select 1 as a) to '{TEST_DIR}/par.csv' +-- +ok +== +FROM '{TEST_DIR}/par.csv' +-- +ok +== +SELECT type, log_level, scope, fs, parse_filename(path), op, bytes, pos FROM duckdb_logs_parsed('FileSystem') ORDER BY timestamp +-- +ok +== +SELECT 'hallo' as value; +-- +ok +== +SELECT type, log_level, scope, message FROM duckdb_logs_parsed('QueryLog') ORDER BY timestamp +-- +ok +== +SELECT type, log_level, scope, message FROM duckdb_logs WHERE type='QueryLog'; +-- +ok +== diff --git a/parser/testdata/corpus/sql/logging/test_logging_function.test b/parser/testdata/corpus/sql/logging/test_logging_function.test new file mode 100644 index 0000000..9b836f7 --- /dev/null +++ b/parser/testdata/corpus/sql/logging/test_logging_function.test @@ -0,0 +1,46 @@ +# source: test/sql/logging/test_logging_function.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +from duckdb_logs +-- +ok +== +PRAGMA enable_logging; +-- +ok +== +set logging_level='info'; +-- +ok +== +set variable base_connection_id = current_connection_id() +-- +ok +== +SELECT write_log('hello from the global log scope', level := 'info', scope := 'database', log_type := 'global_type' ) from range(0,3); +-- +ok +== +SELECT write_log('hello from the connection log scope', level := 'info', scope := 'connection', log_type := 'client_context_type' ) from range(0,3); +-- +ok +== +SELECT write_log('hello from the file_opener log scope', level := 'info', scope := 'file_opener', log_type := 'opener_type' ) from range(0,3); +-- +ok +== +SELECT * EXCLUDE (context_id, timestamp, connection_id, transaction_id, query_id, thread_id) FROM duckdb_logs where starts_with(message, 'hello from the') order by query_id +-- +ok +== +SELECT + type, + connection_id - getvariable('base_connection_id'), + transaction_id - getvariable('base_transaction_id'), + query_id - getvariable('base_query_id') +FROM duckdb_logs where starts_with(message, 'hello from the') order by query_id +-- +ok +== diff --git a/parser/testdata/corpus/sql/merge/merge_into.test b/parser/testdata/corpus/sql/merge/merge_into.test new file mode 100644 index 0000000..89b5ca0 --- /dev/null +++ b/parser/testdata/corpus/sql/merge/merge_into.test @@ -0,0 +1,116 @@ +# source: test/sql/merge/merge_into.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +CREATE TABLE Stock(item_id int, balance int); +-- +ok +== +CREATE TABLE Buy(item_id int, volume int); +-- +ok +== +INSERT INTO Buy values(10, 1000); +-- +ok +== +INSERT INTO Buy values(30, 300); +-- +ok +== +WITH initial_stocks(item_id, balance) AS (VALUES (10, 2200), (20, 1900)) +MERGE INTO Stock USING initial_stocks ON FALSE +WHEN MATCHED THEN DO NOTHING +WHEN NOT MATCHED THEN INSERT VALUES (initial_stocks.item_id, initial_stocks.balance) +-- +ok +== +WITH initial_stocks(item_id, balance) AS (VALUES (10, 2200), (20, 1900)) +MERGE INTO Stock USING initial_stocks USING (item_id) +WHEN NOT MATCHED THEN INSERT VALUES (item_id, initial_stocks.balance) +-- +ok +== +FROM Stock ORDER BY item_id +-- +ok +== +MERGE INTO Stock AS s USING Buy AS b ON s.item_id = b.item_id +WHEN MATCHED THEN UPDATE SET balance = balance + b.volume +WHEN NOT MATCHED THEN INSERT VALUES (b.item_id, b.volume) +-- +ok +== +CREATE TABLE merge_distinct_target(tableticker VARCHAR NOT NULL, figi VARCHAR, cik VARCHAR, lastupdated DATE NOT NULL); +-- +ok +== +INSERT INTO merge_distinct_target VALUES ('tablepermaticker', 'old_figi', 'old_cik', DATE '2026-04-30'); +-- +ok +== +MERGE INTO merge_distinct_target AS t +USING ( + SELECT 'tablepermaticker' AS tableticker, 'new_figi' AS figi, 'new_cik' AS cik, DATE '2026-05-01' AS lastupdated + ORDER BY tableticker +) AS q +ON t.tableticker = q.tableticker +WHEN MATCHED AND t IS DISTINCT FROM q THEN UPDATE +WHEN NOT MATCHED THEN INSERT +-- +ok +== +FROM merge_distinct_target ORDER BY tableticker +-- +ok +== +CREATE TABLE Sale(item_id int, volume int); +-- +ok +== +INSERT INTO Sale VALUES (10, 2200); +-- +ok +== +INSERT INTO Sale VALUES (20, 1900); +-- +ok +== +MERGE INTO Stock USING Sale ON Stock.item_id = Sale.item_id +WHEN MATCHED AND Sale.volume > balance THEN ERROR +WHEN MATCHED AND Sale.volume = balance THEN DELETE +WHEN MATCHED AND TRUE THEN UPDATE SET balance = balance - Sale.volume +WHEN MATCHED THEN ERROR +WHEN NOT MATCHED THEN ERROR +-- +ok +== +MERGE INTO Stock USING Sale ON Stock.item_id = Sale.item_id +WHEN MATCHED AND Sale.volume >= balance THEN DELETE +WHEN MATCHED THEN UPDATE SET balance = balance - Sale.volume +WHEN NOT MATCHED THEN ERROR CONCAT('Sale item with item id ', Sale.item_id, ' not found'); +-- +ok +== +WITH initial_stocks(item_id, balance) AS (VALUES (10, 2200), (20, 1900)) +MERGE INTO Stock USING initial_stocks ON (Stock.item_id = initial_stocks.item_id) +-- +error: Parser Error: syntax error at or near ")" +== +WITH initial_stocks(item_id, balance) AS (VALUES (10, 2200), (20, 1900)) +MERGE INTO Stock USING initial_stocks ON (Stock.item_id = initial_stocks.item_id) +WHEN NOT MATCHED THEN INSERT VALUES (initial_stocks.item_id, initial_stocks.balance) +WHEN NOT MATCHED THEN ERROR; +-- +error: Parser Error: Unconditional WHEN NOT MATCHED clause was already defined - any following WHEN NOT MATCHED clause would be unreachable +== +CREATE VIEW my_view AS SELECT 42 item_id +-- +ok +== +MERGE INTO my_view USING Sale ON my_view.item_id = Sale.item_id +WHEN NOT MATCHED THEN INSERT +-- +ok +== diff --git a/parser/testdata/corpus/sql/merge/merge_into.test.metadata.json b/parser/testdata/corpus/sql/merge/merge_into.test.metadata.json new file mode 100644 index 0000000..bc45ada --- /dev/null +++ b/parser/testdata/corpus/sql/merge/merge_into.test.metadata.json @@ -0,0 +1,5 @@ +{ + "todo": { + "453f7c76e1e881bf": "transformer-raised parser error: upstream rejects in the transformer, not the grammar; expected to clear as transformers land (milestones 3-5)" + } +} diff --git a/parser/testdata/corpus/sql/merge/merge_into_bind_matching_columns.test b/parser/testdata/corpus/sql/merge/merge_into_bind_matching_columns.test new file mode 100644 index 0000000..e13654e --- /dev/null +++ b/parser/testdata/corpus/sql/merge/merge_into_bind_matching_columns.test @@ -0,0 +1,65 @@ +# source: test/sql/merge/merge_into_bind_matching_columns.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +CREATE TABLE dest (id INTEGER, val INTEGER); +-- +ok +== +CREATE TABLE src (id INTEGER, val INTEGER); +-- +ok +== +INSERT INTO dest VALUES (1, 10); +-- +ok +== +INSERT INTO src VALUES (1, 100), (2, 200); +-- +ok +== +MERGE INTO dest AS DBT_INTERNAL_DEST +USING src AS DBT_INTERNAL_SOURCE + ON DBT_INTERNAL_SOURCE.id = DBT_INTERNAL_DEST.id +WHEN MATCHED THEN UPDATE SET + "id" = DBT_INTERNAL_SOURCE."id", + "val" = DBT_INTERNAL_SOURCE."val" +WHEN NOT MATCHED THEN INSERT + ("id", "val") +VALUES + ("id", "val"); +-- +ok +== +SELECT * FROM dest order by all +-- +ok +== +DELETE FROM dest; +-- +ok +== +DELETE FROM src; +-- +ok +== +INSERT INTO dest VALUES (1, 10), (2, 20); +-- +ok +== +INSERT INTO src VALUES (1, 100); +-- +ok +== +MERGE INTO dest AS DBT_INTERNAL_DEST +USING src AS DBT_INTERNAL_SOURCE + ON DBT_INTERNAL_SOURCE.id = DBT_INTERNAL_DEST.id +WHEN MATCHED THEN UPDATE SET + "id" = DBT_INTERNAL_SOURCE."id", + "val" = DBT_INTERNAL_SOURCE."val" +WHEN NOT MATCHED BY SOURCE THEN + UPDATE SET val=val+1; +-- +ok +== diff --git a/parser/testdata/corpus/sql/merge/merge_into_by_source.test b/parser/testdata/corpus/sql/merge/merge_into_by_source.test new file mode 100644 index 0000000..7c056a2 --- /dev/null +++ b/parser/testdata/corpus/sql/merge/merge_into_by_source.test @@ -0,0 +1,25 @@ +# source: test/sql/merge/merge_into_by_source.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +INSERT INTO Stock VALUES (5, 10), (10, 20), (20, 30); +-- +ok +== +MERGE INTO Stock USING (VALUES (5, 20), (10, 30)) new_accounts(item_id, balance) USING (item_id) +WHEN MATCHED THEN UPDATE +WHEN NOT MATCHED BY TARGET THEN INSERT +WHEN NOT MATCHED BY SOURCE THEN DELETE +-- +ok +== +FROM Stock ORDER BY ALL +-- +ok +== +MERGE INTO Stock USING (VALUES (10)) new_accounts(item_id) USING (item_id) +WHEN NOT MATCHED BY SOURCE THEN DELETE +-- +ok +== diff --git a/parser/testdata/corpus/sql/merge/merge_into_constraint.test b/parser/testdata/corpus/sql/merge/merge_into_constraint.test new file mode 100644 index 0000000..7e4a4dd --- /dev/null +++ b/parser/testdata/corpus/sql/merge/merge_into_constraint.test @@ -0,0 +1,46 @@ +# source: test/sql/merge/merge_into_constraint.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +CREATE TABLE Stock(item_id int NOT NULL, balance int, CHECK (balance>0)); +-- +ok +== +MERGE INTO Stock USING (VALUES (NULL, NULL)) new_accounts(item_id, balance) USING (item_id) +WHEN NOT MATCHED THEN INSERT VALUES (new_accounts.item_id, new_accounts.balance) +-- +ok +== +MERGE INTO Stock USING (VALUES (1, 10)) new_accounts(item_id, balance) USING (item_id) +WHEN NOT MATCHED THEN INSERT VALUES (new_accounts.item_id, new_accounts.balance) +-- +ok +== +MERGE INTO Stock USING (VALUES (1, 15)) sales(item_id, volume) USING (item_id) +WHEN MATCHED THEN UPDATE SET balance = balance - volume +-- +ok +== +CREATE TABLE Items(item_id int NOT NULL, total_cost INTEGER, base_cost INTEGER, tax_cost INTEGER, CHECK (total_cost = base_cost + tax_cost)); +-- +ok +== +INSERT INTO Items VALUES (1, 10, 8, 2); +-- +ok +== +MERGE INTO Items USING (VALUES (1, 15)) new_prices(item_id, total_cost) USING (item_id) +WHEN MATCHED THEN UPDATE SET total_cost = new_prices.total_cost +-- +ok +== +MERGE INTO Items USING (VALUES (1, 15)) new_prices(item_id, total_cost) USING (item_id) +WHEN MATCHED THEN UPDATE SET total_cost = new_prices.total_cost, base_cost = new_prices.total_cost - 2 +-- +ok +== +FROM Items +-- +ok +== diff --git a/parser/testdata/corpus/sql/merge/merge_into_default.test b/parser/testdata/corpus/sql/merge/merge_into_default.test new file mode 100644 index 0000000..46382c2 --- /dev/null +++ b/parser/testdata/corpus/sql/merge/merge_into_default.test @@ -0,0 +1,38 @@ +# source: test/sql/merge/merge_into_default.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +CREATE TABLE Stock(item_id int, balance int DEFAULT 0); +-- +ok +== +MERGE INTO Stock USING (VALUES (10)) new_accounts(item_id) USING (item_id) +WHEN NOT MATCHED THEN INSERT VALUES (new_accounts.item_id, DEFAULT) +-- +ok +== +MERGE INTO Stock USING (VALUES (20)) new_accounts(item_id) USING (item_id) +WHEN NOT MATCHED THEN INSERT (item_id) VALUES (new_accounts.item_id) +-- +ok +== +MERGE INTO Stock USING (VALUES (30)) new_accounts(item_id) USING (item_id) +WHEN NOT MATCHED THEN INSERT DEFAULT VALUES +-- +ok +== +FROM Stock order by all +-- +ok +== +UPDATE Stock SET balance=100 +-- +ok +== +MERGE INTO Stock USING (VALUES (10)) reset_accounts(item_id) USING (item_id) +WHEN MATCHED THEN UPDATE SET balance=DEFAULT +WHEN NOT MATCHED THEN ERROR +-- +ok +== diff --git a/parser/testdata/corpus/sql/merge/merge_into_error.test b/parser/testdata/corpus/sql/merge/merge_into_error.test new file mode 100644 index 0000000..ec877f4 --- /dev/null +++ b/parser/testdata/corpus/sql/merge/merge_into_error.test @@ -0,0 +1,28 @@ +# source: test/sql/merge/merge_into_error.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +CREATE TABLE Buys(item_id int, volume int); +-- +ok +== +INSERT INTO Buys VALUES (42, 100); +-- +ok +== +MERGE INTO Stock USING Buys USING (item_id) +WHEN NOT MATCHED AND true THEN INSERT +WHEN NOT MATCHED AND error('this should not be executed') THEN INSERT +WHEN NOT MATCHED THEN ERROR +-- +ok +== +SELECT COUNT(*) FROM Stock +-- +ok +== +FROM Stock +-- +ok +== diff --git a/parser/testdata/corpus/sql/merge/merge_into_index.test b/parser/testdata/corpus/sql/merge/merge_into_index.test new file mode 100644 index 0000000..70629af --- /dev/null +++ b/parser/testdata/corpus/sql/merge/merge_into_index.test @@ -0,0 +1,25 @@ +# source: test/sql/merge/merge_into_index.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +CREATE TABLE Accounts(id INTEGER, username VARCHAR PRIMARY KEY, favorite_numbers INT[]); +-- +ok +== +INSERT INTO Accounts VALUES (1, 'user1', NULL) +-- +ok +== +MERGE INTO Accounts USING ( + VALUES (1, 'user2', [1, 2, 3]) +) new_account(id) USING (id) +WHEN MATCHED THEN UPDATE +WHEN NOT MATCHED THEN INSERT +-- +ok +== +FROM Accounts WHERE username='user2' +-- +ok +== diff --git a/parser/testdata/corpus/sql/merge/merge_into_insert_star.test b/parser/testdata/corpus/sql/merge/merge_into_insert_star.test new file mode 100644 index 0000000..2bb0028 --- /dev/null +++ b/parser/testdata/corpus/sql/merge/merge_into_insert_star.test @@ -0,0 +1,30 @@ +# source: test/sql/merge/merge_into_insert_star.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +MERGE INTO Stock USING (VALUES (5, 10)) new_accounts(item_id, balance) USING (item_id) +WHEN NOT MATCHED THEN INSERT * +-- +ok +== +MERGE INTO Stock USING (VALUES (6, 12)) new_accounts(item_id, balance) USING (item_id) +WHEN NOT MATCHED THEN INSERT +-- +ok +== +MERGE INTO Stock USING (VALUES (0, 7)) new_accounts(balance, item_id) USING (item_id) +WHEN NOT MATCHED THEN INSERT BY NAME +-- +ok +== +MERGE INTO Stock USING (VALUES (0, 7)) new_accounts(balanc, item_id) USING (item_id) +WHEN NOT MATCHED THEN INSERT BY NAME +-- +ok +== +MERGE INTO Stock USING (VALUES (12)) new_accounts(item_id) USING (item_id) +WHEN NOT MATCHED THEN INSERT BY NAME +-- +ok +== diff --git a/parser/testdata/corpus/sql/merge/merge_into_invalid_action.test b/parser/testdata/corpus/sql/merge/merge_into_invalid_action.test new file mode 100644 index 0000000..33a0165 --- /dev/null +++ b/parser/testdata/corpus/sql/merge/merge_into_invalid_action.test @@ -0,0 +1,23 @@ +# source: test/sql/merge/merge_into_invalid_action.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +CREATE TABLE t AS SELECT range a FROM generate_series(0,9) t(range); +-- +ok +== +MERGE INTO t + USING (SELECT range a from generate_series (10,19) t(range)) AS s + USING(a) + WHEN NOT MATCHED BY TARGET THEN DELETE RETURNING merge_action, *; +-- +ok +== +MERGE INTO t + USING (SELECT range a from generate_series (10,19) t(range)) AS s + USING(a) + WHEN NOT MATCHED BY TARGET THEN UPDATE RETURNING merge_action, *; +-- +ok +== diff --git a/parser/testdata/corpus/sql/merge/merge_into_invalid_column.test b/parser/testdata/corpus/sql/merge/merge_into_invalid_column.test new file mode 100644 index 0000000..9527172 --- /dev/null +++ b/parser/testdata/corpus/sql/merge/merge_into_invalid_column.test @@ -0,0 +1,13 @@ +# source: test/sql/merge/merge_into_invalid_column.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +CREATE TABLE v0 (v1 INTEGER PRIMARY KEY); +-- +ok +== +INSERT INTO v0(x) VALUES (2) ON CONFLICT DO NOTHING; +-- +ok +== diff --git a/parser/testdata/corpus/sql/merge/merge_into_invalid_column_reference.test b/parser/testdata/corpus/sql/merge/merge_into_invalid_column_reference.test new file mode 100644 index 0000000..7b22c16 --- /dev/null +++ b/parser/testdata/corpus/sql/merge/merge_into_invalid_column_reference.test @@ -0,0 +1,121 @@ +# source: test/sql/merge/merge_into_invalid_column_reference.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +CREATE TABLE target(id INT PRIMARY KEY, val INT); +-- +ok +== +INSERT INTO target VALUES (1, 10); +-- +ok +== +MERGE INTO target AS t +USING (VALUES (2, 99)) AS s(id, val) +ON t.id = s.id +WHEN NOT MATCHED BY TARGET THEN INSERT VALUES (s.id, t.val); +-- +ok +== +CREATE TABLE target2(id INT PRIMARY KEY, val INT); +-- +ok +== +INSERT INTO target2 VALUES (1, 10), (2, 20); +-- +ok +== +MERGE INTO target2 AS t +USING (VALUES (1, 99)) AS s(id, val) +ON t.id = s.id +WHEN MATCHED THEN DO NOTHING +WHEN NOT MATCHED BY SOURCE THEN UPDATE SET val = s.val; +-- +ok +== +CREATE TABLE target3(id INT PRIMARY KEY, val INT); +-- +ok +== +INSERT INTO target3 VALUES (1, 10), (2, 20), (3, 30); +-- +ok +== +MERGE INTO target3 AS t +USING (VALUES (1, 99)) AS s(id, val) +ON t.id = s.id +WHEN MATCHED THEN DO NOTHING +WHEN NOT MATCHED BY SOURCE AND s.val > 50 THEN DELETE; +-- +ok +== +CREATE TABLE target4(id INT PRIMARY KEY, val INT); +-- +ok +== +INSERT INTO target4 VALUES (1, 10); +-- +ok +== +MERGE INTO target4 AS t +USING (VALUES (2, 99), (3, 50)) AS s(id, val) +ON t.id = s.id +WHEN NOT MATCHED BY TARGET AND t.val > 5 THEN INSERT VALUES (s.id, s.val); +-- +ok +== +CREATE TABLE target5(id INT PRIMARY KEY, val INT); +-- +ok +== +MERGE INTO target5 AS t +USING (VALUES (1, 100)) AS s(id, val) +ON t.id = s.id +WHEN NOT MATCHED BY TARGET THEN INSERT VALUES (s.id, s.val); +-- +ok +== +SELECT * FROM target5; +-- +ok +== +CREATE TABLE target6(id INT PRIMARY KEY, val INT); +-- +ok +== +INSERT INTO target6 VALUES (1, 10), (2, 20); +-- +ok +== +MERGE INTO target6 AS t +USING (VALUES (1, 99)) AS s(id, val) +ON t.id = s.id +WHEN MATCHED THEN DO NOTHING +WHEN NOT MATCHED BY SOURCE THEN UPDATE SET val = t.val + 1; +-- +ok +== +SELECT * FROM target6 ORDER BY id; +-- +ok +== +CREATE TABLE target7(id INT PRIMARY KEY, val INT); +-- +ok +== +INSERT INTO target7 VALUES (1, 10); +-- +ok +== +MERGE INTO target7 AS t +USING (VALUES (1, 99)) AS s(id, val) +ON t.id = s.id +WHEN MATCHED THEN UPDATE SET val = t.val + s.val; +-- +ok +== +SELECT * FROM target7; +-- +ok +== diff --git a/parser/testdata/corpus/sql/merge/merge_into_join_as_filter.test b/parser/testdata/corpus/sql/merge/merge_into_join_as_filter.test new file mode 100644 index 0000000..01dc8d5 --- /dev/null +++ b/parser/testdata/corpus/sql/merge/merge_into_join_as_filter.test @@ -0,0 +1,37 @@ +# source: test/sql/merge/merge_into_join_as_filter.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +create table foo (bar integer); +-- +ok +== +insert into foo values (1); +-- +ok +== +merge into foo as f using (select 2 as bar) b on f.bar is not null when matched then update when not matched then insert; +-- +ok +== +FROM foo +-- +ok +== +create or replace table aaa (id int, status varchar, flag int, starttime datetime, endtime datetime); +-- +ok +== +merge into aaa + using ( + select 1 as id, 'xx' as status, 1 as flag, now() as starttime, null as endtime + ) as upserts + on (upserts.id = aaa.id and aaa.flag =1::int and aaa.status = upserts.status) + when matched then + update set endtime = upserts.starttime + when not matched then + insert by name; +-- +ok +== diff --git a/parser/testdata/corpus/sql/merge/merge_into_multiple_updates.test b/parser/testdata/corpus/sql/merge/merge_into_multiple_updates.test new file mode 100644 index 0000000..734159d --- /dev/null +++ b/parser/testdata/corpus/sql/merge/merge_into_multiple_updates.test @@ -0,0 +1,42 @@ +# source: test/sql/merge/merge_into_multiple_updates.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +CREATE TABLE Entry(type varchar, number int, text varchar, country VARCHAR, date DATE); +-- +ok +== +INSERT INTO Entry VALUES + ('number', 50, NULL, NULL, NULL), + ('text', NULL, 'Hello', NULL, NULL), + ('country', NULL, NULL, 'Netherlands', NULL), + ('date', NULL, NULL, NULL, DATE '2000-01-01'); +-- +ok +== +CREATE TABLE NewEntry(type varchar, number int, text varchar, country VARCHAR, date DATE); +-- +ok +== +INSERT INTO NewEntry VALUES + ('number', 100, NULL, NULL, NULL), + ('text', NULL, 'World', NULL, NULL), + ('country', NULL, NULL, 'Germany', NULL), + ('date', NULL, NULL, NULL, DATE '2010-01-01'); +-- +ok +== +MERGE INTO Entry USING NewEntry ON Entry.type=NewEntry.type +WHEN MATCHED AND Entry.type='number' THEN UPDATE SET number=NewEntry.number +WHEN MATCHED AND Entry.type='text' THEN UPDATE SET text=NewEntry.text +WHEN MATCHED AND Entry.type='country' THEN UPDATE SET country=NewEntry.country +WHEN MATCHED AND Entry.type='date' THEN UPDATE SET date=NewEntry.date +WHEN MATCHED THEN ERROR +-- +ok +== +FROM Entry ORDER BY type +-- +ok +== diff --git a/parser/testdata/corpus/sql/merge/merge_into_parenthesis_bug.test b/parser/testdata/corpus/sql/merge/merge_into_parenthesis_bug.test new file mode 100644 index 0000000..b15b140 --- /dev/null +++ b/parser/testdata/corpus/sql/merge/merge_into_parenthesis_bug.test @@ -0,0 +1,42 @@ +# source: test/sql/merge/merge_into_parenthesis_bug.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +CREATE TABLE my_timeseries (ts TIMESTAMP, x DOUBLE PRECISION, y DOUBLE PRECISION); +-- +ok +== +insert into my_timeseries VALUES ('2025-09-15', 43, 39) +-- +ok +== +CREATE TABLE my_timeseries_new (ts TIMESTAMP, x DOUBLE PRECISION, y DOUBLE PRECISION); +-- +ok +== +insert into my_timeseries_new VALUES ('2025-09-15', 43, 39) +-- +ok +== +MERGE INTO my_timeseries old + USING my_timeseries_new new + ON ( + old.x = new.x AND + ( old.ts != new.ts + OR old.x = 1 + ) + ) +WHEN MATCHED THEN UPDATE; +-- +ok +== +MERGE INTO my_timeseries old + USING my_timeseries_new new + USING(ts) +WHEN MATCHED AND ( + old.x IS DISTINCT FROM new.y +) THEN UPDATE; +-- +ok +== diff --git a/parser/testdata/corpus/sql/merge/merge_into_returning.test b/parser/testdata/corpus/sql/merge/merge_into_returning.test new file mode 100644 index 0000000..187f58f --- /dev/null +++ b/parser/testdata/corpus/sql/merge/merge_into_returning.test @@ -0,0 +1,44 @@ +# source: test/sql/merge/merge_into_returning.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +WITH initial_stocks(item_id, balance) AS (VALUES (10, 2200), (20, 1900)) +MERGE INTO Stock USING initial_stocks ON FALSE +WHEN MATCHED THEN DO NOTHING +WHEN NOT MATCHED THEN INSERT VALUES (initial_stocks.item_id, initial_stocks.balance) +RETURNING merge_action, * +-- +ok +== +WITH initial_stocks(item_id, balance) AS (VALUES (10, 2200), (20, 1900)) +MERGE INTO Stock USING initial_stocks ON (Stock.item_id = initial_stocks.item_id) +WHEN NOT MATCHED THEN INSERT VALUES (initial_stocks.item_id, initial_stocks.balance) +RETURNING * +-- +ok +== +MERGE INTO Stock AS s USING Buy AS b ON s.item_id = b.item_id +WHEN MATCHED THEN UPDATE SET balance = balance + b.volume +WHEN NOT MATCHED THEN INSERT VALUES (b.item_id, b.volume) +RETURNING *, merge_action; +-- +ok +== +MERGE INTO Stock USING Sale ON Stock.item_id = Sale.item_id +WHEN MATCHED AND Sale.volume > balance THEN ERROR +WHEN MATCHED AND Sale.volume = balance THEN DELETE +WHEN MATCHED AND TRUE THEN UPDATE SET balance = balance - Sale.volume +WHEN MATCHED THEN ERROR +WHEN NOT MATCHED THEN ERROR +RETURNING Stock.item_id, merge_action, Stock.balance +-- +ok +== +WITH deleted_stocks(item_id) AS (VALUES (30)) +MERGE INTO Stock USING deleted_stocks ON Stock.item_id = deleted_stocks.item_id +WHEN MATCHED THEN DELETE +RETURNING *, merge_action; +-- +ok +== diff --git a/parser/testdata/corpus/sql/merge/merge_into_subquery.test b/parser/testdata/corpus/sql/merge/merge_into_subquery.test new file mode 100644 index 0000000..52646f4 --- /dev/null +++ b/parser/testdata/corpus/sql/merge/merge_into_subquery.test @@ -0,0 +1,33 @@ +# source: test/sql/merge/merge_into_subquery.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +CREATE TABLE Totals(item_id int, balance int); +-- +ok +== +INSERT INTO Buy values(10, 1000), (30, 300), (20, 2000); +-- +ok +== +MERGE INTO Totals USING (VALUES (10), (30)) Updates(item_id) ON Totals.item_id = Updates.item_id +WHEN MATCHED THEN UPDATE SET balance = (SELECT SUM(volume) FROM Buy WHERE item_id=Totals.item_id) +WHEN NOT MATCHED THEN INSERT VALUES (Updates.item_id, (SELECT SUM(volume) FROM Buy WHERE item_id=Updates.item_id)); +-- +ok +== +FROM Totals ORDER BY ALL +-- +ok +== +INSERT INTO Buy values(10, 2000) +-- +ok +== +MERGE INTO Totals USING (VALUES (10), (20)) Updates(item_id) ON Totals.item_id = Updates.item_id +WHEN MATCHED THEN UPDATE SET balance = (SELECT SUM(volume) FROM Buy WHERE item_id=Totals.item_id) +WHEN NOT MATCHED THEN INSERT VALUES (Updates.item_id, (SELECT SUM(volume) FROM Buy WHERE item_id=Updates.item_id)); +-- +ok +== diff --git a/parser/testdata/corpus/sql/merge/merge_into_subquery_action.test b/parser/testdata/corpus/sql/merge/merge_into_subquery_action.test new file mode 100644 index 0000000..78003f4 --- /dev/null +++ b/parser/testdata/corpus/sql/merge/merge_into_subquery_action.test @@ -0,0 +1,42 @@ +# source: test/sql/merge/merge_into_subquery_action.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +CREATE TABLE Totals(item_id int, balance int, biggest_item BOOL); +-- +ok +== +MERGE INTO Totals USING Buy USING (item_id) +WHEN NOT MATCHED AND Buy.volume = (SELECT MAX(Volume) FROM Buy) + THEN INSERT VALUES (Buy.item_id, Buy.volume, true) +WHEN NOT MATCHED + THEN INSERT VALUES (Buy.item_id, Buy.volume, false) +-- +ok +== +SELECT * FROM Totals ORDER BY item_id +-- +ok +== +CREATE TABLE dummy_edge(id INTEGER, ref_id INTEGER, "value" VARCHAR, note VARCHAR); +-- +ok +== +CREATE TABLE dummy_user(user_id INTEGER, "name" VARCHAR, email VARCHAR, created_at DATE); +-- +ok +== +CREATE TABLE dummy_null(id INTEGER, "value" INTEGER, optional_text VARCHAR); +-- +ok +== +MERGE INTO main.dummy_edge as target_0 +USING dummy_user as ref_0 +ON target_0.note = ref_0.name +WHEN NOT MATCHED AND EXISTS ( + SELECT id FROM main.dummy_null WHERE true +) THEN DO NOTHING +-- +ok +== diff --git a/parser/testdata/corpus/sql/merge/merge_into_subquery_condition.test b/parser/testdata/corpus/sql/merge/merge_into_subquery_condition.test new file mode 100644 index 0000000..825e68f --- /dev/null +++ b/parser/testdata/corpus/sql/merge/merge_into_subquery_condition.test @@ -0,0 +1,20 @@ +# source: test/sql/merge/merge_into_subquery_condition.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +INSERT INTO target VALUES (1, 10), (2, 20); +-- +ok +== +MERGE INTO target AS t +USING (VALUES (1, 99)) AS s(id, val) +ON t.id = s.id AND t.val > (SELECT 5) +WHEN MATCHED THEN UPDATE SET val = s.val; +-- +ok +== +FROM target ORDER BY id +-- +ok +== diff --git a/parser/testdata/corpus/sql/merge/merge_into_too_few_columns.test b/parser/testdata/corpus/sql/merge/merge_into_too_few_columns.test new file mode 100644 index 0000000..e5e24d9 --- /dev/null +++ b/parser/testdata/corpus/sql/merge/merge_into_too_few_columns.test @@ -0,0 +1,24 @@ +# source: test/sql/merge/merge_into_too_few_columns.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +CREATE TABLE people (id INTEGER, name VARCHAR, salary FLOAT); +-- +ok +== +INSERT INTO people VALUES (1, 'John', 92_000.0), (2, 'Anna', 100_000.0); +-- +ok +== +MERGE INTO people +USING ( + SELECT + 3 AS id, + 89_000.0 AS salary +) AS upserts +ON (upserts.id = people.id) +WHEN NOT MATCHED THEN INSERT; +-- +ok +== diff --git a/parser/testdata/corpus/sql/merge/merge_into_update_star.test b/parser/testdata/corpus/sql/merge/merge_into_update_star.test new file mode 100644 index 0000000..c799102 --- /dev/null +++ b/parser/testdata/corpus/sql/merge/merge_into_update_star.test @@ -0,0 +1,34 @@ +# source: test/sql/merge/merge_into_update_star.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +INSERT INTO Stock (item_id) VALUES (5), (10), (20); +-- +ok +== +MERGE INTO Stock USING (VALUES (5, 10)) new_accounts(item_id) USING (item_id) +WHEN MATCHED THEN UPDATE +-- +ok +== +MERGE INTO Stock USING (VALUES (10, 30)) new_accounts(item_id, balance) USING (item_id) +WHEN MATCHED THEN UPDATE SET * +-- +ok +== +MERGE INTO Stock USING (VALUES (100, 20)) new_accounts(balance, item_id) USING (item_id) +WHEN MATCHED THEN UPDATE BY NAME +-- +ok +== +MERGE INTO Stock USING (VALUES (10)) new_accounts(item_id) USING (item_id) +WHEN MATCHED THEN UPDATE SET * +-- +ok +== +MERGE INTO Stock USING (VALUES (10, 20)) new_accounts(item_id, balanc) USING (item_id) +WHEN MATCHED THEN UPDATE BY NAME +-- +ok +== diff --git a/parser/testdata/corpus/sql/merge/merge_multi_match_error.test b/parser/testdata/corpus/sql/merge/merge_multi_match_error.test new file mode 100644 index 0000000..f261138 --- /dev/null +++ b/parser/testdata/corpus/sql/merge/merge_multi_match_error.test @@ -0,0 +1,139 @@ +# source: test/sql/merge/merge_multi_match_error.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +CREATE TABLE target (k INTEGER, v INTEGER); +-- +ok +== +CREATE TABLE source (k INTEGER, v INTEGER); +-- +ok +== +INSERT INTO source VALUES (1, 100), (1, 200); +-- +ok +== +MERGE INTO target USING source ON target.k = source.k +WHEN MATCHED THEN UPDATE SET v = source.v; +-- +ok +== +MERGE INTO target USING source ON target.k = source.k +WHEN MATCHED THEN DELETE; +-- +ok +== +SELECT k, v FROM target; +-- +ok +== +DELETE FROM source WHERE v = 200; +-- +ok +== +CREATE TABLE tc (k INTEGER, v INTEGER); +-- +ok +== +INSERT INTO tc VALUES (1, 10); +-- +ok +== +CREATE TABLE sc (k INTEGER, v INTEGER); +-- +ok +== +INSERT INTO sc VALUES (1, 50), (1, 200); +-- +ok +== +MERGE INTO tc USING sc ON tc.k = sc.k +WHEN MATCHED AND sc.v > 100 THEN UPDATE SET v = sc.v; +-- +ok +== +SELECT k, v FROM tc; +-- +ok +== +UPDATE sc SET v = 150 WHERE v = 50; +-- +ok +== +CREATE TABLE t_ins (k INTEGER, v INTEGER); +-- +ok +== +INSERT INTO t_ins VALUES (1, 10); +-- +ok +== +CREATE TABLE s_ins (k INTEGER, v INTEGER); +-- +ok +== +INSERT INTO s_ins VALUES (2, 1), (2, 2); +-- +ok +== +MERGE INTO t_ins USING s_ins ON t_ins.k = s_ins.k +WHEN NOT MATCHED THEN INSERT VALUES (s_ins.k, s_ins.v); +-- +ok +== +SELECT count(*) FROM t_ins; +-- +ok +== +CREATE TABLE t_src (k INTEGER, v INTEGER); +-- +ok +== +INSERT INTO t_src VALUES (1, 10), (2, 20); +-- +ok +== +CREATE TABLE s_src (k INTEGER, v INTEGER); +-- +ok +== +INSERT INTO s_src VALUES (9, 1), (9, 2); +-- +ok +== +MERGE INTO t_src USING s_src ON t_src.k = s_src.k +WHEN NOT MATCHED BY SOURCE THEN UPDATE SET v = 0; +-- +ok +== +SELECT k, v FROM t_src; +-- +ok +== +CREATE TABLE t_big (k INTEGER, v INTEGER); +-- +ok +== +INSERT INTO t_big SELECT i, 0 FROM range(1, 3000) tbl(i); +-- +ok +== +CREATE TABLE s_big (k INTEGER, v INTEGER); +-- +ok +== +INSERT INTO s_big SELECT i, i FROM range(1, 3000) tbl(i); +-- +ok +== +MERGE INTO t_big USING s_big ON t_big.k = s_big.k +WHEN MATCHED THEN UPDATE SET v = s_big.v; +-- +ok +== +SELECT count(*) FROM t_big WHERE v = k; +-- +ok +== diff --git a/parser/testdata/corpus/sql/merge/trigger_merge_into.test b/parser/testdata/corpus/sql/merge/trigger_merge_into.test new file mode 100644 index 0000000..8d87d95 --- /dev/null +++ b/parser/testdata/corpus/sql/merge/trigger_merge_into.test @@ -0,0 +1,223 @@ +# source: test/sql/merge/trigger_merge_into.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +CREATE TRIGGER insert_after AFTER INSERT ON people FOR EACH STATEMENT +MERGE INTO people + USING ( + SELECT + unnest([3, 1]) AS id, + unnest(['Sarah', 'John']) AS name, + unnest([95_000.0, 105_000.0]) AS salary + ) AS upserts + ON (upserts.id = people.id) + WHEN MATCHED THEN UPDATE + WHEN NOT MATCHED THEN INSERT; +-- +ok +== +FROM people; +-- +ok +== +INSERT INTO people VALUES (4, 'Mike', 80_000.0); +-- +ok +== +CREATE TABLE accounts (id INTEGER, balance INTEGER); +-- +ok +== +CREATE TABLE account_summary (id INTEGER, balance INTEGER, last_change INTEGER); +-- +ok +== +CREATE TRIGGER sync_summary AFTER INSERT ON accounts +REFERENCING NEW TABLE AS new_rows +FOR EACH STATEMENT +MERGE INTO account_summary + USING new_rows ON (account_summary.id = new_rows.id) + WHEN MATCHED THEN UPDATE SET balance = new_rows.balance, last_change = new_rows.balance + WHEN NOT MATCHED THEN INSERT (id, balance, last_change) VALUES (new_rows.id, new_rows.balance, new_rows.balance); +-- +ok +== +INSERT INTO accounts VALUES (1, 100), (2, 200); +-- +ok +== +SELECT id, balance, last_change FROM account_summary; +-- +ok +== +INSERT INTO accounts VALUES (1, 150), (3, 300); +-- +ok +== +CREATE TABLE pending (id INTEGER); +-- +ok +== +CREATE TABLE processed (id INTEGER); +-- +ok +== +INSERT INTO processed VALUES (1), (2), (3); +-- +ok +== +CREATE TRIGGER remove_processed AFTER INSERT ON pending +REFERENCING NEW TABLE AS new_rows +FOR EACH STATEMENT +MERGE INTO processed + USING new_rows ON (processed.id = new_rows.id) + WHEN MATCHED THEN DELETE; +-- +ok +== +INSERT INTO pending VALUES (2); +-- +ok +== +SELECT id FROM processed; +-- +ok +== +CREATE TABLE inventory (id INTEGER, qty INTEGER); +-- +ok +== +INSERT INTO inventory VALUES (1, 50), (2, 30); +-- +ok +== +CREATE TABLE inventory_log (id INTEGER, qty INTEGER); +-- +ok +== +CREATE TRIGGER log_qty_change AFTER UPDATE ON inventory +REFERENCING NEW TABLE AS new_rows +FOR EACH STATEMENT +MERGE INTO inventory_log + USING new_rows ON (inventory_log.id = new_rows.id) + WHEN MATCHED THEN UPDATE SET qty = new_rows.qty + WHEN NOT MATCHED THEN INSERT (id, qty) VALUES (new_rows.id, new_rows.qty); +-- +ok +== +UPDATE inventory SET qty = qty - 10 WHERE id = 1; +-- +ok +== +SELECT id, qty FROM inventory_log; +-- +ok +== +UPDATE inventory SET qty = qty + 100 WHERE id = 2; +-- +ok +== +CREATE TABLE live_orders (id INTEGER, amount INTEGER); +-- +ok +== +INSERT INTO live_orders VALUES (1, 10), (2, 20), (3, 30); +-- +ok +== +CREATE TABLE archived_orders (id INTEGER, amount INTEGER); +-- +ok +== +CREATE TRIGGER archive_deleted AFTER DELETE ON live_orders +REFERENCING OLD TABLE AS old_rows +FOR EACH STATEMENT +MERGE INTO archived_orders + USING old_rows ON (archived_orders.id = old_rows.id) + WHEN NOT MATCHED THEN INSERT (id, amount) VALUES (old_rows.id, old_rows.amount); +-- +ok +== +DELETE FROM live_orders WHERE id = 2; +-- +ok +== +SELECT id, amount FROM archived_orders; +-- +ok +== +SELECT COUNT(*) FROM live_orders; +-- +ok +== +CREATE TABLE t_err_src (id INTEGER); +-- +ok +== +CREATE TABLE t_err_dst (id INTEGER); +-- +ok +== +INSERT INTO t_err_dst VALUES (1); +-- +ok +== +CREATE TRIGGER trg_merge_err AFTER INSERT ON t_err_src +REFERENCING NEW TABLE AS new_rows +FOR EACH STATEMENT +MERGE INTO t_err_dst + USING new_rows ON (t_err_dst.id = new_rows.id) + WHEN MATCHED THEN ERROR 'duplicate detected'; +-- +ok +== +INSERT INTO t_err_src VALUES (1); +-- +ok +== +SELECT COUNT(*) FROM t_err_src; +-- +ok +== +CREATE TABLE has_own_trigger (id INTEGER); +-- +ok +== +CREATE TABLE has_own_trigger_log (msg VARCHAR); +-- +ok +== +CREATE TRIGGER trg_on_other AFTER INSERT ON has_own_trigger FOR EACH STATEMENT + INSERT INTO has_own_trigger_log VALUES ('fired'); +-- +ok +== +CREATE TABLE merge_source_table (id INTEGER); +-- +ok +== +CREATE TRIGGER trg_merge_into_other AFTER INSERT ON merge_source_table +REFERENCING NEW TABLE AS new_rows +FOR EACH STATEMENT +MERGE INTO has_own_trigger + USING new_rows ON (has_own_trigger.id = new_rows.id) + WHEN NOT MATCHED THEN INSERT (id) VALUES (new_rows.id); +-- +ok +== +CREATE TABLE row_target (id INTEGER); +-- +ok +== +CREATE TABLE row_target_2 (id INTEGER); +-- +ok +== +CREATE TRIGGER trg_row_merge AFTER INSERT ON row_target FOR EACH ROW +MERGE INTO row_target_2 + USING (SELECT 1 AS id) AS s ON (row_target_2.id = s.id) + WHEN NOT MATCHED THEN INSERT (id) VALUES (s.id); +-- +ok +== diff --git a/parser/testdata/corpus/sql/optimizer/any_extremum_rewrite.test b/parser/testdata/corpus/sql/optimizer/any_extremum_rewrite.test new file mode 100644 index 0000000..1297aca --- /dev/null +++ b/parser/testdata/corpus/sql/optimizer/any_extremum_rewrite.test @@ -0,0 +1,93 @@ +# source: test/sql/optimizer/any_extremum_rewrite.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +PRAGMA enable_verification +-- +ok +== +CREATE TABLE t1(id INTEGER, x INTEGER); +-- +ok +== +CREATE TABLE t2(id INTEGER, y INTEGER); +-- +ok +== +INSERT INTO t1 VALUES (1, 5), (2, 0), (3, NULL), (4, 10), (99, 100); +-- +ok +== +INSERT INTO t2 VALUES (1, 1), (1, NULL), (2, 10), (2, 20), (3, 1), (4, NULL); +-- +ok +== +SELECT x > ANY(SELECT y FROM t2 WHERE 1=0) FROM t1 ORDER BY id; +-- +ok +== +SELECT x > ANY(SELECT y FROM t2) FROM t1 ORDER BY id; +-- +ok +== +SELECT x > ANY(SELECT y FROM t2 WHERE y IS NOT NULL) FROM t1 ORDER BY id; +-- +ok +== +SELECT x > ANY(SELECT y FROM t2 WHERE t2.id = t1.id) FROM t1 WHERE id = 99; +-- +ok +== +SELECT x > ANY(SELECT y FROM t2 WHERE t2.id = t1.id) FROM t1 WHERE id = 1; +-- +ok +== +SELECT x > ANY(SELECT y FROM t2 WHERE t2.id = t1.id) FROM t1 WHERE id = 4; +-- +ok +== +SELECT x > ANY(SELECT y FROM t2 WHERE t2.id = t1.id) FROM t1 WHERE id = 2; +-- +ok +== +SELECT x > ANY(SELECT y FROM t2 WHERE t2.id = t1.id) FROM t1 WHERE id = 3; +-- +ok +== +SELECT 0 < ANY(SELECT y FROM t2) +-- +ok +== +SELECT 100 < ANY(SELECT y FROM t2) +-- +ok +== +SELECT 0 >= ANY(SELECT y FROM t2 WHERE y IS NOT NULL) +-- +ok +== +SELECT 1 <= ANY(SELECT y FROM t2 WHERE y IS NOT NULL) +-- +ok +== +SELECT 'b' COLLATE NOCASE > ANY(SELECT x FROM (VALUES ('Z'), ('a')) t(x)); +-- +ok +== +CREATE TABLE t_col(x VARCHAR); +-- +ok +== +INSERT INTO t_col VALUES ('Z'), ('a'); +-- +ok +== +SELECT 'b' COLLATE NOCASE > ANY(SELECT x FROM t_col); +-- +ok +== +SELECT 'A' COLLATE NOCASE > ANY(SELECT x FROM t_col); +-- +ok +== diff --git a/parser/testdata/corpus/sql/optimizer/array_extract_row_group_pruning.test b/parser/testdata/corpus/sql/optimizer/array_extract_row_group_pruning.test new file mode 100644 index 0000000..c9e10f6 --- /dev/null +++ b/parser/testdata/corpus/sql/optimizer/array_extract_row_group_pruning.test @@ -0,0 +1,59 @@ +# source: test/sql/optimizer/array_extract_row_group_pruning.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +ATTACH '{TEST_DIR}/array_extract_row_group_pruning.duckdb' AS db (ROW_GROUP_SIZE 2048); +-- +ok +== +USE db; +-- +ok +== +CREATE TABLE arrays AS +SELECT [i::INTEGER, (i + 1)::INTEGER, (i + 2)::INTEGER]::INTEGER[3] AS a +FROM range(6144) tbl(i); +-- +ok +== +EXPLAIN ANALYZE SELECT count(*) FROM arrays WHERE a[1] BETWEEN 2900 AND 3100; +-- +ok +== +SELECT count(*) FROM arrays WHERE a[1] BETWEEN 2900 AND 3100; +-- +ok +== +EXPLAIN ANALYZE SELECT count(*) FROM arrays WHERE a[-1] BETWEEN 2902 AND 3102; +-- +ok +== +SELECT count(*) FROM arrays WHERE a[-1] BETWEEN 2902 AND 3102; +-- +ok +== +SELECT count(*) FROM arrays WHERE a[4] IS NULL; +-- +ok +== +CREATE TABLE nullable_arrays(a INTEGER[3]); +-- +ok +== +INSERT INTO nullable_arrays VALUES (NULL), ([1, NULL, 3]), ([4, 5, 6]); +-- +ok +== +SELECT count(*) FROM nullable_arrays WHERE a[1] IS NULL; +-- +ok +== +SELECT count(*) FROM nullable_arrays WHERE a[2] IS NULL; +-- +ok +== +SELECT count(*) FROM nullable_arrays WHERE a[4] IS NULL; +-- +ok +== diff --git a/parser/testdata/corpus/sql/optimizer/boolean_row_group_pruning.test b/parser/testdata/corpus/sql/optimizer/boolean_row_group_pruning.test new file mode 100644 index 0000000..e02f6d7 --- /dev/null +++ b/parser/testdata/corpus/sql/optimizer/boolean_row_group_pruning.test @@ -0,0 +1,25 @@ +# source: test/sql/optimizer/boolean_row_group_pruning.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +ATTACH '{TEST_DIR}/bool_prune.duckdb' AS db (ROW_GROUP_SIZE 2048); +-- +ok +== +CREATE TABLE bt AS SELECT (range >= 2048) AS b FROM range(4096); +-- +ok +== +EXPLAIN ANALYZE SELECT sum(rowid) FROM bt WHERE b = true; +-- +ok +== +EXPLAIN ANALYZE SELECT sum(rowid) FROM bt WHERE b = false; +-- +ok +== +EXPLAIN ANALYZE SELECT sum(rowid) FROM bt WHERE b IN (true); +-- +ok +== diff --git a/parser/testdata/corpus/sql/optimizer/boolean_wrapper_pushdown.test b/parser/testdata/corpus/sql/optimizer/boolean_wrapper_pushdown.test new file mode 100644 index 0000000..e3a1f58 --- /dev/null +++ b/parser/testdata/corpus/sql/optimizer/boolean_wrapper_pushdown.test @@ -0,0 +1,53 @@ +# source: test/sql/optimizer/boolean_wrapper_pushdown.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +ATTACH '{TEST_DIR}/boolean_wrapper_pushdown.duckdb' AS db (ROW_GROUP_SIZE 2048); +-- +ok +== +CREATE TABLE integers AS SELECT range::BIGINT AS x FROM range(4096); +-- +ok +== +EXPLAIN ANALYZE SELECT sum(rowid) FROM integers WHERE (x > 3000) = true; +-- +ok +== +EXPLAIN ANALYZE SELECT sum(rowid) FROM integers WHERE (x > 3000) IS TRUE; +-- +ok +== +CREATE TABLE booleans(p BOOLEAN); +-- +ok +== +INSERT INTO booleans VALUES (true), (false), (NULL); +-- +ok +== +SELECT p, p = true, p IS TRUE FROM booleans ORDER BY p NULLS LAST; +-- +ok +== +SELECT count(*) FROM booleans WHERE NOT (p IS TRUE); +-- +ok +== +CREATE SEQUENCE s; +-- +ok +== +SELECT count(*) FROM booleans WHERE (nextval('s') > 0) IS TRUE; +-- +ok +== +SELECT currval('s'); +-- +ok +== +SELECT count(*) FROM booleans WHERE (error('expected')::INTEGER > 0) IS TRUE; +-- +ok +== diff --git a/parser/testdata/corpus/sql/optimizer/empty_string_concat_pruning.test b/parser/testdata/corpus/sql/optimizer/empty_string_concat_pruning.test new file mode 100644 index 0000000..2b50609 --- /dev/null +++ b/parser/testdata/corpus/sql/optimizer/empty_string_concat_pruning.test @@ -0,0 +1,47 @@ +# source: test/sql/optimizer/empty_string_concat_pruning.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +CREATE TABLE empty_concat_pruning AS +SELECT i::INTEGER AS i, 'p' || lpad(i::VARCHAR, 6, '0') AS s +FROM range(500000) r(i); +-- +ok +== +EXPLAIN ANALYZE SELECT sum(i) FROM empty_concat_pruning WHERE s || '' = 'p495000'; +-- +ok +== +EXPLAIN ANALYZE SELECT sum(i) FROM empty_concat_pruning WHERE '' || s = 'p495000'; +-- +ok +== +EXPLAIN ANALYZE SELECT sum(i) FROM empty_concat_pruning WHERE '' || s || '' = 'p495000'; +-- +ok +== +EXPLAIN ANALYZE SELECT sum(i) FROM empty_concat_pruning WHERE '' || ('' || (s || '')) = 'p495000'; +-- +ok +== +SELECT count(*) FROM empty_concat_pruning WHERE s || '' = 'p495000'; +-- +ok +== +SELECT count(*) FROM empty_concat_pruning WHERE '' || s = 'p495000'; +-- +ok +== +SELECT count(*) FROM empty_concat_pruning WHERE '' || ('' || (s || '')) = 'p495000'; +-- +ok +== +SELECT NULL::VARCHAR || '', '' || NULL::VARCHAR, 'duck' || '', '' || 'duck'; +-- +ok +== +SELECT s || lower('') FROM (VALUES ('duck'), (NULL)) t(s) ORDER BY s NULLS LAST; +-- +ok +== diff --git a/parser/testdata/corpus/sql/optimizer/expression/list_comprehension_rewrite.test b/parser/testdata/corpus/sql/optimizer/expression/list_comprehension_rewrite.test new file mode 100644 index 0000000..e519359 --- /dev/null +++ b/parser/testdata/corpus/sql/optimizer/expression/list_comprehension_rewrite.test @@ -0,0 +1,95 @@ +# source: test/sql/optimizer/expression/list_comprehension_rewrite.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +CREATE TABLE t(l INTEGER[]); +-- +ok +== +INSERT INTO t VALUES ([10, 9, 8, 7, 6]); +-- +ok +== +EXPLAIN SELECT [i + 5 FOR x, i IN l IF i > 2] FROM t; +-- +ok +== +EXPLAIN SELECT [i + 5 FOR x, i IN l IF x > 8] FROM t; +-- +ok +== +EXPLAIN SELECT [x + 5 FOR x, i IN l IF i > 2] FROM t; +-- +ok +== +EXPLAIN SELECT [x + 5 FOR x, i IN l IF x > 8] FROM t; +-- +ok +== +SELECT [i + 5 FOR x, i IN l IF i > 2] FROM t; +-- +ok +== +SELECT [i + 5 FOR x, i IN l IF x > 8] FROM t; +-- +ok +== +SELECT [x + 5 FOR x, i IN l IF i > 2] FROM t; +-- +ok +== +SELECT [x + 5 FOR x, i IN l IF x > 8] FROM t; +-- +ok +== +EXPLAIN SELECT [x + 5 FOR x, i IN l IF x >> 8] FROM t; +-- +ok +== +SELECT [x + 5 FOR x, i IN l IF x >> 8] FROM t; +-- +ok +== +EXPLAIN SELECT {t}({f}({t}(l, lambda x, i: struct_pack(filter := i > 2, result := i + 5)), lambda s: s.filter), lambda s: s.result) FROM t; +-- +error: Parser Error: syntax error at or near "}" +== +EXPLAIN SELECT {t}({f}({t}(l, lambda x, i: struct_pack(filter := i > 2, result := x + 5)), lambda s: s.filter), lambda s: s.result) FROM t; +-- +error: Parser Error: syntax error at or near "}" +== +SELECT {t}({f}({t}(l, lambda x, i: struct_pack(filter := i > 2, result := i + 5)), lambda s: s.filter), lambda s: s.result) FROM t; +-- +error: Parser Error: syntax error at or near "}" +== +SELECT {t}({f}({t}(l, lambda x, i: struct_pack(filter := i > 2, result := x + 5)), lambda s: s.filter), lambda s: s.result) FROM t; +-- +error: Parser Error: syntax error at or near "}" +== +SELECT list_transform( + list_filter( + list_transform(l, lambda x: struct_pack(filter := x > 8, result := x + 5)), + lambda s: NOT s.filter + ), + lambda s: s.result +) FROM t; +-- +ok +== +CREATE TABLE capture_t(l INTEGER[], c INTEGER); +-- +ok +== +INSERT INTO capture_t VALUES ([10, 9, 8, 7, 6], 8); +-- +ok +== +SELECT [x + c FOR x IN l IF x > c] FROM capture_t; +-- +ok +== +EXPLAIN SELECT [x * random() FOR x, i IN l IF x > 2] FROM t; +-- +ok +== diff --git a/parser/testdata/corpus/sql/optimizer/expression/test_casting_negative_integer_to_bit.test b/parser/testdata/corpus/sql/optimizer/expression/test_casting_negative_integer_to_bit.test new file mode 100644 index 0000000..3f79ab1 --- /dev/null +++ b/parser/testdata/corpus/sql/optimizer/expression/test_casting_negative_integer_to_bit.test @@ -0,0 +1,25 @@ +# source: test/sql/optimizer/expression/test_casting_negative_integer_to_bit.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +CREATE TABLE t1 as select -1 c1 from range(1); +-- +ok +== +SELECT t1.c1 FROM t1; +-- +ok +== +SELECT CAST(CAST(t1.c1 AS BIT) AS INTEGER), (1 BETWEEN -1 AND CAST(CAST(t1.c1 AS BIT) AS INTEGER)) FROM t1; +-- +ok +== +select cast(cast(c1 as BIT) as INTEGER) as cast_res, 1 between -1 and cast(cast(c1 as BIT) as INTEGER) as watever from t1; +-- +ok +== +SELECT t1.c1 FROM t1 WHERE (1 BETWEEN -1 AND CAST(CAST(t1.c1 AS BIT) AS INTEGER)); +-- +ok +== diff --git a/parser/testdata/corpus/sql/optimizer/expression/test_common_aggregate.test b/parser/testdata/corpus/sql/optimizer/expression/test_common_aggregate.test new file mode 100644 index 0000000..2d7fc21 --- /dev/null +++ b/parser/testdata/corpus/sql/optimizer/expression/test_common_aggregate.test @@ -0,0 +1,55 @@ +# source: test/sql/optimizer/expression/test_common_aggregate.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +PRAGMA explain_output = 'OPTIMIZED_ONLY'; +-- +ok +== +EXPLAIN SELECT COUNT(*), COUNT(), COUNT(i) FROM integers; +-- +ok +== +SELECT COUNT(*), COUNT(), COUNT(i) FROM integers; +-- +ok +== +EXPLAIN SELECT COUNT(*), COUNT(), SUM(i), COUNT(i), SUM(i) / COUNT(i) FROM integers; +-- +ok +== +SELECT COUNT(*), COUNT(), SUM(i), COUNT(i), SUM(i) / COUNT(i) FROM integers; +-- +ok +== +CREATE TABLE groups(grp INTEGER, aggr1 INTEGER, aggr2 INTEGER, aggr3 INTEGER) +-- +ok +== +INSERT INTO groups VALUES (1, 1, 2, 3), (1, 2, 4, 6), (2, 1, 2, 3), (2, 3, 6, 9); +-- +ok +== +SELECT + sum(aggr1)::DOUBLE / count(aggr1)::DOUBLE AS avg_qty, + sum(aggr2)::DOUBLE / count(aggr2)::DOUBLE AS avg_price, + sum(aggr3)::DOUBLE / count(aggr3)::DOUBLE AS avg_disc +FROM + groups +GROUP BY + grp +ORDER BY grp; +-- +ok +== +SELECT + name, + MAX(SUM(n)) OVER (PARTITION BY name) AS w1, + SUM(n) / MAX(SUM(n)) OVER (PARTITION BY name) AS w2 +FROM (VALUES ('a',1),('a',2),('b',3)) t(name, n) +GROUP BY name +ORDER BY ALL; +-- +ok +== diff --git a/parser/testdata/corpus/sql/optimizer/expression/test_comparison_simplification.test b/parser/testdata/corpus/sql/optimizer/expression/test_comparison_simplification.test new file mode 100644 index 0000000..e3de114 --- /dev/null +++ b/parser/testdata/corpus/sql/optimizer/expression/test_comparison_simplification.test @@ -0,0 +1,35 @@ +# source: test/sql/optimizer/expression/test_comparison_simplification.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +WITH results AS ( + SELECT '2023-08-17T23:00:08.539Z' as timestamp + ) +SELECT * +FROM results +WHERE timestamp::TIME BETWEEN '22:00:00'::TIME AND '23:59:59'::TIME ; +-- +ok +== +CREATE TABLE issue8316 (dt TIMESTAMP); +-- +ok +== +INSERT INTO issue8316 VALUES + ('2016-02-14 18:00:05'), + ('2016-02-15 10:04:25'), + ('2016-02-16 10:04:25'), + ('2016-02-16 23:59:55'), +; +-- +ok +== +SELECT dt +FROM issue8316 +WHERE CAST(dt as TIME) = CAST('10:04:25' as TIME) +ORDER BY 1 +; +-- +ok +== diff --git a/parser/testdata/corpus/sql/optimizer/expression/test_conjunction_optimization.test b/parser/testdata/corpus/sql/optimizer/expression/test_conjunction_optimization.test new file mode 100644 index 0000000..ecd3cc1 --- /dev/null +++ b/parser/testdata/corpus/sql/optimizer/expression/test_conjunction_optimization.test @@ -0,0 +1,65 @@ +# source: test/sql/optimizer/expression/test_conjunction_optimization.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +SELECT i FROM integers WHERE (i=1 AND i>0) OR (i=1 AND i<3) ORDER BY i +-- +ok +== +SELECT i FROM integers WHERE (i=1) OR (i=1) ORDER BY i +-- +ok +== +SELECT i FROM integers WHERE (i=1) OR (i=1) OR (i=1) OR (i=1) OR (i=1) ORDER BY i +-- +ok +== +SELECT i FROM integers WHERE (i IS NULL AND i=1) OR (i IS NULL AND i<10) ORDER BY i +-- +ok +== +SELECT i FROM integers WHERE (i IS NOT NULL AND i>1) OR (i IS NOT NULL AND i<10) ORDER BY i +-- +ok +== +SELECT i FROM integers WHERE (i IS NULL AND (i+1) IS NULL) OR (i IS NULL AND (i+2) IS NULL) ORDER BY i +-- +ok +== +SELECT i FROM integers WHERE i=1 OR 1=1 ORDER BY i +-- +ok +== +SELECT i FROM integers WHERE i=1 OR 1=0 OR 1=1 ORDER BY i +-- +ok +== +SELECT i FROM integers WHERE (i=1 OR 1=0 OR i=1) AND (0=1 OR 1=0 OR 1=1) ORDER BY i +-- +ok +== +SELECT (i=1 AND i>0) OR (i=1 AND i<3) FROM integers ORDER BY i +-- +ok +== +SELECT (i=1) OR (i=1) FROM integers ORDER BY i +-- +ok +== +SELECT (i=1) OR (i=1) OR (i=1) OR (i=1) OR (i=1) FROM integers ORDER BY i +-- +ok +== +SELECT (i IS NULL AND i=1) OR (i IS NULL AND i<10) FROM integers ORDER BY i +-- +ok +== +SELECT (i IS NOT NULL AND i>1) OR (i IS NOT NULL AND i<10) FROM integers ORDER BY i +-- +ok +== +SELECT (i IS NULL AND (i+1) IS NULL) OR (i IS NULL AND (i+2) IS NULL) FROM integers ORDER BY i +-- +ok +== diff --git a/parser/testdata/corpus/sql/optimizer/expression/test_cse.test b/parser/testdata/corpus/sql/optimizer/expression/test_cse.test new file mode 100644 index 0000000..cc9fa10 --- /dev/null +++ b/parser/testdata/corpus/sql/optimizer/expression/test_cse.test @@ -0,0 +1,57 @@ +# source: test/sql/optimizer/expression/test_cse.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +create table test(a integer); +-- +ok +== +insert into test values (42); +-- +ok +== +SELECT (a*2)+(a*2) FROM test +-- +ok +== +SELECT (a*2)+(a*2)+(a*2)+(a*2)+(a*2) FROM test +-- +ok +== +SELECT (a*2)+(a*2)+(a*2)+(a*2)+(a*2), a FROM test +-- +ok +== +SELECT SUM((a*2)+(a*2)+(a*2)+(a*2)+(a*2)) FROM test +-- +ok +== +SELECT a, SUM((a*2)+(a*2)+(a*2)+(a*2)+(a*2)) FROM test GROUP BY a +-- +ok +== +SELECT * FROM test WHERE ((a*2)+(a*2))>100 +-- +ok +== +SELECT * FROM test WHERE ((a*2)+(a*2)+(a*2)+(a*2)+(a*2))>400 +-- +ok +== +create table test2(a VARCHAR); +-- +ok +== +insert into test2 values ('hello'), ('world'), (NULL); +-- +ok +== +SELECT substring(a, 1, 3)=substring(a, 1, 3) FROM test2 ORDER BY 1 +-- +ok +== +SELECT substring(a, 1, 3)=substring(a, 1, 3) AS b FROM test2 GROUP BY b ORDER BY b +-- +ok +== diff --git a/parser/testdata/corpus/sql/optimizer/expression/test_date_subtract_filter.test b/parser/testdata/corpus/sql/optimizer/expression/test_date_subtract_filter.test new file mode 100644 index 0000000..8ae797d --- /dev/null +++ b/parser/testdata/corpus/sql/optimizer/expression/test_date_subtract_filter.test @@ -0,0 +1,20 @@ +# source: test/sql/optimizer/expression/test_date_subtract_filter.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +CREATE TABLE dates(lo_commitdate DATE); +-- +ok +== +INSERT INTO dates VALUES (DATE '1992-02-10'); +-- +ok +== +SELECT CAST('2020-02-20' AS date) - CAST(min("ta_1"."lo_commitdate") AS date) AS "ca_1" +FROM dates AS "ta_1" +HAVING CAST('2020-02-20' AS date) - CAST(min("ta_1"."lo_commitdate") AS date) > 4 +ORDER BY "ca_1" ASC; +-- +ok +== diff --git a/parser/testdata/corpus/sql/optimizer/expression/test_enum_in_simplification.test b/parser/testdata/corpus/sql/optimizer/expression/test_enum_in_simplification.test new file mode 100644 index 0000000..407b173 --- /dev/null +++ b/parser/testdata/corpus/sql/optimizer/expression/test_enum_in_simplification.test @@ -0,0 +1,218 @@ +# source: test/sql/optimizer/expression/test_enum_in_simplification.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +CREATE TYPE sym_enum AS ENUM ( + SELECT i::VARCHAR + FROM range(10) tbl(i) +); +-- +ok +== +CREATE TABLE quote AS ( + WITH asks AS ( + SELECT + (100.0 * random() + 10.0)::FLOAT AS ask, + round(20.0 * random() + 5)::INTEGER AS asize, + FROM range(100) + ) + SELECT + ask, + asize, + (ask + 5.0 * (random() - 0.5))::FLOAT AS bid, + round(asize + 2 * (random() - 0.5))::INTEGER AS bsize, + floor(random() * 10)::INTEGER::VARCHAR::sym_enum AS sym + FROM asks +); +-- +ok +== +explain +SELECT sym, + SUM(asize * ask) AS wsumAsk, + SUM(bid * bsize) AS wsumBid, + STDDEV(asize) AS sdevasksize, + STDDEV(bid) AS sdevbid, + CORR(ask, bid) AS corPrice, + CORR(asize, bsize) AS corSize +FROM quote +WHERE sym IN ( + NULL, + '0', + '1', + '2', + '3', + '4', + '5', + '6', + '7', + '8', + '9', + '10', + '11', + '12', +) +GROUP BY sym +ORDER BY sym; +-- +ok +== +explain +SELECT sym, + SUM(asize * ask) AS wsumAsk, + SUM(bid * bsize) AS wsumBid, + STDDEV(asize) AS sdevasksize, + STDDEV(bid) AS sdevbid, + CORR(ask, bid) AS corPrice, + CORR(asize, bsize) AS corSize +FROM quote +WHERE sym IN ( + '10', + '11', + '12', +) +GROUP BY sym +ORDER BY sym; +-- +ok +== +explain +SELECT sym, + SUM(asize * ask) AS wsumAsk, + SUM(bid * bsize) AS wsumBid, + STDDEV(asize) AS sdevasksize, + STDDEV(bid) AS sdevbid, + CORR(ask, bid) AS corPrice, + CORR(asize, bsize) AS corSize +FROM quote +WHERE sym NOT IN ( + NULL, + '0', + '1', + '2', + '3', + '4', + '5', + '6', + '7', + '8', + '9', + '10', + '11', + '12', +) +GROUP BY sym +ORDER BY sym; +-- +ok +== +explain +SELECT sym, + SUM(asize * ask) AS wsumAsk, + SUM(bid * bsize) AS wsumBid, + STDDEV(asize) AS sdevasksize, + STDDEV(bid) AS sdevbid, + CORR(ask, bid) AS corPrice, + CORR(asize, bsize) AS corSize +FROM quote +WHERE sym NOT IN ( + '10', + '11', + '12', +) +GROUP BY sym +ORDER BY sym; +-- +ok +== +INSERT INTO quote VALUES (NULL, NULL, NULL, NULL, NULL); +-- +ok +== +explain +SELECT count(*), max(n) +FROM ( + select sym IN ('10', '11', '12') AS n + FROM quote + WHERE n IS NOT NULL +) tbl; +-- +ok +== +SELECT count(*), max(n) +FROM ( + select sym IN ('10', '11', '12') AS n + FROM quote + WHERE n IS NOT NULL +) tbl; +-- +ok +== +explain +SELECT count(*), max(n) +FROM ( + select sym NOT IN ('10', '11', '12') AS n + FROM quote + WHERE n IS NOT NULL +) tbl; +-- +ok +== +SELECT count(*), max(n) +FROM ( + select sym NOT IN ('10', '11', '12') AS n + FROM quote + WHERE n IS NOT NULL +) tbl; +-- +ok +== +EXPLAIN +FROM quote +WHERE sym = '0'; +-- +ok +== +EXPLAIN +FROM quote +WHERE sym = '100'; +-- +ok +== +EXPLAIN +FROM quote +WHERE sym <> '0'; +-- +ok +== +EXPLAIN +FROM quote +WHERE sym <> '100'; +-- +ok +== +EXPLAIN +FROM quote +WHERE sym IS NOT DISTINCT FROM '0'; +-- +ok +== +EXPLAIN +FROM quote +WHERE sym IS NOT DISTINCT FROM '100'; +-- +ok +== +EXPLAIN +FROM quote +WHERE sym IS DISTINCT FROM '0'; +-- +ok +== +EXPLAIN +FROM quote +WHERE sym IS DISTINCT FROM '100'; +-- +ok +== diff --git a/parser/testdata/corpus/sql/optimizer/expression/test_equal_or_null_optimization.test b/parser/testdata/corpus/sql/optimizer/expression/test_equal_or_null_optimization.test new file mode 100644 index 0000000..e0548f1 --- /dev/null +++ b/parser/testdata/corpus/sql/optimizer/expression/test_equal_or_null_optimization.test @@ -0,0 +1,108 @@ +# source: test/sql/optimizer/expression/test_equal_or_null_optimization.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +PRAGMA explain_output = 'PHYSICAL_ONLY' +-- +ok +== +CREATE TABLE test(i INTEGER, j INTEGER, k integer); +-- +ok +== +INSERT INTO test VALUES (1,1,3), (2,2,4), (NULL,NULL,NULL); +-- +ok +== +SELECT i FROM test WHERE (i=j) OR (i IS NULL AND j IS NULL); +-- +ok +== +EXPLAIN SELECT (i=j) OR (i IS NULL AND j IS NULL) FROM test; +-- +ok +== +SELECT i FROM test WHERE i IS NOT DISTINCT FROM j; +-- +ok +== +EXPLAIN SELECT i IS NOT DISTINCT FROM j FROM test; +-- +ok +== +SELECT i FROM test WHERE (i IS NULL AND j IS NULL) OR (i=j); +-- +ok +== +EXPLAIN SELECT (i IS NULL AND j IS NULL) OR (i=j) FROM test; +-- +ok +== +CREATE TABLE projection_test(a INTEGER, b INTEGER); +-- +ok +== +INSERT INTO projection_test VALUES (0, NULL); +-- +ok +== +SELECT a = b OR (a IS NULL AND b IS NULL) AS v FROM projection_test; +-- +ok +== +SELECT (a IS NULL AND b IS NULL) OR a = b AS v FROM projection_test; +-- +ok +== +SELECT count(*) +FROM (VALUES (0::INTEGER, NULL::INTEGER)) l(a, b) +JOIN (VALUES (false)) r(c) + ON (l.a = l.b OR (l.a IS NULL AND l.b IS NULL)) = r.c; +-- +ok +== +SELECT test1.i FROM test AS test1, test AS test2 WHERE (test1.i=test2.j) OR (test1.i IS NULL AND test2.j IS NULL) ORDER BY 1; +-- +ok +== +EXPLAIN SELECT test1.i FROM test AS test1, test AS test2 WHERE (test1.i=test2.j) OR (test1.i IS NULL AND test2.j IS NULL); +-- +ok +== +EXPLAIN SELECT test1.i FROM test AS test1, test AS test2 WHERE (test1.i IS NULL AND test2.j IS NULL) OR (test1.i=test2.j); +-- +ok +== +SELECT i FROM test WHERE (i=k) OR (i IS NULL AND j IS NULL); +-- +ok +== +EXPLAIN SELECT i FROM test WHERE (i=k) OR (i IS NULL AND j IS NULL); +-- +ok +== +SELECT i FROM test WHERE (i=j) OR (i IS NULL AND j = 1); +-- +ok +== +EXPLAIN SELECT i FROM test WHERE (i=j) OR (i IS NULL AND j = 1); +-- +ok +== +SELECT test1.i FROM test AS test1, test AS test2 WHERE (test1.i=test2.j) OR (test2.i IS NULL AND test1.j IS NULL); +-- +ok +== +EXPLAIN SELECT test1.i FROM test AS test1, test AS test2 WHERE (test1.i=test2.j) OR (test2.i IS NULL AND test1.j IS NULL); +-- +ok +== +SELECT test1.i FROM test AS test1, test AS test2 WHERE (test1.i=test2.k) OR (test2.i IS NULL AND test2.j IS NULL); +-- +ok +== +EXPLAIN SELECT test1.i FROM test AS test1, test AS test2 WHERE (test1.i=test2.k) OR (test2.i IS NULL AND test2.j IS NULL); +-- +ok +== diff --git a/parser/testdata/corpus/sql/optimizer/expression/test_in_clause_simplification.test b/parser/testdata/corpus/sql/optimizer/expression/test_in_clause_simplification.test new file mode 100644 index 0000000..e017930 --- /dev/null +++ b/parser/testdata/corpus/sql/optimizer/expression/test_in_clause_simplification.test @@ -0,0 +1,25 @@ +# source: test/sql/optimizer/expression/test_in_clause_simplification.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +CREATE TABLE issue13380(c0 TIMESTAMP); +-- +ok +== +INSERT INTO issue13380(c0) VALUES ('2024-08-09 14:48:00'); +-- +ok +== +SELECT c0::DATE IN ('2024-08-09') d FROM issue13380; +-- +ok +== +SELECT NOT (c0::DATE IN ('2024-08-09')) FROM issue13380; +-- +ok +== +SELECT c0::DATE NOT IN ('2024-08-09') FROM issue13380; +-- +ok +== diff --git a/parser/testdata/corpus/sql/optimizer/expression/test_indistinct_aggregates.test b/parser/testdata/corpus/sql/optimizer/expression/test_indistinct_aggregates.test new file mode 100644 index 0000000..0c07260 --- /dev/null +++ b/parser/testdata/corpus/sql/optimizer/expression/test_indistinct_aggregates.test @@ -0,0 +1,13 @@ +# source: test/sql/optimizer/expression/test_indistinct_aggregates.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +SELECT max(distinct x) from range(10) tbl(x); +-- +ok +== +SELECT x, max(distinct x) over (order by x desc) from range(10) tbl(x); +-- +ok +== diff --git a/parser/testdata/corpus/sql/optimizer/expression/test_move_constants.test b/parser/testdata/corpus/sql/optimizer/expression/test_move_constants.test new file mode 100644 index 0000000..40a9e95 --- /dev/null +++ b/parser/testdata/corpus/sql/optimizer/expression/test_move_constants.test @@ -0,0 +1,129 @@ +# source: test/sql/optimizer/expression/test_move_constants.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +CREATE OR REPLACE TABLE vals(v {type}); +-- +error: Parser Error: syntax error at or near "{" +== +INSERT INTO vals VALUES (2), (NULL); +-- +ok +== +SELECT * FROM vals WHERE v+({max}-10)::{type}=-100::{type}; +-- +error: Parser Error: syntax error at or near "}" +== +SELECT v+({max}-10)::{type}=-100::{type} FROM vals; +-- +error: Parser Error: syntax error at or near "}" +== +SELECT * FROM vals WHERE v-{max}::{type}={max}::{type}; +-- +error: Parser Error: syntax error at or near "}" +== +SELECT * FROM vals WHERE ({min}+100)::{type}-v={max}::{type}; +-- +error: Parser Error: syntax error at or near "}" +== +SELECT * FROM vals WHERE v*0::{type}=1::{type}; +-- +error: Parser Error: syntax error at or near "{" +== +SELECT * FROM vals WHERE v*0::{type}=0::{type}; +-- +error: Parser Error: syntax error at or near "{" +== +SELECT v*0::{type}=0::{type} FROM vals; +-- +error: Parser Error: syntax error at or near "{" +== +SELECT v*0::{type}=1::{type} FROM vals; +-- +error: Parser Error: syntax error at or near "{" +== +SELECT * FROM vals WHERE v*(-1)::{type}=({min})::{type}; +-- +error: Parser Error: syntax error at or near "{" +== +SELECT * FROM vals WHERE v*(-2)::{type}=({min})::{type}; +-- +error: Parser Error: syntax error at or near "{" +== +CREATE OR REPLACE TABLE vals(v {utype}); +-- +error: Parser Error: syntax error at or near "{" +== +SELECT * FROM vals WHERE v+5::{utype}=3::{utype}; +-- +error: Parser Error: syntax error at or near "{" +== +SELECT v+5::{utype}=3::{utype} FROM vals; +-- +error: Parser Error: syntax error at or near "{" +== +SELECT * FROM vals WHERE 5::{utype}+v=3::{utype}; +-- +error: Parser Error: syntax error at or near "{" +== +SELECT * FROM vals WHERE v+1::{utype}=3::{utype}; +-- +error: Parser Error: syntax error at or near "{" +== +SELECT * FROM vals WHERE 1::{utype}+v=3::{utype}; +-- +error: Parser Error: syntax error at or near "{" +== +SELECT * FROM vals WHERE v-2::{utype}=255::{utype}; +-- +error: Parser Error: syntax error at or near "{" +== +SELECT * FROM vals WHERE 2::{utype}-v=3::{utype}; +-- +error: Parser Error: syntax error at or near "{" +== +SELECT * FROM vals WHERE v-1::{utype}=1::{utype}; +-- +error: Parser Error: syntax error at or near "{" +== +SELECT * FROM vals WHERE 4::{utype}-v=2::{utype}; +-- +error: Parser Error: syntax error at or near "{" +== +SELECT * FROM vals WHERE v*0::{utype}=1::{utype}; +-- +error: Parser Error: syntax error at or near "{" +== +SELECT * FROM vals WHERE v*0::{utype}=0::{utype}; +-- +error: Parser Error: syntax error at or near "{" +== +SELECT v*0::{utype}=0::{utype} FROM vals; +-- +error: Parser Error: syntax error at or near "{" +== +SELECT v*0::{utype}=1::{utype} FROM vals; +-- +error: Parser Error: syntax error at or near "{" +== +SELECT * FROM vals WHERE v*3::{utype}=7::{utype}; +-- +error: Parser Error: syntax error at or near "{" +== +SELECT v*3::{utype}=7::{utype} FROM vals; +-- +error: Parser Error: syntax error at or near "{" +== +SELECT * FROM vals WHERE v*3::{utype}=6::{utype}; +-- +error: Parser Error: syntax error at or near "{" +== +SELECT v*3::{utype}=6::{utype} FROM vals; +-- +error: Parser Error: syntax error at or near "{" +== +DROP TABLE vals +-- +ok +== diff --git a/parser/testdata/corpus/sql/optimizer/expression/test_negation_limits.test b/parser/testdata/corpus/sql/optimizer/expression/test_negation_limits.test new file mode 100644 index 0000000..75834cb --- /dev/null +++ b/parser/testdata/corpus/sql/optimizer/expression/test_negation_limits.test @@ -0,0 +1,57 @@ +# source: test/sql/optimizer/expression/test_negation_limits.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +CREATE OR REPLACE TABLE vals(id INTEGER, v {type}); +-- +error: Parser Error: syntax error at or near "{" +== +INSERT INTO vals VALUES (0, {min}), (1, {max}), (2, 0), (3, -2), (4, 2); +-- +error: Parser Error: syntax error at or near "}" +== +SELECT -v FROM vals; +-- +ok +== +SELECT -v FROM vals WHERE id>0 +-- +ok +== +SELECT -v FROM vals WHERE id>1 ORDER BY id +-- +ok +== +SELECT -(CAST(-128 AS TINYINT)), typeof(-(CAST(-128 AS TINYINT))) +-- +ok +== +SELECT -(CAST(-32768 AS SMALLINT)), typeof(-(CAST(-32768 AS SMALLINT))) +-- +ok +== +SELECT -(CAST(-2147483648 AS INTEGER)), typeof(-(CAST(-2147483648 AS INTEGER))) +-- +ok +== +SELECT -(CAST(-9223372036854775808 AS BIGINT)), typeof(-(CAST(-9223372036854775808 AS BIGINT))) +-- +ok +== +SELECT -(CAST(-64 AS TINYINT) + CAST(-64 AS TINYINT)), typeof(-(CAST(-64 AS TINYINT) + CAST(-64 AS TINYINT))) +-- +ok +== +SELECT typeof(-(CAST(-100 AS TINYINT))) +-- +ok +== +SELECT -(CAST(-170141183460469231731687303715884105728 AS HUGEINT)) +-- +ok +== +SELECT -v FROM (VALUES (CAST(-128 AS TINYINT))) t(v) +-- +ok +== diff --git a/parser/testdata/corpus/sql/optimizer/expression/test_nop_arithmetic.test b/parser/testdata/corpus/sql/optimizer/expression/test_nop_arithmetic.test new file mode 100644 index 0000000..b804b84 --- /dev/null +++ b/parser/testdata/corpus/sql/optimizer/expression/test_nop_arithmetic.test @@ -0,0 +1,69 @@ +# source: test/sql/optimizer/expression/test_nop_arithmetic.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +SELECT a + 0 FROM test +-- +ok +== +SELECT 0 + a FROM test +-- +ok +== +SELECT a - 0 FROM test +-- +ok +== +SELECT 0 - a FROM test +-- +ok +== +SELECT a * 1 FROM test +-- +ok +== +SELECT 1 * a FROM test +-- +ok +== +SELECT a * 0 FROM test +-- +ok +== +SELECT 0 * a FROM test +-- +ok +== +SELECT a / 1 FROM test +-- +ok +== +SELECT 1 // a FROM test +-- +ok +== +SELECT a // 0 FROM test +-- +ok +== +SELECT 0 // a FROM test +-- +ok +== +UPDATE test SET a=NULL +-- +ok +== +SELECT rowid * 0 FROM test +-- +ok +== +SELECT 0 / a FROM test +-- +ok +== +SELECT 0 / rowid FROM test +-- +ok +== diff --git a/parser/testdata/corpus/sql/optimizer/expression/test_row_comparison_simplification.test b/parser/testdata/corpus/sql/optimizer/expression/test_row_comparison_simplification.test new file mode 100644 index 0000000..1ffa6ab --- /dev/null +++ b/parser/testdata/corpus/sql/optimizer/expression/test_row_comparison_simplification.test @@ -0,0 +1,53 @@ +# source: test/sql/optimizer/expression/test_row_comparison_simplification.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +CREATE TABLE rows(a INTEGER, b INTEGER, c INTEGER, d INTEGER); +-- +ok +== +INSERT INTO rows VALUES + (1, 2, 1, 2), + (1, 2, 1, 3), + (NULL, 2, NULL, 2), + (NULL, 2, NULL, 3), + (NULL, 2, 1, 3), + (1, 2, NULL, 3), + (NULL, 2, 1, 2), + (1, NULL, 1, NULL); +-- +ok +== +SELECT (a, b) = (c, d) FROM rows; +-- +ok +== +SELECT count(*) FROM rows WHERE (a, b) = (c, d); +-- +ok +== +SELECT row() = row(), row(a + 1, b) = row(c + 1, d) FROM rows WHERE a = 1 AND b = 2 AND d = 2; +-- +ok +== +SET disabled_optimizers='expression_rewriter'; +-- +ok +== +EXPLAIN WITH RECURSIVE +edges(here, there) AS ( + VALUES (0, 1), (1, 0) +), +cc(node, comp) USING KEY (node) AS ( + VALUES (0, 0), (1, 1) + UNION ALL + SELECT current.node, changed.comp + FROM cc changed, edges edge, recurring.cc current + WHERE (edge.here, edge.there) = (current.node, changed.node) + AND changed.comp < current.comp +) +SELECT * FROM cc; +-- +ok +== diff --git a/parser/testdata/corpus/sql/optimizer/expression/test_timestamp_offset.test b/parser/testdata/corpus/sql/optimizer/expression/test_timestamp_offset.test new file mode 100644 index 0000000..8e20a69 --- /dev/null +++ b/parser/testdata/corpus/sql/optimizer/expression/test_timestamp_offset.test @@ -0,0 +1,43 @@ +# source: test/sql/optimizer/expression/test_timestamp_offset.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +create or replace table table1 ( + timestamp_str varchar +); +-- +ok +== +insert into table1 values ('2024-05-03 01:00:00'), ('2024-05-03 01:00:02'); +-- +ok +== +select timestamp_str, cast(timestamp_str as timestamp) +from table1 +where cast(timestamp_str as timestamp) > cast('2024-05-03 01:00:00' as timestamp); +-- +ok +== +truncate table table1; +-- +ok +== +insert into table1 values ('2024-05-03T01:00:00+00:00'), ('2024-05-03T01:00:02+00:00'); +-- +ok +== +select timestamp_str, cast(timestamp_str as timestamp) +from table1 +where cast(timestamp_str as timestamp) > cast('2024-05-03T01:00:00+00:00' as timestamp); +-- +ok +== +select * from ( + select timestamp_str, cast(timestamp_str as timestamp) as timestamp_column + from table1 +) +where timestamp_column > cast('2024-05-03 01:00:00' as timestamp); +-- +ok +== diff --git a/parser/testdata/corpus/sql/optimizer/in_list_row_group_pruning.test b/parser/testdata/corpus/sql/optimizer/in_list_row_group_pruning.test new file mode 100644 index 0000000..d7f455d --- /dev/null +++ b/parser/testdata/corpus/sql/optimizer/in_list_row_group_pruning.test @@ -0,0 +1,39 @@ +# source: test/sql/optimizer/in_list_row_group_pruning.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +ATTACH '{TEST_DIR}/in_list_prune.duckdb' AS db (ROW_GROUP_SIZE 2048); +-- +ok +== +CREATE TABLE covered AS SELECT (range % 3 + 1)::INTEGER AS i FROM range(6144); +-- +ok +== +EXPLAIN ANALYZE SELECT count(*) FROM covered WHERE i NOT IN (1, 2, 3); +-- +ok +== +CREATE TABLE mixed AS + SELECT CASE WHEN range < 2048 THEN (range % 3 + 1) ELSE (range % 2 + 4) END::INTEGER AS i + FROM range(6144); +-- +ok +== +SELECT count(*) FROM mixed WHERE i NOT IN (1, 2, 3); +-- +ok +== +EXPLAIN ANALYZE SELECT count(*) FROM mixed WHERE i NOT IN (1, 2, 3); +-- +ok +== +CREATE TABLE doubles AS SELECT unnest([1.0, 1.5, 3.0])::DOUBLE AS i; +-- +ok +== +SELECT count(*) FROM doubles WHERE i NOT IN (1, 2, 3); +-- +ok +== diff --git a/parser/testdata/corpus/sql/optimizer/instr_zonemap_pruning.test b/parser/testdata/corpus/sql/optimizer/instr_zonemap_pruning.test new file mode 100644 index 0000000..25552b4 --- /dev/null +++ b/parser/testdata/corpus/sql/optimizer/instr_zonemap_pruning.test @@ -0,0 +1,46 @@ +# source: test/sql/optimizer/instr_zonemap_pruning.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +CREATE TABLE instr_pruning AS +SELECT CASE WHEN i < 122880 THEN 'aaa' || i::VARCHAR + WHEN i < 245760 THEN 'mmm' || i::VARCHAR + ELSE 'zzz' || i::VARCHAR + END AS s +FROM range(368640) tbl(i); +-- +ok +== +EXPLAIN ANALYZE SELECT count(*) FROM instr_pruning WHERE instr(s, 'mmm') = 1; +-- +ok +== +SELECT count(*) FROM instr_pruning WHERE instr(s, 'mmm') = 1; +-- +ok +== +EXPLAIN ANALYZE SELECT count(*) FROM instr_pruning WHERE instr(s, 'aaa') = 1; +-- +ok +== +SELECT count(*) FROM instr_pruning WHERE instr(s, 'aaa') = 1; +-- +ok +== +EXPLAIN ANALYZE SELECT count(*) FROM instr_pruning WHERE instr(s, 'zzz') = 1; +-- +ok +== +SELECT count(*) FROM instr_pruning WHERE instr(s, 'zzz') = 1; +-- +ok +== +EXPLAIN ANALYZE SELECT count(*) FROM instr_pruning WHERE 1 = instr(s, 'mmm'); +-- +ok +== +EXPLAIN ANALYZE SELECT count(*) FROM instr_pruning WHERE instr(s, 'qqq') = 1; +-- +ok +== diff --git a/parser/testdata/corpus/sql/optimizer/interval_row_group_pruning.test b/parser/testdata/corpus/sql/optimizer/interval_row_group_pruning.test new file mode 100644 index 0000000..95ec88f --- /dev/null +++ b/parser/testdata/corpus/sql/optimizer/interval_row_group_pruning.test @@ -0,0 +1,57 @@ +# source: test/sql/optimizer/interval_row_group_pruning.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +ATTACH ':memory:' AS memory_db; +-- +ok +== +ATTACH '{TEST_DIR}/interval_prune.duckdb' AS db (ROW_GROUP_SIZE 2048, STORAGE_VERSION 'v2.0.0'); +-- +ok +== +CREATE TABLE intervals AS + SELECT range * INTERVAL '1 day' AS iv, range::BIGINT AS i + FROM range(6144); +-- +ok +== +USE memory_db; +-- +ok +== +ATTACH '{TEST_DIR}/interval_prune.duckdb' AS db; +-- +ok +== +SELECT count(*) FROM intervals WHERE iv > INTERVAL '5000 days'; +-- +ok +== +EXPLAIN ANALYZE SELECT sum(i) FROM intervals WHERE iv > INTERVAL '5000 days'; +-- +ok +== +ATTACH '{TEST_DIR}/interval_prune_v1_5.duckdb' AS compat (ROW_GROUP_SIZE 2048, STORAGE_VERSION 'v1.5.3'); +-- +ok +== +CREATE TABLE compat.intervals AS + SELECT range * INTERVAL '1 day' AS iv, range::BIGINT AS i + FROM range(6144); +-- +ok +== +DETACH compat; +-- +ok +== +ATTACH '{TEST_DIR}/interval_prune_v1_5.duckdb' AS compat; +-- +ok +== +SELECT count(*) FROM compat.intervals WHERE iv > INTERVAL '5000 days'; +-- +ok +== diff --git a/parser/testdata/corpus/sql/optimizer/late_materialization_pushdown_extract.test b/parser/testdata/corpus/sql/optimizer/late_materialization_pushdown_extract.test new file mode 100644 index 0000000..c55abfd --- /dev/null +++ b/parser/testdata/corpus/sql/optimizer/late_materialization_pushdown_extract.test @@ -0,0 +1,64 @@ +# source: test/sql/optimizer/late_materialization_pushdown_extract.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +SET late_materialization_max_rows = 100; +-- +ok +== +CREATE TABLE lm_pushdown_extract ( + id INTEGER, + s STRUCT(a INTEGER, b VARCHAR), + x INTEGER +); +-- +ok +== +INSERT INTO lm_pushdown_extract VALUES (1, {'a': 1, 'b': NULL}, 10), (2, {'a': 2, 'b': 'y'}, 20); +-- +ok +== +SELECT s, x FROM lm_pushdown_extract WHERE s.a = 1 ORDER BY id LIMIT 1 +-- +ok +== +SET disabled_optimizers = 'LATE_MATERIALIZATION'; +-- +ok +== +PRAGMA explain_output = OPTIMIZED_ONLY +-- +ok +== +EXPLAIN SELECT s, x FROM lm_pushdown_extract WHERE s.a = 1 ORDER BY id LIMIT 1 +-- +ok +== +CREATE TABLE pushdown_extract_multi ( + s STRUCT(a INTEGER, b INTEGER), + x INTEGER +); +-- +ok +== +INSERT INTO pushdown_extract_multi VALUES (row(1, 11), 10), (row(2, 22), 20); +-- +ok +== +SELECT x FROM pushdown_extract_multi WHERE s.a + s.b = 12 +-- +ok +== +SELECT x FROM pushdown_extract_multi WHERE s.a + s.b = 12 AND s.a = 1 +-- +ok +== +SELECT x FROM pushdown_extract_multi WHERE s.a + x = 11 +-- +ok +== +SELECT x FROM pushdown_extract_multi WHERE s.a + s.b = 12 ORDER BY x LIMIT 1 +-- +ok +== diff --git a/parser/testdata/corpus/sql/optimizer/late_materialization_table_filters.test b/parser/testdata/corpus/sql/optimizer/late_materialization_table_filters.test new file mode 100644 index 0000000..4d53dbc --- /dev/null +++ b/parser/testdata/corpus/sql/optimizer/late_materialization_table_filters.test @@ -0,0 +1,122 @@ +# source: test/sql/optimizer/late_materialization_table_filters.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +CREATE TABLE lm_test ( + id INTEGER, + grp INTEGER, + ts TIMESTAMP, + payload1 VARCHAR, + payload2 VARCHAR, + payload3 VARCHAR, + payload4 VARCHAR, + payload5 VARCHAR +); +-- +ok +== +INSERT INTO lm_test +SELECT + i AS id, + (i % 100) + 1 AS grp, + TIMESTAMP '2024-01-01' + INTERVAL (i * 60) SECOND AS ts, + md5(i::VARCHAR || 'p1') AS payload1, + md5(i::VARCHAR || 'p2') AS payload2, + md5(i::VARCHAR || 'p3') AS payload3, + md5(i::VARCHAR || 'p4') AS payload4, + md5(i::VARCHAR || 'p5') AS payload5 +FROM generate_series(1, 100000) t(i); +-- +ok +== +SELECT count(*) FROM lm_test WHERE grp = 1 +-- +ok +== +SELECT count(*) FROM ( + SELECT id, grp, ts, payload1, payload2, payload3, payload4, payload5 + FROM lm_test + WHERE grp = 1 + AND ts >= TIMESTAMP '2024-01-01' + AND ts < TIMESTAMP '2024-07-01' + ORDER BY ts + LIMIT 20 +) sub +-- +ok +== +EXPLAIN +SELECT id, grp, ts, payload1, payload2, payload3, payload4, payload5 +FROM lm_test +WHERE grp = 1 + AND ts >= TIMESTAMP '2024-01-01' + AND ts < TIMESTAMP '2024-07-01' +ORDER BY ts +LIMIT 20; +-- +ok +== +SELECT id, grp, ts +FROM lm_test +WHERE grp = 1 + AND ts >= TIMESTAMP '2024-01-01' + AND ts < TIMESTAMP '2024-07-01' +ORDER BY ts +LIMIT 3 +-- +ok +== +SET late_materialization_max_rows = 0; +-- +ok +== +SELECT payload1 = md5(id::VARCHAR || 'p1') +FROM lm_test +WHERE grp = 1 + AND ts >= TIMESTAMP '2024-01-01' + AND ts < TIMESTAMP '2024-07-01' +ORDER BY ts +LIMIT 1 +-- +ok +== +EXPLAIN SELECT id, grp, ts, payload1, payload2, payload3, payload4, payload5 +FROM lm_test ORDER BY ts LIMIT 3; +-- +ok +== +SELECT id, grp, ts +FROM lm_test ORDER BY ts LIMIT 3 +-- +ok +== +EXPLAIN SELECT id, grp, ts, payload1 +FROM lm_test WHERE grp = 1 ORDER BY ts LIMIT 3; +-- +ok +== +SELECT id, grp, ts +FROM lm_test WHERE grp = 1 ORDER BY ts LIMIT 3 +-- +ok +== +SELECT id, grp, ts +FROM lm_test WHERE ts >= TIMESTAMP '2024-03-01' ORDER BY ts LIMIT 3 +-- +ok +== +EXPLAIN SELECT id, grp, ts, payload1 +FROM lm_test WHERE grp = 1 AND ts >= TIMESTAMP '2024-03-01' ORDER BY ts LIMIT 3; +-- +ok +== +SELECT id, grp, ts +FROM lm_test WHERE grp = 1 AND ts >= TIMESTAMP '2024-03-01' ORDER BY ts LIMIT 3 +-- +ok +== +DROP TABLE lm_test; +-- +ok +== diff --git a/parser/testdata/corpus/sql/optimizer/monotone_function_zonemap_pruning.test b/parser/testdata/corpus/sql/optimizer/monotone_function_zonemap_pruning.test new file mode 100644 index 0000000..aca746f --- /dev/null +++ b/parser/testdata/corpus/sql/optimizer/monotone_function_zonemap_pruning.test @@ -0,0 +1,100 @@ +# source: test/sql/optimizer/monotone_function_zonemap_pruning.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +CREATE TABLE t AS SELECT range::INTEGER AS x FROM range(500000); +-- +ok +== +EXPLAIN ANALYZE SELECT count(*) FROM t WHERE floor(x::DOUBLE) > 495000; +-- +ok +== +SELECT count(*) FROM t WHERE floor(x::DOUBLE) > 495000; +-- +ok +== +EXPLAIN ANALYZE SELECT count(*) FROM t WHERE floor(x::DOUBLE) < 5000; +-- +ok +== +SELECT count(*) FROM t WHERE floor(x::DOUBLE) < 5000; +-- +ok +== +EXPLAIN ANALYZE SELECT sum(x) FROM t WHERE floor(x::DOUBLE) >= 245760; +-- +ok +== +EXPLAIN ANALYZE SELECT count(*) FROM t WHERE floor(x::DOUBLE) BETWEEN 245760 AND 249999; +-- +ok +== +SELECT count(*) FROM t WHERE floor(x::DOUBLE) BETWEEN 245760 AND 249999; +-- +ok +== +SELECT count(*) FROM t WHERE floor(x::DOUBLE) BETWEEN 600000 AND 700000; +-- +ok +== +CREATE TABLE d AS SELECT (DATE '1970-01-01' + INTERVAL (range) DAY)::DATE AS dt FROM range(500000); +-- +ok +== +EXPLAIN ANALYZE SELECT count(*) FROM d WHERE year(dt) < 1971; +-- +ok +== +SELECT count(*) FROM d WHERE year(dt) < 1971; +-- +ok +== +SELECT count(*) FROM d WHERE year(dt) BETWEEN 1975 AND 1976; +-- +ok +== +CREATE TABLE monotone_math AS +SELECT CASE + WHEN i < 122880 THEN 0.0 + ELSE 10.0 + END::DOUBLE AS x +FROM range(245760) tbl(i); +-- +ok +== +SELECT count(*), sum(x) +FROM monotone_math +WHERE atan(x) > 1; +-- +ok +== +EXPLAIN ANALYZE +SELECT sum(x) +FROM monotone_math +WHERE atan(x) > 1; +-- +ok +== +EXPLAIN ANALYZE +SELECT sum(x) +FROM monotone_math +WHERE sinh(x) > 1; +-- +ok +== +EXPLAIN ANALYZE +SELECT sum(x) +FROM monotone_math +WHERE asinh(x) > 1; +-- +ok +== +EXPLAIN ANALYZE +SELECT sum(x) +FROM monotone_math +WHERE tanh(x) > 0.5; +-- +ok +== diff --git a/parser/testdata/corpus/sql/optimizer/monotone_preimage.test b/parser/testdata/corpus/sql/optimizer/monotone_preimage.test new file mode 100644 index 0000000..1f6ee7b --- /dev/null +++ b/parser/testdata/corpus/sql/optimizer/monotone_preimage.test @@ -0,0 +1,121 @@ +# source: test/sql/optimizer/monotone_preimage.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +EXPLAIN SELECT count(*) FROM d WHERE year(dt) = 2020; +-- +ok +== +EXPLAIN SELECT count(*) FROM d WHERE year(dt) < 1975; +-- +ok +== +EXPLAIN SELECT count(*) FROM d WHERE year(dt) >= 2020; +-- +ok +== +EXPLAIN ANALYZE SELECT count(*) FROM d WHERE year(dt) = 2020; +-- +ok +== +EXPLAIN SELECT count(*) FROM d WHERE month(dt) = 6; +-- +ok +== +CREATE TABLE e(dt DATE); +-- +ok +== +INSERT INTO e VALUES ('2020-06-15'), ('2019-01-01'), ('2021-12-31'), ('infinity'), ('-infinity'), (NULL); +-- +ok +== +SELECT count(*) FROM e WHERE year(dt) = 2020; +-- +ok +== +SELECT count(*) FROM e WHERE year(dt) > 2020; +-- +ok +== +SELECT count(*) FROM e WHERE year(dt) < 2020; +-- +ok +== +SELECT count(*) FROM e WHERE year(dt) >= 2020; +-- +ok +== +SELECT count(*) FROM e WHERE year(dt) <= 2020; +-- +ok +== +SELECT year(dt) = 2020 FROM e ORDER BY dt NULLS LAST; +-- +ok +== +SELECT count(*) FROM e WHERE (year(dt) = 2020) IS FALSE; +-- +ok +== +CREATE TABLE ints(x INTEGER); +-- +ok +== +INSERT INTO ints VALUES (1), (2), (3), (NULL); +-- +ok +== +CREATE TABLE big AS + SELECT (DATE '1900-01-01' + INTERVAL (range) DAY)::DATE AS dt FROM range(200000) + UNION ALL SELECT 'infinity'::DATE UNION ALL SELECT '-infinity'::DATE UNION ALL SELECT NULL::DATE; +-- +ok +== +SELECT count(*) FROM ( + SELECT 1 FROM big WHERE year(dt) > 2000 + EXCEPT ALL SELECT 1 FROM (SELECT dt FROM big OFFSET 0) WHERE year(dt) > 2000 +); +-- +ok +== +SELECT count(*) FROM ( + SELECT 1 FROM (SELECT dt FROM big OFFSET 0) WHERE year(dt) > 2000 + EXCEPT ALL SELECT 1 FROM big WHERE year(dt) > 2000 +); +-- +ok +== +CREATE TABLE ts AS SELECT ('2020-01-01'::TIMESTAMP + INTERVAL (range) MINUTE) AS t FROM range(1000000); +-- +ok +== +EXPLAIN SELECT count(*) FROM ts WHERE year(t) = 2020; +-- +ok +== +CREATE TABLE ets AS + SELECT ('2000-01-01'::TIMESTAMP + INTERVAL (range) HOUR) AS t FROM range(200000) + UNION ALL SELECT 'infinity'::TIMESTAMP UNION ALL SELECT '-infinity'::TIMESTAMP UNION ALL SELECT NULL::TIMESTAMP; +-- +ok +== +SELECT count(*) FROM ( + SELECT 1 FROM ets WHERE year(t) > 2010 + EXCEPT ALL SELECT 1 FROM (SELECT t FROM ets OFFSET 0) WHERE year(t) > 2010 +); +-- +ok +== +SELECT count(*) FROM ( + SELECT 1 FROM (SELECT t FROM ets OFFSET 0) WHERE year(t) > 2010 + EXCEPT ALL SELECT 1 FROM ets WHERE year(t) > 2010 +); +-- +ok +== +SELECT count(*) FROM ets WHERE year(t) = 2005; +-- +ok +== diff --git a/parser/testdata/corpus/sql/optimizer/nested_null_segment_pruning.test b/parser/testdata/corpus/sql/optimizer/nested_null_segment_pruning.test new file mode 100644 index 0000000..b278cf3 --- /dev/null +++ b/parser/testdata/corpus/sql/optimizer/nested_null_segment_pruning.test @@ -0,0 +1,44 @@ +# source: test/sql/optimizer/nested_null_segment_pruning.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +CREATE TABLE nested_nulls AS +SELECT CASE WHEN i >= 99999 THEN NULL ELSE {'v': i} END AS s, + CASE WHEN i >= 99999 THEN NULL ELSE [i] END AS l +FROM range(100000) t(i) +-- +ok +== +CREATE TABLE array_nulls AS +SELECT [i, i, i]::INTEGER[3] AS a +FROM range(99999) t(i) +-- +ok +== +INSERT INTO array_nulls VALUES (NULL) +-- +ok +== +SELECT (SELECT count(*) FROM nested_nulls WHERE l IS NULL), + (SELECT count(*) FROM array_nulls WHERE a IS NULL) +-- +ok +== +PRAGMA profiling_output = '{TEST_DIR}/nested_null_profile.json' +-- +error: Parser Error: Profiler file type ({TEST_DIR}/nested_null_profile.json) must either have the same file extension as the profiling output type (query_tree), or be a '.txt' file. Set "enable_profiling = 'json'" first. +== +SET tracked_metrics = ['query.total_rows_scanned'] +-- +ok +== +SELECT count(*) FROM nested_nulls WHERE s IS NULL +-- +ok +== +SELECT query.total_rows_scanned +FROM '{TEST_DIR}/nested_null_profile.json' +-- +ok +== diff --git a/parser/testdata/corpus/sql/optimizer/nested_null_segment_pruning.test.metadata.json b/parser/testdata/corpus/sql/optimizer/nested_null_segment_pruning.test.metadata.json new file mode 100644 index 0000000..9fe17fa --- /dev/null +++ b/parser/testdata/corpus/sql/optimizer/nested_null_segment_pruning.test.metadata.json @@ -0,0 +1,5 @@ +{ + "todo": { + "7830ebec5e2d8f76": "transformer-raised parser error: upstream rejects in the transformer, not the grammar; expected to clear as transformers land (milestones 3-5)" + } +} diff --git a/parser/testdata/corpus/sql/optimizer/not_conjunction_simplification.test b/parser/testdata/corpus/sql/optimizer/not_conjunction_simplification.test new file mode 100644 index 0000000..92f5c0e --- /dev/null +++ b/parser/testdata/corpus/sql/optimizer/not_conjunction_simplification.test @@ -0,0 +1,79 @@ +# source: test/sql/optimizer/not_conjunction_simplification.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +CREATE TABLE t AS SELECT range AS i FROM range(1000000); +-- +ok +== +EXPLAIN SELECT count() FROM t WHERE i NOT BETWEEN 10 AND 999989; +-- +ok +== +EXPLAIN ANALYZE SELECT count() FROM t WHERE i NOT BETWEEN 10 AND 999989; +-- +ok +== +SELECT count() FROM t WHERE i NOT BETWEEN 10 AND 999989; +-- +ok +== +EXPLAIN ANALYZE SELECT count() FROM t WHERE NOT (i >= 10 AND i <= 999989); +-- +ok +== +SELECT count() FROM t WHERE NOT (i >= 10 AND i <= 999989); +-- +ok +== +EXPLAIN ANALYZE SELECT count() FROM t WHERE NOT (i < 400000 OR i > 600000); +-- +ok +== +SELECT count() FROM t WHERE NOT (i < 400000 OR i > 600000); +-- +ok +== +SELECT NOT (a AND b), (NOT a) OR (NOT b) +FROM (VALUES (1, NULL::BOOLEAN, TRUE), + (2, NULL::BOOLEAN, FALSE), + (3, TRUE, NULL::BOOLEAN), + (4, FALSE, NULL::BOOLEAN)) v(id, a, b) +ORDER BY id; +-- +ok +== +SELECT NOT (a OR b), (NOT a) AND (NOT b) +FROM (VALUES (1, NULL::BOOLEAN, TRUE), + (2, NULL::BOOLEAN, FALSE), + (3, TRUE, NULL::BOOLEAN), + (4, FALSE, NULL::BOOLEAN)) v(id, a, b) +ORDER BY id; +-- +ok +== +CREATE TABLE volatile_t(a BOOLEAN); +-- +ok +== +INSERT INTO volatile_t VALUES (false), (true); +-- +ok +== +SELECT count(*) FROM volatile_t WHERE NOT (a AND nextval('s') > 0); +-- +ok +== +CREATE TABLE throwing_t(a BOOLEAN); +-- +ok +== +INSERT INTO throwing_t VALUES (false); +-- +ok +== +SELECT count(*) FROM throwing_t WHERE NOT (a AND error('expected')); +-- +ok +== diff --git a/parser/testdata/corpus/sql/optimizer/nullable_row_group_pruning.test b/parser/testdata/corpus/sql/optimizer/nullable_row_group_pruning.test new file mode 100644 index 0000000..3aa7500 --- /dev/null +++ b/parser/testdata/corpus/sql/optimizer/nullable_row_group_pruning.test @@ -0,0 +1,93 @@ +# source: test/sql/optimizer/nullable_row_group_pruning.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +ATTACH '{TEST_DIR}/nullable_prune.duckdb' AS db (ROW_GROUP_SIZE 2048); +-- +ok +== +CREATE TABLE integers AS + SELECT CASE WHEN range % 2048 = 0 THEN NULL ELSE range::INTEGER END AS i + FROM range(6144); +-- +ok +== +SELECT sum(i) FROM integers WHERE i = 3000; +-- +ok +== +EXPLAIN ANALYZE SELECT sum(i) FROM integers WHERE i = 3000; +-- +ok +== +SELECT sum(i) FROM integers WHERE i < 1000; +-- +ok +== +EXPLAIN ANALYZE SELECT sum(i) FROM integers WHERE i < 1000; +-- +ok +== +SELECT sum(i) FROM integers WHERE i BETWEEN 2900 AND 3100; +-- +ok +== +EXPLAIN ANALYZE SELECT sum(i) FROM integers WHERE i BETWEEN 2900 AND 3100; +-- +ok +== +SELECT sum(i) FROM integers WHERE i IS DISTINCT FROM 3000; +-- +ok +== +EXPLAIN ANALYZE SELECT sum(i) FROM integers WHERE i IS DISTINCT FROM 3000; +-- +ok +== +CREATE TABLE strings AS + SELECT CASE WHEN range % 2048 = 0 THEN NULL ELSE lpad(range::VARCHAR, 5, '0') END AS s + FROM range(6144); +-- +ok +== +SELECT sum(length(s)) FROM strings WHERE s = '03000'; +-- +ok +== +EXPLAIN ANALYZE SELECT sum(length(s)) FROM strings WHERE s = '03000'; +-- +ok +== +SELECT sum(length(s)) FROM strings WHERE s BETWEEN '02900' AND '03100'; +-- +ok +== +EXPLAIN ANALYZE SELECT sum(length(s)) FROM strings WHERE s BETWEEN '02900' AND '03100'; +-- +ok +== +CREATE TABLE not_null_integers(i INTEGER NOT NULL); +-- +ok +== +INSERT INTO not_null_integers SELECT range::INTEGER FROM range(6144); +-- +ok +== +SELECT count(*) FROM not_null_integers WHERE i IS NOT DISTINCT FROM NULL; +-- +ok +== +EXPLAIN ANALYZE SELECT count(*) FROM not_null_integers WHERE i IS NOT DISTINCT FROM NULL; +-- +ok +== +SELECT count(*) FROM not_null_integers WHERE NULL IS NOT DISTINCT FROM i; +-- +ok +== +EXPLAIN ANALYZE SELECT count(*) FROM not_null_integers WHERE NULL IS NOT DISTINCT FROM i; +-- +ok +== diff --git a/parser/testdata/corpus/sql/optimizer/plan/plan_struct_projection_pushdown.test b/parser/testdata/corpus/sql/optimizer/plan/plan_struct_projection_pushdown.test new file mode 100644 index 0000000..478c374 --- /dev/null +++ b/parser/testdata/corpus/sql/optimizer/plan/plan_struct_projection_pushdown.test @@ -0,0 +1,85 @@ +# source: test/sql/optimizer/plan/plan_struct_projection_pushdown.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +CREATE TABLE struct_pushdown_test(id INT, struct_col STRUCT(sub_col1 integer, sub_col2 bool)); +-- +ok +== +INSERT INTO struct_pushdown_test VALUES (1, {'sub_col1': 42, 'sub_col2': true}), (2, NULL), (3, {'sub_col1': 84, 'sub_col2': NULL}), (4, {'sub_col1': NULL, 'sub_col2': false}); +-- +ok +== +COPY struct_pushdown_test TO '{TEST_DIR}/struct_pushdown_test.parquet' +-- +ok +== +EXPLAIN SELECT struct_col.sub_col2 FROM {source}; +-- +error: Parser Error: syntax error at or near "{" +== +EXPLAIN SELECT struct_col.sub_col1 FROM {source}; +-- +error: Parser Error: syntax error at or near "{" +== +EXPLAIN SELECT struct_col.sub_col1, struct_col.sub_col2 FROM {source}; +-- +error: Parser Error: syntax error at or near "{" +== +EXPLAIN SELECT struct_col.sub_col1, struct_col FROM {source}; +-- +error: Parser Error: syntax error at or near "{" +== +CREATE TABLE nested_struct_pushdown_test(id INT, struct_col STRUCT(name STRUCT(v VARCHAR, id INT), nested_struct STRUCT(a integer, b bool))); +-- +ok +== +INSERT INTO nested_struct_pushdown_test +VALUES (1, {'name': {'v': 'Row 1', 'id': 1}, 'nested_struct': {'a': 42, 'b': true}}), + (2, NULL), + (3, {'name': {'v': 'Row 3', 'id': 3}, 'nested_struct': {'a': 84, 'b': NULL}}), + (4, {'name': NULL, 'nested_struct': {'a': NULL, 'b': false}}); +-- +ok +== +COPY nested_struct_pushdown_test TO '{TEST_DIR}/nested_struct_pushdown_test.parquet' +-- +ok +== +EXPLAIN SELECT struct_col.name.id FROM {source}; +-- +error: Parser Error: syntax error at or near "{" +== +EXPLAIN SELECT struct_col.name.id, struct_col.name FROM {source}; +-- +error: Parser Error: syntax error at or near "{" +== +EXPLAIN SELECT struct_col.name.id, struct_col FROM {source}; +-- +error: Parser Error: syntax error at or near "{" +== +CREATE OR REPLACE TABLE nested_struct_pushdown_test(id INT, struct_col STRUCT(s STRUCT(name STRUCT(v VARCHAR, id INT), nested_struct STRUCT(a integer, b bool)))); +-- +ok +== +INSERT INTO nested_struct_pushdown_test +VALUES (1, {'s': {'name': {'v': 'Row 1', 'id': 1}, 'nested_struct': {'a': 42, 'b': true}}}), + (2, NULL), + (3, {'s': {'name': {'v': 'Row 3', 'id': 3}, 'nested_struct': {'a': 84, 'b': NULL}}}), + (4, {'s': {'name': NULL, 'nested_struct': {'a': NULL, 'b': false}}}); +-- +ok +== +EXPLAIN SELECT struct_col.s.name.id FROM {source}; +-- +error: Parser Error: syntax error at or near "{" +== +EXPLAIN SELECT struct_col.s.name.id, struct_col.s.name FROM {source}; +-- +error: Parser Error: syntax error at or near "{" +== +EXPLAIN SELECT struct_col.s.name.id, struct_col FROM {source}; +-- +error: Parser Error: syntax error at or near "{" +== diff --git a/parser/testdata/corpus/sql/optimizer/plan/test_anti_join_empty_child.test b/parser/testdata/corpus/sql/optimizer/plan/test_anti_join_empty_child.test new file mode 100644 index 0000000..fee0437 --- /dev/null +++ b/parser/testdata/corpus/sql/optimizer/plan/test_anti_join_empty_child.test @@ -0,0 +1,17 @@ +# source: test/sql/optimizer/plan/test_anti_join_empty_child.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +pragma explain_output='OPTIMIZED_ONLY' +-- +ok +== +SELECT lhs.id FROM (SELECT 1 id) lhs ANTI JOIN (SELECT 1 id WHERE FALSE) rhs ON lhs.id = rhs.id +-- +ok +== +EXPLAIN SELECT lhs.id FROM (SELECT 1 id) lhs ANTI JOIN (SELECT 1 id WHERE FALSE) rhs ON lhs.id = rhs.id +-- +ok +== diff --git a/parser/testdata/corpus/sql/optimizer/plan/test_disable_build_side_probe_side.test b/parser/testdata/corpus/sql/optimizer/plan/test_disable_build_side_probe_side.test new file mode 100644 index 0000000..05a2189 --- /dev/null +++ b/parser/testdata/corpus/sql/optimizer/plan/test_disable_build_side_probe_side.test @@ -0,0 +1,9 @@ +# source: test/sql/optimizer/plan/test_disable_build_side_probe_side.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +explain from range(10) r1 right join range(10) r2 using (range) +-- +ok +== diff --git a/parser/testdata/corpus/sql/optimizer/plan/test_equivalent_filter_mirroring.test b/parser/testdata/corpus/sql/optimizer/plan/test_equivalent_filter_mirroring.test new file mode 100644 index 0000000..d6ebdeb --- /dev/null +++ b/parser/testdata/corpus/sql/optimizer/plan/test_equivalent_filter_mirroring.test @@ -0,0 +1,51 @@ +# source: test/sql/optimizer/plan/test_equivalent_filter_mirroring.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +CREATE TABLE tmp AS SELECT * FROM range(1000); +-- +ok +== +EXPLAIN +SELECT * +FROM tmp AS t1 +NATURAL JOIN tmp AS t2 +WHERE t1.range * t1.range = 0 +-- +ok +== +CREATE TABLE t (f VARCHAR); +-- +ok +== +INSERT INTO t (f) VALUES ('42'), ('43'); +-- +ok +== +explain SELECT * +FROM t AS t1 +JOIN t AS t2 on t1.f = t2.f +WHERE right(t1.f, 1) = '2' +-- +ok +== +explain SELECT * +FROM t AS t1 +LEFT JOIN t AS t2 on t1.f = t2.f +WHERE right(t1.f, 1) = '2' +-- +ok +== +CREATE TABLE tbl(x INTEGER); +-- +ok +== +INSERT INTO tbl VALUES (1), (2), (3); +-- +ok +== +EXPLAIN SELECT * FROM tbl n1 JOIN tbl n2 ON n1.x = n2.x WHERE n1.x + (random() * 0)::INTEGER = 1; +-- +ok +== diff --git a/parser/testdata/corpus/sql/optimizer/plan/test_except_empty_rhs.test b/parser/testdata/corpus/sql/optimizer/plan/test_except_empty_rhs.test new file mode 100644 index 0000000..e4507c1 --- /dev/null +++ b/parser/testdata/corpus/sql/optimizer/plan/test_except_empty_rhs.test @@ -0,0 +1,21 @@ +# source: test/sql/optimizer/plan/test_except_empty_rhs.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +SELECT * FROM (SELECT 1) lhs +EXCEPT +SELECT * FROM (SELECT 1 WHERE 1=0) rhs +-- +ok +== +EXPLAIN SELECT * FROM (SELECT 1) lhs +EXCEPT +SELECT * FROM (SELECT 1 WHERE 1=0) rhs +-- +ok +== +SELECT * FROM (SELECT 42 EXCEPT SELECT 43) tbl(i) WHERE i = 42 +-- +ok +== diff --git a/parser/testdata/corpus/sql/optimizer/plan/test_filter_pushdown.test b/parser/testdata/corpus/sql/optimizer/plan/test_filter_pushdown.test new file mode 100644 index 0000000..e46c4c7 --- /dev/null +++ b/parser/testdata/corpus/sql/optimizer/plan/test_filter_pushdown.test @@ -0,0 +1,162 @@ +# source: test/sql/optimizer/plan/test_filter_pushdown.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +SELECT * FROM integers i1, integers i2 WHERE i1.i=i2.i ORDER BY 1 +-- +ok +== +SELECT * FROM integers i1, integers i2 WHERE i1.i=i2.i AND i1.i>1 ORDER BY 1 +-- +ok +== +SELECT * FROM integers i1, integers i2, integers i3 WHERE i1.i=i2.i AND i1.i=i3.i AND i1.i>1 ORDER BY 1 +-- +ok +== +SELECT * FROM integers i1 JOIN integers i2 ON i1.i=i2.i WHERE i1.i>1 ORDER BY 1 +-- +ok +== +SELECT * FROM integers i1 LEFT OUTER JOIN integers i2 ON 1=1 WHERE i1.i>2 ORDER BY 2 +-- +ok +== +SELECT * FROM integers i1 LEFT OUTER JOIN integers i2 ON 1=0 WHERE i2.i IS NOT NULL ORDER BY 2 +-- +ok +== +SELECT * FROM integers i1 LEFT OUTER JOIN integers i2 ON 1=0 WHERE i2.i>1 ORDER BY 2 +-- +ok +== +SELECT * FROM integers i1 LEFT OUTER JOIN integers i2 ON 1=0 WHERE CASE WHEN i2.i IS NULL THEN False ELSE True END ORDER BY 2 +-- +ok +== +SELECT DISTINCT * FROM integers i1 LEFT OUTER JOIN integers i2 ON 1=0 WHERE i2.i IS NULL ORDER BY 1 +-- +ok +== +SELECT * FROM integers i1 LEFT OUTER JOIN integers i2 ON 1=1 WHERE i1.i=i2.i ORDER BY 1 +-- +ok +== +SELECT * FROM integers WHERE i IN ((SELECT * FROM integers)) ORDER BY i +-- +ok +== +SELECT * FROM integers WHERE i NOT IN ((SELECT * FROM integers WHERE i=1)) ORDER BY i +-- +ok +== +SELECT * FROM integers WHERE i IN ((SELECT * FROM integers)) AND i<3 ORDER BY i +-- +ok +== +SELECT * FROM integers i1, integers i2 WHERE i1.i IN ((SELECT * FROM integers)) AND i1.i=i2.i ORDER BY 1 +-- +ok +== +SELECT * FROM integers i1 WHERE EXISTS(SELECT i FROM integers WHERE i=i1.i) ORDER BY i1.i +-- +ok +== +SELECT * FROM integers i1 WHERE NOT EXISTS(SELECT i FROM integers WHERE i=i1.i) ORDER BY i1.i +-- +ok +== +SELECT * FROM integers i1, integers i2 WHERE i1.i=(SELECT i FROM integers WHERE i1.i=i) AND i1.i=i2.i ORDER BY i1.i +-- +ok +== +SELECT * FROM (SELECT i1.i AS a, i2.i AS b FROM integers i1, integers i2) a1 WHERE a=b ORDER BY 1 +-- +ok +== +SELECT * FROM (SELECT i1.i=i2.i AS cond FROM integers i1, integers i2) a1 WHERE cond ORDER BY 1 +-- +ok +== +SELECT * FROM (SELECT DISTINCT i1.i AS a, i2.i AS b FROM integers i1, integers i2) res WHERE a=1 AND b=3; +-- +ok +== +SELECT * FROM (SELECT * FROM integers i1 UNION SELECT * FROM integers i2) a WHERE i=3; +-- +ok +== +SELECT * FROM (SELECT i1.i AS a, i2.i AS b, row_number() OVER (ORDER BY i1.i, i2.i) FROM integers i1, integers i2 WHERE i1.i IS NOT NULL AND i2.i IS NOT NULL) a1 WHERE a=b ORDER BY 1 +-- +ok +== +SELECT * FROM (SELECT 0=1 AS cond FROM integers i1, integers i2) a1 WHERE cond ORDER BY 1 +-- +ok +== +SELECT * FROM (SELECT 0=1 AS cond FROM integers i1, integers i2 GROUP BY 1) a1 WHERE cond ORDER BY 1 +-- +ok +== +CREATE TABLE cohort ( + person_id INTEGER, + cohort_start_date DATE, + cohort_end_date DATE +); +-- +ok +== +INSERT INTO cohort (person_id, cohort_start_date, cohort_end_date) VALUES + (1, DATE '2021-01-01', DATE '2021-02-15'), + (1, DATE '2021-01-01', NULL); +-- +ok +== +CREATE TABLE obs ( + person_id INTEGER, + observation_period_start_date DATE +); +-- +ok +== +INSERT INTO obs (person_id, observation_period_start_date) VALUES + (1, DATE '2010-01-01'), + (2, DATE '2010-01-01'); +-- +ok +== +SELECT q01.* +FROM ( + SELECT LHS.*, observation_period_start_date + FROM ( + SELECT q01.* + FROM ( + SELECT + person_id, + cohort_start_date, + COALESCE(cohort_end_date, cohort_start_date) AS cohort_end_date + FROM cohort + ) q01 + WHERE (cohort_start_date <= cohort_end_date) + ) LHS + INNER JOIN obs + ON (LHS.person_id = obs.person_id) +) q01 +WHERE (cohort_end_date >= observation_period_start_date) +ORDER BY ALL; +-- +ok +== +CREATE TABLE t0(c0 VARCHAR(500)); +-- +ok +== +INSERT INTO t0(c0) VALUES ('2'); +-- +ok +== +SELECT * FROM t0 WHERE (t0.c0<(ALIAS(t0.c0))); +-- +ok +== diff --git a/parser/testdata/corpus/sql/optimizer/plan/test_filter_pushdown_duplicate.test b/parser/testdata/corpus/sql/optimizer/plan/test_filter_pushdown_duplicate.test new file mode 100644 index 0000000..446664c --- /dev/null +++ b/parser/testdata/corpus/sql/optimizer/plan/test_filter_pushdown_duplicate.test @@ -0,0 +1,13 @@ +# source: test/sql/optimizer/plan/test_filter_pushdown_duplicate.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +CREATE TABLE vals1 AS SELECT i AS i, i AS j FROM range(0, 10000, 1) t1(i) +-- +ok +== +CREATE TABLE vals2(k INTEGER, l INTEGER) +-- +ok +== diff --git a/parser/testdata/corpus/sql/optimizer/plan/test_filter_pushdown_large.test b/parser/testdata/corpus/sql/optimizer/plan/test_filter_pushdown_large.test new file mode 100644 index 0000000..03e5496 --- /dev/null +++ b/parser/testdata/corpus/sql/optimizer/plan/test_filter_pushdown_large.test @@ -0,0 +1,113 @@ +# source: test/sql/optimizer/plan/test_filter_pushdown_large.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +SELECT i, k FROM (SELECT i, k FROM vals1, vals2) tbl1 WHERE i=k AND i<5 ORDER BY i +-- +ok +== +SELECT i, k FROM (SELECT DISTINCT i, k FROM vals1, vals2) tbl1 WHERE i=k AND i<5 ORDER BY i +-- +ok +== +SELECT i, k, SUM(j) FROM vals1, vals2 GROUP BY i, k HAVING i=k AND i<5 ORDER BY i +-- +ok +== +SELECT i, k, SUM(j) FROM (SELECT * FROM vals1, vals2) tbl1 GROUP BY i, k HAVING i=k AND i<5 ORDER BY i +-- +ok +== +SELECT i, k, sum FROM (SELECT i, k, SUM(j) AS sum FROM vals1, vals2 GROUP BY i, k) tbl1 WHERE i=k AND i<5 ORDER BY i; +-- +ok +== +SELECT * FROM vals1 LEFT OUTER JOIN vals2 ON 1=1 WHERE i=k AND k=5 +-- +ok +== +SELECT * FROM vals1 LEFT OUTER JOIN vals2 ON 1=1 WHERE i=k ORDER BY i LIMIT 5 +-- +ok +== +SELECT * FROM (SELECT * FROM vals1, vals2 WHERE j=5 AND l=5) tbl1 LEFT OUTER JOIN (SELECT * FROM vals1, vals2) tbl2 ON tbl1.i=tbl2.i AND tbl1.k=tbl2.k WHERE tbl2.j=5 AND tbl2.l=5; +-- +ok +== +SELECT * FROM (SELECT * FROM vals1, vals2) tbl1 LEFT OUTER JOIN (SELECT * FROM vals1, vals2 WHERE i=5 AND k=10) tbl2 ON tbl1.i=tbl2.i AND tbl1.k=tbl2.k WHERE tbl1.i=5 AND tbl1.k=10 +-- +ok +== +SELECT * FROM (SELECT * FROM vals1, vals2 WHERE i=5 AND k=5) tbl1 LEFT OUTER JOIN (SELECT * FROM vals1, vals2) tbl2 ON tbl2.i=5 AND tbl2.k=5 +-- +ok +== +SELECT * FROM (SELECT * FROM vals1, vals2 WHERE i=5 AND k=5) tbl1 LEFT OUTER JOIN (SELECT * FROM vals1, vals2) tbl2 ON tbl2.i>10000 AND tbl2.k=5 +-- +ok +== +SELECT * FROM (SELECT * FROM vals1, vals2) tbl1 LEFT OUTER JOIN (SELECT * FROM vals1, vals2) tbl2 ON tbl1.i=tbl2.i AND tbl1.k=tbl2.k WHERE tbl1.i=5 AND tbl1.k=10 +-- +ok +== +SELECT * FROM (SELECT * FROM vals1, vals2) tbl1 LEFT OUTER JOIN (SELECT * FROM vals1, vals2) tbl2 ON tbl1.i=tbl2.i AND tbl1.k=tbl2.k WHERE tbl1.i>4 AND tbl1.i<6 AND tbl1.k=10 +-- +ok +== +SELECT * FROM (SELECT * FROM vals1, vals2 UNION SELECT * FROM vals1, vals2) tbl1 WHERE i=3 AND k=5 +-- +ok +== +SELECT * FROM (SELECT * FROM vals1, vals2 EXCEPT SELECT * FROM vals1, vals2) tbl1 WHERE i=3 AND k=5 +-- +ok +== +SELECT * FROM (SELECT * FROM vals1, vals2 EXCEPT SELECT * FROM vals1, vals2 WHERE i<>1) tbl1 WHERE i<5 AND k<5 ORDER BY 1, 2, 3, 4; +-- +ok +== +SELECT * FROM (SELECT * FROM vals1, vals2 INTERSECT SELECT * FROM vals1, vals2) tbl1 WHERE i=3 AND k=5 +-- +ok +== +SELECT * FROM (SELECT 0=1 AS cond FROM vals1, vals2) a1 WHERE cond ORDER BY 1 +-- +ok +== +SELECT * FROM (SELECT 1 AS a FROM vals1, vals2) a1 WHERE a=0 ORDER BY 1 +-- +ok +== +SELECT * FROM (SELECT 0=1 AS cond FROM vals1, vals2 GROUP BY 1) a1 WHERE cond ORDER BY 1 +-- +ok +== +SELECT * FROM (SELECT 1 AS a FROM vals1, vals2 GROUP BY a) a1 WHERE a=0 ORDER BY 1 +-- +ok +== +SELECT COUNT(*) FROM (SELECT * FROM vals1, vals2) tbl1, (SELECT * FROM vals1, vals2) tbl2 WHERE tbl1.i=tbl1.k AND tbl1.i=tbl2.k AND tbl1.i=tbl2.i AND tbl1.i=5000; +-- +ok +== +SELECT COUNT(*) FROM (SELECT * FROM vals1, vals2) tbl1, (SELECT * FROM vals1, vals2) tbl2 WHERE tbl1.i=tbl1.k AND tbl1.i=tbl2.k AND tbl1.i=tbl2.i AND tbl1.i>4999 AND tbl1.i<5001; +-- +ok +== +SELECT COUNT(*) FROM (SELECT * FROM vals1, vals2) tbl1, (SELECT * FROM vals1, vals2) tbl2 WHERE tbl1.i=5000 AND tbl1.i<>5000; +-- +ok +== +SELECT COUNT(*) FROM (SELECT * FROM vals1, vals2) tbl1, (SELECT * FROM vals1, vals2) tbl2 WHERE tbl1.i=5000 AND tbl1.i=tbl2.i AND tbl2.i<>5000; +-- +ok +== +SELECT COUNT(*) FROM (SELECT * FROM vals1, vals2) tbl1, (SELECT * FROM vals1, vals2) tbl2 WHERE tbl1.i=5000 AND tbl1.i=tbl2.i AND tbl1.i=tbl2.k AND tbl1.i=tbl1.k AND tbl2.i<>5001; +-- +ok +== +SELECT COUNT(*) FROM (SELECT * FROM vals1, vals2) tbl1, (SELECT * FROM vals1, vals2) tbl2 WHERE tbl2.i>10 AND tbl1.k>=500 AND tbl2.k<7000 AND tbl2.k<=6000 AND tbl2.k<>8000 AND tbl1.i<>4000 AND tbl1.i=tbl2.i AND tbl1.i=tbl2.k AND tbl1.i=tbl1.k AND tbl1.i=5000; +-- +ok +== diff --git a/parser/testdata/corpus/sql/optimizer/plan/test_filter_pushdown_materialized_cte.test b/parser/testdata/corpus/sql/optimizer/plan/test_filter_pushdown_materialized_cte.test new file mode 100644 index 0000000..98046d8 --- /dev/null +++ b/parser/testdata/corpus/sql/optimizer/plan/test_filter_pushdown_materialized_cte.test @@ -0,0 +1,31 @@ +# source: test/sql/optimizer/plan/test_filter_pushdown_materialized_cte.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +call dsdgen(sf=0.01) +-- +ok +== +EXPLAIN WITH ss AS MATERIALIZED + ( SELECT i_manufact_id, + sum(ss_ext_sales_price) total_sales + FROM store_sales, + date_dim, + customer_address, + item + WHERE i_manufact_id IN + (SELECT i_manufact_id + FROM item + WHERE i_category IN ('Electronics')) + AND ss_item_sk = i_item_sk + AND ss_sold_date_sk = d_date_sk + AND d_year = 1998 + AND d_moy = 5 + AND ss_addr_sk = ca_address_sk + AND ca_gmt_offset = -5 + GROUP BY i_manufact_id) +FROM ss +-- +ok +== diff --git a/parser/testdata/corpus/sql/optimizer/plan/test_recursive_build_side_probe_side.test b/parser/testdata/corpus/sql/optimizer/plan/test_recursive_build_side_probe_side.test new file mode 100644 index 0000000..43ca1b8 --- /dev/null +++ b/parser/testdata/corpus/sql/optimizer/plan/test_recursive_build_side_probe_side.test @@ -0,0 +1,16 @@ +# source: test/sql/optimizer/plan/test_recursive_build_side_probe_side.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +explain with recursive t(x) as ( + select 1 + union all + select t.x + 1 + from range(100000) s(v) right join t on s.v = t.x + where t.x < 3 +) +select * from t +-- +ok +== diff --git a/parser/testdata/corpus/sql/optimizer/plan/test_recursive_join_order_guard.test b/parser/testdata/corpus/sql/optimizer/plan/test_recursive_join_order_guard.test new file mode 100644 index 0000000..c76dbf6 --- /dev/null +++ b/parser/testdata/corpus/sql/optimizer/plan/test_recursive_join_order_guard.test @@ -0,0 +1,38 @@ +# source: test/sql/optimizer/plan/test_recursive_join_order_guard.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +pragma explain_output='physical_only' +-- +ok +== +explain with recursive + field(x, y, v) as ( + values (0, 0, 'S'), (1, 0, '.'), (0, 1, '.'), (1, 1, '#') + ), + directions(dx, dy) as ( + values (1, 0), (-1, 0), (0, 1), (0, -1) + ), + maxlen(maxlen) as ( + select 3 + ), + flood(step, x, y, lx, ly) as ( + select 0::smallint, x, y, -1::smallint, -1::smallint + from field + where v = 'S' + union all + select distinct + step + 1::smallint, + f.x, + f.y, + l.x, + l.y + from (flood l cross join directions) + join field f on l.x + dx = f.x and l.y + dy = f.y, maxlen + where v != '#' and (f.x != lx or f.y != ly) and step < maxlen + ) +select * from flood +-- +ok +== diff --git a/parser/testdata/corpus/sql/optimizer/plan/test_table_filter_pushdown.test b/parser/testdata/corpus/sql/optimizer/plan/test_table_filter_pushdown.test new file mode 100644 index 0000000..badcf39 --- /dev/null +++ b/parser/testdata/corpus/sql/optimizer/plan/test_table_filter_pushdown.test @@ -0,0 +1,29 @@ +# source: test/sql/optimizer/plan/test_table_filter_pushdown.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +CREATE TABLE integers AS SELECT i AS i, i AS j FROM range(0, 100) tbl(i) +-- +ok +== +SELECT j FROM integers where j = 99 +-- +ok +== +SELECT j FROM integers where j = 99 AND i=99 +-- +ok +== +SELECT j FROM integers where j = 99 AND i=90 +-- +ok +== +SELECT count(i) FROM integers where j > 90 and i < 95 +-- +ok +== +SELECT count(i) FROM integers where j > 90 and j < 95 +-- +ok +== diff --git a/parser/testdata/corpus/sql/optimizer/plan/test_unused_column_after_join.test b/parser/testdata/corpus/sql/optimizer/plan/test_unused_column_after_join.test new file mode 100644 index 0000000..d91b4c5 --- /dev/null +++ b/parser/testdata/corpus/sql/optimizer/plan/test_unused_column_after_join.test @@ -0,0 +1,29 @@ +# source: test/sql/optimizer/plan/test_unused_column_after_join.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +SELECT COUNT(*) FROM test, test2 WHERE test.b = test2.b +-- +ok +== +SELECT SUM(test.a), MIN(test.a), MAX(test.a) FROM test, test2 WHERE test.b = test2.b +-- +ok +== +SELECT COUNT(*) FROM test a1, test a2, test a3 WHERE a1.b=a2.b AND a2.b=a3.b +-- +ok +== +SELECT SUM(a1.a) FROM test a1, test a2, test a3 WHERE a1.b=a2.b AND a2.b=a3.b +-- +ok +== +SELECT COUNT(*) FROM test a1, test a2, test a3 WHERE a1.b=a2.b AND a2.b=a3.b AND a1.a=11 AND a2.a=11 AND a3.a=11 +-- +ok +== +SELECT (TRUE OR a1.a=a2.b) FROM test a1, test a2 WHERE a1.a=11 AND a2.a>=10 +-- +ok +== diff --git a/parser/testdata/corpus/sql/optimizer/power_zonemap_pruning.test b/parser/testdata/corpus/sql/optimizer/power_zonemap_pruning.test new file mode 100644 index 0000000..02f757b --- /dev/null +++ b/parser/testdata/corpus/sql/optimizer/power_zonemap_pruning.test @@ -0,0 +1,77 @@ +# source: test/sql/optimizer/power_zonemap_pruning.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +CREATE TABLE power_pruning AS +SELECT CASE WHEN i < 122880 THEN 1 ELSE 100 END::INTEGER AS x +FROM range(245760) tbl(i); +-- +ok +== +EXPLAIN ANALYZE SELECT sum(x) FROM power_pruning WHERE power(x, 2) > 2500; +-- +ok +== +SELECT sum(x) FROM power_pruning WHERE power(x, 2) > 2500; +-- +ok +== +CREATE TABLE power_stats(x INTEGER); +-- +ok +== +INSERT INTO power_stats VALUES (-3), (2); +-- +ok +== +SELECT s.min, s.max FROM (SELECT stats(power(x, 2)) s FROM power_stats LIMIT 1); +-- +ok +== +SELECT s.min, s.max FROM (SELECT stats(power(x, 3)) s FROM power_stats LIMIT 1); +-- +ok +== +SELECT s.min, s.max FROM (SELECT stats(power(x, 0)) s FROM power_stats LIMIT 1); +-- +ok +== +CREATE TABLE power_zero AS +SELECT CASE WHEN i < 122880 THEN 'inf'::DOUBLE ELSE 1.0 END AS x +FROM range(245760) tbl(i); +-- +ok +== +EXPLAIN ANALYZE SELECT count(*) FROM power_zero WHERE power(x, 0) > 1; +-- +ok +== +SELECT count(*) FROM power_zero WHERE power(x, 0) > 1; +-- +ok +== +CREATE TABLE negative_power_stats(x INTEGER); +-- +ok +== +INSERT INTO negative_power_stats VALUES (-3), (-2); +-- +ok +== +SELECT s.min, s.max FROM (SELECT stats(power(x, 2)) s FROM negative_power_stats LIMIT 1); +-- +ok +== +CREATE TABLE negative_exponent(x INTEGER); +-- +ok +== +INSERT INTO negative_exponent VALUES (0), (1); +-- +ok +== +SELECT count(*) FROM negative_exponent WHERE power(x, -2) < 0; +-- +ok +== diff --git a/parser/testdata/corpus/sql/optimizer/predicate_factoring.test b/parser/testdata/corpus/sql/optimizer/predicate_factoring.test new file mode 100644 index 0000000..741a234 --- /dev/null +++ b/parser/testdata/corpus/sql/optimizer/predicate_factoring.test @@ -0,0 +1,85 @@ +# source: test/sql/optimizer/predicate_factoring.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +CREATE TABLE t (a INTEGER, b INTEGER, c INTEGER); +-- +ok +== +INSERT INTO t VALUES (1, 5, 3), (1, 2, 3), (1, 5, 11), (2, 5, 3), (NULL, 5, 3); +-- +ok +== +SELECT * FROM t WHERE (a=1 AND b>3) OR (a=1 AND c<5) +-- +ok +== +EXPLAIN SELECT * FROM t WHERE (a=1 AND b>3) OR (a=1 AND c<5) +-- +ok +== +SELECT * FROM t WHERE (a=1 AND (b>3 AND TRUE)) OR (a=1 AND (TRUE AND c<5)) +-- +ok +== +EXPLAIN SELECT * FROM t WHERE (a=1 AND (b>3 AND TRUE)) OR (a=1 AND (TRUE AND c<5)) +-- +ok +== +SELECT * FROM t WHERE (a=1 AND b=5) OR (a=2 AND b=5) +-- +ok +== +EXPLAIN SELECT * FROM t WHERE (a=1 AND b=5) OR (a=2 AND b=5) +-- +ok +== +SELECT * FROM t WHERE (a=1 AND b=5 AND c>2) OR (a=1 AND b=5 AND c<6) +-- +ok +== +EXPLAIN SELECT * FROM t WHERE (a=1 AND b=5 AND c>2) OR (a=1 AND b=5 AND c<6) +-- +ok +== +SELECT * FROM t WHERE (a=1 AND b=5) OR (a=1 AND c>2) OR (a=1 AND b=2) +-- +ok +== +EXPLAIN SELECT * FROM t WHERE (a=1 AND b=5) OR (a=1 AND c>2) OR (a=1 AND b=2) +-- +ok +== +SELECT * FROM t WHERE (a=1 AND b>3) OR (a=2 AND c<5) +-- +ok +== +SELECT * FROM t WHERE a=1 OR a=2 +-- +ok +== +SELECT * FROM t WHERE (a=1 AND b=5) OR (a=1 AND c=3) +-- +ok +== +SELECT (a=1 AND b>3) OR (a=1 AND c<5) FROM t +-- +ok +== +CREATE TABLE s (x INTEGER, y INTEGER); +-- +ok +== +INSERT INTO s VALUES (1, 10), (2, 20), (1, 30); +-- +ok +== +SELECT t.a, t.b, t.c, s.x, s.y FROM t, s WHERE (t.a=1 AND s.x=1 AND t.b>3) OR (t.a=1 AND s.x=1 AND s.y<20) +-- +ok +== +EXPLAIN SELECT t.a, t.b, t.c, s.x, s.y FROM t, s WHERE (t.a=1 AND s.x=1 AND t.b>3) OR (t.a=1 AND s.x=1 AND s.y<20) +-- +ok +== diff --git a/parser/testdata/corpus/sql/optimizer/rewrite_nan_null.test b/parser/testdata/corpus/sql/optimizer/rewrite_nan_null.test new file mode 100644 index 0000000..1cbbc8e --- /dev/null +++ b/parser/testdata/corpus/sql/optimizer/rewrite_nan_null.test @@ -0,0 +1,91 @@ +# source: test/sql/optimizer/rewrite_nan_null.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +CREATE TABLE neg(id INTEGER, x DOUBLE) +-- +ok +== +INSERT INTO neg VALUES (0, NULL), (1, 0.0), (2, -0.0), (3, 1.0), (4, -1.0), + (5, 'nan'::DOUBLE), (6, '-nan'::DOUBLE), (7, 'inf'::DOUBLE), (8, '-inf'::DOUBLE) +-- +ok +== +SET disabled_optimizers='{opt}' +-- +error: Parser Error: Optimizer type "{opt}" not recognized +== +SELECT id, + coalesce(((-x) > 0)::VARCHAR, 'NIL'), + coalesce(((-x) >= 0)::VARCHAR, 'NIL'), + coalesce(((-x) < 0)::VARCHAR, 'NIL'), + coalesce(((-x) <= 0)::VARCHAR, 'NIL'), + coalesce(((-x) = 0)::VARCHAR, 'NIL') +FROM neg ORDER BY id +-- +ok +== +SELECT (SELECT count(*) FROM neg WHERE (-x) > 0), + (SELECT sum(CASE WHEN (-x) > 0 THEN 1 ELSE 0 END) FROM neg), + (SELECT count(*) FROM neg WHERE (-x) >= 0), + (SELECT sum(CASE WHEN (-x) >= 0 THEN 1 ELSE 0 END) FROM neg) +-- +ok +== +SELECT (SELECT count(*) FROM neg WHERE (-x) > 1), + (SELECT count(*) FROM neg WHERE (-x) < -1) +-- +ok +== +SELECT count(*) FROM (SELECT x::FLOAT AS f FROM neg) WHERE (-f) >= 0 +-- +ok +== +RESET disabled_optimizers +-- +ok +== +CREATE TABLE dt(id INTEGER, d DATE) +-- +ok +== +INSERT INTO dt VALUES (0, NULL), (1, DATE '2020-06-15'), (2, DATE '2020-06-01'), (3, DATE '2019-01-01') +-- +ok +== +SELECT id, + coalesce((date_trunc('month', d) = DATE '2020-06-15')::VARCHAR, 'NIL'), + coalesce((date_trunc('month', d) <> DATE '2020-06-15')::VARCHAR, 'NIL'), + coalesce((date_trunc('month', d) IS NOT DISTINCT FROM DATE '2020-06-15')::VARCHAR, 'NIL'), + coalesce((date_trunc('month', d) IS DISTINCT FROM DATE '2020-06-15')::VARCHAR, 'NIL') +FROM dt ORDER BY id +-- +ok +== +SELECT id, + coalesce((date_trunc('month', d) = DATE '2020-06-01')::VARCHAR, 'NIL'), + coalesce((date_trunc('month', d) <> DATE '2020-06-01')::VARCHAR, 'NIL') +FROM dt ORDER BY id +-- +ok +== +CREATE OR REPLACE TABLE ts(id INTEGER, t TIMESTAMP) +-- +ok +== +DELETE FROM ts +-- +ok +== +INSERT INTO ts VALUES (0, NULL), (1, TIMESTAMP '2020-06-15 12:34:56'), (2, TIMESTAMP '2020-06-15 00:00:00') +-- +ok +== +SELECT id, + coalesce((date_trunc('day', t) = TIMESTAMP '2020-06-15 12:00:00')::VARCHAR, 'NIL'), + coalesce((date_trunc('day', t) <> TIMESTAMP '2020-06-15 12:00:00')::VARCHAR, 'NIL') +FROM ts ORDER BY id +-- +ok +== diff --git a/parser/testdata/corpus/sql/optimizer/rewrite_nan_null.test.metadata.json b/parser/testdata/corpus/sql/optimizer/rewrite_nan_null.test.metadata.json new file mode 100644 index 0000000..e398711 --- /dev/null +++ b/parser/testdata/corpus/sql/optimizer/rewrite_nan_null.test.metadata.json @@ -0,0 +1,5 @@ +{ + "todo": { + "d54780da5a3d98ea": "transformer-raised parser error: upstream rejects in the transformer, not the grammar; expected to clear as transformers land (milestones 3-5)" + } +} diff --git a/parser/testdata/corpus/sql/optimizer/sign_row_group_pruning.test b/parser/testdata/corpus/sql/optimizer/sign_row_group_pruning.test new file mode 100644 index 0000000..60d9bac --- /dev/null +++ b/parser/testdata/corpus/sql/optimizer/sign_row_group_pruning.test @@ -0,0 +1,23 @@ +# source: test/sql/optimizer/sign_row_group_pruning.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +ATTACH '{TEST_DIR}/sign_prune.duckdb' AS db (ROW_GROUP_SIZE 2048); +-- +ok +== +CREATE TABLE integers AS + SELECT range::INTEGER AS i + FROM range(6144); +-- +ok +== +SELECT sum(i) FROM integers WHERE sign(i) = 0; +-- +ok +== +EXPLAIN ANALYZE SELECT sum(i) FROM integers WHERE sign(i) = 0; +-- +ok +== diff --git a/parser/testdata/corpus/sql/optimizer/string_row_group_pruning.test b/parser/testdata/corpus/sql/optimizer/string_row_group_pruning.test new file mode 100644 index 0000000..afbcca7 --- /dev/null +++ b/parser/testdata/corpus/sql/optimizer/string_row_group_pruning.test @@ -0,0 +1,95 @@ +# source: test/sql/optimizer/string_row_group_pruning.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +ATTACH '{TEST_DIR}/string_prune.duckdb' AS db (ROW_GROUP_SIZE 2048); +-- +ok +== +CREATE TABLE s AS +SELECT CASE WHEN range < 2048 THEN 'a' ELSE 'b' END AS v, 1 AS payload +FROM range(4096); +-- +ok +== +EXPLAIN ANALYZE SELECT sum(payload) FROM s WHERE v > 'a'; +-- +ok +== +SELECT sum(payload) FROM s WHERE v > 'a'; +-- +ok +== +EXPLAIN ANALYZE SELECT sum(payload) FROM s WHERE v = 'b'; +-- +ok +== +SELECT sum(payload) FROM s WHERE v = 'b'; +-- +ok +== +EXPLAIN ANALYZE SELECT sum(payload) FROM s WHERE v IS NOT DISTINCT FROM 'b'; +-- +ok +== +SELECT sum(payload) FROM s WHERE v IS NOT DISTINCT FROM 'b'; +-- +ok +== +EXPLAIN ANALYZE SELECT sum(payload) FROM s WHERE v <> 'a'; +-- +ok +== +SELECT sum(payload) FROM s WHERE v <> 'a'; +-- +ok +== +EXPLAIN ANALYZE SELECT sum(payload) FROM s WHERE v IS DISTINCT FROM 'a'; +-- +ok +== +SELECT sum(payload) FROM s WHERE v IS DISTINCT FROM 'a'; +-- +ok +== +EXPLAIN ANALYZE SELECT sum(payload) FROM s WHERE v >= 'b'; +-- +ok +== +SELECT sum(payload) FROM s WHERE v >= 'b'; +-- +ok +== +EXPLAIN ANALYZE SELECT sum(payload) FROM s WHERE v < 'b'; +-- +ok +== +SELECT sum(payload) FROM s WHERE v < 'b'; +-- +ok +== +EXPLAIN ANALYZE SELECT sum(payload) FROM s WHERE v <= 'a'; +-- +ok +== +SELECT sum(payload) FROM s WHERE v <= 'a'; +-- +ok +== +EXPLAIN ANALYZE SELECT sum(payload) FROM s WHERE v >= 'a'; +-- +ok +== +SELECT sum(payload) FROM s WHERE v >= 'a'; +-- +ok +== +EXPLAIN ANALYZE SELECT sum(payload) FROM s WHERE v <= 'b'; +-- +ok +== +SELECT sum(payload) FROM s WHERE v <= 'b'; +-- +ok +== diff --git a/parser/testdata/corpus/sql/optimizer/string_stats_merge.test b/parser/testdata/corpus/sql/optimizer/string_stats_merge.test new file mode 100644 index 0000000..6ac6fe8 --- /dev/null +++ b/parser/testdata/corpus/sql/optimizer/string_stats_merge.test @@ -0,0 +1,213 @@ +# source: test/sql/optimizer/string_stats_merge.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +ATTACH '{TEST_DIR}/string_stats_merge.duckdb' AS db (ROW_GROUP_SIZE 2048); +-- +ok +== +CREATE TABLE long_strings (v VARCHAR, payload INTEGER); +-- +ok +== +INSERT INTO long_strings SELECT repeat('b', 12), 1 FROM range(2048); +-- +ok +== +INSERT INTO long_strings SELECT repeat('b', 13), 1 FROM range(2048); +-- +ok +== +EXPLAIN ANALYZE SELECT sum(payload) FROM long_strings WHERE v > repeat('b', 12); +-- +ok +== +SELECT sum(payload) FROM long_strings WHERE v > repeat('b', 12); +-- +ok +== +EXPLAIN ANALYZE SELECT sum(payload) FROM long_strings WHERE v < repeat('b', 12); +-- +ok +== +SELECT sum(payload) FROM long_strings WHERE v < repeat('b', 12); +-- +ok +== +EXPLAIN ANALYZE SELECT sum(payload) FROM long_strings WHERE v >= repeat('b', 12); +-- +ok +== +SELECT sum(payload) FROM long_strings WHERE v >= repeat('b', 12); +-- +ok +== +EXPLAIN ANALYZE SELECT sum(payload) FROM long_strings WHERE v <= repeat('b', 12); +-- +ok +== +SELECT sum(payload) FROM long_strings WHERE v <= repeat('b', 12); +-- +ok +== +EXPLAIN ANALYZE SELECT sum(payload) FROM long_strings WHERE v = repeat('b', 12); +-- +ok +== +SELECT sum(payload) FROM long_strings WHERE v = repeat('b', 12); +-- +ok +== +EXPLAIN ANALYZE SELECT sum(payload) FROM long_strings WHERE v <> repeat('b', 12); +-- +ok +== +SELECT sum(payload) FROM long_strings WHERE v <> repeat('b', 12); +-- +ok +== +EXPLAIN ANALYZE SELECT sum(payload) FROM long_strings WHERE v > repeat('b', 13); +-- +ok +== +SELECT sum(payload) FROM long_strings WHERE v > repeat('b', 13); +-- +ok +== +EXPLAIN ANALYZE SELECT sum(payload) FROM long_strings WHERE v < repeat('b', 13); +-- +ok +== +SELECT sum(payload) FROM long_strings WHERE v < repeat('b', 13); +-- +ok +== +EXPLAIN ANALYZE SELECT sum(payload) FROM long_strings WHERE v >= repeat('b', 13); +-- +ok +== +SELECT sum(payload) FROM long_strings WHERE v >= repeat('b', 13); +-- +ok +== +EXPLAIN ANALYZE SELECT sum(payload) FROM long_strings WHERE v <= repeat('b', 13); +-- +ok +== +SELECT sum(payload) FROM long_strings WHERE v <= repeat('b', 13); +-- +ok +== +EXPLAIN ANALYZE SELECT sum(payload) FROM long_strings WHERE v = repeat('b', 13); +-- +ok +== +SELECT sum(payload) FROM long_strings WHERE v = repeat('b', 13); +-- +ok +== +EXPLAIN ANALYZE SELECT sum(payload) FROM long_strings WHERE v <> repeat('b', 13); +-- +ok +== +SELECT sum(payload) FROM long_strings WHERE v <> repeat('b', 13); +-- +ok +== +EXPLAIN ANALYZE SELECT sum(payload) FROM long_strings WHERE v > repeat('a', 12); +-- +ok +== +SELECT sum(payload) FROM long_strings WHERE v > repeat('a', 12); +-- +ok +== +EXPLAIN SELECT sum(payload) FROM long_strings WHERE v < repeat('a', 12); +-- +ok +== +SELECT sum(payload) FROM long_strings WHERE v < repeat('a', 12); +-- +ok +== +EXPLAIN ANALYZE SELECT sum(payload) FROM long_strings WHERE v >= repeat('a', 12); +-- +ok +== +SELECT sum(payload) FROM long_strings WHERE v >= repeat('a', 12); +-- +ok +== +EXPLAIN SELECT sum(payload) FROM long_strings WHERE v <= repeat('a', 12); +-- +ok +== +SELECT sum(payload) FROM long_strings WHERE v <= repeat('a', 12); +-- +ok +== +EXPLAIN SELECT sum(payload) FROM long_strings WHERE v = repeat('a', 12); +-- +ok +== +SELECT sum(payload) FROM long_strings WHERE v = repeat('a', 12); +-- +ok +== +EXPLAIN ANALYZE SELECT sum(payload) FROM long_strings WHERE v <> repeat('a', 12); +-- +ok +== +SELECT sum(payload) FROM long_strings WHERE v <> repeat('a', 12); +-- +ok +== +EXPLAIN SELECT sum(payload) FROM long_strings WHERE v > repeat('c', 12); +-- +ok +== +SELECT sum(payload) FROM long_strings WHERE v > repeat('c', 12); +-- +ok +== +EXPLAIN ANALYZE SELECT sum(payload) FROM long_strings WHERE v < repeat('c', 12); +-- +ok +== +SELECT sum(payload) FROM long_strings WHERE v < repeat('c', 12); +-- +ok +== +EXPLAIN SELECT sum(payload) FROM long_strings WHERE v >= repeat('c', 12); +-- +ok +== +SELECT sum(payload) FROM long_strings WHERE v >= repeat('c', 12); +-- +ok +== +EXPLAIN ANALYZE SELECT sum(payload) FROM long_strings WHERE v <= repeat('c', 12); +-- +ok +== +SELECT sum(payload) FROM long_strings WHERE v <= repeat('c', 12); +-- +ok +== +EXPLAIN SELECT sum(payload) FROM long_strings WHERE v = repeat('c', 12); +-- +ok +== +SELECT sum(payload) FROM long_strings WHERE v = repeat('c', 12); +-- +ok +== +EXPLAIN ANALYZE SELECT sum(payload) FROM long_strings WHERE v <> repeat('c', 12); +-- +ok +== +SELECT sum(payload) FROM long_strings WHERE v <> repeat('c', 12); +-- +ok +== diff --git a/parser/testdata/corpus/sql/optimizer/struct_segment_pruning.test b/parser/testdata/corpus/sql/optimizer/struct_segment_pruning.test new file mode 100644 index 0000000..e3a5987 --- /dev/null +++ b/parser/testdata/corpus/sql/optimizer/struct_segment_pruning.test @@ -0,0 +1,50 @@ +# source: test/sql/optimizer/struct_segment_pruning.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +SET threads = 1 +-- +ok +== +SET initial_column_segment_size = 2048 +-- +ok +== +SET wal_autocheckpoint = '1TB' +-- +ok +== +CREATE TABLE events AS +SELECT i, + CASE WHEN i = 50000 THEN NULL + ELSE {'meta': {'ts': CASE WHEN i = 50001 THEN NULL + WHEN i = 99999 THEN TIMESTAMP '2100-01-01' + ELSE TIMESTAMP '2020-01-01' + i * INTERVAL 1 SECOND + END}} + END AS payload +FROM range(100000) t(i) +-- +ok +== +SELECT count(*) FROM events WHERE payload.meta.ts IS NULL +-- +ok +== +PRAGMA profiling_output = '{TEST_DIR}/struct_segment_pruning_profile.json' +-- +error: Parser Error: Profiler file type ({TEST_DIR}/struct_segment_pruning_profile.json) must either have the same file extension as the profiling output type (query_tree), or be a '.txt' file. Set "enable_profiling = 'json'" first. +== +SELECT count(*) FROM events WHERE payload.meta.ts >= TIMESTAMP '2099-01-01' +-- +ok +== +SELECT query.total_rows_scanned BETWEEN 1 AND 99999 +FROM '{TEST_DIR}/struct_segment_pruning_profile.json' +-- +ok +== +UPDATE events SET payload = NULL WHERE i = 1 +-- +ok +== diff --git a/parser/testdata/corpus/sql/optimizer/struct_segment_pruning.test.metadata.json b/parser/testdata/corpus/sql/optimizer/struct_segment_pruning.test.metadata.json new file mode 100644 index 0000000..a40228a --- /dev/null +++ b/parser/testdata/corpus/sql/optimizer/struct_segment_pruning.test.metadata.json @@ -0,0 +1,5 @@ +{ + "todo": { + "921bce1208fece2d": "transformer-raised parser error: upstream rejects in the transformer, not the grammar; expected to clear as transformers land (milestones 3-5)" + } +} diff --git a/parser/testdata/corpus/sql/optimizer/substring_zonemap_pruning.test b/parser/testdata/corpus/sql/optimizer/substring_zonemap_pruning.test new file mode 100644 index 0000000..6b04dc9 --- /dev/null +++ b/parser/testdata/corpus/sql/optimizer/substring_zonemap_pruning.test @@ -0,0 +1,226 @@ +# source: test/sql/optimizer/substring_zonemap_pruning.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +CREATE TABLE substring_pruning AS +SELECT i::INTEGER AS i, 'p' || lpad(i::VARCHAR, 6, '0') AS s +FROM range(500000) r(i); +-- +ok +== +EXPLAIN ANALYZE SELECT sum(i) FROM substring_pruning WHERE substr(s, 2) = '495000'; +-- +ok +== +SELECT count(*) FROM substring_pruning WHERE substr(s, 2) = '495000'; +-- +ok +== +EXPLAIN ANALYZE SELECT sum(i) FROM substring_pruning WHERE substr(s, 2, 4) = '4950'; +-- +ok +== +SELECT count(*) FROM substring_pruning WHERE substr(s, 2, 4) = '4950'; +-- +ok +== +EXPLAIN ANALYZE SELECT sum(i) FROM substring_pruning WHERE s[2:] > '495000'; +-- +ok +== +SELECT count(*) FROM substring_pruning WHERE s[2:] > '495000'; +-- +ok +== +EXPLAIN ANALYZE SELECT sum(i) FROM substring_pruning WHERE s[2:5] > '4950'; +-- +ok +== +SELECT count(*) FROM substring_pruning WHERE s[2:5] > '4950'; +-- +ok +== +EXPLAIN ANALYZE SELECT sum(i) FROM substring_pruning WHERE s[:] > 'p495000'; +-- +ok +== +SELECT count(*) FROM substring_pruning WHERE s[:] > 'p495000'; +-- +ok +== +EXPLAIN ANALYZE SELECT sum(i) FROM substring_pruning WHERE s[0:2] > 'p3'; +-- +ok +== +SELECT count(*) FROM substring_pruning WHERE s[0:2] > 'p3'; +-- +ok +== +EXPLAIN ANALYZE SELECT sum(i) FROM substring_pruning WHERE s[1:2] > 'p3'; +-- +ok +== +SELECT count(*) FROM substring_pruning WHERE s[1:2] > 'p3'; +-- +ok +== +EXPLAIN ANALYZE SELECT sum(i) FROM substring_pruning WHERE s[:2] > 'p3'; +-- +ok +== +SELECT count(*) FROM substring_pruning WHERE s[:2] > 'p3'; +-- +ok +== +EXPLAIN ANALYZE SELECT sum(i) FROM substring_pruning WHERE s[2:20] > '491519'; +-- +ok +== +SELECT count(*) FROM substring_pruning WHERE s[2:20] > '491519'; +-- +ok +== +SELECT count(*) FROM substring_pruning WHERE s[5:2] = ''; +-- +ok +== +EXPLAIN ANALYZE SELECT sum(i) FROM substring_pruning WHERE s[(i % 2) + 1:] > '495000'; +-- +ok +== +SELECT count(*) FROM substring_pruning WHERE s[(i % 2) + 1:] > '495000'; +-- +ok +== +EXPLAIN ANALYZE SELECT sum(i) FROM substring_pruning WHERE s[-6:] > '495000'; +-- +ok +== +SELECT count(*) FROM substring_pruning WHERE s[-6:] > '495000'; +-- +ok +== +EXPLAIN ANALYZE SELECT sum(i) FROM substring_pruning WHERE substr(s, 1, 2) > 'p3'; +-- +ok +== +SELECT count(*) FROM substring_pruning WHERE substr(s, 1, 2) > 'p3'; +-- +ok +== +EXPLAIN ANALYZE SELECT sum(i) FROM substring_pruning WHERE substr(s, 0, 3) > 'p3'; +-- +ok +== +SELECT count(*) FROM substring_pruning WHERE substr(s, 0, 3) > 'p3'; +-- +ok +== +EXPLAIN ANALYZE SELECT sum(i) FROM substring_pruning WHERE substr(s, 1, 20) > 'p491519'; +-- +ok +== +SELECT count(*) FROM substring_pruning WHERE substr(s, 1, 20) > 'p491519'; +-- +ok +== +CREATE TABLE substring_pruning_utf8 AS +SELECT i::INTEGER AS i, '🦆' || lpad(i::VARCHAR, 6, '0') AS s +FROM range(500000) r(i); +-- +ok +== +EXPLAIN ANALYZE SELECT sum(i) FROM substring_pruning_utf8 WHERE substr(s, 2) = '495000'; +-- +ok +== +SELECT count(*) FROM substring_pruning_utf8 WHERE substr(s, 2) = '495000'; +-- +ok +== +EXPLAIN ANALYZE SELECT sum(i) FROM substring_pruning_utf8 WHERE s[2:] > '495000'; +-- +ok +== +SELECT count(*) FROM substring_pruning_utf8 WHERE s[2:] > '495000'; +-- +ok +== +EXPLAIN ANALYZE SELECT sum(i) FROM substring_pruning_utf8 WHERE s[2:5] > '4950'; +-- +ok +== +SELECT count(*) FROM substring_pruning_utf8 WHERE s[2:5] > '4950'; +-- +ok +== +CREATE TABLE substring_no_shared_prefix AS +SELECT i::INTEGER AS i, CASE WHEN i % 2 = 0 THEN 'a' ELSE 'b' END || lpad(i::VARCHAR, 6, '0') AS s +FROM range(500000) r(i); +-- +ok +== +EXPLAIN ANALYZE SELECT sum(i) FROM substring_no_shared_prefix WHERE substr(s, 2) = '495000'; +-- +ok +== +SELECT count(*) FROM substring_no_shared_prefix WHERE substr(s, 2) = '495000'; +-- +ok +== +EXPLAIN ANALYZE SELECT sum(i) FROM substring_no_shared_prefix WHERE s[2:] > '495000'; +-- +ok +== +SELECT count(*) FROM substring_no_shared_prefix WHERE s[2:] > '495000'; +-- +ok +== +CREATE TABLE substring_truncated_pruning AS +SELECT i::INTEGER AS i, 'p' || lpad(i::VARCHAR, 6, '0') || repeat('x', 20) AS s +FROM range(500000) r(i); +-- +ok +== +EXPLAIN ANALYZE SELECT sum(i) FROM substring_truncated_pruning +WHERE substr(s, 2) = '495000' || repeat('x', 20); +-- +ok +== +SELECT count(*) FROM substring_truncated_pruning WHERE substr(s, 2) = '495000' || repeat('x', 20); +-- +ok +== +EXPLAIN ANALYZE SELECT sum(i) FROM substring_truncated_pruning +WHERE s[2:] > '495000' || repeat('x', 20); +-- +ok +== +SELECT count(*) FROM substring_truncated_pruning +WHERE s[2:] > '495000' || repeat('x', 20); +-- +ok +== +CREATE TABLE substring_truncated_stats AS +SELECT i::INTEGER AS i, repeat('p', 13) || lpad(i::VARCHAR, 6, '0') AS s +FROM range(500000) r(i); +-- +ok +== +EXPLAIN ANALYZE SELECT sum(i) FROM substring_truncated_stats WHERE substr(s, 14) = '495000'; +-- +ok +== +SELECT count(*) FROM substring_truncated_stats WHERE substr(s, 14) = '495000'; +-- +ok +== +EXPLAIN ANALYZE SELECT sum(i) FROM substring_truncated_stats WHERE s[14:] > '495000'; +-- +ok +== +SELECT count(*) FROM substring_truncated_stats WHERE s[14:] > '495000'; +-- +ok +== diff --git a/parser/testdata/corpus/sql/optimizer/table_filters.test b/parser/testdata/corpus/sql/optimizer/table_filters.test new file mode 100644 index 0000000..a6424f7 --- /dev/null +++ b/parser/testdata/corpus/sql/optimizer/table_filters.test @@ -0,0 +1,514 @@ +# source: test/sql/optimizer/table_filters.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +SET dynamic_or_filter_threshold=0 +-- +ok +== +CREATE TABLE distinct_from_nulls AS +SELECT NULL::INTEGER AS a +FROM range(10000) +-- +ok +== +SELECT count(*) +FROM distinct_from_nulls +WHERE a IS DISTINCT FROM 5 +-- +ok +== +CREATE TABLE distinct_from_mixed_nulls AS +SELECT CASE WHEN i % 2 = 0 THEN NULL ELSE 5 END::INTEGER AS a +FROM range(10000) t(i) +-- +ok +== +SELECT count(*) +FROM distinct_from_mixed_nulls +WHERE a IS DISTINCT FROM 5 +-- +ok +== +SET force_compression='rle' +-- +ok +== +CREATE TABLE distinct_from_mixed_nulls_rle AS +SELECT CASE WHEN i % 2 = 0 THEN NULL ELSE 5 END::INTEGER AS a +FROM range(10000) t(i) +-- +ok +== +SELECT count(*) +FROM distinct_from_mixed_nulls_rle +WHERE a IS DISTINCT FROM 5 +-- +ok +== +SET force_compression='auto' +-- +ok +== +CREATE TABLE probe_num AS +SELECT i::BIGINT AS k, (i % 7)::INTEGER AS g +FROM range(0, 1000000) t(i) +-- +ok +== +CREATE TABLE build_num AS +SELECT i::BIGINT AS k, (i % 7)::INTEGER AS g +FROM (VALUES (100000), (900000)) v(i) +-- +ok +== +EXPLAIN ANALYZE +SELECT count(*) +FROM probe_num p +JOIN build_num b + ON p.k = b.k + AND p.g >= b.g +-- +ok +== +SELECT count(*) +FROM probe_num p +JOIN build_num b + ON p.k = b.k + AND p.g >= b.g +-- +ok +== +CREATE TABLE probe_str AS +SELECT lpad(i::VARCHAR, 8, '0') AS k, (i % 7)::INTEGER AS g +FROM range(0, 1000000) t(i) +-- +ok +== +CREATE TABLE build_str AS +SELECT lpad(i::VARCHAR, 8, '0') AS k, (i % 7)::INTEGER AS g +FROM (VALUES (100000), (900000)) v(i) +-- +ok +== +EXPLAIN ANALYZE +SELECT count(*) +FROM probe_str p +JOIN build_str b + ON p.k = b.k + AND p.g >= b.g +-- +ok +== +SELECT count(*) +FROM probe_str p +JOIN build_str b + ON p.k = b.k + AND p.g >= b.g +-- +ok +== +CREATE TABLE partition_src AS +SELECT i::INTEGER AS id, (i % 100)::INTEGER AS part +FROM range(0, 100000) t(i) +-- +ok +== +COPY partition_src +TO '{TEMP_DIR}/optional_partition_prune_22617' +(FORMAT parquet, PARTITION_BY part, OVERWRITE true) +-- +ok +== +CREATE TABLE build_part AS +SELECT v::INTEGER AS part +FROM (VALUES (42), (43)) t(v) +-- +ok +== +EXPLAIN ANALYZE +SELECT count(*) +FROM read_parquet('{TEMP_DIR}/optional_partition_prune_22617/*/*.parquet', + hive_partitioning=1, + hive_types={'part': INTEGER}) p +JOIN build_part b + ON p.part = b.part +-- +ok +== +SELECT count(*) +FROM read_parquet('{TEMP_DIR}/optional_partition_prune_22617/*/*.parquet', + hive_partitioning=1, + hive_types={'part': INTEGER}) p +JOIN build_part b + ON p.part = b.part +-- +ok +== +CREATE TABLE probe_cast_up AS +SELECT i::INTEGER AS k, (i % 7)::INTEGER AS g +FROM range(0, 1000000) t(i) +-- +ok +== +CREATE TABLE build_cast_up AS +SELECT i::BIGINT AS k, (i % 7)::INTEGER AS g +FROM (VALUES (100000), (900000)) v(i) +-- +ok +== +EXPLAIN ANALYZE +SELECT count(*) +FROM probe_cast_up p +JOIN build_cast_up b + ON p.k = b.k + AND p.g >= b.g +-- +ok +== +SELECT count(*) +FROM probe_cast_up p +JOIN build_cast_up b + ON p.k = b.k + AND p.g >= b.g +-- +ok +== +CREATE TABLE probe_cast_down AS +SELECT i::BIGINT AS k, (i % 7)::INTEGER AS g +FROM range(0, 1000000) t(i) +-- +ok +== +CREATE TABLE build_cast_down AS +SELECT i::INTEGER AS k, (i % 7)::INTEGER AS g +FROM (VALUES (100000), (900000)) v(i) +-- +ok +== +EXPLAIN ANALYZE +SELECT count(*) +FROM probe_cast_down p +JOIN build_cast_down b + ON p.k = b.k + AND p.g >= b.g +-- +ok +== +SELECT count(*) +FROM probe_cast_down p +JOIN build_cast_down b + ON p.k = b.k + AND p.g >= b.g +-- +ok +== +CREATE TABLE phj_probe_cast_up AS +SELECT i::INTEGER AS k +FROM range(0, 1000000) t(i) +-- +ok +== +CREATE TABLE phj_build_cast_up AS +SELECT i::BIGINT AS k +FROM range(100000, 100010) t(i) +-- +ok +== +EXPLAIN ANALYZE +SELECT count(*) +FROM phj_probe_cast_up p +JOIN phj_build_cast_up b + ON p.k = b.k +-- +ok +== +SELECT count(*) +FROM phj_probe_cast_up p +JOIN phj_build_cast_up b + ON p.k = b.k +-- +ok +== +CREATE TABLE phj_probe_cast_down AS +SELECT i::BIGINT AS k +FROM range(0, 1000000) t(i) +-- +ok +== +CREATE TABLE phj_build_cast_down AS +SELECT i::INTEGER AS k +FROM range(100000, 100010) t(i) +-- +ok +== +EXPLAIN ANALYZE +SELECT count(*) +FROM phj_probe_cast_down p +JOIN phj_build_cast_down b + ON p.k = b.k +-- +ok +== +SELECT count(*) +FROM phj_probe_cast_down p +JOIN phj_build_cast_down b + ON p.k = b.k +-- +ok +== +CREATE TABLE phj_probe_narrow_cast AS +SELECT i::BIGINT AS k +FROM range(0, 1000000) t(i) +UNION ALL +SELECT 1000000000::BIGINT +UNION ALL +SELECT 3000000000::BIGINT +-- +ok +== +CREATE TABLE phj_build_narrow_cast AS +SELECT i::INTEGER AS k +FROM range(100000, 100010) t(i) +-- +ok +== +EXPLAIN ANALYZE +SELECT count(*) +FROM ( + SELECT * + FROM phj_probe_narrow_cast + WHERE k < 1000000 +) p +JOIN phj_build_narrow_cast b + ON p.k::INTEGER = b.k +-- +ok +== +SELECT count(*) +FROM ( + SELECT * + FROM phj_probe_narrow_cast + WHERE k < 1000000 +) p +JOIN phj_build_narrow_cast b + ON p.k::INTEGER = b.k +-- +ok +== +SET dynamic_or_filter_threshold=10 +-- +ok +== +CREATE TABLE phj_build_narrow_cast_sparse AS +SELECT * +FROM (VALUES (1::INTEGER), (1000000000::INTEGER)) t(k) +-- +ok +== +EXPLAIN ANALYZE +SELECT count(*) +FROM ( + SELECT * + FROM phj_probe_narrow_cast + WHERE k < 2000000000 +) p +JOIN phj_build_narrow_cast_sparse b + ON p.k::INTEGER = b.k +-- +ok +== +SELECT count(*) +FROM ( + SELECT * + FROM phj_probe_narrow_cast + WHERE k < 2000000000 +) p +JOIN phj_build_narrow_cast_sparse b + ON p.k::INTEGER = b.k +-- +ok +== +SELECT count(*) +FROM phj_probe_narrow_cast p +JOIN phj_build_narrow_cast_sparse b + ON p.k::INTEGER = b.k +-- +ok +== +SELECT count(*) +FROM phj_probe_narrow_cast p +JOIN phj_build_narrow_cast b + ON p.k::INTEGER = b.k +-- +ok +== +EXPLAIN ANALYZE +SELECT count(*) +FROM ( + SELECT * + FROM phj_probe_narrow_cast + WHERE k < 1000000 +) p +JOIN phj_build_narrow_cast b + ON CAST(CAST(p.k AS INTEGER) AS BIGINT) = CAST(b.k AS BIGINT) +-- +ok +== +SELECT count(*) +FROM phj_probe_narrow_cast p +JOIN phj_build_narrow_cast b + ON CAST(CAST(p.k AS INTEGER) AS BIGINT) = CAST(b.k AS BIGINT) +-- +ok +== +SELECT count(*) +FROM phj_probe_narrow_cast p +JOIN phj_build_narrow_cast b + ON TRY_CAST(p.k AS INTEGER) = b.k +-- +ok +== +CREATE TABLE bf_build_narrow_cast_errors AS +SELECT (i * 1000)::INTEGER AS k +FROM range(0, 100000) t(i) +-- +ok +== +EXPLAIN ANALYZE +SELECT count(*) +FROM ( + SELECT * + FROM phj_probe_narrow_cast + WHERE k < 2000000000 +) p +JOIN bf_build_narrow_cast_errors b + ON p.k::INTEGER = b.k +-- +ok +== +SELECT count(*) +FROM phj_probe_narrow_cast p +JOIN bf_build_narrow_cast_errors b + ON p.k::INTEGER = b.k +-- +ok +== +EXPLAIN ANALYZE +SELECT count(*) +FROM ( + SELECT * + FROM phj_probe_narrow_cast + WHERE k < 2000000000 +) p +JOIN bf_build_narrow_cast_errors b + ON CAST(CAST(p.k AS INTEGER) AS BIGINT) = CAST(b.k AS BIGINT) +-- +ok +== +SELECT count(*) +FROM phj_probe_narrow_cast p +JOIN bf_build_narrow_cast_errors b + ON CAST(CAST(p.k AS INTEGER) AS BIGINT) = CAST(b.k AS BIGINT) +-- +ok +== +SELECT count(*) +FROM phj_probe_narrow_cast p +JOIN bf_build_narrow_cast_errors b + ON TRY_CAST(p.k AS INTEGER) = b.k +-- +ok +== +CREATE TABLE bf_probe_cast_up AS +SELECT i::INTEGER AS k, (i % 7)::INTEGER AS g +FROM range(0, 2000000) t(i) +-- +ok +== +CREATE TABLE bf_build_cast_up AS +SELECT (100000 + i * 3)::BIGINT AS k, ((100000 + i * 3) % 7)::INTEGER AS g +FROM range(0, 600000) t(i) +-- +ok +== +EXPLAIN ANALYZE +SELECT count(*) +FROM bf_probe_cast_up p +JOIN bf_build_cast_up b + ON p.k = b.k + AND p.g >= b.g +-- +ok +== +SELECT count(*) +FROM bf_probe_cast_up p +JOIN bf_build_cast_up b + ON p.k = b.k + AND p.g >= b.g +-- +ok +== +CREATE TABLE bf_probe_cast_down AS +SELECT i::BIGINT AS k, (i % 7)::INTEGER AS g +FROM range(0, 2000000) t(i) +-- +ok +== +CREATE TABLE bf_build_cast_down AS +SELECT (100000 + i * 3)::INTEGER AS k, ((100000 + i * 3) % 7)::INTEGER AS g +FROM range(0, 600000) t(i) +-- +ok +== +EXPLAIN ANALYZE +SELECT count(*) +FROM bf_probe_cast_down p +JOIN bf_build_cast_down b + ON p.k = b.k + AND p.g >= b.g +-- +ok +== +SELECT count(*) +FROM bf_probe_cast_down p +JOIN bf_build_cast_down b + ON p.k = b.k + AND p.g >= b.g +-- +ok +== +CREATE TABLE prf_parallel_wide_build AS +SELECT (i * 200)::INTEGER AS k +FROM range(0, 300000) t(i) +-- +ok +== +EXPLAIN ANALYZE +SELECT count(*) +FROM bf_probe_cast_up p +JOIN prf_parallel_wide_build b + ON p.k = b.k +-- +ok +== +SELECT count(*) +FROM bf_probe_cast_up p +JOIN prf_parallel_wide_build b + ON p.k = b.k +-- +ok +== +CREATE TABLE chained_comparison_filters AS +SELECT i::INTEGER AS a, i::INTEGER AS b +FROM range(0, 4096) t(i) +-- +ok +== +SELECT count(*) +FROM chained_comparison_filters +WHERE a >= 1000 AND b < 10 +-- +ok +== diff --git a/parser/testdata/corpus/sql/optimizer/temporal_cast_dst.test b/parser/testdata/corpus/sql/optimizer/temporal_cast_dst.test new file mode 100644 index 0000000..244a186 --- /dev/null +++ b/parser/testdata/corpus/sql/optimizer/temporal_cast_dst.test @@ -0,0 +1,43 @@ +# source: test/sql/optimizer/temporal_cast_dst.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +SET timezone='Europe/Paris'; +-- +ok +== +CREATE TABLE dst_table AS + SELECT '2026-10-25 00:00:00+02'::TIMESTAMPTZ + (i * INTERVAL '1 minute') AS col + FROM range(600) t(i); +-- +ok +== +EXPLAIN SELECT * FROM dst_table WHERE CAST(col AS TIMESTAMP) > '2026-10-25 02:30:00'::TIMESTAMP; +-- +ok +== +EXPLAIN SELECT * FROM dst_table WHERE CAST(col AS TIMESTAMP) <= '2026-10-25 02:30:00'::TIMESTAMP; +-- +ok +== +SELECT (SELECT count(*) FROM dst_table WHERE CAST(col AS TIMESTAMP) > '2026-10-25 02:30:00'::TIMESTAMP) + + (SELECT count(*) FROM dst_table WHERE CAST(col AS TIMESTAMP) <= '2026-10-25 02:30:00'::TIMESTAMP); +-- +ok +== +CREATE TABLE ts_dst_table AS + SELECT ('2026-10-25 00:00:00'::TIMESTAMP + (i * INTERVAL '1 minute')) AS col + FROM range(300) t(i); +-- +ok +== +EXPLAIN SELECT * FROM ts_dst_table WHERE CAST(col AS TIMESTAMPTZ) > '2026-10-25 02:30:00+01'::TIMESTAMPTZ; +-- +ok +== +SELECT (SELECT count(*) FROM ts_dst_table WHERE CAST(col AS TIMESTAMPTZ) > '2026-10-25 02:30:00+01'::TIMESTAMPTZ) + + (SELECT count(*) FROM ts_dst_table WHERE CAST(col AS TIMESTAMPTZ) <= '2026-10-25 02:30:00+01'::TIMESTAMPTZ); +-- +ok +== diff --git a/parser/testdata/corpus/sql/optimizer/temporal_cast_zonemap.test b/parser/testdata/corpus/sql/optimizer/temporal_cast_zonemap.test new file mode 100644 index 0000000..21cdb78 --- /dev/null +++ b/parser/testdata/corpus/sql/optimizer/temporal_cast_zonemap.test @@ -0,0 +1,129 @@ +# source: test/sql/optimizer/temporal_cast_zonemap.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +CREATE TABLE ts_table AS SELECT '2020-01-01'::TIMESTAMP + (i * INTERVAL '1 minute') AS col FROM range(1000000) t(i); +-- +ok +== +CREATE TABLE date_table AS SELECT ('2020-01-01'::DATE + (i * INTERVAL '1 day'))::DATE AS col FROM range(100000) d(i); +-- +ok +== +CREATE TABLE tsns_table AS SELECT ('2020-01-01'::TIMESTAMP + (i * INTERVAL '1 minute'))::TIMESTAMP_NS AS col FROM range(1000000) t(i); +-- +ok +== +CREATE TABLE tsms_table AS SELECT ('2020-01-01'::TIMESTAMP + (i * INTERVAL '1 minute'))::TIMESTAMP_MS AS col FROM range(1000000) t(i); +-- +ok +== +CREATE TABLE tss_table AS SELECT ('2020-01-01'::TIMESTAMP + (i * INTERVAL '1 minute'))::TIMESTAMP_S AS col FROM range(1000000) t(i); +-- +ok +== +EXPLAIN SELECT * FROM ts_table WHERE CAST(col AS TIMESTAMPTZ) > TIMESTAMPTZ '2020-06-01 00:00:00+00'; +-- +ok +== +EXPLAIN SELECT * FROM ts_table WHERE CAST(col AS TIMESTAMPTZ) <= TIMESTAMPTZ '2020-06-01 00:00:00+00'; +-- +ok +== +EXPLAIN SELECT * FROM date_table WHERE CAST(col AS TIMESTAMP) > '2024-01-01'::TIMESTAMP; +-- +ok +== +EXPLAIN SELECT * FROM date_table WHERE CAST(col AS TIMESTAMP) < '2021-01-01'::TIMESTAMP; +-- +ok +== +EXPLAIN SELECT * FROM date_table WHERE CAST(col AS TIMESTAMP) >= '2022-06-15'::TIMESTAMP; +-- +ok +== +EXPLAIN SELECT * FROM date_table WHERE CAST(col AS TIMESTAMP) = '2022-06-15'::TIMESTAMP; +-- +ok +== +EXPLAIN SELECT * FROM date_table WHERE CAST(col AS TIMESTAMP) > '2024-01-01 12:00:00'::TIMESTAMP; +-- +ok +== +EXPLAIN SELECT * FROM date_table WHERE CAST(col AS TIMESTAMP) = '2024-01-01 12:00:00'::TIMESTAMP; +-- +ok +== +EXPLAIN SELECT * FROM ts_table WHERE CAST(col AS DATE) > '2020-06-01'::DATE; +-- +ok +== +EXPLAIN SELECT * FROM tsns_table WHERE CAST(col AS TIMESTAMP) > '2020-06-01'::TIMESTAMP; +-- +ok +== +EXPLAIN SELECT * FROM ts_table WHERE CAST(col AS TIMESTAMP_MS) > '2020-06-01'::TIMESTAMP_MS; +-- +ok +== +EXPLAIN SELECT * FROM ts_table WHERE CAST(col AS TIMESTAMP_S) > '2020-06-01'::TIMESTAMP_S; +-- +ok +== +EXPLAIN SELECT * FROM tsms_table WHERE CAST(col AS DATE) > '2020-06-01'::DATE; +-- +ok +== +EXPLAIN SELECT * FROM tss_table WHERE CAST(col AS DATE) > '2020-06-01'::DATE; +-- +ok +== +EXPLAIN SELECT * FROM tsns_table WHERE CAST(col AS TIMESTAMP_MS) > '2020-06-01'::TIMESTAMP_MS; +-- +ok +== +EXPLAIN SELECT * FROM tsms_table WHERE CAST(col AS TIMESTAMP_S) > '2020-06-01'::TIMESTAMP_S; +-- +ok +== +EXPLAIN SELECT * FROM date_table WHERE '2024-01-01'::TIMESTAMP < CAST(col AS TIMESTAMP); +-- +ok +== +EXPLAIN SELECT * FROM date_table WHERE '2021-01-01'::TIMESTAMP > CAST(col AS TIMESTAMP); +-- +ok +== +EXPLAIN SELECT * FROM date_table WHERE CAST(col AS TIMESTAMP) != '2024-01-01'::TIMESTAMP; +-- +ok +== +CREATE TABLE int_table AS SELECT i AS col FROM range(100000) t(i); +-- +ok +== +EXPLAIN SELECT * FROM int_table WHERE CAST(col AS VARCHAR) > '50000'; +-- +ok +== +SELECT count(*) FROM date_table WHERE CAST(col AS TIMESTAMP) > '2024-01-01'::TIMESTAMP; +-- +ok +== +SELECT count(*) FROM date_table WHERE CAST(col AS TIMESTAMP) < '2021-01-01'::TIMESTAMP; +-- +ok +== +SELECT count(*) FROM date_table WHERE CAST(col AS TIMESTAMP) = '2022-06-15 00:00:00'::TIMESTAMP; +-- +ok +== +SELECT count(*) FROM date_table WHERE CAST(col AS TIMESTAMP) >= '2024-01-01'::TIMESTAMP; +-- +ok +== +SELECT count(*) FROM date_table WHERE CAST(col AS TIMESTAMP) <= '2020-01-03'::TIMESTAMP; +-- +ok +== diff --git a/parser/testdata/corpus/sql/optimizer/test_common_subplan_cte_binding_order.test b/parser/testdata/corpus/sql/optimizer/test_common_subplan_cte_binding_order.test new file mode 100644 index 0000000..8473fd7 --- /dev/null +++ b/parser/testdata/corpus/sql/optimizer/test_common_subplan_cte_binding_order.test @@ -0,0 +1,75 @@ +# source: test/sql/optimizer/test_common_subplan_cte_binding_order.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +CREATE TABLE orders (id INT, amount INT, status VARCHAR, created_at TIMESTAMP); +-- +ok +== +CREATE TABLE line_items (id INT, order_id INT, sku VARCHAR, extracted_at TIMESTAMP); +-- +ok +== +INSERT INTO orders VALUES + (1, 50, 'paid', '2025-01-01'), + (2, 75, 'paid', '2025-01-02'), + (3, 30, 'refunded', '2025-01-03'); +-- +ok +== +INSERT INTO line_items VALUES + (1, 1, 'WIDGET', '2025-01-01'), + (2, 2, 'GADGET', '2025-01-02'), + (3, 3, 'WIDGET', '2025-01-03'); +-- +ok +== +CREATE VIEW orders_deduped AS + SELECT id, amount, status + FROM orders + QUALIFY row_number() OVER (PARTITION BY id ORDER BY created_at DESC) = 1; +-- +ok +== +CREATE VIEW line_items_deduped AS + SELECT order_id, sku + FROM line_items + QUALIFY row_number() OVER (PARTITION BY id ORDER BY extracted_at DESC) = 1; +-- +ok +== +CREATE VIEW order_lifecycle AS + WITH sku_agg AS ( + SELECT order_id, sum(CASE WHEN sku = 'WIDGET' THEN 1 ELSE 0 END) AS widget_count + FROM line_items_deduped + GROUP BY order_id + ) + SELECT + o.amount, + CASE WHEN COALESCE(s.widget_count, 0) > 0 THEN 'widget_order' ELSE 'other' END AS order_type, + (o.status != 'refunded') AS is_net_order + FROM orders_deduped o + LEFT JOIN sku_agg s ON o.id = s.order_id; +-- +ok +== +WITH survey_daily AS ( + SELECT order_type, count(*) AS responses, sum(amount) AS revenue + FROM (SELECT amount, order_type FROM order_lifecycle) survey_results + GROUP BY order_type +), +daily_totals AS ( + SELECT count(*) AS total_orders + FROM order_lifecycle + WHERE is_net_order +) +SELECT order_type, responses::VARCHAR, revenue::VARCHAR, total_orders::VARCHAR +FROM ( + SELECT s.order_type, s.responses, s.revenue, dt.total_orders + FROM survey_daily s, daily_totals dt +) result +ORDER BY order_type; +-- +ok +== diff --git a/parser/testdata/corpus/sql/optimizer/test_common_subplan_projection_maps.test b/parser/testdata/corpus/sql/optimizer/test_common_subplan_projection_maps.test new file mode 100644 index 0000000..98bfd59 --- /dev/null +++ b/parser/testdata/corpus/sql/optimizer/test_common_subplan_projection_maps.test @@ -0,0 +1,198 @@ +# source: test/sql/optimizer/test_common_subplan_projection_maps.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +CREATE TABLE csp_pm_a_upserts(customer_id BIGINT, id BIGINT); +-- +ok +== +CREATE TABLE csp_pm_a_snapshot AS +SELECT 9999 + i AS customer_id, 9999 + i AS id +FROM range(1, 6) tbl(i); +-- +ok +== +CREATE TABLE csp_pm_a_deletes(id BIGINT); +-- +ok +== +CREATE VIEW csp_pm_a AS + (SELECT * FROM csp_pm_a_upserts) + UNION ALL + (SELECT tbl.customer_id, tbl.id + FROM csp_pm_a_snapshot tbl + ANTI JOIN csp_pm_a_deletes d ON tbl.id = d.id); +-- +ok +== +CREATE TABLE csp_pm_tx_upserts(a_id BIGINT, id BIGINT); +-- +ok +== +CREATE TABLE csp_pm_tx_snapshot AS +SELECT 9999 + i AS a_id, 9999 + i AS id +FROM range(1, 6) tbl(i); +-- +ok +== +CREATE TABLE csp_pm_tx_deletes(id BIGINT); +-- +ok +== +CREATE VIEW csp_pm_tx AS + (SELECT * FROM csp_pm_tx_upserts) + UNION ALL + (SELECT tbl.a_id, tbl.id + FROM csp_pm_tx_snapshot tbl + ANTI JOIN csp_pm_tx_deletes d ON tbl.id = d.id); +-- +ok +== +CREATE TABLE csp_pm_o_upserts(customer_id BIGINT, id BIGINT, flag BOOLEAN); +-- +ok +== +CREATE TABLE csp_pm_o_snapshot AS +SELECT 9999 + i AS id, + 10000 + ((i - 1) % 5) AS customer_id, + (i % 3 = 0) AS flag +FROM range(1, 5) tbl(i); +-- +ok +== +CREATE TABLE csp_pm_o_deletes(id BIGINT); +-- +ok +== +CREATE VIEW csp_pm_o AS + (SELECT * FROM csp_pm_o_upserts) + UNION ALL + (SELECT tbl.customer_id, tbl.id, tbl.flag + FROM csp_pm_o_snapshot tbl + ANTI JOIN csp_pm_o_deletes d ON tbl.id = d.id); +-- +ok +== +CREATE TABLE csp_pm_i_upserts(order_id BIGINT, product_id BIGINT, id BIGINT); +-- +ok +== +CREATE TABLE csp_pm_i_snapshot AS +SELECT 9999 + i AS id, + 10000 + ((i - 1) % 4) AS order_id, + 1 + ((i - 1) % 3) AS product_id +FROM range(1, 5) tbl(i); +-- +ok +== +CREATE TABLE csp_pm_i_deletes(id BIGINT); +-- +ok +== +CREATE VIEW csp_pm_i AS + (SELECT * FROM csp_pm_i_upserts) + UNION ALL + (SELECT tbl.order_id, tbl.product_id, tbl.id + FROM csp_pm_i_snapshot tbl + ANTI JOIN csp_pm_i_deletes d ON tbl.id = d.id); +-- +ok +== +CREATE TABLE csp_pm_p_upserts(id BIGINT, category VARCHAR, alert_at TIMETZ); +-- +ok +== +CREATE TABLE csp_pm_p_snapshot AS +SELECT i AS id, + 'cat' || (1 + ((i - 1) % 3)) AS category, + CASE WHEN i <= 2 THEN ('18:30:00.178')::TIMETZ ELSE ('18:29:00')::TIMETZ END AS alert_at +FROM range(1, 4) tbl(i); +-- +ok +== +CREATE TABLE csp_pm_p_deletes(id BIGINT); +-- +ok +== +CREATE VIEW csp_pm_p AS + (SELECT * FROM csp_pm_p_upserts) + UNION ALL + (SELECT tbl.id, tbl.category, tbl.alert_at + FROM csp_pm_p_snapshot tbl + ANTI JOIN csp_pm_p_deletes d ON tbl.id = d.id); +-- +ok +== +CREATE TABLE csp_pm_c_upserts(name VARCHAR, short_name VARCHAR, demand SMALLINT); +-- +ok +== +CREATE TABLE csp_pm_c_snapshot AS +SELECT 'cat' || i AS name, + 'short' || i AS short_name, + CASE WHEN i <= 1 THEN 2::SMALLINT ELSE 3::SMALLINT END AS demand +FROM range(1, 3) tbl(i); +-- +ok +== +CREATE TABLE csp_pm_c_deletes(name VARCHAR); +-- +ok +== +CREATE VIEW csp_pm_c AS + (SELECT * FROM csp_pm_c_upserts) + UNION ALL + (SELECT tbl.name, tbl.short_name, tbl.demand + FROM csp_pm_c_snapshot tbl + ANTI JOIN csp_pm_c_deletes d ON tbl.name = d.name); +-- +ok +== +SELECT MAX(CASE WHEN COALESCE(orders_by_customer.c1, 0) = 0 OR COALESCE(orders_by_customer.c2, 0) = 0 THEN 1 ELSE 2 END) +FROM csp_pm_a +LEFT JOIN ( + SELECT csp_pm_o.customer_id, + COUNT(product_info.name1) AS c1, + COUNT(product_info.name2) AS c2 + FROM csp_pm_o + INNER JOIN csp_pm_i ON csp_pm_o.id = csp_pm_i.order_id + LEFT JOIN ( + SELECT csp_pm_p.id, + category_info.name1 AS name1, + category_info.name2 AS name2 + FROM csp_pm_p + LEFT JOIN ( + SELECT csp_pm_c.name, + csp_pm_c.short_name AS name1, + csp_pm_c.short_name AS name2 + FROM csp_pm_c + WHERE csp_pm_c.demand <= 2::SMALLINT + ) AS category_info + ON csp_pm_p.category = category_info.name + WHERE csp_pm_p.alert_at >= ('18:30:00.178')::TIMETZ + ) AS product_info + ON csp_pm_i.product_id = product_info.id + GROUP BY csp_pm_o.customer_id +) AS orders_by_customer +ON csp_pm_a.customer_id = orders_by_customer.customer_id +LEFT JOIN csp_pm_tx +ON csp_pm_a.id = csp_pm_tx.a_id +LEFT JOIN ( + SELECT csp_pm_o.customer_id, + MAX(repeated_order.v) AS v + FROM csp_pm_o + LEFT JOIN ( + SELECT csp_pm_o.customer_id, + MIN(DISTINCT csp_pm_o.customer_id) AS v + FROM csp_pm_o + GROUP BY csp_pm_o.customer_id + ) AS repeated_order + ON csp_pm_o.customer_id = repeated_order.customer_id + WHERE csp_pm_o.flag != FALSE + GROUP BY csp_pm_o.customer_id +) AS unreferenced_branch +ON csp_pm_a.customer_id = unreferenced_branch.customer_id; +-- +ok +== diff --git a/parser/testdata/corpus/sql/optimizer/test_common_subplan_table_filters.test b/parser/testdata/corpus/sql/optimizer/test_common_subplan_table_filters.test new file mode 100644 index 0000000..ef692b4 --- /dev/null +++ b/parser/testdata/corpus/sql/optimizer/test_common_subplan_table_filters.test @@ -0,0 +1,49 @@ +# source: test/sql/optimizer/test_common_subplan_table_filters.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +CREATE TABLE csp_filter_key(a INTEGER, b INTEGER); +-- +ok +== +INSERT INTO csp_filter_key VALUES (1, 0), (2, 2), (3, 0), (4, 4); +-- +ok +== +SELECT 'a', count(*) FROM csp_filter_key WHERE a > 1 +UNION ALL +SELECT 'b', count(*) FROM csp_filter_key WHERE b > 1; +-- +ok +== +SELECT 'a', count(*) FROM csp_filter_key WHERE a > 1 AND b < 3 +UNION ALL +SELECT 'b', count(*) FROM csp_filter_key WHERE a < 3 AND b > 1; +-- +ok +== +SELECT 'a', count(*) FROM csp_filter_key WHERE a IN (2, 3, 4) +UNION ALL +SELECT 'b', count(*) FROM csp_filter_key WHERE b IN (2, 3, 4); +-- +ok +== +SELECT 'x', count(*) FROM csp_filter_key WHERE a > 1 +UNION ALL +SELECT 'y', count(*) FROM csp_filter_key WHERE a > 1; +-- +ok +== +EXPLAIN SELECT 'a', count(*) FROM csp_filter_key WHERE a > 1 +UNION ALL +SELECT 'b', count(*) FROM csp_filter_key WHERE b > 1; +-- +ok +== +EXPLAIN SELECT 'x', count(*) FROM csp_filter_key WHERE a > 1 +UNION ALL +SELECT 'y', count(*) FROM csp_filter_key WHERE a > 1; +-- +ok +== diff --git a/parser/testdata/corpus/sql/optimizer/test_duplicate_groups_optimizer.test b/parser/testdata/corpus/sql/optimizer/test_duplicate_groups_optimizer.test new file mode 100644 index 0000000..672af4c --- /dev/null +++ b/parser/testdata/corpus/sql/optimizer/test_duplicate_groups_optimizer.test @@ -0,0 +1,84 @@ +# source: test/sql/optimizer/test_duplicate_groups_optimizer.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +create table t1(col1 int, col2 int); +-- +ok +== +create table t2(col3 int); +-- +ok +== +insert into t1 values (1, 1); +-- +ok +== +select + col1, + col2, + col3 +from t1 + join t2 + on t1.col1 = t2.col3 +group by rollup(col1, col2, col3) order by 1, 2 ,3; +-- +ok +== +select + col1, + col2, + col3 +from t1 + join t2 + on t1.col1 = t2.col3 +group by cube(col1, col2, col3) order by 1, 2 ,3; +-- +ok +== +select + col1, + col2, + col3 + from t1 + join t2 + on t1.col1 = t2.col3 + group by grouping sets (col1, col2, col3), (col1, col2), (col1) order by 1, 2 ,3; +-- +ok +== +pragma explain_output='optimized_only'; +-- +ok +== +pragma disable_verification; +-- +ok +== +explain select + col1, + col3 +from t1 + join t2 + on t1.col1 = t2.col3 +group by col1, col3; +-- +ok +== +create table t3 (a int, b int, c int); +-- +ok +== +insert into t3 values +(1, 1, 1), +(1, 2, 2), +(1, 1, 1), +(1, 2, 1); +-- +ok +== +select * from t3 group by cube(a, b, c) order by all; +-- +ok +== diff --git a/parser/testdata/corpus/sql/optimizer/test_fd_derived_groups.test b/parser/testdata/corpus/sql/optimizer/test_fd_derived_groups.test new file mode 100644 index 0000000..e770d88 --- /dev/null +++ b/parser/testdata/corpus/sql/optimizer/test_fd_derived_groups.test @@ -0,0 +1,94 @@ +# source: test/sql/optimizer/test_fd_derived_groups.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +CREATE TABLE t(x INTEGER); +-- +ok +== +INSERT INTO t SELECT range FROM range(0, 100); +-- +ok +== +CREATE TABLE f(x DOUBLE); +-- +ok +== +INSERT INTO f VALUES (1.5), (1.7), (2.3); +-- +ok +== +SELECT x, (x-1)*2, count(*) FROM t WHERE x < 4 GROUP BY x, (x-1)*2 ORDER BY x; +-- +ok +== +SELECT floor(x), floor(x)+1, count(*) FROM f GROUP BY floor(x), floor(x)+1 ORDER BY floor(x); +-- +ok +== +SELECT signbit(x), count(*) FROM (VALUES (0e0::DOUBLE), (-0e0::DOUBLE)) t(x) GROUP BY x, signbit(x) ORDER BY signbit(x); +-- +ok +== +SELECT signbit(x), count(*) FROM (VALUES (0e0::FLOAT), (-0e0::FLOAT)) t(x) GROUP BY x, signbit(x) ORDER BY signbit(x); +-- +ok +== +SELECT signbit(s.b), count(*) FROM (VALUES ({'a': 1::INTEGER, 'b': 0e0::DOUBLE}), ({'a': 1::INTEGER, 'b': -0e0::DOUBLE})) t(s) GROUP BY s, signbit(s.b) ORDER BY signbit(s.b); +-- +ok +== +CREATE TABLE iv(i INTERVAL); +-- +ok +== +INSERT INTO iv VALUES (INTERVAL '1' DAY), (INTERVAL '24' HOUR); +-- +ok +== +SELECT i, datepart('day', i), count(*) FROM iv GROUP BY i, datepart('day', i) ORDER BY datepart('day', i); +-- +ok +== +EXPLAIN (FORMAT JSON) SELECT x, x-1, count(*) FROM t GROUP BY x, x-1; +-- +ok +== +EXPLAIN (FORMAT JSON) SELECT x, x-1, x+2, x*3, count(*) FROM t GROUP BY x, x-1, x+2, x*3; +-- +ok +== +EXPLAIN (FORMAT JSON) SELECT x, (x-1)*2, CAST((x+5)*7 AS BIGINT), count(*) + FROM t GROUP BY x, (x-1)*2, CAST((x+5)*7 AS BIGINT); +-- +ok +== +CREATE TABLE u(a INTEGER, b INTEGER); +-- +ok +== +INSERT INTO u VALUES (1, 10), (2, 20), (3, 30); +-- +ok +== +EXPLAIN (FORMAT JSON) SELECT a, a+b, count(*) FROM u GROUP BY a, a+b; +-- +ok +== +EXPLAIN (FORMAT JSON) SELECT x, (x - random()) * 2, count(*) FROM t GROUP BY x, (x - random()) * 2; +-- +ok +== +EXPLAIN (FORMAT JSON) SELECT x, x-1, count(*) FROM t GROUP BY GROUPING SETS ((x), (x-1)); +-- +ok +== +EXPLAIN (FORMAT JSON) SELECT x+1, x+2, count(*) FROM t GROUP BY x+1, x+2; +-- +ok +== +EXPLAIN (FORMAT JSON) SELECT floor(x), floor(x)+1, count(*) FROM f GROUP BY floor(x), floor(x)+1; +-- +ok +== diff --git a/parser/testdata/corpus/sql/optimizer/test_glob_row_group_pruning.test b/parser/testdata/corpus/sql/optimizer/test_glob_row_group_pruning.test new file mode 100644 index 0000000..b0b7f99 --- /dev/null +++ b/parser/testdata/corpus/sql/optimizer/test_glob_row_group_pruning.test @@ -0,0 +1,43 @@ +# source: test/sql/optimizer/test_glob_row_group_pruning.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +ATTACH '{TEST_DIR}/glob_prune.duckdb' AS db (ROW_GROUP_SIZE 2048); +-- +ok +== +CREATE TABLE t AS + SELECT CASE + WHEN range < 2048 THEN 'aaa' || range::VARCHAR + WHEN range < 4096 THEN 'mmm' || range::VARCHAR + ELSE 'zzz' || range::VARCHAR + END AS s + FROM range(6144); +-- +ok +== +EXPLAIN ANALYZE SELECT count(*) FROM t WHERE s GLOB 'mmm*'; +-- +ok +== +SELECT count(*) FROM t WHERE s GLOB 'mmm*'; +-- +ok +== +EXPLAIN ANALYZE SELECT count(*) FROM t WHERE s GLOB 'qqq'; +-- +ok +== +SELECT count(*) FROM t WHERE s GLOB 'qqq'; +-- +ok +== +EXPLAIN ANALYZE SELECT count(*) FROM t WHERE s GLOB 'm?m*'; +-- +ok +== +SELECT count(*) FROM t WHERE s NOT GLOB 'qqq'; +-- +ok +== diff --git a/parser/testdata/corpus/sql/optimizer/test_in_rewrite_rule.test b/parser/testdata/corpus/sql/optimizer/test_in_rewrite_rule.test new file mode 100644 index 0000000..dbe29bb --- /dev/null +++ b/parser/testdata/corpus/sql/optimizer/test_in_rewrite_rule.test @@ -0,0 +1,29 @@ +# source: test/sql/optimizer/test_in_rewrite_rule.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +create table t (i integer); +-- +ok +== +insert into t values (1) +-- +ok +== +insert into t values (2) +-- +ok +== +select * from t where i in ('1','2','y'); +-- +ok +== +SELECT x::VARCHAR IN ('1', y::VARCHAR) FROM (VALUES (1, 2), (2, 3)) tbl(x, y); +-- +ok +== +SELECT x::BIGINT IN (1::BIGINT, y) FROM (VALUES (1::INTEGER, 2::BIGINT), (2::INTEGER, 3::BIGINT)) tbl(x, y); +-- +ok +== diff --git a/parser/testdata/corpus/sql/optimizer/test_negated_filter_cardinality.test b/parser/testdata/corpus/sql/optimizer/test_negated_filter_cardinality.test new file mode 100644 index 0000000..20357a4 --- /dev/null +++ b/parser/testdata/corpus/sql/optimizer/test_negated_filter_cardinality.test @@ -0,0 +1,41 @@ +# source: test/sql/optimizer/test_negated_filter_cardinality.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +CREATE TABLE strings(value VARCHAR NOT NULL); +-- +ok +== +INSERT INTO strings SELECT CASE WHEN i % 10 = 0 THEN 'special requests' ELSE 'ordinary' END FROM range(1000) t(i); +-- +ok +== +CREATE TABLE nullable_strings AS SELECT CASE WHEN i = 0 THEN NULL ELSE 'ordinary' END AS value FROM range(1000) t(i); +-- +ok +== +CREATE TABLE one_string(value VARCHAR NOT NULL); +-- +ok +== +INSERT INTO one_string VALUES ('ordinary'); +-- +ok +== +EXPLAIN (FORMAT JSON) SELECT * FROM strings WHERE value LIKE '%special%requests%'; +-- +ok +== +EXPLAIN (FORMAT JSON) SELECT * FROM strings WHERE value NOT LIKE '%special%requests%'; +-- +ok +== +EXPLAIN (FORMAT JSON) SELECT * FROM one_string WHERE value NOT LIKE '%special%requests%'; +-- +ok +== +EXPLAIN (FORMAT JSON) SELECT * FROM nullable_strings WHERE value NOT LIKE '%special%requests%'; +-- +ok +== diff --git a/parser/testdata/corpus/sql/optimizer/test_no_pushdown_cast_into_cte.test b/parser/testdata/corpus/sql/optimizer/test_no_pushdown_cast_into_cte.test new file mode 100644 index 0000000..a3c5675 --- /dev/null +++ b/parser/testdata/corpus/sql/optimizer/test_no_pushdown_cast_into_cte.test @@ -0,0 +1,87 @@ +# source: test/sql/optimizer/test_no_pushdown_cast_into_cte.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +WITH t(a, b) AS ( + SELECT a :: int, b :: int + FROM (VALUES + ('1', '4'), + ('5', '3'), + ('2', '*'), + ('3', '8'), + ('7', '*')) AS _(a, b) + WHERE position('*' in b) = 0 +) +SELECT a, b +FROM t +WHERE a < b; +-- +ok +== +EXPLAIN WITH t(a, b) AS ( + SELECT a :: int, b :: int + FROM (VALUES + ('1', '4'), + ('5', '3'), + ('2', '*'), + ('3', '8'), + ('7', '*')) AS _(a, b) + WHERE position('*' in b) = 0 +) +SELECT a, b +FROM t +WHERE a < b; +-- +ok +== +with t(a, b) as ( + select a :: varchar, b :: varchar + FROM VALUES + (1, 2), + (3, 3), + (5, 6), + (7, 6) as + _(a, b) where a <= b +) select a, b from t where a[1] = '1'; +-- +ok +== +explain with t(a, b) as ( + select a :: varchar, b :: varchar + FROM VALUES + (1, 2), + (3, 3), + (5, 6), + (7, 6) as + _(a, b) where a <= b +) select a, b from t where a[1] = '1'; +-- +ok +== +create or replace table mytablename2 as +from (values + ('a0'), + ('a1'), + ('a2'), + ('xxx-0'), + ('xxx-1'), + ('xxx-2'), + ('xxx-3'), + ('xxxx'), + ('xxx0'), + ('xxx1'), + ('xxx2'), + ('xxx3') +) t(mycolname), +range(4300) b(someothercolname) +-- +ok +== +select + mycolname[2:]::int as mycolname2 +from mytablename2 +where mycolname[1:3] != 'xxx' AND mycolname2 = 0 limit 5; +-- +ok +== diff --git a/parser/testdata/corpus/sql/optimizer/test_not_comparison_simplification.test b/parser/testdata/corpus/sql/optimizer/test_not_comparison_simplification.test new file mode 100644 index 0000000..10fcfcc --- /dev/null +++ b/parser/testdata/corpus/sql/optimizer/test_not_comparison_simplification.test @@ -0,0 +1,49 @@ +# source: test/sql/optimizer/test_not_comparison_simplification.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +CREATE TABLE t AS SELECT * FROM (VALUES (1),(2),(3),(NULL)) v(a); +-- +ok +== +EXPLAIN SELECT * FROM t WHERE NOT (a > 2); +-- +ok +== +EXPLAIN SELECT * FROM t WHERE NOT (a >= 2); +-- +ok +== +EXPLAIN SELECT * FROM t WHERE NOT (a < 2); +-- +ok +== +EXPLAIN SELECT * FROM t WHERE NOT (a <= 2); +-- +ok +== +EXPLAIN SELECT * FROM t WHERE NOT (a = 2); +-- +ok +== +EXPLAIN SELECT * FROM t WHERE NOT (a != 2); +-- +ok +== +EXPLAIN SELECT * FROM t WHERE NOT (a IS DISTINCT FROM 2); +-- +ok +== +EXPLAIN SELECT * FROM t WHERE NOT (a IS NOT DISTINCT FROM 2); +-- +ok +== +SELECT * FROM t WHERE NOT (a > 2) +-- +ok +== +SELECT * FROM t WHERE NOT (a = 1) ORDER BY a +-- +ok +== diff --git a/parser/testdata/corpus/sql/optimizer/test_rollup_column_pruning.test b/parser/testdata/corpus/sql/optimizer/test_rollup_column_pruning.test new file mode 100644 index 0000000..24c9847 --- /dev/null +++ b/parser/testdata/corpus/sql/optimizer/test_rollup_column_pruning.test @@ -0,0 +1,67 @@ +# source: test/sql/optimizer/test_rollup_column_pruning.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +CREATE TABLE events( + col1 INT, + col2 INT, + col3 INT, + unused1 INT, + unused2 INT, + unused3 INT +); +-- +ok +== +INSERT INTO events VALUES + (1, 1, 1, 100, 200, 300), + (1, 2, 2, 100, 200, 300), + (2, 1, 3, 100, 200, 300); +-- +ok +== +EXPLAIN SELECT col1, COUNT(*) FROM events GROUP BY ROLLUP(col1); +-- +ok +== +CREATE TABLE t2(col4 INT); +-- +ok +== +INSERT INTO t2 VALUES (1), (2); +-- +ok +== +EXPLAIN SELECT col1, col2, col4 +FROM events JOIN t2 ON events.col1 = t2.col4 +GROUP BY ROLLUP(col1, col2, col4); +-- +ok +== +EXPLAIN WITH limited AS ( + SELECT col1, col2 FROM events WHERE col3 = 1 LIMIT 10 +) +SELECT e.col1, COUNT(*) +FROM events e +WHERE e.col1 IN (SELECT col1 FROM limited) +GROUP BY ROLLUP(e.col1); +-- +ok +== +SELECT col1, col2, col4, COUNT(*) +FROM events JOIN t2 ON events.col1 = t2.col4 +GROUP BY ROLLUP(col1, col2, col4); +-- +ok +== +WITH limited AS ( + SELECT col1, col2 FROM events WHERE col3 = 1 LIMIT 10 +) +SELECT e.col1, COUNT(*) +FROM events e +WHERE e.col1 IN (SELECT col1 FROM limited) +GROUP BY ROLLUP(e.col1); +-- +ok +== diff --git a/parser/testdata/corpus/sql/optimizer/test_rowid_pruning.test b/parser/testdata/corpus/sql/optimizer/test_rowid_pruning.test new file mode 100644 index 0000000..f50bdf5 --- /dev/null +++ b/parser/testdata/corpus/sql/optimizer/test_rowid_pruning.test @@ -0,0 +1,73 @@ +# source: test/sql/optimizer/test_rowid_pruning.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +CREATE TABLE rowid_prune AS SELECT range AS v FROM range(300000); +-- +ok +== +EXPLAIN ANALYZE SELECT count(*) FROM rowid_prune WHERE rowid = 0; +-- +ok +== +EXPLAIN ANALYZE SELECT count(*) FROM rowid_prune WHERE rowid BETWEEN 0 AND 10; +-- +ok +== +EXPLAIN ANALYZE SELECT count(*) FROM rowid_prune WHERE rowid = 122879; +-- +ok +== +SELECT count(*) FROM rowid_prune WHERE rowid = 122879; +-- +ok +== +EXPLAIN ANALYZE SELECT count(*) FROM rowid_prune WHERE rowid = 122880; +-- +ok +== +SELECT count(*) FROM rowid_prune WHERE rowid = 122880; +-- +ok +== +EXPLAIN ANALYZE SELECT count(*) FROM rowid_prune WHERE rowid = 245759; +-- +ok +== +SELECT count(*) FROM rowid_prune WHERE rowid = 245759; +-- +ok +== +EXPLAIN ANALYZE SELECT count(*) FROM rowid_prune WHERE rowid = 245760; +-- +ok +== +SELECT count(*) FROM rowid_prune WHERE rowid = 245760; +-- +ok +== +EXPLAIN ANALYZE SELECT count(*) FROM rowid_prune WHERE rowid = 300000; +-- +ok +== +SELECT count(*) FROM rowid_prune WHERE rowid = 300000; +-- +ok +== +EXPLAIN ANALYZE SELECT count(*) FROM rowid_prune WHERE rowid >= 300000; +-- +ok +== +SELECT count(*) FROM rowid_prune WHERE rowid >= 300000; +-- +ok +== +CREATE TABLE empty_rowid_prune(i INTEGER); +-- +ok +== +SELECT count(*) FROM empty_rowid_prune WHERE rowid = 0; +-- +ok +== diff --git a/parser/testdata/corpus/sql/optimizer/test_rowid_pushdown.test b/parser/testdata/corpus/sql/optimizer/test_rowid_pushdown.test new file mode 100644 index 0000000..ebfaea7 --- /dev/null +++ b/parser/testdata/corpus/sql/optimizer/test_rowid_pushdown.test @@ -0,0 +1,45 @@ +# source: test/sql/optimizer/test_rowid_pushdown.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +CREATE TABLE t1 AS SELECT i + 100 as x FROM range(250000) AS t(i); +-- +ok +== +SELECT * FROM t1 where rowid = 6; +-- +ok +== +EXPLAIN SELECT * FROM t1 where rowid = 6; +-- +ok +== +SELECT * FROM t1 where rowid = 200000; +-- +ok +== +EXPLAIN SELECT * FROM t1 where rowid = 200000; +-- +ok +== +SELECT * FROM t1 where rowid IN (SELECT rowid FROM t1 ORDER BY rowid DESC LIMIT 10) ORDER BY rowid; +-- +ok +== +SELECT * FROM t1 where rowid IN (6, 9) ORDER BY ALL; +-- +ok +== +EXPLAIN SELECT * FROM t1 where rowid IN (6, 9); +-- +ok +== +SELECT * FROM t1 where rowid = 6 OR rowid = 9 ORDER BY ALL; +-- +ok +== +EXPLAIN SELECT * FROM t1 where rowid = 6 OR rowid = 9 ORDER BY ALL; +-- +ok +== diff --git a/parser/testdata/corpus/sql/optimizer/test_rowid_pushdown_deletes.test b/parser/testdata/corpus/sql/optimizer/test_rowid_pushdown_deletes.test new file mode 100644 index 0000000..93df123 --- /dev/null +++ b/parser/testdata/corpus/sql/optimizer/test_rowid_pushdown_deletes.test @@ -0,0 +1,21 @@ +# source: test/sql/optimizer/test_rowid_pushdown_deletes.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +CREATE TABLE tbl_grow_shrink (id_var VARCHAR, id_int INTEGER, id_point BIGINT); +-- +ok +== +INSERT INTO tbl_grow_shrink VALUES ('hello there stranger! :sunshine:', 2, {i}); +-- +error: Parser Error: syntax error at or near "}" +== +SELECT id_int, id_point = {i} FROM tbl_grow_shrink WHERE rowid = (SELECT min(rowid) FROM tbl_grow_shrink); +-- +error: Parser Error: syntax error at or near "}" +== +DELETE FROM tbl_grow_shrink WHERE rowid = (SELECT min(rowid) FROM tbl_grow_shrink); +-- +ok +== diff --git a/parser/testdata/corpus/sql/optimizer/test_rowid_pushdown_plan.test b/parser/testdata/corpus/sql/optimizer/test_rowid_pushdown_plan.test new file mode 100644 index 0000000..3270309 --- /dev/null +++ b/parser/testdata/corpus/sql/optimizer/test_rowid_pushdown_plan.test @@ -0,0 +1,25 @@ +# source: test/sql/optimizer/test_rowid_pushdown_plan.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +SELECT * FROM lineitem ORDER BY l_orderkey DESC LIMIT 5; +-- +ok +== +SELECT * FROM lineitem WHERE rowid IN (SELECT rowid FROM lineitem ORDER BY l_orderkey DESC LIMIT 5); +-- +ok +== +SELECT * FROM lineitem WHERE l_orderkey % 20000 == 0; +-- +ok +== +SELECT * FROM lineitem WHERE rowid IN (SELECT rowid FROM lineitem WHERE l_orderkey % 20000 == 0); +-- +ok +== +EXPLAIN SELECT * FROM lineitem WHERE rowid = 20058; +-- +ok +== diff --git a/parser/testdata/corpus/sql/optimizer/test_window_self_join.test b/parser/testdata/corpus/sql/optimizer/test_window_self_join.test new file mode 100644 index 0000000..7a00e8a --- /dev/null +++ b/parser/testdata/corpus/sql/optimizer/test_window_self_join.test @@ -0,0 +1,273 @@ +# source: test/sql/optimizer/test_window_self_join.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +CREATE TABLE services (date DATE, train_number INT); +-- +ok +== +INSERT INTO services VALUES ('2024-01-01', 100), ('2024-01-01', 100), ('2024-01-01', 101), ('2024-01-02', 100); +-- +ok +== +EXPLAIN FROM services QUALIFY count(*) OVER(PARTITION BY date, train_number) = 1; +-- +ok +== +FROM services QUALIFY count(*) OVER(PARTITION BY date, train_number) = 1 +ORDER BY ALL; +-- +ok +== +EXPLAIN FROM services QUALIFY count(*) OVER(PARTITION BY date, train_number) > 1; +-- +ok +== +FROM services QUALIFY count(*) OVER(PARTITION BY date, train_number) > 1; +-- +ok +== +EXPLAIN FROM services QUALIFY count(*) OVER(PARTITION BY date, train_number) = 2; +-- +ok +== +FROM services QUALIFY count(*) OVER(PARTITION BY date, train_number) = 2; +-- +ok +== +EXPLAIN FROM services QUALIFY count(*) OVER() = 1; +-- +ok +== +EXPLAIN FROM services QUALIFY count(*) OVER(PARTITION BY date ORDER BY train_number) = 1; +-- +ok +== +CREATE TABLE items (id INT, category VARCHAR); +-- +ok +== +INSERT INTO items VALUES (1, 'A'), (2, 'A'), (3, 'B'), (4, 'C'), (5, 'C'); +-- +ok +== +FROM items QUALIFY count(*) OVER(PARTITION BY category) = 1; +-- +ok +== +EXPLAIN FROM items QUALIFY count(*) OVER(PARTITION BY category) = 1; +-- +ok +== +CREATE TABLE null_partition_test (id INT, category VARCHAR); +-- +ok +== +INSERT INTO null_partition_test VALUES (1, 'A'), (2, 'A'), (3, NULL), (4, NULL), (5, 'B'); +-- +ok +== +FROM null_partition_test QUALIFY count(*) OVER(PARTITION BY category) = 1; +-- +ok +== +EXPLAIN FROM null_partition_test QUALIFY count(*) OVER(PARTITION BY category) = 1; +-- +ok +== +EXPLAIN +FROM services QUALIFY max(train_number) OVER(PARTITION BY date, train_number) = 101; +-- +ok +== +FROM services QUALIFY max(train_number) OVER(PARTITION BY date, train_number) = 101; +-- +ok +== +EXPLAIN +FROM services +QUALIFY max(train_number) OVER(PARTITION BY date, train_number) = 100 + AND count(*) OVER(PARTITION BY date, train_number) = 1; +-- +ok +== +FROM services +QUALIFY max(train_number) OVER(PARTITION BY date, train_number) = 100 + AND count(*) OVER(PARTITION BY date, train_number) = 1; +-- +ok +== +EXPLAIN +FROM services +WHERE date > '2024-06-30'::DATE +QUALIFY max(train_number) OVER(PARTITION BY date, train_number) = 100 + AND count(*) OVER(PARTITION BY date, train_number) = 1; +-- +ok +== +EXPLAIN +SELECT *, + list(train_number) OVER( + PARTITION BY date + ORDER BY train_number DESC + ROWS BETWEEN UNBOUNDED PRECEDING AND UNBOUNDED FOLLOWING + ) as trains +FROM services +-- +ok +== +SELECT + *, + list(train_number) OVER( + PARTITION BY date + ORDER BY train_number DESC + ROWS BETWEEN UNBOUNDED PRECEDING AND UNBOUNDED FOLLOWING + ) as trains +FROM services +-- +ok +== +EXPLAIN +SELECT *, + list(DISTINCT train_number) OVER( + PARTITION BY date + ORDER BY train_number DESC + ROWS BETWEEN UNBOUNDED PRECEDING AND UNBOUNDED FOLLOWING + ) as trains +FROM services +-- +ok +== +SELECT + *, + list(DISTINCT train_number) OVER( + PARTITION BY date + ORDER BY train_number DESC + ROWS BETWEEN UNBOUNDED PRECEDING AND UNBOUNDED FOLLOWING + ) as trains +FROM services +-- +ok +== +EXPLAIN +SELECT *, + list(DISTINCT train_number) OVER( + PARTITION BY train_number + ORDER BY date DESC + ROWS BETWEEN UNBOUNDED PRECEDING AND UNBOUNDED FOLLOWING + ) as trains +FROM services +-- +ok +== +SELECT + SUM(DISTINCT q) OVER ( + PARTITION BY 1 + ORDER BY b + ROWS BETWEEN UNBOUNDED PRECEDING AND UNBOUNDED FOLLOWING + ) AS wf +FROM (VALUES (1, 1), (2, 1)) AS t(b, q); +-- +ok +== +explain +SELECT seq, + sum(seq) OVER (PARTITION BY grp ROWS BETWEEN UNBOUNDED PRECEDING AND CURRENT ROW) AS cumsum +FROM (VALUES (1,'A'),(2,'A'),(3,'A'),(1,'B'),(2,'B')) AS t(seq, grp) +ORDER BY grp, seq; +-- +ok +== +explain +SELECT seq, + sum(seq) OVER (PARTITION BY grp {framing} BETWEEN UNBOUNDED PRECEDING AND CURRENT ROW) AS cumsum +FROM (VALUES (1,'A'),(2,'A'),(3,'A'),(1,'B'),(2,'B')) AS t(seq, grp) +ORDER BY grp, seq; +-- +error: Parser Error: syntax error at or near "{" +== +CREATE +OR REPLACE TABLE foo ( + emp_name VARCHAR, + dept_name VARCHAR, + base_salary FLOAT +); +-- +ok +== +INSERT INTO + foo +VALUES + ('a', 'x', 1.0), + ('b', 'x', 2.0), + ('c', 'x', 3.0), + ('d', 'y', 4.0), + ('e', 'y', 5.0), + ('f', 'y', 6.0); +-- +ok +== +select + avg(avg(base_salary)) over ( + partition by + dept_name + ) +from + foo +group by + dept_name +order by all; +-- +ok +== +explain +select + avg(avg(base_salary)) over ( + partition by + dept_name + ) +from + foo +group by + dept_name +order by all; +-- +ok +== +CREATE OR REPLACE TABLE t(id INTEGER, x DOUBLE); +-- +ok +== +INSERT INTO t VALUES (1, 10.0); +-- +ok +== +SELECT id, SUM(x) OVER (PARTITION BY id) AS outer_sum +FROM ( + SELECT id, x, LAG(total, 1, 0) OVER (PARTITION BY id) AS prev_total + FROM ( + SELECT id, x, COUNT(*) OVER (PARTITION BY id) AS total + FROM t + ) AS a +) AS b; +-- +ok +== +CREATE OR REPLACE SEQUENCE seq; +-- +ok +== +CREATE OR REPLACE TABLE t AS SELECT * FROM range(6) tt(i); +-- +ok +== +SELECT g, n, sum(n) OVER (PARTITION BY g) s +FROM ( + SELECT nextval('seq') g, i n + FROM t +) +ORDER BY n; +-- +ok +== diff --git a/parser/testdata/corpus/sql/optimizer/tests_no_pushdown_under_samples.test b/parser/testdata/corpus/sql/optimizer/tests_no_pushdown_under_samples.test new file mode 100644 index 0000000..ae18393 --- /dev/null +++ b/parser/testdata/corpus/sql/optimizer/tests_no_pushdown_under_samples.test @@ -0,0 +1,22 @@ +# source: test/sql/optimizer/tests_no_pushdown_under_samples.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +CREATE OR REPLACE TABLE df AS (SELECT * AS i FROM range(10)); +-- +ok +== +CREATE OR REPLACE TABLE wtf AS (SELECT 1 AS i); +-- +ok +== +explain FROM +df, wtf +SELECT +df.i +WHERE df.i > 8 +USING SAMPLE 1; +-- +ok +== diff --git a/parser/testdata/corpus/sql/optimizer/topn_window_elimination_late_materialization.test b/parser/testdata/corpus/sql/optimizer/topn_window_elimination_late_materialization.test new file mode 100644 index 0000000..d4bd452 --- /dev/null +++ b/parser/testdata/corpus/sql/optimizer/topn_window_elimination_late_materialization.test @@ -0,0 +1,93 @@ +# source: test/sql/optimizer/topn_window_elimination_late_materialization.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +CREATE TABLE sample_table AS +SELECT generate_series AS id, id % 4 AS partition_key, id % 7 AS sort_key, 'C:/file.txt' AS path +FROM generate_series(10); +-- +ok +== +CREATE VIEW sample_view AS SELECT *, parse_filename(path) AS filename FROM sample_table; +-- +ok +== +EXPLAIN SELECT * FROM sample_view +QUALIFY row_number() OVER (PARTITION BY partition_key ORDER BY sort_key) = 1 +-- +ok +== +SELECT id, partition_key, sort_key, path, filename FROM sample_view +QUALIFY row_number() OVER (PARTITION BY partition_key ORDER BY sort_key) = 1 +ORDER BY partition_key +-- +ok +== +CREATE TABLE t(id INTEGER, g INTEGER, s INTEGER, v VARCHAR, n INTEGER) +-- +ok +== +INSERT INTO t VALUES (1, 0, 5, 'aa', 10), (2, 0, 3, 'bb', 20), (3, 1, 2, 'cc', 30), (4, 1, 9, 'dd', 40), (5, 0, 1, 'ee', 50) +-- +ok +== +SELECT id, upper(v) FROM (SELECT *, upper(v) AS uv FROM t) +QUALIFY row_number() OVER (PARTITION BY g ORDER BY s) = 1 +ORDER BY g +-- +ok +== +SELECT id, np FROM (SELECT *, n + 1 AS np FROM t) +QUALIFY row_number() OVER (PARTITION BY g ORDER BY s) = 1 +ORDER BY g +-- +ok +== +EXPLAIN SELECT id, gp, v FROM (SELECT id, g + 1 AS gp, s, v FROM t) +QUALIFY row_number() OVER (PARTITION BY gp ORDER BY s) = 1 +-- +ok +== +SELECT id, gp, v FROM (SELECT id, g + 1 AS gp, s, v FROM t) +QUALIFY row_number() OVER (PARTITION BY gp ORDER BY s) = 1 +ORDER BY gp +-- +ok +== +SELECT id, uv FROM (SELECT *, upper(v) AS uv FROM t) +QUALIFY row_number() OVER (PARTITION BY g ORDER BY s) <= 2 +ORDER BY g, id +-- +ok +== +SELECT uv FROM (SELECT *, upper(v) AS uv FROM t) +QUALIFY row_number() OVER (PARTITION BY g ORDER BY s) = 1 +ORDER BY uv +-- +ok +== +SELECT id, cf FROM (SELECT *, CAST(upper(v) AS VARCHAR) AS cf FROM t) +QUALIFY row_number() OVER (PARTITION BY g ORDER BY s) = 1 +ORDER BY g +-- +ok +== +CREATE TABLE casted (a VARCHAR, b BOOLEAN, c VARCHAR) +-- +ok +== +INSERT INTO casted VALUES ('x', false, '2024-01-01') +-- +ok +== +EXPLAIN WITH cte AS (SELECT a, b, c::TIMESTAMPTZ AS c FROM casted) +SELECT * FROM cte QUALIFY row_number() OVER (PARTITION BY a ORDER BY c DESC) = 1 +-- +ok +== +WITH cte AS (SELECT a, b, c::TIMESTAMPTZ AS c FROM casted) +SELECT * FROM cte QUALIFY row_number() OVER (PARTITION BY a ORDER BY c DESC) = 1 +-- +ok +== diff --git a/parser/testdata/corpus/sql/optimizer/topn_window_set_elimination.test b/parser/testdata/corpus/sql/optimizer/topn_window_set_elimination.test new file mode 100644 index 0000000..60202b9 --- /dev/null +++ b/parser/testdata/corpus/sql/optimizer/topn_window_set_elimination.test @@ -0,0 +1,56 @@ +# source: test/sql/optimizer/topn_window_set_elimination.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +CREATE or replace TABLE timeseries AS +FROM ( + VALUES + (timestamp '2026-03-25 05:33:11.822+08', 10), + (timestamp '2026-03-26 05:33:11.822+08', 15), + (timestamp '2026-03-27 05:33:11.822+08', 12), + (timestamp '2026-03-28 05:33:11.822+08', 18), + (timestamp '2026-03-29 05:33:11.822+08', 14) +) AS t(date, value); +-- +ok +== +CREATE OR REPLACE MACRO nextValue(time_serie, ts_col, value_col, ts) AS TABLE ( + (SELECT + ts_col, + value_col + FROM query_table(time_serie) + WHERE ts_col >= ts order by ts_col limit 1) + union + select + ts AS ts_col, + (select value_col from query_table(time_serie) order by ts_col desc limit 1) AS value_col + WHERE NOT EXISTS (FROM query_table(time_serie) WHERE ts_col >= ts) +); +-- +ok +== +from range(1,5) as t(days), +nextValue(timeseries, date, value, '2026-03-29 05:33:11.822+08'::timestamp - INTERVAL (days) DAY) +limit 5; +-- +ok +== +CREATE TABLE t2 (a VARCHAR, b BOOLEAN, c VARCHAR); +-- +ok +== +INSERT INTO t2 VALUES ('x', false, '2024-01-01'); +-- +ok +== +WITH cte AS ( + SELECT a, b, c::TIMESTAMPTZ AS c + FROM t2 +) +SELECT * +FROM cte +QUALIFY ROW_NUMBER() OVER (PARTITION BY a ORDER BY c DESC) = 1; +-- +ok +== diff --git a/parser/testdata/corpus/sql/optimizer/window_self_join_optimizer_csv.test b/parser/testdata/corpus/sql/optimizer/window_self_join_optimizer_csv.test new file mode 100644 index 0000000..f3d7e19 --- /dev/null +++ b/parser/testdata/corpus/sql/optimizer/window_self_join_optimizer_csv.test @@ -0,0 +1,21 @@ +# source: test/sql/optimizer/window_self_join_optimizer_csv.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +COPY ( + SELECT 'a' AS x, 10 AS a, 20 AS b, 30 AS c + UNION ALL BY NAME + SELECT 'b' AS x, 11 AS a, 21 AS b, 31 AS c + UNION ALL BY NAME + SELECT 'c' AS x, 12 AS a, 22 AS b, 32 AS c +) TO '{TEST_DIR}/window_self_join_src.csv' +-- +ok +== +SELECT + x, MAX(a) OVER (PARTITION BY x) +FROM '{TEST_DIR}/window_self_join_src.csv' +-- +ok +== diff --git a/parser/testdata/corpus/sql/order/hugeint_order_by_extremes.test b/parser/testdata/corpus/sql/order/hugeint_order_by_extremes.test new file mode 100644 index 0000000..fd93503 --- /dev/null +++ b/parser/testdata/corpus/sql/order/hugeint_order_by_extremes.test @@ -0,0 +1,21 @@ +# source: test/sql/order/hugeint_order_by_extremes.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +CREATE TABLE test (a hugeint); +-- +ok +== +INSERT INTO test values ((-170141183460469231731687303715884105728)::hugeint), (-1111::hugeint), (-1::hugeint), (0::hugeint), (1::hugeint), (1111::hugeint); +-- +ok +== +SELECT * FROM test order by a; +-- +ok +== +SELECT * FROM test order by a DESC; +-- +ok +== diff --git a/parser/testdata/corpus/sql/order/issue_11936.test b/parser/testdata/corpus/sql/order/issue_11936.test new file mode 100644 index 0000000..9d3dc38 --- /dev/null +++ b/parser/testdata/corpus/sql/order/issue_11936.test @@ -0,0 +1,17 @@ +# source: test/sql/order/issue_11936.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +CREATE TABLE test(col1 INT, col2 INT2[][][][][][]); +-- +ok +== +INSERT INTO test VALUES(1000000000, null), (1000000001, [[[[[[]]]]]]), (null, [[[[[[]]]]]]), (null, [[[[[[]]]]]]), (1, [[[[[[]]]]]]); +-- +ok +== +SELECT col1, col2 FROM test ORDER BY col1 NULLS LAST, col2; +-- +ok +== diff --git a/parser/testdata/corpus/sql/order/limit_full_outer_join.test b/parser/testdata/corpus/sql/order/limit_full_outer_join.test new file mode 100644 index 0000000..cfcb5d4 --- /dev/null +++ b/parser/testdata/corpus/sql/order/limit_full_outer_join.test @@ -0,0 +1,13 @@ +# source: test/sql/order/limit_full_outer_join.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +SELECT i, j, k, l FROM integers FULL OUTER JOIN integers2 ON integers.i=integers2.k ORDER BY ALL LIMIT 2 +-- +ok +== +SELECT COUNT(*) FROM (SELECT i, j, k, l FROM integers FULL OUTER JOIN integers2 ON integers.i=integers2.k LIMIT 2) tbl +-- +ok +== diff --git a/parser/testdata/corpus/sql/order/limit_parameter.test b/parser/testdata/corpus/sql/order/limit_parameter.test new file mode 100644 index 0000000..880da30 --- /dev/null +++ b/parser/testdata/corpus/sql/order/limit_parameter.test @@ -0,0 +1,49 @@ +# source: test/sql/order/limit_parameter.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +SELECT * FROM generate_series(0, 10000, 1) tbl(i) ORDER BY i DESC LIMIT 5 +-- +ok +== +CREATE TABLE integers AS SELECT 5 k +-- +ok +== +SELECT * FROM generate_series(0, 10000, 1) tbl(i) ORDER BY i DESC LIMIT (SELECT k FROM integers) +-- +ok +== +CREATE TABLE strings AS SELECT '5'::VARCHAR k +-- +ok +== +SELECT * FROM generate_series(0, 10000, 1) tbl(i) ORDER BY i DESC LIMIT (SELECT k FROM strings) +-- +ok +== +PREPARE v1 AS SELECT * FROM generate_series(0, 10000, 1) tbl(i) ORDER BY i DESC LIMIT ?::VARCHAR +-- +ok +== +EXECUTE v1(5) +-- +ok +== +PREPARE v1 AS SELECT * FROM generate_series(0, 10000, 1) tbl(i) ORDER BY i DESC LIMIT ?::VARCHAR % +-- +ok +== +EXECUTE v1('0.05') +-- +ok +== +CREATE TABLE doubles AS SELECT 0.05 d +-- +ok +== +SELECT * FROM generate_series(0, 10000, 1) tbl(i) ORDER BY i DESC LIMIT (SELECT d FROM doubles) % +-- +ok +== diff --git a/parser/testdata/corpus/sql/order/limit_percent_view.test b/parser/testdata/corpus/sql/order/limit_percent_view.test new file mode 100644 index 0000000..d9685da --- /dev/null +++ b/parser/testdata/corpus/sql/order/limit_percent_view.test @@ -0,0 +1,25 @@ +# source: test/sql/order/limit_percent_view.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +INSERT INTO test VALUES (11, 22), (12, 21), (13, 22), (14, 32), (15, 52) +-- +ok +== +CREATE VIEW test_view AS SELECT a FROM test LIMIT 20 % +-- +ok +== +FROM test_view +-- +ok +== +CREATE VIEW test_view2 AS SELECT a FROM test LIMIT 20 % OFFSET 1 +-- +ok +== +FROM test_view2 +-- +ok +== diff --git a/parser/testdata/corpus/sql/order/limit_union.test b/parser/testdata/corpus/sql/order/limit_union.test new file mode 100644 index 0000000..9533a93 --- /dev/null +++ b/parser/testdata/corpus/sql/order/limit_union.test @@ -0,0 +1,13 @@ +# source: test/sql/order/limit_union.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +SELECT * FROM range(5) UNION ALL SELECT * FROM range(5) LIMIT 7 +-- +ok +== +SELECT COUNT(*) FROM (SELECT * FROM range(5) UNION ALL SELECT * FROM range(5) LIMIT 7) tbl +-- +ok +== diff --git a/parser/testdata/corpus/sql/order/negative_offset.test b/parser/testdata/corpus/sql/order/negative_offset.test new file mode 100644 index 0000000..7ef21dd --- /dev/null +++ b/parser/testdata/corpus/sql/order/negative_offset.test @@ -0,0 +1,29 @@ +# source: test/sql/order/negative_offset.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +SELECT * FROM generate_series(0,10,1) LIMIT 3 OFFSET -1; +-- +ok +== +SELECT * FROM generate_series(0,10,1) LIMIT -3; +-- +ok +== +SELECT * FROM generate_series(0,10,1) LIMIT -1% +-- +ok +== +CREATE TABLE integers AS SELECT -1 k; +-- +ok +== +SELECT * FROM generate_series(0,10,1) LIMIT (SELECT k FROM integers); +-- +ok +== +SELECT * FROM generate_series(0,10,1) LIMIT 1 OFFSET (SELECT k FROM integers); +-- +ok +== diff --git a/parser/testdata/corpus/sql/order/order_by_all.test b/parser/testdata/corpus/sql/order/order_by_all.test new file mode 100644 index 0000000..a473ded --- /dev/null +++ b/parser/testdata/corpus/sql/order/order_by_all.test @@ -0,0 +1,25 @@ +# source: test/sql/order/order_by_all.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +SELECT * FROM integers ORDER BY ALL +-- +ok +== +SELECT * FROM integers ORDER BY * DESC +-- +ok +== +SELECT * FROM integers ORDER BY * DESC NULLS LAST +-- +ok +== +SELECT * FROM integers UNION ALL SELECT * FROM integers ORDER BY ALL +-- +ok +== +SELECT * FROM integers UNION SELECT * FROM integers ORDER BY ALL +-- +ok +== diff --git a/parser/testdata/corpus/sql/order/order_by_internal_5293.test b/parser/testdata/corpus/sql/order/order_by_internal_5293.test new file mode 100644 index 0000000..f1cc034 --- /dev/null +++ b/parser/testdata/corpus/sql/order/order_by_internal_5293.test @@ -0,0 +1,27 @@ +# source: test/sql/order/order_by_internal_5293.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +create table t1 as from VALUES + ('A', 1), + ('B', 3), + ('C', 12), + ('A', 5), + ('B', 8), + ('C', 9), + ('A', 10), + ('B', 20), + ('C', 3) + t(a, b); +-- +ok +== +PRAGMA disabled_optimizers='compressed_materialization'; +-- +ok +== +from t1 order by a +-- +ok +== diff --git a/parser/testdata/corpus/sql/order/order_overflow.test b/parser/testdata/corpus/sql/order/order_overflow.test new file mode 100644 index 0000000..395dede --- /dev/null +++ b/parser/testdata/corpus/sql/order/order_overflow.test @@ -0,0 +1,9 @@ +# source: test/sql/order/order_overflow.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +SELECT 42 ORDER BY -9223372036854775808; +-- +ok +== diff --git a/parser/testdata/corpus/sql/order/test_limit.test b/parser/testdata/corpus/sql/order/test_limit.test new file mode 100644 index 0000000..11428ce --- /dev/null +++ b/parser/testdata/corpus/sql/order/test_limit.test @@ -0,0 +1,157 @@ +# source: test/sql/order/test_limit.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +INSERT INTO test VALUES (11, 22), (12, 21), (13, 22) +-- +ok +== +SELECT a FROM test LIMIT 1 +-- +ok +== +SELECT a FROM test LIMIT 1.25 +-- +ok +== +SELECT a FROM test LIMIT 2-1 +-- +ok +== +SELECT a FROM test LIMIT a +-- +ok +== +SELECT a FROM test LIMIT a+1 +-- +ok +== +SELECT a FROM test LIMIT SUM(42) +-- +ok +== +SELECT a FROM test LIMIT row_number() OVER () +-- +ok +== +CREATE TABLE test2 (a STRING); +-- +ok +== +INSERT INTO test2 VALUES ('Hello World') +-- +ok +== +PREPARE v1 AS SELECT * FROM test2 LIMIT 3 +-- +ok +== +select 1 limit date '1992-01-01'; +-- +ok +== +CREATE SEQUENCE seq START 3; +-- +ok +== +SELECT * FROM integers LIMIT nextval('seq'); +-- +ok +== +SELECT * FROM integers LIMIT RANDOM(); +-- +ok +== +SELECT * FROM integers as int LIMIT (SELECT MIN(integers.i) FROM integers); +-- +ok +== +CREATE SEQUENCE of_seq START 1; +-- +ok +== +SELECT * FROM integers OFFSET nextval('of_seq'); +-- +ok +== +SELECT * FROM integers OFFSET RANDOM(); +-- +ok +== +SELECT * FROM integers as int OFFSET (SELECT MIN(integers.i) FROM integers); +-- +ok +== +SELECT * FROM integers as int LIMIT (SELECT MAX(integers.i) FROM integers) OFFSET (SELECT MIN(integers.i) FROM integers); +-- +ok +== +SELECT * FROM integers as int LIMIT (SELECT max(integers.i) FROM integers where i > 5) +-- +ok +== +SELECT * FROM integers as int LIMIT (SELECT NULL) +-- +ok +== +SELECT * FROM integers as int LIMIT (SELECT -1); +-- +ok +== +SELECT * FROM integers as int LIMIT (SELECT 'ab'); +-- +ok +== +CREATE OR REPLACE TABLE t AS SELECT range x FROM range(10); +-- +ok +== +SELECT * FROM t ORDER BY x; +-- +ok +== +SELECT * FROM t ORDER BY x OFFSET 5; +-- +ok +== +SELECT * FROM t ORDER BY x OFFSET (SELECT 5); +-- +ok +== +SELECT * FROM t ORDER BY x LIMIT (SELECT 5); +-- +ok +== +SELECT * FROM t ORDER BY x LIMIT (SELECT 3) OFFSET (SELECT 3); +-- +ok +== +SELECT * FROM t ORDER BY x LIMIT 3 OFFSET (SELECT 3); +-- +ok +== +SELECT * FROM t ORDER BY x LIMIT (SELECT 3) OFFSET 3; +-- +ok +== +SELECT * FROM t ORDER BY x LIMIT (SELECT -1); +-- +ok +== +SELECT * FROM t ORDER BY x OFFSET (SELECT -1); +-- +ok +== +create table t0(c0 int); +-- +ok +== +insert into t0 values (1), (2), (3), (4), (5), (6), (7); +-- +ok +== +SELECT * FROM t0 ORDER BY ALL OFFSET (SELECT DISTINCT 6.5 FROM (SELECT 1) t1(c0) UNION ALL SELECT 3); +-- +ok +== diff --git a/parser/testdata/corpus/sql/order/test_limit_cte.test b/parser/testdata/corpus/sql/order/test_limit_cte.test new file mode 100644 index 0000000..f847f28 --- /dev/null +++ b/parser/testdata/corpus/sql/order/test_limit_cte.test @@ -0,0 +1,13 @@ +# source: test/sql/order/test_limit_cte.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +WITH cte AS (SELECT 3) SELECT * FROM range(10000000) LIMIT (SELECT * FROM cte) +-- +ok +== +WITH cte AS (SELECT 3) SELECT * FROM range(10000000) LIMIT (SELECT * FROM cte) OFFSET (SELECT * FROM cte) +-- +ok +== diff --git a/parser/testdata/corpus/sql/order/test_limit_parameter.test b/parser/testdata/corpus/sql/order/test_limit_parameter.test new file mode 100644 index 0000000..fd7f1cc --- /dev/null +++ b/parser/testdata/corpus/sql/order/test_limit_parameter.test @@ -0,0 +1,105 @@ +# source: test/sql/order/test_limit_parameter.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +SELECT 'Test' LIMIT ? +-- +ok +== +PREPARE v1 AS SELECT 'Test' LIMIT ? +-- +ok +== +PREPARE v2 AS SELECT * FROM RANGE(1000000000) LIMIT ? OFFSET ? +-- +ok +== +EXECUTE v2(3, 0) +-- +ok +== +EXECUTE v2(3, 17) +-- +ok +== +PREPARE v3 AS SELECT * FROM RANGE(1000000000) LIMIT 2 OFFSET ? +-- +ok +== +EXECUTE v3(0) +-- +ok +== +EXECUTE v3(17) +-- +ok +== +PREPARE v4 AS SELECT * FROM RANGE(1000000000) LIMIT ? OFFSET 17 +-- +ok +== +EXECUTE v4(3) +-- +ok +== +EXECUTE v4(6) +-- +ok +== +PREPARE v5 AS SELECT * FROM RANGE(1000000000) LIMIT (SELECT ?::INT) OFFSET (SELECT ?::INT) +-- +ok +== +EXECUTE v5(3, 0) +-- +ok +== +EXECUTE v5(3, 17) +-- +ok +== +PREPARE v6 AS SELECT * FROM RANGE(1000000000) LIMIT 3+? OFFSET ?+2*? +-- +ok +== +EXECUTE v6(1, 0, 0) +-- +ok +== +EXECUTE v6(3, 1, 2) +-- +ok +== +PREPARE v7 AS SELECT * FROM GENERATE_SERIES(0,4,1) LIMIT ? OFFSET ? +-- +ok +== +EXECUTE v7(NULL, 2) +-- +ok +== +EXECUTE v7(2, NULL) +-- +ok +== +EXECUTE v7(NULL, 9223372036854775807) +-- +ok +== +EXECUTE v7(9223372036854775807, NULL) +-- +ok +== +EXECUTE v7(NULL, 922337203685477580700) +-- +ok +== +EXECUTE v7(NULL, 4611686018427387904) +-- +ok +== +EXECUTE v7(4611686018427387904, NULL) +-- +ok +== diff --git a/parser/testdata/corpus/sql/order/test_limit_percent.test b/parser/testdata/corpus/sql/order/test_limit_percent.test new file mode 100644 index 0000000..1c2c860 --- /dev/null +++ b/parser/testdata/corpus/sql/order/test_limit_percent.test @@ -0,0 +1,149 @@ +# source: test/sql/order/test_limit_percent.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +SELECT a FROM test LIMIT 20 % +-- +ok +== +SELECT a FROM test LIMIT 40 PERCENT +-- +ok +== +SELECT a FROM test LIMIT 35% +-- +ok +== +SELECT a FROM test LIMIT 79.9% +-- +ok +== +SELECT a FROM test LIMIT 80.1% +-- +ok +== +SELECT a FROM test LIMIT 100 PERCENT +-- +ok +== +SELECT a FROM test LIMIT (30-10) % +-- +ok +== +SELECT a FROM test LIMIT a % +-- +ok +== +SELECT a FROM test LIMIT (a+1) % +-- +ok +== +SELECT a FROM test LIMIT (a+b*c) % +-- +ok +== +SELECT a FROM test LIMIT SUM(42) % +-- +ok +== +SELECT * FROM test LIMIT RANDOM() %; +-- +ok +== +SELECT a FROM test LIMIT 50% OFFSET 2 +-- +ok +== +SELECT * FROM range(10) LIMIT 50% OFFSET 2 +-- +ok +== +SELECT * FROM range(10000) LIMIT 0.1% OFFSET 8000 +-- +ok +== +SELECT * FROM range(10000) LIMIT 0.1% OFFSET 9999 +-- +ok +== +SELECT a FROM test LIMIT (SELECT COUNT(*) FROM test) % OFFSET 1 +-- +ok +== +SELECT a FROM test LIMIT 50% OFFSET (((SELECT MIN(b) FROM test)-1)/10); +-- +ok +== +SELECT b FROM test LIMIT 70% OFFSET (((SELECT MIN(test.a) FROM test)-1)/10); +-- +ok +== +SELECT * FROM test LIMIT 30% OFFSET RANDOM() / 10.0; +-- +ok +== +SELECT b FROM test LIMIT 0% +-- +ok +== +SELECT * FROM range(100) LIMIT -10 %; +-- +ok +== +SELECT * FROM test LIMIT (SELECT 'ab') % +-- +ok +== +select 1 limit date '2021-11-25' %; +-- +ok +== +select * from test limit "Hello World" %; +-- +ok +== +INSERT INTO test2 VALUES ('first'), ('second'), ('third'), ('4th'), ('5th') +-- +ok +== +PREPARE v1 AS SELECT * FROM test2 LIMIT 40% +-- +ok +== +CREATE VIEW v3 AS SELECT i % 5 g, LIST(CASE WHEN i=6 or i=8 then null else i end) l FROM RANGE(20) tbl(i) group by g +-- +ok +== +SELECT g, 5=ANY(l) FROM v3 ORDER BY g LIMIT 80%; +-- +ok +== +SELECT g, 3>ANY(l) FROM v3 ORDER BY g LIMIT 50%; +-- +ok +== +CREATE TABLE struct_data (g INTEGER, e INTEGER) +-- +ok +== +INSERT INTO struct_data VALUES (1, 1), (1, 2), (2, 3), (2, 4), (2, 5), (3, 6), (5, NULL) +-- +ok +== +SELECT STRUCT_PACK(a := 42, b := 43) +-- +ok +== +SELECT e, STRUCT_PACK(e) FROM struct_data ORDER BY e LIMIT 60% +-- +ok +== +SELECT * FROM integers as int LIMIT (SELECT max(integers.i) FROM integers where i > 5) % +-- +ok +== +select 1 union all select 2 union all select 3 union all select 4 limit 50% +-- +ok +== diff --git a/parser/testdata/corpus/sql/order/test_nulls_first.test b/parser/testdata/corpus/sql/order/test_nulls_first.test new file mode 100644 index 0000000..6b2e7e4 --- /dev/null +++ b/parser/testdata/corpus/sql/order/test_nulls_first.test @@ -0,0 +1,73 @@ +# source: test/sql/order/test_nulls_first.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +INSERT INTO integers VALUES (1), (NULL) +-- +ok +== +SELECT * FROM integers ORDER BY i NULLS FIRST +-- +ok +== +SELECT 10 AS j, i FROM integers ORDER BY j, i NULLS LAST +-- +ok +== +INSERT INTO test VALUES (1, 1), (NULL, 1), (1, NULL) +-- +ok +== +SELECT * FROM test ORDER BY i NULLS FIRST, j NULLS LAST +-- +ok +== +SELECT * FROM test ORDER BY i NULLS FIRST, j NULLS FIRST +-- +ok +== +SELECT * FROM test ORDER BY i NULLS LAST, j NULLS FIRST +-- +ok +== +SELECT i, j, row_number() OVER (PARTITION BY i ORDER BY j NULLS FIRST) FROM test ORDER BY i NULLS FIRST, j NULLS FIRST; +-- +ok +== +SELECT i, j, row_number() OVER (PARTITION BY i ORDER BY j NULLS LAST) FROM test ORDER BY i NULLS FIRST, j NULLS FIRST; +-- +ok +== +SELECT * FROM test ORDER BY i NULLS FIRST, j NULLS LAST LIMIT 2 +-- +ok +== +SELECT * FROM test ORDER BY i NULLS LAST, j NULLS LAST LIMIT 2 +-- +ok +== +PRAGMA default_null_order='NULLS LAST' +-- +ok +== +PRAGMA default_null_order='NULLS FIRST' +-- +ok +== +PRAGMA default_null_order()) +-- +error: Parser Error: syntax error at or near ")" +== +PRAGMA default_null_order='UNKNOWN' +-- +error: Parser Error: Unrecognized parameter for option NULL_ORDER "unknown", expected either NULLS FIRST, NULLS LAST, SQLite, MySQL or Postgres +== +PRAGMA default_null_order=UNKNOWN) +-- +error: Parser Error: syntax error at or near ")" +== +PRAGMA default_null_order=3) +-- +error: Parser Error: syntax error at or near ")" +== diff --git a/parser/testdata/corpus/sql/order/test_nulls_first.test.metadata.json b/parser/testdata/corpus/sql/order/test_nulls_first.test.metadata.json new file mode 100644 index 0000000..53fa86e --- /dev/null +++ b/parser/testdata/corpus/sql/order/test_nulls_first.test.metadata.json @@ -0,0 +1,5 @@ +{ + "todo": { + "5cb1f0cf73c77783": "transformer-raised parser error: upstream rejects in the transformer, not the grammar; expected to clear as transformers land (milestones 3-5)" + } +} diff --git a/parser/testdata/corpus/sql/order/test_order_by.test b/parser/testdata/corpus/sql/order/test_order_by.test new file mode 100644 index 0000000..09d674a --- /dev/null +++ b/parser/testdata/corpus/sql/order/test_order_by.test @@ -0,0 +1,105 @@ +# source: test/sql/order/test_order_by.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +INSERT INTO test VALUES (11, 22), (12, 21), (13, 22); +-- +ok +== +select b from test where a = 12; +-- +ok +== +SELECT b FROM test ORDER BY a DESC; +-- +ok +== +SELECT a, b FROM test ORDER BY a; +-- +ok +== +SELECT a, b FROM test ORDER BY a DESC; +-- +ok +== +SELECT a, b FROM test ORDER BY b, a; +-- +ok +== +SELECT a, b FROM test ORDER BY 2, 1; +-- +ok +== +SELECT a, b FROM test ORDER BY b DESC, a; +-- +ok +== +SELECT a, b FROM test ORDER BY b, a DESC; +-- +ok +== +SELECT a, b FROM test ORDER BY b, a DESC LIMIT 1; +-- +ok +== +SELECT a, b FROM test ORDER BY b, a DESC LIMIT 1 OFFSET 1; +-- +ok +== +SELECT a, b FROM test ORDER BY b, a DESC OFFSET 1; +-- +ok +== +SELECT a, b FROM test WHERE a < 13 ORDER BY b; +-- +ok +== +SELECT a, b FROM test WHERE a < 13 ORDER BY 2; +-- +ok +== +SELECT a, b FROM test WHERE a < 13 ORDER BY b DESC; +-- +ok +== +SELECT b, a FROM test WHERE a < 13 ORDER BY b DESC; +-- +ok +== +SELECT b % 2 AS f, SUM(a) FROM test GROUP BY f ORDER BY b % 2; +-- +ok +== +SELECT b % 2 AS f, a FROM test ORDER BY b % 2, a; +-- +ok +== +SELECT b % 2 AS f, SUM(a) FROM test GROUP BY f ORDER BY 1; +-- +ok +== +SELECT a-10 AS k FROM test UNION SELECT a-10 AS l FROM test ORDER BY k; +-- +ok +== +SELECT a-10 AS k FROM test UNION SELECT a-10 AS l FROM test ORDER BY l; +-- +ok +== +SELECT a-10 AS k FROM test UNION SELECT a-10 AS l FROM test ORDER BY 1-k; +-- +ok +== +SELECT a-10 AS k FROM test UNION SELECT a-10 AS l FROM test ORDER BY a-10; +-- +ok +== +SELECT a-10 AS k FROM test UNION SELECT a-11 AS l FROM test ORDER BY a-11; +-- +ok +== +SELECT a FROM test ORDER BY 'hello world', a +-- +ok +== diff --git a/parser/testdata/corpus/sql/order/test_order_by_exceptions.test b/parser/testdata/corpus/sql/order/test_order_by_exceptions.test new file mode 100644 index 0000000..48917ca --- /dev/null +++ b/parser/testdata/corpus/sql/order/test_order_by_exceptions.test @@ -0,0 +1,41 @@ +# source: test/sql/order/test_order_by_exceptions.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +SELECT a FROM test ORDER BY 2 +-- +ok +== +SELECT a FROM test ORDER BY 'hello', a +-- +ok +== +SELECT a AS k, b FROM test UNION SELECT a, b AS k FROM test ORDER BY k +-- +ok +== +SELECT a AS k, b FROM test UNION SELECT a AS k, b FROM test ORDER BY k +-- +ok +== +SELECT a % 2, b FROM test UNION SELECT b, a % 2 AS k ORDER BY a % 2 +-- +ok +== +SELECT a % 2, b FROM test UNION SELECT a % 2 AS k, b FROM test ORDER BY a % 2 +-- +ok +== +SELECT a % 2, b FROM test UNION SELECT a % 2 AS k, b FROM test ORDER BY 3 +-- +ok +== +SELECT a % 2, b FROM test UNION SELECT a % 2 AS k, b FROM test ORDER BY -1 +-- +ok +== +SELECT a % 2, b FROM test UNION SELECT a % 2 AS k FROM test ORDER BY -1 +-- +ok +== diff --git a/parser/testdata/corpus/sql/order/test_order_by_non_ordinal_literal.test b/parser/testdata/corpus/sql/order/test_order_by_non_ordinal_literal.test new file mode 100644 index 0000000..7afb76f --- /dev/null +++ b/parser/testdata/corpus/sql/order/test_order_by_non_ordinal_literal.test @@ -0,0 +1,69 @@ +# source: test/sql/order/test_order_by_non_ordinal_literal.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +CREATE TABLE t (a INTEGER, b INTEGER); +-- +ok +== +INSERT INTO t VALUES (11, 22), (12, 21), (13, 22); +-- +ok +== +SELECT a, b FROM t ORDER BY 1, 2 +-- +ok +== +SELECT a FROM t ORDER BY NULL, a +-- +ok +== +SELECT a FROM t ORDER BY true, a +-- +ok +== +SELECT a FROM t ORDER BY false, a +-- +ok +== +SELECT a FROM t ORDER BY CAST('a' AS VARCHAR), a +-- +ok +== +SELECT a FROM t ORDER BY CAST('t' AS BOOLEAN), a +-- +ok +== +SELECT a FROM t ORDER BY CAST('yes' AS BOOLEAN), a +-- +ok +== +SELECT a FROM t UNION SELECT b FROM t ORDER BY true +-- +ok +== +SELECT a FROM t UNION SELECT b FROM t ORDER BY false +-- +ok +== +SELECT a AS k FROM t UNION SELECT a AS k FROM t ORDER BY true, k +-- +ok +== +SELECT DISTINCT ON (true) a, b FROM t ORDER BY a, b +-- +ok +== +SELECT DISTINCT ON (false) a, b FROM t ORDER BY a, b +-- +ok +== +SELECT DISTINCT ON (a) a, b FROM t ORDER BY true, a +-- +ok +== +SELECT DISTINCT ON (a) a, b FROM t ORDER BY true, a, b +-- +ok +== diff --git a/parser/testdata/corpus/sql/order/test_order_large.test b/parser/testdata/corpus/sql/order/test_order_large.test new file mode 100644 index 0000000..632dbb3 --- /dev/null +++ b/parser/testdata/corpus/sql/order/test_order_large.test @@ -0,0 +1,13 @@ +# source: test/sql/order/test_order_large.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +CREATE TABLE test AS SELECT a FROM range(10000, 0, -1) t1(a) +-- +ok +== +SELECT * FROM test ORDER BY a +-- +ok +== diff --git a/parser/testdata/corpus/sql/order/test_order_pragma.test b/parser/testdata/corpus/sql/order/test_order_pragma.test new file mode 100644 index 0000000..e2d6f7a --- /dev/null +++ b/parser/testdata/corpus/sql/order/test_order_pragma.test @@ -0,0 +1,33 @@ +# source: test/sql/order/test_order_pragma.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +SELECT a FROM test ORDER BY a +-- +ok +== +PRAGMA default_order='DESCENDING' +-- +ok +== +PRAGMA default_order='ASC' +-- +ok +== +PRAGMA default_order()) +-- +error: Parser Error: syntax error at or near ")" +== +PRAGMA default_order='UNKNOWN' +-- +ok +== +PRAGMA default_order=UNKNOWN) +-- +error: Parser Error: syntax error at or near ")" +== +PRAGMA default_order=3) +-- +error: Parser Error: syntax error at or near ")" +== diff --git a/parser/testdata/corpus/sql/order/test_order_range_mapping.test b/parser/testdata/corpus/sql/order/test_order_range_mapping.test new file mode 100644 index 0000000..5ab5bee --- /dev/null +++ b/parser/testdata/corpus/sql/order/test_order_range_mapping.test @@ -0,0 +1,41 @@ +# source: test/sql/order/test_order_range_mapping.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +create table test (i {type}) +-- +error: Parser Error: syntax error at or near "{" +== +insert into test values (100), (25), (75), (50); +-- +ok +== +select * from test order by i +-- +ok +== +drop table test +-- +ok +== +insert into test values (10000), (2500), (7500), (5000) +-- +ok +== +insert into test values (1000000), (250000), (750000), (500000) +-- +ok +== +insert into test values (1000000000), (250000000), (750000000), (500000000) +-- +ok +== +create table test (i hugeint) +-- +ok +== +insert into test values (295147905179352825856), (73786976294838206464), (147573952589676412928), (36893488147419103232) +-- +ok +== diff --git a/parser/testdata/corpus/sql/order/test_order_unnest.test b/parser/testdata/corpus/sql/order/test_order_unnest.test new file mode 100644 index 0000000..e3d8225 --- /dev/null +++ b/parser/testdata/corpus/sql/order/test_order_unnest.test @@ -0,0 +1,43 @@ +# source: test/sql/order/test_order_unnest.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +CREATE TABLE tbl_structs AS SELECT + {'a': 2.0, 'b': 'hello', 'c': [1, 2]} AS s1, + 1::BIGINT AS i, + {'k': 1::TINYINT, 'j': 0::BOOL} AS s2; +-- +ok +== +INSERT INTO tbl_structs VALUES ( + {'a': 1.0, 'b': 'yay', 'c': [10, 20]}, + 42, + {'k': 2, 'j': 1}); +-- +ok +== +SELECT UNNEST(s1), s1.a AS id FROM tbl_structs ORDER BY id; +-- +ok +== +SELECT s1, s1.a FROM tbl_structs ORDER BY 1; +-- +ok +== +SELECT UNNEST(s1), s1.a AS id FROM tbl_structs ORDER BY 1; +-- +ok +== +SELECT UNNEST(s1), UNNEST(s2), i FROM tbl_structs ORDER BY i; +-- +ok +== +SELECT UNNEST(s1), UNNEST(s2), i FROM tbl_structs ORDER BY 2 DESC; +-- +ok +== +SELECT i, UNNEST(s1), UNNEST(s2) FROM tbl_structs ORDER BY 5 DESC; +-- +ok +== diff --git a/parser/testdata/corpus/sql/order/top_n_issue_21623.test b/parser/testdata/corpus/sql/order/top_n_issue_21623.test new file mode 100644 index 0000000..8952a6d --- /dev/null +++ b/parser/testdata/corpus/sql/order/top_n_issue_21623.test @@ -0,0 +1,72 @@ +# source: test/sql/order/top_n_issue_21623.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +CREATE OR REPLACE TABLE t3(c VARCHAR); +-- +ok +== +INSERT INTO t3 +VALUES ('19'), + ('21'), + ('22'), + ('23'); +-- +ok +== +CREATE OR REPLACE TABLE t2( + a VARCHAR, + b VARCHAR +); +-- +ok +== +INSERT INTO t2 +VALUES ('3', '8'), + ('5', NULL), + ('8', NULL), + ('11', NULL); +-- +ok +== +CREATE OR REPLACE TABLE t1( + a VARCHAR, + c VARCHAR +); +-- +ok +== +INSERT INTO t1 +VALUES ('2', '22'), + ('3', '21'), + ('11', '19'), + ('5', '23'); +-- +ok +== +WITH + cte1 AS ( + SELECT + struct_pack(f := json_extract('[]', '$[*]')) AS s0, struct_pack(ff := c) AS s1, t1.a AS p + FROM t3 + JOIN t1 USING (c) + ), + cte2 AS ( + SELECT + cte1.s1, cte1.s0, struct_pack(fff := cte1.p) AS s2 + FROM cte1 + JOIN t2 AS t22 ON cte1.p = t22.a + LEFT JOIN t2 ON t22.b = t2.a + ), + cte3 AS ( + SELECT cte2.* + FROM cte2 + ORDER BY s1, s2 + ) +SELECT * +FROM cte3 +LIMIT 1; +-- +ok +== diff --git a/parser/testdata/corpus/sql/order/top_n_nulls.test b/parser/testdata/corpus/sql/order/top_n_nulls.test new file mode 100644 index 0000000..411349f --- /dev/null +++ b/parser/testdata/corpus/sql/order/top_n_nulls.test @@ -0,0 +1,23 @@ +# source: test/sql/order/top_n_nulls.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +CREATE TABLE orders_small AS SELECT * FROM parquet_scan('{DATA_DIR}/parquet-testing/orders_small_parquet.test'); +-- +ok +== +select o_orderkey, o_clerk, o_orderstatus, o_totalprice from orders_small + order by o_orderkey NULLS FIRST, + o_clerk NULLS FIRST, o_orderstatus NULLS FIRST, + o_totalprice DESC NULLS LAST limit 360 +-- +ok +== +select o_orderkey, o_clerk, o_orderstatus, o_totalprice from orders_small + order by o_orderkey NULLS FIRST, + o_clerk NULLS FIRST, o_orderstatus NULLS FIRST, + o_totalprice DESC NULLS LAST limit 10 offset 440 +-- +ok +== diff --git a/parser/testdata/corpus/sql/ordinality/ordinality_constant.test b/parser/testdata/corpus/sql/ordinality/ordinality_constant.test new file mode 100644 index 0000000..1d7eeb8 --- /dev/null +++ b/parser/testdata/corpus/sql/ordinality/ordinality_constant.test @@ -0,0 +1,89 @@ +# source: test/sql/ordinality/ordinality_constant.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +SELECT * FROM range(1) WITH ORDINALITY AS _(ordinality); +-- +ok +== +SELECT o,range FROM range(1) WITH ORDINALITY AS _(range,o); +-- +ok +== +SELECT col = '{DATA_DIR}/csv/customer.csv' OR col = '{DATA_DIR}\csv\customer.csv', o FROM glob('{DATA_DIR}/csv/customer.csv') with ordinality AS _(col,o); +-- +ok +== +SELECT my_range, my_ordinality FROM range(3) WITH ORDINALITY AS _(my_range, my_ordinality) ORDER BY my_range,my_ordinality; +-- +ok +== +SELECT my_series, my_ordinality FROM generate_series(0,3,1) WITH ORDINALITY AS _(my_series,my_ordinality) ORDER BY my_series, my_ordinality; +-- +ok +== +SELECT * FROM repeat('x', 5) WITH ORDINALITY ORDER BY ordinality; +-- +ok +== +SELECT * FROM repeat('x', 9) WITH ORDINALITY WHERE ordinality > 4 ORDER BY ordinality; +-- +ok +== +CREATE OR REPLACE VIEW view_ordinality AS +SELECT r AS range, o AS my_ordinality +FROM range((select 10)) WITH ORDINALITY AS _(r, o) +WHERE my_ordinality > 4 +ORDER BY range, my_ordinality; +-- +ok +== +SELECT range, my_ordinality FROM view_ordinality ORDER BY range, my_ordinality; +-- +ok +== +WITH RECURSIVE ordinalityCTE AS ( + SELECT 1 AS ordinality + UNION + SELECT oCTE.ordinality + r.ordinality AS ordinality + FROM + ordinalityCTE AS oCTE, + LATERAL range(1) WITH ORDINALITY AS r(range,ordinality) + WHERE oCTE.ordinality < 5 +) SELECT ordinality FROM ordinalityCTE ORDER BY ordinality; +-- +ok +== +WITH RECURSIVE ordinalityCTE AS ( + SELECT 1 AS ordinality + UNION ALL + SELECT oCTE.ordinality + r.ordinality AS ordinality + FROM + ordinalityCTE AS oCTE, + LATERAL range(1) WITH ORDINALITY AS r(range,ordinality) + WHERE oCTE.ordinality < 5 +) SELECT ordinality FROM ordinalityCTE ORDER BY ordinality; +-- +ok +== +SELECT * FROM unnest([41,42,43]) WITH ORDINALITY; +-- +ok +== +SELECT column00, ordinality FROM read_csv('{DATA_DIR}/csv/customer.csv') WITH ORDINALITY ORDER BY ordinality,column00; +-- +ok +== +SELECT column00, row_number() OVER () AS ordinality FROM read_csv('{DATA_DIR}/csv/customer.csv') ORDER BY ordinality,column00; +-- +ok +== +SELECT d,ordinality FROM read_parquet('{DATA_DIR}/parquet-testing/date.parquet') WITH ORDINALITY ORDER BY ordinality,d; +-- +ok +== +SELECT d, row_number() OVER () AS ordinality FROM read_parquet('{DATA_DIR}/parquet-testing/date.parquet') ORDER BY ordinality,d; +-- +ok +== diff --git a/parser/testdata/corpus/sql/ordinality/ordinality_inout.test b/parser/testdata/corpus/sql/ordinality/ordinality_inout.test new file mode 100644 index 0000000..2be8c4c --- /dev/null +++ b/parser/testdata/corpus/sql/ordinality/ordinality_inout.test @@ -0,0 +1,65 @@ +# source: test/sql/ordinality/ordinality_inout.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +CREATE TABLE test(a int); +-- +ok +== +INSERT INTO test VALUES (1),(3); +-- +ok +== +SELECT a,my_range,my_ordinality FROM test AS t(a), LATERAL range(t.a) WITH ORDINALITY AS _(my_range,my_ordinality) ORDER BY a,my_range; +-- +ok +== +SELECT a,my_series,my_ordinality FROM test AS t(a), LATERAL generate_series(0,t.a,1) WITH ORDINALITY AS _(my_series,my_ordinality) ORDER BY t.a, my_series, my_ordinality; +-- +ok +== +WITH ordinalityCTE AS ( + SELECT r AS range, o AS my_ordinality + FROM range((select 10)) WITH ORDINALITY AS _(r, o) + WHERE my_ordinality > 4 +) SELECT range, my_ordinality FROM ordinalityCTE ORDER BY range, my_ordinality; +-- +ok +== +WITH RECURSIVE ordinalityCTE AS ( + SELECT 1 AS ordinality + UNION + SELECT oCTE.ordinality + r.ordinality AS ordinality + FROM + ordinalityCTE AS oCTE, + LATERAL range(oCTE.ordinality) WITH ORDINALITY AS r(range,ordinality) + WHERE oCTE.ordinality < 5 +) SELECT ordinality FROM ordinalityCTE ORDER BY ordinality; +-- +ok +== +WITH RECURSIVE ordinalityCTE AS ( + SELECT 1 AS ordinality + UNION ALL + SELECT oCTE.ordinality + r.ordinality AS ordinality + FROM + ordinalityCTE AS oCTE, + LATERAL range(oCTE.ordinality) WITH ORDINALITY AS r(range,ordinality) + WHERE oCTE.ordinality <= 4 + ) SELECT ordinality FROM ordinalityCTE order by ordinality; +-- +ok +== +CREATE TABLE unnest_test(a char[]); +-- +ok +== +INSERT INTO unnest_test VALUES (['a1','a2','a3']),(['b1','b2']); +-- +ok +== +SELECT * FROM unnest_test AS t, LATERAL unnest(t.a) WITH ORDINALITY AS _(unnest,my_ordinality) ORDER BY unnest, my_ordinality; +-- +ok +== diff --git a/parser/testdata/corpus/sql/overflow/bigint_overflow.test b/parser/testdata/corpus/sql/overflow/bigint_overflow.test new file mode 100644 index 0000000..27bb725 --- /dev/null +++ b/parser/testdata/corpus/sql/overflow/bigint_overflow.test @@ -0,0 +1,109 @@ +# source: test/sql/overflow/bigint_overflow.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +SELECT 251658240::BIGINT * 251658240::BIGINT +-- +ok +== +SELECT 251658240::BIGINT * 1080863910568919040::BIGINT +-- +ok +== +SELECT 1080863910568919040::BIGINT * 251658240::BIGINT +-- +ok +== +SELECT 1080863910568919040::BIGINT * 1080863910568919040::BIGINT +-- +ok +== +SELECT -1::BIGINT * 9223372036854775807::BIGINT +-- +ok +== +SELECT -2::BIGINT * 4611686018427387905::BIGINT +-- +ok +== +SELECT 8589934592::BIGINT * 1073741823::BIGINT +-- +ok +== +SELECT 10737418240::BIGINT * 1073741823::BIGINT +-- +ok +== +SELECT 1073741823::BIGINT * 8589934592::BIGINT +-- +ok +== +SELECT 1073741823::BIGINT * 10737418240::BIGINT +-- +ok +== +SELECT (-9223372036854775808)::BIGINT * 2::BIGINT +-- +ok +== +SELECT (-9223372036854775808)::BIGINT * -1::BIGINT +-- +ok +== +SELECT -1::BIGINT * (-9223372036854775808)::BIGINT +-- +ok +== +SELECT -2::BIGINT * (-9223372036854775808)::BIGINT +-- +ok +== +SELECT (-9223372036854775808)::BIGINT * 0::BIGINT +-- +ok +== +SELECT (-9223372036854775808)::BIGINT * 1::BIGINT +-- +ok +== +SELECT 0::BIGINT * (-9223372036854775808)::BIGINT +-- +ok +== +SELECT 1::BIGINT * (-9223372036854775808)::BIGINT +-- +ok +== +SELECT (-9223372036854775807)::BIGINT * 2::BIGINT +-- +ok +== +SELECT (-9223372036854775807)::BIGINT * -1::BIGINT +-- +ok +== +SELECT -1::BIGINT * (-9223372036854775807)::BIGINT +-- +ok +== +SELECT -2::BIGINT * (-9223372036854775807)::BIGINT +-- +ok +== +SELECT (-9223372036854775807)::BIGINT * 0::BIGINT +-- +ok +== +SELECT (-9223372036854775807)::BIGINT * 1::BIGINT +-- +ok +== +SELECT 0::BIGINT * (-9223372036854775807)::BIGINT +-- +ok +== +SELECT 1::BIGINT * (-9223372036854775807)::BIGINT +-- +ok +== diff --git a/parser/testdata/corpus/sql/overflow/double_float_overflow.test b/parser/testdata/corpus/sql/overflow/double_float_overflow.test new file mode 100644 index 0000000..6aa8573 --- /dev/null +++ b/parser/testdata/corpus/sql/overflow/double_float_overflow.test @@ -0,0 +1,33 @@ +# source: test/sql/overflow/double_float_overflow.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +SELECT 1e308::DOUBLE + 1e308::DOUBLE; +-- +ok +== +SELECT 0::DOUBLE - 1e308::DOUBLE - 1e308::DOUBLE; +-- +ok +== +SELECT 1e308::DOUBLE * 1e308::DOUBLE; +-- +ok +== +SELECT 1e308::DOUBLE / 0.1; +-- +ok +== +SELECT 2e38::FLOAT + 2e38::FLOAT; +-- +ok +== +SELECT 2e38::FLOAT * 2e38::FLOAT; +-- +ok +== +SELECT 2e38::FLOAT / 0.1; +-- +ok +== diff --git a/parser/testdata/corpus/sql/overflow/expression_tree_depth.test b/parser/testdata/corpus/sql/overflow/expression_tree_depth.test new file mode 100644 index 0000000..6ea10c5 --- /dev/null +++ b/parser/testdata/corpus/sql/overflow/expression_tree_depth.test @@ -0,0 +1,17 @@ +# source: test/sql/overflow/expression_tree_depth.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +CREATE TABLE integers(x INTEGER) +-- +ok +== +SET max_expression_depth=250 +-- +ok +== +SELECT x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x FROM integers +-- +error: Parser Error: Max expression depth limit of 1000 exceeded. Use "SET max_expression_depth TO x" to increase the maximum expression depth. +== diff --git a/parser/testdata/corpus/sql/overflow/expression_tree_depth.test.metadata.json b/parser/testdata/corpus/sql/overflow/expression_tree_depth.test.metadata.json new file mode 100644 index 0000000..5b2a030 --- /dev/null +++ b/parser/testdata/corpus/sql/overflow/expression_tree_depth.test.metadata.json @@ -0,0 +1,5 @@ +{ + "todo": { + "700a2a3f3ebdd6f9": "transformer-raised parser error: upstream rejects in the transformer, not the grammar; expected to clear as transformers land (milestones 3-5)" + } +} diff --git a/parser/testdata/corpus/sql/overflow/integer_overflow.test b/parser/testdata/corpus/sql/overflow/integer_overflow.test new file mode 100644 index 0000000..59ba947 --- /dev/null +++ b/parser/testdata/corpus/sql/overflow/integer_overflow.test @@ -0,0 +1,201 @@ +# source: test/sql/overflow/integer_overflow.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +SELECT 100::TINYINT + 1::TINYINT +-- +ok +== +SELECT 100::TINYINT + 50::TINYINT +-- +ok +== +SELECT 0::TINYINT + -127::TINYINT +-- +ok +== +SELECT -2::TINYINT + -127::TINYINT +-- +ok +== +SELECT 30000::SMALLINT + 1::SMALLINT +-- +ok +== +SELECT 30000::SMALLINT + 5000::SMALLINT +-- +ok +== +SELECT 0::SMALLINT + -32767::SMALLINT +-- +ok +== +SELECT -2::SMALLINT + -32767::SMALLINT +-- +ok +== +SELECT 2147483640::INTEGER + 1::INTEGER +-- +ok +== +SELECT 2147483640::INTEGER + 5000::INTEGER +-- +ok +== +SELECT 0::INTEGER + -2147483647::INTEGER +-- +ok +== +SELECT -2::INTEGER + -2147483647::INTEGER +-- +ok +== +SELECT 9223372036854775800::BIGINT + 1::BIGINT +-- +ok +== +SELECT 9223372036854775800::BIGINT + 5000::BIGINT +-- +ok +== +SELECT 0::BIGINT + -9223372036854775807::BIGINT +-- +ok +== +SELECT -2::BIGINT + -9223372036854775808::BIGINT +-- +ok +== +SELECT -100::TINYINT - 1::TINYINT +-- +ok +== +SELECT -100::TINYINT - 50::TINYINT +-- +ok +== +SELECT 0::TINYINT - 127::TINYINT +-- +ok +== +SELECT -2::TINYINT - 127::TINYINT +-- +ok +== +SELECT -30000::SMALLINT - 1::SMALLINT +-- +ok +== +SELECT -30000::SMALLINT - 5000::SMALLINT +-- +ok +== +SELECT 0::SMALLINT - 32767::SMALLINT +-- +ok +== +SELECT -2::SMALLINT - 32767::SMALLINT +-- +ok +== +SELECT -2147483640::INTEGER - 1::INTEGER +-- +ok +== +SELECT -2147483640::INTEGER - 5000::INTEGER +-- +ok +== +SELECT 0::INTEGER - 2147483647::INTEGER +-- +ok +== +SELECT -2::INTEGER - 2147483647::INTEGER +-- +ok +== +SELECT -9223372036854775800::BIGINT - 1::BIGINT +-- +ok +== +SELECT -9223372036854775800::BIGINT - 5000::BIGINT +-- +ok +== +SELECT 0::BIGINT - 9223372036854775807::BIGINT +-- +ok +== +SELECT -2::BIGINT - 9223372036854775807::BIGINT +-- +ok +== +SELECT 50::TINYINT * 2::TINYINT +-- +ok +== +SELECT 50::TINYINT * 3::TINYINT +-- +ok +== +SELECT -1::TINYINT * 127::TINYINT +-- +ok +== +SELECT -2::TINYINT * 64::TINYINT +-- +ok +== +SELECT -2::TINYINT * 65::TINYINT +-- +ok +== +SELECT 15000::SMALLINT * 2::SMALLINT +-- +ok +== +SELECT 15000::SMALLINT * 3::SMALLINT +-- +ok +== +SELECT -1::SMALLINT * 32767::SMALLINT +-- +ok +== +SELECT -2::SMALLINT * 16384::SMALLINT +-- +ok +== +SELECT -2::SMALLINT * 16385::SMALLINT +-- +ok +== +SELECT 1073741820::INTEGER * 2::INTEGER +-- +ok +== +SELECT 1073741820::INTEGER * 3::INTEGER +-- +ok +== +SELECT -1::INTEGER * 2147483647::INTEGER +-- +ok +== +SELECT -2::INTEGER * 1073741824::INTEGER +-- +ok +== +SELECT -2::INTEGER * 1073741825::INTEGER +-- +ok +== +SELECT 4611686018427387900::BIGINT * 2::BIGINT +-- +ok +== +SELECT 4611686018427387900::BIGINT * 3::BIGINT +-- +ok +== diff --git a/parser/testdata/corpus/sql/overflow/table_overflow.test b/parser/testdata/corpus/sql/overflow/table_overflow.test new file mode 100644 index 0000000..b3f7722 --- /dev/null +++ b/parser/testdata/corpus/sql/overflow/table_overflow.test @@ -0,0 +1,149 @@ +# source: test/sql/overflow/table_overflow.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +CREATE TABLE tinyints(i TINYINT); +-- +ok +== +INSERT INTO tinyints VALUES (1), (10); +-- +ok +== +SELECT i+100::TINYINT FROM tinyints ORDER BY 1; +-- +ok +== +SELECT i+120::TINYINT FROM tinyints ORDER BY 1; +-- +ok +== +SELECT i+120::TINYINT FROM tinyints WHERE i=1 ORDER BY 1; +-- +ok +== +SELECT -100::TINYINT-i FROM tinyints ORDER BY 1; +-- +ok +== +SELECT -120::TINYINT-i FROM tinyints ORDER BY 1; +-- +ok +== +SELECT -120::TINYINT-i FROM tinyints WHERE i=1 ORDER BY 1; +-- +ok +== +SELECT -120::TINYINT + (-i) FROM tinyints ORDER BY 1; +-- +ok +== +SELECT -120::TINYINT + (-(-(-i))) FROM tinyints ORDER BY 1; +-- +ok +== +SELECT i*10::TINYINT FROM tinyints ORDER BY 1; +-- +ok +== +SELECT i*15::TINYINT FROM tinyints ORDER BY 1; +-- +ok +== +SELECT (i*10::TINYINT)*10::TINYINT FROM tinyints ORDER BY 1; +-- +ok +== +SELECT (i*10::TINYINT)*10::TINYINT FROM tinyints WHERE i=1 ORDER BY 1; +-- +ok +== +SELECT (i*10::TINYINT)*10::TINYINT FROM (SELECT * FROM tinyints) tbl(i) ORDER BY 1; +-- +ok +== +SELECT (i*10::TINYINT)*10::TINYINT FROM (SELECT * FROM tinyints) tbl(i) WHERE i=1 ORDER BY 1; +-- +ok +== +SELECT (i*10::TINYINT)*10::TINYINT FROM (SELECT * FROM tinyints WHERE i=1 UNION ALL SELECT * FROM tinyints WHERE i=10) tbl(i) ORDER BY 1; +-- +ok +== +CREATE TABLE smallints(i SMALLINT); +-- +ok +== +INSERT INTO smallints VALUES (1), (10); +-- +ok +== +SELECT i+32765::SMALLINT FROM smallints +-- +ok +== +SELECT i+32765::SMALLINT FROM smallints WHERE i=1 +-- +ok +== +SELECT -32765::SMALLINT-i FROM smallints +-- +ok +== +SELECT -32765::SMALLINT-i FROM smallints WHERE i=1 +-- +ok +== +SELECT i*10000::SMALLINT FROM smallints +-- +ok +== +SELECT i*10000::SMALLINT FROM smallints WHERE i=1 +-- +ok +== +SELECT i::TINYINT+120::TINYINT FROM smallints +-- +ok +== +SELECT i::TINYINT+120::TINYINT FROM smallints WHERE i=1 +-- +ok +== +INSERT INTO smallints VALUES (1000) +-- +ok +== +SELECT i::TINYINT FROM smallints +-- +ok +== +INSERT INTO smallints VALUES (30000); +-- +ok +== +SELECT integers1.i::SMALLINT + integers2.i::SMALLINT from smallints integers1, smallints integers2 where integers1.i = integers2.i; +-- +ok +== +CREATE TABLE smallints2 (j SMALLINT); +-- +ok +== +INSERT INTO smallints2 VALUES (1), (10); +-- +ok +== +SELECT i + j from smallints si_left LEFT JOIN smallints2 si_right ON (i = j); +-- +ok +== +INSERT INTO smallints2 VALUES (30000); +-- +ok +== +SELECT i + j from smallints LEFT JOIN smallints2 ON (i = j); +-- +ok +== diff --git a/parser/testdata/corpus/sql/overflow/test_numeric_overflow.test b/parser/testdata/corpus/sql/overflow/test_numeric_overflow.test new file mode 100644 index 0000000..5f57736 --- /dev/null +++ b/parser/testdata/corpus/sql/overflow/test_numeric_overflow.test @@ -0,0 +1,65 @@ +# source: test/sql/overflow/test_numeric_overflow.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +SELECT 1e1000 +-- +ok +== +SELECT 1e308::REAL +-- +ok +== +SELECT 1e1000::REAL +-- +ok +== +SELECT '1e1000'::DOUBLE +-- +ok +== +SELECT '1e100'::REAL +-- +ok +== +SELECT SUM(i) FROM (VALUES (1e308), (1e308)) tbl(i) +-- +ok +== +SELECT AVG(i) FROM (VALUES (1e308), (1e308)) tbl(i) +-- +ok +== +SELECT 1e308+1e308 +-- +ok +== +SELECT 1e308*2 +-- +ok +== +SELECT -1e308-1e308 +-- +ok +== +SELECT 1e308/0.1 +-- +ok +== +SELECT 2e38::REAL+2e38::REAL +-- +ok +== +SELECT 2e38::REAL*2 +-- +ok +== +SELECT -2e38::REAL-2e38::REAL +-- +ok +== +SELECT 2e38::REAL/0.1::REAL +-- +ok +== diff --git a/parser/testdata/corpus/sql/overflow/test_overflow.test b/parser/testdata/corpus/sql/overflow/test_overflow.test new file mode 100644 index 0000000..df46163 --- /dev/null +++ b/parser/testdata/corpus/sql/overflow/test_overflow.test @@ -0,0 +1,73 @@ +# source: test/sql/overflow/test_overflow.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +INSERT INTO test VALUES (-1099511627776, 3) +-- +ok +== +INSERT INTO test VALUES (11, 22), (12, 21), (14, 22) +-- +ok +== +SELECT ALL CAST ( - SUM ( DISTINCT - CAST ( NULL AS INTEGER ) ) AS INTEGER ) FROM test +-- +ok +== +SELECT b, AVG(a) FROM test GROUP BY b ORDER BY b; +-- +ok +== +SELECT cast(200 AS TINYINT) +-- +ok +== +SELECT cast(-129 AS TINYINT) +-- +ok +== +SELECT cast(100 AS TINYINT) + cast(100 AS TINYINT) +-- +ok +== +CREATE TABLE test2 (a INTEGER, b TINYINT); +-- +ok +== +INSERT INTO test2 VALUES (200, 60), (12, 60), (14, 60) +-- +ok +== +SELECT cast(a AS TINYINT) FROM test2 +-- +ok +== +SELECT SUM(b) FROM test2 +-- +ok +== +SELECT 100::TINYINT - -50::TINYINT +-- +ok +== +SELECT 100::TINYINT * 2::TINYINT +-- +ok +== +SELECT 100::TINYINT + b::TINYINT FROM test2 +-- +ok +== +SELECT 100::TINYINT - -b::TINYINT FROM test2 +-- +ok +== +SELECT 100::TINYINT * b::TINYINT FROM test2 +-- +ok +== +SELECT a + b FROM (SELECT cast(100 AS TINYINT) AS a, cast(100 AS TINYINT) AS b) tbl1 +-- +ok +== diff --git a/parser/testdata/corpus/sql/parallelism/async_task_schedule_pool.test b/parser/testdata/corpus/sql/parallelism/async_task_schedule_pool.test new file mode 100644 index 0000000..1b113da --- /dev/null +++ b/parser/testdata/corpus/sql/parallelism/async_task_schedule_pool.test @@ -0,0 +1,29 @@ +# source: test/sql/parallelism/async_task_schedule_pool.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +SET debug_physical_table_scan_execution_strategy=DEFAULT +-- +ok +== +COPY (SELECT range AS i FROM range(100000)) TO '{TEST_DIR}/async_pool.parquet' (ROW_GROUP_SIZE 10000) +-- +ok +== +CALL enable_logging('AsyncTaskSchedule') +-- +ok +== +SELECT sum(i) FROM '{TEST_DIR}/async_pool.parquet' +-- +ok +== +SELECT DISTINCT pool FROM duckdb_logs_parsed('AsyncTaskSchedule') +-- +ok +== +SELECT sum(task_count) > 0 FROM duckdb_logs_parsed('AsyncTaskSchedule') +-- +ok +== diff --git a/parser/testdata/corpus/sql/parallelism/interquery/concurrent_appends.test b/parser/testdata/corpus/sql/parallelism/interquery/concurrent_appends.test new file mode 100644 index 0000000..cc4d716 --- /dev/null +++ b/parser/testdata/corpus/sql/parallelism/interquery/concurrent_appends.test @@ -0,0 +1,13 @@ +# source: test/sql/parallelism/interquery/concurrent_appends.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +INSERT INTO integers SELECT * FROM range(100); +-- +ok +== +SELECT COUNT(*), SUM(i) FROM integers +-- +ok +== diff --git a/parser/testdata/corpus/sql/parallelism/interquery/concurrent_checkpoint_insert.test b/parser/testdata/corpus/sql/parallelism/interquery/concurrent_checkpoint_insert.test new file mode 100644 index 0000000..21a5526 --- /dev/null +++ b/parser/testdata/corpus/sql/parallelism/interquery/concurrent_checkpoint_insert.test @@ -0,0 +1,21 @@ +# source: test/sql/parallelism/interquery/concurrent_checkpoint_insert.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +ATTACH '{TEST_DIR}/bla_{j}.db' AS db{j}; +-- +error: Parser Error: syntax error at or near "{" +== +CREATE TABLE db{j}.tbl (key INTEGER PRIMARY KEY); +-- +error: Parser Error: syntax error at or near "{" +== +INSERT INTO db{j}.tbl VALUES ({i}) +-- +error: Parser Error: syntax error at or near "{" +== +SELECT COUNT(*) FROM db{j}.tbl where key = {i} +-- +error: Parser Error: syntax error at or near "{" +== diff --git a/parser/testdata/corpus/sql/parallelism/interquery/concurrent_force_checkpoint.test b/parser/testdata/corpus/sql/parallelism/interquery/concurrent_force_checkpoint.test new file mode 100644 index 0000000..951468b --- /dev/null +++ b/parser/testdata/corpus/sql/parallelism/interquery/concurrent_force_checkpoint.test @@ -0,0 +1,33 @@ +# source: test/sql/parallelism/interquery/concurrent_force_checkpoint.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +CREATE OR REPLACE TABLE integers(i INTEGER) +-- +ok +== +INSERT INTO integers SELECT * FROM range(10000); +-- +ok +== +INSERT INTO integers SELECT * FROM range(10000 + {i} * 100, 10100 + {i} * 100); +-- +error: Parser Error: syntax error at or near "}" +== +DELETE FROM integers WHERE i=({threadid}-1)*100+{i} +-- +error: Parser Error: syntax error at or near "}" +== +UPDATE integers SET i=100000+i WHERE i=({threadid}-1)*100+{i} +-- +error: Parser Error: syntax error at or near "}" +== +SELECT COUNT(*), SUM(i) FROM integers; +-- +ok +== +FORCE CHECKPOINT +-- +ok +== diff --git a/parser/testdata/corpus/sql/parallelism/interquery/concurrent_index_scans_while_appending.test b/parser/testdata/corpus/sql/parallelism/interquery/concurrent_index_scans_while_appending.test new file mode 100644 index 0000000..cf06c7a --- /dev/null +++ b/parser/testdata/corpus/sql/parallelism/interquery/concurrent_index_scans_while_appending.test @@ -0,0 +1,9 @@ +# source: test/sql/parallelism/interquery/concurrent_index_scans_while_appending.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +SELECT * FROM integers WHERE i={i} * ({threadid} * 300); +-- +error: Parser Error: syntax error at or near "}" +== diff --git a/parser/testdata/corpus/sql/parallelism/interquery/concurrent_reads_while_altering.test b/parser/testdata/corpus/sql/parallelism/interquery/concurrent_reads_while_altering.test new file mode 100644 index 0000000..ac4972f --- /dev/null +++ b/parser/testdata/corpus/sql/parallelism/interquery/concurrent_reads_while_altering.test @@ -0,0 +1,13 @@ +# source: test/sql/parallelism/interquery/concurrent_reads_while_altering.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +ALTER TABLE integers ADD COLUMN newcol_{i} INTEGER +-- +error: Parser Error: syntax error at or near "{" +== +INSERT INTO integers (i) SELECT * FROM range(10000 + {i} * 100, 10100 + {i} * 100); +-- +error: Parser Error: syntax error at or near "}" +== diff --git a/parser/testdata/corpus/sql/parallelism/interquery/concurrent_reads_while_renaming.test b/parser/testdata/corpus/sql/parallelism/interquery/concurrent_reads_while_renaming.test new file mode 100644 index 0000000..7639fc8 --- /dev/null +++ b/parser/testdata/corpus/sql/parallelism/interquery/concurrent_reads_while_renaming.test @@ -0,0 +1,13 @@ +# source: test/sql/parallelism/interquery/concurrent_reads_while_renaming.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +ALTER TABLE integers RENAME TO integers_{i} +-- +error: Parser Error: syntax error at or near "{" +== +ALTER TABLE integers_{i} RENAME TO integers +-- +error: Parser Error: syntax error at or near "{" +== diff --git a/parser/testdata/corpus/sql/parallelism/interquery/concurrent_set_async_threads_read_ahead.test b/parser/testdata/corpus/sql/parallelism/interquery/concurrent_set_async_threads_read_ahead.test new file mode 100644 index 0000000..52a2e4e --- /dev/null +++ b/parser/testdata/corpus/sql/parallelism/interquery/concurrent_set_async_threads_read_ahead.test @@ -0,0 +1,25 @@ +# source: test/sql/parallelism/interquery/concurrent_set_async_threads_read_ahead.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +SET debug_physical_table_scan_execution_strategy='SYNCHRONOUS' +-- +ok +== +COPY (SELECT range AS i FROM range(500000)) TO '{TEST_DIR}/ra_race_{i}.parquet' (FORMAT parquet, ROW_GROUP_SIZE 2048) +-- +ok +== +SELECT sum(i) FROM '{TEST_DIR}/ra_race_*.parquet' +-- +ok +== +SELECT sleep_ms(100) +-- +ok +== +SET async_threads=0 +-- +ok +== diff --git a/parser/testdata/corpus/sql/parallelism/intraquery/depth_first_evaluation_union_and_join.test b/parser/testdata/corpus/sql/parallelism/intraquery/depth_first_evaluation_union_and_join.test new file mode 100644 index 0000000..7b33696 --- /dev/null +++ b/parser/testdata/corpus/sql/parallelism/intraquery/depth_first_evaluation_union_and_join.test @@ -0,0 +1,41 @@ +# source: test/sql/parallelism/intraquery/depth_first_evaluation_union_and_join.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +SELECT ss_quantity quantity, + ss_list_price list_price +FROM store_sales, + date_dim +WHERE ss_sold_date_sk = d_date_sk + AND d_year BETWEEN 1999 AND 1999 + 2 +UNION ALL SELECT cs_quantity quantity, + cs_list_price list_price +FROM catalog_sales, + date_dim +WHERE cs_sold_date_sk = d_date_sk + AND d_year BETWEEN 1999 AND 1999 + 2 +-- +ok +== +SELECT ss_quantity quantity, + ss_list_price list_price +FROM store_sales, + date_dim +WHERE ss_sold_date_sk = d_date_sk + AND d_year BETWEEN 1999 AND 1999 + 2 +UNION ALL SELECT cs_quantity quantity, + cs_list_price list_price +FROM catalog_sales, + date_dim +WHERE cs_sold_date_sk = d_date_sk + AND d_year BETWEEN 1999 AND 1999 + 2 +UNION ALL SELECT ws_quantity quantity, + ws_list_price list_price +FROM web_sales, + date_dim +WHERE ws_sold_date_sk = d_date_sk + AND d_year BETWEEN 1999 AND 1999 + 2 +-- +ok +== diff --git a/parser/testdata/corpus/sql/parallelism/intraquery/error_in_pipeline.test b/parser/testdata/corpus/sql/parallelism/intraquery/error_in_pipeline.test new file mode 100644 index 0000000..7abaee2 --- /dev/null +++ b/parser/testdata/corpus/sql/parallelism/intraquery/error_in_pipeline.test @@ -0,0 +1,21 @@ +# source: test/sql/parallelism/intraquery/error_in_pipeline.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +PRAGMA threads=16 +-- +ok +== +create table varchars as select i::varchar i from range(1000000) tbl(i); +-- +ok +== +insert into varchars values ('hello') +-- +ok +== +select (select min(i::int)+tbl.k from varchars) from (values (1), (2), (3)) tbl(k); +-- +ok +== diff --git a/parser/testdata/corpus/sql/parallelism/intraquery/parallel_sample.test b/parser/testdata/corpus/sql/parallelism/intraquery/parallel_sample.test new file mode 100644 index 0000000..3b1f4b6 --- /dev/null +++ b/parser/testdata/corpus/sql/parallelism/intraquery/parallel_sample.test @@ -0,0 +1,13 @@ +# source: test/sql/parallelism/intraquery/parallel_sample.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +CREATE TABLE integers AS SELECT * FROM range(50000) tbl(i) +-- +ok +== +SELECT COUNT(*) FROM integers TABLESAMPLE RESERVOIR(100) +-- +ok +== diff --git a/parser/testdata/corpus/sql/parallelism/intraquery/test_parallel_nested_aggregates.test b/parser/testdata/corpus/sql/parallelism/intraquery/test_parallel_nested_aggregates.test new file mode 100644 index 0000000..85c68d0 --- /dev/null +++ b/parser/testdata/corpus/sql/parallelism/intraquery/test_parallel_nested_aggregates.test @@ -0,0 +1,45 @@ +# source: test/sql/parallelism/intraquery/test_parallel_nested_aggregates.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +create table t as select range a, range%10 b from range(100000); +-- +ok +== +select first([a]) from t group by b%2; +-- +ok +== +select min([a]), max([a]) from t group by b%2; +-- +ok +== +select min([-a, 1, a]), max([-a, 1, a]) from t group by b%2; +-- +ok +== +select min({'i': a}), max({'i': a}) from t group by b%2 order by all; +-- +ok +== +select min({'i': a, 'j': a % 2}), max({'i': a, 'j': a % 2}) from t group by b%2; +-- +ok +== +select first(NULL::INT[]) from t group by b%2; +-- +ok +== +select min(NULL::INT[]) from t group by b%2; +-- +ok +== +select first(NULL::ROW(i INTEGER)) from t group by b%2; +-- +ok +== +select min(NULL::ROW(i INTEGER)) from t group by b%2; +-- +ok +== diff --git a/parser/testdata/corpus/sql/parallelism/intraquery/test_persistent_parallelism.test b/parser/testdata/corpus/sql/parallelism/intraquery/test_persistent_parallelism.test new file mode 100644 index 0000000..90b0b2a --- /dev/null +++ b/parser/testdata/corpus/sql/parallelism/intraquery/test_persistent_parallelism.test @@ -0,0 +1,17 @@ +# source: test/sql/parallelism/intraquery/test_persistent_parallelism.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +CREATE TABLE integers AS SELECT * FROM range(0, 5000) tbl(i) +-- +ok +== +SELECT MIN(i), MAX(i) FROM integers +-- +ok +== +INSERT INTO integers SELECT * FROM range(5000, 10000) +-- +ok +== diff --git a/parser/testdata/corpus/sql/parallelism/intraquery/test_simple_parallelism.test b/parser/testdata/corpus/sql/parallelism/intraquery/test_simple_parallelism.test new file mode 100644 index 0000000..48df3d7 --- /dev/null +++ b/parser/testdata/corpus/sql/parallelism/intraquery/test_simple_parallelism.test @@ -0,0 +1,21 @@ +# source: test/sql/parallelism/intraquery/test_simple_parallelism.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +SELECT SUM(i) FROM integers UNION ALL SELECT AVG(i) FROM integers UNION ALL SELECT MIN(i) FROM integers UNION ALL SELECT MAX(i) FROM integers; +-- +ok +== +CREATE VIEW v1(i) AS SELECT SUM(i) FROM integers UNION ALL SELECT AVG(i) FROM integers UNION ALL SELECT MIN(i) FROM integers UNION ALL SELECT MAX(i) FROM integers; +-- +ok +== +SELECT SUM(i) FROM integers UNION ALL SELECT AVG(i) FROM integers UNION ALL SELECT MIN(i::DATE) FROM integers UNION ALL SELECT MAX(i::DATE) FROM integers; +-- +ok +== +SELECT * FROM v1 t1 JOIN v1 t2 USING (i); +-- +ok +== diff --git a/parser/testdata/corpus/sql/parallelism/intraquery/test_verify_parallelism.test b/parser/testdata/corpus/sql/parallelism/intraquery/test_verify_parallelism.test new file mode 100644 index 0000000..43976da --- /dev/null +++ b/parser/testdata/corpus/sql/parallelism/intraquery/test_verify_parallelism.test @@ -0,0 +1,17 @@ +# source: test/sql/parallelism/intraquery/test_verify_parallelism.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +SELECT MIN(i), MAX(i) FROM integers WHERE i>2000 +-- +ok +== +CREATE TABLE integers2 AS SELECT i%4 i, i j FROM range(0, 5000) tbl(i) +-- +ok +== +SELECT i, SUM(j), MIN(j), MAX(j) FROM integers2 GROUP BY i ORDER BY i +-- +ok +== diff --git a/parser/testdata/corpus/sql/parser/columns_aliases.test b/parser/testdata/corpus/sql/parser/columns_aliases.test new file mode 100644 index 0000000..3f14b76 --- /dev/null +++ b/parser/testdata/corpus/sql/parser/columns_aliases.test @@ -0,0 +1,77 @@ +# source: test/sql/parser/columns_aliases.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +CREATE TABLE integers AS SELECT 42 i, 84 j UNION ALL SELECT 13, 14 +-- +ok +== +SELECT i, j FROM (SELECT COLUMNS(*)::VARCHAR FROM integers) +-- +ok +== +SELECT min_i, min_j, max_i, max_j FROM (SELECT MIN(COLUMNS(*)) AS "min_\0", MAX(COLUMNS(*)) AS "max_\0" FROM integers) +-- +ok +== +CREATE TABLE numerics AS SELECT 42 a42, 84 b84, 126 c126, 1000 d +-- +ok +== +SELECT min_a, min_b, min_c FROM (SELECT MIN(COLUMNS('([a-z])\d+')) AS "min_\1" FROM numerics) +-- +ok +== +SELECT min_, "min__1", "min__2" FROM (SELECT MIN(COLUMNS('([a-z])\d+')) AS "min_\2" FROM numerics) +-- +ok +== +SELECT "min_\a\", "min_\b\", "min_\c\" FROM (SELECT MIN(COLUMNS('([a-z])\d+')) AS "min_\\\1\\" FROM numerics) +-- +ok +== +SELECT "a42aa", "b84bb", "c126cc" FROM (SELECT MIN(COLUMNS('([a-z])(\d+)')) AS "\1\2\1\1" FROM numerics) +-- +ok +== +SELECT MIN(COLUMNS('([a-z])\d+')) AS "\" FROM numerics +-- +ok +== +SELECT MIN(COLUMNS('([a-z])\d+')) AS "\a" FROM numerics +-- +ok +== +SELECT MIN(COLUMNS(*)) AS "min_\1" FROM numerics +-- +ok +== +SELECT price, amount_sold, total_profit FROM (SELECT COLUMNS(*)::VARCHAR FROM tbl) +-- +ok +== +SELECT varchar_price, varchar_amount_sold, varchar_total_profit FROM (SELECT COLUMNS(*)::VARCHAR AS "varchar_\0" FROM tbl) +-- +ok +== +create table a as select 42 as i, 80 as j; +-- +ok +== +create table b as select 43 as i, 84 as k; +-- +ok +== +create table c as select 44 as i, 84 as l; +-- +ok +== +select i, j, k from (select columns(*)::VARCHAR from a full outer join b using (i)) order by 1; +-- +ok +== +select i, j, k, l from (select columns(*)::VARCHAR from a full outer join b using (i) full outer join c using (i)) order by 1; +-- +ok +== diff --git a/parser/testdata/corpus/sql/parser/columns_issue9867.test b/parser/testdata/corpus/sql/parser/columns_issue9867.test new file mode 100644 index 0000000..defb2a3 --- /dev/null +++ b/parser/testdata/corpus/sql/parser/columns_issue9867.test @@ -0,0 +1,28 @@ +# source: test/sql/parser/columns_issue9867.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +CREATE TABLE df1 AS + SELECT + UNNEST(['K0', 'K1', 'K2', 'K3', 'K4', 'K5']) AS key, + UNNEST([11, 12, 13, 14, 15, 16]) AS A, + UNNEST([21, 22, 23, 24, 25, 26]) AS B +-- +ok +== +CREATE TABLE df2 AS + SELECT + UNNEST(['K0', 'K2', 'K5']) AS key, + UNNEST([2, 3, 5]) AS C +-- +ok +== +select sin(columns(df1.* exclude (key))) from df1 join df2 using(key) +-- +ok +== +select sin(columns(dfxx.* exclude (key))) from df1 join df2 using(key) +-- +ok +== diff --git a/parser/testdata/corpus/sql/parser/digit_separators.test b/parser/testdata/corpus/sql/parser/digit_separators.test new file mode 100644 index 0000000..9d4bfb2 --- /dev/null +++ b/parser/testdata/corpus/sql/parser/digit_separators.test @@ -0,0 +1,229 @@ +# source: test/sql/parser/digit_separators.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +SELECT 1_2 +-- +ok +== +SELECT 1_2.1_2E1_0 +-- +ok +== +SELECT '1_2.1_2E1_0'::DOUBLE +-- +ok +== +SELECT 1__2 +-- +ok +== +SELECT 1_000_000 +-- +ok +== +SELECT '1000_000_000'::INT +-- +ok +== +SELECT '1000__000__000'::INT +-- +ok +== +SELECT '_1_2'::INT +-- +ok +== +SELECT '1_2_'::INT +-- +ok +== +SELECT 1_2.1_2 +-- +ok +== +SELECT 12.1_2 +-- +ok +== +SELECT 1_2.12 +-- +ok +== +SELECT '_12.12'::DECIMAL(4,2) +-- +ok +== +SELECT '12._12'::DECIMAL(4,2) +-- +ok +== +SELECT '12_.12'::DECIMAL(4,2) +-- +ok +== +SELECT '12.12_'::DECIMAL(4,2) +-- +ok +== +SELECT '1__2.1__2'::FLOAT +-- +ok +== +SELECT '12.1_2'::FLOAT +-- +ok +== +SELECT '1_2.12'::FLOAT +-- +ok +== +SELECT '12.1_2e2'::FLOAT +-- +ok +== +SELECT '_12.12'::FLOAT == 12.12 +-- +ok +== +SELECT '12._12'::FLOAT == 12.12 +-- +ok +== +SELECT '12._12e2'::FLOAT == 12.12e2 +-- +ok +== +SELECT '12_.12'::FLOAT == 12.12 +-- +ok +== +SELECT '12.12_'::FLOAT == 12.12 +-- +ok +== +SELECT '12.12_e2'::FLOAT == 12.12e2 +-- +ok +== +SELECT 1_000_000_000_000_000_000_000::DOUBLE +-- +ok +== +SELECT .000_000_000_000_000_000_000_123::DOUBLE +-- +ok +== +SELECT 1_000_000_000_000_000_000_000.5::DOUBLE +-- +ok +== +SELECT '1_000_000_000.000_000_000_5'::DOUBLE +-- +ok +== +SELECT '_1_000_000_000_000_000_000_000'::DOUBLE == 1e+21 +-- +ok +== +SELECT '._000_000_000_000_000_000_000_123'::DOUBLE == 123e-23 +-- +ok +== +SELECT '1_000_000_000_000_000_000_000_'::DOUBLE == 1e+21 +-- +ok +== +SELECT '.000_000_000_000_000_000_000_123_'::DOUBLE == 123e-23 +-- +ok +== +select '20e10_'::FLOAT +-- +ok +== +select '20e_10'::FLOAT +-- +ok +== +select '20e10_'::BIGINT +-- +ok +== +select '20e_10'::BIGINT +-- +ok +== +SELECT 12e1_0::BIGINT == 12e10::BIGINT +-- +ok +== +SELECT '12e10_'::BIGINT == 12e10::BIGINT +-- +ok +== +SELECT '_12e10::BIGINT' == 12e10::BIGINT +-- +ok +== +SELECT '0b01_01'::INT +-- +ok +== +SELECT '0b0_1_0_1'::INT +-- +ok +== +SELECT '0b0_1_0_1_'::INT +-- +ok +== +SELECT '0b_0_1_0_1'::INT +-- +ok +== +SELECT '0b0__1_0_1'::INT +-- +ok +== +SELECT '0xFF_FF'::INT; +-- +ok +== +SELECT '0xF_F_F_F'::INT; +-- +ok +== +SELECT '0x0_F_F_F_'::INT +-- +ok +== +SELECT '0x_F_F_F'::INT +-- +ok +== +SELECT '0x0__F_F_F'::INT +-- +ok +== +SELECT typeof(10.00), typeof(10.0_0), typeof(1_0.00), typeof(1_0.0_0); +-- +ok +== +select 1_2e1_0::FLOAT +-- +ok +== +select '1_2e1_0'::FLOAT +-- +ok +== +select 1_2e1_0::BIGINT +-- +ok +== +select '1_2e1_0'::BIGINT +-- +ok +== diff --git a/parser/testdata/corpus/sql/parser/division_operator_precedence.test b/parser/testdata/corpus/sql/parser/division_operator_precedence.test new file mode 100644 index 0000000..8ccb9d8 --- /dev/null +++ b/parser/testdata/corpus/sql/parser/division_operator_precedence.test @@ -0,0 +1,29 @@ +# source: test/sql/parser/division_operator_precedence.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +SELECT 6 * 1 / 2 +-- +ok +== +SELECT 6 * 1 // 2 +-- +ok +== +SELECT (6 * 1) // 2 +-- +ok +== +SELECT 6 * (1 // 2) +-- +ok +== +SELECT 6 + 1 / 2 +-- +ok +== +SELECT 6 + 1 // 2 +-- +ok +== diff --git a/parser/testdata/corpus/sql/parser/dollar_quotes_internal_issue2224.test b/parser/testdata/corpus/sql/parser/dollar_quotes_internal_issue2224.test new file mode 100644 index 0000000..2a842de --- /dev/null +++ b/parser/testdata/corpus/sql/parser/dollar_quotes_internal_issue2224.test @@ -0,0 +1,57 @@ +# source: test/sql/parser/dollar_quotes_internal_issue2224.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +select $tag$ $tag$ = $tag$　$tag$; +-- +ok +== +select ' ' = '　'; +-- +ok +== +select $$$$ = ''; +-- +ok +== +select $tag$$tag$ = ''; +-- +ok +== +select '' = $$$$; +-- +ok +== +select '' = $tag$$tag$; +-- +ok +== +select $$ $$ = $$　$$ or ' ' = '　'; +-- +ok +== +select $tag$ $tag$ = $tag$　$tag$ or ' ' = '　'; +-- +ok +== +select ' ' = '　' or $$ $$ = $$　$$; +-- +ok +== +select ' ' = '　' or $tag$ $tag$ = $tag$　$tag$; +-- +ok +== +select $tag$ $duck$ $tag$ = $tag$　$duck$　$tag$; +-- +ok +== +select $🦆$du ck$🦆$ = $🦆$du　ck$🦆$; +-- +ok +== +select $ü$x x$ü$ = $ü$x　x$ü$; +-- +ok +== diff --git a/parser/testdata/corpus/sql/parser/empty_quoted_identifier.test b/parser/testdata/corpus/sql/parser/empty_quoted_identifier.test new file mode 100644 index 0000000..570cca2 --- /dev/null +++ b/parser/testdata/corpus/sql/parser/empty_quoted_identifier.test @@ -0,0 +1,17 @@ +# source: test/sql/parser/empty_quoted_identifier.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +SELECT a.""; +-- +error: Parser Error: zero-length delimited identifier +== +SELECT ""; +-- +error: Parser Error: zero-length delimited identifier +== +CREATE TABLE t(""); +-- +error: Parser Error: zero-length delimited identifier +== diff --git a/parser/testdata/corpus/sql/parser/expression_depth_limit.test b/parser/testdata/corpus/sql/parser/expression_depth_limit.test new file mode 100644 index 0000000..67e5e49 --- /dev/null +++ b/parser/testdata/corpus/sql/parser/expression_depth_limit.test @@ -0,0 +1,17 @@ +# source: test/sql/parser/expression_depth_limit.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +SELECT (1+(1+(1+(1+(1+(1+(1+1))))))); +-- +ok +== +SET max_expression_depth TO 7; +-- +ok +== +SET max_expression_depth TO 1000; +-- +ok +== diff --git a/parser/testdata/corpus/sql/parser/external_resource_roundtrip.test b/parser/testdata/corpus/sql/parser/external_resource_roundtrip.test new file mode 100644 index 0000000..0eda814 --- /dev/null +++ b/parser/testdata/corpus/sql/parser/external_resource_roundtrip.test @@ -0,0 +1,73 @@ +# source: test/sql/parser/external_resource_roundtrip.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +SET debug_verify_statement='{mode}' +-- +ok +== +DESTROY EXTERNAL RESOURCE plain_name +-- +ok +== +DESTROY EXTERNAL RESOURCE "weird name" +-- +ok +== +DESTROY EXTERNAL RESOURCE "select" +-- +ok +== +DESTROY EXTERNAL RESOURCE "he said ""hi""" +-- +ok +== +DESTROY EXTERNAL RESOURCE "MixedCase" +-- +ok +== +CREATE EXTERNAL RESOURCE 'aws:ec2:quack' AS x (SPOT, REGION 'eu-west-1') +-- +ok +== +CREATE EXTERNAL RESOURCE 'aws:ec2:quack' AS "weird name" (SPOT, REGION 'eu-west-1') +-- +ok +== +CREATE EXTERNAL RESOURCE 'aws:ec2:quack' AS "select" (REGION 'eu-west-1') +-- +ok +== +CREATE EXTERNAL RESOURCE 'aws:ec2:quack' +-- +ok +== +CREATE EXTERNAL RESOURCE 'aws:ec2:it''s quacky' AS x +-- +ok +== +REGISTER EXTERNAL RESOURCE 'aws:ec2:quack' AS x FROM {'id': 'i-123'} +-- +ok +== +REGISTER EXTERNAL RESOURCE 'aws:ec2:quack' AS "weird name" FROM {'id': 'i-123', 'tags': ['a','b']} +-- +ok +== +REGISTER EXTERNAL RESOURCE 'aws:ec2:quack' AS x FROM 'plain-handle' +-- +ok +== +SHOW EXTERNAL RESOURCES +-- +ok +== +SELECT count(*) FROM duckdb_external_resources() +-- +ok +== +RESET debug_verify_statement +-- +ok +== diff --git a/parser/testdata/corpus/sql/parser/fetch_first.test b/parser/testdata/corpus/sql/parser/fetch_first.test new file mode 100644 index 0000000..6aaac1a --- /dev/null +++ b/parser/testdata/corpus/sql/parser/fetch_first.test @@ -0,0 +1,37 @@ +# source: test/sql/parser/fetch_first.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +CREATE TABLE t(a INT); +-- +ok +== +SELECT * FROM t ORDER BY a FETCH FIRST 2 ROWS ONLY +-- +ok +== +SELECT * FROM t ORDER BY a FETCH NEXT 1 ROW ONLY +-- +ok +== +SELECT * FROM t ORDER BY a FETCH FIRST 1 ROW ONLY +-- +ok +== +SELECT * FROM t ORDER BY a FETCH NEXT 2 ROWS ONLY +-- +ok +== +SELECT * FROM t ORDER BY a OFFSET 1 ROW FETCH FIRST 1 ROW ONLY +-- +ok +== +SELECT * FROM t ORDER BY a OFFSET 1 ROWS FETCH NEXT 2 ROWS ONLY +-- +ok +== +SELECT * FROM t ORDER BY a FETCH FIRST (1 + 1) ROWS ONLY +-- +ok +== diff --git a/parser/testdata/corpus/sql/parser/from_first.test b/parser/testdata/corpus/sql/parser/from_first.test new file mode 100644 index 0000000..b7771f1 --- /dev/null +++ b/parser/testdata/corpus/sql/parser/from_first.test @@ -0,0 +1,37 @@ +# source: test/sql/parser/from_first.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +FROM integers SELECT i + 1 +-- +ok +== +FROM integers LIMIT 2 +-- +ok +== +FROM integers WHERE i IS NOT NULL +-- +ok +== +FROM integers ORDER BY i DESC NULLS FIRST +-- +ok +== +FROM integers SELECT DISTINCT i%2 WHERE i>0 ORDER BY ALL +-- +ok +== +FROM integers SELECT i%2 AS g, SUM(i) sum GROUP BY g HAVING sum IS NOT NULL ORDER BY ALL +-- +ok +== +FROM integers JOIN integers i2 USING (i) +-- +ok +== +FROM integers i1, integers i2 SELECT COUNT(*) +-- +ok +== diff --git a/parser/testdata/corpus/sql/parser/function_chaining.test b/parser/testdata/corpus/sql/parser/function_chaining.test new file mode 100644 index 0000000..913b0cf --- /dev/null +++ b/parser/testdata/corpus/sql/parser/function_chaining.test @@ -0,0 +1,73 @@ +# source: test/sql/parser/function_chaining.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +INSERT INTO varchars VALUES ('Hello'), ('World') +-- +ok +== +SELECT x.lower() FROM varchars +-- +ok +== +SELECT main.lower() FROM varchars AS t(main) +-- +ok +== +SELECT (v).lower() FROM varchars +-- +ok +== +SELECT v.lowe() FROM varchars +-- +ok +== +SELECT varchars.v.lower() FROM varchars +-- +ok +== +SELECT v.lower().upper() FROM varchars +-- +ok +== +SELECT v.lower()[:3] FROM varchars +-- +ok +== +INSERT INTO varchars VALUES ('Hello World'); +-- +ok +== +SELECT v.split(' ') FROM varchars +-- +ok +== +SELECT v.split(' ').apply(lambda x: x.lower()) FROM varchars +-- +ok +== +SELECT v.split(' ').apply(lambda x: x.lower()).filter(lambda x: x[1] == 'h') FROM varchars +-- +ok +== +SELECT v.split(' ').length() FROM varchars +-- +ok +== +SELECT v.split(' ').aggregate('count') FROM varchars +-- +ok +== +SELECT v.split(' ').aggregate('min') FROM varchars +-- +ok +== +PREPARE v1 AS SELECT ?.split(' ')[1].lower() +-- +ok +== +EXECUTE v1('Hello World') +-- +ok +== diff --git a/parser/testdata/corpus/sql/parser/hex_string_literal.test b/parser/testdata/corpus/sql/parser/hex_string_literal.test new file mode 100644 index 0000000..7ebc004 --- /dev/null +++ b/parser/testdata/corpus/sql/parser/hex_string_literal.test @@ -0,0 +1,21 @@ +# source: test/sql/parser/hex_string_literal.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +SELECT pg_typeof(X'FF'); +-- +ok +== +SELECT X'41'::VARCHAR; +-- +ok +== +SELECT X'48656C6C6F'::VARCHAR; +-- +ok +== +SELECT octet_length(X'DEADBEEF'); +-- +ok +== diff --git a/parser/testdata/corpus/sql/parser/indirection.test b/parser/testdata/corpus/sql/parser/indirection.test new file mode 100644 index 0000000..cb341a1 --- /dev/null +++ b/parser/testdata/corpus/sql/parser/indirection.test @@ -0,0 +1,29 @@ +# source: test/sql/parser/indirection.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +select case when true then {'a': 42} end.a; +-- +ok +== +select [42][1]; +-- +ok +== +select array[42][1]; +-- +ok +== +select [a for a in [42, 84]][1]; +-- +ok +== +prepare v1 as select $1[1]; +-- +ok +== +execute v1([42]); +-- +ok +== diff --git a/parser/testdata/corpus/sql/parser/invalid_utf8_parser_location.test b/parser/testdata/corpus/sql/parser/invalid_utf8_parser_location.test new file mode 100644 index 0000000..3bdf88a --- /dev/null +++ b/parser/testdata/corpus/sql/parser/invalid_utf8_parser_location.test @@ -0,0 +1,15 @@ +# source: test/sql/parser/invalid_utf8_parser_location.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +SELECT + 42 +FROM t; +-- +error: Parser Error: Invalid UTF-8 in query (byte sequence mismatch) +== +SET errors_as_json=true; +-- +ok +== diff --git a/parser/testdata/corpus/sql/parser/invisible_spaces.test b/parser/testdata/corpus/sql/parser/invisible_spaces.test new file mode 100644 index 0000000..0db2fa7 --- /dev/null +++ b/parser/testdata/corpus/sql/parser/invisible_spaces.test @@ -0,0 +1,42 @@ +# source: test/sql/parser/invisible_spaces.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +SELECT{unicode_space}42; +-- +error: Parser Error: syntax error at or near "}" +== +SELECT{unicode_space}strlen('{unicode_space}')>=2; +-- +error: Parser Error: syntax error at or near "}" +== +SELECT{unicode_space}strlen(' ''{unicode_space}')>=4; +-- +error: Parser Error: syntax error at or near "}" +== +SELECT{unicode_space} -- {unicode_space}; +42 +-- +error: Parser Error: syntax error at or near "}" +== +SELECT{unicode_space}42{unicode_space}{unicode_space}{unicode_space}{unicode_space}{unicode_space} +-- +error: Parser Error: syntax error at or near "}" +== +SELECT a{unicode_space} FROM (SELECT 42) t(a); +-- +error: Parser Error: syntax error at or near "{" +== +SELEC  +-- +ok +== +  +-- +ok +== +S +-- +ok +== diff --git a/parser/testdata/corpus/sql/parser/join_alias.test b/parser/testdata/corpus/sql/parser/join_alias.test new file mode 100644 index 0000000..463418a --- /dev/null +++ b/parser/testdata/corpus/sql/parser/join_alias.test @@ -0,0 +1,31 @@ +# source: test/sql/parser/join_alias.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +select t.* +from ( + (values (1), (2)) as t1 (a) + cross join + (values (3), (4)) as t2 (b) +) as t +-- +ok +== +select x, y +from ( + (values (1), (2)) as t1 (a) + cross join + (values (3), (4)) as t2 (b) +) as t(x, y) +-- +ok +== +from ( + (values (1), (2)) as t1 (a) + cross join + (values (3), (4)) as t2 (b) +) as t(x, y, z) +-- +ok +== diff --git a/parser/testdata/corpus/sql/parser/position_prepare.test b/parser/testdata/corpus/sql/parser/position_prepare.test new file mode 100644 index 0000000..04b6ef7 --- /dev/null +++ b/parser/testdata/corpus/sql/parser/position_prepare.test @@ -0,0 +1,13 @@ +# source: test/sql/parser/position_prepare.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +PREPARE v1 AS SELECT POSITION(? in ?) +-- +ok +== +EXECUTE v1('e', 'hello world') +-- +ok +== diff --git a/parser/testdata/corpus/sql/parser/star_expression.test b/parser/testdata/corpus/sql/parser/star_expression.test new file mode 100644 index 0000000..42e68f8 --- /dev/null +++ b/parser/testdata/corpus/sql/parser/star_expression.test @@ -0,0 +1,53 @@ +# source: test/sql/parser/star_expression.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +SELECT * FROM integers WHERE * +-- +ok +== +SELECT * FROM integers WHERE * IS NOT NULL +-- +ok +== +SELECT * FROM integers WHERE COLUMNS(*) IS NULL ORDER BY ALL +-- +ok +== +SELECT * FROM integers GROUP BY COLUMNS(*) +-- +ok +== +SELECT * FROM integers GROUP BY * + 42 +-- +ok +== +SELECT * FROM integers GROUP BY i HAVING * > 42 +-- +ok +== +SELECT * FROM integers GROUP BY i HAVING COLUMNS(*)>42 +-- +ok +== +SELECT * FROM integers ORDER BY *, * +-- +ok +== +SELECT * FROM integers ORDER BY * + 42 +-- +ok +== +INSERT INTO integers VALUES (*, *) +-- +ok +== +VALUES (*) +-- +ok +== +FROM read_csv(*, *); +-- +ok +== diff --git a/parser/testdata/corpus/sql/parser/statement_tostring_roundtrip.test b/parser/testdata/corpus/sql/parser/statement_tostring_roundtrip.test new file mode 100644 index 0000000..f5c0c63 --- /dev/null +++ b/parser/testdata/corpus/sql/parser/statement_tostring_roundtrip.test @@ -0,0 +1,346 @@ +# source: test/sql/parser/statement_tostring_roundtrip.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +CREATE TABLE "weird name"("odd col" INTEGER, "select" VARCHAR, "He said ""hi""" INTEGER) +-- +ok +== +CREATE TABLE "t chk"("a b" INTEGER CHECK ("a b" > 0), "c d" INTEGER UNIQUE) +-- +ok +== +CREATE TABLE "t gen"("a b" INTEGER, "g h" INTEGER GENERATED ALWAYS AS ("a b" * 2)) +-- +ok +== +CREATE TABLE "t fk"("a b" INTEGER PRIMARY KEY, "c d" INTEGER REFERENCES "t fk"("a b")) +-- +ok +== +CREATE TABLE "t comp"("a b" INTEGER NOT NULL DEFAULT 7, "c d" INTEGER, PRIMARY KEY ("a b", "c d")) +-- +ok +== +CREATE SCHEMA "weird schema" +-- +ok +== +CREATE TABLE "weird schema"."qualified tbl"("x y" INTEGER) +-- +ok +== +CREATE TABLE "t fk2"("a b" INTEGER, FOREIGN KEY ("a b") REFERENCES "t fk"("a b")) +-- +ok +== +CREATE VIEW "weird view"("col a", "col b") AS SELECT 1, 2 +-- +ok +== +CREATE SEQUENCE "weird seq" START WITH 3 INCREMENT BY 2 MINVALUE 1 MAXVALUE 99 CYCLE +-- +ok +== +CREATE TYPE "weird enum" AS ENUM ('a b', 'c''d', '') +-- +ok +== +CREATE TYPE "weird struct" AS STRUCT("a b" INTEGER, "c d" VARCHAR) +-- +ok +== +CREATE TYPE "weird union" AS UNION("a b" INTEGER, "c d" VARCHAR) +-- +ok +== +CREATE MACRO "weird macro"("a b") AS "a b" + 1 +-- +ok +== +CREATE MACRO "macro defaults"(a, "b c" := 3) AS a + "b c" +-- +ok +== +CREATE MACRO "table macro"() AS TABLE SELECT 1 AS "q q" +-- +ok +== +ALTER TABLE "weird name" ADD COLUMN "new col" INTEGER +-- +ok +== +ALTER TABLE "weird name" ADD COLUMN IF NOT EXISTS "new col2" INTEGER DEFAULT 4 +-- +ok +== +ALTER TABLE "weird name" RENAME COLUMN "odd col" TO "odder col" +-- +ok +== +ALTER TABLE "weird name" ALTER COLUMN "odder col" SET DEFAULT 5 +-- +ok +== +ALTER TABLE "weird name" ALTER COLUMN "odder col" DROP DEFAULT +-- +ok +== +ALTER TABLE "weird name" ALTER COLUMN "odder col" TYPE BIGINT +-- +ok +== +ALTER TABLE "weird name" DROP COLUMN "new col2" +-- +ok +== +ALTER TABLE "weird name" RENAME TO "other name" +-- +ok +== +ALTER TABLE "other name" RENAME TO "weird name" +-- +ok +== +ALTER VIEW "weird view" RENAME TO "other view" +-- +ok +== +COMMENT ON TABLE "weird name" IS 'a comment with '' a quote' +-- +ok +== +COMMENT ON COLUMN "weird name"."odder col" IS 'hi' +-- +ok +== +CREATE INDEX "weird idx" ON "weird name"("odder col") +-- +ok +== +CREATE UNIQUE INDEX "weird uidx" ON "weird name"("select") +-- +ok +== +INSERT INTO "weird name"("odder col", "select", "He said ""hi""") VALUES (1, 'x', 2) +-- +ok +== +INSERT INTO "weird name" BY NAME SELECT 3 AS "odder col", 'y' AS "select" +-- +ok +== +INSERT INTO "t chk" VALUES (1, 1) ON CONFLICT DO NOTHING +-- +ok +== +UPDATE "weird name" SET "select" = 'z' WHERE "odder col" = 1 +-- +ok +== +DELETE FROM "weird name" WHERE "odder col" = 99 +-- +ok +== +MERGE INTO "t chk" USING "t chk" AS "src x" ON "t chk"."a b" = "src x"."a b" WHEN MATCHED THEN DELETE +-- +ok +== +SELECT "odder col" AS "a b" FROM "weird name" AS "al ias" ORDER BY "a b" +-- +ok +== +SELECT * FROM "weird name" t1 JOIN "weird name" t2 USING ("odder col") +-- +ok +== +SELECT sum("odder col") FILTER (WHERE "odder col" > 0) OVER (PARTITION BY "select" ORDER BY "odder col") +FROM "weird name" +-- +ok +== +SELECT * FROM "weird name" QUALIFY row_number() OVER (ORDER BY "odder col") = 1 +-- +ok +== +SELECT list_transform([1,2], lambda "x y": "x y" * 2), {'a b': 1}['a b'], MAP{'k k': 1}['k k'] +-- +ok +== +SELECT * FROM (VALUES (1)) AS "v v"("c c") +-- +ok +== +SELECT "weird name".* FROM "weird name" +-- +ok +== +SELECT "weird name".* EXCLUDE ("select") FROM "weird name" +-- +ok +== +SELECT * EXCLUDE ("select") RENAME ("odder col" AS "renamed col") FROM "weird name" +-- +ok +== +SELECT * REPLACE ("odder col" + 1 AS "odder col") FROM "weird name" +-- +ok +== +SELECT COLUMNS('od.*') FROM "weird name" +-- +ok +== +SELECT * FROM (PIVOT "weird name" ON "select" USING sum("odder col")) +-- +ok +== +SELECT * FROM (UNPIVOT "weird name" ON "odder col" INTO NAME "n n" VALUE "v v") +-- +ok +== +WITH "cte name"("c one") AS (SELECT 1) SELECT "c one" FROM "cte name" +-- +ok +== +SELECT * FROM "weird name" TABLESAMPLE reservoir(2 ROWS) REPEATABLE (1) +-- +ok +== +PREPARE "weird prep" AS SELECT $1 +-- +ok +== +EXECUTE "weird prep"(1) +-- +ok +== +DEALLOCATE "weird prep" +-- +ok +== +COPY "weird name" TO '{TEST_DIR}/roundtrip.csv' (FORMAT csv, DELIMITER '|', HEADER, NULLSTR 'NULL') +-- +ok +== +COPY (SELECT "odder col" AS "a b" FROM "weird name") TO '{TEST_DIR}/roundtrip2.csv' (FORMAT csv) +-- +ok +== +COPY "weird name" TO '{TEST_DIR}/rtdir' (FORMAT csv, PARTITION_BY ("select"), OVERWRITE_OR_IGNORE) +-- +ok +== +COPY (SELECT 1) TO '{TEST_DIR}/rt_fmt.csv' (FORMAT "odd format") +-- +ok +== +COPY (SELECT 1) TO '{TEST_DIR}/rt_fmt.csv' (FORMAT 'odd format') +-- +ok +== +ATTACH IF NOT EXISTS ':memory:' AS "db two" +-- +ok +== +DETACH "db two" +-- +ok +== +ATTACH ':memory:' AS "db three" ("odd opt" 'v') +-- +ok +== +COPY "weird name" TO '{TEST_DIR}/rt_opt.csv' ("odd opt" 'v') +-- +ok +== +CONNECT 'some_target' ("odd opt" 'v') +-- +ok +== +ATTACH IF NOT EXISTS ':memory:' AS "db four" (READ_ONLY false) +-- +ok +== +DETACH "db four" +-- +ok +== +DESCRIBE SELECT "odder col" AS "a b" FROM "weird name" +-- +ok +== +SUMMARIZE SELECT "odder col" AS "a b" FROM "weird name" +-- +ok +== +DROP INDEX "weird uidx" +-- +ok +== +DROP INDEX "weird idx" +-- +ok +== +DROP MACRO "weird macro" +-- +ok +== +DROP MACRO "macro defaults" +-- +ok +== +DROP MACRO TABLE "table macro" +-- +ok +== +DROP VIEW "other view" +-- +ok +== +DROP SEQUENCE "weird seq" +-- +ok +== +DROP TYPE "weird enum" +-- +ok +== +DROP TYPE "weird struct" +-- +ok +== +DROP TYPE "weird union" +-- +ok +== +DROP TABLE "t fk2" +-- +ok +== +DROP TABLE "t fk" +-- +ok +== +DROP TABLE "t gen" +-- +ok +== +DROP TABLE "t chk" +-- +ok +== +DROP TABLE "t comp" +-- +ok +== +DROP TABLE "weird name" +-- +ok +== +DROP SCHEMA "weird schema" CASCADE +-- +ok +== diff --git a/parser/testdata/corpus/sql/parser/switch_case.test b/parser/testdata/corpus/sql/parser/switch_case.test new file mode 100644 index 0000000..df27cab --- /dev/null +++ b/parser/testdata/corpus/sql/parser/switch_case.test @@ -0,0 +1,85 @@ +# source: test/sql/parser/switch_case.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +CREATE TABLE tbl AS FROM values(1), (4), (8), (0) i(x); +-- +ok +== +SELECT SWITCH(x, MAP { 1: 'yes', 0: 'no'}, 'maybe') FROM tbl; +-- +ok +== +CREATE TABLE nums AS FROM range(5) tbl(i); +-- +ok +== +SELECT SWITCH(i % 2, MAP { 0 : 'even', 1 : 'odd'}, 'error') FROM nums ORDER BY i; +-- +ok +== +SELECT + CASE (i % 2) + WHEN 0 THEN 'even' + WHEN 1 THEN 'odd' + ELSE 'error' + END +FROM nums +ORDER BY i; +-- +ok +== +SELECT switch(i, MAP {1 : 100, 3 : 300}) FROM nums ORDER BY i; +-- +ok +== +SELECT + CASE i + WHEN 1 THEN 100 + WHEN 3 THEN 300 + END +FROM nums +ORDER BY i; +-- +ok +== +CREATE TABLE null_test AS FROM VALUES (1), (NULL), (2) i(val); +-- +ok +== +SELECT switch(val, MAP { 1 : 'one', NULL : 'is_null'}, 'other') FROM null_test ORDER BY val; +-- +ok +== +SELECT + CASE val + WHEN 1 THEN 'one' + WHEN NULL THEN 'is_null' + ELSE 'other' + END +FROM null_test +ORDER BY val; +-- +ok +== +SELECT switch(val, MAP { 1+1 : 'one', 1: 'is_null'}, 'other') FROM null_test ORDER BY val; +-- +ok +== +SELECT switch(val, MAP {}, 'other') FROM null_test ORDER BY val; +-- +ok +== +CREATE TABLE map_expr(i map(integer, integer)); +-- +ok +== +INSERT INTO map_expr VALUES (MAP {1 : 2}); +-- +ok +== +SELECT SWITCH (1, i) FROM map_expr; +-- +ok +== diff --git a/parser/testdata/corpus/sql/parser/table_at_clause.test b/parser/testdata/corpus/sql/parser/table_at_clause.test new file mode 100644 index 0000000..1a1dbed --- /dev/null +++ b/parser/testdata/corpus/sql/parser/table_at_clause.test @@ -0,0 +1,37 @@ +# source: test/sql/parser/table_at_clause.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +SELECT * FROM tbl AT (TIMESTAMP => TIMESTAMP '2020-01-01') +-- +ok +== +SELECT * FROM tbl AT (VERSION => 42) +-- +ok +== +SELECT * FROM tbl t(c1, c2) AT (TIMESTAMP => '2020-01-01') +-- +ok +== +SET VARIABLE my_timestamp = TIMESTAMP '2020-01-01' +-- +ok +== +SELECT * FROM tbl AT (TIMESTAMP => getvariable('my_timestamp')) +-- +ok +== +SELECT * FROM tbl AT (TIMESTAMP => NOW() - INTERVAL '3 days') +-- +ok +== +SELECT * FROM tbl AT (TIMESTAMP => TIMESTAMP '2020-01-01' + a) +-- +ok +== +SELECT * FROM tbl AT (TIMESTAMP => (SELECT MIN(ts) FROM tbl)) +-- +ok +== diff --git a/parser/testdata/corpus/sql/parser/test_columns.test b/parser/testdata/corpus/sql/parser/test_columns.test new file mode 100644 index 0000000..911cd8d --- /dev/null +++ b/parser/testdata/corpus/sql/parser/test_columns.test @@ -0,0 +1,77 @@ +# source: test/sql/parser/test_columns.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +SELECT COLUMNS(*) FROM integers +-- +ok +== +SELECT MIN(COLUMNS(*)), MAX(COLUMNS(*)) FROM integers +-- +ok +== +SELECT MIN(COLUMNS(* EXCLUDE (j))), MAX(COLUMNS(* EXCLUDE (i))) FROM integers +-- +ok +== +SELECT MIN(COLUMNS(* REPLACE (i+j AS i))) FROM integers +-- +ok +== +SELECT COLUMNS(*) + 1 FROM integers +-- +ok +== +SELECT COLUMNS(*) + COLUMNS(*) FROM integers +-- +ok +== +CREATE TABLE grouped_table AS SELECT 1 id, 42 index1, 84 index2 UNION ALL SELECT 2, 13, 14 +-- +ok +== +SELECT COLUMNS('indxe.*') FROM grouped_table +-- +ok +== +SELECT id, MIN(COLUMNS('index[0-9]')) FROM grouped_table GROUP BY all ORDER BY ALL +-- +ok +== +SELECT id, MIN(COLUMNS('[0-9]')) FROM grouped_table GROUP BY all ORDER BY ALL +-- +ok +== +SELECT id, MIN(COLUMNS('xxx')) FROM grouped_table GROUP BY all +-- +ok +== +SELECT MIN(COLUMNS('xxx')) FROM grouped_table +-- +ok +== +SELECT MIN(COLUMNS('[asdadd')) FROM grouped_table +-- +ok +== +SELECT COLUMNS(*) + COLUMNS(* EXCLUDE(j)) FROM integers +-- +ok +== +SELECT (SELECT COLUMNS(*)) FROM integers +-- +ok +== +SELECT columns(['a', null]) FROM values (42) t(a); +-- +ok +== +SELECT * FROM grouped_table ORDER BY COLUMNS('index[0-9]'); +-- +ok +== +SELECT * FROM grouped_table ORDER BY COLUMNS(*); +-- +ok +== diff --git a/parser/testdata/corpus/sql/parser/test_columns_lists.test b/parser/testdata/corpus/sql/parser/test_columns_lists.test new file mode 100644 index 0000000..e9659cc --- /dev/null +++ b/parser/testdata/corpus/sql/parser/test_columns_lists.test @@ -0,0 +1,97 @@ +# source: test/sql/parser/test_columns_lists.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +SELECT COLUMNS([x for x in *]) FROM integers +-- +ok +== +SELECT COLUMNS([x for x in (*) if x <> 'i']) FROM integers +-- +ok +== +SELECT COLUMNS(lambda x: x <> 'i') FROM integers +-- +ok +== +SELECT COLUMNS([x for x in (*) if x SIMILAR TO 'i']) FROM integers +-- +ok +== +SELECT COLUMNS(['i', 'i']) FROM integers +-- +ok +== +SELECT COLUMNS(list_concat(['i'], ['i'])) FROM integers +-- +ok +== +SELECT COLUMNS([x for x in (* EXCLUDE (i))]) FROM integers +-- +ok +== +SELECT COLUMNS(['i']) + COLUMNS(['i']) FROM integers +-- +ok +== +SELECT COLUMNS([i, j]) FROM integers +-- +ok +== +SELECT COLUMNS([x for x in COLUMNS(*)]) FROM integers +-- +ok +== +SELECT COLUMNS(COLUMNS(*)) FROM integers +-- +ok +== +SELECT * + 42 FROM integers +-- +ok +== +SELECT COLUMNS([x for x in (*) if x = 'k']) FROM integers +-- +ok +== +SELECT COLUMNS(['k']) FROM integers +-- +ok +== +SELECT COLUMNS([x for x in (*) if x LIKE 'i']) FROM integers i1 JOIN integers i2 USING (i) +-- +ok +== +SELECT COLUMNS([x for x in (*) if x LIKE 'i']) FROM integers i1 JOIN integers i2 ON (i1.i=i2.i) +-- +ok +== +SELECT COLUMNS([43]) FROM integers +-- +ok +== +SELECT COLUMNS([NULL]) FROM integers +-- +ok +== +SELECT COLUMNS([]::VARCHAR[]) FROM integers +-- +ok +== +SELECT COLUMNS(NULL::VARCHAR[]) FROM integers +-- +ok +== +SELECT COLUMNS(NULL::VARCHAR) FROM integers +-- +ok +== +SELECT COLUMNS(['i']) + COLUMNS(['j']) FROM integers +-- +ok +== +SELECT COLUMNS([x for x in (* REPLACE (i AS i))]) FROM integers +-- +ok +== diff --git a/parser/testdata/corpus/sql/parser/test_columns_order.test b/parser/testdata/corpus/sql/parser/test_columns_order.test new file mode 100644 index 0000000..440402b --- /dev/null +++ b/parser/testdata/corpus/sql/parser/test_columns_order.test @@ -0,0 +1,41 @@ +# source: test/sql/parser/test_columns_order.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +CREATE TABLE tbl(col1 INTEGER, col2 INTEGER, col3 INTEGER); +-- +ok +== +INSERT INTO tbl VALUES (1, 200, 10), (2, 100, 20), (3, 200, 0) +-- +ok +== +SELECT * FROM tbl ORDER BY COLUMNS('col1|col3') +-- +ok +== +SELECT * FROM tbl ORDER BY COLUMNS('col2|col3') +-- +ok +== +SELECT * FROM tbl ORDER BY COLUMNS('col2|col3') DESC +-- +ok +== +SELECT * FROM tbl ORDER BY COLUMNS('col2') DESC, COLUMNS('col3') ASC +-- +ok +== +SELECT * FROM tbl ORDER BY COLUMNS(lambda x: x[-1] IN ('2', '3')) +-- +ok +== +FROM tbl UNION FROM tbl ORDER BY COLUMNS('col2|col3') DESC +-- +ok +== +SELECT * FROM tbl ORDER BY COLUMNS('xxxx') +-- +ok +== diff --git a/parser/testdata/corpus/sql/parser/test_columns_prepared.test b/parser/testdata/corpus/sql/parser/test_columns_prepared.test new file mode 100644 index 0000000..2c88f6d --- /dev/null +++ b/parser/testdata/corpus/sql/parser/test_columns_prepared.test @@ -0,0 +1,37 @@ +# source: test/sql/parser/test_columns_prepared.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +create or replace table my_table as +select 'test1' as column1, 1 as column2, 'quack' as column3 +union all +select 'test2' as column1, 2 as column2, 'quacks' as column3 +union all +select 'test3' as column1, 3 as column2, 'quacking' as column3 +-- +ok +== +prepare v1 as +select + COLUMNS(?) +from my_table +-- +ok +== +EXECUTE v1('col.*1') +-- +ok +== +EXECUTE v1('col.*2') +-- +ok +== +EXECUTE v1('col.*3') +-- +ok +== +EXECUTE v1(['column1', 'column2']) +-- +ok +== diff --git a/parser/testdata/corpus/sql/parser/test_columns_unpacked.test b/parser/testdata/corpus/sql/parser/test_columns_unpacked.test new file mode 100644 index 0000000..8fd3d8c --- /dev/null +++ b/parser/testdata/corpus/sql/parser/test_columns_unpacked.test @@ -0,0 +1,218 @@ +# source: test/sql/parser/test_columns_unpacked.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +select COALESCE(*COLUMNS(*)) from (select NULL, 2, 3) t(a, b, c); +-- +ok +== +select column_name from (describe select COALESCE(*COLUMNS(*)) from (select NULL, 2, 3) t(a, b, c)); +-- +ok +== +select column_name from (describe select COALESCE(*COLUMNS(*)) as a from (select NULL, 2, 3) t(a, b, c)); +-- +ok +== +create table contains_test as select '123abc234' a, 4 b, 'abc' c; +-- +ok +== +select contains(*COLUMNS('[a|c]')) from contains_test; +-- +ok +== +select COLUMNS('[a|c]') from contains_test; +-- +ok +== +select *COLUMNS('[a|c]') from contains_test; +-- +ok +== +create table sales as from ( values + (150, '2017/06/12'::DATE, 3), + (125, '2017/08/29'::DATE, 2), + (175, '2017/06/12'::DATE, 4), +) t(amount, date, priority) +-- +ok +== +SELECT first(amount ORDER BY date ASC, priority DESC) FROM sales; +-- +ok +== +select first(amount ORDER BY *COLUMNS('date|priority') ASC) from sales; +-- +ok +== +select COALESCE(*COLUMNS(lambda c: c in ('a', 'c'))) from (select NULL, 2, 3) t(a, b, c); +-- +ok +== +select 2 in (*COLUMNS(*)) from (select 1, 2, 3) t(a, b, c); +-- +ok +== +from (VALUES (1, 2, 3), (2, 3, 0), (0, 0, 1)) tbl(a, b, c) where 1 IN (*COLUMNS(*)); +-- +ok +== +create table data AS ( + SELECT * FROM (VALUES + (1, 'Alice'), + (2, 'Bob'), + (3, 'Alice'), + (4, 'Carol') + ) AS t(id, name) +) +-- +ok +== +select struct_pack(*COLUMNS(*)) from data +-- +ok +== +SELECT COLUMNS(*COLUMNS(*)) FROM (VALUES ('test')) +-- +ok +== +SELECT *COLUMNS(COLUMNS(*)) FROM (VALUES ('test')) +-- +ok +== +select COLUMNS(*), struct_pack(COLUMNS(['id'])) from data +-- +ok +== +select struct_pack(struct_pack(*COLUMNS(['id']), struct_pack(*COLUMNS(['name'])))) from data +-- +ok +== +select struct_pack( + b := struct_pack(*COLUMNS(['id'])), + a := struct_pack(*COLUMNS(['id'])) +) from data +-- +ok +== +select struct_pack(*COLUMNS('id')) a, struct_pack(*COLUMNS('name')) from data +-- +ok +== +select CONCAT(*COLUMNS(*), *COLUMNS(*)) from data +-- +ok +== +select COLUMNS(lambda col: *COLUMNS('id')) from data +-- +ok +== +select *COLUMNS(lambda col: *COLUMNS(*)) from data +-- +ok +== +with integers as ( + SELECT * FROM (VALUES + (42, 31), + (85, 76), + ) as t(a, b) +) +select *COLUMNS(*) + 42 from integers +-- +ok +== +with integers as ( + SELECT * FROM (VALUES + (42, 31), + (85, 76), + ) as t(a, b) +) +select *COLUMNS('a') + 42 from integers +-- +ok +== +with integers as ( + select * FROM (VALUES + (21, 42), + (1337, 7331) + ) as t(a, b) +) +select [(UNPACK(a + COLUMNS(['a', 'b'])))] from integers +-- +ok +== +select + [ + UNPACK([ + UNPACK(COLUMNS(*)), + a + b + ]) + ] +from ( + select 42 a, 21 b +) +-- +ok +== +select + [UNPACK(COLUMNS(*)::VARCHAR)] +from ( + select + 21::INTEGER a, + True::BOOL b, + 0.1234::DOUBLE c +) +-- +ok +== +select + [ + UNPACK( + [ + COLUMNS(['a', 'b']), + COLUMNS(['c']) + ] + ) + ] +from (select 21 a, 42 b, 1337 c) +-- +ok +== +select + [ + UNPACK( + [ + 'test' + ] + ) + ] +from (select 21 a, 42 b, 1337 c) +-- +ok +== +select + [ + UNPACK( + [ + COLUMNS([]::VARCHAR[]) + ] + ) + ] +from (select 21 a, 42 b, 1337 c) +-- +ok +== +select + [ + UNPACK( + [ + COLUMNS(['d']) + ] + ) + ] +from (select 21 a, 42 b, 1337 c) +-- +ok +== diff --git a/parser/testdata/corpus/sql/parser/test_columns_where.test b/parser/testdata/corpus/sql/parser/test_columns_where.test new file mode 100644 index 0000000..40d45fc --- /dev/null +++ b/parser/testdata/corpus/sql/parser/test_columns_where.test @@ -0,0 +1,37 @@ +# source: test/sql/parser/test_columns_where.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +SELECT * FROM tbl WHERE COLUMNS(*) >= 2 ORDER BY ALL +-- +ok +== +SELECT * FROM tbl WHERE COLUMNS(['col1', 'col2']) >= 2 ORDER BY ALL +-- +ok +== +SELECT * FROM tbl WHERE COLUMNS(['col1', 'col2']) >= 2 AND COLUMNS(*) IS NOT NULL ORDER BY ALL +-- +ok +== +SELECT * FROM tbl WHERE COLUMNS(['col1', 'col2']) >= 2 AND COLUMNS(['col1', 'col3']) < 10 ORDER BY ALL +-- +ok +== +SELECT * FROM tbl WHERE COLUMNS(['nonexistent']) >= 2 ORDER BY ALL +-- +ok +== +SELECT * FROM tbl WHERE COLUMNS(* EXCLUDE (col1, col2, col3)) >= 2 ORDER BY ALL +-- +ok +== +SELECT * FROM tbl WHERE * ORDER BY ALL +-- +ok +== +SELECT * FROM tbl WHERE * >= 2 ORDER BY ALL +-- +ok +== diff --git a/parser/testdata/corpus/sql/parser/test_long_error.test b/parser/testdata/corpus/sql/parser/test_long_error.test new file mode 100644 index 0000000..d4c7980 --- /dev/null +++ b/parser/testdata/corpus/sql/parser/test_long_error.test @@ -0,0 +1,13 @@ +# source: test/sql/parser/test_long_error.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx +-- +ok +== +SELECT xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx +-- +ok +== diff --git a/parser/testdata/corpus/sql/parser/test_operator_precedence.test b/parser/testdata/corpus/sql/parser/test_operator_precedence.test new file mode 100644 index 0000000..1bce883 --- /dev/null +++ b/parser/testdata/corpus/sql/parser/test_operator_precedence.test @@ -0,0 +1,57 @@ +# source: test/sql/parser/test_operator_precedence.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +SELECT 2*3+1 +-- +ok +== +SELECT 1+2*3 +-- +ok +== +SELECT 2^2 + 1; +-- +ok +== +SELECT 2**2 + 1; +-- +ok +== +SELECT 1+2**2; +-- +ok +== +SELECT 1+2^2; +-- +ok +== +SELECT 2**4 / 2; +-- +ok +== +SELECT 2**(4 / 2); +-- +ok +== +SELECT 16/2**4; +-- +ok +== +SELECT (16/2)**4; +-- +ok +== +SELECT 2**3**2; +-- +ok +== +SELECT 2^3**2; +-- +ok +== +SELECT 2**3^2; +-- +ok +== diff --git a/parser/testdata/corpus/sql/parser/test_value_functions.test b/parser/testdata/corpus/sql/parser/test_value_functions.test new file mode 100644 index 0000000..9a1d2b7 --- /dev/null +++ b/parser/testdata/corpus/sql/parser/test_value_functions.test @@ -0,0 +1,49 @@ +# source: test/sql/parser/test_value_functions.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +SELECT user FROM (VALUES ('hello world')) t(user) +-- +ok +== +SELECT user +-- +ok +== +SELECT UsEr +-- +ok +== +SELECT user FROM (VALUES (42)) user(x) +-- +ok +== +SELECT {value_function} +-- +error: Parser Error: syntax error at or near "}" +== +SELECT useRrr +-- +ok +== +select + 1 as one, + max(cast('1000-05-01 00:00:00' as timestamp)) as mt +group by one +having max(cast('1000-05-01 00:00:00' as timestamp)) <= current_timestamp; +-- +ok +== +select a as "b", "b" + 1 from (VALUES (84), (42)) t(a) ORDER BY ALL; +-- +ok +== +select a as "CURRENT_TIMESTAMP" from (VALUES (84), (42)) t(a) order by "CURRENT_TIMESTAMP" + 1; +-- +ok +== +select a as localtime from (VALUES ('2018-01-01'), ('2022-01-01')) t(a) where localtime >= '2020-01-01' +-- +ok +== diff --git a/parser/testdata/corpus/sql/parser/trailing_commas.test b/parser/testdata/corpus/sql/parser/trailing_commas.test new file mode 100644 index 0000000..aa2a88e --- /dev/null +++ b/parser/testdata/corpus/sql/parser/trailing_commas.test @@ -0,0 +1,67 @@ +# source: test/sql/parser/trailing_commas.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +SELECT 42, +-- +ok +== +SELECT 42, + 84, +-- +ok +== +SELECT DISTINCT 42, + 84, +-- +ok +== +VALUES (42,) +-- +ok +== +VALUES (42,), +-- +ok +== +SELECT * FROM (VALUES (42,)) +-- +ok +== +CREATE TABLE integers(i INTEGER, j INTEGER,); +-- +ok +== +INSERT INTO integers VALUES (42, 84,),; +-- +ok +== +SELECT * FROM integers, +-- +ok +== +SELECT i, SUM(j) FROM integers GROUP BY i, +-- +ok +== +UPDATE integers SET i=100, +-- +ok +== +SELECT i FROM integers +-- +ok +== +SELECT [1,] +-- +ok +== +SELECT ARRAY[1,] +-- +ok +== +SELECT {'a': 42, 'b': 84,} +-- +ok +== diff --git a/parser/testdata/corpus/sql/parser/unreserved_keyword_casing.test b/parser/testdata/corpus/sql/parser/unreserved_keyword_casing.test new file mode 100644 index 0000000..cabc06e --- /dev/null +++ b/parser/testdata/corpus/sql/parser/unreserved_keyword_casing.test @@ -0,0 +1,13 @@ +# source: test/sql/parser/unreserved_keyword_casing.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +CREATE TABLE people(Name VARCHAR, STATE VARCHAR, Country VARCHAR); +-- +ok +== +DESCRIBE people +-- +ok +== diff --git a/parser/testdata/corpus/sql/parser/values_list_error.test b/parser/testdata/corpus/sql/parser/values_list_error.test new file mode 100644 index 0000000..efdb9ab --- /dev/null +++ b/parser/testdata/corpus/sql/parser/values_list_error.test @@ -0,0 +1,13 @@ +# source: test/sql/parser/values_list_error.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +FROM (VALUES ('1', '2'), ('1')) +-- +error: Parser Error: VALUES lists must all be the same length, expected 2 entries but found a list with 1 entry +== +FROM (VALUES ('1'), ('1', '2')) +-- +error: Parser Error: VALUES lists must all be the same length, expected 1 entry but found a list with 2 entries +== diff --git a/parser/testdata/corpus/sql/parser/values_list_error.test.metadata.json b/parser/testdata/corpus/sql/parser/values_list_error.test.metadata.json new file mode 100644 index 0000000..af09779 --- /dev/null +++ b/parser/testdata/corpus/sql/parser/values_list_error.test.metadata.json @@ -0,0 +1,6 @@ +{ + "todo": { + "157130d4fe4932fa": "transformer-raised parser error: upstream rejects in the transformer, not the grammar; expected to clear as transformers land (milestones 3-5)", + "ee5cf0bf5f0b1b24": "transformer-raised parser error: upstream rejects in the transformer, not the grammar; expected to clear as transformers land (milestones 3-5)" + } +} diff --git a/parser/testdata/corpus/sql/parser/values_list_without_brackets.test b/parser/testdata/corpus/sql/parser/values_list_without_brackets.test new file mode 100644 index 0000000..cb85d23 --- /dev/null +++ b/parser/testdata/corpus/sql/parser/values_list_without_brackets.test @@ -0,0 +1,13 @@ +# source: test/sql/parser/values_list_without_brackets.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +SELECT * FROM values (42) t; +-- +ok +== +SELECT * FROM values (42) t, values (84) x; +-- +ok +== diff --git a/parser/testdata/corpus/sql/peg_parser/binary_type.test b/parser/testdata/corpus/sql/peg_parser/binary_type.test new file mode 100644 index 0000000..aaefb16 --- /dev/null +++ b/parser/testdata/corpus/sql/peg_parser/binary_type.test @@ -0,0 +1,17 @@ +# source: test/sql/peg_parser/binary_type.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +CREATE TABLE t(b binary, c blob, d varbinary); +-- +ok +== +INSERT INTO t VALUES (NULL, NULL, NULL); +-- +ok +== +SELECT typeof(b), typeof(c), typeof(d) FROM t; +-- +ok +== diff --git a/parser/testdata/corpus/sql/peg_parser/enable_peg_parser.test b/parser/testdata/corpus/sql/peg_parser/enable_peg_parser.test new file mode 100644 index 0000000..aef8193 --- /dev/null +++ b/parser/testdata/corpus/sql/peg_parser/enable_peg_parser.test @@ -0,0 +1,13 @@ +# source: test/sql/peg_parser/enable_peg_parser.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +select xvariable a = 1; +-- +error: Parser Error: syntax error at or near "=" +== +SELECT * FROM values(1); +-- +ok +== diff --git a/parser/testdata/corpus/sql/peg_parser/escape_string.test b/parser/testdata/corpus/sql/peg_parser/escape_string.test new file mode 100644 index 0000000..bc94ab7 --- /dev/null +++ b/parser/testdata/corpus/sql/peg_parser/escape_string.test @@ -0,0 +1,73 @@ +# source: test/sql/peg_parser/escape_string.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +SELECT E'it\'s a test' = 'it''s a test'; +-- +ok +== +SELECT e'it\'s a test' = 'it''s a test'; +-- +ok +== +SELECT E'a\'b\'c' = 'a''b''c'; +-- +ok +== +SELECT E'\\' = '\'; +-- +ok +== +SELECT E'\\\\' = '\\'; +-- +ok +== +SELECT e'\033' = chr(27); +-- +ok +== +SELECT e'\7' = chr(7); +-- +ok +== +SELECT e'\xFF' = chr(255); +-- +error: Parser Error: Invalid UTF-8 in escape string literal at byte offset 0: byte mismatch +== +SELECT e'\x41' = 'A'; +-- +ok +== +SELECT e'\101' = 'A'; +-- +ok +== +SELECT e'\x' = 'x'; +-- +ok +== +SELECT e'\b' = chr(8); +-- +ok +== +SELECT e'\f' = chr(12); +-- +ok +== +SELECT e'\n' = chr(10); +-- +ok +== +SELECT e'\1012' = 'A2'; +-- +ok +== +SELECT e'\400'; +-- +error: Parser Error: Null character not permitted in escape string literal +== +SELECT e'\000'; +-- +error: Parser Error: Null character not permitted in escape string literal +== diff --git a/parser/testdata/corpus/sql/peg_parser/escape_string.test.metadata.json b/parser/testdata/corpus/sql/peg_parser/escape_string.test.metadata.json new file mode 100644 index 0000000..c801d30 --- /dev/null +++ b/parser/testdata/corpus/sql/peg_parser/escape_string.test.metadata.json @@ -0,0 +1,7 @@ +{ + "todo": { + "1c8886b392c0c04a": "transformer-raised parser error: upstream rejects in the transformer, not the grammar; expected to clear as transformers land (milestones 3-5)", + "7cfabb58230d67f1": "transformer-raised parser error: upstream rejects in the transformer, not the grammar; expected to clear as transformers land (milestones 3-5)", + "e843a7b940b10b01": "transformer-raised parser error: upstream rejects in the transformer, not the grammar; expected to clear as transformers land (milestones 3-5)" + } +} diff --git a/parser/testdata/corpus/sql/peg_parser/expression_statement.test b/parser/testdata/corpus/sql/peg_parser/expression_statement.test new file mode 100644 index 0000000..5c6b6a4 --- /dev/null +++ b/parser/testdata/corpus/sql/peg_parser/expression_statement.test @@ -0,0 +1,49 @@ +# source: test/sql/peg_parser/expression_statement.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +1 + 1; +-- +ok +== +[1,2,3][1]; +-- +ok +== +CREATE TABLE foo (i integer); +-- +ok +== +INSERT INTO foo values (1), (2), (3); +-- +ok +== +foo; +-- +ok +== +('hello world').replace(' ', '_'); +-- +ok +== +bar: 1 + 1 +-- +ok +== +foo: 1 + 1, bar: ('hello world').replace(' ', '_'), [1,2,3][1] as list_element; +-- +ok +== +1 + 1 foo +-- +error: Parser Error: syntax error at or near "foo" +== +selec 42 +-- +error: Parser Error: syntax error at or near "42" +== +SEL +-- +ok +== diff --git a/parser/testdata/corpus/sql/peg_parser/fuzzer/diverge_0000.test b/parser/testdata/corpus/sql/peg_parser/fuzzer/diverge_0000.test new file mode 100644 index 0000000..efa872e --- /dev/null +++ b/parser/testdata/corpus/sql/peg_parser/fuzzer/diverge_0000.test @@ -0,0 +1,9 @@ +# source: test/sql/peg_parser/fuzzer/diverge_0000.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +DETACH IF EXISTS my_table; +-- +ok +== diff --git a/parser/testdata/corpus/sql/peg_parser/fuzzer/diverge_0002.test b/parser/testdata/corpus/sql/peg_parser/fuzzer/diverge_0002.test new file mode 100644 index 0000000..9b16432 --- /dev/null +++ b/parser/testdata/corpus/sql/peg_parser/fuzzer/diverge_0002.test @@ -0,0 +1,9 @@ +# source: test/sql/peg_parser/fuzzer/diverge_0002.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +ANALYZE VERBOSE +-- +ok +== diff --git a/parser/testdata/corpus/sql/peg_parser/fuzzer/diverge_0004.test b/parser/testdata/corpus/sql/peg_parser/fuzzer/diverge_0004.test new file mode 100644 index 0000000..3a67b49 --- /dev/null +++ b/parser/testdata/corpus/sql/peg_parser/fuzzer/diverge_0004.test @@ -0,0 +1,9 @@ +# source: test/sql/peg_parser/fuzzer/diverge_0004.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +DROP MATERIALIZED VIEW IF EXISTS t +-- +ok +== diff --git a/parser/testdata/corpus/sql/peg_parser/fuzzer/diverge_0007.test b/parser/testdata/corpus/sql/peg_parser/fuzzer/diverge_0007.test new file mode 100644 index 0000000..a2e1cf9 --- /dev/null +++ b/parser/testdata/corpus/sql/peg_parser/fuzzer/diverge_0007.test @@ -0,0 +1,13 @@ +# source: test/sql/peg_parser/fuzzer/diverge_0007.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +EXPLAIN ( entry ) RESET SESSION item +-- +ok +== +EXPLAIN ( t , s , t ) LOAD XMLCONCAT +-- +ok +== diff --git a/parser/testdata/corpus/sql/peg_parser/fuzzer/diverge_0009.test b/parser/testdata/corpus/sql/peg_parser/fuzzer/diverge_0009.test new file mode 100644 index 0000000..27b646c --- /dev/null +++ b/parser/testdata/corpus/sql/peg_parser/fuzzer/diverge_0009.test @@ -0,0 +1,9 @@ +# source: test/sql/peg_parser/fuzzer/diverge_0009.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +CREATE OR REPLACE SEQUENCE t1 NO MINVALUE +-- +ok +== diff --git a/parser/testdata/corpus/sql/peg_parser/fuzzer/diverge_0014.test b/parser/testdata/corpus/sql/peg_parser/fuzzer/diverge_0014.test new file mode 100644 index 0000000..ca6dad3 --- /dev/null +++ b/parser/testdata/corpus/sql/peg_parser/fuzzer/diverge_0014.test @@ -0,0 +1,13 @@ +# source: test/sql/peg_parser/fuzzer/diverge_0014.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +EXPLAIN RESET LOCAL result +-- +ok +== +RESET LOCAL allowed_paths +-- +ok +== diff --git a/parser/testdata/corpus/sql/peg_parser/fuzzer/diverge_0020.test b/parser/testdata/corpus/sql/peg_parser/fuzzer/diverge_0020.test new file mode 100644 index 0000000..7fe6fec --- /dev/null +++ b/parser/testdata/corpus/sql/peg_parser/fuzzer/diverge_0020.test @@ -0,0 +1,9 @@ +# source: test/sql/peg_parser/fuzzer/diverge_0020.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +PREPARE y AS DEALLOCATE PREPARE result +-- +error: Parser Error: DROP_STATEMENT is not a preparable statement +== diff --git a/parser/testdata/corpus/sql/peg_parser/fuzzer/diverge_0020.test.metadata.json b/parser/testdata/corpus/sql/peg_parser/fuzzer/diverge_0020.test.metadata.json new file mode 100644 index 0000000..71c6de9 --- /dev/null +++ b/parser/testdata/corpus/sql/peg_parser/fuzzer/diverge_0020.test.metadata.json @@ -0,0 +1,5 @@ +{ + "todo": { + "c860d45d17d642d6": "transformer-raised parser error: upstream rejects in the transformer, not the grammar; expected to clear as transformers land (milestones 3-5)" + } +} diff --git a/parser/testdata/corpus/sql/peg_parser/fuzzer/diverge_0039.test b/parser/testdata/corpus/sql/peg_parser/fuzzer/diverge_0039.test new file mode 100644 index 0000000..e98850b --- /dev/null +++ b/parser/testdata/corpus/sql/peg_parser/fuzzer/diverge_0039.test @@ -0,0 +1,17 @@ +# source: test/sql/peg_parser/fuzzer/diverge_0039.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +create table t(i bigint); +-- +ok +== +insert into t values (1), (2), (3); +-- +ok +== +( TABLE t ) LIMIT ALL +-- +ok +== diff --git a/parser/testdata/corpus/sql/peg_parser/fuzzer/diverge_0060.test b/parser/testdata/corpus/sql/peg_parser/fuzzer/diverge_0060.test new file mode 100644 index 0000000..ac5c5fc --- /dev/null +++ b/parser/testdata/corpus/sql/peg_parser/fuzzer/diverge_0060.test @@ -0,0 +1,13 @@ +# source: test/sql/peg_parser/fuzzer/diverge_0060.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +create table t(i bigint);create table t1(i bigint); +-- +ok +== +WITH RECURSIVE entry ( my_table ) AS ( TABLE t ORDER BY '0x41' NULLS FIRST ) DELETE FROM t1 RETURNING 'k9o' +-- +ok +== diff --git a/parser/testdata/corpus/sql/peg_parser/fuzzer/fuzzer_4434.test b/parser/testdata/corpus/sql/peg_parser/fuzzer/fuzzer_4434.test new file mode 100644 index 0000000..ce83d8d --- /dev/null +++ b/parser/testdata/corpus/sql/peg_parser/fuzzer/fuzzer_4434.test @@ -0,0 +1,14 @@ +# source: test/sql/peg_parser/fuzzer/fuzzer_4434.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +n''''+ST�&6>ttacrotablesampimportleT�&6>tta�rordeT�Niqeger[], e�tfilter% + t_not_currorderent; +-- +error: Parser Error: Empty subscript '[]' is not allowed +== +[1,2,3][]; +-- +error: Parser Error: Empty subscript '[]' is not allowed +== diff --git a/parser/testdata/corpus/sql/peg_parser/fuzzer/fuzzer_4434.test.metadata.json b/parser/testdata/corpus/sql/peg_parser/fuzzer/fuzzer_4434.test.metadata.json new file mode 100644 index 0000000..d5faca8 --- /dev/null +++ b/parser/testdata/corpus/sql/peg_parser/fuzzer/fuzzer_4434.test.metadata.json @@ -0,0 +1,6 @@ +{ + "todo": { + "1a023700c33c60cc": "transformer-raised parser error: upstream rejects in the transformer, not the grammar; expected to clear as transformers land (milestones 3-5)", + "cf66331a950ed4cd": "transformer-raised parser error: upstream rejects in the transformer, not the grammar; expected to clear as transformers land (milestones 3-5)" + } +} diff --git a/parser/testdata/corpus/sql/peg_parser/fuzzer/internal_0001.test b/parser/testdata/corpus/sql/peg_parser/fuzzer/internal_0001.test new file mode 100644 index 0000000..c0449ae --- /dev/null +++ b/parser/testdata/corpus/sql/peg_parser/fuzzer/internal_0001.test @@ -0,0 +1,9 @@ +# source: test/sql/peg_parser/fuzzer/internal_0001.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +CREATE SECRET ( x '\r' ); +-- +error: Parser Error: Failed to create secret - secret must have a type defined +== diff --git a/parser/testdata/corpus/sql/peg_parser/fuzzer/internal_0001.test.metadata.json b/parser/testdata/corpus/sql/peg_parser/fuzzer/internal_0001.test.metadata.json new file mode 100644 index 0000000..61ad85a --- /dev/null +++ b/parser/testdata/corpus/sql/peg_parser/fuzzer/internal_0001.test.metadata.json @@ -0,0 +1,5 @@ +{ + "todo": { + "865fff04e40c569e": "transformer-raised parser error: upstream rejects in the transformer, not the grammar; expected to clear as transformers land (milestones 3-5)" + } +} diff --git a/parser/testdata/corpus/sql/peg_parser/fuzzer/internal_0206.test b/parser/testdata/corpus/sql/peg_parser/fuzzer/internal_0206.test new file mode 100644 index 0000000..d31a527 --- /dev/null +++ b/parser/testdata/corpus/sql/peg_parser/fuzzer/internal_0206.test @@ -0,0 +1,9 @@ +# source: test/sql/peg_parser/fuzzer/internal_0206.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +DROP COLLATION a +-- +ok +== diff --git a/parser/testdata/corpus/sql/peg_parser/fuzzer/internal_0208.test b/parser/testdata/corpus/sql/peg_parser/fuzzer/internal_0208.test new file mode 100644 index 0000000..445f52e --- /dev/null +++ b/parser/testdata/corpus/sql/peg_parser/fuzzer/internal_0208.test @@ -0,0 +1,9 @@ +# source: test/sql/peg_parser/fuzzer/internal_0208.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +INSTALL 'CWQqtzCCq9' FROM ''''' 'bj7OGvEqL' +-- +error: Parser Error: unterminated string literal +== diff --git a/parser/testdata/corpus/sql/peg_parser/fuzzer/internal_0227.test b/parser/testdata/corpus/sql/peg_parser/fuzzer/internal_0227.test new file mode 100644 index 0000000..c94f576 --- /dev/null +++ b/parser/testdata/corpus/sql/peg_parser/fuzzer/internal_0227.test @@ -0,0 +1,25 @@ +# source: test/sql/peg_parser/fuzzer/internal_0227.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +create table mytbl(i bigint); +-- +ok +== +ALTER TABLE mytbl ADD IF NOT EXISTS result . v bigint; +-- +ok +== +ALTER TABLE mytbl ADD result . v bigint; +-- +ok +== +ALTER TABLE mytbl ADD result . v; +-- +error: Parser Error: Column definition requires a type or generated expression +== +ALTER TABLE mytbl ADD IF NOT EXISTS result . v; +-- +error: Parser Error: Column definition requires a type or generated expression +== diff --git a/parser/testdata/corpus/sql/peg_parser/fuzzer/internal_0227.test.metadata.json b/parser/testdata/corpus/sql/peg_parser/fuzzer/internal_0227.test.metadata.json new file mode 100644 index 0000000..533a027 --- /dev/null +++ b/parser/testdata/corpus/sql/peg_parser/fuzzer/internal_0227.test.metadata.json @@ -0,0 +1,6 @@ +{ + "todo": { + "308c39e6a7c3410e": "transformer-raised parser error: upstream rejects in the transformer, not the grammar; expected to clear as transformers land (milestones 3-5)", + "ce8bdf52f82ed226": "transformer-raised parser error: upstream rejects in the transformer, not the grammar; expected to clear as transformers land (milestones 3-5)" + } +} diff --git a/parser/testdata/corpus/sql/peg_parser/identifier.test b/parser/testdata/corpus/sql/peg_parser/identifier.test new file mode 100644 index 0000000..3b889fb --- /dev/null +++ b/parser/testdata/corpus/sql/peg_parser/identifier.test @@ -0,0 +1,57 @@ +# source: test/sql/peg_parser/identifier.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +SELECT 1 a; +-- +ok +== +SELECT 1 A1; +-- +ok +== +SELECT 1 _abc; +-- +ok +== +SELECT 1 _; +-- +ok +== +SELECT 1 a1; +-- +ok +== +SELECT 1 a_1; +-- +ok +== +SELECT 1 a_b; +-- +ok +== +SELECT 1 abc123; +-- +ok +== +SELECT 1 a$c; +-- +ok +== +SELECT 1 a$1; +-- +ok +== +SELECT 1 1abc; +-- +error: Parser Error: syntax error at or near "1" +== +SELECT 1 123; +-- +error: Parser Error: syntax error at or near "123" +== +SELECT 1 $col; +-- +error: Parser Error: syntax error at or near "$" +== diff --git a/parser/testdata/corpus/sql/peg_parser/parser/alter.test b/parser/testdata/corpus/sql/peg_parser/parser/alter.test new file mode 100644 index 0000000..109ef97 --- /dev/null +++ b/parser/testdata/corpus/sql/peg_parser/parser/alter.test @@ -0,0 +1,9 @@ +# source: test/sql/peg_parser/parser/alter.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +CALL check_peg_parser($TEST_PEG_PARSER$ALTER TABLE tbl SET SORTED BY (i DESC NULLS FIRST)$TEST_PEG_PARSER$); +-- +ok +== diff --git a/parser/testdata/corpus/sql/peg_parser/parser/analyze_vacuum.test b/parser/testdata/corpus/sql/peg_parser/parser/analyze_vacuum.test new file mode 100644 index 0000000..8df14e5 --- /dev/null +++ b/parser/testdata/corpus/sql/peg_parser/parser/analyze_vacuum.test @@ -0,0 +1,25 @@ +# source: test/sql/peg_parser/parser/analyze_vacuum.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +CALL check_peg_parser($TEST_PEG_PARSER$ANALYZE;$TEST_PEG_PARSER$); +-- +ok +== +CALL check_peg_parser($TEST_PEG_PARSER$ANALYZE test(x);$TEST_PEG_PARSER$); +-- +ok +== +CALL check_peg_parser($TEST_PEG_PARSER$VACUUM test(i);$TEST_PEG_PARSER$); +-- +ok +== +CALL check_peg_parser($TEST_PEG_PARSER$VACUUM;$TEST_PEG_PARSER$); +-- +ok +== +CALL check_peg_parser($TEST_PEG_PARSER$VACUUM db1.integers;$TEST_PEG_PARSER$); +-- +ok +== diff --git a/parser/testdata/corpus/sql/peg_parser/parser/array_subquery.test b/parser/testdata/corpus/sql/peg_parser/parser/array_subquery.test new file mode 100644 index 0000000..2f02799 --- /dev/null +++ b/parser/testdata/corpus/sql/peg_parser/parser/array_subquery.test @@ -0,0 +1,29 @@ +# source: test/sql/peg_parser/parser/array_subquery.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +CALL check_peg_parser($TEST_PEG_PARSER$SELECT i, ARRAY( SELECT 42 ) top FROM integers i1 ORDER BY i$TEST_PEG_PARSER$); +-- +ok +== +CALL check_peg_parser($TEST_PEG_PARSER$SELECT ARRAY[42]$TEST_PEG_PARSER$); +-- +ok +== +CALL check_peg_parser($TEST_PEG_PARSER$SELECT ARRAY(SELECT 42)$TEST_PEG_PARSER$); +-- +ok +== +CALL check_peg_parser($TEST_PEG_PARSER$SELECT ARRAY((SELECT 42))$TEST_PEG_PARSER$); +-- +ok +== +CALL check_peg_parser($TEST_PEG_PARSER$SELECT i, ARRAY( SELECT * FROM integers WHERE i>i1.i ORDER BY i ) top FROM integers i1 ORDER BY i$TEST_PEG_PARSER$); +-- +ok +== +CALL check_peg_parser($TEST_PEG_PARSER$select array(select distinct i from t order by i desc) as a, array(select distinct i from t order by i desc) as b, array(select distinct i from t order by i desc) as c;$TEST_PEG_PARSER$); +-- +ok +== diff --git a/parser/testdata/corpus/sql/peg_parser/parser/attach_or_replace.test b/parser/testdata/corpus/sql/peg_parser/parser/attach_or_replace.test new file mode 100644 index 0000000..d6bb826 --- /dev/null +++ b/parser/testdata/corpus/sql/peg_parser/parser/attach_or_replace.test @@ -0,0 +1,9 @@ +# source: test/sql/peg_parser/parser/attach_or_replace.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +CALL check_peg_parser($TEST_PEG_PARSER$ATTACH OR REPLACE '{TEST_DIR}/attach_or_replace.db' AS db1;$TEST_PEG_PARSER$); +-- +ok +== diff --git a/parser/testdata/corpus/sql/peg_parser/parser/collate.test b/parser/testdata/corpus/sql/peg_parser/parser/collate.test new file mode 100644 index 0000000..fe86668 --- /dev/null +++ b/parser/testdata/corpus/sql/peg_parser/parser/collate.test @@ -0,0 +1,9 @@ +# source: test/sql/peg_parser/parser/collate.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +CALL check_peg_parser($TEST_PEG_PARSER$select left(b collate de, 6) from tbl order by all;$TEST_PEG_PARSER$); +-- +ok +== diff --git a/parser/testdata/corpus/sql/peg_parser/parser/colon_alias.test b/parser/testdata/corpus/sql/peg_parser/parser/colon_alias.test new file mode 100644 index 0000000..d011b2f --- /dev/null +++ b/parser/testdata/corpus/sql/peg_parser/parser/colon_alias.test @@ -0,0 +1,21 @@ +# source: test/sql/peg_parser/parser/colon_alias.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +CALL check_peg_parser($TEST_PEG_PARSER$SELECT * FROM b : a$TEST_PEG_PARSER$); +-- +ok +== +CALL check_peg_parser($TEST_PEG_PARSER$SELECT * FROM foo: tablefunction()$TEST_PEG_PARSER$); +-- +ok +== +CALL check_peg_parser($TEST_PEG_PARSER$with cte1 as MATERIALIZED (Select i as j from a) select x from cte1 t1(x);$TEST_PEG_PARSER$); +-- +ok +== +CALL check_peg_parser($TEST_PEG_PARSER$from my_wonderful_values : (values(42))$TEST_PEG_PARSER$); +-- +ok +== diff --git a/parser/testdata/corpus/sql/peg_parser/parser/comments.test b/parser/testdata/corpus/sql/peg_parser/parser/comments.test new file mode 100644 index 0000000..2257520 --- /dev/null +++ b/parser/testdata/corpus/sql/peg_parser/parser/comments.test @@ -0,0 +1,26 @@ +# source: test/sql/peg_parser/parser/comments.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +SELECT 1 /* I /* love */ comments */ + 2; +-- +ok +== +SELECT 1 -- /* not a block */ rest ++ 2; +-- +ok +== +CALL check_peg_parser($TEST_PEG_PARSER$SELECT 1 /* outer /* inner */ rest */ + 2;$TEST_PEG_PARSER$); +-- +ok +== +CALL check_peg_parser($TEST_PEG_PARSER$SELECT 10 /* a /* b /* c */ b */ a */ + 5;$TEST_PEG_PARSER$); +-- +ok +== +CALL check_peg_parser($TEST_PEG_PARSER$SELECT 1/**//* second */+2;$TEST_PEG_PARSER$); +-- +ok +== diff --git a/parser/testdata/corpus/sql/peg_parser/parser/copy_expression.test b/parser/testdata/corpus/sql/peg_parser/parser/copy_expression.test new file mode 100644 index 0000000..29018db --- /dev/null +++ b/parser/testdata/corpus/sql/peg_parser/parser/copy_expression.test @@ -0,0 +1,37 @@ +# source: test/sql/peg_parser/parser/copy_expression.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +CALL check_peg_parser($TEST_PEG_PARSER$COPY (SELECT * FROM foo) TO ('foo') WITH (HEADER)$TEST_PEG_PARSER$); +-- +ok +== +CALL check_peg_parser($TEST_PEG_PARSER$COPY (SELECT * FROM range(5) t(i)) TO (getvariable('copy_target')) WITH (HEADER)$TEST_PEG_PARSER$); +-- +ok +== +CALL check_peg_parser($TEST_PEG_PARSER$COPY t TO 'x.parquet' (FORMAT parquet, PARTITION_BY (p1, p2), ORDER_BY (a ASC NULLS FIRST, b DESC NULLS LAST, c ASCENDING NULLS LAST, d DESCENDING NULLS FIRST, e NULLS FIRST))$TEST_PEG_PARSER$); +-- +ok +== +CALL check_peg_parser($TEST_PEG_PARSER$COPY t TO 'x.parquet' (FORMAT parquet, ORDER_BY (a DESC, b ASC))$TEST_PEG_PARSER$); +-- +ok +== +CALL check_peg_parser($TEST_PEG_PARSER$COPY t TO 'x.parquet' (FORMAT parquet, ORDER_BY (a, b))$TEST_PEG_PARSER$); +-- +ok +== +CALL check_peg_parser($TEST_PEG_PARSER$COPY t TO 'x.parquet' (FORMAT parquet, PARTITIONED BY (p1, p2), ORDER BY (a DESC, b ASC))$TEST_PEG_PARSER$); +-- +ok +== +CALL check_peg_parser($TEST_PEG_PARSER$COPY (SELECT 1 a) TO 'file.csv' PARTITION BY a, HEADER$TEST_PEG_PARSER$); +-- +ok +== +CALL check_peg_parser($TEST_PEG_PARSER$COPY (SELECT 1 a, 2 b, 3 c) TO 'file.csv' PARTITION BY (a, b), HEADER$TEST_PEG_PARSER$); +-- +ok +== diff --git a/parser/testdata/corpus/sql/peg_parser/parser/create_macro.test b/parser/testdata/corpus/sql/peg_parser/parser/create_macro.test new file mode 100644 index 0000000..7d33547 --- /dev/null +++ b/parser/testdata/corpus/sql/peg_parser/parser/create_macro.test @@ -0,0 +1,17 @@ +# source: test/sql/peg_parser/parser/create_macro.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +CALL check_peg_parser($TEST_PEG_PARSER$create macro my_range(x) as table from range(x);$TEST_PEG_PARSER$); +-- +ok +== +CALL check_peg_parser($TEST_PEG_PARSER$create macro m(s varchar) as s || 'c'$TEST_PEG_PARSER$); +-- +ok +== +CALL check_peg_parser($TEST_PEG_PARSER$create or replace macro m(s varchar := 'cc') as s || 'c'$TEST_PEG_PARSER$); +-- +ok +== diff --git a/parser/testdata/corpus/sql/peg_parser/parser/create_table.test b/parser/testdata/corpus/sql/peg_parser/parser/create_table.test new file mode 100644 index 0000000..650d6ac --- /dev/null +++ b/parser/testdata/corpus/sql/peg_parser/parser/create_table.test @@ -0,0 +1,33 @@ +# source: test/sql/peg_parser/parser/create_table.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +CALL check_peg_parser($TEST_PEG_PARSER$CREATE TABLE test (bar GENERATED ALWAYS AS (1));$TEST_PEG_PARSER$); +-- +ok +== +CALL check_peg_parser($TEST_PEG_PARSER$CREATE TABLE database.schema.table(col INTEGER);$TEST_PEG_PARSER$); +-- +ok +== +CALL check_peg_parser($TEST_PEG_PARSER$SELECT flags.desc;$TEST_PEG_PARSER$); +-- +ok +== +CALL check_peg_parser($TEST_PEG_PARSER$INSERT INTO database.schema.table VALUES ({'field': 42});$TEST_PEG_PARSER$); +-- +ok +== +CALL check_peg_parser($TEST_PEG_PARSER$CREATE TABLE tbl4(foo, bar) AS SELECT 1;$TEST_PEG_PARSER$); +-- +ok +== +CALL check_peg_parser($TEST_PEG_PARSER$CREATE TEMPORARY TABLE integers(i INTEGER) ON COMMIT PRESERVE ROWS;$TEST_PEG_PARSER$); +-- +ok +== +CALL check_peg_parser($TEST_PEG_PARSER$CREATE TABLE tbl8 AS SELECT 42 WITH NO DATA$TEST_PEG_PARSER$); +-- +ok +== diff --git a/parser/testdata/corpus/sql/peg_parser/parser/create_type.test b/parser/testdata/corpus/sql/peg_parser/parser/create_type.test new file mode 100644 index 0000000..5c76cd8 --- /dev/null +++ b/parser/testdata/corpus/sql/peg_parser/parser/create_type.test @@ -0,0 +1,9 @@ +# source: test/sql/peg_parser/parser/create_type.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +CALL check_peg_parser($TEST_PEG_PARSER$CREATE TYPE t4 AS UNION ( v0 SETOF t4 );$TEST_PEG_PARSER$); +-- +ok +== diff --git a/parser/testdata/corpus/sql/peg_parser/parser/custom_operator.test b/parser/testdata/corpus/sql/peg_parser/parser/custom_operator.test new file mode 100644 index 0000000..0732428 --- /dev/null +++ b/parser/testdata/corpus/sql/peg_parser/parser/custom_operator.test @@ -0,0 +1,21 @@ +# source: test/sql/peg_parser/parser/custom_operator.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +CALL check_peg_parser($TEST_PEG_PARSER$SELECT i FROM tbl WHERE i >>= '127.0.0.1/8';$TEST_PEG_PARSER$); +-- +ok +== +CALL check_peg_parser($TEST_PEG_PARSER$SELECT j->>'duck';$TEST_PEG_PARSER$); +-- +ok +== +CALL check_peg_parser($TEST_PEG_PARSER$SELECT 2**2 + 1;$TEST_PEG_PARSER$); +-- +ok +== +CALL check_peg_parser($TEST_PEG_PARSER$select 1 not null; $TEST_PEG_PARSER$); +-- +ok +== diff --git a/parser/testdata/corpus/sql/peg_parser/parser/delete_from.test b/parser/testdata/corpus/sql/peg_parser/parser/delete_from.test new file mode 100644 index 0000000..e5a8c46 --- /dev/null +++ b/parser/testdata/corpus/sql/peg_parser/parser/delete_from.test @@ -0,0 +1,9 @@ +# source: test/sql/peg_parser/parser/delete_from.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +CALL check_peg_parser($TEST_PEG_PARSER$DELETE FROM integers i1 WHERE i>(SELECT MAX(i) FROM integers WHERE i1.i<>i)$TEST_PEG_PARSER$); +-- +ok +== diff --git a/parser/testdata/corpus/sql/peg_parser/parser/dollar_quoted.test b/parser/testdata/corpus/sql/peg_parser/parser/dollar_quoted.test new file mode 100644 index 0000000..759bd06 --- /dev/null +++ b/parser/testdata/corpus/sql/peg_parser/parser/dollar_quoted.test @@ -0,0 +1,37 @@ +# source: test/sql/peg_parser/parser/dollar_quoted.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +CALL check_peg_parser($TEST_PEG_PARSER$set variable time_travel_snapshot_id = $$foo$$$TEST_PEG_PARSER$); +-- +ok +== +CALL check_peg_parser($TEST_PEG_PARSER$select $🦆$du ck$🦆$ = $🦆$du　ck$🦆$;$TEST_PEG_PARSER$); +-- +ok +== +CALL check_peg_parser($TEST_PEG_PARSER$prepare p4 as select $name, $other_name$TEST_PEG_PARSER$); +-- +ok +== +CALL check_peg_parser($TEST_PEG_PARSER$prepare q123 as select $param, $other_name, $param;$TEST_PEG_PARSER$); +-- +ok +== +CALL check_peg_parser($TEST_PEG_PARSER$select $tag$ $duck$ $tag$ = $tag$　$duck$　$tag$;$TEST_PEG_PARSER$); +-- +ok +== +CALL check_peg_parser($TEST_PEG_PARSER$select $tag$ $tag$ = $tag$　$tag$;$TEST_PEG_PARSER$); +-- +ok +== +CALL check_peg_parser($TEST_PEG_PARSER$SELECT $marker$[hello, world]$marker$::VARCHAR[];$TEST_PEG_PARSER$); +-- +ok +== +CALL check_peg_parser($TEST_PEG_PARSER$SELECT $$[hello, world]$$::VARCHAR[];$TEST_PEG_PARSER$); +-- +ok +== diff --git a/parser/testdata/corpus/sql/peg_parser/parser/dotted_functions.test b/parser/testdata/corpus/sql/peg_parser/parser/dotted_functions.test new file mode 100644 index 0000000..8218498 --- /dev/null +++ b/parser/testdata/corpus/sql/peg_parser/parser/dotted_functions.test @@ -0,0 +1,21 @@ +# source: test/sql/peg_parser/parser/dotted_functions.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +CALL check_peg_parser($TEST_PEG_PARSER$select trim('a')$TEST_PEG_PARSER$); +-- +ok +== +CALL check_peg_parser($TEST_PEG_PARSER$select x.trim().nullif(''); $TEST_PEG_PARSER$); +-- +ok +== +CALL check_peg_parser($TEST_PEG_PARSER$select ['aa'].list_transform(lambda x: x.trim().nullif(''));$TEST_PEG_PARSER$); +-- +ok +== +CALL check_peg_parser($TEST_PEG_PARSER$SELECT v.trim()$TEST_PEG_PARSER$); +-- +ok +== diff --git a/parser/testdata/corpus/sql/peg_parser/parser/empty_map.test b/parser/testdata/corpus/sql/peg_parser/parser/empty_map.test new file mode 100644 index 0000000..829485b --- /dev/null +++ b/parser/testdata/corpus/sql/peg_parser/parser/empty_map.test @@ -0,0 +1,9 @@ +# source: test/sql/peg_parser/parser/empty_map.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +CALL check_peg_parser($TEST_PEG_PARSER$SELECT MAP {};$TEST_PEG_PARSER$); +-- +ok +== diff --git a/parser/testdata/corpus/sql/peg_parser/parser/ignore_nulls.test b/parser/testdata/corpus/sql/peg_parser/parser/ignore_nulls.test new file mode 100644 index 0000000..a3c0113 --- /dev/null +++ b/parser/testdata/corpus/sql/peg_parser/parser/ignore_nulls.test @@ -0,0 +1,9 @@ +# source: test/sql/peg_parser/parser/ignore_nulls.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +CALL check_peg_parser($TEST_PEG_PARSER$explain select first_value(i IGNORE NULLS) over () from integers$TEST_PEG_PARSER$); +-- +ok +== diff --git a/parser/testdata/corpus/sql/peg_parser/parser/index.test b/parser/testdata/corpus/sql/peg_parser/parser/index.test new file mode 100644 index 0000000..6b92229 --- /dev/null +++ b/parser/testdata/corpus/sql/peg_parser/parser/index.test @@ -0,0 +1,25 @@ +# source: test/sql/peg_parser/parser/index.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +CALL check_peg_parser($TEST_PEG_PARSER$create unique index part_comp_key_index on insertconflicttest(key, fruit) where 1;$TEST_PEG_PARSER$); +-- +ok +== +CALL check_peg_parser($TEST_PEG_PARSER$CREATE INDEX my_ip_idx ON t1 USING HNSW (vec) WITH (metric = 'ip');$TEST_PEG_PARSER$); +-- +ok +== +CALL check_peg_parser($TEST_PEG_PARSER$CREATE INDEX idx ON embeddings USING HNSW (vec) WITH (ef_construction = 100, ef_search = 100, M = 3, M0 = 3);$TEST_PEG_PARSER$); +-- +ok +== +CALL check_peg_parser($TEST_PEG_PARSER$DROP INDEX simple.new_schema.i_index$TEST_PEG_PARSER$); +-- +ok +== +CALL check_peg_parser($TEST_PEG_PARSER$DROP INDEX s.i_index;$TEST_PEG_PARSER$); +-- +ok +== diff --git a/parser/testdata/corpus/sql/peg_parser/parser/insert.test b/parser/testdata/corpus/sql/peg_parser/parser/insert.test new file mode 100644 index 0000000..94f4817 --- /dev/null +++ b/parser/testdata/corpus/sql/peg_parser/parser/insert.test @@ -0,0 +1,17 @@ +# source: test/sql/peg_parser/parser/insert.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +CALL check_peg_parser($TEST_PEG_PARSER$SELECT TRUE OFFSET 1 ROWS;$TEST_PEG_PARSER$); +-- +ok +== +CALL check_peg_parser($TEST_PEG_PARSER$INSERT INTO v0 BY POSITION ( SELECT TRUE ) OFFSET 1 ROWS RETURNING v0;$TEST_PEG_PARSER$); +-- +ok +== +CALL check_peg_parser($TEST_PEG_PARSER$INSERT INTO table2 WITH cte AS (INSERT INTO table1 SELECT 1) SELECT id FROM cte;$TEST_PEG_PARSER$); +-- +ok +== diff --git a/parser/testdata/corpus/sql/peg_parser/parser/insert_statement.test b/parser/testdata/corpus/sql/peg_parser/parser/insert_statement.test new file mode 100644 index 0000000..764368f --- /dev/null +++ b/parser/testdata/corpus/sql/peg_parser/parser/insert_statement.test @@ -0,0 +1,9 @@ +# source: test/sql/peg_parser/parser/insert_statement.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +CALL check_peg_parser($TEST_PEG_PARSER$INSERT INTO v0 BY POSITION ( SELECT TRUE ) OFFSET 1 ROWS RETURNING v0 . * EXCLUDE c1 ;$TEST_PEG_PARSER$); +-- +ok +== diff --git a/parser/testdata/corpus/sql/peg_parser/parser/invisible_space.test b/parser/testdata/corpus/sql/peg_parser/parser/invisible_space.test new file mode 100644 index 0000000..5c7d49e --- /dev/null +++ b/parser/testdata/corpus/sql/peg_parser/parser/invisible_space.test @@ -0,0 +1,9 @@ +# source: test/sql/peg_parser/parser/invisible_space.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +CALL check_peg_parser($TEST_PEG_PARSER$ $TEST_PEG_PARSER$); +-- +ok +== diff --git a/parser/testdata/corpus/sql/peg_parser/parser/lambda_functions.test b/parser/testdata/corpus/sql/peg_parser/parser/lambda_functions.test new file mode 100644 index 0000000..938c0a7 --- /dev/null +++ b/parser/testdata/corpus/sql/peg_parser/parser/lambda_functions.test @@ -0,0 +1,41 @@ +# source: test/sql/peg_parser/parser/lambda_functions.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +CALL check_peg_parser($TEST_PEG_PARSER$select histogram(g) from hist_data group by g%2==0 ORDER BY g%2==0$TEST_PEG_PARSER$); +-- +ok +== +CALL check_peg_parser($TEST_PEG_PARSER$select kurtosis(10) from range (5) where 1 == 0;$TEST_PEG_PARSER$); +-- +ok +== +CALL check_peg_parser($TEST_PEG_PARSER$select a ilike 'col%';$TEST_PEG_PARSER$); +-- +ok +== +CALL check_peg_parser($TEST_PEG_PARSER$select list_apply(maps, lambda x: map_keys(x)) from tbl;$TEST_PEG_PARSER$); +-- +ok +== +CALL check_peg_parser($TEST_PEG_PARSER$PREPARE v1 AS SELECT list_transform(?, lambda x: x + 1)$TEST_PEG_PARSER$); +-- +ok +== +CALL check_peg_parser($TEST_PEG_PARSER$SELECT COLUMNS(lambda x: x LIKE 'col%') FROM integers$TEST_PEG_PARSER$); +-- +ok +== +CALL check_peg_parser($TEST_PEG_PARSER$create table tbl as select i // 5_000 as num, num::VARCHAR || list_reduce([uuid()::varchar for x in range(10)], lambda x, y: concat(x, y)) str from range(20_000) t(i) order by num$TEST_PEG_PARSER$); +-- +ok +== +CALL check_peg_parser($TEST_PEG_PARSER$SELECT a.filter(lambda x: x > 0) FROM arrays$TEST_PEG_PARSER$); +-- +ok +== +CALL check_peg_parser($TEST_PEG_PARSER$SELECT list_transform(array_value(3,2,1), lambda x: x + 1) = list_transform([3,2,1], lambda x: x + 1);$TEST_PEG_PARSER$); +-- +ok +== diff --git a/parser/testdata/corpus/sql/peg_parser/parser/list_slices.test b/parser/testdata/corpus/sql/peg_parser/parser/list_slices.test new file mode 100644 index 0000000..65fdaf0 --- /dev/null +++ b/parser/testdata/corpus/sql/peg_parser/parser/list_slices.test @@ -0,0 +1,13 @@ +# source: test/sql/peg_parser/parser/list_slices.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +CALL check_peg_parser($TEST_PEG_PARSER$SELECT ([1,2,3])[1:-1:1];$TEST_PEG_PARSER$); +-- +ok +== +CALL check_peg_parser($TEST_PEG_PARSER$SELECT ([1,2,3,4,5])[1:-:2];$TEST_PEG_PARSER$); +-- +ok +== diff --git a/parser/testdata/corpus/sql/peg_parser/parser/load_extension.test b/parser/testdata/corpus/sql/peg_parser/parser/load_extension.test new file mode 100644 index 0000000..cc77b1c --- /dev/null +++ b/parser/testdata/corpus/sql/peg_parser/parser/load_extension.test @@ -0,0 +1,25 @@ +# source: test/sql/peg_parser/parser/load_extension.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +CALL check_peg_parser($TEST_PEG_PARSER$INSTALL tpch;$TEST_PEG_PARSER$); +-- +ok +== +CALL check_peg_parser($TEST_PEG_PARSER$FORCE INSTALL tpch;$TEST_PEG_PARSER$); +-- +ok +== +CALL check_peg_parser($TEST_PEG_PARSER$FORCE INSTALL tpch FROM '{LOCAL_EXTENSION_REPO_UPDATED}'$TEST_PEG_PARSER$); +-- +ok +== +CALL check_peg_parser($TEST_PEG_PARSER$LOAD tpch;$TEST_PEG_PARSER$); +-- +ok +== +CALL check_peg_parser($TEST_PEG_PARSER$LOAD '{SPATIAL_EXTENSION}'$TEST_PEG_PARSER$); +-- +ok +== diff --git a/parser/testdata/corpus/sql/peg_parser/parser/map.test b/parser/testdata/corpus/sql/peg_parser/parser/map.test new file mode 100644 index 0000000..1eeb2ed --- /dev/null +++ b/parser/testdata/corpus/sql/peg_parser/parser/map.test @@ -0,0 +1,33 @@ +# source: test/sql/peg_parser/parser/map.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +CALL check_peg_parser($TEST_PEG_PARSER$INSERT INTO test VALUES (MAP {ROW(3,3): ROW(1, 1)}), (MAP {ROW(4,4): ROW(2, 2)})$TEST_PEG_PARSER$); +-- +ok +== +CALL check_peg_parser($TEST_PEG_PARSER$create table unsupported_value as select val from ( select MAP { '01010101000'::BIT: 'hello', '11110111101'::BIT: 'world' } val ), range(3);$TEST_PEG_PARSER$); +-- +ok +== +CALL check_peg_parser($TEST_PEG_PARSER$SELECT list_transform(l, lambda x: {'map1': MAP {x::VARCHAR:1::VARCHAR, 'b'::VARCHAR: x::VARCHAR}}) FROM i;$TEST_PEG_PARSER$); +-- +ok +== +CALL check_peg_parser($TEST_PEG_PARSER$SELECT DISTINCT MAP { * : ? IN ( SELECT TRUE ) } ;$TEST_PEG_PARSER$); +-- +ok +== +CALL check_peg_parser($TEST_PEG_PARSER$SELECT MAP { [i]: [i + 1] } FROM range(5) t(i);$TEST_PEG_PARSER$); +-- +ok +== +CALL check_peg_parser($TEST_PEG_PARSER$CREATE TABLE MAP(i BIGINT);$TEST_PEG_PARSER$); +-- +ok +== +CALL check_peg_parser($TEST_PEG_PARSER$SELECT map([1,2])$TEST_PEG_PARSER$); +-- +ok +== diff --git a/parser/testdata/corpus/sql/peg_parser/parser/merge_into.test b/parser/testdata/corpus/sql/peg_parser/parser/merge_into.test new file mode 100644 index 0000000..0b37a53 --- /dev/null +++ b/parser/testdata/corpus/sql/peg_parser/parser/merge_into.test @@ -0,0 +1,29 @@ +# source: test/sql/peg_parser/parser/merge_into.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +CALL check_peg_parser($TEST_PEG_PARSER$WITH initial_stocks(item_id, balance) AS (VALUES (10, 2200), (20, 1900)) MERGE INTO Stock USING initial_stocks ON FALSE WHEN MATCHED THEN DO NOTHING WHEN NOT MATCHED THEN INSERT VALUES (initial_stocks.item_id, initial_stocks.balance) RETURNING merge_action, *$TEST_PEG_PARSER$); +-- +ok +== +CALL check_peg_parser($TEST_PEG_PARSER$MERGE INTO Stock USING (VALUES (30)) new_accounts(item_id) USING (item_id) WHEN NOT MATCHED THEN INSERT DEFAULT VALUES$TEST_PEG_PARSER$); +-- +ok +== +CALL check_peg_parser($TEST_PEG_PARSER$WITH initial_stocks(item_id, balance) AS (VALUES (10, 2200), (20, 1900)) MERGE INTO Stock USING initial_stocks ON FALSE WHEN MATCHED THEN DO NOTHING WHEN NOT MATCHED THEN INSERT VALUES (initial_stocks.item_id, initial_stocks.balance)$TEST_PEG_PARSER$); +-- +ok +== +CALL check_peg_parser($TEST_PEG_PARSER$MERGE INTO Stock USING (VALUES (5, 10)) new_accounts(item_id) USING (item_id) WHEN MATCHED THEN UPDATE$TEST_PEG_PARSER$); +-- +ok +== +CALL check_peg_parser($TEST_PEG_PARSER$MERGE INTO Accounts USING ( VALUES (1, 'user2', [1, 2, 3]) ) new_account(id) USING (id) WHEN MATCHED THEN UPDATE WHEN NOT MATCHED THEN INSERT$TEST_PEG_PARSER$); +-- +ok +== +CALL check_peg_parser($TEST_PEG_PARSER$MERGE INTO Stock USING (VALUES (10)) new_accounts(item_id) USING (item_id) WHEN NOT MATCHED THEN INSERT VALUES (new_accounts.item_id, DEFAULT)$TEST_PEG_PARSER$); +-- +ok +== diff --git a/parser/testdata/corpus/sql/peg_parser/parser/named_parameters.test b/parser/testdata/corpus/sql/peg_parser/parser/named_parameters.test new file mode 100644 index 0000000..bf9ec89 --- /dev/null +++ b/parser/testdata/corpus/sql/peg_parser/parser/named_parameters.test @@ -0,0 +1,29 @@ +# source: test/sql/peg_parser/parser/named_parameters.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +CALL check_peg_parser($TEST_PEG_PARSER$SELECT * FROM read_csv('file.csv', columns := {'a': 'INTEGER'})$TEST_PEG_PARSER$); +-- +ok +== +CALL check_peg_parser($TEST_PEG_PARSER$SELECT * FROM read_csv('file.csv', columns => {'a': 'INTEGER'})$TEST_PEG_PARSER$); +-- +ok +== +CALL check_peg_parser($TEST_PEG_PARSER$SELECT * FROM read_csv('file.csv', auto_detect := true)$TEST_PEG_PARSER$); +-- +ok +== +CALL check_peg_parser($TEST_PEG_PARSER$SELECT range(start => 1, stop => 10)$TEST_PEG_PARSER$); +-- +ok +== +CALL check_peg_parser($TEST_PEG_PARSER$SELECT range(start := 1, stop := 10)$TEST_PEG_PARSER$); +-- +ok +== +CALL check_peg_parser($TEST_PEG_PARSER$SELECT * FROM read_csv('file.csv', auto_detect := true, columns := {'a': 'INTEGER', 'b': 'VARCHAR'})$TEST_PEG_PARSER$); +-- +ok +== diff --git a/parser/testdata/corpus/sql/peg_parser/parser/nested_join.test b/parser/testdata/corpus/sql/peg_parser/parser/nested_join.test new file mode 100644 index 0000000..bb2ce13 --- /dev/null +++ b/parser/testdata/corpus/sql/peg_parser/parser/nested_join.test @@ -0,0 +1,21 @@ +# source: test/sql/peg_parser/parser/nested_join.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +CALL check_peg_parser($TEST_PEG_PARSER$from tenk1 join tenk1 join int8_tbl on 1 = 1 on 1 = 1;$TEST_PEG_PARSER$); +-- +ok +== +CALL check_peg_parser($TEST_PEG_PARSER$select * from a cross join b left join c on (a.x = c.x);$TEST_PEG_PARSER$); +-- +ok +== +CALL check_peg_parser($TEST_PEG_PARSER$select * from a cross join b cross join c left join d on (a.x = d.x);$TEST_PEG_PARSER$); +-- +ok +== +CALL check_peg_parser($TEST_PEG_PARSER$select * from a natural join b left join c on (a.x = c.x);$TEST_PEG_PARSER$); +-- +ok +== diff --git a/parser/testdata/corpus/sql/peg_parser/parser/on_conflict.test b/parser/testdata/corpus/sql/peg_parser/parser/on_conflict.test new file mode 100644 index 0000000..2e5f963 --- /dev/null +++ b/parser/testdata/corpus/sql/peg_parser/parser/on_conflict.test @@ -0,0 +1,9 @@ +# source: test/sql/peg_parser/parser/on_conflict.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +CALL check_peg_parser($TEST_PEG_PARSER$INSERT INTO tbl_comp VALUES (2, 'hello', 1, 'world') ON CONFLICT (c, b) DO UPDATE SET a = excluded.a, d = excluded.d;$TEST_PEG_PARSER$); +-- +ok +== diff --git a/parser/testdata/corpus/sql/peg_parser/parser/pivot_statement.test b/parser/testdata/corpus/sql/peg_parser/parser/pivot_statement.test new file mode 100644 index 0000000..0914c14 --- /dev/null +++ b/parser/testdata/corpus/sql/peg_parser/parser/pivot_statement.test @@ -0,0 +1,9 @@ +# source: test/sql/peg_parser/parser/pivot_statement.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +CALL check_peg_parser($TEST_PEG_PARSER$SELECT * FROM oncall UNPIVOT ((name) FOR precedence IN ((name1), (name2)));$TEST_PEG_PARSER$); +-- +ok +== diff --git a/parser/testdata/corpus/sql/peg_parser/parser/position.test b/parser/testdata/corpus/sql/peg_parser/parser/position.test new file mode 100644 index 0000000..4a00905 --- /dev/null +++ b/parser/testdata/corpus/sql/peg_parser/parser/position.test @@ -0,0 +1,21 @@ +# source: test/sql/peg_parser/parser/position.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +CALL check_peg_parser($TEST_PEG_PARSER$SELECT POSITION('a' || 'b' IN 'xab')$TEST_PEG_PARSER$); +-- +ok +== +CALL check_peg_parser($TEST_PEG_PARSER$SELECT POSITION('a' IN 'x' || 'ab')$TEST_PEG_PARSER$); +-- +ok +== +CALL check_peg_parser($TEST_PEG_PARSER$SELECT POSITION(lower('A') IN 'xab')$TEST_PEG_PARSER$); +-- +ok +== +CALL check_peg_parser($TEST_PEG_PARSER$SELECT POSITION(lower('A') || 'b' IN 'xab')$TEST_PEG_PARSER$); +-- +ok +== diff --git a/parser/testdata/corpus/sql/peg_parser/parser/recursive.test b/parser/testdata/corpus/sql/peg_parser/parser/recursive.test new file mode 100644 index 0000000..27e0eca --- /dev/null +++ b/parser/testdata/corpus/sql/peg_parser/parser/recursive.test @@ -0,0 +1,29 @@ +# source: test/sql/peg_parser/parser/recursive.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +CALL check_peg_parser($TEST_PEG_PARSER$CREATE RECURSIVE VIEW nums (n) AS VALUES (1) UNION ALL SELECT n+1;$TEST_PEG_PARSER$); +-- +ok +== +CALL check_peg_parser($TEST_PEG_PARSER$WITH RECURSIVE tbl(a) USING KEY (a) AS (SELECT 1 UNION ALL SELECT a.a+1 FROM tbl AS a) SELECT * FROM tbl;$TEST_PEG_PARSER$); +-- +ok +== +CALL check_peg_parser($TEST_PEG_PARSER$FROM (WITH foo2 AS ((WITH a AS (SELECT 1) (FROM a))) TABLE foo2);$TEST_PEG_PARSER$); +-- +ok +== +CALL check_peg_parser($TEST_PEG_PARSER$FROM (WITH foo AS (SELECT 1) (FROM foo)) foo;$TEST_PEG_PARSER$); +-- +ok +== +CALL check_peg_parser($TEST_PEG_PARSER$(FROM foo);$TEST_PEG_PARSER$); +-- +ok +== +CALL check_peg_parser($TEST_PEG_PARSER$FROM (WITH foo AS (SELECT 1) FROM foo) foo;$TEST_PEG_PARSER$); +-- +ok +== diff --git a/parser/testdata/corpus/sql/peg_parser/parser/sample.test b/parser/testdata/corpus/sql/peg_parser/parser/sample.test new file mode 100644 index 0000000..5195e8c --- /dev/null +++ b/parser/testdata/corpus/sql/peg_parser/parser/sample.test @@ -0,0 +1,29 @@ +# source: test/sql/peg_parser/parser/sample.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +CALL check_peg_parser($TEST_PEG_PARSER$select count(*)$TEST_PEG_PARSER$); +-- +ok +== +CALL check_peg_parser($TEST_PEG_PARSER$select count(*) from range(200000) using sample reservoir(90 PERCENT);$TEST_PEG_PARSER$); +-- +ok +== +CALL check_peg_parser($TEST_PEG_PARSER$select count(*) from range(200000) tablesample reservoir(90 PERCENT);$TEST_PEG_PARSER$); +-- +ok +== +CALL check_peg_parser($TEST_PEG_PARSER$SELECT COUNT(*) FROM test USING SAMPLE 3 (reservoir);$TEST_PEG_PARSER$); +-- +ok +== +CALL check_peg_parser($TEST_PEG_PARSER$select count(*) from integers tablesample reservoir(10);$TEST_PEG_PARSER$); +-- +ok +== +CALL check_peg_parser($TEST_PEG_PARSER$SELECT * from t1 using sample reservoir(6000) repeatable (1) order by a;$TEST_PEG_PARSER$); +-- +ok +== diff --git a/parser/testdata/corpus/sql/peg_parser/parser/scientific_notation.test b/parser/testdata/corpus/sql/peg_parser/parser/scientific_notation.test new file mode 100644 index 0000000..c9efd57 --- /dev/null +++ b/parser/testdata/corpus/sql/peg_parser/parser/scientific_notation.test @@ -0,0 +1,17 @@ +# source: test/sql/peg_parser/parser/scientific_notation.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +CALL check_peg_parser($TEST_PEG_PARSER$select +1234.56789e-1$TEST_PEG_PARSER$); +-- +ok +== +CALL check_peg_parser($TEST_PEG_PARSER$select 1e30, 1e100, 1e-1$TEST_PEG_PARSER$); +-- +ok +== +CALL check_peg_parser($TEST_PEG_PARSER$SELECT 1e308+1e308$TEST_PEG_PARSER$); +-- +ok +== diff --git a/parser/testdata/corpus/sql/peg_parser/parser/select_star.test b/parser/testdata/corpus/sql/peg_parser/parser/select_star.test new file mode 100644 index 0000000..5bafd1a --- /dev/null +++ b/parser/testdata/corpus/sql/peg_parser/parser/select_star.test @@ -0,0 +1,21 @@ +# source: test/sql/peg_parser/parser/select_star.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +CALL check_peg_parser($TEST_PEG_PARSER$SELECT integers.* EXCLUDE ('i')$TEST_PEG_PARSER$); +-- +ok +== +CALL check_peg_parser($TEST_PEG_PARSER$SELECT * EXCLUDE (db1.s1.t.c) FROM db1.s1.t, db2.s1.t$TEST_PEG_PARSER$); +-- +ok +== +CALL check_peg_parser($TEST_PEG_PARSER$SELECT struct.*$TEST_PEG_PARSER$); +-- +ok +== +CALL check_peg_parser($TEST_PEG_PARSER$select t.* from ((select 1) cross join (select 1)) as t$TEST_PEG_PARSER$); +-- +ok +== diff --git a/parser/testdata/corpus/sql/peg_parser/parser/show_table.test b/parser/testdata/corpus/sql/peg_parser/parser/show_table.test new file mode 100644 index 0000000..b2a63c2 --- /dev/null +++ b/parser/testdata/corpus/sql/peg_parser/parser/show_table.test @@ -0,0 +1,9 @@ +# source: test/sql/peg_parser/parser/show_table.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +CALL check_peg_parser($TEST_PEG_PARSER$SHOW TABLES FROM db.main$TEST_PEG_PARSER$); +-- +ok +== diff --git a/parser/testdata/corpus/sql/peg_parser/parser/struct_identifier.test b/parser/testdata/corpus/sql/peg_parser/parser/struct_identifier.test new file mode 100644 index 0000000..6cce1c7 --- /dev/null +++ b/parser/testdata/corpus/sql/peg_parser/parser/struct_identifier.test @@ -0,0 +1,41 @@ +# source: test/sql/peg_parser/parser/struct_identifier.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +CALL check_peg_parser($TEST_PEG_PARSER$ALTER TABLE test ADD COLUMN s.i INTEGER$TEST_PEG_PARSER$); +-- +ok +== +CALL check_peg_parser($TEST_PEG_PARSER$ALTER TABLE test RENAME s.i TO v1$TEST_PEG_PARSER$); +-- +ok +== +CALL check_peg_parser($TEST_PEG_PARSER$ALTER TABLE test RENAME s.s2.v1 TO i$TEST_PEG_PARSER$); +-- +ok +== +CALL check_peg_parser($TEST_PEG_PARSER$ALTER TABLE test DROP COLUMN s.i$TEST_PEG_PARSER$); +-- +ok +== +CALL check_peg_parser($TEST_PEG_PARSER$ALTER TABLE test DROP s.s2.v1$TEST_PEG_PARSER$); +-- +ok +== +CALL check_peg_parser($TEST_PEG_PARSER$ALTER TABLE test ADD COLUMN s.k INTEGER$TEST_PEG_PARSER$); +-- +ok +== +CALL check_peg_parser($TEST_PEG_PARSER$ALTER TABLE test RENAME COLUMN s.value.j TO abc$TEST_PEG_PARSER$); +-- +ok +== +CALL check_peg_parser($TEST_PEG_PARSER$ALTER TABLE test RENAME COLUMN s.element.j TO k$TEST_PEG_PARSER$); +-- +ok +== +CALL check_peg_parser($TEST_PEG_PARSER$ALTER TABLE test DROP COLUMN s.element.j$TEST_PEG_PARSER$); +-- +ok +== diff --git a/parser/testdata/corpus/sql/peg_parser/parser/support_optional_not_null_constraint.test b/parser/testdata/corpus/sql/peg_parser/parser/support_optional_not_null_constraint.test new file mode 100644 index 0000000..9fc0f6e --- /dev/null +++ b/parser/testdata/corpus/sql/peg_parser/parser/support_optional_not_null_constraint.test @@ -0,0 +1,9 @@ +# source: test/sql/peg_parser/parser/support_optional_not_null_constraint.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +CALL check_peg_parser($TEST_PEG_PARSER$CREATE TABLE tag_8764 ( key VARCHAR(65535) NOT NULL, name VARCHAR(65535) NULL, value VARCHAR(65535) NOT NULL, PRIMARY KEY (key, name) );$TEST_PEG_PARSER$); +-- +ok +== diff --git a/parser/testdata/corpus/sql/peg_parser/parser/support_try.test b/parser/testdata/corpus/sql/peg_parser/parser/support_try.test new file mode 100644 index 0000000..0e45043 --- /dev/null +++ b/parser/testdata/corpus/sql/peg_parser/parser/support_try.test @@ -0,0 +1,9 @@ +# source: test/sql/peg_parser/parser/support_try.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +CALL check_peg_parser($TEST_PEG_PARSER$select TRY(~CAST('abc' as INTEGER))$TEST_PEG_PARSER$); +-- +ok +== diff --git a/parser/testdata/corpus/sql/peg_parser/parser/support_unreserved_keywords.test b/parser/testdata/corpus/sql/peg_parser/parser/support_unreserved_keywords.test new file mode 100644 index 0000000..0535e0f --- /dev/null +++ b/parser/testdata/corpus/sql/peg_parser/parser/support_unreserved_keywords.test @@ -0,0 +1,229 @@ +# source: test/sql/peg_parser/parser/support_unreserved_keywords.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +CALL check_peg_parser($TEST_PEG_PARSER$CREATE OR REPLACE TABLE 'everflow_daily' AS SELECT *$TEST_PEG_PARSER$); +-- +ok +== +CALL check_peg_parser($TEST_PEG_PARSER$CREATE TABLE tmp.t1(id int);$TEST_PEG_PARSER$); +-- +ok +== +CALL check_peg_parser($TEST_PEG_PARSER$CREATE TABLE database.schema.table(foo integer);$TEST_PEG_PARSER$); +-- +ok +== +CALL check_peg_parser($TEST_PEG_PARSER$CREATE MACRO foo(a,b) as TABLE select *;$TEST_PEG_PARSER$); +-- +ok +== +CALL check_peg_parser($TEST_PEG_PARSER$FROM database.schema.table;$TEST_PEG_PARSER$); +-- +ok +== +CALL check_peg_parser($TEST_PEG_PARSER$select * from '{DATA_DIR}/csv/nullbyte.csv';$TEST_PEG_PARSER$); +-- +ok +== +CALL check_peg_parser($TEST_PEG_PARSER$CREATE TABLE foo(try_cast INTEGER);$TEST_PEG_PARSER$); +-- +ok +== +CALL check_peg_parser($TEST_PEG_PARSER$SELECT "hello world".i FROM foo AS 'hello world'$TEST_PEG_PARSER$); +-- +ok +== +CALL check_peg_parser($TEST_PEG_PARSER$FROM information_schema.schema$TEST_PEG_PARSER$); +-- +ok +== +CALL check_peg_parser($TEST_PEG_PARSER$FROM information_schema.columns$TEST_PEG_PARSER$); +-- +ok +== +CALL check_peg_parser($TEST_PEG_PARSER$DROP TABLE IF EXISTS map;$TEST_PEG_PARSER$); +-- +ok +== +CALL check_peg_parser($TEST_PEG_PARSER$CREATE TABLE map(v INTEGER);$TEST_PEG_PARSER$); +-- +ok +== +CALL check_peg_parser($TEST_PEG_PARSER$RESET VARIABLE foo$TEST_PEG_PARSER$); +-- +ok +== +CALL check_peg_parser($TEST_PEG_PARSER$select left(b collate de, 6)$TEST_PEG_PARSER$); +-- +ok +== +CALL check_peg_parser($TEST_PEG_PARSER$SELECT v.trim('><')$TEST_PEG_PARSER$); +-- +ok +== +CALL check_peg_parser($TEST_PEG_PARSER$CREATE TABLE bits (b bit);$TEST_PEG_PARSER$); +-- +ok +== +CALL check_peg_parser($TEST_PEG_PARSER$CREATE TABLE issue14384(i INTERVAL);$TEST_PEG_PARSER$); +-- +ok +== +CALL check_peg_parser($TEST_PEG_PARSER$SELECT cast(1 as INT)$TEST_PEG_PARSER$); +-- +ok +== +CALL check_peg_parser($TEST_PEG_PARSER$SELECT 1::SMALLINT$TEST_PEG_PARSER$); +-- +ok +== +CALL check_peg_parser($TEST_PEG_PARSER$copy integers to '{TEMP_DIR}/integers.json.gz' (FORMAT JSON, COMPRESSION GZIP)$TEST_PEG_PARSER$); +-- +ok +== +CALL check_peg_parser($TEST_PEG_PARSER$CREATE OR REPLACE TABLE t( x VARCHAR USING COMPRESSION Dictionary );$TEST_PEG_PARSER$); +-- +ok +== +CALL check_peg_parser($TEST_PEG_PARSER$select distinct on (types) types from (select vector_type(a) from test limit 8192) tbl(types)$TEST_PEG_PARSER$); +-- +ok +== +CALL check_peg_parser($TEST_PEG_PARSER$create table data(id integer, value integer);$TEST_PEG_PARSER$); +-- +ok +== +CALL check_peg_parser($TEST_PEG_PARSER$create table t2 (id int, v_map struct(foo integer[]));$TEST_PEG_PARSER$); +-- +ok +== +CALL check_peg_parser($TEST_PEG_PARSER$ATTACH '{TEMP_DIR}/encrypted.duckdb' AS encrypted (ENCRYPTION_KEY 'asdf');$TEST_PEG_PARSER$); +-- +ok +== +CALL check_peg_parser($TEST_PEG_PARSER$SELECT COUNT(*) FROM glob('{TEMP_DIR}/attach_no_wal.db.wal');$TEST_PEG_PARSER$); +-- +ok +== +CALL check_peg_parser($TEST_PEG_PARSER$CREATE TABLE testjson AS SELECT JSON '{ "key" : "value" }';$TEST_PEG_PARSER$); +-- +ok +== +CALL check_peg_parser($TEST_PEG_PARSER$COPY FROM DATABASE unencrypted TO encrypted;$TEST_PEG_PARSER$); +-- +ok +== +CALL check_peg_parser($TEST_PEG_PARSER$INSERT INTO hero (name, secret_name, age) VALUES (1) ON CONFLICT (name) DO UPDATE SET secret_name = EXCLUDED.secret_name, age = EXCLUDED.age;$TEST_PEG_PARSER$); +-- +ok +== +CALL check_peg_parser($TEST_PEG_PARSER$SELECT list_reduce(s, lambda curr, next: struct_pack(a:=curr.a + (next.b - curr.b), b:=next.b)) FROM df$TEST_PEG_PARSER$); +-- +ok +== +CALL check_peg_parser($TEST_PEG_PARSER$select features[1].name;$TEST_PEG_PARSER$); +-- +ok +== +CALL check_peg_parser($TEST_PEG_PARSER$SELECT last(value ORDER BY foo IGNORE NULLS)$TEST_PEG_PARSER$); +-- +ok +== +CALL check_peg_parser($TEST_PEG_PARSER$select UNPACK(a)$TEST_PEG_PARSER$); +-- +ok +== +CALL check_peg_parser($TEST_PEG_PARSER$select sum(salary) over (order by enroll_date range between '1 year' preceding and '1 year' following)$TEST_PEG_PARSER$); +-- +ok +== +CALL check_peg_parser($TEST_PEG_PARSER$CREATE TEMPORARY MACRO my_seq(start, finish, stride:=3) as TABLE SELECT *;$TEST_PEG_PARSER$); +-- +ok +== +CALL check_peg_parser($TEST_PEG_PARSER$CREATE TABLE history(id TEXT, type TEXT, PRIMARY KEY(id, type));$TEST_PEG_PARSER$); +-- +ok +== +CALL check_peg_parser($TEST_PEG_PARSER$UNPIVOT PivotedCities ON 2000, 2010, 2020 INTO NAME YEAR VALUE Population;$TEST_PEG_PARSER$); +-- +ok +== +CALL check_peg_parser($TEST_PEG_PARSER$WITH data AS ( SELECT 1 as a, 2 as b, 3 as c ) SELECT d FROM data d$TEST_PEG_PARSER$); +-- +ok +== +CALL check_peg_parser($TEST_PEG_PARSER$insert into data (id, value) select 1$TEST_PEG_PARSER$); +-- +ok +== +CALL check_peg_parser($TEST_PEG_PARSER$SELECT UNNEST({'a': 42, 'b': {'c': 88, 'd': 99}}, recursive := true)$TEST_PEG_PARSER$); +-- +ok +== +CALL check_peg_parser($TEST_PEG_PARSER$SELECT c2 as end;$TEST_PEG_PARSER$); +-- +ok +== +CALL check_peg_parser($TEST_PEG_PARSER$CREATE TABLE big_tbl AS SELECT i, concat('thisisalongstring', i) as str FROM range(10000000) t(i);$TEST_PEG_PARSER$); +-- +ok +== +CALL check_peg_parser($TEST_PEG_PARSER$select distinct on (a) b from (select s a, md5(s::text)) limit 10;$TEST_PEG_PARSER$); +-- +ok +== +CALL check_peg_parser($TEST_PEG_PARSER$select distinct on (a) b from (select s a, md5(s::double)) limit 10;$TEST_PEG_PARSER$); +-- +ok +== +CALL check_peg_parser($TEST_PEG_PARSER$SELECT histogram_exact((date '2000-01-01' + interval (n) days))$TEST_PEG_PARSER$); +-- +ok +== +CALL check_peg_parser($TEST_PEG_PARSER$SELECT MAP{ 0 : 0 } FROM lineitem$TEST_PEG_PARSER$); +-- +ok +== +CALL check_peg_parser($TEST_PEG_PARSER$SELECT l_returnflag, map { '0': case when sum(1) filter(l_orderkey <= 0) is null then 0 end, '1000000': sum(1) filter(l_orderkey > 0 and l_orderkey <= 1000000), '2000000': sum(1) filter(l_orderkey > 1000000 and l_orderkey <= 2000000), '3000000': sum(1) filter(l_orderkey > 2000000 and l_orderkey <= 3000000), '4000000': sum(1) filter(l_orderkey > 3000000 and l_orderkey <= 4000000), '5000000': sum(1) filter(l_orderkey > 4000000 and l_orderkey <= 5000000), '6000000': sum(1) filter(l_orderkey > 5000000 and l_orderkey <= 6000000) } FROM lineitem GROUP BY l_returnflag ORDER BY l_returnflag$TEST_PEG_PARSER$); +-- +ok +== +CALL check_peg_parser($TEST_PEG_PARSER$SELECT c2 as foo;$TEST_PEG_PARSER$); +-- +ok +== +CALL check_peg_parser($TEST_PEG_PARSER$SELECT c2 foo;$TEST_PEG_PARSER$); +-- +ok +== +CALL check_peg_parser($TEST_PEG_PARSER$SELECT foo: c2;$TEST_PEG_PARSER$); +-- +ok +== +CALL check_peg_parser($TEST_PEG_PARSER$SELECT c2 'foo';$TEST_PEG_PARSER$); +-- +ok +== +CALL check_peg_parser($TEST_PEG_PARSER$SELECT c2, c1 FROM (SELECT a)$TEST_PEG_PARSER$); +-- +ok +== +CALL check_peg_parser($TEST_PEG_PARSER$SELECT number1, number2 SIMILAR TO '0' as a;$TEST_PEG_PARSER$); +-- +ok +== +CALL check_peg_parser($TEST_PEG_PARSER$SELECT number1, number2 SIMILAR TO '0' as 'a';$TEST_PEG_PARSER$); +-- +ok +== +CALL check_peg_parser($TEST_PEG_PARSER$SELECT * SIMILAR TO '0' as 'a';$TEST_PEG_PARSER$); +-- +ok +== +CALL check_peg_parser($TEST_PEG_PARSER$SELECT c2, c1 FROM ( SELECT * SIMILAR TO 'number(\d+)' AS 'c\1' FROM (SELECT 1 as number1, 2 as number2, 3 as end) );$TEST_PEG_PARSER$); +-- +ok +== diff --git a/parser/testdata/corpus/sql/peg_parser/parser/type.test b/parser/testdata/corpus/sql/peg_parser/parser/type.test new file mode 100644 index 0000000..08e30a4 --- /dev/null +++ b/parser/testdata/corpus/sql/peg_parser/parser/type.test @@ -0,0 +1,65 @@ +# source: test/sql/peg_parser/parser/type.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +CALL check_peg_parser($TEST_PEG_PARSER$CREATE TYPE type_int AS ENUM (SELECT 1);$TEST_PEG_PARSER$); +-- +ok +== +CALL check_peg_parser($TEST_PEG_PARSER$CREATE TYPE number_enum AS ENUM (SELECT x FROM number_str);$TEST_PEG_PARSER$); +-- +ok +== +CALL check_peg_parser($TEST_PEG_PARSER$CREATE TYPE type_int AS ENUM ('a','b');$TEST_PEG_PARSER$); +-- +ok +== +CALL check_peg_parser($TEST_PEG_PARSER$CREATE TYPE type_int AS BIGINT;$TEST_PEG_PARSER$); +-- +ok +== +CALL check_peg_parser($TEST_PEG_PARSER$CREATE TABLE decs(i DEC())$TEST_PEG_PARSER$); +-- +ok +== +CALL check_peg_parser($TEST_PEG_PARSER$CREATE TABLE decimals(i DECIMAL(), j DECIMAL)$TEST_PEG_PARSER$); +-- +ok +== +CALL check_peg_parser($TEST_PEG_PARSER$CREATE TABLE numerics(i NUMERIC(), j NUMERIC)$TEST_PEG_PARSER$); +-- +ok +== +CALL check_peg_parser($TEST_PEG_PARSER$CREATE TYPE bla AS ENUM ();$TEST_PEG_PARSER$); +-- +ok +== +set allow_parser_override_extension=strict; +-- +ok +== +SELECT typeof(NULL::INTEGER ARRAY[3]); +-- +ok +== +SELECT typeof(NULL::INTEGER ARRAY[3][2]); +-- +ok +== +SELECT typeof(NULL::INTEGER ARRAY ARRAY[3]); +-- +ok +== +CALL check_peg_parser($TEST_PEG_PARSER$SELECT typeof(NULL::INTEGER ARRAY[3]);$TEST_PEG_PARSER$); +-- +ok +== +CALL check_peg_parser($TEST_PEG_PARSER$SELECT typeof(NULL::INTEGER ARRAY[3][2]);$TEST_PEG_PARSER$); +-- +ok +== +CALL check_peg_parser($TEST_PEG_PARSER$SELECT typeof(NULL::INTEGER ARRAY ARRAY[3]);$TEST_PEG_PARSER$); +-- +ok +== diff --git a/parser/testdata/corpus/sql/peg_parser/parser/update_statement.test b/parser/testdata/corpus/sql/peg_parser/parser/update_statement.test new file mode 100644 index 0000000..b024ef4 --- /dev/null +++ b/parser/testdata/corpus/sql/peg_parser/parser/update_statement.test @@ -0,0 +1,21 @@ +# source: test/sql/peg_parser/parser/update_statement.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +CALL check_peg_parser($TEST_PEG_PARSER$UPDATE temp.a SET i = 44$TEST_PEG_PARSER$); +-- +ok +== +CALL check_peg_parser($TEST_PEG_PARSER$UPDATE foo SET (key, fruit, cost) = (1, 'pear', 2);$TEST_PEG_PARSER$); +-- +ok +== +CALL check_peg_parser($TEST_PEG_PARSER$UPDATE test t SET a=1$TEST_PEG_PARSER$); +-- +ok +== +CALL check_peg_parser($TEST_PEG_PARSER$UPDATE foo t SET (key, fruit, cost) = (1, 'pear', 2);$TEST_PEG_PARSER$); +-- +ok +== diff --git a/parser/testdata/corpus/sql/peg_parser/parser/use_statement.test b/parser/testdata/corpus/sql/peg_parser/parser/use_statement.test new file mode 100644 index 0000000..d3c1e01 --- /dev/null +++ b/parser/testdata/corpus/sql/peg_parser/parser/use_statement.test @@ -0,0 +1,13 @@ +# source: test/sql/peg_parser/parser/use_statement.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +CALL check_peg_parser($TEST_PEG_PARSER$use my_datalake.default;$TEST_PEG_PARSER$); +-- +ok +== +CALL check_peg_parser($TEST_PEG_PARSER$select * from my_datalake.default.empty_table;$TEST_PEG_PARSER$); +-- +ok +== diff --git a/parser/testdata/corpus/sql/peg_parser/parser/window_function.test b/parser/testdata/corpus/sql/peg_parser/parser/window_function.test new file mode 100644 index 0000000..4a6235a --- /dev/null +++ b/parser/testdata/corpus/sql/peg_parser/parser/window_function.test @@ -0,0 +1,25 @@ +# source: test/sql/peg_parser/parser/window_function.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +CALL check_peg_parser($TEST_PEG_PARSER$explain select first_value(i IGNORE NULLS) over () from integers;$TEST_PEG_PARSER$); +-- +ok +== +CALL check_peg_parser($TEST_PEG_PARSER$select regr_avgx(v, v2) over (partition by k) from aggr;$TEST_PEG_PARSER$); +-- +ok +== +CALL check_peg_parser($TEST_PEG_PARSER$select regr_avgx(v, v2) over (w partition by k) from aggr;$TEST_PEG_PARSER$); +-- +ok +== +CALL check_peg_parser($TEST_PEG_PARSER$SELECT sum(unique1) over (w range between unbounded preceding and current row exclude current row);$TEST_PEG_PARSER$); +-- +ok +== +CALL check_peg_parser($TEST_PEG_PARSER$SELECT sum(unique1) over (w range between unbounded preceding and current row exclude current row), unique1, four FROM tenk1d WINDOW w AS (order by four) ORDER BY four, unique1;$TEST_PEG_PARSER$); +-- +ok +== diff --git a/parser/testdata/corpus/sql/peg_parser/parser/with_ordinality.test b/parser/testdata/corpus/sql/peg_parser/parser/with_ordinality.test new file mode 100644 index 0000000..f47eb6d --- /dev/null +++ b/parser/testdata/corpus/sql/peg_parser/parser/with_ordinality.test @@ -0,0 +1,13 @@ +# source: test/sql/peg_parser/parser/with_ordinality.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +CALL check_peg_parser($TEST_PEG_PARSER$FROM foo() WITH ORDINALITY AS _(ordinality);$TEST_PEG_PARSER$); +-- +ok +== +CALL check_peg_parser($TEST_PEG_PARSER$SELECT a,my_range,my_ordinality FROM test AS t(a), LATERAL range(t.a) WITH ORDINALITY AS _(my_range,my_ordinality) ORDER BY a,my_range;$TEST_PEG_PARSER$); +-- +ok +== diff --git a/parser/testdata/corpus/sql/peg_parser/peg_syntax_error.test b/parser/testdata/corpus/sql/peg_parser/peg_syntax_error.test new file mode 100644 index 0000000..286fd3c --- /dev/null +++ b/parser/testdata/corpus/sql/peg_parser/peg_syntax_error.test @@ -0,0 +1,133 @@ +# source: test/sql/peg_parser/peg_syntax_error.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +SELECT (1 + (2 * 3) +-- +error: Parser Error: syntax error at or near ")" +== +SELECT (1 + (2 * 3); +-- +error: Parser Error: syntax error at or near ";" +== +SELECT (((((((((((((((((((; +-- +error: Parser Error: syntax error at or near ";" +== +SELECT 1 + 2 * ; +-- +error: Parser Error: syntax error at or near ";" +== +SELECT * FROM users JOIN orders +-- +error: Parser Error: syntax error at or near "orders" +== +SELECT * FROM users JOIN orders; +-- +error: Parser Error: syntax error at or near ";" +== +SELECT * FROM users WHERE id = 1 WHERE age > 20; +-- +error: Parser Error: syntax error at or near "WHERE" +== +SELECT (10). +-- +error: Parser Error: syntax error at or near "." +== +SELECT (10).; +-- +error: Parser Error: syntax error at or near ";" +== +SELECT * FROM tbl WHERE id IN (,); +-- +error: Parser Error: syntax error at or near "," +== +SELECT a, b,, FROM tbl; +-- +error: Parser Error: syntax error at or near "," +== +SELECT users..id FROM users; +-- +error: Parser Error: syntax error at or near ".." +== +SELECT * FROM tbl WHERE x = (SELECT 1 FROM (SELECT 2) +-- +error: Parser Error: syntax error at or near ")" +== +SELECT x -> x + FROM tbl; +-- +error: Parser Error: syntax error at or near "FROM" +== +WITH cte AS (SELECT 1) SELECT * FROM cte WHERE (SELECT 1 FROM cte2; +-- +error: Parser Error: syntax error at or near ";" +== +SELECT id, SUM(amount) OVER (PARTITION BY ) FROM sales; +-- +error: Parser Error: syntax error at or near ")" +== +WITH cte1 AS (SELECT 1), cte2 AS (SELECT ) SELECT * FROM cte1; +-- +error: Parser Error: SELECT clause without selection list +== +SELECT count(*) FILTER (WHERE ) FROM tbl; +-- +error: Parser Error: syntax error at or near ")" +== +SELECT {'a': 1, 'b': }; +-- +error: Parser Error: syntax error at or near "}" +== +SELECT CASE WHEN x > 10 THEN 'large' WHEN x < 5 +-- +error: Parser Error: syntax error at or near "5" +== +SELECT '2023-01-01':: +-- +error: Parser Error: syntax error at or near "::" +== +SELECT 1 INTERSECT +-- +error: Parser Error: syntax error at or near "INTERSECT" +== +create table tbl (a bigint, b bigint, c bigint); +-- +ok +== +SELECT a, b, SUM(c) FROM tbl GROUP BY GROUPING SETS (a, (b, )); +-- +ok +== +CREATE TABLE t1 (id INTEGER, name ); +-- +error: Parser Error: Column "name" must have a type or be defined as a GENERATED column. +== +SELECT 'abcd'::VARCHAR[1:3]; +-- +error: Parser Error: Subscript/slice cannot be applied directly after a cast operator (e.g. x::TYPE[1:3] is not allowed). Wrap the cast in parentheses: (x::TYPE)[1:3] +== +SELECT ('abcd'::VARCHAR)[1:3]; +-- +ok +== +SELECT * FROM 1e5; +-- +error: Parser Error: syntax error at or near "1e5" +== +CREATE TABLE 1 (id INTEGER); +-- +error: Parser Error: syntax error at or near "1" +== +SELECT 1 AS 1col; +-- +error: Parser Error: syntax error at or near "1" +== +SELECT 0 10; +-- +error: Parser Error: syntax error at or near "10" +== +CREATE TABLE "1abc" (id INTEGER); +-- +ok +== diff --git a/parser/testdata/corpus/sql/peg_parser/peg_syntax_error.test.metadata.json b/parser/testdata/corpus/sql/peg_parser/peg_syntax_error.test.metadata.json new file mode 100644 index 0000000..ef3795f --- /dev/null +++ b/parser/testdata/corpus/sql/peg_parser/peg_syntax_error.test.metadata.json @@ -0,0 +1,7 @@ +{ + "todo": { + "0e47440052e6de8f": "transformer-raised parser error: upstream rejects in the transformer, not the grammar; expected to clear as transformers land (milestones 3-5)", + "b81f308accbd170a": "transformer-raised parser error: upstream rejects in the transformer, not the grammar; expected to clear as transformers land (milestones 3-5)", + "f2d5692029146f8a": "transformer-raised parser error: upstream rejects in the transformer, not the grammar; expected to clear as transformers land (milestones 3-5)" + } +} diff --git a/parser/testdata/corpus/sql/peg_parser/qualified_operator.test b/parser/testdata/corpus/sql/peg_parser/qualified_operator.test new file mode 100644 index 0000000..b4e4c93 --- /dev/null +++ b/parser/testdata/corpus/sql/peg_parser/qualified_operator.test @@ -0,0 +1,13 @@ +# source: test/sql/peg_parser/qualified_operator.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +select 1 OPERATOR(main.+) 2; +-- +ok +== +select 1 OPERATOR(foo.bar.main.+) 2; +-- +error: Parser Error: Too many identifiers found, expected schema.operator or operator +== diff --git a/parser/testdata/corpus/sql/peg_parser/qualified_operator.test.metadata.json b/parser/testdata/corpus/sql/peg_parser/qualified_operator.test.metadata.json new file mode 100644 index 0000000..f40261e --- /dev/null +++ b/parser/testdata/corpus/sql/peg_parser/qualified_operator.test.metadata.json @@ -0,0 +1,5 @@ +{ + "todo": { + "884568dd738cc3d8": "transformer-raised parser error: upstream rejects in the transformer, not the grammar; expected to clear as transformers land (milestones 3-5)" + } +} diff --git a/parser/testdata/corpus/sql/peg_parser/transformer/alter_statement.test b/parser/testdata/corpus/sql/peg_parser/transformer/alter_statement.test new file mode 100644 index 0000000..b31ee71 --- /dev/null +++ b/parser/testdata/corpus/sql/peg_parser/transformer/alter_statement.test @@ -0,0 +1,82 @@ +# source: test/sql/peg_parser/transformer/alter_statement.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +CREATE TABLE test3(s integer); +-- +ok +== +ALTER TABLE test3 ADD COLUMN l INTEGER DEFAULT 42; +-- +ok +== +CREATE TYPE mood AS ENUM ( + 'sad', + 'ok', + 'happy' +); +-- +ok +== +CREATE TABLE person ( + id INTEGER, + c STRUCT( + name text, + current_mood mood + ) +); +-- +ok +== +INSERT INTO person VALUES (0, ('Bob', 'happy')) +-- +ok +== +alter table person add column b integer default 5; +-- +ok +== +select * from person; +-- +ok +== +ALTER TABLE person ADD COLUMN c STRUCT( + name text, + current_mood mood +); +-- +ok +== +ALTER TABLE test2 DROP s.s2.v1; +-- +ok +== +ALTER TABLE tbl SET PARTITIONED BY (i); +-- +ok +== +ALTER SEQUENCE seq OWNED BY tbl1; +-- +ok +== +ALTER TABLE integers ALTER j TYPE BIGINT; +-- +ok +== +ALTER TABLE T_1 ADD COLUMN b INTEGER DEFAULT 2; +-- +ok +== +ALTER VIEW new_database.s1.v1 RENAME TO v2; +-- +ok +== +ALTER TABLE aliens ADD COLUMN iq_level intelligence; +-- +ok +== +ALTER TABLE t0 ALTER c1 TYPE TIMESTAMP; +-- +ok +== diff --git a/parser/testdata/corpus/sql/peg_parser/transformer/attach_statement.test b/parser/testdata/corpus/sql/peg_parser/transformer/attach_statement.test new file mode 100644 index 0000000..6c40f17 --- /dev/null +++ b/parser/testdata/corpus/sql/peg_parser/transformer/attach_statement.test @@ -0,0 +1,25 @@ +# source: test/sql/peg_parser/transformer/attach_statement.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +SET VARIABLE db_type='DUCKDB'; +-- +ok +== +ATTACH ':memory:' AS db1 (TYPE getvariable('db_type')); +-- +ok +== +ATTACH '{TEST_DIR}/attach_read_only.db' AS db2 +-- +ok +== +DETACH db2 +-- +ok +== +ATTACH '{TEST_DIR}/attach_read_only.db' AS db2 (READONLY 1); +-- +ok +== diff --git a/parser/testdata/corpus/sql/peg_parser/transformer/call_statement.test b/parser/testdata/corpus/sql/peg_parser/transformer/call_statement.test new file mode 100644 index 0000000..ff24f4a --- /dev/null +++ b/parser/testdata/corpus/sql/peg_parser/transformer/call_statement.test @@ -0,0 +1,21 @@ +# source: test/sql/peg_parser/transformer/call_statement.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +CALL enable_logging(['FileSystem'], storage='file', storage_config={'path': '{TEST_DIR}/logging_csv_log.csv', 'normalize': false}); +-- +ok +== +CALL enable_logging(['QueryLog', 'FileSystem']); +-- +ok +== +CALL dbgen(sf=0.01, children=-1); +-- +ok +== +CALL dbgen(sf=0.1, suffix='_original'); +-- +ok +== diff --git a/parser/testdata/corpus/sql/peg_parser/transformer/delete_statement.test b/parser/testdata/corpus/sql/peg_parser/transformer/delete_statement.test new file mode 100644 index 0000000..94d4127 --- /dev/null +++ b/parser/testdata/corpus/sql/peg_parser/transformer/delete_statement.test @@ -0,0 +1,79 @@ +# source: test/sql/peg_parser/transformer/delete_statement.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +CREATE TABLE integers (i bigint); +-- +ok +== +INSERT INTO integers values (1), (2), (3); +-- +ok +== +DELETE FROM integers WHERE i%2 AND i<157353; +-- +ok +== +DELETE FROM integers WHERE i=2; +-- +ok +== +create table test (pk bigint); +-- +ok +== +DELETE FROM test WHERE pk > 738645 AND pk < 978908; +-- +ok +== +DELETE FROM integers WHERE i=(1-1)*100+0; +-- +ok +== +DELETE FROM integers WHERE i <> i::DECIMAL(9,1); +-- +ok +== +DELETE FROM integers WHERE i%3=0; +-- +ok +== +DELETE FROM integers WHERE i BETWEEN 200 AND 300; +-- +ok +== +DELETE FROM integers +WHERE i < 5 RETURNING i; +-- +ok +== +DELETE FROM integers WHERE integers.rowid; +-- +ok +== +DELETE FROM integers WHERE i = 7 RETURNING *; +-- +ok +== +DELETE FROM integers +WHERE i>=10 AND i <=13 RETURNING i as aliasc; +-- +ok +== +CREATE TABLE integers2 (i bigint); +-- +ok +== +DELETE FROM integers WHERE i < 5 RETURNING i; +-- +ok +== +CREATE TABLE a(b STRUCT(i INTEGER, j INTEGER)); +-- +ok +== +DELETE FROM a WHERE (b).i=1; +-- +ok +== diff --git a/parser/testdata/corpus/sql/peg_parser/transformer/drop_statement.test b/parser/testdata/corpus/sql/peg_parser/transformer/drop_statement.test new file mode 100644 index 0000000..514995a --- /dev/null +++ b/parser/testdata/corpus/sql/peg_parser/transformer/drop_statement.test @@ -0,0 +1,41 @@ +# source: test/sql/peg_parser/transformer/drop_statement.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +DROP MACRO plus1; +-- +ok +== +DROP SEQUENCE temp.t1; +-- +ok +== +attach ':memory:' as my_ducklake; +-- +ok +== +create schema my_ducklake.default; +-- +ok +== +drop schema my_ducklake.default; +-- +ok +== +DROP SCHEMA my_ducklake.default; +-- +ok +== +create table my_ducklake.foo (i bigint); +-- +ok +== +create index "default" on my_ducklake.foo (i); +-- +ok +== +drop index my_ducklake.default; +-- +ok +== diff --git a/parser/testdata/corpus/sql/peg_parser/transformer/load_statement.test b/parser/testdata/corpus/sql/peg_parser/transformer/load_statement.test new file mode 100644 index 0000000..85c2a43 --- /dev/null +++ b/parser/testdata/corpus/sql/peg_parser/transformer/load_statement.test @@ -0,0 +1,13 @@ +# source: test/sql/peg_parser/transformer/load_statement.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +set extension_directory='{TEST_DIR}/install_extension' +-- +ok +== +INSTALL will_never_exist; +-- +ok +== diff --git a/parser/testdata/corpus/sql/peg_parser/transformer/peg_transformer.test b/parser/testdata/corpus/sql/peg_parser/transformer/peg_transformer.test new file mode 100644 index 0000000..c04fcf0 --- /dev/null +++ b/parser/testdata/corpus/sql/peg_parser/transformer/peg_transformer.test @@ -0,0 +1,9 @@ +# source: test/sql/peg_parser/transformer/peg_transformer.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +select 1; +-- +ok +== diff --git a/parser/testdata/corpus/sql/peg_parser/transformer/set_statement.test b/parser/testdata/corpus/sql/peg_parser/transformer/set_statement.test new file mode 100644 index 0000000..ec2bfe2 --- /dev/null +++ b/parser/testdata/corpus/sql/peg_parser/transformer/set_statement.test @@ -0,0 +1,45 @@ +# source: test/sql/peg_parser/transformer/set_statement.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +set VARIABLE dataset_size = 122880; +-- +ok +== +SET SEARCH_PATH TO app2; +-- +ok +== +SET GLOBAL enable_progress_bar=true; +-- +ok +== +SET TimeZone='UTC'; +-- +ok +== +SET TIME ZONE 'UTC'; +-- +ok +== +SET TIME ZONE UTC; +-- +ok +== +SET TIME ZONE DEFAULT; +-- +ok +== +SET TIME ZONE LOCAL; +-- +ok +== +SET TIME ZONE INTERVAL '01:30' HOUR TO MINUTE; +-- +error: Parser Error: HOUR TO MINUTE is not supported +== +SET TIME ZONE INTERVAL '01:30'; +-- +ok +== diff --git a/parser/testdata/corpus/sql/peg_parser/transformer/set_statement.test.metadata.json b/parser/testdata/corpus/sql/peg_parser/transformer/set_statement.test.metadata.json new file mode 100644 index 0000000..858be78 --- /dev/null +++ b/parser/testdata/corpus/sql/peg_parser/transformer/set_statement.test.metadata.json @@ -0,0 +1,5 @@ +{ + "todo": { + "137ba824c42917c0": "transformer-raised parser error: upstream rejects in the transformer, not the grammar; expected to clear as transformers land (milestones 3-5)" + } +} diff --git a/parser/testdata/corpus/sql/peg_parser/transformer/special_string.test b/parser/testdata/corpus/sql/peg_parser/transformer/special_string.test new file mode 100644 index 0000000..1846938 --- /dev/null +++ b/parser/testdata/corpus/sql/peg_parser/transformer/special_string.test @@ -0,0 +1,13 @@ +# source: test/sql/peg_parser/transformer/special_string.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +select B'1010'; +-- +ok +== +select B'1010'; +-- +ok +== diff --git a/parser/testdata/corpus/sql/peg_parser/transformer/statement_length.test b/parser/testdata/corpus/sql/peg_parser/transformer/statement_length.test new file mode 100644 index 0000000..1e4578c --- /dev/null +++ b/parser/testdata/corpus/sql/peg_parser/transformer/statement_length.test @@ -0,0 +1,21 @@ +# source: test/sql/peg_parser/transformer/statement_length.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +SET allow_parser_override_extension = strict; +-- +ok +== +ATTACH ':memory:' AS memory_compressed (COMPRESS); +-- +ok +== +ATTACH ':memory:' AS memory_comp; +-- +ok +== +COPY FROM DATABASE memory_comp TO memory_compressed; +-- +ok +== diff --git a/parser/testdata/corpus/sql/peg_parser/transformer/transaction_statement.test b/parser/testdata/corpus/sql/peg_parser/transformer/transaction_statement.test new file mode 100644 index 0000000..1638b51 --- /dev/null +++ b/parser/testdata/corpus/sql/peg_parser/transformer/transaction_statement.test @@ -0,0 +1,9 @@ +# source: test/sql/peg_parser/transformer/transaction_statement.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +BEGIN TRANSACTION READ ONLY; +-- +ok +== diff --git a/parser/testdata/corpus/sql/peg_parser/transformer/trim.test b/parser/testdata/corpus/sql/peg_parser/transformer/trim.test new file mode 100644 index 0000000..09d2812 --- /dev/null +++ b/parser/testdata/corpus/sql/peg_parser/transformer/trim.test @@ -0,0 +1,9 @@ +# source: test/sql/peg_parser/transformer/trim.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +SELECT TRIM(TRAILING FROM 'hello'); +-- +ok +== diff --git a/parser/testdata/corpus/sql/peg_parser/transformer/unary_expression.test b/parser/testdata/corpus/sql/peg_parser/transformer/unary_expression.test new file mode 100644 index 0000000..9157606 --- /dev/null +++ b/parser/testdata/corpus/sql/peg_parser/transformer/unary_expression.test @@ -0,0 +1,29 @@ +# source: test/sql/peg_parser/transformer/unary_expression.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +CALL check_peg_parser($TEST_PEG_PARSER$SELECT - + 16;$TEST_PEG_PARSER$); +-- +ok +== +CALL check_peg_parser($TEST_PEG_PARSER$SELECT + - 16;$TEST_PEG_PARSER$); +-- +ok +== +CALL check_peg_parser($TEST_PEG_PARSER$SELECT - - 16;$TEST_PEG_PARSER$); +-- +ok +== +CALL check_peg_parser($TEST_PEG_PARSER$SELECT + + 16;$TEST_PEG_PARSER$); +-- +ok +== +SELECT + - 9223372036854775808; +-- +ok +== +CALL check_peg_parser($TEST_PEG_PARSER$SELECT x * - + 16 * y FROM (SELECT 2 AS x, 3 AS y) t;$TEST_PEG_PARSER$); +-- +ok +== diff --git a/parser/testdata/corpus/sql/peg_parser/transformer/update_extensions.test b/parser/testdata/corpus/sql/peg_parser/transformer/update_extensions.test new file mode 100644 index 0000000..9d75519 --- /dev/null +++ b/parser/testdata/corpus/sql/peg_parser/transformer/update_extensions.test @@ -0,0 +1,21 @@ +# source: test/sql/peg_parser/transformer/update_extensions.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +CALL check_peg_parser($TEST_PEG_PARSER$UPDATE EXTENSIONS;$TEST_PEG_PARSER$); +-- +ok +== +CALL check_peg_parser($TEST_PEG_PARSER$UPDATE EXTENSIONS (json);$TEST_PEG_PARSER$); +-- +ok +== +CALL check_peg_parser($TEST_PEG_PARSER$UPDATE EXTENSIONS (json, parquet);$TEST_PEG_PARSER$); +-- +ok +== +CALL check_peg_parser($TEST_PEG_PARSER$UPDATE EXTENSIONS (json, parquet, autocomplete);$TEST_PEG_PARSER$); +-- +ok +== diff --git a/parser/testdata/corpus/sql/peg_parser/transformer/use_statement_trampoline.test b/parser/testdata/corpus/sql/peg_parser/transformer/use_statement_trampoline.test new file mode 100644 index 0000000..47009ae --- /dev/null +++ b/parser/testdata/corpus/sql/peg_parser/transformer/use_statement_trampoline.test @@ -0,0 +1,49 @@ +# source: test/sql/peg_parser/transformer/use_statement_trampoline.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +ATTACH ':memory:' AS trampoline_use_catalog +-- +ok +== +SET debug_transformer_trampoline_style=true +-- +ok +== +USE main +-- +ok +== +USE MAIN +-- +ok +== +USE "main" +-- +ok +== +USE trampoline_use_catalog.main +-- +ok +== +USE "trampoline_use_catalog"."main" +-- +ok +== +USE temp +-- +ok +== +USE main.temp +-- +ok +== +USE main.extra +-- +ok +== +USE main.main.extra +-- +error: Parser Error: Expected "USE database" or "USE database.schema" +== diff --git a/parser/testdata/corpus/sql/peg_parser/transformer/use_statement_trampoline.test.metadata.json b/parser/testdata/corpus/sql/peg_parser/transformer/use_statement_trampoline.test.metadata.json new file mode 100644 index 0000000..db8de33 --- /dev/null +++ b/parser/testdata/corpus/sql/peg_parser/transformer/use_statement_trampoline.test.metadata.json @@ -0,0 +1,5 @@ +{ + "todo": { + "c826a808796eb361": "transformer-raised parser error: upstream rejects in the transformer, not the grammar; expected to clear as transformers land (milestones 3-5)" + } +} diff --git a/parser/testdata/corpus/sql/peg_parser/unterminated_literals.test b/parser/testdata/corpus/sql/peg_parser/unterminated_literals.test new file mode 100644 index 0000000..09e895f --- /dev/null +++ b/parser/testdata/corpus/sql/peg_parser/unterminated_literals.test @@ -0,0 +1,21 @@ +# source: test/sql/peg_parser/unterminated_literals.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +SELECT 'hello +-- +error: Parser Error: unterminated string literal +== +SELECT 'CONCAT_WS(',', '''' +-- +error: Parser Error: unterminated string literal +== +SELECT 'abc +-- +error: Parser Error: unterminated string literal +== +SELECT "my_col +-- +error: Parser Error: unterminated quoted identifier +== diff --git a/parser/testdata/corpus/sql/pg_catalog/pg_attribute.test b/parser/testdata/corpus/sql/pg_catalog/pg_attribute.test new file mode 100644 index 0000000..86427e0 --- /dev/null +++ b/parser/testdata/corpus/sql/pg_catalog/pg_attribute.test @@ -0,0 +1,17 @@ +# source: test/sql/pg_catalog/pg_attribute.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +SELECT * FROM pg_attribute +-- +ok +== +SELECT * FROM pg_catalog.pg_attribute +-- +ok +== +select relname, attname, attnum from pg_attribute join pg_class on (pg_attribute.attrelid=pg_class.oid) where relname='integers' and attnum>=0; +-- +ok +== diff --git a/parser/testdata/corpus/sql/pg_catalog/pg_constraint.test b/parser/testdata/corpus/sql/pg_catalog/pg_constraint.test new file mode 100644 index 0000000..68d9c1b --- /dev/null +++ b/parser/testdata/corpus/sql/pg_catalog/pg_constraint.test @@ -0,0 +1,29 @@ +# source: test/sql/pg_catalog/pg_constraint.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +SELECT * FROM pg_constraint +-- +ok +== +create table a (id int , primary key (id)); +-- +ok +== +create table b (id int , foreign_a int, foreign key (foreign_a) references a); +-- +ok +== +insert into a (id) values (0); +-- +ok +== +insert into b (id, foreign_a) VALUES (0, 0); +-- +ok +== +SELECT * EXCLUDE (OID, CONRELID, connamespace) FROM pg_catalog.pg_constraint +-- +ok +== diff --git a/parser/testdata/corpus/sql/pg_catalog/pg_database.test b/parser/testdata/corpus/sql/pg_catalog/pg_database.test new file mode 100644 index 0000000..06b6497 --- /dev/null +++ b/parser/testdata/corpus/sql/pg_catalog/pg_database.test @@ -0,0 +1,13 @@ +# source: test/sql/pg_catalog/pg_database.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +SELECT * FROM pg_database +-- +ok +== +SELECT * FROM pg_catalog.pg_database +-- +ok +== diff --git a/parser/testdata/corpus/sql/pg_catalog/pg_depend.test b/parser/testdata/corpus/sql/pg_catalog/pg_depend.test new file mode 100644 index 0000000..07f0fd9 --- /dev/null +++ b/parser/testdata/corpus/sql/pg_catalog/pg_depend.test @@ -0,0 +1,13 @@ +# source: test/sql/pg_catalog/pg_depend.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +SELECT * FROM pg_depend ORDER BY ALL +-- +ok +== +SELECT * FROM pg_catalog.pg_depend ORDER BY ALL +-- +ok +== diff --git a/parser/testdata/corpus/sql/pg_catalog/pg_enum.test b/parser/testdata/corpus/sql/pg_catalog/pg_enum.test new file mode 100644 index 0000000..e0d51b9 --- /dev/null +++ b/parser/testdata/corpus/sql/pg_catalog/pg_enum.test @@ -0,0 +1,13 @@ +# source: test/sql/pg_catalog/pg_enum.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +SELECT * FROM pg_enum +-- +ok +== +SELECT * FROM pg_catalog.pg_enum +-- +ok +== diff --git a/parser/testdata/corpus/sql/pg_catalog/pg_index.test b/parser/testdata/corpus/sql/pg_catalog/pg_index.test new file mode 100644 index 0000000..597c7a4 --- /dev/null +++ b/parser/testdata/corpus/sql/pg_catalog/pg_index.test @@ -0,0 +1,29 @@ +# source: test/sql/pg_catalog/pg_index.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +CREATE TABLE integers(i INTEGER, j INTEGER, k INTEGER) +-- +ok +== +CREATE INDEX i_index ON integers((j + 1), k) +-- +ok +== +SELECT * FROM pg_index +-- +ok +== +SELECT * FROM pg_catalog.pg_index +-- +ok +== +SELECT * FROM pg_indexes +-- +ok +== +SELECT * FROM pg_catalog.pg_indexes +-- +ok +== diff --git a/parser/testdata/corpus/sql/pg_catalog/pg_namespace.test b/parser/testdata/corpus/sql/pg_catalog/pg_namespace.test new file mode 100644 index 0000000..9fd5a15 --- /dev/null +++ b/parser/testdata/corpus/sql/pg_catalog/pg_namespace.test @@ -0,0 +1,37 @@ +# source: test/sql/pg_catalog/pg_namespace.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +SELECT COUNT(*) FROM pg_namespace WHERE nspname='myschema' +-- +ok +== +CREATE SCHEMA myschema +-- +ok +== +SELECT * FROM pg_namespace +-- +ok +== +SELECT * FROM pg_catalog.pg_namespace +-- +ok +== +SELECT * FROM pg_namespace WHERE nspname='myschema' +-- +ok +== +CREATE SCHEMA bla +-- +ok +== +CREATE SCHEMA test +-- +ok +== +CREATE SCHEMA myschema33 +-- +ok +== diff --git a/parser/testdata/corpus/sql/pg_catalog/pg_prepared_statements.test b/parser/testdata/corpus/sql/pg_catalog/pg_prepared_statements.test new file mode 100644 index 0000000..6d92632 --- /dev/null +++ b/parser/testdata/corpus/sql/pg_catalog/pg_prepared_statements.test @@ -0,0 +1,25 @@ +# source: test/sql/pg_catalog/pg_prepared_statements.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +prepare p1 as select 42; +-- +ok +== +prepare p2 as insert into tbl values ('test'); +-- +ok +== +prepare p3 as select 21, $1, $2 +-- +ok +== +prepare p4 as select $name, $other_name +-- +ok +== +select * from pg_prepared_statements order by name; +-- +ok +== diff --git a/parser/testdata/corpus/sql/pg_catalog/pg_privilege.test b/parser/testdata/corpus/sql/pg_catalog/pg_privilege.test new file mode 100644 index 0000000..bef666f --- /dev/null +++ b/parser/testdata/corpus/sql/pg_catalog/pg_privilege.test @@ -0,0 +1,17 @@ +# source: test/sql/pg_catalog/pg_privilege.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +SELECT {function}('main', 'test') +-- +error: Parser Error: syntax error at or near "}" +== +SELECT {function}(current_user, 'main', 'test') +-- +error: Parser Error: syntax error at or near "}" +== +SELECT has_column_privilege('main', 'test', 'col'), has_column_privilege(current_user, 'main', 'test', 'col') +-- +ok +== diff --git a/parser/testdata/corpus/sql/pg_catalog/pg_sequence.test b/parser/testdata/corpus/sql/pg_catalog/pg_sequence.test new file mode 100644 index 0000000..385d614 --- /dev/null +++ b/parser/testdata/corpus/sql/pg_catalog/pg_sequence.test @@ -0,0 +1,17 @@ +# source: test/sql/pg_catalog/pg_sequence.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +SELECT * FROM pg_sequence +-- +ok +== +SELECT * FROM pg_catalog.pg_sequence +-- +ok +== +SELECT seqstart, seqincrement, seqmax, seqmin, seqcycle FROM pg_sequence +-- +ok +== diff --git a/parser/testdata/corpus/sql/pg_catalog/pg_sequences.test b/parser/testdata/corpus/sql/pg_catalog/pg_sequences.test new file mode 100644 index 0000000..72b266d --- /dev/null +++ b/parser/testdata/corpus/sql/pg_catalog/pg_sequences.test @@ -0,0 +1,17 @@ +# source: test/sql/pg_catalog/pg_sequences.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +SELECT * FROM pg_sequences +-- +ok +== +SELECT * FROM pg_catalog.pg_sequences +-- +ok +== +SELECT sequencename, min_value, max_value, start_value, cycle FROM pg_sequences +-- +ok +== diff --git a/parser/testdata/corpus/sql/pg_catalog/pg_settings.test b/parser/testdata/corpus/sql/pg_catalog/pg_settings.test new file mode 100644 index 0000000..da0e723 --- /dev/null +++ b/parser/testdata/corpus/sql/pg_catalog/pg_settings.test @@ -0,0 +1,17 @@ +# source: test/sql/pg_catalog/pg_settings.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +SELECT * FROM pg_settings; +-- +ok +== +SELECT name, setting FROM pg_settings WHERE name='default_null_order'; +-- +ok +== +SET default_null_order='nulls_last' +-- +ok +== diff --git a/parser/testdata/corpus/sql/pg_catalog/pg_tablespace.test b/parser/testdata/corpus/sql/pg_catalog/pg_tablespace.test new file mode 100644 index 0000000..8c303e8 --- /dev/null +++ b/parser/testdata/corpus/sql/pg_catalog/pg_tablespace.test @@ -0,0 +1,13 @@ +# source: test/sql/pg_catalog/pg_tablespace.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +SELECT * FROM pg_tablespace +-- +ok +== +SELECT * FROM pg_catalog.pg_tablespace +-- +ok +== diff --git a/parser/testdata/corpus/sql/pg_catalog/pg_type.test b/parser/testdata/corpus/sql/pg_catalog/pg_type.test new file mode 100644 index 0000000..2478885 --- /dev/null +++ b/parser/testdata/corpus/sql/pg_catalog/pg_type.test @@ -0,0 +1,101 @@ +# source: test/sql/pg_catalog/pg_type.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +CREATE TYPE greeting AS ENUM('hi', 'bonjour', 'konnichiwa', 'howdy') +-- +ok +== +SELECT * FROM pg_type +-- +ok +== +SELECT * FROM pg_catalog.pg_type +-- +ok +== +SELECT oid FROM pg_type WHERE typname = 'int8' AND oid IS NOT NULL +-- +ok +== +SELECT oid FROM pg_type WHERE typname = 'bytea' AND oid IS NOT NULL +-- +ok +== +SELECT oid FROM pg_type WHERE typname = 'bit' AND oid IS NOT NULL +-- +ok +== +SELECT oid FROM pg_type WHERE typname = 'bool' AND oid IS NOT NULL +-- +ok +== +SELECT oid FROM pg_type WHERE typname = 'varchar' AND oid IS NOT NULL +-- +ok +== +SELECT oid FROM pg_type WHERE typname = 'date' AND oid IS NOT NULL +-- +ok +== +SELECT oid FROM pg_type WHERE typname = 'float8' AND oid IS NOT NULL +-- +ok +== +SELECT oid FROM pg_type WHERE typname = 'float4' AND oid IS NOT NULL +-- +ok +== +SELECT oid FROM pg_type WHERE typname = 'uuid' AND oid IS NOT NULL +-- +ok +== +SELECT oid FROM pg_type WHERE typname = 'int4' AND oid IS NOT NULL +-- +ok +== +SELECT oid FROM pg_type WHERE typname = 'int2' AND oid IS NOT NULL +-- +ok +== +SELECT oid FROM pg_type WHERE typname = 'interval' AND oid IS NOT NULL +-- +ok +== +SELECT oid FROM pg_type WHERE typname = 'time' AND oid IS NOT NULL +-- +ok +== +SELECT oid FROM pg_type WHERE typname = 'timestamp' AND oid IS NOT NULL +-- +ok +== +SELECT oid FROM pg_type WHERE typname = 'timestamptz' AND oid IS NOT NULL +-- +ok +== +SELECT oid FROM pg_type WHERE typname = 'timetz' AND oid IS NOT NULL +-- +ok +== +SELECT count(*) FROM pg_type where typname = 'greeting' +-- +ok +== +SELECT oid FROM pg_type WHERE typname = 'numeric' AND oid IS NOT NULL +-- +ok +== +SELECT count(*) FROM pg_type where typname = 'enum' AND oid is NOT NULL +-- +ok +== +SELECT pg_catalog.format_pg_type('DECIMAL', 'test'); +-- +ok +== +SELECT pg_catalog.format_pg_type('decimal', 'test'); +-- +ok +== diff --git a/parser/testdata/corpus/sql/pg_catalog/pg_views.test b/parser/testdata/corpus/sql/pg_catalog/pg_views.test new file mode 100644 index 0000000..0cecdcf --- /dev/null +++ b/parser/testdata/corpus/sql/pg_catalog/pg_views.test @@ -0,0 +1,17 @@ +# source: test/sql/pg_catalog/pg_views.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +SELECT * FROM pg_views +-- +ok +== +SELECT * FROM pg_catalog.pg_views +-- +ok +== +SELECT viewname, viewowner FROM pg_views WHERE viewname='v1' +-- +ok +== diff --git a/parser/testdata/corpus/sql/pg_catalog/sqlalchemy.test b/parser/testdata/corpus/sql/pg_catalog/sqlalchemy.test new file mode 100644 index 0000000..64bae43 --- /dev/null +++ b/parser/testdata/corpus/sql/pg_catalog/sqlalchemy.test @@ -0,0 +1,334 @@ +# source: test/sql/pg_catalog/sqlalchemy.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +CREATE TABLE integral_values ( + j smallint, + k integer, + l bigint, + i real, + z double precision, + m DECIMAL(4, 1), + n DECIMAL(9, 2), + o DECIMAL(18, 4), + p DECIMAL(37, 2), + q varchar, + r bytea, + s date, + t time, + u timestamp, + v date[], + w greeting +); +-- +ok +== +select distinct nspname from pg_namespace " "where lower(nspname)='main' +-- +ok +== +select relname from pg_class c join pg_namespace n on +n.oid=c.relnamespace where +pg_catalog.pg_table_is_visible(c.oid) +and relname='integral_values' +-- +ok +== +select relname from pg_class c join pg_namespace n on +n.oid=c.relnamespace where +pg_catalog.pg_table_is_visible(c.oid) +and relname='f' +-- +ok +== +select relname from pg_class c join pg_namespace n on +n.oid=c.relnamespace where n.nspname='main' and +relname='integral_values' +-- +ok +== +select relname from pg_class c join pg_namespace n on +n.oid=c.relnamespace where n.nspname='main' and +relname='f' +-- +ok +== +SELECT relname FROM pg_class c join pg_namespace n on +n.oid=c.relnamespace where relkind='S' and +n.nspname='main' and relname='seq' +-- +ok +== +SELECT relname FROM pg_class c join pg_namespace n on +n.oid=c.relnamespace where relkind='S' and +n.nspname='main' and relname='f' +-- +ok +== +SELECT EXISTS ( + SELECT * FROM pg_catalog.pg_type t, pg_catalog.pg_namespace n + WHERE t.typnamespace = n.oid + AND t.typname = 'integer' + AND n.nspname = 'main' + ) +-- +ok +== +SELECT EXISTS ( + SELECT * FROM pg_catalog.pg_type t, pg_catalog.pg_namespace n + WHERE t.typnamespace = n.oid + AND t.typname = 'int4' + AND n.nspname = 'main' + ) +-- +ok +== +SELECT COUNT(c.oid) +FROM pg_catalog.pg_class c +LEFT JOIN pg_catalog.pg_namespace n ON n.oid = c.relnamespace +WHERE (pg_catalog.pg_table_is_visible(c.oid)) +AND c.relname = 'integral_values' AND c.relkind in +('r', 'v', 'm', 'f', 'p') +-- +ok +== +SELECT nspname FROM pg_namespace +WHERE nspname NOT LIKE 'pg_%' +ORDER BY nspname +-- +ok +== +SELECT c.relname FROM pg_class c +JOIN pg_namespace n ON n.oid = c.relnamespace +WHERE n.nspname = 'main' AND c.relkind in ('r', 'p') +-- +ok +== +SELECT c.relname FROM pg_class c +JOIN pg_namespace n ON n.oid = c.relnamespace +WHERE n.nspname = 'main' AND c.relkind = 'f' +-- +ok +== +CREATE VIEW myschema.v1 AS SELECT 42; +-- +ok +== +SELECT c.relname FROM pg_class c +JOIN pg_namespace n ON n.oid = c.relnamespace +WHERE n.nspname = 'myschema' AND c.relkind IN ('v', 'm') +-- +ok +== +SELECT relname FROM pg_class c join pg_namespace n on +n.oid=c.relnamespace where relkind='S' and +n.nspname='main' +-- +ok +== +SELECT string_split_regex(pg_get_viewdef(c.oid), '\n')[1] view_def FROM pg_class c +JOIN pg_namespace n ON n.oid = c.relnamespace +WHERE n.nspname = 'myschema' AND c.relname = 'v1' +AND c.relkind IN ('v', 'm') +-- +ok +== +SELECT a.attname, + pg_catalog.format_type(a.atttypid, a.atttypmod), + ( + SELECT pg_catalog.pg_get_expr(d.adbin, d.adrelid) + FROM pg_catalog.pg_attrdef d + WHERE d.adrelid = a.attrelid AND d.adnum = a.attnum + AND a.atthasdef + ) AS DEFAULT, + a.attnotnull +FROM pg_catalog.pg_attribute a +LEFT JOIN pg_catalog.pg_description pgd ON ( + pgd.objoid = a.attrelid AND pgd.objsubid = a.attnum) +WHERE a.attrelid = (SELECT MIN(oid) FROM pg_class WHERE relname='integral_values') +AND a.attnum > 0 AND NOT a.attisdropped +ORDER BY a.attnum; +-- +ok +== +SELECT a.attname, + CASE WHEN (a.attcollation != 0 AND ( + SELECT t.typcollation + FROM pg_catalog.pg_type t + WHERE t.oid = a.atttypid + ) != a.attcollation) THEN ( + SELECT c.collname + FROM pg_catalog.pg_collation c + WHERE c.oid = a.attcollation + ) ELSE NULL END AS collation +FROM pg_catalog.pg_attribute a +WHERE a.attrelid = (SELECT MIN(oid) FROM pg_class WHERE relname='integral_values') +AND a.attnum > 0 AND NOT a.attisdropped +ORDER BY a.attnum; +-- +ok +== +SELECT a.attname +FROM + pg_class t + join pg_index ix on t.oid = ix.indrelid + join pg_attribute a + on t.oid=a.attrelid + WHERE + t.oid = (SELECT MIN(table_oid) FROM duckdb_tables) and ix.indisprimary = 't' +ORDER BY a.attnum +-- +ok +== +SELECT a.attname +FROM pg_attribute a JOIN ( + SELECT unnest(ix.indkey) attnum, + generate_subscripts(ix.indkey, 1) ord + FROM pg_index ix + WHERE ix.indrelid = (SELECT MIN(table_oid) FROM duckdb_tables) AND ix.indisprimary + ) k ON a.attnum=k.attnum +WHERE a.attrelid = (SELECT MIN(table_oid) FROM duckdb_tables) +ORDER BY k.ord +-- +ok +== +SELECT r.conname, + pg_catalog.pg_get_constraintdef(r.oid, true) as condef, + n.nspname as conschema +FROM pg_catalog.pg_constraint r, + pg_namespace n, + pg_class c +WHERE r.conrelid = (SELECT MIN(table_oid) FROM duckdb_tables) AND + r.contype = 'f' AND + c.oid = confrelid AND + n.oid = c.relnamespace +ORDER BY 1 +-- +ok +== +SELECT + cons.conname as name, + cons.conkey as key, + a.attnum as col_num, + a.attname as col_name +FROM + pg_catalog.pg_constraint cons + join pg_attribute a + on cons.conrelid = a.attrelid AND + a.attnum = ANY(cons.conkey) +WHERE + cons.conrelid = (SELECT MIN(table_oid) FROM duckdb_tables) AND + cons.contype = 'u' +-- +ok +== +SELECT + i.relname as relname, + ix.indisunique, ix.indexprs, ix.indpred, + a.attname, a.attnum, NULL, ix.indkey, + am.amname, + NULL as indnkeyatts +FROM + pg_class t + join pg_index ix on t.oid = ix.indrelid + join pg_class i on i.oid = ix.indexrelid + left outer join + pg_attribute a + on t.oid = a.attrelid + left outer join + pg_am am + on i.relam = am.oid +WHERE + t.relkind IN ('r', 'v', 'f', 'm') + and t.oid = (SELECT MIN(table_oid) FROM duckdb_tables) + and ix.indisprimary = 'f' +ORDER BY + t.relname, + i.relname +-- +ok +== +SELECT + i.relname as relname, + ix.indisunique, ix.indexprs, + a.attname, a.attnum, c.conrelid, ix.indkey::varchar, + ix.indoption::varchar, i.reloptions, am.amname, + pg_get_expr(ix.indpred, ix.indrelid) +FROM + pg_class t + join pg_index ix on t.oid = ix.indrelid + join pg_class i on i.oid = ix.indexrelid + left outer join + pg_attribute a + on t.oid = a.attrelid and a.attnum = ANY(ix.indkey) + left outer join + pg_constraint c + on (ix.indrelid = c.conrelid and + ix.indexrelid = c.conindid and + c.contype in ('p', 'u', 'x')) + left outer join + pg_am am + on i.relam = am.oid +WHERE + t.relkind IN ('r', 'v', 'f', 'm', 'p') + and t.oid = (SELECT MIN(table_oid) FROM duckdb_tables) + and ix.indisprimary = 'f' +ORDER BY + t.relname, + i.relname +-- +ok +== +SELECT + pgd.description as table_comment +FROM + pg_catalog.pg_description pgd +WHERE + pgd.objsubid = 0 AND + pgd.objoid = (SELECT MIN(table_oid) FROM duckdb_tables) +-- +ok +== +CREATE TABLE check_constraint_tbl ( + i INTEGER CHECK (i < 42) +); +-- +ok +== +SELECT + cons.conname as name, + pg_get_constraintdef(cons.oid) as src +FROM + pg_catalog.pg_constraint cons +WHERE + cons.contype = 'c' +-- +ok +== +SELECT t.typname as "name", + -- no enum defaults in 8.4 at least + -- t.typdefault as "default", + pg_catalog.pg_type_is_visible(t.oid) as "visible", + n.nspname as "schema", + e.enumlabel as "label" +FROM pg_catalog.pg_type t + LEFT JOIN pg_catalog.pg_namespace n ON n.oid = t.typnamespace + LEFT JOIN pg_catalog.pg_enum e ON t.oid = e.enumtypid +WHERE t.typtype = 'e' AND e.enumlabel IS NOT NULL +ORDER BY e.enumsortorder +-- +ok +== +SELECT t.typname as "name", + pg_catalog.format_type(t.typbasetype, t.typtypmod) as "attype", + not t.typnotnull as "nullable", + t.typdefault as "default", + pg_catalog.pg_type_is_visible(t.oid) as "visible", + n.nspname as "schema" +FROM pg_catalog.pg_type t + LEFT JOIN pg_catalog.pg_namespace n ON n.oid = t.typnamespace +WHERE t.typtype = 'd' +-- +ok +== diff --git a/parser/testdata/corpus/sql/pg_catalog/system_functions.test b/parser/testdata/corpus/sql/pg_catalog/system_functions.test new file mode 100644 index 0000000..8e3eb99 --- /dev/null +++ b/parser/testdata/corpus/sql/pg_catalog/system_functions.test @@ -0,0 +1,69 @@ +# source: test/sql/pg_catalog/system_functions.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +SELECT CURRENT_USER +-- +ok +== +SELECT CURRENT_CATALOG +-- +ok +== +SELECT CURRENT_DATABASE() +-- +ok +== +SELECT pg_catalog.CURRENT_DATABASE() +-- +ok +== +SELECT USER +-- +ok +== +SELECT SESSION_USER +-- +ok +== +SELECT version(); +-- +ok +== +SELECT pg_catalog.current_query(); +-- +ok +== +SELECT 1, 2, 3, current_query(); +-- +ok +== +SELECT inet_client_addr(), inet_client_port(), inet_server_addr(), inet_server_port(); +-- +ok +== +select pg_postmaster_start_time(); +-- +ok +== +SELECT pg_is_other_temp_schema(33) +-- +ok +== +SELECT col_description(0, 0), obj_description(0, 'duckdb'), shobj_description(0, 'duckdb'); +-- +ok +== +select txid_current(); +-- +ok +== +select pg_typeof(1); +-- +ok +== +SELECT temp.current_user() +-- +ok +== diff --git a/parser/testdata/corpus/sql/pivot/optional_pivots.test b/parser/testdata/corpus/sql/pivot/optional_pivots.test new file mode 100644 index 0000000..1daaff8 --- /dev/null +++ b/parser/testdata/corpus/sql/pivot/optional_pivots.test @@ -0,0 +1,61 @@ +# source: test/sql/pivot/optional_pivots.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +CREATE TABLE Cities(Country VARCHAR, Name VARCHAR, Year INT, Population INT); +-- +ok +== +INSERT INTO Cities VALUES ('NL', 'Amsterdam', 2000, 1005); +-- +ok +== +INSERT INTO Cities VALUES ('NL', 'Amsterdam', 2010, 1065); +-- +ok +== +INSERT INTO Cities VALUES ('NL', 'Amsterdam', 2020, 1158); +-- +ok +== +INSERT INTO Cities VALUES ('US', 'Seattle', 2000, 564); +-- +ok +== +INSERT INTO Cities VALUES ('US', 'Seattle', 2010, 608); +-- +ok +== +INSERT INTO Cities VALUES ('US', 'Seattle', 2020, 738); +-- +ok +== +INSERT INTO Cities VALUES ('US', 'New York City', 2000, 8015); +-- +ok +== +INSERT INTO Cities VALUES ('US', 'New York City', 2010, 8175); +-- +ok +== +PIVOT Cities USING SUM(Population); +-- +ok +== +PIVOT Cities USING SUM(Population) GROUP BY Country; +-- +ok +== +PIVOT Cities GROUP BY Country; +-- +ok +== +PIVOT Cities ON Year GROUP BY Country; +-- +ok +== +PIVOT (SELECT Country, Year FROM Cities) ON Year; +-- +ok +== diff --git a/parser/testdata/corpus/sql/pivot/pivot_15141.test b/parser/testdata/corpus/sql/pivot/pivot_15141.test new file mode 100644 index 0000000..e24e581 --- /dev/null +++ b/parser/testdata/corpus/sql/pivot/pivot_15141.test @@ -0,0 +1,25 @@ +# source: test/sql/pivot/pivot_15141.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +create table p (col1 timestamp, col2 int); +-- +ok +== +INSERT INTO p VALUES + ('2024-12-04 09:30:01', 100), + ('2024-12-04 09:30:02', 100), + ('2024-12-04 09:30:03', 100), + ('2024-12-04 09:30:04', 100), + ('2024-12-04 09:30:05', 100), + ('2024-12-04 09:30:06', 100), + ('2024-12-04 09:30:07', 100), + ('2024-12-04 09:30:08', 100); +-- +ok +== +pivot p using sum (col2) group by col1 order by col1; +-- +ok +== diff --git a/parser/testdata/corpus/sql/pivot/pivot_6390.test b/parser/testdata/corpus/sql/pivot/pivot_6390.test new file mode 100644 index 0000000..9282d2d --- /dev/null +++ b/parser/testdata/corpus/sql/pivot/pivot_6390.test @@ -0,0 +1,204 @@ +# source: test/sql/pivot/pivot_6390.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +CREATE TABLE cpb_tbl AS +WITH CPB(CPDH,NF,JG) AS ( +SELECT 'C1',2022,10 +UNION ALL +SELECT 'C1',2018,20 +UNION ALL +SELECT 'C1',2017,0 +UNION ALL +SELECT 'C2',2022,10 +UNION ALL +SELECT 'C2',2010,30 +UNION ALL +SELECT 'C3',2010,80 +) FROM CPB; +-- +ok +== +pivot cpb_tbl on nf using sum(jg)group by cpdh +-- +ok +== +WITH CPB(CPDH,NF,JG) AS ( +SELECT 'C1',2022,10 +UNION ALL +SELECT 'C1',2018,20 +UNION ALL +SELECT 'C1',2017,0 +UNION ALL +SELECT 'C2',2022,10 +UNION ALL +SELECT 'C2',2010,30 +UNION ALL +SELECT 'C3',2010,80 +) +pivot CPB on nf IN (2010, 2017, 2018, 2022) using sum(jg)group by cpdh +-- +ok +== +WITH CPB(CPDH,NF,JG) AS ( +SELECT 'C1',2022,10 +UNION ALL +SELECT 'C1',2018,20 +UNION ALL +SELECT 'C1',2017,0 +UNION ALL +SELECT 'C2',2022,10 +UNION ALL +SELECT 'C2',2010,30 +UNION ALL +SELECT 'C3',2010,80 +) +pivot CPB on nf using sum(jg)group by cpdh +-- +ok +== +WITH CPB(CPDH,NF,JG) AS ( +SELECT 'C1',2022,10 +UNION ALL +SELECT 'C1',2018,20 +UNION ALL +SELECT 'C1',2017,0 +UNION ALL +SELECT 'C2',2022,10 +UNION ALL +SELECT 'C2',2010,30 +UNION ALL +SELECT 'C3',2010,80 +) +SELECT * +FROM (pivot CPB on nf using sum(jg)group by cpdh) +-- +ok +== +WITH CPB(CPDH,NF,JG) AS ( +SELECT 'C1',2022,10 +UNION ALL +SELECT 'C1',2018,20 +UNION ALL +SELECT 'C1',2017,0 +UNION ALL +SELECT 'C2',2022,10 +UNION ALL +SELECT 'C2',2010,30 +UNION ALL +SELECT 'C3',2010,80 +) +from CPB pivot (sum(jg) for nf in (2010, 2017, 2018, 2022) group by cpdh) +-- +ok +== +WITH CPB AS (SELECT 42) +SELECT * +FROM ( + WITH CPB(CPDH,NF,JG) AS ( + SELECT 'C1',2022,10 + UNION ALL + SELECT 'C1',2018,20 + UNION ALL + SELECT 'C1',2017,0 + UNION ALL + SELECT 'C2',2022,10 + UNION ALL + SELECT 'C2',2010,30 + UNION ALL + SELECT 'C3',2010,80 + ) + pivot CPB on nf using sum(jg) group by cpdh) +-- +ok +== +WITH CPB(CPDH,NF,JG) AS MATERIALIZED ( +SELECT 'C1',2022,10 +UNION ALL +SELECT 'C1',2018,20 +UNION ALL +SELECT 'C1',2017,0 +UNION ALL +SELECT 'C2',2022,10 +UNION ALL +SELECT 'C2',2010,30 +UNION ALL +SELECT 'C3',2010,80 +) +pivot CPB on nf IN (2010, 2017, 2018, 2022) using sum(jg)group by cpdh +-- +ok +== +WITH CPB(CPDH,NF,JG) AS MATERIALIZED ( +SELECT 'C1',2022,10 +UNION ALL +SELECT 'C1',2018,20 +UNION ALL +SELECT 'C1',2017,0 +UNION ALL +SELECT 'C2',2022,10 +UNION ALL +SELECT 'C2',2010,30 +UNION ALL +SELECT 'C3',2010,80 +) +pivot CPB on nf using sum(jg)group by cpdh +-- +ok +== +WITH CPB(CPDH,NF,JG) AS MATERIALIZED ( +SELECT 'C1',2022,10 +UNION ALL +SELECT 'C1',2018,20 +UNION ALL +SELECT 'C1',2017,0 +UNION ALL +SELECT 'C2',2022,10 +UNION ALL +SELECT 'C2',2010,30 +UNION ALL +SELECT 'C3',2010,80 +) +SELECT * +FROM (pivot CPB on nf using sum(jg)group by cpdh) +-- +ok +== +WITH CPB(CPDH,NF,JG) AS MATERIALIZED ( +SELECT 'C1',2022,10 +UNION ALL +SELECT 'C1',2018,20 +UNION ALL +SELECT 'C1',2017,0 +UNION ALL +SELECT 'C2',2022,10 +UNION ALL +SELECT 'C2',2010,30 +UNION ALL +SELECT 'C3',2010,80 +) +from CPB pivot (sum(jg) for nf in (2010, 2017, 2018, 2022) group by cpdh) +-- +ok +== +WITH CPB AS (SELECT 42) +SELECT * +FROM ( + WITH CPB(CPDH,NF,JG) AS MATERIALIZED ( + SELECT 'C1',2022,10 + UNION ALL + SELECT 'C1',2018,20 + UNION ALL + SELECT 'C1',2017,0 + UNION ALL + SELECT 'C2',2022,10 + UNION ALL + SELECT 'C2',2010,30 + UNION ALL + SELECT 'C3',2010,80 + ) + pivot CPB on nf using sum(jg) group by cpdh) +-- +ok +== diff --git a/parser/testdata/corpus/sql/pivot/pivot_bigquery.test b/parser/testdata/corpus/sql/pivot/pivot_bigquery.test new file mode 100644 index 0000000..33fd86a --- /dev/null +++ b/parser/testdata/corpus/sql/pivot/pivot_bigquery.test @@ -0,0 +1,72 @@ +# source: test/sql/pivot/pivot_bigquery.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +CREATE TABLE Produce AS + SELECT 'Kale' as product, 51 as sales, 'Q1' as quarter, 2020 as year UNION ALL + SELECT 'Kale', 23, 'Q2', 2020 UNION ALL + SELECT 'Kale', 45, 'Q3', 2020 UNION ALL + SELECT 'Kale', 3, 'Q4', 2020 UNION ALL + SELECT 'Kale', 70, 'Q1', 2021 UNION ALL + SELECT 'Kale', 85, 'Q2', 2021 UNION ALL + SELECT 'Apple', 77, 'Q1', 2020 UNION ALL + SELECT 'Apple', 0, 'Q2', 2020 UNION ALL + SELECT 'Apple', 1, 'Q1', 2021 +-- +ok +== +SELECT * FROM Produce +PIVOT(SUM(sales) FOR quarter IN ('Q1', 'Q2', 'Q3', 'Q4')) +ORDER BY ALL +-- +ok +== +SELECT * FROM + (SELECT product, sales, quarter FROM Produce) + PIVOT(SUM(sales) FOR quarter IN ('Q1', 'Q2', 'Q3', 'Q4')) +ORDER BY ALL +-- +ok +== +SELECT * FROM + (SELECT product, sales, quarter FROM Produce) + PIVOT(SUM(sales) FOR quarter IN ('Q1', 'Q2', 'Q3')) + ORDER BY ALL +-- +ok +== +SELECT * FROM + (SELECT sales, quarter FROM Produce) + PIVOT(SUM(sales) FOR quarter IN ('Q1', 'Q2', 'Q3')) + ORDER BY ALL +-- +ok +== +SELECT * FROM + (SELECT product, sales, quarter FROM Produce) + PIVOT(SUM(sales) total_sales, COUNT(*) num_records FOR quarter IN ('Q1', 'Q2')) +ORDER BY ALL +-- +ok +== +CREATE OR REPLACE TABLE Produce AS + SELECT 'Kale' as product, 51 as Q1, 23 as Q2, 45 as Q3, 3 as Q4 UNION ALL + SELECT 'Apple', 77, 0, 25, 2 +-- +ok +== +SELECT * FROM Produce +UNPIVOT(sales FOR quarter IN (Q1, Q2, Q3, Q4)) +ORDER BY ALL +-- +ok +== +SELECT product, first_half_sales, second_half_sales, semesters FROM Produce +UNPIVOT( + (first_half_sales, second_half_sales) + FOR semesters + IN ((Q1, Q2) AS 'semester_1', (Q3, Q4) AS 'semester_2')) +-- +ok +== diff --git a/parser/testdata/corpus/sql/pivot/pivot_case_insensitive.test b/parser/testdata/corpus/sql/pivot/pivot_case_insensitive.test new file mode 100644 index 0000000..064c67d --- /dev/null +++ b/parser/testdata/corpus/sql/pivot/pivot_case_insensitive.test @@ -0,0 +1,33 @@ +# source: test/sql/pivot/pivot_case_insensitive.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +CREATE TABLE Cities (Name VARCHAR, id INTEGER); +INSERT INTO Cities VALUES ('Test', 1); +INSERT INTO Cities VALUES ('test',2); +-- +ok +== +SET pivot_filter_threshold=1; +-- +ok +== +FROM Cities +PIVOT ( + array_agg(id) + FOR + name IN ('test','Test') +); +-- +ok +== +FROM Cities +PIVOT ( + array_agg(id), sum(id) + FOR + name IN ('test','Test') +); +-- +ok +== diff --git a/parser/testdata/corpus/sql/pivot/pivot_databricks.test b/parser/testdata/corpus/sql/pivot/pivot_databricks.test new file mode 100644 index 0000000..b140f94 --- /dev/null +++ b/parser/testdata/corpus/sql/pivot/pivot_databricks.test @@ -0,0 +1,124 @@ +# source: test/sql/pivot/pivot_databricks.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +CREATE TEMP VIEW sales(year, quarter, region, sales) AS + VALUES (2018, 1, 'east', 100), + (2018, 2, 'east', 20), + (2018, 3, 'east', 40), + (2018, 4, 'east', 40), + (2019, 1, 'east', 120), + (2019, 2, 'east', 110), + (2019, 3, 'east', 80), + (2019, 4, 'east', 60), + (2018, 1, 'west', 105), + (2018, 2, 'west', 25), + (2018, 3, 'west', 45), + (2018, 4, 'west', 45), + (2019, 1, 'west', 125), + (2019, 2, 'west', 115), + (2019, 3, 'west', 85), + (2019, 4, 'west', 65); +-- +ok +== +SELECT year, region, q1, q2, q3, q4 + FROM sales + PIVOT (sum(sales) + FOR quarter + IN (1 AS q1, 2 AS q2, 3 AS q3, 4 AS q4)); +-- +ok +== +SELECT year, q1_east, q1_west, q2_east, q2_west, q3_east, q3_west, q4_east, q4_west + FROM sales + PIVOT (sum(sales) + FOR (quarter, region) + IN ((1, 'east') AS q1_east, (1, 'west') AS q1_west, (2, 'east') AS q2_east, (2, 'west') AS q2_west, + (3, 'east') AS q3_east, (3, 'west') AS q3_west, (4, 'east') AS q4_east, (4, 'west') AS q4_west)); +-- +ok +== +SELECT year, q1_east, q1_west, q2_east, q2_west, q3_east, q3_west, q4_east, q4_west + FROM sales + PIVOT (sum(sales) + FOR (quarter, region, too_many_names) + IN ((1, 'east') AS q1_east, (1, 'west') AS q1_west, (2, 'east') AS q2_east, (2, 'west') AS q2_west, + (3, 'east') AS q3_east, (3, 'west') AS q3_west, (4, 'east') AS q4_east, (4, 'west') AS q4_west)); +-- +ok +== +SELECT year, q1_east, q1_west, q2_east, q2_west, q3_east, q3_west, q4_east, q4_west + FROM sales + PIVOT (sum(sales) + FOR (quarter, region) + IN ((1, 'east', 'west') AS q1_east, (1, 'west') AS q1_west, (2, 'east') AS q2_east, (2, 'west') AS q2_west, + (3, 'east') AS q3_east, (3, 'west') AS q3_west, (4, 'east') AS q4_east, (4, 'west') AS q4_west)); +-- +ok +== +SELECT * + FROM sales + PIVOT (sum(sales) + FOR (quarter, region) + IN ((1, 'east') AS q1_east, (1, 'east') AS q1_east_2)); +-- +ok +== +SELECT year, q1, q2, q3, q4 + FROM (SELECT year, quarter, sales FROM sales) AS s + PIVOT (sum(sales) + FOR quarter + IN (1 AS q1, 2 AS q2, 3 AS q3, 4 AS q4)); +-- +ok +== +SELECT year, q1_total, q1_avg, q2_total, q2_avg, q3_total, q3_avg, q4_total, q4_avg + FROM (SELECT year, quarter, sales FROM sales) AS s + PIVOT (sum(sales) AS total, avg(sales) AS avg + FOR quarter + IN (1 AS q1, 2 AS q2, 3 AS q3, 4 AS q4)); +-- +ok +== +SELECT * + FROM (SELECT year, quarter, sales FROM sales) AS s + PIVOT (sum(sales), avg(sales) + FOR quarter + IN (1 AS q1, 2 AS q2, 3 AS q3, 4 AS q4)); +-- +ok +== +CREATE OR REPLACE TEMPORARY VIEW sales(location, year, q1, q2, q3, q4) AS + VALUES ('Toronto' , 2020, 100 , 80 , 70, 150), + ('San Francisco', 2020, NULL, 20 , 50, 60), + ('Toronto' , 2021, 110 , 90 , 80, 170), + ('San Francisco', 2021, 70 , 120, 85, 105); +-- +ok +== +SELECT * + FROM sales UNPIVOT INCLUDE NULLS + (sales FOR quarter IN (q1 AS "Jan-Mar", + q2 AS "Apr-Jun", + q3 AS "Jul-Sep", + q4 AS "Oct-Dec")); +-- +ok +== +CREATE OR REPLACE TEMPORARY VIEW oncall + (year, week, area , name1 , email1 , phone1 , name2 , email2 , phone2) AS + VALUES (2022, 1 , 'frontend', 'Freddy', 'fred@alwaysup.org' , 15551234567, 'Fanny' , 'fanny@lwaysup.org' , 15552345678), + (2022, 1 , 'backend' , 'Boris' , 'boris@alwaysup.org', 15553456789, 'Boomer', 'boomer@lwaysup.org', 15554567890), + (2022, 2 , 'frontend', 'Franky', 'frank@lwaysup.org' , 15555678901, 'Fin' , 'fin@alwaysup.org' , 15556789012), + (2022, 2 , 'backend' , 'Bonny' , 'bonny@alwaysup.org', 15557890123, 'Bea' , 'bea@alwaysup.org' , 15558901234); +-- +ok +== +SELECT * + FROM oncall UNPIVOT ((name, email, phone) FOR precedence IN ((name1, email1, phone1) AS primary, + (name2, email2, phone2) AS secondary)); +-- +ok +== diff --git a/parser/testdata/corpus/sql/pivot/pivot_empty.test b/parser/testdata/corpus/sql/pivot/pivot_empty.test new file mode 100644 index 0000000..dffa150 --- /dev/null +++ b/parser/testdata/corpus/sql/pivot/pivot_empty.test @@ -0,0 +1,25 @@ +# source: test/sql/pivot/pivot_empty.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +PIVOT Cities ON Country USING SUM(Population); +-- +ok +== +PIVOT Cities ON Country, Name USING SUM(Population); +-- +ok +== +PIVOT Cities ON Country IN ('xx') USING SUM(Population); +-- +ok +== +PIVOT Cities ON (Country, Name) IN ('xx') USING SUM(Population); +-- +ok +== +PIVOT Cities ON Country IN ('xx', 'yy') USING SUM(Population); +-- +ok +== diff --git a/parser/testdata/corpus/sql/pivot/pivot_enum.test b/parser/testdata/corpus/sql/pivot/pivot_enum.test new file mode 100644 index 0000000..b20b1a4 --- /dev/null +++ b/parser/testdata/corpus/sql/pivot/pivot_enum.test @@ -0,0 +1,62 @@ +# source: test/sql/pivot/pivot_enum.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +CREATE OR REPLACE TABLE monthly_sales(empid INT, amount INT, month TEXT); +-- +ok +== +INSERT INTO monthly_sales VALUES + (1, 10000, 'JAN'), + (1, 400, 'JAN'), + (2, 4500, 'JAN'), + (2, 35000, 'JAN'), + (1, 5000, 'FEB'), + (1, 3000, 'FEB'), + (2, 200, 'FEB'), + (2, 90500, 'FEB'), + (1, 6000, 'MAR'), + (1, 5000, 'MAR'), + (2, 2500, 'MAR'), + (2, 9500, 'MAR'), + (1, 8000, 'APR'), + (1, 10000, 'APR'), + (2, 800, 'APR'), + (2, 4500, 'APR'); +-- +ok +== +CREATE TYPE unique_months AS ENUM (SELECT DISTINCT month FROM monthly_sales ORDER BY + CASE month WHEN 'JAN' THEN 1 WHEN 'FEB' THEN 2 WHEN 'MAR' THEN 3 ELSE 4 END); +-- +ok +== +SELECT * + FROM monthly_sales + PIVOT(SUM(amount) FOR MONTH IN unique_months) + AS p + ORDER BY EMPID; +-- +ok +== +SELECT * + FROM monthly_sales + PIVOT(SUM(amount) FOR MONTH IN unique_monthsx) + AS p + ORDER BY EMPID; +-- +ok +== +CREATE TYPE not_an_enum AS VARCHAR; +-- +ok +== +SELECT * + FROM monthly_sales + PIVOT(SUM(amount) FOR MONTH IN not_an_enum) + AS p + ORDER BY EMPID; +-- +ok +== diff --git a/parser/testdata/corpus/sql/pivot/pivot_errors.test b/parser/testdata/corpus/sql/pivot/pivot_errors.test new file mode 100644 index 0000000..3df2115 --- /dev/null +++ b/parser/testdata/corpus/sql/pivot/pivot_errors.test @@ -0,0 +1,33 @@ +# source: test/sql/pivot/pivot_errors.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +CREATE TABLE test(i INT, j VARCHAR); +-- +ok +== +PIVOT test ON j IN ('a', 'b') USING SUM(test.i); +-- +ok +== +PIVOT test ON j IN ('a', 'b') USING get_current_timestamp(); +-- +ok +== +SET pivot_filter_threshold=100 +-- +ok +== +PIVOT test ON j IN ('a', 'b') USING sum(41) over (); +-- +ok +== +PIVOT test ON j IN ('a', 'b') USING sum(sum(41) over ()); +-- +ok +== +FROM tbl PIVOT (c FOR IN enum_val); +-- +error: Parser Error: syntax error at or near "IN" +== diff --git a/parser/testdata/corpus/sql/pivot/pivot_expressions.test b/parser/testdata/corpus/sql/pivot/pivot_expressions.test new file mode 100644 index 0000000..8456731 --- /dev/null +++ b/parser/testdata/corpus/sql/pivot/pivot_expressions.test @@ -0,0 +1,53 @@ +# source: test/sql/pivot/pivot_expressions.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +PIVOT Cities ON Country || '_' || Name USING SUM(Population) GROUP BY Year; +-- +ok +== +PIVOT Cities ON (CASE WHEN Country='NL' THEN NULL ELSE Country END) USING SUM(Population) GROUP BY Year; +-- +ok +== +PIVOT Cities ON Country || '_' || Name USING COALESCE(SUM(Population), 0) GROUP BY Year; +-- +ok +== +PIVOT Cities ON Country || '_' || Name USING SUM(Population)::VARCHAR GROUP BY Year; +-- +ok +== +PIVOT Cities ON Country || '_' || Name USING SUM(Population) + 42 GROUP BY Year; +-- +ok +== +PIVOT Cities ON Country || '_' || Name USING SUM(Population) + COUNT(*) GROUP BY Year; +-- +ok +== +PIVOT Cities ON Country || '_' || Name USING SUM(Population) + Population GROUP BY Year; +-- +ok +== +PIVOT Cities ON min(Country) over () USING SUM(Population) GROUP BY Year; +-- +ok +== +PIVOT Cities ON min(Country) USING SUM(Population) GROUP BY Year; +-- +ok +== +PIVOT Cities ON NULL USING SUM(Population) GROUP BY Year; +-- +error: Parser Error: Cannot pivot on constant value "NULL" +== +PIVOT Cities ON 'hello world' USING SUM(Population) GROUP BY Year; +-- +error: Parser Error: Cannot pivot on constant value "'hello world'" +== +PIVOT Cities ON (SELECT COUNTRY) USING SUM(Population) GROUP BY Year; +-- +error: Parser Error: Cannot pivot on subquery "(SELECT COUNTRY)" +== diff --git a/parser/testdata/corpus/sql/pivot/pivot_expressions.test.metadata.json b/parser/testdata/corpus/sql/pivot/pivot_expressions.test.metadata.json new file mode 100644 index 0000000..1baae07 --- /dev/null +++ b/parser/testdata/corpus/sql/pivot/pivot_expressions.test.metadata.json @@ -0,0 +1,7 @@ +{ + "todo": { + "114998ed400809b2": "transformer-raised parser error: upstream rejects in the transformer, not the grammar; expected to clear as transformers land (milestones 3-5)", + "85d4bdf17dda06a9": "transformer-raised parser error: upstream rejects in the transformer, not the grammar; expected to clear as transformers land (milestones 3-5)", + "feaf1903116b5ee0": "transformer-raised parser error: upstream rejects in the transformer, not the grammar; expected to clear as transformers land (milestones 3-5)" + } +} diff --git a/parser/testdata/corpus/sql/pivot/pivot_generated.test b/parser/testdata/corpus/sql/pivot/pivot_generated.test new file mode 100644 index 0000000..7daaa85 --- /dev/null +++ b/parser/testdata/corpus/sql/pivot/pivot_generated.test @@ -0,0 +1,28 @@ +# source: test/sql/pivot/pivot_generated.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +CREATE TABLE Product(DaysToManufacture int, StandardCost int GENERATED ALWAYS AS (DaysToManufacture * 5)); +-- +ok +== +INSERT INTO Product VALUES (0), (1), (2), (4); +-- +ok +== +SELECT 'AverageCost' AS Cost_Sorted_By_Production_Days, + "0", "1", "2", "3", "4" +FROM +( + SELECT DaysToManufacture, StandardCost + FROM Product +) AS SourceTable +PIVOT +( + AVG(StandardCost) + FOR DaysToManufacture IN (0, 1, 2, 3, 4) +) AS PivotTable; +-- +ok +== diff --git a/parser/testdata/corpus/sql/pivot/pivot_in_boolean.test b/parser/testdata/corpus/sql/pivot/pivot_in_boolean.test new file mode 100644 index 0000000..041b9de --- /dev/null +++ b/parser/testdata/corpus/sql/pivot/pivot_in_boolean.test @@ -0,0 +1,13 @@ +# source: test/sql/pivot/pivot_in_boolean.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +pivot cities on (Country='NL') using avg(Population) group by name; +-- +ok +== +pivot cities on (Country='NL') in (false, true) using avg(Population) group by name; +-- +ok +== diff --git a/parser/testdata/corpus/sql/pivot/pivot_in_subquery.test b/parser/testdata/corpus/sql/pivot/pivot_in_subquery.test new file mode 100644 index 0000000..baf87bd --- /dev/null +++ b/parser/testdata/corpus/sql/pivot/pivot_in_subquery.test @@ -0,0 +1,21 @@ +# source: test/sql/pivot/pivot_in_subquery.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +PIVOT Cities ON Year IN (SELECT Year FROM Cities ORDER BY Year DESC) USING SUM(Population); +-- +ok +== +PIVOT Cities ON Year IN (SELECT YEAR FROM (SELECT Year, SUM(POPULATION) AS popsum FROM Cities GROUP BY Year ORDER BY popsum DESC)) USING SUM(Population); +-- +ok +== +PIVOT Cities ON Year IN (SELECT '2010' UNION ALL SELECT '2000' UNION ALL SELECT '2020') USING SUM(Population); +-- +ok +== +PIVOT Cities ON Year IN (SELECT xx FROM Cities) USING SUM(Population); +-- +ok +== diff --git a/parser/testdata/corpus/sql/pivot/pivot_operator_expression.test b/parser/testdata/corpus/sql/pivot/pivot_operator_expression.test new file mode 100644 index 0000000..cf6c902 --- /dev/null +++ b/parser/testdata/corpus/sql/pivot/pivot_operator_expression.test @@ -0,0 +1,31 @@ +# source: test/sql/pivot/pivot_operator_expression.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +INSERT INTO monthly_sales VALUES + (1, 10000, '1-JAN'), + (1, 400, '1-JAN'), + (2, 4500, '1-JAN'), + (2, 35000, '1-JAN'), + (1, 5000, '2-FEB'), + (1, 3000, '2-FEB'), + (2, 200, '2-FEB'), + (2, 90500, '2-FEB'), + (2, 2500, '3-MAR'), + (2, 9500, '3-MAR'), + (1, 8000, '4-APR'), + (1, 10000, '4-APR'), + (2, 800, '4-APR'), + (2, 4500, '4-APR'); +-- +ok +== +PIVOT monthly_sales ON MONTH USING COALESCE(SUM(AMOUNT), 0) +-- +ok +== +SELECT mode(column_type) FROM (DESCRIBE PIVOT monthly_sales ON MONTH USING SUM(AMOUNT)::INTEGER) +-- +ok +== diff --git a/parser/testdata/corpus/sql/pivot/pivot_prepare.test b/parser/testdata/corpus/sql/pivot/pivot_prepare.test new file mode 100644 index 0000000..4d3ea66 --- /dev/null +++ b/parser/testdata/corpus/sql/pivot/pivot_prepare.test @@ -0,0 +1,43 @@ +# source: test/sql/pivot/pivot_prepare.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +INSERT INTO monthly_sales VALUES + (1, 10000, '1-JAN'), + (1, 400, '1-JAN'), + (2, 4500, '1-JAN'), + (2, 35000, '1-JAN'), + (1, 5000, '2-FEB'), + (1, 3000, '2-FEB'), + (2, 200, '2-FEB'), + (2, 90500, '2-FEB'), + (1, 6000, '3-MAR'), + (1, 5000, '3-MAR'), + (2, 2500, '3-MAR'), + (2, 9500, '3-MAR'), + (1, 8000, '4-APR'), + (1, 10000, '4-APR'), + (2, 800, '4-APR'), + (2, 4500, '4-APR'); +-- +ok +== +PREPARE v1 AS SELECT * + FROM monthly_sales + PIVOT(SUM(amount + ?) FOR MONTH IN ('1-JAN', '2-FEB', '3-MAR', '4-APR')) + AS p + ORDER BY EMPID; +-- +ok +== +PREPARE v2 AS + PIVOT monthly_sales ON MONTH USING SUM(AMOUNT + ?) +-- +ok +== +PREPARE v3 AS + PIVOT (SELECT empid, amount + ? AS amount, month FROM monthly_sales) ON MONTH USING SUM(AMOUNT) +-- +error: Parser Error: PIVOT statements with pivot elements extracted from the data cannot have parameters in their source. +== diff --git a/parser/testdata/corpus/sql/pivot/pivot_prepare.test.metadata.json b/parser/testdata/corpus/sql/pivot/pivot_prepare.test.metadata.json new file mode 100644 index 0000000..cbf25fb --- /dev/null +++ b/parser/testdata/corpus/sql/pivot/pivot_prepare.test.metadata.json @@ -0,0 +1,5 @@ +{ + "todo": { + "e88aadafc6ebda1f": "transformer-raised parser error: upstream rejects in the transformer, not the grammar; expected to clear as transformers land (milestones 3-5)" + } +} diff --git a/parser/testdata/corpus/sql/pivot/pivot_query_text.test b/parser/testdata/corpus/sql/pivot/pivot_query_text.test new file mode 100644 index 0000000..b9c8969 --- /dev/null +++ b/parser/testdata/corpus/sql/pivot/pivot_query_text.test @@ -0,0 +1,25 @@ +# source: test/sql/pivot/pivot_query_text.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +CREATE TABLE t(c VARCHAR, v INTEGER); +-- +ok +== +INSERT INTO t VALUES ('a', 1), ('b', 2); +-- +ok +== +CREATE TABLE captured AS +PIVOT (SELECT c, v, current_query() AS q FROM t) ON c USING ANY_VALUE(q) ORDER BY v; +-- +ok +== +SELECT v, + regexp_replace(a, '__pivot_enum_[0-9a-f\-]+', '__pivot_enum_X') AS a, + regexp_replace(b, '__pivot_enum_[0-9a-f\-]+', '__pivot_enum_X') AS b +FROM captured ORDER BY v; +-- +ok +== diff --git a/parser/testdata/corpus/sql/pivot/pivot_star.test b/parser/testdata/corpus/sql/pivot/pivot_star.test new file mode 100644 index 0000000..3489ba0 --- /dev/null +++ b/parser/testdata/corpus/sql/pivot/pivot_star.test @@ -0,0 +1,21 @@ +# source: test/sql/pivot/pivot_star.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +CREATE TABLE t(id INT, jan INT, feb INT); +-- +ok +== +CREATE VIEW poison_view AS SELECT * FROM t UNPIVOT (val FOR col IN (*)); +-- +ok +== +CREATE VIEW expr_view AS SELECT * FROM t UNPIVOT (val FOR col IN (1+2+id)); +-- +ok +== +CREATE VIEW v AS PIVOT t ON id IN (CASE WHEN true THEN 'a' END) USING (SUM(feb)) +-- +ok +== diff --git a/parser/testdata/corpus/sql/pivot/pivot_storage.test b/parser/testdata/corpus/sql/pivot/pivot_storage.test new file mode 100644 index 0000000..669fdc5 --- /dev/null +++ b/parser/testdata/corpus/sql/pivot/pivot_storage.test @@ -0,0 +1,30 @@ +# source: test/sql/pivot/pivot_storage.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +CREATE VIEW v1 AS SELECT * + FROM monthly_sales + PIVOT(SUM(amount) FOR MONTH IN ('JAN', 'FEB', 'MAR', 'APR')) + AS p + ORDER BY EMPID; +-- +ok +== +CREATE MACRO pivot_macro(val) +as TABLE SELECT * + FROM monthly_sales + PIVOT(SUM(amount + val) FOR MONTH IN ('JAN', 'FEB', 'MAR', 'APR')) + AS p + ORDER BY EMPID; +-- +ok +== +FROM v1; +-- +ok +== +FROM pivot_macro(1); +-- +ok +== diff --git a/parser/testdata/corpus/sql/pivot/pivot_struct_aggregate.test b/parser/testdata/corpus/sql/pivot/pivot_struct_aggregate.test new file mode 100644 index 0000000..914c92b --- /dev/null +++ b/parser/testdata/corpus/sql/pivot/pivot_struct_aggregate.test @@ -0,0 +1,13 @@ +# source: test/sql/pivot/pivot_struct_aggregate.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +create table donnees_csv as select {'year': i::varchar, 'month': i::varchar} AS donnee, i%5 as variable_id, i%10 id_niv from range(1000) t(i); +-- +ok +== +pivot donnees_csv on variable_id using first(donnee) group by id_niv order by all; +-- +ok +== diff --git a/parser/testdata/corpus/sql/pivot/pivot_subquery.test b/parser/testdata/corpus/sql/pivot/pivot_subquery.test new file mode 100644 index 0000000..04ecbfe --- /dev/null +++ b/parser/testdata/corpus/sql/pivot/pivot_subquery.test @@ -0,0 +1,46 @@ +# source: test/sql/pivot/pivot_subquery.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +CREATE OR REPLACE TABLE sales(empid INT, amount INT, d DATE); +-- +ok +== +INSERT INTO sales VALUES + (1, 10000, DATE '2000-01-01'), + (1, 400, DATE '2000-01-07'), + (2, 4500, DATE '2001-01-21'), + (2, 35000, DATE '2001-01-21'), + (1, 5000, DATE '2000-02-03'), + (1, 3000, DATE '2000-02-07'), + (2, 200, DATE '2001-02-05'), + (2, 90500, DATE '2001-02-19'), + (1, 6000, DATE '2000-03-01'), + (1, 5000, DATE '2000-03-09'), + (2, 2500, DATE '2001-03-03'), + (2, 9500, DATE '2001-03-08'); +-- +ok +== +PIVOT (SELECT YEAR(d) AS year, MONTH(d) AS month, empid, amount FROM sales) ON YEAR, MONTH USING SUM(AMOUNT) ORDER BY ALL; +-- +ok +== +PIVOT (PIVOT (SELECT YEAR(d) AS year, MONTH(d) AS month, empid, amount FROM sales) ON YEAR, MONTH USING SUM(AMOUNT)) +ON empid USING SUM(COALESCE("2000_1",0) + COALESCE("2000_2",0) + COALESCE("2000_3",0) + COALESCE("2001_1",0) + COALESCE("2001_2",0) + COALESCE("2001_3",0)) +-- +ok +== +CREATE VIEW pivot_view AS PIVOT (SELECT YEAR(d) AS year, MONTH(d) AS month, empid, amount FROM sales) ON YEAR, MONTH USING SUM(AMOUNT); +-- +error: Parser Error: PIVOT statements with pivot elements extracted from the data cannot be used in views. +== +CREATE MACRO xt2(a) as TABLE PIVOT sales ON d USING SUM(amount) +-- +error: Parser Error: PIVOT statements with pivot elements extracted from the data cannot be used in macros. +== +CREATE MACRO xt2(a) as (PIVOT sales ON d USING SUM(amount)) +-- +error: Parser Error: PIVOT statements with pivot elements extracted from the data cannot be used in macros. +== diff --git a/parser/testdata/corpus/sql/pivot/pivot_subquery.test.metadata.json b/parser/testdata/corpus/sql/pivot/pivot_subquery.test.metadata.json new file mode 100644 index 0000000..66794ff --- /dev/null +++ b/parser/testdata/corpus/sql/pivot/pivot_subquery.test.metadata.json @@ -0,0 +1,7 @@ +{ + "todo": { + "72437cd5e2d32c00": "transformer-raised parser error: upstream rejects in the transformer, not the grammar; expected to clear as transformers land (milestones 3-5)", + "858d0b1660da9ca5": "transformer-raised parser error: upstream rejects in the transformer, not the grammar; expected to clear as transformers land (milestones 3-5)", + "a3e1b09632521981": "transformer-raised parser error: upstream rejects in the transformer, not the grammar; expected to clear as transformers land (milestones 3-5)" + } +} diff --git a/parser/testdata/corpus/sql/pivot/test_multi_pivot.test b/parser/testdata/corpus/sql/pivot/test_multi_pivot.test new file mode 100644 index 0000000..8ff0003 --- /dev/null +++ b/parser/testdata/corpus/sql/pivot/test_multi_pivot.test @@ -0,0 +1,92 @@ +# source: test/sql/pivot/test_multi_pivot.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +CREATE OR REPLACE TABLE sales(empid INT, amount INT, month TEXT, year INT); +-- +ok +== +INSERT INTO sales VALUES + (1, 10000, 'JAN', 2020), + (1, 400, 'JAN', 2021), + (2, 4500, 'JAN', 2021), + (2, 35000, 'JAN', 2020), + (1, 5000, 'FEB', 2020), + (1, 3000, 'FEB', 2021), + (2, 200, 'FEB', 2021), + (2, 90500, 'FEB', 2020), + (1, 6000, 'MAR', 2021), + (1, 5000, 'MAR', 2021), + (2, 2500, 'MAR', 2021), + (2, 9500, 'MAR', 2021), + (1, 8000, 'APR', 2020), + (1, 10000, 'APR', 2020), + (2, 800, 'APR', 2021), + (2, 4500, 'APR', 2020); +-- +ok +== +SELECT * + FROM sales + PIVOT( + SUM(amount) + FOR YEAR IN (2020, 2021) + MONTH IN ('JAN', 'FEB', 'MAR', 'APR') + ) AS p + ORDER BY EMPID; +-- +ok +== +SELECT * + FROM sales + PIVOT( + SUM(amount + year) + FOR YEAR IN (2020, 2021) + MONTH IN ('JAN', 'FEB', 'MAR', 'APR') + ) AS p + ORDER BY EMPID; +-- +ok +== +SELECT * +FROM (SELECT 1 a, NULL::INTEGER b, [1] c) +PIVOT (min(a) FOR (b, c) IN ((NULL, [1]))); +-- +ok +== +SELECT * +FROM (SELECT 1 a, 2 b, 3 c) +PIVOT (min(a) FOR (b, c) IN ((NULL, [1]))); +-- +ok +== +SELECT (SELECT * FROM (SELECT 1 a, 2 b, 3 c) PIVOT (min(a) FOR (b, c) IN ((NULL, [1])))); +-- +ok +== +SELECT * FROM (VALUES (1)) PIVOT (count(col0) FOR col0 IN (1::INT)); +-- +ok +== +FROM (SELECT 1 a, 2 b) PIVOT (sum(a) FOR b IN ('2022-01-01'::DATE)); +-- +ok +== +SET pivot_limit=10000 +-- +ok +== +SELECT * + FROM sales + PIVOT( + SUM(amount) + FOR YEAR IN (1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20) + MONTH IN ('JAN', 'FEB', 'MAR', 'APR') + amount IN (1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20) + empid IN (1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20) + ) AS p + ORDER BY EMPID; +-- +ok +== diff --git a/parser/testdata/corpus/sql/pivot/test_pivot.test b/parser/testdata/corpus/sql/pivot/test_pivot.test new file mode 100644 index 0000000..4759114 --- /dev/null +++ b/parser/testdata/corpus/sql/pivot/test_pivot.test @@ -0,0 +1,183 @@ +# source: test/sql/pivot/test_pivot.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +CREATE TABLE Product(DaysToManufacture int, StandardCost int); +-- +ok +== +INSERT INTO Product VALUES (0, 5.0885), (1, 223.88), (2, 359.1082), (4, 949.4105); +-- +ok +== +SELECT DaysToManufacture, AVG(StandardCost) AS AverageCost +FROM Product +GROUP BY DaysToManufacture; +-- +ok +== +SELECT * + FROM monthly_sales + PIVOT(SUM(amount) FOR MONTH IN ('JAN', 'FEB', 'MAR', 'APR')) + AS p + ORDER BY EMPID; +-- +ok +== +SELECT * + FROM monthly_sales + PIVOT(SUM(amount+1) FOR MONTH IN ('JAN', 'FEB', 'MAR', 'DEC')) + AS p + ORDER BY EMPID; +-- +ok +== +SELECT * + FROM monthly_sales + PIVOT(COUNT(*) FOR MONTH IN ('JAN', 'FEB', 'MAR', 'DEC') GROUP BY empid) + AS p + ORDER BY EMPID; +-- +ok +== +SELECT empid, January, February, March, April + FROM monthly_sales + PIVOT(SUM(amount) FOR MONTH IN ('JAN' AS January, 'FEB' AS February, 'MAR' AS March, 'APR' AS April)) + AS p + ORDER BY EMPID; +-- +ok +== +SELECT * + FROM monthly_sales + PIVOT(SUM(amount) FOR MONTH IN ('JAN', 'FEB', 'MAR')) + AS p + ORDER BY EMPID; +-- +ok +== +SELECT * + FROM monthly_sales + PIVOT(SUM(amount) FOR MONTH IN ('JAN', 'FEB', 'MAR', 'DEC')) + AS p + ORDER BY EMPID; +-- +ok +== +SELECT * +FROM monthly_sales +PIVOT(SUM(amount) FOR MONTH IN ('JAN', 'FEB', 'MAR', 'APR')) + AS p (EMP_ID_renamed, JAN, FEB, MAR, APR) +ORDER BY EMP_ID_renamed; +-- +ok +== +INSERT INTO monthly_sales VALUES (1, 250, NULL); +-- +ok +== +SELECT * + FROM monthly_sales + PIVOT(SUM(amount) FOR MONTH IN (NULL, 'JAN', 'FEB', 'MAR', 'APR')) + AS p + ORDER BY EMPID; +-- +ok +== +SELECT * + FROM monthly_sales + PIVOT(SUM(amount) FOR MONTH IN (NULL, 'JAN', 'FEB', 'MAR', 'APR')) + AS p + UNPIVOT INCLUDE NULLS(amount FOR MONTH IN ("NULL", JAN, FEB, MAR, APR)) + ORDER BY ALL; +-- +ok +== +SELECT * + FROM monthly_sales + PIVOT(SUM(amount) FOR MONTH IN (NULL, 'JAN', 'FEB', 'MAR', 'APR')) + AS p + UNPIVOT EXCLUDE NULLS(amount FOR MONTH IN ("NULL", JAN, FEB, MAR, APR)) + ORDER BY ALL; +-- +ok +== +SELECT * + FROM monthly_sales + PIVOT(SUM(amount) FOR MONTH IN (NULL, 'JAN', 'FEB', 'MAR', 'APR')) + AS p + UNPIVOT EXCLUDE NULLS(amount FOR MONTH IN ("NULL", JAN, FEB, MAR, APR)) + ORDER BY EMPID; +-- +ok +== +SELECT * +FROM monthly_sales +PIVOT(SUM(amount) FOR MONTH IN ('JAN', 'JAN')) + AS p +ORDER BY EMPID; +-- +ok +== +SELECT * +FROM monthly_sales +PIVOT(COS(amount) FOR MONTH IN ('JAN', 'FEB', 'MAR', 'APR')) + AS p (EMP_ID_renamed, JAN, FEB, MAR, APR) +ORDER BY EMP_ID_renamed; +-- +ok +== +SELECT * +FROM monthly_sales +PIVOT(SUM(amount + (SELECT 42)) FOR MONTH IN ('JAN', 'FEB', 'MAR', 'APR')) + AS p (EMP_ID_renamed, JAN, FEB, MAR, APR) +ORDER BY EMP_ID_renamed; +-- +ok +== +SELECT * +FROM monthly_sales +PIVOT(SUM(amount + row_number() over ()) FOR MONTH IN ('JAN', 'FEB', 'MAR', 'APR')) + AS p (EMP_ID_renamed, JAN, FEB, MAR, APR) +ORDER BY EMP_ID_renamed; +-- +ok +== +SELECT * + FROM monthly_sales + PIVOT(SUM(amount) FOR MONTHx IN ('JAN', 'FEB', 'MAR', 'DEC')) + AS p + ORDER BY EMPID; +-- +ok +== +SELECT * + FROM monthly_sales + PIVOT(SUM(amount) FOR MONTH IN ()) + AS p + ORDER BY EMPID; +-- +error: Parser Error: syntax error at or near ")" +== +SELECT * + FROM monthly_sales + PIVOT(SUM(amount) FOR MONTH IN (*)) + AS p + ORDER BY EMPID; +-- +ok +== +FROM +( + SELECT DaysToManufacture, StandardCost + FROM Product +) AS SourceTable +PIVOT +( + AVG(StandardCost) + FOR DaysToManufacture IN ('zz') +) AS PivotTable; +-- +ok +== diff --git a/parser/testdata/corpus/sql/pivot/test_pivot_duplicate_aggregates.test b/parser/testdata/corpus/sql/pivot/test_pivot_duplicate_aggregates.test new file mode 100644 index 0000000..338f361 --- /dev/null +++ b/parser/testdata/corpus/sql/pivot/test_pivot_duplicate_aggregates.test @@ -0,0 +1,84 @@ +# source: test/sql/pivot/test_pivot_duplicate_aggregates.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +PIVOT (FROM range(21)) ON range USING sum(range), sum(range); +-- +ok +== +SELECT COUNT(*) FROM (PIVOT (FROM range(21)) ON range USING sum(range), sum(range)); +-- +ok +== +PIVOT (FROM range(20)) ON range USING sum(range), sum(range); +-- +ok +== +PIVOT (FROM range(10)) ON range USING sum(range), sum(range); +-- +ok +== +PIVOT (FROM range(10)) ON range USING sum(range), sum(range), sum(range); +-- +ok +== +SELECT COUNT(*) FROM (PIVOT (FROM range(10)) ON range USING sum(range), sum(range), sum(range)); +-- +ok +== +PIVOT (FROM range(21)) ON range USING sum(range), max(range), sum(range); +-- +ok +== +SELECT COUNT(*) FROM (PIVOT (FROM range(21)) ON range USING sum(range), max(range), sum(range)); +-- +ok +== +PIVOT (FROM range(21)) ON range USING avg(range), avg(range); +-- +ok +== +PIVOT (FROM range(21)) ON range USING count(range), count(range); +-- +ok +== +SELECT * FROM ( + PIVOT (FROM range(3)) ON range USING sum(range), sum(range) +); +-- +ok +== +SELECT "0_sum(""range"")", "0_sum(""range"")_1" FROM ( + PIVOT (FROM range(21)) ON range USING sum(range), sum(range) +); +-- +ok +== +SELECT "5_sum(""range"")", "5_sum(""range"")_1" FROM ( + PIVOT (FROM range(21)) ON range USING sum(range), sum(range) +); +-- +ok +== +SELECT "0_sum(""range"")", "0_max(""range"")", "0_sum(""range"")_1" FROM ( + PIVOT (FROM range(21)) ON range USING sum(range), max(range), sum(range) +); +-- +ok +== +SELECT "5_sum(""range"")", "5_max(""range"")", "5_sum(""range"")_1" FROM ( + PIVOT (FROM range(21)) ON range USING sum(range), max(range), sum(range) +); +-- +ok +== +PIVOT ( + SELECT range, range::VARCHAR as str_range + FROM range(21) +) +ON range +USING max(str_range), max(str_range); +-- +ok +== diff --git a/parser/testdata/corpus/sql/pivot/test_unpivot.test b/parser/testdata/corpus/sql/pivot/test_unpivot.test new file mode 100644 index 0000000..3ddb576 --- /dev/null +++ b/parser/testdata/corpus/sql/pivot/test_unpivot.test @@ -0,0 +1,100 @@ +# source: test/sql/pivot/test_unpivot.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +CREATE OR REPLACE TABLE monthly_sales(empid INT, dept TEXT, Jan INT, Feb INT, Mar INT, April INT); +-- +ok +== +INSERT INTO monthly_sales VALUES + (1, 'electronics', 100, 200, 300, 100), + (2, 'clothes', 100, 300, 150, 200), + (3, 'cars', 200, 400, 100, 50); +-- +ok +== +SELECT * FROM monthly_sales + UNPIVOT(sales FOR month IN (jan, feb, mar, april)) + ORDER BY empid; +-- +ok +== +SELECT empid, dept, april, month, sales FROM monthly_sales + UNPIVOT(sales FOR month IN (jan, feb, mar)) + ORDER BY empid; +-- +ok +== +SELECT * FROM monthly_sales + UNPIVOT(sales FOR month IN (jan AS January, feb AS February, mar AS March, april)) + ORDER BY empid; +-- +ok +== +SELECT p.id, p.type, p.m, p.vals FROM monthly_sales + UNPIVOT(sales FOR month IN (jan, feb, mar, april)) AS p(id, type, m, vals); +-- +ok +== +SELECT empid, dept, month, sales_jan_feb, sales_mar_apr FROM monthly_sales + UNPIVOT((sales_jan_feb, sales_mar_apr) FOR month IN ((jan, feb), (mar, april))); +-- +ok +== +SELECT * FROM monthly_sales + UNPIVOT((sales_jan_feb, sales_mar_apr) FOR (month, month2) IN ((jan, feb), (mar, april))); +-- +error: Parser Error: UNPIVOT requires a single column name for the PIVOT IN clause +== +SELECT * FROM monthly_sales + UNPIVOT(sales_jan_feb FOR month IN ((jan, feb), (mar, april))); +-- +ok +== +SELECT * FROM monthly_sales + UNPIVOT((a, b, c) FOR month IN ((jan, feb), (mar, april))); +-- +ok +== +SELECT empid, dept, month, sales_jan_feb, sales_mar_apr FROM monthly_sales + UNPIVOT((sales_jan_feb, sales_mar_apr) FOR month IN ((jan, feb), mar)); +-- +ok +== +SELECT empid, dept, april, month, sales FROM monthly_sales + UNPIVOT(sales FOR month IN (jan, feb, mar, dec)) + ORDER BY empid; +-- +ok +== +SELECT * FROM monthly_sales + UNPIVOT(sales FOR month IN (empid, dept, jan, feb, mar, april)) +-- +ok +== +UNPIVOT (SELECT * FROM monthly_sales) + ON jan, feb, mar april + INTO + NAME month + VALUE sales; +-- +ok +== +SELECT * FROM monthly_sales + UNPIVOT(sales FOR month IN ()) + ORDER BY empid; +-- +error: Parser Error: syntax error at or near ")" +== +SELECT * FROM monthly_sales + UNPIVOT(sales FOR month IN ('')) + ORDER BY empid; +-- +ok +== +SELECT * FROM monthly_sales + UNPIVOT(SUM(sales) FOR month IN (empid, dept, jan, feb, mar, april)) +-- +error: Parser Error: syntax error at or near "(" +== diff --git a/parser/testdata/corpus/sql/pivot/test_unpivot.test.metadata.json b/parser/testdata/corpus/sql/pivot/test_unpivot.test.metadata.json new file mode 100644 index 0000000..b878b44 --- /dev/null +++ b/parser/testdata/corpus/sql/pivot/test_unpivot.test.metadata.json @@ -0,0 +1,5 @@ +{ + "todo": { + "d7ec37659c5b2fbc": "transformer-raised parser error: upstream rejects in the transformer, not the grammar; expected to clear as transformers land (milestones 3-5)" + } +} diff --git a/parser/testdata/corpus/sql/pivot/test_unpivot_stmt.test b/parser/testdata/corpus/sql/pivot/test_unpivot_stmt.test new file mode 100644 index 0000000..baa79b4 --- /dev/null +++ b/parser/testdata/corpus/sql/pivot/test_unpivot_stmt.test @@ -0,0 +1,58 @@ +# source: test/sql/pivot/test_unpivot_stmt.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +CREATE TABLE t1(id BIGINT, "Sales (05/19/2020)" BIGINT, "Sales (06/03/2020)" BIGINT, "Sales (10/23/2020)" BIGINT); +-- +ok +== +INSERT INTO t1 VALUES(10629465, 23, 47, 99); +-- +ok +== +INSERT INTO t1 VALUES(98765432, 10, 99, 33); +-- +ok +== +SELECT id, regexp_replace(date, 'Sales [(]([0-9]+)/([0-9]+)/([0-9]+)[)]', '\3-\1-\2')::DATE AS date, sales +FROM t1 + UNPIVOT (sales FOR date IN ("Sales (05/19/2020)", "Sales (06/03/2020)", "Sales (10/23/2020)")) + ORDER BY ALL; +-- +ok +== +SELECT id, regexp_replace(date, 'Sales [(]([0-9]+)/([0-9]+)/([0-9]+)[)]', '\3-\1-\2')::DATE AS date, sales +FROM + (UNPIVOT t1 ON "Sales (05/19/2020)", "Sales (06/03/2020)", "Sales (10/23/2020)" INTO NAME date VALUE sales) + ORDER BY ALL; +-- +ok +== +SELECT * +FROM + (UNPIVOT t1 ON "Sales (05/19/2020)" AS "2020-05-19", "Sales (06/03/2020)" AS "2020-06-03", "Sales (10/23/2020)" AS "2020-10-23" INTO NAME date VALUE sales) +ORDER BY ALL; +-- +ok +== +SELECT id, regexp_replace(date, 'Sales [(]([0-9]+)/([0-9]+)/([0-9]+)[)]', '\3-\1-\2')::DATE AS date, sales FROM t1 + UNPIVOT (Sales FOR Date IN (COLUMNS('Sales.*'))) + ORDER BY ALL; +-- +ok +== +SELECT id, regexp_replace(date, 'Sales [(]([0-9]+)/([0-9]+)/([0-9]+)[)]', '\3-\1-\2')::DATE AS date, sales +FROM + (UNPIVOT t1 ON COLUMNS('Sales.*') INTO NAME date VALUE sales) +ORDER BY ALL; +-- +ok +== +SELECT id, regexp_replace(date, 'Sales [(]([0-9]+)/([0-9]+)/([0-9]+)[)]', '\3-\1-\2')::DATE AS date, sales +FROM + (UNPIVOT t1 ON * EXCLUDE (id) INTO NAME date VALUE sales) +ORDER BY ALL; +-- +ok +== diff --git a/parser/testdata/corpus/sql/pivot/top_level_pivot_syntax.test b/parser/testdata/corpus/sql/pivot/top_level_pivot_syntax.test new file mode 100644 index 0000000..ee02507 --- /dev/null +++ b/parser/testdata/corpus/sql/pivot/top_level_pivot_syntax.test @@ -0,0 +1,71 @@ +# source: test/sql/pivot/top_level_pivot_syntax.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +PIVOT monthly_sales ON MONTH USING SUM(AMOUNT) +-- +ok +== +FROM (PIVOT monthly_sales ON MONTH USING SUM(AMOUNT)); +-- +ok +== +PIVOT monthly_sales ON MONTH USING SUM(AMOUNT) GROUP BY empid +-- +ok +== +PIVOT monthly_sales ON MONTH IN ('1-JAN', '2-FEB', '3-MAR', '4-APR') USING SUM(AMOUNT) GROUP BY empid +-- +ok +== +PIVOT monthly_sales ON MONTH IN ('1-JAN', '2-FEB', '3-MAR') USING SUM(AMOUNT) GROUP BY empid +-- +ok +== +ALTER TABLE monthly_sales ADD COLUMN status VARCHAR +-- +ok +== +UPDATE monthly_sales SET status=CASE WHEN amount >= 10000 THEN 'important' ELSE 'regular' END +-- +ok +== +FROM (PIVOT monthly_sales ON MONTH USING SUM(AMOUNT)) ORDER BY ALL; +-- +ok +== +PIVOT monthly_sales ON MONTH USING SUM(AMOUNT) GROUP BY empid ORDER BY ALL +-- +ok +== +FROM (PIVOT monthly_sales ON MONTH USING SUM(AMOUNT) GROUP BY status) ORDER BY ALL +-- +ok +== +SELECT * + FROM monthly_sales + PIVOT(SUM(amount) FOR MONTH IN ('1-JAN', '2-FEB', '3-MAR', '4-APR') GROUP BY status) + AS p + ORDER BY 1; +-- +ok +== +WITH pivoted_sales AS (PIVOT monthly_sales ON MONTH USING SUM(AMOUNT) GROUP BY empid) +SELECT * FROM pivoted_sales ORDER BY empid DESC; +-- +ok +== +WITH pivoted_sales AS MATERIALIZED (PIVOT monthly_sales ON MONTH USING SUM(AMOUNT) GROUP BY empid) +SELECT * FROM pivoted_sales ORDER BY empid DESC; +-- +ok +== +CREATE VIEW v1 AS PIVOT monthly_sales ON MONTH USING SUM(AMOUNT) +-- +error: Parser Error: PIVOT statements with pivot elements extracted from the data cannot be used in views. +== +CREATE VIEW v1 AS PIVOT monthly_sales ON MONTH IN ('1-JAN', '2-FEB', '3-MAR', '4-APR') USING SUM(AMOUNT) GROUP BY empid ORDER BY ALL +-- +ok +== diff --git a/parser/testdata/corpus/sql/pivot/top_level_pivot_syntax.test.metadata.json b/parser/testdata/corpus/sql/pivot/top_level_pivot_syntax.test.metadata.json new file mode 100644 index 0000000..62ad8d3 --- /dev/null +++ b/parser/testdata/corpus/sql/pivot/top_level_pivot_syntax.test.metadata.json @@ -0,0 +1,5 @@ +{ + "todo": { + "e5d746e954944af5": "transformer-raised parser error: upstream rejects in the transformer, not the grammar; expected to clear as transformers land (milestones 3-5)" + } +} diff --git a/parser/testdata/corpus/sql/pivot/unpivot_expression.test b/parser/testdata/corpus/sql/pivot/unpivot_expression.test new file mode 100644 index 0000000..dad19b1 --- /dev/null +++ b/parser/testdata/corpus/sql/pivot/unpivot_expression.test @@ -0,0 +1,54 @@ +# source: test/sql/pivot/unpivot_expression.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +unpivot (select 42 as col1, 'woot' as col2) + on col1::VARCHAR, col2; +-- +ok +== +unpivot (select 42 as col1, 'woot' as col2) + on COLUMNS(*)::VARCHAR; +-- +ok +== +unpivot (select 42 as col1, 'woot' as col2) + on (col1 + 100)::VARCHAR, col2; +-- +ok +== +unpivot (select 42 as col1, 'woot' as col2) + on (col1 + 100)::VARCHAR AS c, col2; +-- +ok +== +select * from (select 42 as col1, 'woot' as col2) UNPIVOT ("value" FOR "name" IN (col1::VARCHAR, col2)) +-- +ok +== +FROM (SELECT 42 c1) AS t +UNPIVOT (c1 FOR 'v' IN ((c1, 40 + 2))); +-- +ok +== +unpivot (select 42 as col1, 'woot' as col2) + on (col1 + (SELECT col1))::VARCHAR, col2; +-- +ok +== +unpivot (select 42 as col1, 'woot' as col2) + on random(), col2; +-- +ok +== +unpivot (select 42 as col1, 'woot' as col2) + on col1 + col2; +-- +ok +== +unpivot (select 42 as col1, 'woot' as col2) + on t.col1::VARCHAR, col2; +-- +ok +== diff --git a/parser/testdata/corpus/sql/pivot/unpivot_internal_names.test b/parser/testdata/corpus/sql/pivot/unpivot_internal_names.test new file mode 100644 index 0000000..ef0e100 --- /dev/null +++ b/parser/testdata/corpus/sql/pivot/unpivot_internal_names.test @@ -0,0 +1,17 @@ +# source: test/sql/pivot/unpivot_internal_names.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +CREATE TABLE unpivot_names(unpivot_names VARCHAR, unpivot_list VARCHAR, unpivot_list_2 VARCHAR, col1 INT, col2 INT, col3 INT); +-- +ok +== +INSERT INTO unpivot_names VALUES ('unpivot_names', 'unpivot_list', 'unpivot_list_2', 1, 2, 3); +-- +ok +== +UNPIVOT unpivot_names ON COLUMNS('col*') +-- +ok +== diff --git a/parser/testdata/corpus/sql/pivot/unpivot_no_columns.test b/parser/testdata/corpus/sql/pivot/unpivot_no_columns.test new file mode 100644 index 0000000..0902bfd --- /dev/null +++ b/parser/testdata/corpus/sql/pivot/unpivot_no_columns.test @@ -0,0 +1,13 @@ +# source: test/sql/pivot/unpivot_no_columns.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +create table integers(i integer); +-- +ok +== +unpivot integers on columns(* exclude (i)); +-- +ok +== diff --git a/parser/testdata/corpus/sql/pivot/unpivot_non_aligned_columns.test b/parser/testdata/corpus/sql/pivot/unpivot_non_aligned_columns.test new file mode 100644 index 0000000..7d35c07 --- /dev/null +++ b/parser/testdata/corpus/sql/pivot/unpivot_non_aligned_columns.test @@ -0,0 +1,29 @@ +# source: test/sql/pivot/unpivot_non_aligned_columns.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +CREATE TABLE test(id BIGINT, metric_1 VARCHAR, value_x VARCHAR, metric_2 VARCHAR, value_q VARCHAR, metric_3 VARCHAR, value_j VARCHAR);; +-- +ok +== +INSERT INTO test VALUES(1,'a','a_value','b','b_value','c','c_value'); +-- +ok +== +INSERT INTO test VALUES(2,'d','d_value','e','e_value','f','f_value'); +-- +ok +== +UNPIVOT test ON (metric_1, value_x), metric_2, metric_3; +-- +ok +== +UNPIVOT test ON (metric_1, value_x), (metric_2, value_q), (metric_3, value_j) INTO NAME metric VALUE metric_value; +-- +ok +== +UNPIVOT test ON (metric_1, value_x), (metric_2, value_q), (metric_3, value_j) INTO NAME metric VALUES metric_value, metric_type; +-- +ok +== diff --git a/parser/testdata/corpus/sql/pivot/unpivot_types.test b/parser/testdata/corpus/sql/pivot/unpivot_types.test new file mode 100644 index 0000000..cb214f8 --- /dev/null +++ b/parser/testdata/corpus/sql/pivot/unpivot_types.test @@ -0,0 +1,27 @@ +# source: test/sql/pivot/unpivot_types.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +SELECT column_name, column_type FROM (DESCRIBE unpivot ( select 42) on columns(*)) +-- +ok +== +SELECT column_name, column_type FROM (DESCRIBE unpivot ( select {n : 1 }) on columns(*)) +-- +ok +== +SELECT unpivot_list(1, 2.5), typeof(unpivot_list(1, 2.5)) +-- +ok +== +SELECT unpivot_list(1.2::DECIMAL(2,1), 1.23::DECIMAL(3,2)), typeof(unpivot_list(1.2::DECIMAL(2,1), 1.23::DECIMAL(3,2))) +-- +ok +== +UNPIVOT (SELECT 1::INTEGER AS i, 2.5::DECIMAL(2,1) AS d) +ON i, d +INTO NAME source_column VALUE value +-- +ok +== diff --git a/parser/testdata/corpus/sql/pivot/unpivot_unnamed_subquery.test b/parser/testdata/corpus/sql/pivot/unpivot_unnamed_subquery.test new file mode 100644 index 0000000..4077393 --- /dev/null +++ b/parser/testdata/corpus/sql/pivot/unpivot_unnamed_subquery.test @@ -0,0 +1,10 @@ +# source: test/sql/pivot/unpivot_unnamed_subquery.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +unpivot (select cast(columns(*) as varchar) from (select 42 as col1, 'woot' as col2)) + on columns(*); +-- +ok +== diff --git a/parser/testdata/corpus/sql/pivot/unpivot_view.test b/parser/testdata/corpus/sql/pivot/unpivot_view.test new file mode 100644 index 0000000..0655b1d --- /dev/null +++ b/parser/testdata/corpus/sql/pivot/unpivot_view.test @@ -0,0 +1,28 @@ +# source: test/sql/pivot/unpivot_view.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +CREATE TABLE t ( + id INTEGER, + a INTEGER, + b INTEGER +); +-- +ok +== +INSERT INTO t VALUES (1, 10, 20); +-- +ok +== +CREATE VIEW v AS +SELECT * +FROM t +UNPIVOT (val FOR key IN (a, b)); +-- +ok +== +FROM v; +-- +ok +== diff --git a/parser/testdata/corpus/sql/pragma/pragma_database_size_readonly.test b/parser/testdata/corpus/sql/pragma/pragma_database_size_readonly.test new file mode 100644 index 0000000..776b084 --- /dev/null +++ b/parser/testdata/corpus/sql/pragma/pragma_database_size_readonly.test @@ -0,0 +1,9 @@ +# source: test/sql/pragma/pragma_database_size_readonly.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +PRAGMA database_size +-- +ok +== diff --git a/parser/testdata/corpus/sql/pragma/profiling/call_enable_profiling_function.test b/parser/testdata/corpus/sql/pragma/profiling/call_enable_profiling_function.test new file mode 100644 index 0000000..7f35db7 --- /dev/null +++ b/parser/testdata/corpus/sql/pragma/profiling/call_enable_profiling_function.test @@ -0,0 +1,145 @@ +# source: test/sql/pragma/profiling/call_enable_profiling_function.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +PRAGMA profiling_output = '{TEST_DIR}/test.txt' +-- +ok +== +CALL disable_profiling(); +-- +ok +== +SELECT CURRENT_SETTING('enable_profiling'); +-- +ok +== +CALL enable_profiling(); +-- +ok +== +CALL enable_profiling(format='json') +-- +ok +== +CALL enable_profiling(format='i dont exist hehe') +-- +ok +== +SELECT CURRENT_SETTING('profiling_coverage'); +-- +ok +== +CALL enable_profiling(coverage='all') +-- +ok +== +CALL enable_profiling(coverage='i dont exist hehe') +-- +ok +== +SELECT CURRENT_SETTING('profiling_output'); +-- +ok +== +CALL enable_profiling(save_location='{TEST_DIR}/other_file.txt') +-- +ok +== +CALL enable_profiling(save_location='{TEST_DIR}/other_file.db') +-- +error: Parser Error: Invalid output file type: db +== +SELECT CURRENT_SETTING('profiling_mode'); +-- +ok +== +CALL enable_profiling(mode='detailed') +-- +ok +== +CALL enable_profiling(mode='i dont exist hehe') +-- +error: Parser Error: Unrecognized profiling mode "i dont exist hehe", supported formats: [standard, detailed, all] +== +CALL enable_profiling(mode='true') +-- +error: Parser Error: Unrecognized profiling mode "true", supported formats: [standard, detailed, all] +== +CALL enable_profiling(metrics = 42); +-- +ok +== +CALL enable_profiling(metrics = ['operator.intermediate_rows', 'operator.rows_scanned', 'query.total_intermediate_rows', 'query.total_rows_scanned']) +-- +ok +== +SELECT UNNEST(CURRENT_SETTING('tracked_metrics')) ORDER BY ALL; +-- +ok +== +CALL enable_profiling(metrics = ['query.sql', 'operator.extra_info']) +-- +ok +== +CALL enable_profiling(metrics = ['query.total_time', 'operator.intermediate_size_bytes']); +-- +ok +== +CALL enable_profiling(metrics = 'query.*'); +-- +ok +== +CALL enable_profiling(metrics = '*'); +-- +ok +== +CALL enable_profiling(metrics = ['LATENCY', 'RESULT_SET_SIZE' = true]); +-- +ok +== +CALL enable_profiling(metrics = 'QUERY_NAME': true, 'EXTRA_INFO': true, 'OPERATOR_ROWS_SCANNED': false, "CUMULATIVE_CARDINALITY": "true"); +-- +error: Parser Error: syntax error at or near ":" +== +RESET tracked_metrics; +-- +ok +== +CALL enable_profiling(['query.total_time', 'operator.intermediate_size_bytes']); +-- +ok +== +CALL enable_profiling(['io.total_bytes_read', 'io.total_bytes_written'], mode = 'detailed'); +-- +ok +== +CALL enable_profiling(mode = 'detailed', ['LATENCY', 'RESULT_SET_SIZE']); +-- +ok +== +CALL enable_profiling(format='json', save_location='{TEST_DIR}/test.json') +-- +ok +== +CALL enable_profiling(format='query_tree', save_location='{TEST_DIR}/test.json') +-- +ok +== +CALL enable_profiling(format='query_tree', save_location='{TEST_DIR}/test.txt', coverage='select', mode='standard', metrics=['query.sql', 'query.total_time']) +-- +ok +== +CALL enable_profiling(this_does_not_exist = 'hello'); +-- +ok +== +CALL enable_profiling(format); +-- +ok +== +CALL enable_profiling('hello', 'goodbye'); +-- +ok +== diff --git a/parser/testdata/corpus/sql/pragma/profiling/call_enable_profiling_function.test.metadata.json b/parser/testdata/corpus/sql/pragma/profiling/call_enable_profiling_function.test.metadata.json new file mode 100644 index 0000000..a119d36 --- /dev/null +++ b/parser/testdata/corpus/sql/pragma/profiling/call_enable_profiling_function.test.metadata.json @@ -0,0 +1,7 @@ +{ + "todo": { + "3e3820d623be76c1": "transformer-raised parser error: upstream rejects in the transformer, not the grammar; expected to clear as transformers land (milestones 3-5)", + "5f0ea5a77db63984": "transformer-raised parser error: upstream rejects in the transformer, not the grammar; expected to clear as transformers land (milestones 3-5)", + "bbb93f23d864aa04": "transformer-raised parser error: upstream rejects in the transformer, not the grammar; expected to clear as transformers land (milestones 3-5)" + } +} diff --git a/parser/testdata/corpus/sql/pragma/profiling/test_all_profiling_settings.test b/parser/testdata/corpus/sql/pragma/profiling/test_all_profiling_settings.test new file mode 100644 index 0000000..1ac3b42 --- /dev/null +++ b/parser/testdata/corpus/sql/pragma/profiling/test_all_profiling_settings.test @@ -0,0 +1,25 @@ +# source: test/sql/pragma/profiling/test_all_profiling_settings.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +SET profiling_mode='all'; +-- +ok +== +SELECT unnest(['Maia', 'Thijs', 'Mark', 'Hannes', 'Tom', 'Max', 'Carlo', 'Sam', 'Tania']) AS names ORDER BY random(); +-- +ok +== +SELECT unnest(current_setting('tracked_metrics')) ORDER BY ALL; +-- +ok +== +CREATE OR REPLACE TABLE metrics_output AS SELECT * FROM '{TEST_DIR}/profiling_output.json'; +-- +ok +== +SELECT operator[1].extra_info, operator[1].intermediate_size_bytes, query.cpu_time, query.total_time FROM metrics_output; +-- +ok +== diff --git a/parser/testdata/corpus/sql/pragma/profiling/test_attach_and_checkpoint_latency.test b/parser/testdata/corpus/sql/pragma/profiling/test_attach_and_checkpoint_latency.test new file mode 100644 index 0000000..767980c --- /dev/null +++ b/parser/testdata/corpus/sql/pragma/profiling/test_attach_and_checkpoint_latency.test @@ -0,0 +1,69 @@ +# source: test/sql/pragma/profiling/test_attach_and_checkpoint_latency.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +ATTACH '{TEST_DIR}/profile_fs.db'; +-- +ok +== +CREATE TABLE profile_fs.tbl AS SELECT range AS id FROM range(100_000); +-- +ok +== +PRAGMA profiling_output = '{TEST_DIR}/profile_fs.json'; +-- +error: Parser Error: Profiler file type ({TEST_DIR}/profile_fs.json) must either have the same file extension as the profiling output type (query_tree), or be a '.txt' file. Set "enable_profiling = 'json'" first. +== +SET tracked_metrics = ['storage.waiting_to_attach_latency', 'storage.attach_load_storage_latency', 'storage.attach_replay_wal_latency', 'storage.checkpoint_latency']; +-- +ok +== +SET profiling_coverage='ALL'; +-- +ok +== +CHECKPOINT profile_fs; +-- +ok +== +CREATE OR REPLACE TABLE metrics_output AS SELECT * FROM '{TEST_DIR}/profile_fs.json'; +-- +ok +== +SELECT + CASE WHEN storage.checkpoint_latency >= 0 THEN 'true' + ELSE 'false' END +FROM metrics_output; +-- +ok +== +CREATE TABLE profile_fs.other_tbl AS SELECT range AS id FROM range(100_000); +-- +ok +== +DETACH profile_fs; +-- +ok +== +SELECT + CASE WHEN storage.waiting_to_attach_latency >= 0 THEN 'true' + ELSE 'false' END +FROM metrics_output; +-- +ok +== +SELECT + CASE WHEN storage.attach_load_storage_latency >= 0 THEN 'true' + ELSE 'false' END +FROM metrics_output; +-- +ok +== +SELECT + CASE WHEN storage.attach_replay_wal_latency >= 0 THEN 'true' + ELSE 'false' END +FROM metrics_output; +-- +ok +== diff --git a/parser/testdata/corpus/sql/pragma/profiling/test_attach_and_checkpoint_latency.test.metadata.json b/parser/testdata/corpus/sql/pragma/profiling/test_attach_and_checkpoint_latency.test.metadata.json new file mode 100644 index 0000000..418291b --- /dev/null +++ b/parser/testdata/corpus/sql/pragma/profiling/test_attach_and_checkpoint_latency.test.metadata.json @@ -0,0 +1,5 @@ +{ + "todo": { + "22caeac19def70af": "transformer-raised parser error: upstream rejects in the transformer, not the grammar; expected to clear as transformers land (milestones 3-5)" + } +} diff --git a/parser/testdata/corpus/sql/pragma/profiling/test_autocheckpoint_latency.test b/parser/testdata/corpus/sql/pragma/profiling/test_autocheckpoint_latency.test new file mode 100644 index 0000000..449cfeb --- /dev/null +++ b/parser/testdata/corpus/sql/pragma/profiling/test_autocheckpoint_latency.test @@ -0,0 +1,63 @@ +# source: test/sql/pragma/profiling/test_autocheckpoint_latency.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +ATTACH '{TEST_DIR}/autocheckpoint_latency.db' AS acp_db; +-- +ok +== +CREATE TABLE acp_db.tbl(id INTEGER); +-- +ok +== +CHECKPOINT acp_db; +-- +ok +== +PRAGMA profiling_output = '{TEST_DIR}/acp_before.json'; +-- +error: Parser Error: Profiler file type ({TEST_DIR}/acp_before.json) must either have the same file extension as the profiling output type (query_tree), or be a '.txt' file. Set "enable_profiling = 'json'" first. +== +SET tracked_metrics = ['storage.checkpoint_latency', 'io.total_bytes_written', 'storage.commit_local_storage_latency', 'storage.write_to_wal_latency']; +-- +ok +== +INSERT INTO acp_db.tbl VALUES (1); +-- +ok +== +SELECT + CASE WHEN json_extract(to_json(storage), '$.checkpoint_latency') IS NULL THEN 'true' ELSE 'false' END, + CASE WHEN io.total_bytes_written = 0 THEN 'true' ELSE 'false' END, + CASE WHEN storage.commit_local_storage_latency > 0 THEN 'true' ELSE 'false' END, + CASE WHEN storage.write_to_wal_latency > 0 THEN 'true' ELSE 'false' END +FROM '{TEST_DIR}/acp_before.json'; +-- +ok +== +SET wal_autocheckpoint_entries=1; +-- +ok +== +PRAGMA profiling_output = '{TEST_DIR}/acp_after.json'; +-- +error: Parser Error: Profiler file type ({TEST_DIR}/acp_after.json) must either have the same file extension as the profiling output type (query_tree), or be a '.txt' file. Set "enable_profiling = 'json'" first. +== +INSERT INTO acp_db.tbl VALUES (2); +-- +ok +== +SELECT + CASE WHEN storage.checkpoint_latency > 0 THEN 'true' ELSE 'false' END, + CASE WHEN io.total_bytes_written > 0 THEN 'true' ELSE 'false' END, + CASE WHEN storage.commit_local_storage_latency > 0 THEN 'true' ELSE 'false' END, + CASE WHEN storage.write_to_wal_latency > 0 THEN 'true' ELSE 'false' END +FROM '{TEST_DIR}/acp_after.json'; +-- +ok +== +DETACH acp_db; +-- +ok +== diff --git a/parser/testdata/corpus/sql/pragma/profiling/test_autocheckpoint_latency.test.metadata.json b/parser/testdata/corpus/sql/pragma/profiling/test_autocheckpoint_latency.test.metadata.json new file mode 100644 index 0000000..a9881e1 --- /dev/null +++ b/parser/testdata/corpus/sql/pragma/profiling/test_autocheckpoint_latency.test.metadata.json @@ -0,0 +1,6 @@ +{ + "todo": { + "1506f00102367993": "transformer-raised parser error: upstream rejects in the transformer, not the grammar; expected to clear as transformers land (milestones 3-5)", + "e771a88a05ba1459": "transformer-raised parser error: upstream rejects in the transformer, not the grammar; expected to clear as transformers land (milestones 3-5)" + } +} diff --git a/parser/testdata/corpus/sql/pragma/profiling/test_checkpoint_profiling.test b/parser/testdata/corpus/sql/pragma/profiling/test_checkpoint_profiling.test new file mode 100644 index 0000000..3ebd85e --- /dev/null +++ b/parser/testdata/corpus/sql/pragma/profiling/test_checkpoint_profiling.test @@ -0,0 +1,93 @@ +# source: test/sql/pragma/profiling/test_checkpoint_profiling.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +ATTACH '{TEST_DIR}/checkpoint_prof.db'; +-- +ok +== +CREATE TABLE checkpoint_prof.tbl(id INTEGER, category INTEGER); +-- +ok +== +INSERT INTO checkpoint_prof.tbl SELECT range, range % 100 FROM range(10000); +-- +ok +== +CHECKPOINT checkpoint_prof; +-- +ok +== +PRAGMA profiling_output = '{TEST_DIR}/cp_noop.json'; +-- +error: Parser Error: Profiler file type ({TEST_DIR}/cp_noop.json) must either have the same file extension as the profiling output type (query_tree), or be a '.txt' file. Set "enable_profiling = 'json'" first. +== +SET tracked_metrics = ['storage.checkpoint_latency', 'query.total_time']; +-- +ok +== +SELECT query.total_time > 0 FROM '{TEST_DIR}/cp_noop.json'; +-- +ok +== +INSERT INTO checkpoint_prof.tbl SELECT range + 100000, range % 100 FROM range(10000); +-- +ok +== +PRAGMA profiling_output = '{TEST_DIR}/cp_first.json'; +-- +error: Parser Error: Profiler file type ({TEST_DIR}/cp_first.json) must either have the same file extension as the profiling output type (query_tree), or be a '.txt' file. Set "enable_profiling = 'json'" first. +== +CREATE TABLE first_cp AS SELECT storage.checkpoint_latency AS latency FROM '{TEST_DIR}/cp_first.json'; +-- +ok +== +SELECT CASE WHEN latency > 0 THEN 'true' ELSE 'false' END FROM first_cp; +-- +ok +== +INSERT INTO checkpoint_prof.tbl SELECT range + 200000, range % 100 FROM range(10000); +-- +ok +== +PRAGMA profiling_output = '{TEST_DIR}/cp_second.json'; +-- +error: Parser Error: Profiler file type ({TEST_DIR}/cp_second.json) must either have the same file extension as the profiling output type (query_tree), or be a '.txt' file. Set "enable_profiling = 'json'" first. +== +CREATE TABLE second_cp AS SELECT storage.checkpoint_latency AS latency FROM '{TEST_DIR}/cp_second.json'; +-- +ok +== +SELECT CASE WHEN latency > 0 THEN 'true' ELSE 'false' END FROM second_cp; +-- +ok +== +SELECT CASE WHEN (SELECT latency FROM first_cp) + (SELECT latency FROM second_cp) > (SELECT latency FROM first_cp) THEN 'true' ELSE 'false' END; +-- +ok +== +INSERT INTO checkpoint_prof.tbl SELECT range + 1000000, range % 100 FROM range(10000); +-- +ok +== +INSERT INTO checkpoint_prof.tbl SELECT range + (2000000 + {threadid} * 10000 + {x} * 1000), range % 100 FROM range(1000); +-- +error: Parser Error: syntax error at or near "}" +== +PRAGMA profiling_output = '{TEST_DIR}/cp_concurrent_{x}.json'; +-- +error: Parser Error: Profiler file type ({TEST_DIR}/cp_concurrent_{x}.json) must either have the same file extension as the profiling output type (query_tree), or be a '.txt' file. Set "enable_profiling = 'json'" first. +== +SELECT query.total_time >= 0 FROM '{TEST_DIR}/cp_concurrent_{x}.json'; +-- +ok +== +CREATE OR REPLACE TABLE metrics AS SELECT * FROM '{TEST_DIR}/cp_concurrent_0.json'; +-- +ok +== +SELECT CASE WHEN storage.checkpoint_latency > 0 THEN 'true' ELSE 'false' END FROM metrics; +-- +ok +== diff --git a/parser/testdata/corpus/sql/pragma/profiling/test_checkpoint_profiling.test.metadata.json b/parser/testdata/corpus/sql/pragma/profiling/test_checkpoint_profiling.test.metadata.json new file mode 100644 index 0000000..ac8db13 --- /dev/null +++ b/parser/testdata/corpus/sql/pragma/profiling/test_checkpoint_profiling.test.metadata.json @@ -0,0 +1,8 @@ +{ + "todo": { + "4e1a908b16d2d263": "transformer-raised parser error: upstream rejects in the transformer, not the grammar; expected to clear as transformers land (milestones 3-5)", + "9a8ccbb4bc80bdf7": "transformer-raised parser error: upstream rejects in the transformer, not the grammar; expected to clear as transformers land (milestones 3-5)", + "af1ea835ee327dd8": "transformer-raised parser error: upstream rejects in the transformer, not the grammar; expected to clear as transformers land (milestones 3-5)", + "c177711e16dcd525": "transformer-raised parser error: upstream rejects in the transformer, not the grammar; expected to clear as transformers land (milestones 3-5)" + } +} diff --git a/parser/testdata/corpus/sql/pragma/profiling/test_commit_write_wal_latency_and_count.test b/parser/testdata/corpus/sql/pragma/profiling/test_commit_write_wal_latency_and_count.test new file mode 100644 index 0000000..6e142dd --- /dev/null +++ b/parser/testdata/corpus/sql/pragma/profiling/test_commit_write_wal_latency_and_count.test @@ -0,0 +1,61 @@ +# source: test/sql/pragma/profiling/test_commit_write_wal_latency_and_count.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +ATTACH '{TEST_DIR}/wal_latency.db' AS wal_latency; +-- +ok +== +CREATE TABLE wal_latency.tbl AS SELECT range AS id, 0 AS v FROM range(500_000); +-- +ok +== +UPDATE wal_latency.tbl SET v = id; +-- +ok +== +PRAGMA profiling_output = '{TEST_DIR}/wal_commit.json'; +-- +error: Parser Error: Profiler file type ({TEST_DIR}/wal_commit.json) must either have the same file extension as the profiling output type (query_tree), or be a '.txt' file. Set "enable_profiling = 'json'" first. +== +SET tracked_metrics = ['storage.commit_local_storage_latency', 'storage.write_to_wal_latency']; +-- +ok +== +CREATE OR REPLACE TABLE commit_metrics AS SELECT * FROM '{TEST_DIR}/wal_commit.json'; +-- +ok +== +SELECT CASE WHEN storage.commit_local_storage_latency >= 0 THEN 'true' ELSE 'false' END FROM commit_metrics; +-- +ok +== +SELECT CASE WHEN storage.write_to_wal_latency >= 0 THEN 'true' ELSE 'false' END FROM commit_metrics; +-- +ok +== +DETACH wal_latency; +-- +ok +== +PRAGMA profiling_output = '{TEST_DIR}/wal_replay.json'; +-- +error: Parser Error: Profiler file type ({TEST_DIR}/wal_replay.json) must either have the same file extension as the profiling output type (query_tree), or be a '.txt' file. Set "enable_profiling = 'json'" first. +== +SET tracked_metrics = ['storage.wal_replay_entry_count', 'storage.attach_replay_wal_latency']; +-- +ok +== +CREATE OR REPLACE TABLE replay_metrics AS SELECT * FROM '{TEST_DIR}/wal_replay.json'; +-- +ok +== +SELECT CASE WHEN storage.wal_replay_entry_count > 0 THEN 'true' ELSE 'false' END FROM replay_metrics; +-- +ok +== +SELECT CASE WHEN storage.attach_replay_wal_latency > 0 THEN 'true' ELSE 'false' END FROM replay_metrics; +-- +ok +== diff --git a/parser/testdata/corpus/sql/pragma/profiling/test_commit_write_wal_latency_and_count.test.metadata.json b/parser/testdata/corpus/sql/pragma/profiling/test_commit_write_wal_latency_and_count.test.metadata.json new file mode 100644 index 0000000..af3ff99 --- /dev/null +++ b/parser/testdata/corpus/sql/pragma/profiling/test_commit_write_wal_latency_and_count.test.metadata.json @@ -0,0 +1,6 @@ +{ + "todo": { + "f3771c8b33bec4e9": "transformer-raised parser error: upstream rejects in the transformer, not the grammar; expected to clear as transformers land (milestones 3-5)", + "fce1da9a57227ed2": "transformer-raised parser error: upstream rejects in the transformer, not the grammar; expected to clear as transformers land (milestones 3-5)" + } +} diff --git a/parser/testdata/corpus/sql/pragma/profiling/test_custom_profiling_blocked_thread_time.test b/parser/testdata/corpus/sql/pragma/profiling/test_custom_profiling_blocked_thread_time.test new file mode 100644 index 0000000..088e5ce --- /dev/null +++ b/parser/testdata/corpus/sql/pragma/profiling/test_custom_profiling_blocked_thread_time.test @@ -0,0 +1,29 @@ +# source: test/sql/pragma/profiling/test_custom_profiling_blocked_thread_time.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +PRAGMA threads = 4; +-- +ok +== +CREATE TABLE bigdata AS SELECT i AS col_a, i AS col_b FROM range(0, 10000) tbl(i); +-- +ok +== +SET tracked_metrics = ['system.blocked_thread_time']; +-- +ok +== +SELECT (SELECT COUNT(*) FROM bigdata WHERE col_a = 1) + (SELECT COUNT(*) FROM bigdata WHERE col_b = 1); +-- +ok +== +SELECT unnest(current_setting('tracked_metrics')) ORDER BY ALL +-- +ok +== +SELECT COUNT(system.blocked_thread_time) FROM metrics_output; +-- +ok +== diff --git a/parser/testdata/corpus/sql/pragma/profiling/test_custom_profiling_disable_metrics.test b/parser/testdata/corpus/sql/pragma/profiling/test_custom_profiling_disable_metrics.test new file mode 100644 index 0000000..8db0a57 --- /dev/null +++ b/parser/testdata/corpus/sql/pragma/profiling/test_custom_profiling_disable_metrics.test @@ -0,0 +1,71 @@ +# source: test/sql/pragma/profiling/test_custom_profiling_disable_metrics.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +SET tracked_metrics = ['operator.extra_info', 'operator.intermediate_rows', 'operator.timing', 'query.total_time']; +-- +ok +== +SELECT query.cpu_time FROM metrics_output; +-- +ok +== +SELECT operator[1].extra_info, query.total_time FROM metrics_output; +-- +ok +== +SET tracked_metrics = ['query.sql', 'query.cpu_time', 'operator.extra_info', 'query.total_intermediate_rows', 'query.total_rows_scanned']; +-- +ok +== +SELECT + CASE WHEN query.cpu_time > 0 THEN 'true' + ELSE 'false' END +FROM metrics_output; +-- +ok +== +SELECT + CASE WHEN query.total_intermediate_rows > 0 THEN 'true' + ELSE 'false' END +FROM metrics_output; +-- +ok +== +SELECT + CASE WHEN query.total_rows_scanned > 0 THEN 'true' + ELSE 'false' END +FROM metrics_output; +-- +ok +== +SELECT + CASE WHEN EXISTS( + SELECT + 1 + FROM information_schema.columns + WHERE table_name = 'metrics_output' AND column_name = 'query' + ) THEN 'true' + ELSE 'false' END; +-- +ok +== +SELECT + query.sql +FROM metrics_output; +-- +ok +== +SET tracked_metrics = []; +-- +ok +== +PRAGMA profiling_output = '{TEST_DIR}/profiling_output_no_query.json'; +-- +error: Parser Error: Profiler file type ({TEST_DIR}/profiling_output_no_query.json) must either have the same file extension as the profiling output type (query_tree), or be a '.txt' file. Set "enable_profiling = 'json'" first. +== +CREATE OR REPLACE TABLE metrics_output AS SELECT * FROM '{TEST_DIR}/profiling_output_no_query.json'; +-- +ok +== diff --git a/parser/testdata/corpus/sql/pragma/profiling/test_custom_profiling_disable_metrics.test.metadata.json b/parser/testdata/corpus/sql/pragma/profiling/test_custom_profiling_disable_metrics.test.metadata.json new file mode 100644 index 0000000..b3839fc --- /dev/null +++ b/parser/testdata/corpus/sql/pragma/profiling/test_custom_profiling_disable_metrics.test.metadata.json @@ -0,0 +1,5 @@ +{ + "todo": { + "1bf64e38825d2e20": "transformer-raised parser error: upstream rejects in the transformer, not the grammar; expected to clear as transformers land (milestones 3-5)" + } +} diff --git a/parser/testdata/corpus/sql/pragma/profiling/test_custom_profiling_errors.test b/parser/testdata/corpus/sql/pragma/profiling/test_custom_profiling_errors.test new file mode 100644 index 0000000..9f7afbf --- /dev/null +++ b/parser/testdata/corpus/sql/pragma/profiling/test_custom_profiling_errors.test @@ -0,0 +1,29 @@ +# source: test/sql/pragma/profiling/test_custom_profiling_errors.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +PRAGMA custom_profiling_settings='}}}}}}'; +-- +ok +== +PRAGMA custom_profiling_settings=BONJOUR; +-- +ok +== +PRAGMA configure_profiling='{"INVALID_SETTING": "true"}'; +-- +ok +== +SET configure_metrics = 'hello'; +-- +ok +== +SET tracked_metrics = ['*']; +-- +ok +== +SELECT unnest(current_setting('tracked_metrics')); +-- +ok +== diff --git a/parser/testdata/corpus/sql/pragma/profiling/test_custom_profiling_optimizer_settings.test b/parser/testdata/corpus/sql/pragma/profiling/test_custom_profiling_optimizer_settings.test new file mode 100644 index 0000000..89d56c2 --- /dev/null +++ b/parser/testdata/corpus/sql/pragma/profiling/test_custom_profiling_optimizer_settings.test @@ -0,0 +1,39 @@ +# source: test/sql/pragma/profiling/test_custom_profiling_optimizer_settings.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +SET profiling_mode='standard'; +-- +ok +== +SET tracked_metrics = ['optimizer.total_time']; +-- +ok +== +SET tracked_metrics = ['optimizer.join_order']; +-- +ok +== +SELECT + CASE WHEN optimizer.join_order > 0 THEN 'true' + ELSE 'false' END +FROM metrics_output; +-- +ok +== +SELECT + CASE WHEN optimizer.total_time > 0 THEN 'true' + ELSE 'false' END +FROM metrics_output; +-- +ok +== +SET profiling_mode = 'detailed'; +-- +ok +== +SET profiling_mode = 'standard'; +-- +ok +== diff --git a/parser/testdata/corpus/sql/pragma/profiling/test_custom_profiling_result_set_size.test b/parser/testdata/corpus/sql/pragma/profiling/test_custom_profiling_result_set_size.test new file mode 100644 index 0000000..1598575 --- /dev/null +++ b/parser/testdata/corpus/sql/pragma/profiling/test_custom_profiling_result_set_size.test @@ -0,0 +1,18 @@ +# source: test/sql/pragma/profiling/test_custom_profiling_result_set_size.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +SET tracked_metrics = ['operator.intermediate_size_bytes', 'operator.intermediate_rows']; +-- +ok +== +SELECT + CASE + WHEN operator[1].intermediate_size_bytes < 10_000 THEN NULL + ELSE operator[1].intermediate_size_bytes + END AS result +FROM metrics_output; +-- +ok +== diff --git a/parser/testdata/corpus/sql/pragma/profiling/test_custom_profiling_row_group_metrics_local_storage.test b/parser/testdata/corpus/sql/pragma/profiling/test_custom_profiling_row_group_metrics_local_storage.test new file mode 100644 index 0000000..43d4c27 --- /dev/null +++ b/parser/testdata/corpus/sql/pragma/profiling/test_custom_profiling_row_group_metrics_local_storage.test @@ -0,0 +1,67 @@ +# source: test/sql/pragma/profiling/test_custom_profiling_row_group_metrics_local_storage.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +CREATE TABLE local_pruned(i BIGINT); +-- +ok +== +INSERT INTO local_pruned VALUES + (1000000), (1000001), (1000002), (1000003), (1000004), + (1000005), (1000006), (1000007), (1000008), (1000009); +-- +ok +== +CREATE TABLE persistent_only(i BIGINT); +-- +ok +== +INSERT INTO persistent_only VALUES + (0), (1), (2), (3), (4), + (5), (6), (7), (8), (9); +-- +ok +== +INSERT INTO local_pruned VALUES + (0), (1), (2), (3), (4), + (5), (6), (7), (8), (9); +-- +ok +== +SET tracked_metrics = ['operator.row_groups_scanned', 'operator.total_row_groups_to_scan', 'operator.type', 'query.total_row_groups_scanned', 'query.total_row_groups_to_scan']; +-- +ok +== +SELECT count(*) FROM local_pruned a, persistent_only b WHERE a.i < 100 AND b.i < 100; +-- +ok +== +CREATE VIEW operator_metrics AS +SELECT t.type AS operator_type, + t.row_groups_scanned AS scanned, + t.total_row_groups_to_scan AS total +FROM '{TEST_DIR}/profiling_output.json' prof, + LATERAL unnest(prof.operator) t0(op0), + LATERAL unnest(op0.children) t1(op1), + LATERAL unnest(op1.children) t2(op2), + LATERAL unnest(op2.children) t3(t) +WHERE t.type = 'TABLE_SCAN'; +-- +ok +== +SELECT * FROM operator_metrics WHERE operator_type = 'TABLE_SCAN' ORDER BY total; +-- +ok +== +SELECT sum(scanned)::VARCHAR || '/' || sum(total)::VARCHAR +FROM operator_metrics +WHERE operator_type = 'TABLE_SCAN'; +-- +ok +== +SELECT query.total_row_groups_scanned::BIGINT, query.total_row_groups_to_scan::BIGINT +FROM '{TEST_DIR}/profiling_output.json'; +-- +ok +== diff --git a/parser/testdata/corpus/sql/pragma/profiling/test_custom_profiling_rows_scanned.test b/parser/testdata/corpus/sql/pragma/profiling/test_custom_profiling_rows_scanned.test new file mode 100644 index 0000000..b67bc80 --- /dev/null +++ b/parser/testdata/corpus/sql/pragma/profiling/test_custom_profiling_rows_scanned.test @@ -0,0 +1,32 @@ +# source: test/sql/pragma/profiling/test_custom_profiling_rows_scanned.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +SET tracked_metrics = ['operator.intermediate_rows', 'operator.rows_scanned', 'query.total_intermediate_rows', 'query.total_rows_scanned']; +-- +ok +== +SELECT * FROM integers i1, integers i2 WHERE i1.i = i2.i ORDER BY 1; +-- +ok +== +pragma disable_profiling; +-- +ok +== +SELECT query.total_intermediate_rows, query.total_rows_scanned FROM metrics_output; +-- +ok +== +SELECT + CASE WHEN query.total_rows_scanned = 8 THEN NULL + ELSE metrics_output END +FROM metrics_output; +-- +ok +== +SET tracked_metrics = ['query.total_intermediate_rows', 'query.total_rows_scanned', 'system.blocked_thread_time']; +-- +ok +== diff --git a/parser/testdata/corpus/sql/pragma/profiling/test_custom_profiling_rows_scanned_parquet.test b/parser/testdata/corpus/sql/pragma/profiling/test_custom_profiling_rows_scanned_parquet.test new file mode 100644 index 0000000..f3cd6ac --- /dev/null +++ b/parser/testdata/corpus/sql/pragma/profiling/test_custom_profiling_rows_scanned_parquet.test @@ -0,0 +1,24 @@ +# source: test/sql/pragma/profiling/test_custom_profiling_rows_scanned_parquet.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +COPY (SELECT * FROM range(0, 10) as r(i)) TO '{TEST_DIR}/range.parquet' (FORMAT 'parquet'); +-- +ok +== +COPY (SELECT * FROM range(0, 10) as r(i)) TO '{TEST_DIR}/range2.parquet' (FORMAT 'parquet'); +-- +ok +== +SELECT * FROM '{TEST_DIR}/range.parquet' order by all; +-- +ok +== +SELECT + CASE WHEN query.total_rows_scanned = 10 THEN 'true' + ELSE 'false' END +FROM metrics_output; +-- +ok +== diff --git a/parser/testdata/corpus/sql/pragma/profiling/test_custom_profiling_total_memory_allocated.test b/parser/testdata/corpus/sql/pragma/profiling/test_custom_profiling_total_memory_allocated.test new file mode 100644 index 0000000..b0870e9 --- /dev/null +++ b/parser/testdata/corpus/sql/pragma/profiling/test_custom_profiling_total_memory_allocated.test @@ -0,0 +1,56 @@ +# source: test/sql/pragma/profiling/test_custom_profiling_total_memory_allocated.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +SET tracked_metrics = ['system.total_memory_allocated']; +-- +ok +== +CREATE OR REPLACE TABLE test AS SELECT range AS id, hash(range) AS data FROM range(100000); +-- +ok +== +SELECT + CASE WHEN system.total_memory_allocated >= 0 THEN 'true' + ELSE 'false' END +FROM metrics_output; +-- +ok +== +SELECT id, COUNT(*) as cnt FROM test GROUP BY id ORDER BY id LIMIT 1000; +-- +ok +== +SET tracked_metrics = ['system.total_memory_allocated', 'operator.type']; +-- +ok +== +SELECT * FROM test WHERE id < 1000 ORDER BY id; +-- +ok +== +CREATE OR REPLACE TABLE metrics_children AS SELECT unnest(operator, recursive := true) FROM metrics_output; +-- +ok +== +SELECT system.total_memory_allocated FROM metrics_children; +-- +ok +== +CREATE OR REPLACE TABLE test2 AS SELECT range AS id FROM range(10000); +-- +ok +== +SELECT system.total_memory_allocated FROM metrics_output; +-- +ok +== +SET memory_limit = '100MB'; +-- +ok +== +CREATE OR REPLACE TABLE large_test AS SELECT range AS id, hash(range) AS data FROM range(1000000); +-- +ok +== diff --git a/parser/testdata/corpus/sql/pragma/profiling/test_custom_profiling_using_groups.test b/parser/testdata/corpus/sql/pragma/profiling/test_custom_profiling_using_groups.test new file mode 100644 index 0000000..9e2e2d3 --- /dev/null +++ b/parser/testdata/corpus/sql/pragma/profiling/test_custom_profiling_using_groups.test @@ -0,0 +1,141 @@ +# source: test/sql/pragma/profiling/test_custom_profiling_using_groups.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +SELECT operator[1].extra_info, + optimizer, + optimizer.total_time, + parser.total_time, + physical_planner.column_binding, + physical_planner.create_plan, + physical_planner.resolve_types, + physical_planner.total_time, + planner.binding_time, + planner.total_time, + operator[1].intermediate_size_bytes, + query.cpu_time, + query.total_intermediate_rows, + query.total_rows_scanned, + query.total_time, + query.sql, + system.blocked_thread_time, + system.peak_buffer_memory, + system.peak_temp_dir_size, + system.total_memory_allocated +FROM metrics_output; +-- +ok +== +SET tracked_metrics = ['query.*']; +-- +ok +== +SELECT query.cpu_time, + query.total_intermediate_rows, + query.total_rows_scanned, + query.total_time, + query.sql, +FROM metrics_output; +-- +ok +== +SET tracked_metrics = ['system.*']; +-- +ok +== +SELECT system.blocked_thread_time, + system.peak_buffer_memory, + system.peak_temp_dir_size, + system.total_memory_allocated +FROM metrics_output; +-- +ok +== +SET tracked_metrics = ['storage.*']; +-- +ok +== +SELECT EXISTS(SELECT 1 FROM information_schema.columns WHERE table_name='metrics_output' AND column_name='operator'); +-- +ok +== +SET tracked_metrics = ['operator.*']; +-- +ok +== +SELECT intermediate_rows, + timing, + type +FROM ( + SELECT unnest(operator, max_depth := 2) + FROM metrics_output +) +-- +ok +== +SET tracked_metrics = ['optimizer.*']; +-- +ok +== +SELECT optimizer FROM metrics_output; +-- +ok +== +SET tracked_metrics = ['optimizer.*', 'parser.*', 'physical_planner.*', 'planner.*']; +-- +ok +== +SELECT optimizer.total_time, + optimizer, + parser.total_time, + physical_planner.column_binding, + physical_planner.create_plan, + physical_planner.resolve_types, + physical_planner.total_time, + planner.binding_time, + planner.total_time +FROM metrics_output; +-- +ok +== +SET tracked_metrics = ['io.*', 'operator.*', 'query.*', 'storage.*', 'system.*']; +-- +ok +== +SELECT operator[1].extra_info, + operator[1].intermediate_size_bytes, + query.cpu_time, + query.total_intermediate_rows, + query.total_rows_scanned, + query.total_time, + query.sql, + system.blocked_thread_time, + system.peak_buffer_memory, + system.peak_temp_dir_size, + system.total_memory_allocated +FROM metrics_output; +-- +ok +== +SET tracked_metrics = ['optimizer.*', 'parser.*', 'physical_planner.*', 'planner.*', 'system.*', 'storage.*']; +-- +ok +== +SELECT optimizer.total_time, + optimizer, + parser.total_time, + physical_planner.column_binding, + physical_planner.create_plan, + physical_planner.resolve_types, + physical_planner.total_time, + planner.binding_time, + planner.total_time, + system.blocked_thread_time, + system.peak_buffer_memory, + system.peak_temp_dir_size, + system.total_memory_allocated +FROM metrics_output; +-- +ok +== diff --git a/parser/testdata/corpus/sql/pragma/profiling/test_duckdb_profiling_settings_function.test b/parser/testdata/corpus/sql/pragma/profiling/test_duckdb_profiling_settings_function.test new file mode 100644 index 0000000..e23101a --- /dev/null +++ b/parser/testdata/corpus/sql/pragma/profiling/test_duckdb_profiling_settings_function.test @@ -0,0 +1,33 @@ +# source: test/sql/pragma/profiling/test_duckdb_profiling_settings_function.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +SELECT * EXCLUDE(value, description) FROM duckdb_profiling_settings(); +-- +ok +== +PRAGMA enable_profiling='json'; +-- +ok +== +PRAGMA profiling_output='{TEST_DIR}/test_profiling_output.json'; +-- +error: Parser Error: Profiler file type ({TEST_DIR}/test_profiling_output.json) must either have the same file extension as the profiling output type (query_tree), or be a '.txt' file. Set "enable_profiling = 'json'" first. +== +PRAGMA profiling_coverage='ALL'; +-- +ok +== +PRAGMA profiling_mode='DETAILED'; +-- +ok +== +SET tracked_metrics = ['query.cpu_time']; +-- +ok +== +SELECT * EXCLUDE(description) FROM duckdb_profiling_settings(); +-- +ok +== diff --git a/parser/testdata/corpus/sql/pragma/profiling/test_duckdb_profiling_settings_function.test.metadata.json b/parser/testdata/corpus/sql/pragma/profiling/test_duckdb_profiling_settings_function.test.metadata.json new file mode 100644 index 0000000..1332ee5 --- /dev/null +++ b/parser/testdata/corpus/sql/pragma/profiling/test_duckdb_profiling_settings_function.test.metadata.json @@ -0,0 +1,5 @@ +{ + "todo": { + "0d20feb1c2e289a6": "transformer-raised parser error: upstream rejects in the transformer, not the grammar; expected to clear as transformers land (milestones 3-5)" + } +} diff --git a/parser/testdata/corpus/sql/pragma/profiling/test_empty_profiling_settings.test b/parser/testdata/corpus/sql/pragma/profiling/test_empty_profiling_settings.test new file mode 100644 index 0000000..9bc1163 --- /dev/null +++ b/parser/testdata/corpus/sql/pragma/profiling/test_empty_profiling_settings.test @@ -0,0 +1,25 @@ +# source: test/sql/pragma/profiling/test_empty_profiling_settings.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +SELECT cpu_time FROM metrics_output; +-- +ok +== +SELECT extra_info FROM metrics_output; +-- +ok +== +SELECT operator_cardinality FROM metrics_output; +-- +ok +== +SELECT operator_timing FROM metrics_output; +-- +ok +== +SELECT cumulative_cardinality FROM metrics_output; +-- +ok +== diff --git a/parser/testdata/corpus/sql/pragma/profiling/test_legacy_metrics_format.test b/parser/testdata/corpus/sql/pragma/profiling/test_legacy_metrics_format.test new file mode 100644 index 0000000..a86f461 --- /dev/null +++ b/parser/testdata/corpus/sql/pragma/profiling/test_legacy_metrics_format.test @@ -0,0 +1,49 @@ +# source: test/sql/pragma/profiling/test_legacy_metrics_format.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +SET tracked_metrics = ['query.total_time', 'query.cpu_time', 'query.sql', 'query.total_intermediate_rows', 'query.total_rows_scanned', 'operator.type', 'operator.timing', 'operator.intermediate_rows']; +-- +ok +== +SET legacy_metrics_format = true; +-- +ok +== +SELECT latency, cpu_time, query_name, cumulative_cardinality, cumulative_rows_scanned FROM metrics_output; +-- +ok +== +SELECT EXISTS(SELECT 1 FROM information_schema.columns WHERE table_name='metrics_output' AND column_name='query'); +-- +ok +== +SELECT children IS NOT NULL FROM metrics_output; +-- +ok +== +SELECT children[1].operator_type, children[1].operator_timing FROM metrics_output; +-- +ok +== +SET tracked_metrics = ['query.total_time', 'operator.type', 'operator.timing']; +-- +ok +== +SET legacy_metrics_format = false; +-- +ok +== +SELECT query.total_time FROM metrics_output; +-- +ok +== +SELECT operator IS NOT NULL FROM metrics_output; +-- +ok +== +SELECT EXISTS(SELECT 1 FROM information_schema.columns WHERE table_name='metrics_output' AND column_name='latency'); +-- +ok +== diff --git a/parser/testdata/corpus/sql/pragma/profiling/test_logging_interaction.test b/parser/testdata/corpus/sql/pragma/profiling/test_logging_interaction.test new file mode 100644 index 0000000..48a4b35 --- /dev/null +++ b/parser/testdata/corpus/sql/pragma/profiling/test_logging_interaction.test @@ -0,0 +1,37 @@ +# source: test/sql/pragma/profiling/test_logging_interaction.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +PRAGMA profiling_output = '{TEST_DIR}/profile_attach.json'; +-- +error: Parser Error: Profiler file type ({TEST_DIR}/profile_attach.json) must either have the same file extension as the profiling output type (query_tree), or be a '.txt' file. Set "enable_profiling = 'json'" first. +== +ATTACH '{TEST_DIR}/profiler_logger.db' AS my_db; +-- +ok +== +USE my_db; +-- +ok +== +call enable_logging(); +-- +ok +== +CREATE TABLE small AS FROM range(100); +-- +ok +== +CREATE TABLE medium AS FROM range(10000); +-- +ok +== +CREATE TABLE big AS FROM range(1000000); +-- +ok +== +SELECT count(*) FROM duckdb_logs_parsed('Metrics') WHERE metric == 'query.cpu_time'; +-- +ok +== diff --git a/parser/testdata/corpus/sql/pragma/profiling/test_logging_interaction.test.metadata.json b/parser/testdata/corpus/sql/pragma/profiling/test_logging_interaction.test.metadata.json new file mode 100644 index 0000000..5a7e4f7 --- /dev/null +++ b/parser/testdata/corpus/sql/pragma/profiling/test_logging_interaction.test.metadata.json @@ -0,0 +1,5 @@ +{ + "todo": { + "bc519dcc03daf997": "transformer-raised parser error: upstream rejects in the transformer, not the grammar; expected to clear as transformers land (milestones 3-5)" + } +} diff --git a/parser/testdata/corpus/sql/pragma/profiling/test_no_reset_setting.test b/parser/testdata/corpus/sql/pragma/profiling/test_no_reset_setting.test new file mode 100644 index 0000000..e89dd25 --- /dev/null +++ b/parser/testdata/corpus/sql/pragma/profiling/test_no_reset_setting.test @@ -0,0 +1,13 @@ +# source: test/sql/pragma/profiling/test_no_reset_setting.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +PRAGMA profiling_output = '{TEST_DIR}/profile_file.json'; +-- +error: Parser Error: Profiler file type ({TEST_DIR}/profile_file.json) must either have the same file extension as the profiling output type (query_tree), or be a '.txt' file. Set "enable_profiling = 'json'" first. +== +SET tracked_metrics = ['io.total_bytes_read', 'io.total_bytes_written']; +-- +ok +== diff --git a/parser/testdata/corpus/sql/pragma/profiling/test_no_reset_setting.test.metadata.json b/parser/testdata/corpus/sql/pragma/profiling/test_no_reset_setting.test.metadata.json new file mode 100644 index 0000000..a904794 --- /dev/null +++ b/parser/testdata/corpus/sql/pragma/profiling/test_no_reset_setting.test.metadata.json @@ -0,0 +1,5 @@ +{ + "todo": { + "cd037695c2fbba16": "transformer-raised parser error: upstream rejects in the transformer, not the grammar; expected to clear as transformers land (milestones 3-5)" + } +} diff --git a/parser/testdata/corpus/sql/pragma/profiling/test_operator_info_suppression.test b/parser/testdata/corpus/sql/pragma/profiling/test_operator_info_suppression.test new file mode 100644 index 0000000..4ffc4d5 --- /dev/null +++ b/parser/testdata/corpus/sql/pragma/profiling/test_operator_info_suppression.test @@ -0,0 +1,9 @@ +# source: test/sql/pragma/profiling/test_operator_info_suppression.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +SET tracked_metrics = ['operator.timing']; +-- +ok +== diff --git a/parser/testdata/corpus/sql/pragma/profiling/test_profiling_all.test b/parser/testdata/corpus/sql/pragma/profiling/test_profiling_all.test new file mode 100644 index 0000000..c395d7e --- /dev/null +++ b/parser/testdata/corpus/sql/pragma/profiling/test_profiling_all.test @@ -0,0 +1,53 @@ +# source: test/sql/pragma/profiling/test_profiling_all.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +ATTACH '{TEST_DIR}/profile_attach.db'; +-- +ok +== +SET profiling_coverage='SELECT'; +-- +ok +== +CREATE OR REPLACE TABLE metrics_output AS SELECT * FROM '{TEST_DIR}/profile_attach.json'; +-- +ok +== +SELECT query.total_time != 0, contains(query.sql, 'ATTACH') FROM metrics_output; +-- +ok +== +CREATE TABLE profile_attach.tbl AS SELECT range AS id FROM range(10000); +-- +ok +== +SELECT query.total_time != 0, contains(query.sql, 'CREATE TABLE') FROM metrics_output; +-- +ok +== +INSERT INTO profile_attach.tbl SELECT range + 20000 FROM range(10000); +-- +ok +== +SELECT query.total_time != 0, contains(query.sql, 'INSERT INTO') FROM metrics_output; +-- +ok +== +CREATE INDEX idx ON profile_attach.tbl(id); +-- +ok +== +SELECT query.total_time != 0, contains(query.sql, 'CREATE INDEX') FROM metrics_output; +-- +ok +== +DETACH profile_attach; +-- +ok +== +SELECT query.total_time != 0, contains(query.sql, 'DETACH') FROM metrics_output; +-- +ok +== diff --git a/parser/testdata/corpus/sql/pragma/profiling/test_profiling_fs.test b/parser/testdata/corpus/sql/pragma/profiling/test_profiling_fs.test new file mode 100644 index 0000000..b28abf4 --- /dev/null +++ b/parser/testdata/corpus/sql/pragma/profiling/test_profiling_fs.test @@ -0,0 +1,35 @@ +# source: test/sql/pragma/profiling/test_profiling_fs.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +CREATE TABLE profile_fs.tbl AS SELECT range AS id FROM range(10000); +-- +ok +== +SELECT io.total_bytes_written FROM metrics_output; +-- +ok +== +SELECT + CASE WHEN io.total_bytes_written > 0 THEN 'true' + ELSE 'false' END +FROM metrics_output; +-- +ok +== +CREATE INDEX idx ON profile_fs.tbl(id); +-- +ok +== +SELECT * FROM profile_fs.tbl; +-- +ok +== +SELECT + CASE WHEN io.total_bytes_read > 0 THEN 'true' + ELSE 'false' END +FROM metrics_output; +-- +ok +== diff --git a/parser/testdata/corpus/sql/pragma/profiling/test_profiling_output_file_overwrite.test b/parser/testdata/corpus/sql/pragma/profiling/test_profiling_output_file_overwrite.test new file mode 100644 index 0000000..81afae5 --- /dev/null +++ b/parser/testdata/corpus/sql/pragma/profiling/test_profiling_output_file_overwrite.test @@ -0,0 +1,45 @@ +# source: test/sql/pragma/profiling/test_profiling_output_file_overwrite.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +PRAGMA profiling_output = '{TEST_DIR}/profiler.json'; +-- +error: Parser Error: Profiler file type ({TEST_DIR}/profiler.json) must either have the same file extension as the profiling output type (query_tree), or be a '.txt' file. Set "enable_profiling = 'json'" first. +== +PRAGMA enable_profiling = 'html'; +-- +ok +== +RESET profiling_output; +-- +ok +== +PRAGMA profiling_output = '{TEST_DIR}/profiler.txt'; +-- +ok +== +PRAGMA enable_profiling = 'query_tree'; +-- +ok +== +PRAGMA enable_profiling = 'GRAPHVIZ'; +-- +ok +== +RESET enable_profiling; +-- +ok +== +ATTACH '{TEST_DIR}/my_important_database.db'; +-- +ok +== +PRAGMA profiling_output = '{TEST_DIR}/my_important_database.db.db'; +-- +error: Parser Error: Invalid output file type: db +== +PRAGMA enable_profiling = 'db'; +-- +ok +== diff --git a/parser/testdata/corpus/sql/pragma/profiling/test_profiling_output_file_overwrite.test.metadata.json b/parser/testdata/corpus/sql/pragma/profiling/test_profiling_output_file_overwrite.test.metadata.json new file mode 100644 index 0000000..e6f09c8 --- /dev/null +++ b/parser/testdata/corpus/sql/pragma/profiling/test_profiling_output_file_overwrite.test.metadata.json @@ -0,0 +1,6 @@ +{ + "todo": { + "1603dedee627838d": "transformer-raised parser error: upstream rejects in the transformer, not the grammar; expected to clear as transformers land (milestones 3-5)", + "21f537269ccbd0b5": "transformer-raised parser error: upstream rejects in the transformer, not the grammar; expected to clear as transformers land (milestones 3-5)" + } +} diff --git a/parser/testdata/corpus/sql/pragma/test_db_invalidation_after_load.test b/parser/testdata/corpus/sql/pragma/test_db_invalidation_after_load.test new file mode 100644 index 0000000..3ccb2a6 --- /dev/null +++ b/parser/testdata/corpus/sql/pragma/test_db_invalidation_after_load.test @@ -0,0 +1,13 @@ +# source: test/sql/pragma/test_db_invalidation_after_load.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +SET disable_database_invalidation=true; +-- +ok +== +SET allow_unredacted_secrets=true; +-- +ok +== diff --git a/parser/testdata/corpus/sql/pragma/test_disabled_compression.test b/parser/testdata/corpus/sql/pragma/test_disabled_compression.test new file mode 100644 index 0000000..4b3fd1c --- /dev/null +++ b/parser/testdata/corpus/sql/pragma/test_disabled_compression.test @@ -0,0 +1,21 @@ +# source: test/sql/pragma/test_disabled_compression.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +PRAGMA disabled_compression_methods='{compression}' +-- +ok +== +PRAGMA disabled_compression_methods='uncompressed,rle' +-- +ok +== +PRAGMA disabled_compression_methods='dictionary,rle' +-- +ok +== +PRAGMA disabled_compression_methods='xzx' +-- +ok +== diff --git a/parser/testdata/corpus/sql/pragma/test_enable_profile.test b/parser/testdata/corpus/sql/pragma/test_enable_profile.test new file mode 100644 index 0000000..120a68e --- /dev/null +++ b/parser/testdata/corpus/sql/pragma/test_enable_profile.test @@ -0,0 +1,25 @@ +# source: test/sql/pragma/test_enable_profile.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +PRAGMA enable_profiling() +-- +error: Parser Error: syntax error at or near ")" +== +PRAGMA enable_profiling='unsupported' +-- +ok +== +PRAGMA profiling_output +-- +ok +== +PRAGMA profiling_output='test.json' +-- +error: Parser Error: Profiler file type (test.json) must either have the same file extension as the profiling output type (query_tree), or be a '.txt' file. Set "enable_profiling = 'json'" first. +== +PRAGMA profiling_output='' +-- +ok +== diff --git a/parser/testdata/corpus/sql/pragma/test_enable_profile.test.metadata.json b/parser/testdata/corpus/sql/pragma/test_enable_profile.test.metadata.json new file mode 100644 index 0000000..9331fb2 --- /dev/null +++ b/parser/testdata/corpus/sql/pragma/test_enable_profile.test.metadata.json @@ -0,0 +1,5 @@ +{ + "todo": { + "864fb44520179e80": "transformer-raised parser error: upstream rejects in the transformer, not the grammar; expected to clear as transformers land (milestones 3-5)" + } +} diff --git a/parser/testdata/corpus/sql/pragma/test_force_compression.test b/parser/testdata/corpus/sql/pragma/test_force_compression.test new file mode 100644 index 0000000..05472ef --- /dev/null +++ b/parser/testdata/corpus/sql/pragma/test_force_compression.test @@ -0,0 +1,13 @@ +# source: test/sql/pragma/test_force_compression.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +PRAGMA force_compression='{compression}' +-- +ok +== +PRAGMA force_compression='unknown' +-- +ok +== diff --git a/parser/testdata/corpus/sql/pragma/test_memory_limit.test b/parser/testdata/corpus/sql/pragma/test_memory_limit.test new file mode 100644 index 0000000..d302bf5 --- /dev/null +++ b/parser/testdata/corpus/sql/pragma/test_memory_limit.test @@ -0,0 +1,153 @@ +# source: test/sql/pragma/test_memory_limit.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +PRAGMA memory_limit='1GB' +-- +ok +== +PRAGMA memory_limit=-1 +-- +ok +== +PRAGMA memory_limit='-1' +-- +ok +== +PRAGMA memory_limit='none' +-- +ok +== +PRAGMA memory_limit=' -1' +-- +ok +== +PRAGMA memory_limit='1G' +-- +ok +== +PRAGMA memory_limit=' 1G' +-- +ok +== +PRAGMA memory_limit='1gb' +-- +ok +== +PRAGMA memory_limit = '1GB' +-- +ok +== +PRAGMA memory_limit='1.0gb' +-- +ok +== +PRAGMA memory_limit='1.0 gb' +-- +ok +== +PRAGMA memory_limit='488.2 MiB' +-- +ok +== +PRAGMA memory_limit='1.0 gigabytes' +-- +ok +== +PRAGMA memory_limit='100M' +-- +ok +== +PRAGMA memory_limit='100MB' +-- +ok +== +PRAGMA memory_limit='100mb' +-- +ok +== +PRAGMA memory_limit='100 megabytes' +-- +ok +== +PRAGMA memory_limit='10000K' +-- +ok +== +PRAGMA memory_limit='10000KB' +-- +ok +== +PRAGMA memory_limit='10000kb' +-- +ok +== +PRAGMA memory_limit='10000 kilobytes' +-- +ok +== +PRAGMA memory_limit='1000000B' +-- +ok +== +PRAGMA memory_limit='1000000b' +-- +ok +== +PRAGMA memory_limit='1000000 bytes' +-- +ok +== +PRAGMA memory_limit='0.01T' +-- +ok +== +PRAGMA memory_limit='0.01TB' +-- +ok +== +PRAGMA memory_limit='0.01tb' +-- +ok +== +PRAGMA memory_limit='0.01 terabytes' +-- +ok +== +PRAGMA memory_limit=100 +-- +error: Parser Error: Unknown unit for memory: '' (expected: KB, MB, GB, TB for 1000^i units or KiB, MiB, GiB, TiB for 1024^i units) +== +PRAGMA memory_limit='0.01BG' +-- +error: Parser Error: Unknown unit for memory: 'bg' (expected: KB, MB, GB, TB for 1000^i units or KiB, MiB, GiB, TiB for 1024^i units) +== +PRAGMA memory_limit='0.01BLA' +-- +error: Parser Error: Unknown unit for memory: 'bla' (expected: KB, MB, GB, TB for 1000^i units or KiB, MiB, GiB, TiB for 1024^i units) +== +PRAGMA memory_limit='0.01PP' +-- +error: Parser Error: Unknown unit for memory: 'pp' (expected: KB, MB, GB, TB for 1000^i units or KiB, MiB, GiB, TiB for 1024^i units) +== +PRAGMA memory_limit='0.01TEST' +-- +error: Parser Error: Unknown unit for memory: 'test' (expected: KB, MB, GB, TB for 1000^i units or KiB, MiB, GiB, TiB for 1024^i units) +== +PRAGMA memory_limit +-- +ok +== +PRAGMA memory_limit() +-- +error: Parser Error: syntax error at or near ")" +== +PRAGMA memory_limit(1, 2) +-- +ok +== +PRAGMA memory_limit='blabla' +-- +error: Parser Error: Memory must have a number (e.g. 1GB) +== diff --git a/parser/testdata/corpus/sql/pragma/test_memory_limit.test.metadata.json b/parser/testdata/corpus/sql/pragma/test_memory_limit.test.metadata.json new file mode 100644 index 0000000..a428b51 --- /dev/null +++ b/parser/testdata/corpus/sql/pragma/test_memory_limit.test.metadata.json @@ -0,0 +1,10 @@ +{ + "todo": { + "0d5d26c75bb47c33": "transformer-raised parser error: upstream rejects in the transformer, not the grammar; expected to clear as transformers land (milestones 3-5)", + "8868ad02aeb4b7fc": "transformer-raised parser error: upstream rejects in the transformer, not the grammar; expected to clear as transformers land (milestones 3-5)", + "908f3a0729f66a0b": "transformer-raised parser error: upstream rejects in the transformer, not the grammar; expected to clear as transformers land (milestones 3-5)", + "ae6d8be7e8f2577e": "transformer-raised parser error: upstream rejects in the transformer, not the grammar; expected to clear as transformers land (milestones 3-5)", + "bedc8dd4f19175dd": "transformer-raised parser error: upstream rejects in the transformer, not the grammar; expected to clear as transformers land (milestones 3-5)", + "c275efc796943d1c": "transformer-raised parser error: upstream rejects in the transformer, not the grammar; expected to clear as transformers land (milestones 3-5)" + } +} diff --git a/parser/testdata/corpus/sql/pragma/test_metadata_info.test b/parser/testdata/corpus/sql/pragma/test_metadata_info.test new file mode 100644 index 0000000..27d0418 --- /dev/null +++ b/parser/testdata/corpus/sql/pragma/test_metadata_info.test @@ -0,0 +1,29 @@ +# source: test/sql/pragma/test_metadata_info.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +PRAGMA metadata_info; +-- +ok +== +FROM pragma_metadata_info(); +-- +ok +== +ATTACH '{TEST_DIR}/test_metadata_info_attach.db' AS db1 +-- +ok +== +CREATE TABLE db1.integers(i INTEGER, j INTEGER) +-- +ok +== +FROM pragma_metadata_info('db1'); +-- +ok +== +FROM pragma_metadata_info(NULL) +-- +ok +== diff --git a/parser/testdata/corpus/sql/pragma/test_pragma_database_list.test b/parser/testdata/corpus/sql/pragma/test_pragma_database_list.test new file mode 100644 index 0000000..e910487 --- /dev/null +++ b/parser/testdata/corpus/sql/pragma/test_pragma_database_list.test @@ -0,0 +1,21 @@ +# source: test/sql/pragma/test_pragma_database_list.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +PRAGMA database_list +-- +ok +== +SELECT * FROM pragma_database_list +-- +ok +== +SELECT name, file FROM pragma_database_list +-- +ok +== +PRAGMA database_list() +-- +error: Parser Error: syntax error at or near ")" +== diff --git a/parser/testdata/corpus/sql/pragma/test_pragma_database_size.test b/parser/testdata/corpus/sql/pragma/test_pragma_database_size.test new file mode 100644 index 0000000..792b1a0 --- /dev/null +++ b/parser/testdata/corpus/sql/pragma/test_pragma_database_size.test @@ -0,0 +1,33 @@ +# source: test/sql/pragma/test_pragma_database_size.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +PRAGMA database_size; +-- +ok +== +ATTACH '{TEST_DIR}/db_size.db' AS db1 +-- +ok +== +CREATE TABLE db1.integers AS FROM range(1000000); +-- +ok +== +DROP TABLE db1.integers +-- +ok +== +SELECT case when used_blocks <= 3 then NULL else t end FROM pragma_database_size() t WHERE database_name='db1'; +-- +ok +== +ATTACH '{TEST_DIR}/db_size.db' AS db1 (READ_ONLY) +-- +ok +== +SELECT case when used_blocks <= 3 then NULL else t end FROM pragma_database_size() t WHERE database_name='db1'; +-- +ok +== diff --git a/parser/testdata/corpus/sql/pragma/test_pragma_functions.test b/parser/testdata/corpus/sql/pragma/test_pragma_functions.test new file mode 100644 index 0000000..048edae --- /dev/null +++ b/parser/testdata/corpus/sql/pragma/test_pragma_functions.test @@ -0,0 +1,9 @@ +# source: test/sql/pragma/test_pragma_functions.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +PRAGMA functions +-- +ok +== diff --git a/parser/testdata/corpus/sql/pragma/test_pragma_parsing.test b/parser/testdata/corpus/sql/pragma/test_pragma_parsing.test new file mode 100644 index 0000000..a001b45 --- /dev/null +++ b/parser/testdata/corpus/sql/pragma/test_pragma_parsing.test @@ -0,0 +1,25 @@ +# source: test/sql/pragma/test_pragma_parsing.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +PRAG +-- +ok +== +PRAGMA +-- +ok +== +PRAGMA random_unknown_pragma +-- +ok +== +PRAGMA table_info = 3 +-- +ok +== + PRAGMA table_info ('integers'); +-- +ok +== diff --git a/parser/testdata/corpus/sql/pragma/test_pragma_sanitized_inputs.test b/parser/testdata/corpus/sql/pragma/test_pragma_sanitized_inputs.test new file mode 100644 index 0000000..a7a4a6b --- /dev/null +++ b/parser/testdata/corpus/sql/pragma/test_pragma_sanitized_inputs.test @@ -0,0 +1,29 @@ +# source: test/sql/pragma/test_pragma_sanitized_inputs.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +CREATE TABLE test_table(i INTEGER, j VARCHAR) +-- +ok +== +INSERT INTO test_table VALUES (1, 'hello'), (2, 'world') +-- +ok +== +PRAGMA {pragma_func}('test_table''); DROP TABLE test_table; --') +-- +error: Parser Error: syntax error at or near "{" +== +PRAGMA import_database('test_table''); DROP TABLE test_table; --') +-- +ok +== +PRAGMA copy_database('test_table''); DROP TABLE test_table; --', 'target') +-- +ok +== +SELECT * FROM test_table ORDER BY i +-- +ok +== diff --git a/parser/testdata/corpus/sql/pragma/test_pragma_version.test b/parser/testdata/corpus/sql/pragma/test_pragma_version.test new file mode 100644 index 0000000..68689e4 --- /dev/null +++ b/parser/testdata/corpus/sql/pragma/test_pragma_version.test @@ -0,0 +1,53 @@ +# source: test/sql/pragma/test_pragma_version.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +PRAGMA version; +-- +ok +== +select * from pragma_version(); +-- +ok +== +select library_version from pragma_version(); +-- +ok +== +PRAGMA platform; +-- +ok +== +select * from pragma_platform(); +-- +ok +== +select platform from pragma_platform(); +-- +ok +== +SELECT count(*) FROM pragma_version() WHERE library_version LIKE 'v%'; +-- +ok +== +pragma extension_versions; +-- +ok +== +SET VARIABLE v = (select library_version from pragma_version()); +-- +ok +== +SET VARIABLE v_or_latest = (select CASE WHEN getvariable('v') ILIKE 'v%-dev%' THEN 'latest' WHEN getvariable('v') ILIKE 'v%-alpha%' THEN 'latest' WHEN getvariable('v') ILIKE 'v0.0.1' THEN 'latest' ELSE getvariable('v') END); +-- +ok +== +SET VARIABLE codename = (select CASE WHEN getvariable('v') ILIKE 'v%-dev%' THEN 'Development Version' WHEN getvariable('v') ILIKE 'v0.0.1' THEN 'Unknown Version' ELSE '%' END); +-- +ok +== +select count(*) FROM (select codename from pragma_version() WHERE codename LIKE getvariable('codename')); +-- +ok +== diff --git a/parser/testdata/corpus/sql/pragma/test_query_log.test b/parser/testdata/corpus/sql/pragma/test_query_log.test new file mode 100644 index 0000000..911792a --- /dev/null +++ b/parser/testdata/corpus/sql/pragma/test_query_log.test @@ -0,0 +1,25 @@ +# source: test/sql/pragma/test_query_log.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +SELECT CURRENT_SETTING('log_query_path') +-- +ok +== +PRAGMA log_query_path='{TEST_DIR}/query_log.txt' +-- +ok +== +SELECT 100;SELECT 200 +-- +ok +== +PRAGMA log_query_path='' +-- +ok +== +SELECT * FROM read_csv('{TEST_DIR}/query_log.txt', columns={'sql': 'VARCHAR'}, auto_detect=false) +-- +ok +== diff --git a/parser/testdata/corpus/sql/pragma/test_show_tables.test b/parser/testdata/corpus/sql/pragma/test_show_tables.test new file mode 100644 index 0000000..d2caed4 --- /dev/null +++ b/parser/testdata/corpus/sql/pragma/test_show_tables.test @@ -0,0 +1,85 @@ +# source: test/sql/pragma/test_show_tables.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +CREATE TABLE "select"(i INTEGER); +-- +ok +== +CREATE VIEW v1 AS SELECT DATE '1992-01-01' AS k +-- +ok +== +CREATE TABLE t2 (id INTEGER PRIMARY KEY, j VARCHAR UNIQUE) +-- +ok +== +CREATE TABLE s1.tbl(i INTEGER UNIQUE); +-- +ok +== +CREATE INDEX my_index ON s1.tbl(i); +-- +ok +== +CREATE TABLE tbl(i INTEGER PRIMARY KEY); +-- +ok +== +CREATE INDEX not_a_table ON tbl(i); +-- +ok +== +DESCRIBE s1.tbl; +-- +ok +== +DESCRIBE my_index; +-- +ok +== +DESCRIBE tbl; +-- +ok +== +DESCRIBE t2 +-- +ok +== +PRAGMA "SHOW"('t2') +-- +ok +== +DESCRIBE TABLES +-- +ok +== +PRAGMA show_tables +-- +ok +== +SHOW integers +-- +ok +== +SHOW "select"; +-- +ok +== +PRAGMA "SHOW"('integers') +-- +ok +== +DESCRIBE v1 +-- +ok +== +CREATE VIEW show_tables_view AS ( SHOW TABLES ); +-- +ok +== +SELECT * FROM show_tables_view ORDER BY ALL +-- +ok +== diff --git a/parser/testdata/corpus/sql/pragma/test_show_tables_from.test b/parser/testdata/corpus/sql/pragma/test_show_tables_from.test new file mode 100644 index 0000000..1c934fd --- /dev/null +++ b/parser/testdata/corpus/sql/pragma/test_show_tables_from.test @@ -0,0 +1,109 @@ +# source: test/sql/pragma/test_show_tables_from.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +ATTACH IF NOT EXISTS ':memory:' AS db +-- +ok +== +USE db +-- +ok +== +CREATE TABLE main_table1(i INTEGER) +-- +ok +== +CREATE SCHEMA test_schema +-- +ok +== +CREATE TABLE test_schema.test_schema_table1(k INTEGER) +-- +ok +== +ATTACH DATABASE ':memory:' AS db1 +-- +ok +== +CREATE TABLE db1.db1_table1(m INTEGER) +-- +ok +== +CREATE SCHEMA db1.db1_schema +-- +ok +== +CREATE TABLE db1.db1_schema.db1_schema_table1(n INTEGER) +-- +ok +== +ATTACH DATABASE ':memory:' AS "db_quo""ted" +-- +ok +== +CREATE SCHEMA "db_quo""ted"."db_quo""ted_schema"; +-- +ok +== +CREATE TABLE "db_quo""ted"."db_quo""ted_schema"."db_quo""ted_table1"(m INTEGER) +-- +ok +== +SHOW TABLES FROM db.main +-- +ok +== +SHOW TABLES FROM db1 +-- +ok +== +SHOW TABLES FROM test_schema +-- +ok +== +SHOW TABLES FROM db1.main +-- +ok +== +SHOW TABLES FROM db1.db1_schema +-- +ok +== +SHOW TABLES FROM DB1 +-- +ok +== +SHOW TABLES FROM DB1.DB1_SCHEMA +-- +ok +== +SHOW TABLES FROM db1.DB1_SCHEMA +-- +ok +== +CREATE SCHEMA "Quoted Schema" +-- +ok +== +CREATE TABLE "Quoted Schema"."Quoted Table"(r INTEGER) +-- +ok +== +SHOW TABLES FROM db."Quoted Schema" +-- +ok +== +SHOW TABLES FROM "db_quo""ted"."db_quo""ted_schema" +-- +ok +== +SHOW TABLES FROM nonexistent_db +-- +ok +== +SHOW TABLES FROM main.nonexistent_schema +-- +ok +== diff --git a/parser/testdata/corpus/sql/pragma/test_show_tables_temp_views.test b/parser/testdata/corpus/sql/pragma/test_show_tables_temp_views.test new file mode 100644 index 0000000..0b7db47 --- /dev/null +++ b/parser/testdata/corpus/sql/pragma/test_show_tables_temp_views.test @@ -0,0 +1,25 @@ +# source: test/sql/pragma/test_show_tables_temp_views.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +CREATE TEMPORARY VIEW v1 AS SELECT 42 AS a +-- +ok +== +CREATE VIEW v2 AS SELECT 42 AS b +-- +ok +== +CREATE VIEW s1.v3 AS SELECT 42 AS c +-- +ok +== +SET schema='s1'; +-- +ok +== +FROM v2 +-- +ok +== diff --git a/parser/testdata/corpus/sql/pragma/test_storage_info.test b/parser/testdata/corpus/sql/pragma/test_storage_info.test new file mode 100644 index 0000000..f23abe3 --- /dev/null +++ b/parser/testdata/corpus/sql/pragma/test_storage_info.test @@ -0,0 +1,44 @@ +# source: test/sql/pragma/test_storage_info.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +PRAGMA storage_info('integers') +-- +ok +== +INSERT INTO integers VALUES (1, 1), (2, NULL), (3, 3), (4, 5) +-- +ok +== +PRAGMA storage_info('v1') +-- +ok +== +PRAGMA storage_info('bla') +-- +ok +== +CREATE TABLE different_types(i INTEGER, j VARCHAR, k STRUCT(k INTEGER, l VARCHAR)) +-- +ok +== +INSERT INTO different_types VALUES (1, 'hello', {'k': 3, 'l': 'hello'}), (2, 'world', {'k': 3, 'l': 'thisisaverylongstring'}) +-- +ok +== +PRAGMA storage_info('different_types') +-- +ok +== +CREATE TABLE nested_lists AS SELECT + [1, 2, 3] i, + [['hello', 'world'], [NULL]] j, + [{'a': 3}, {'a': 4}] k; +-- +ok +== +PRAGMA storage_info('nested_lists') +-- +ok +== diff --git a/parser/testdata/corpus/sql/pragma/test_table_info.test b/parser/testdata/corpus/sql/pragma/test_table_info.test new file mode 100644 index 0000000..146b747 --- /dev/null +++ b/parser/testdata/corpus/sql/pragma/test_table_info.test @@ -0,0 +1,88 @@ +# source: test/sql/pragma/test_table_info.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +CREATE TABLE integers(i INTEGER DEFAULT 1+3, j INTEGER) +-- +ok +== +PRAGMA table_info(integers); +-- +ok +== +PRAGMA table_info='integers'; +-- +ok +== +PRAGMA table_info=integers; +-- +ok +== +CREATE VIEW v1 AS SELECT 42::INTEGER AS a, 'hello' AS b +-- +ok +== +PRAGMA table_info('v1') +-- +ok +== +CREATE VIEW v2(c) AS SELECT 42::INTEGER AS a, 'hello' AS b +-- +ok +== +PRAGMA table_info('v2') +-- +ok +== +CREATE VIEW v3(c, d) AS SELECT DATE '1992-01-01' a, 'hello' AS b +-- +ok +== +PRAGMA table_info('v3') +-- +ok +== +CREATE VIEW test.v1 AS SELECT 42::INTEGER AS a, 'hello' AS b +-- +ok +== +PRAGMA table_info('test.v1') +-- +ok +== +PRAGMA table_info('nonexistant_table'); +-- +ok +== +create table tconstraint1(i integer primary key default(3), j blob not null); +-- +ok +== +PRAGMA table_info(tconstraint1) +-- +ok +== +create table tconstraint2(i integer, j integer, k integer, l integer unique, primary key(i, j, k)); +-- +ok +== +PRAGMA table_info(tconstraint2) +-- +ok +== +PRAGMA table_info(1,2,3); +-- +ok +== +create table t1 ( + c1 int, + c2 int generated always as (c1 + 1) +); +-- +ok +== +SELECT * FROM pragma_table_info(t1); +-- +ok +== diff --git a/parser/testdata/corpus/sql/pragma/test_table_info_quoted_names.test b/parser/testdata/corpus/sql/pragma/test_table_info_quoted_names.test new file mode 100644 index 0000000..c2c4d85 --- /dev/null +++ b/parser/testdata/corpus/sql/pragma/test_table_info_quoted_names.test @@ -0,0 +1,57 @@ +# source: test/sql/pragma/test_table_info_quoted_names.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +CREATE SCHEMA "my.schema" +-- +ok +== +CREATE TABLE "my.schema"."dotted.name"(i INTEGER) +-- +ok +== +SELECT count(*) FROM pragma_table_info('"my.schema"."dotted.name"') +-- +ok +== +CREATE TABLE "quo""ted"(i INTEGER, j INTEGER) +-- +ok +== +SELECT count(*) FROM pragma_table_info('"quo""ted"') +-- +ok +== +CREATE TABLE quoted(i INTEGER) +-- +ok +== +CREATE TABLE """"(i INTEGER) +-- +ok +== +SELECT count(*) FROM pragma_table_info('""""') +-- +ok +== +SELECT * FROM pragma_table_info('"unterminated') +-- +error: Parser Error: Unterminated quote in qualified name! (input: "unterminated) +== +SELECT * FROM pragma_table_info('abc"xyz"') +-- +error: Parser Error: Unexpected quote in the middle of a qualified name component! (input: abc"xyz") +== +SELECT * FROM pragma_table_info('"abc"xyz') +-- +error: Parser Error: Unexpected character after a quoted identifier in a qualified name! (input: "abc"xyz) +== +SELECT * FROM pragma_table_info('""."t"') +-- +error: Parser Error: Zero-length delimited identifier in qualified name! (input: ""."t") +== +SELECT * FROM pragma_table_info('""') +-- +error: Parser Error: Zero-length delimited identifier in qualified name! (input: "") +== diff --git a/parser/testdata/corpus/sql/pragma/test_table_info_quoted_names.test.metadata.json b/parser/testdata/corpus/sql/pragma/test_table_info_quoted_names.test.metadata.json new file mode 100644 index 0000000..b005363 --- /dev/null +++ b/parser/testdata/corpus/sql/pragma/test_table_info_quoted_names.test.metadata.json @@ -0,0 +1,9 @@ +{ + "todo": { + "223d2294dffb81c9": "transformer-raised parser error: upstream rejects in the transformer, not the grammar; expected to clear as transformers land (milestones 3-5)", + "49ac3a030f9e967d": "transformer-raised parser error: upstream rejects in the transformer, not the grammar; expected to clear as transformers land (milestones 3-5)", + "aa6c6e328a511bfe": "transformer-raised parser error: upstream rejects in the transformer, not the grammar; expected to clear as transformers land (milestones 3-5)", + "dd035f1d606b9579": "transformer-raised parser error: upstream rejects in the transformer, not the grammar; expected to clear as transformers land (milestones 3-5)", + "f5e9e8921ceeb4c3": "transformer-raised parser error: upstream rejects in the transformer, not the grammar; expected to clear as transformers land (milestones 3-5)" + } +} diff --git a/parser/testdata/corpus/sql/pragma/test_various_pragmas.test b/parser/testdata/corpus/sql/pragma/test_various_pragmas.test new file mode 100644 index 0000000..5012e04 --- /dev/null +++ b/parser/testdata/corpus/sql/pragma/test_various_pragmas.test @@ -0,0 +1,49 @@ +# source: test/sql/pragma/test_various_pragmas.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +PRAGMA enable_checkpoint_on_shutdown +-- +ok +== +PRAGMA disable_verify_parallelism +-- +ok +== +PRAGMA explain_output='all' +-- +ok +== +PRAGMA explain_output='unknown' +-- +ok +== +PRAGMA enable_progress_bar +-- +ok +== +PRAGMA disable_progress_bar +-- +ok +== +PRAGMA enable_print_progress_bar +-- +ok +== +PRAGMA disable_print_progress_bar +-- +ok +== +PRAGMA debug_checkpoint_abort='none' +-- +ok +== +PRAGMA debug_checkpoint_abort='unknown' +-- +ok +== +pragma explain_output =null; +-- +ok +== diff --git a/parser/testdata/corpus/sql/prepared/invalid_prepare.test b/parser/testdata/corpus/sql/prepared/invalid_prepare.test new file mode 100644 index 0000000..01e516f --- /dev/null +++ b/parser/testdata/corpus/sql/prepared/invalid_prepare.test @@ -0,0 +1,37 @@ +# source: test/sql/prepared/invalid_prepare.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +select ?; +-- +ok +== +create view v1 as select ?; +-- +ok +== +prepare v1 as select $2::int; +-- +ok +== +execute v1(0); +-- +ok +== +prepare v2 as select $1::int; +-- +ok +== +execute v2('hello'); +-- +ok +== +prepare v3 as select $1::int where 1=0; +-- +ok +== +execute v3(1); +-- +ok +== diff --git a/parser/testdata/corpus/sql/prepared/parameter_order_subquery.test b/parser/testdata/corpus/sql/prepared/parameter_order_subquery.test new file mode 100644 index 0000000..ab66565 --- /dev/null +++ b/parser/testdata/corpus/sql/prepared/parameter_order_subquery.test @@ -0,0 +1,104 @@ +# source: test/sql/prepared/parameter_order_subquery.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +CREATE TABLE t1(c0 INT2); +-- +ok +== +INSERT INTO t1 VALUES (1), (2), (3), (5), (7), (10), (20); +-- +ok +== +PREPARE prepare_query AS SELECT (? NOT IN (SELECT t1.c0 FROM t1 ORDER BY t1.c0 LIMIT ?)); +-- +ok +== +EXECUTE prepare_query(-675986880, 1); +-- +ok +== +PREPARE q1 AS SELECT (? NOT IN (SELECT t1.c0 FROM t1 ORDER BY t1.c0 LIMIT ?)) AND + (? IN (SELECT t1.c0 FROM t1 ORDER BY t1.c0 LIMIT ?)); +-- +ok +== +EXECUTE q1(10, 1, 20, 3); +-- +ok +== +PREPARE q2 AS SELECT ? IN ( + SELECT t1.c0 + FROM t1 + WHERE t1.c0 IN (SELECT t1.c0 FROM t1 ORDER BY t1.c0 LIMIT ?) + AND t1.c0 > ? + ORDER BY t1.c0 + LIMIT ? +); +-- +ok +== +EXECUTE q2(7, 5, 3, 2); +-- +ok +== +PREPARE q3 AS SELECT ? = ANY ( + SELECT t1.c0 + FROM t1 + WHERE t1.c0 = ALL (SELECT t1.c0 FROM t1 ORDER BY t1.c0 LIMIT ?) + ORDER BY t1.c0 + LIMIT ? +); +-- +ok +== +EXECUTE q3(1, 1, 2); +-- +ok +== +PREPARE q4 AS SELECT (? NOT IN ( + SELECT t1.c0 + FROM t1 + WHERE t1.c0 < ? + ORDER BY t1.c0 + LIMIT ? +)); +-- +ok +== +EXECUTE q4(10, 5, 2); +-- +ok +== +PREPARE q5 AS SELECT ? IN ( + (SELECT t1.c0 FROM t1 ORDER BY t1.c0 LIMIT ?) + UNION ALL + (SELECT t1.c0 FROM t1 ORDER BY t1.c0 LIMIT ?) +); +-- +ok +== +EXECUTE q5(2, 2, 4); +-- +ok +== +PREPARE q7 AS SELECT ? = (SELECT t1.c0 FROM t1 ORDER BY t1.c0 LIMIT ?); +-- +ok +== +EXECUTE q7(1, 1); +-- +ok +== +PREPARE q8 AS SELECT + (SELECT MAX(c0) FROM (SELECT t1.c0 FROM t1 ORDER BY t1.c0 LIMIT ?) s1) AS a, + ? AS b, + (SELECT MAX(c0) FROM (SELECT t1.c0 FROM t1 ORDER BY t1.c0 LIMIT ?) s2) AS c; +-- +ok +== +EXECUTE q8(1, 10, 3); +-- +ok +== diff --git a/parser/testdata/corpus/sql/prepared/parameter_variants.test b/parser/testdata/corpus/sql/prepared/parameter_variants.test new file mode 100644 index 0000000..5ba43e6 --- /dev/null +++ b/parser/testdata/corpus/sql/prepared/parameter_variants.test @@ -0,0 +1,29 @@ +# source: test/sql/prepared/parameter_variants.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +PREPARE s1 AS SELECT CAST(? AS INTEGER), CAST(? AS STRING) +-- +ok +== +EXECUTE s1(42, 'dpfkg') +-- +ok +== +DEALLOCATE s1 +-- +ok +== +PREPARE s1 AS SELECT CAST(?1 AS INTEGER), CAST(?2 AS STRING) +-- +ok +== +PREPARE s1 AS SELECT CAST(?2 AS INTEGER), CAST(?1 AS STRING) +-- +ok +== +EXECUTE s1('dpfkg', 42) +-- +ok +== diff --git a/parser/testdata/corpus/sql/prepared/prepare_copy.test b/parser/testdata/corpus/sql/prepared/prepare_copy.test new file mode 100644 index 0000000..911cd0e --- /dev/null +++ b/parser/testdata/corpus/sql/prepared/prepare_copy.test @@ -0,0 +1,39 @@ +# source: test/sql/prepared/prepare_copy.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +PREPARE q1 AS + COPY ( + select $1 as 'col' + ) to '{TEST_DIR}/res.csv' ( + FORMAT csv + ); +-- +ok +== +execute q1 (42); +-- +ok +== +select i from '{TEST_DIR}/res.csv' tbl(i); +-- +ok +== +PREPARE q2 AS + COPY ( + select 42 as 'col' + ) to $1 ( + FORMAT csv + ); +-- +ok +== +EXECUTE q2('{TEST_DIR}/res2.csv') +-- +ok +== +select i from '{TEST_DIR}/res2.csv' tbl(i); +-- +ok +== diff --git a/parser/testdata/corpus/sql/prepared/prepare_default_varchar.test b/parser/testdata/corpus/sql/prepared/prepare_default_varchar.test new file mode 100644 index 0000000..f8eac8a --- /dev/null +++ b/parser/testdata/corpus/sql/prepared/prepare_default_varchar.test @@ -0,0 +1,237 @@ +# source: test/sql/prepared/prepare_default_varchar.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +PREPARE v1 AS SELECT ? +-- +ok +== +EXECUTE v1(27) +-- +ok +== +EXECUTE v1('hello world') +-- +ok +== +EXECUTE v1([1, 2, 3]) +-- +ok +== +PREPARE v2 AS SELECT ?=? +-- +ok +== +EXECUTE v2(27, 27) +-- +ok +== +EXECUTE v2('hello world', 'hello mars') +-- +ok +== +EXECUTE v2(1, 1.0) +-- +ok +== +EXECUTE v2([1, 2, 3], '[1, 2, 3]') +-- +ok +== +EXECUTE v2([[1, 2, 3]], [1, 2, 3]) +-- +ok +== +PREPARE v3 AS SELECT (SELECT ?) +-- +ok +== +EXECUTE v3(27) +-- +ok +== +EXECUTE v3('hello world') +-- +ok +== +EXECUTE v3([1, 2, 3]) +-- +ok +== +PREPARE v4 AS SELECT ? IS NULL +-- +ok +== +EXECUTE v4(27) +-- +ok +== +EXECUTE v4('hello world') +-- +ok +== +EXECUTE v4(NULL) +-- +ok +== +PREPARE v5 AS SELECT ? IN (?, ?) +-- +ok +== +EXECUTE v5(27, 27, 28) +-- +ok +== +EXECUTE v5('hello world', 'hello', 'world') +-- +ok +== +EXECUTE v5(NULL, 27, 28) +-- +ok +== +PREPARE v6 AS SELECT COUNT(?) +-- +ok +== +EXECUTE v6(27) +-- +ok +== +EXECUTE v6('hello world') +-- +ok +== +EXECUTE v6(NULL) +-- +ok +== +PREPARE v7 AS SELECT printf('%s: %d', ?, ?) +-- +ok +== +EXECUTE v7('time', 27) +-- +ok +== +EXECUTE v7('hello world', [1, 2, 3]) +-- +ok +== +PREPARE v8 AS SELECT [?] +-- +ok +== +EXECUTE v8(27) +-- +ok +== +EXECUTE v8('hello world') +-- +ok +== +EXECUTE v8(NULL) +-- +ok +== +PREPARE v9 AS SELECT [?, NULL] +-- +ok +== +EXECUTE v9(27) +-- +ok +== +EXECUTE v9('hello world') +-- +ok +== +EXECUTE v9(NULL) +-- +ok +== +PREPARE v10 AS SELECT {'x': ?} +-- +ok +== +EXECUTE v10(27) +-- +ok +== +EXECUTE v10('hello world') +-- +ok +== +EXECUTE v10(NULL) +-- +ok +== +PREPARE v11 AS SELECT {'x': ?, 'y': NULL} +-- +ok +== +EXECUTE v11(27) +-- +ok +== +EXECUTE v11('hello world') +-- +ok +== +EXECUTE v11(NULL) +-- +ok +== +PREPARE v12 AS SELECT * FROM (VALUES (?, ?), (?, ?)) tbl(i, j) +-- +ok +== +EXECUTE v12(27, 28, 29, 30) +-- +ok +== +EXECUTE v12('hello', 'world', 'a', NULL) +-- +ok +== +PREPARE v13 AS SELECT CASE WHEN ? THEN ? ELSE ? END +-- +ok +== +EXECUTE v13(1=1, 1, 2) +-- +ok +== +EXECUTE v13(1=0, 'hello', 'world') +-- +ok +== +PREPARE v14 AS SELECT ?+NULL +-- +ok +== +EXECUTE v14(1) +-- +ok +== +PREPARE v15 AS SELECT ?=NULL +-- +ok +== +EXECUTE v15(1) +-- +ok +== +PREPARE v16 AS SELECT CASE WHEN (? = 1) AND (? = 2) AND (? = 3) AND ((? IS NULL)) THEN 1.5 ELSE 2.5 END AS a +-- +ok +== +EXECUTE v16(1, 2, 3, NULL) +-- +ok +== +EXECUTE v16(1, 2, 4, NULL) +-- +ok +== diff --git a/parser/testdata/corpus/sql/prepared/prepare_from_first.test b/parser/testdata/corpus/sql/prepared/prepare_from_first.test new file mode 100644 index 0000000..d187a59 --- /dev/null +++ b/parser/testdata/corpus/sql/prepared/prepare_from_first.test @@ -0,0 +1,17 @@ +# source: test/sql/prepared/prepare_from_first.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +prepare fromFirst as from (select ? fromV) select ? selectV,*; +-- +ok +== +execute fromFirst('from', 'sel'); +-- +ok +== +from (select 'from' fromV) select 'sel' selectV,*; +-- +ok +== diff --git a/parser/testdata/corpus/sql/prepared/prepare_in.test b/parser/testdata/corpus/sql/prepared/prepare_in.test new file mode 100644 index 0000000..5f97dc3 --- /dev/null +++ b/parser/testdata/corpus/sql/prepared/prepare_in.test @@ -0,0 +1,17 @@ +# source: test/sql/prepared/prepare_in.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +create table test(id varchar); +-- +ok +== +prepare p as delete from test where ("id") in ((?)); +-- +ok +== +execute p(null); +-- +ok +== diff --git a/parser/testdata/corpus/sql/prepared/prepare_lambda.test b/parser/testdata/corpus/sql/prepared/prepare_lambda.test new file mode 100644 index 0000000..f697873 --- /dev/null +++ b/parser/testdata/corpus/sql/prepared/prepare_lambda.test @@ -0,0 +1,45 @@ +# source: test/sql/prepared/prepare_lambda.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +PREPARE v1 AS SELECT list_transform(?, lambda x: x + 1) +-- +ok +== +PREPARE v2 AS SELECT list_transform([1, 2, 3], lambda x: x + ?) +-- +ok +== +PREPARE v3 AS SELECT list_transform(?, lambda x: x + ? + ?) +-- +ok +== +EXECUTE v3([1, 2, 3], 1, 1) +-- +ok +== +PREPARE v4 AS SELECT list_filter(?, lambda x: x > 1) +-- +ok +== +EXECUTE v4([1, 2, 3]) +-- +ok +== +PREPARE v5 AS SELECT list_filter([1, 2, 3], lambda x: x > ?) +-- +ok +== +EXECUTE v5(1) +-- +ok +== +PREPARE v6 AS SELECT list_filter(?, lambda x: x > ? AND ?) +-- +ok +== +EXECUTE v6([1, 2, 3], 1, True) +-- +ok +== diff --git a/parser/testdata/corpus/sql/prepared/prepare_list_functions.test b/parser/testdata/corpus/sql/prepared/prepare_list_functions.test new file mode 100644 index 0000000..821ef6a --- /dev/null +++ b/parser/testdata/corpus/sql/prepared/prepare_list_functions.test @@ -0,0 +1,45 @@ +# source: test/sql/prepared/prepare_list_functions.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +PREPARE v1 AS SELECT list_aggregate(?, 'min') +-- +ok +== +EXECUTE v1(['hello', 'world']) +-- +ok +== +EXECUTE v1(NULL::INT[]) +-- +ok +== +PREPARE v2 AS SELECT array_slice(?, 1, 2); +-- +ok +== +EXECUTE v2([1, 2, 3]); +-- +ok +== +EXECUTE v2('123'); +-- +ok +== +PREPARE v3 AS SELECT flatten(?) +-- +ok +== +EXECUTE v3([[1,2,3],[4,5]]); +-- +ok +== +PREPARE v4 AS SELECT list_extract(?, 2) +-- +ok +== +EXECUTE v4([1, 2, 3]); +-- +ok +== diff --git a/parser/testdata/corpus/sql/prepared/prepare_maintain_types.test b/parser/testdata/corpus/sql/prepared/prepare_maintain_types.test new file mode 100644 index 0000000..bf27745 --- /dev/null +++ b/parser/testdata/corpus/sql/prepared/prepare_maintain_types.test @@ -0,0 +1,29 @@ +# source: test/sql/prepared/prepare_maintain_types.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +prepare v1 as select cast(111 as short) * $1; +-- +ok +== +execute v1(1665); +-- +ok +== +execute v1('1665'); +-- +ok +== +execute v1('1665'::VARCHAR); +-- +ok +== +execute v1(1665::BIGINT); +-- +ok +== +execute v1(1665::SHORT); +-- +ok +== diff --git a/parser/testdata/corpus/sql/prepared/prepare_mixed_types.test b/parser/testdata/corpus/sql/prepared/prepare_mixed_types.test new file mode 100644 index 0000000..99fcec3 --- /dev/null +++ b/parser/testdata/corpus/sql/prepared/prepare_mixed_types.test @@ -0,0 +1,77 @@ +# source: test/sql/prepared/prepare_mixed_types.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +PREPARE v1 AS SELECT $1::INT, $1::BIGINT +-- +ok +== +PREPARE v2 AS SELECT $1::BIGINT, $1::INT +-- +ok +== +EXECUTE v2(42) +-- +ok +== +PREPARE v3 AS SELECT $1::BIGINT, $1::UBIGINT +-- +ok +== +EXECUTE v3(42) +-- +ok +== +EXECUTE v3(-1) +-- +ok +== +PREPARE v4 AS SELECT $1::VARCHAR, $1::DATE +-- +ok +== +EXECUTE v4('1992-01-01') +-- +ok +== +PREPARE v5 AS SELECT $1::INT, $1::BIGINT, $1::TINYINT, $1::HUGEINT, $1::SMALLINT +-- +ok +== +EXECUTE v5(42) +-- +ok +== +PREPARE v6 AS SELECT $1::INT, $1::BIGINT, $1::TINYINT, $1::UBIGINT, $1::SMALLINT, $1::UHUGEINT +-- +ok +== +EXECUTE v6(42) +-- +ok +== +PREPARE v7 AS SELECT CONCAT($1::TINYINT, $1) +-- +ok +== +EXECUTE v7(42) +-- +ok +== +PREPARE v8 AS SELECT * FROM (values ('body')) t(field) WHERE CASE WHEN $1 IS NULL THEN 1 ELSE field IN (SELECT * FROM (SELECT UNNEST(string_split($1, ','))) AS fsq) END +-- +ok +== +EXECUTE v8('body') +-- +ok +== +PREPARE v9 AS SELECT UNNEST($1) UNION ALL SELECT * FROM range(1) WHERE $1::INT[]=[1] +-- +ok +== +EXECUTE v9([1]) +-- +ok +== diff --git a/parser/testdata/corpus/sql/prepared/prepare_offset_first.test b/parser/testdata/corpus/sql/prepared/prepare_offset_first.test new file mode 100644 index 0000000..e7591ec --- /dev/null +++ b/parser/testdata/corpus/sql/prepared/prepare_offset_first.test @@ -0,0 +1,17 @@ +# source: test/sql/prepared/prepare_offset_first.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +PREPARE q AS SELECT x FROM generate_series(1, 10) t(x) OFFSET ? LIMIT ?; +-- +ok +== +EXECUTE q(3, 5); +-- +ok +== +SELECT x FROM generate_series(1, 10) t(x) OFFSET 3 LIMIT 5; +-- +ok +== diff --git a/parser/testdata/corpus/sql/prepared/prepare_summarize.test b/parser/testdata/corpus/sql/prepared/prepare_summarize.test new file mode 100644 index 0000000..6f6c0c5 --- /dev/null +++ b/parser/testdata/corpus/sql/prepared/prepare_summarize.test @@ -0,0 +1,37 @@ +# source: test/sql/prepared/prepare_summarize.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +CREATE TABLE accounts AS SELECT 1 id, 'Mark' AS name +-- +ok +== +SUMMARIZE SELECT * FROM accounts WHERE id = 1; +-- +ok +== +PREPARE query AS SUMMARIZE SELECT * FROM accounts WHERE id = $1; +-- +ok +== +EXECUTE query(1); +-- +ok +== +PREPARE query AS (SUMMARIZE SELECT * FROM accounts WHERE id = $1); +-- +ok +== +DESCRIBE SELECT * FROM accounts WHERE id = 1; +-- +ok +== +PREPARE query AS DESCRIBE SELECT * FROM accounts WHERE id = $1; +-- +ok +== +PREPARE query AS (DESCRIBE SELECT * FROM accounts WHERE id = $1); +-- +ok +== diff --git a/parser/testdata/corpus/sql/prepared/prepare_window_functions.test b/parser/testdata/corpus/sql/prepared/prepare_window_functions.test new file mode 100644 index 0000000..ed799e7 --- /dev/null +++ b/parser/testdata/corpus/sql/prepared/prepare_window_functions.test @@ -0,0 +1,37 @@ +# source: test/sql/prepared/prepare_window_functions.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +PREPARE v1 AS SELECT SUM(?) OVER () +-- +ok +== +EXECUTE v1(2) +-- +ok +== +EXECUTE v1(2::HUGEINT) +-- +ok +== +EXECUTE v1(0.5) +-- +ok +== +CREATE TABLE v0 ( v2 INTEGER CHECK( v2 BETWEEN 1 AND 1119 ) , v1 INT ) ; +-- +ok +== +INSERT INTO v0 ( v2 ) VALUES ( 10 ); +-- +ok +== +PREPARE q1 AS SELECT COALESCE ( LEAD ( $1 ) OVER( ) , ( v1 ) ) > $1 FROM v0; +-- +ok +== +EXECUTE q1(1); +-- +ok +== diff --git a/parser/testdata/corpus/sql/prepared/prepared_named_param.test b/parser/testdata/corpus/sql/prepared/prepared_named_param.test new file mode 100644 index 0000000..262bb9c --- /dev/null +++ b/parser/testdata/corpus/sql/prepared/prepared_named_param.test @@ -0,0 +1,33 @@ +# source: test/sql/prepared/prepared_named_param.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +prepare q123 as select $param, $other_name, $param; +-- +ok +== +execute q123(param := 5, other_name := 3); +-- +ok +== +execute q123(param := 5, 3) +-- +ok +== +prepare q01 as select $1, ?, $2; +-- +ok +== +execute q01(4, 2, 0) +-- +ok +== +prepare q02 as select $1, $param, $2; +-- +ok +== +execute q01(a, 2, 0) +-- +ok +== diff --git a/parser/testdata/corpus/sql/prepared/prepared_null_binding.test b/parser/testdata/corpus/sql/prepared/prepared_null_binding.test new file mode 100644 index 0000000..b098c94 --- /dev/null +++ b/parser/testdata/corpus/sql/prepared/prepared_null_binding.test @@ -0,0 +1,21 @@ +# source: test/sql/prepared/prepared_null_binding.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +PREPARE v1 AS SELECT COALESCE(COALESCE(NULL, $1) / 42::BIGINT, 0.5); +-- +ok +== +EXECUTE v1(INTERVAL '1' DAY) +-- +ok +== +PREPARE v2 AS SELECT COALESCE(CASE WHEN FALSE THEN $1 ELSE NULL END / 42::BIGINT, 0.5); +-- +ok +== +EXECUTE v2(INTERVAL '1' DAY) +-- +ok +== diff --git a/parser/testdata/corpus/sql/prepared/prepared_select.test b/parser/testdata/corpus/sql/prepared/prepared_select.test new file mode 100644 index 0000000..c51111a --- /dev/null +++ b/parser/testdata/corpus/sql/prepared/prepared_select.test @@ -0,0 +1,58 @@ +# source: test/sql/prepared/prepared_select.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +PREPARE s1 AS SELECT ?::VARCHAR FROM (SELECT ?::INTEGER) tbl(i) WHERE i > ?::INTEGER +-- +ok +== +EXECUTE s1('hello', 2, 1) +-- +ok +== +PREPARE s2 AS +SELECT FIRST(?::VARCHAR) +FROM (VALUES (?::INTEGER)) tbl(i) +WHERE i > ?::INTEGER +GROUP BY i % ?::INTEGER +HAVING SUM(i)::VARCHAR <> ?::VARCHAR +-- +ok +== +EXECUTE s2('hello', 2, 1, 2, 'blabla') +-- +ok +== +EXECUTE s2('hello', 2, 1, 2, '2') +-- +ok +== +PREPARE s3 AS +SELECT LENGTH(?::VARCHAR) +UNION ALL +SELECT ?::INTEGER +ORDER BY 1 +-- +ok +== +EXECUTE s3('hello', 3) +-- +ok +== +PREPARE s4 AS SELECT ?::INTEGER IN (?::INTEGER, ?::INTEGER, ?::INTEGER) +-- +ok +== +EXECUTE s4(1, 2, 3, 1) +-- +ok +== +PREPARE s5 AS SELECT ?::INTEGER IN (SELECT i FROM (VALUES (?::INTEGER), (?::INTEGER), (?::INTEGER)) tbl(i)) +-- +ok +== +EXECUTE s5(1, 2, 3, 1) +-- +ok +== diff --git a/parser/testdata/corpus/sql/prepared/prepared_stale_statistics.test b/parser/testdata/corpus/sql/prepared/prepared_stale_statistics.test new file mode 100644 index 0000000..2ee905d --- /dev/null +++ b/parser/testdata/corpus/sql/prepared/prepared_stale_statistics.test @@ -0,0 +1,165 @@ +# source: test/sql/prepared/prepared_stale_statistics.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +CREATE TABLE filter_t(i INTEGER); +-- +ok +== +INSERT INTO filter_t SELECT range FROM range(100); +-- +ok +== +PREPARE stale_filter AS SELECT count(*) FROM filter_t WHERE i = 200; +-- +ok +== +EXECUTE stale_filter; +-- +ok +== +INSERT INTO filter_t VALUES (200); +-- +ok +== +SELECT count(*) FROM filter_t WHERE i = 200; +-- +ok +== +PREPARE stale_cte AS +WITH filtered AS MATERIALIZED (SELECT * FROM filter_t WHERE i = 201) +SELECT count(*) FROM filtered; +-- +ok +== +EXECUTE stale_cte; +-- +ok +== +INSERT INTO filter_t VALUES (201); +-- +ok +== +CREATE TABLE probe AS SELECT i::BIGINT AS k FROM range(0, 6144) t(i); +-- +ok +== +CREATE TABLE build(k BIGINT); +-- +ok +== +INSERT INTO build VALUES (3000), (5000); +-- +ok +== +PREPARE stale_join AS +SELECT count(*)::BIGINT AS c, coalesce(sum(probe.k), 0)::BIGINT AS s +FROM probe +JOIN build USING (k); +-- +ok +== +EXECUTE stale_join; +-- +ok +== +DELETE FROM build; +-- +ok +== +INSERT INTO build VALUES (1), (2); +-- +ok +== +SELECT count(*)::BIGINT AS c, coalesce(sum(probe.k), 0)::BIGINT AS s +FROM probe +JOIN build USING (k); +-- +ok +== +INSERT INTO build VALUES (1), (1), (2), (NULL); +-- +ok +== +PREPARE stale_semi AS +SELECT count(*)::BIGINT AS c, coalesce(sum(k), 0)::BIGINT AS s +FROM probe +WHERE k IN (SELECT k FROM build); +-- +ok +== +EXECUTE stale_semi; +-- +ok +== +INSERT INTO build VALUES (3000), (3000), (5000), (NULL); +-- +ok +== +SELECT count(*)::BIGINT AS c, coalesce(sum(k), 0)::BIGINT AS s +FROM probe +WHERE k IN (SELECT k FROM build); +-- +ok +== +CREATE TABLE aggregate_t AS SELECT i::INTEGER AS i FROM range(100) t(i); +-- +ok +== +PREPARE stale_aggregate AS SELECT min(i), max(i), count(*) FROM aggregate_t; +-- +ok +== +EXECUTE stale_aggregate; +-- +ok +== +INSERT INTO aggregate_t VALUES (-1), (200); +-- +ok +== +SELECT min(i), max(i), count(*) FROM aggregate_t; +-- +ok +== +CREATE TABLE count_t(i INTEGER); +-- +ok +== +INSERT INTO count_t VALUES (1), (2); +-- +ok +== +PREPARE stale_count AS SELECT count(i), count(*) FROM count_t; +-- +ok +== +EXECUTE stale_count; +-- +ok +== +INSERT INTO count_t VALUES (NULL); +-- +ok +== +CREATE TABLE delete_t(i INTEGER); +-- +ok +== +PREPARE stale_delete AS DELETE FROM delete_t WHERE i = 42; +-- +ok +== +EXECUTE stale_delete; +-- +ok +== +INSERT INTO delete_t VALUES (42); +-- +ok +== +SELECT count(*) FROM delete_t; +-- +ok +== diff --git a/parser/testdata/corpus/sql/prepared/prepared_statistics_optimization.test b/parser/testdata/corpus/sql/prepared/prepared_statistics_optimization.test new file mode 100644 index 0000000..6bebdd2 --- /dev/null +++ b/parser/testdata/corpus/sql/prepared/prepared_statistics_optimization.test @@ -0,0 +1,143 @@ +# source: test/sql/prepared/prepared_statistics_optimization.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +PREPARE cached_constant AS SELECT 42; +-- +ok +== +SELECT result_types IS NULL FROM duckdb_prepared_statements() WHERE name = 'cached_constant'; +-- +ok +== +CREATE TABLE insert_t(i INTEGER); +-- +ok +== +PREPARE cached_insert AS INSERT INTO insert_t VALUES (42) RETURNING i; +-- +ok +== +SELECT result_types IS NULL FROM duckdb_prepared_statements() WHERE name = 'cached_insert'; +-- +ok +== +EXECUTE cached_insert; +-- +ok +== +SELECT count(*) FROM insert_t; +-- +ok +== +CREATE TEMP TABLE temp_insert_t(i INTEGER); +-- +ok +== +PREPARE cached_temp_insert AS INSERT INTO temp_insert_t VALUES (84) RETURNING i; +-- +ok +== +SELECT result_types IS NULL FROM duckdb_prepared_statements() WHERE name = 'cached_temp_insert'; +-- +ok +== +EXECUTE cached_temp_insert; +-- +ok +== +PREPARE cached_scan AS SELECT i FROM filter_t; +-- +ok +== +SELECT result_types IS NULL FROM duckdb_prepared_statements() WHERE name = 'cached_scan'; +-- +ok +== +EXPLAIN EXECUTE stale_filter; +-- +ok +== +SELECT result_types IS NULL FROM duckdb_prepared_statements() WHERE name = 'stale_filter'; +-- +ok +== +EXPLAIN EXECUTE stale_join; +-- +ok +== +EXPLAIN ANALYZE EXECUTE stale_join; +-- +ok +== +SELECT result_types IS NULL FROM duckdb_prepared_statements() WHERE name = 'stale_aggregate'; +-- +ok +== +CREATE TABLE bitstring_t(i INTEGER); +-- +ok +== +INSERT INTO bitstring_t VALUES (1), (2); +-- +ok +== +PREPARE stale_bitstring AS SELECT bit_count(bitstring_agg(i)) FROM bitstring_t; +-- +ok +== +EXECUTE stale_bitstring; +-- +ok +== +INSERT INTO bitstring_t VALUES (4); +-- +ok +== +CREATE TABLE stats_t(i INTEGER); +-- +ok +== +INSERT INTO stats_t VALUES (1), (2); +-- +ok +== +PREPARE stale_stats AS +SELECT s.min, s.max, s.has_null +FROM (SELECT stats(i) AS s FROM stats_t LIMIT 1); +-- +ok +== +EXECUTE stale_stats; +-- +ok +== +INSERT INTO stats_t VALUES (5), (NULL); +-- +ok +== +SET disabled_optimizers = 'statistics_propagation'; +-- +ok +== +CREATE TABLE row_group_t AS SELECT i::INTEGER AS i FROM range(245760) t(i); +-- +ok +== +PREPARE stale_row_group AS SELECT i FROM row_group_t ORDER BY i LIMIT 1 OFFSET 122880; +-- +ok +== +EXECUTE stale_row_group; +-- +ok +== +INSERT INTO row_group_t VALUES (-1); +-- +ok +== +SELECT i FROM row_group_t ORDER BY i LIMIT 1 OFFSET 122880; +-- +ok +== diff --git a/parser/testdata/corpus/sql/prepared/prepared_update.test b/parser/testdata/corpus/sql/prepared/prepared_update.test new file mode 100644 index 0000000..bd61d70 --- /dev/null +++ b/parser/testdata/corpus/sql/prepared/prepared_update.test @@ -0,0 +1,37 @@ +# source: test/sql/prepared/prepared_update.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +CREATE TABLE integers(i INTEGER, j VARCHAR) +-- +ok +== +INSERT INTO integers VALUES (1, 'hello') +-- +ok +== +PREPARE s1 AS UPDATE integers SET i=?, j=?; +-- +ok +== +EXECUTE s1(2, 'world') +-- +ok +== +PREPARE s2 AS UPDATE integers SET j=? WHERE i=?; +-- +ok +== +EXECUTE s2('test', 2) +-- +ok +== +PREPARE s3 AS UPDATE integers SET j=? WHERE i=? AND j=?; +-- +ok +== +EXECUTE s3('test2', 2, 'test') +-- +ok +== diff --git a/parser/testdata/corpus/sql/prepared/test_basic_prepare.test b/parser/testdata/corpus/sql/prepared/test_basic_prepare.test new file mode 100644 index 0000000..051cfc0 --- /dev/null +++ b/parser/testdata/corpus/sql/prepared/test_basic_prepare.test @@ -0,0 +1,61 @@ +# source: test/sql/prepared/test_basic_prepare.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +PREPARE s1 AS SELECT CAST($1 AS INTEGER), CAST($2 AS STRING) +-- +ok +== +EXECUTE s1(43, 'asdf') +-- +ok +== +EXECUTE s1(43) +-- +ok +== +EXECUTE s1(43, 'asdf', 42) +-- +ok +== +EXECUTE s1('asdf', 'asdf') +-- +ok +== +DEALLOCATE s2 +-- +ok +== +PREPARE EXPLAIN SELECT 42 +-- +error: Parser Error: syntax error at or near "SELECT" +== +PREPARE CREATE TABLE a(i INTEGER) +-- +error: Parser Error: syntax error at or near "CREATE" +== +PREPARE s1 AS SELECT $1+$2 +-- +ok +== +PREPARE s1 AS SELECT NOT($1), 10+$2, $3+20, 4 IN (2, 3, $4), $5 IN (2, 3, 4) +-- +ok +== +EXECUTE s1(1, 2, 3, 4, 2) +-- +ok +== +PREPARE s1 AS SELECT $1 +-- +ok +== +PREPARE s2 AS SELECT (SELECT $1) +-- +ok +== +PREPARE s3 AS SELECT $1=$2 +-- +ok +== diff --git a/parser/testdata/corpus/sql/prepared/test_issue_2079.test b/parser/testdata/corpus/sql/prepared/test_issue_2079.test new file mode 100644 index 0000000..0dcefb6 --- /dev/null +++ b/parser/testdata/corpus/sql/prepared/test_issue_2079.test @@ -0,0 +1,53 @@ +# source: test/sql/prepared/test_issue_2079.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +PREPARE v1 AS SELECT ? + 1.0 AS a +-- +ok +== +EXECUTE v1(2.0) +-- +ok +== +PREPARE v2 AS SELECT ? * 2.0 AS a +-- +ok +== +EXECUTE v2(2.0) +-- +ok +== +PREPARE v3 AS SELECT ? = 2.0 AS a +-- +ok +== +EXECUTE v3(2.0) +-- +ok +== +PREPARE v4 AS SELECT 2.0 IN (1.0, 1.5, ?) +-- +ok +== +EXECUTE v4(2.0) +-- +ok +== +EXECUTE v4(2.5) +-- +ok +== +PREPARE v5 AS SELECT ? IN (1.0, 1.5, 2.0) +-- +ok +== +EXECUTE v5(2.0) +-- +ok +== +EXECUTE v5(2.5) +-- +ok +== diff --git a/parser/testdata/corpus/sql/prepared/test_issue_21077.test b/parser/testdata/corpus/sql/prepared/test_issue_21077.test new file mode 100644 index 0000000..9034f01 --- /dev/null +++ b/parser/testdata/corpus/sql/prepared/test_issue_21077.test @@ -0,0 +1,29 @@ +# source: test/sql/prepared/test_issue_21077.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +PREPARE pssmallint AS SELECT - ? +-- +ok +== +EXECUTE pssmallint(-32768); +-- +ok +== +PREPARE psinteger AS SELECT - ? +-- +ok +== +EXECUTE psinteger(-2147483648); +-- +ok +== +PREPARE psbigint AS SELECT - ? +-- +ok +== +EXECUTE psbigint(-9223372036854775808); +-- +ok +== diff --git a/parser/testdata/corpus/sql/prepared/test_issue_4010.test b/parser/testdata/corpus/sql/prepared/test_issue_4010.test new file mode 100644 index 0000000..0f1e716 --- /dev/null +++ b/parser/testdata/corpus/sql/prepared/test_issue_4010.test @@ -0,0 +1,13 @@ +# source: test/sql/prepared/test_issue_4010.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +CREATE table T1(A0 TIMESTAMP, A1 INTEGER, A2 VARCHAR, A3 VARCHAR, A4 INTEGER, A5 DOUBLE) +-- +ok +== +PREPARE v1 AS SELECT (SUM(CASE WHEN ((T1.A2 = ($1)::text) AND (T1.A3 = ($1)::text)) THEN T1.A4 ELSE (0)::int END) / ((SUM(CASE WHEN ((T1.A2 = ($1)::text) AND (T1.A3 = ($1)::text)) THEN T1.A4 ELSE (0)::int END) + SUM(CASE WHEN ((T1.A2 = ($2)::text) AND (T1.A3 = ($1)::text)) THEN T1.A4 ELSE (0)::int END)))::float8) AS A00036933 FROM T1 +-- +ok +== diff --git a/parser/testdata/corpus/sql/prepared/test_issue_4042.test b/parser/testdata/corpus/sql/prepared/test_issue_4042.test new file mode 100644 index 0000000..133f01d --- /dev/null +++ b/parser/testdata/corpus/sql/prepared/test_issue_4042.test @@ -0,0 +1,37 @@ +# source: test/sql/prepared/test_issue_4042.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +CREATE TABLE stringliterals AS SELECT 1 AS ID, 1::BIGINT AS a1,'value-1' AS a2,'value-1' AS a3,10::BIGINT AS a4 +-- +ok +== +PREPARE v1 AS +SELECT ((SUM(CASE + WHEN ((stringliterals.a2 = ($1)::text) AND (stringliterals.a3 = ($1)::text)) + THEN stringliterals.a4 + ELSE (0)::int + END) + + SUM(CASE + WHEN ((stringliterals.a2 = ($2)::text) AND (stringliterals.a3 = ($2)::text)) + THEN stringliterals.a4 + ELSE (0)::int + END)) / ((SUM(CASE + WHEN ((stringliterals.a2 = ($1)::text) AND (stringliterals.a3 = ($1)::text)) + THEN stringliterals.a4 + ELSE (0)::int + END) + + SUM(CASE + WHEN ((stringliterals.a2 = ($2)::text) AND (stringliterals.a3 = ($2)::text)) + THEN stringliterals.a4 + ELSE (0)::int + END)))::float8) AS A00000185 +FROM stringliterals +-- +ok +== +EXECUTE v1('value-1', 'value-2') +-- +ok +== diff --git a/parser/testdata/corpus/sql/prepared/test_issue_6276.test b/parser/testdata/corpus/sql/prepared/test_issue_6276.test new file mode 100644 index 0000000..ac2d22d --- /dev/null +++ b/parser/testdata/corpus/sql/prepared/test_issue_6276.test @@ -0,0 +1,13 @@ +# source: test/sql/prepared/test_issue_6276.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +PREPARE v1 AS SELECT CASE ? WHEN ? THEN ? WHEN ? THEN ? ELSE ? END AS x +-- +ok +== +EXECUTE V1(1, 2, 3, 4, 5, 6); +-- +ok +== diff --git a/parser/testdata/corpus/sql/prepared/test_prepare_ambiguous_type.test b/parser/testdata/corpus/sql/prepared/test_prepare_ambiguous_type.test new file mode 100644 index 0000000..21b20d1 --- /dev/null +++ b/parser/testdata/corpus/sql/prepared/test_prepare_ambiguous_type.test @@ -0,0 +1,257 @@ +# source: test/sql/prepared/test_prepare_ambiguous_type.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +PREPARE v1 AS SELECT typeof(?) +-- +ok +== +EXECUTE v1(3::int) +-- +ok +== +EXECUTE v1('hello') +-- +ok +== +PREPARE v2 AS SELECT ? +-- +ok +== +EXECUTE v2(3::int) +-- +ok +== +EXECUTE v2('hello') +-- +ok +== +EXECUTE v2([1, 2, 3]) +-- +ok +== +PREPARE v3 AS SELECT ?=? +-- +ok +== +EXECUTE v3(3::int, 4::bigint) +-- +ok +== +EXECUTE v3('hello', 'hello') +-- +ok +== +EXECUTE v3([1, 2, 3], [1, 2, 3]) +-- +ok +== +PREPARE v4 AS SELECT extract(year from ?) +-- +ok +== +EXECUTE v4(DATE '1992-01-01') +-- +ok +== +EXECUTE v4(TIMESTAMP '1992-01-01 23:00:20') +-- +ok +== +PREPARE v5 AS SELECT printf('%s', ?) +-- +ok +== +EXECUTE v5(4) +-- +ok +== +EXECUTE v5('hello') +-- +ok +== +PREPARE v6 AS SELECT printf('%d', ?) +-- +ok +== +EXECUTE v6(4) +-- +ok +== +EXECUTE v6('hello') +-- +ok +== +PREPARE v7 AS SELECT [?] +-- +ok +== +EXECUTE v7(1) +-- +ok +== +EXECUTE v7('hello') +-- +ok +== +EXECUTE v7([1,2,3]) +-- +ok +== +EXECUTE v7(NULL) +-- +ok +== +PREPARE v8 AS SELECT [?, ?, ?] +-- +ok +== +EXECUTE v8(1, 2, 3) +-- +ok +== +EXECUTE v8(NULL, NULL, NULL) +-- +ok +== +EXECUTE v8('hello', 'world', NULL) +-- +ok +== +PREPARE v9 AS SELECT {'a': ?} +-- +ok +== +EXECUTE v9(42) +-- +ok +== +EXECUTE v9([1,2,3]) +-- +ok +== +PREPARE v10 AS SELECT {'a': ?, 'b': 42, 'c': ?} +-- +ok +== +EXECUTE v10(33, [1, 2, 3]) +-- +ok +== +EXECUTE v10(NULL, {'a': 88}) +-- +ok +== +PREPARE v11 AS SELECT ROW(?, ?) +-- +ok +== +EXECUTE v11(11, 'hello') +-- +ok +== +PREPARE v12 AS SELECT ? IS NULL +-- +ok +== +EXECUTE v12('hello') +-- +ok +== +EXECUTE v12([1, 2, 3]) +-- +ok +== +EXECUTE v12(NULL) +-- +ok +== +PREPARE v13 AS SELECT (SELECT ?) +-- +ok +== +EXECUTE v13(3::int) +-- +ok +== +EXECUTE v13('hello') +-- +ok +== +EXECUTE v13([1, 2, 3]) +-- +ok +== +PREPARE v14 AS SELECT SUM(?) FROM RANGE(100) +-- +ok +== +EXECUTE v14(2) +-- +ok +== +EXECUTE v14(2::HUGEINT) +-- +ok +== +EXECUTE v14(0.005) +-- +ok +== +PREPARE v15 AS SELECT ?+? +-- +ok +== +EXECUTE v15(0.25, 0.25) +-- +ok +== +EXECUTE v15(1000000000000000000000000000000000000::hugeint, 1000000000000000000000000000000000000::hugeint) +-- +ok +== +PREPARE v17 AS SELECT ARRAY_CONTAINS(?, ?) +-- +ok +== +EXECUTE v17([1, 2, 3], 1) +-- +ok +== +EXECUTE v17([], 1) +-- +ok +== +EXECUTE v17(['hello', NULL, 'world'], 'world') +-- +ok +== +PREPARE v18 AS SELECT ARRAY_CONTAINS([1, 2, 3], ?) +-- +ok +== +EXECUTE v18(1) +-- +ok +== +EXECUTE v18(0) +-- +ok +== +EXECUTE v18([1]) +-- +ok +== +PREPARE v19 AS SELECT ARRAY_CONTAINS(?, 1) +-- +ok +== +EXECUTE v19([1, 2, 3]) +-- +ok +== +EXECUTE v19(0) +-- +ok +== diff --git a/parser/testdata/corpus/sql/prepared/test_prepare_delete.test b/parser/testdata/corpus/sql/prepared/test_prepare_delete.test new file mode 100644 index 0000000..139dd60 --- /dev/null +++ b/parser/testdata/corpus/sql/prepared/test_prepare_delete.test @@ -0,0 +1,29 @@ +# source: test/sql/prepared/test_prepare_delete.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +CREATE TABLE b (i TINYINT) +-- +ok +== +INSERT INTO b VALUES (1), (2), (3), (4), (5) +-- +ok +== +PREPARE s1 AS DELETE FROM b WHERE i=$1 +-- +ok +== +SELECT * FROM b ORDER BY 1 +-- +ok +== +EXECUTE s1(3) +-- +ok +== +DROP TABLE b CASCADE +-- +ok +== diff --git a/parser/testdata/corpus/sql/prepared/test_prepare_delete_update.test b/parser/testdata/corpus/sql/prepared/test_prepare_delete_update.test new file mode 100644 index 0000000..e13b4bb --- /dev/null +++ b/parser/testdata/corpus/sql/prepared/test_prepare_delete_update.test @@ -0,0 +1,13 @@ +# source: test/sql/prepared/test_prepare_delete_update.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +PREPARE s1 AS UPDATE b SET i=$1 WHERE i=$2 +-- +ok +== +EXECUTE s1(6, 3) +-- +ok +== diff --git a/parser/testdata/corpus/sql/prepared/test_prepare_drop.test b/parser/testdata/corpus/sql/prepared/test_prepare_drop.test new file mode 100644 index 0000000..2c966ba --- /dev/null +++ b/parser/testdata/corpus/sql/prepared/test_prepare_drop.test @@ -0,0 +1,21 @@ +# source: test/sql/prepared/test_prepare_drop.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +CREATE TABLE a (i TINYINT) +-- +ok +== +PREPARE p1 AS SELECT * FROM a +-- +ok +== +DROP TABLE a +-- +ok +== +DEALLOCATE p1 +-- +ok +== diff --git a/parser/testdata/corpus/sql/prepared/test_prepare_error.test b/parser/testdata/corpus/sql/prepared/test_prepare_error.test new file mode 100644 index 0000000..aa4c8e3 --- /dev/null +++ b/parser/testdata/corpus/sql/prepared/test_prepare_error.test @@ -0,0 +1,13 @@ +# source: test/sql/prepared/test_prepare_error.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +PREPARE v1 AS SELECT ?::VARCHAR::INT +-- +ok +== +EXECUTE v1('3') +-- +ok +== diff --git a/parser/testdata/corpus/sql/prepared/test_prepare_issue_5132.test b/parser/testdata/corpus/sql/prepared/test_prepare_issue_5132.test new file mode 100644 index 0000000..6606d03 --- /dev/null +++ b/parser/testdata/corpus/sql/prepared/test_prepare_issue_5132.test @@ -0,0 +1,17 @@ +# source: test/sql/prepared/test_prepare_issue_5132.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +create table test as select 42 i +-- +ok +== +prepare q1 as SELECT cast(? AS VARCHAR) FROM test +-- +ok +== +execute q1('oops') +-- +ok +== diff --git a/parser/testdata/corpus/sql/prepared/test_prepare_issue_8500.test b/parser/testdata/corpus/sql/prepared/test_prepare_issue_8500.test new file mode 100644 index 0000000..96113b1 --- /dev/null +++ b/parser/testdata/corpus/sql/prepared/test_prepare_issue_8500.test @@ -0,0 +1,13 @@ +# source: test/sql/prepared/test_prepare_issue_8500.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +PREPARE S1 AS SELECT (? / 1) + 1; +-- +ok +== +EXECUTE S1(42) +-- +ok +== diff --git a/parser/testdata/corpus/sql/prepared/test_prepare_null.test b/parser/testdata/corpus/sql/prepared/test_prepare_null.test new file mode 100644 index 0000000..19ff5e5 --- /dev/null +++ b/parser/testdata/corpus/sql/prepared/test_prepare_null.test @@ -0,0 +1,33 @@ +# source: test/sql/prepared/test_prepare_null.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +PREPARE s1 AS INSERT INTO b VALUES ($1) +-- +ok +== +EXECUTE s1 (NULL) +-- +ok +== +SELECT i FROM b +-- +ok +== +PREPARE s2 AS UPDATE b SET i=$1 +-- +ok +== +EXECUTE s2 (NULL) +-- +ok +== +PREPARE s3 AS DELETE FROM b WHERE i=$1 +-- +ok +== +EXECUTE s3 (NULL) +-- +ok +== diff --git a/parser/testdata/corpus/sql/prepared/test_prepare_select.test b/parser/testdata/corpus/sql/prepared/test_prepare_select.test new file mode 100644 index 0000000..5ecd628 --- /dev/null +++ b/parser/testdata/corpus/sql/prepared/test_prepare_select.test @@ -0,0 +1,45 @@ +# source: test/sql/prepared/test_prepare_select.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +INSERT INTO a VALUES (42) +-- +ok +== +PREPARE s3 AS SELECT * FROM a WHERE i=$1 +-- +ok +== +EXECUTE s3(10000) +-- +ok +== +EXECUTE s3(42) +-- +ok +== +EXECUTE s3(84) +-- +ok +== +DEALLOCATE s3 +-- +ok +== +SELECT * FROM a WHERE i=$1 +-- +ok +== +SELECT * FROM a WHERE i=CAST($1 AS VARCHAR) +-- +ok +== +PREPARE s1 AS SELECT to_years($1), CAST(list_value($1) AS BIGINT[]); +-- +ok +== +EXECUTE s1(1); +-- +ok +== diff --git a/parser/testdata/corpus/sql/prepared/test_prepare_subquery.test b/parser/testdata/corpus/sql/prepared/test_prepare_subquery.test new file mode 100644 index 0000000..bf02b1e --- /dev/null +++ b/parser/testdata/corpus/sql/prepared/test_prepare_subquery.test @@ -0,0 +1,25 @@ +# source: test/sql/prepared/test_prepare_subquery.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +PREPARE v1 AS SELECT * FROM (SELECT $1::INTEGER) sq1; +-- +ok +== +PREPARE v2 AS SELECT * FROM (SELECT $1::INTEGER WHERE 1=0) sq1; +-- +ok +== +PREPARE v3 AS SELECT (SELECT $1::INT+sq1.i) FROM (SELECT 42 AS i) sq1; +-- +ok +== +PREPARE v4 AS SELECT (SELECT (SELECT $1::INT+sq1.i)+$2::INT+sq1.i) FROM (SELECT 42 AS i) sq1; +-- +ok +== +EXECUTE v4(20, 20) +-- +ok +== diff --git a/parser/testdata/corpus/sql/prepared/test_prepare_types.test b/parser/testdata/corpus/sql/prepared/test_prepare_types.test new file mode 100644 index 0000000..9b6ccdb --- /dev/null +++ b/parser/testdata/corpus/sql/prepared/test_prepare_types.test @@ -0,0 +1,17 @@ +# source: test/sql/prepared/test_prepare_types.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +CREATE TABLE test(a TINYINT, b SMALLINT, c INTEGER, d BIGINT, e REAL, f DOUBLE, g DATE, h VARCHAR) +-- +ok +== +PREPARE s1 AS INSERT INTO test VALUES ($1,$2,$3,$4,$5,$6,$7,$8); +-- +ok +== +EXECUTE s1(1,2,3,4,1.5,2.5,'1992-10-20', 'hello world'); +-- +ok +== diff --git a/parser/testdata/corpus/sql/prepared/test_prepare_unused_cte.test b/parser/testdata/corpus/sql/prepared/test_prepare_unused_cte.test new file mode 100644 index 0000000..38947b6 --- /dev/null +++ b/parser/testdata/corpus/sql/prepared/test_prepare_unused_cte.test @@ -0,0 +1,29 @@ +# source: test/sql/prepared/test_prepare_unused_cte.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +CREATE TABLE "user" (name string); +-- +ok +== +PREPARE s2965 AS +WITH temp_first AS ( + SELECT * FROM "user" + WHERE "name" = ? +), temp_second AS ( + SELECT * FROM "user" + WHERE "name" = ? +) +SELECT * FROM temp_second; +-- +ok +== +EXECUTE s2965('val1', 'val2') +-- +ok +== +DEALLOCATE s2965 +-- +ok +== diff --git a/parser/testdata/corpus/sql/projection/coalesce_error.test b/parser/testdata/corpus/sql/projection/coalesce_error.test new file mode 100644 index 0000000..4612bbf --- /dev/null +++ b/parser/testdata/corpus/sql/projection/coalesce_error.test @@ -0,0 +1,27 @@ +# source: test/sql/projection/coalesce_error.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +SELECT COALESCE(1, 'hello'::INT) +-- +ok +== +SELECT COALESCE(NULL, 'hello'::INT) +-- +ok +== +CREATE TABLE vals AS SELECT * FROM ( + VALUES (1, 'hello'), (NULL, '2'), (3, NULL) +) tbl(a, b) +-- +ok +== +SELECT COALESCE(a, b::INT) FROM vals +-- +ok +== +SELECT COALESCE(NULL, b::INT) FROM vals +-- +ok +== diff --git a/parser/testdata/corpus/sql/projection/coalesce_rowid.test b/parser/testdata/corpus/sql/projection/coalesce_rowid.test new file mode 100644 index 0000000..6c44138 --- /dev/null +++ b/parser/testdata/corpus/sql/projection/coalesce_rowid.test @@ -0,0 +1,17 @@ +# source: test/sql/projection/coalesce_rowid.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +create table tbl as select case when i%2=0 then null else i end as i from range(10) tbl(i); +-- +ok +== +select i, coalesce(rowid+i, rowid) from tbl ORDER BY rowid; +-- +ok +== +select i, rowid, rowid+i, COALESCE(rowid+i, NULL) IS NULL OR rowid+3=6 from tbl ORDER BY rowid; +-- +ok +== diff --git a/parser/testdata/corpus/sql/projection/select_star_exclude.test b/parser/testdata/corpus/sql/projection/select_star_exclude.test new file mode 100644 index 0000000..4c38441 --- /dev/null +++ b/parser/testdata/corpus/sql/projection/select_star_exclude.test @@ -0,0 +1,217 @@ +# source: test/sql/projection/select_star_exclude.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +SELECT * EXCLUDE i FROM integers +-- +ok +== +SELECT * EXCLUDE (i, j) FROM integers +-- +ok +== +SELECT * EXCLUDE (j) FROM integers +-- +ok +== +SELECT * EXCLUDE ("J") FROM integers +-- +ok +== +SELECT * EXCLUDE (i, j, k) FROM integers +-- +ok +== +SELECT integers.* EXCLUDE (i) FROM integers +-- +ok +== +SELECT integers.* EXCLUDE ('i') FROM integers +-- +ok +== +SELECT integers.* EXCLUDE (i, j) FROM integers +-- +ok +== +SELECT integers.* EXCLUDE (j) FROM integers +-- +ok +== +SELECT integers.* EXCLUDE (i, j), * EXCLUDE (i, j), * EXCLUDE (i, k) FROM integers +-- +ok +== +SELECT integers.* EXCLUDE (i, j, k) FROM integers +-- +ok +== +SELECT * EXCLUDE (i, j) FROM integers i1, integers i2 +-- +ok +== +SELECT i1.* EXCLUDE (i, j), i2.* EXCLUDE (i, j, k) FROM integers i1, integers i2 +-- +ok +== +SELECT i1.* EXCLUDE (i, j), i2.* EXCLUDE (k) FROM integers i1, integers i2 +-- +ok +== +SELECT * EXCLUDE (i) FROM integers i1 JOIN integers i2 USING (i) +-- +ok +== +SELECT * EXCLUDE integers.i FROM integers +-- +ok +== +SELECT * EXCLUDE (integers.i, integers.j) FROM integers +-- +ok +== +SELECT integers.* EXCLUDE (integers.i, integers.j) FROM integers +-- +ok +== +SELECT * EXCLUDE (INTEGERS.i, integers.J) FROM integers +-- +ok +== +SELECT * EXCLUDE (integers.i, integers.j, integers2.i) FROM integers +-- +ok +== +SELECT * EXCLUDE (integers2.i) FROM integers +-- +ok +== +SELECT * EXCLUDE (i1.i, i2.i) FROM integers i1 JOIN integers i2 USING (i) +-- +ok +== +SELECT * EXCLUDE (i, i) FROM integers +-- +error: Parser Error: Duplicate entry "i" in EXCLUDE list +== +SELECT * EXCLUDE (integers.i, i) FROM integers +-- +error: Parser Error: Duplicate entry "i" in EXCLUDE list +== +SELECT * EXCLUDE (blabla) FROM integers +-- +ok +== +SELECT integers.* EXCLUDE (blabla) FROM integers +-- +ok +== +SELECT * EXCEPT i FROM integers +-- +ok +== +SELECT * EXCEPT (i, j) FROM integers +-- +ok +== +SELECT * EXCEPT (j) FROM integers +-- +ok +== +SELECT * EXCEPT ("J") FROM integers +-- +ok +== +SELECT * EXCEPT (i, j, k) FROM integers +-- +ok +== +SELECT integers.* EXCEPT (i) FROM integers +-- +ok +== +SELECT integers.* EXCEPT ('i') FROM integers +-- +ok +== +SELECT integers.* EXCEPT (i, j) FROM integers +-- +ok +== +SELECT integers.* EXCEPT (j) FROM integers +-- +ok +== +SELECT integers.* EXCEPT (i, j), * EXCEPT (i, j), * EXCEPT (i, k) FROM integers +-- +ok +== +SELECT integers.* EXCEPT (i, j, k) FROM integers +-- +ok +== +SELECT * EXCEPT (i, j) FROM integers i1, integers i2 +-- +ok +== +SELECT i1.* EXCEPT (i, j), i2.* EXCEPT (i, j, k) FROM integers i1, integers i2 +-- +ok +== +SELECT i1.* EXCEPT (i, j), i2.* EXCEPT (k) FROM integers i1, integers i2 +-- +ok +== +SELECT * EXCEPT (i) FROM integers i1 JOIN integers i2 USING (i) +-- +ok +== +SELECT * EXCEPT integers.i FROM integers +-- +ok +== +SELECT * EXCEPT (integers.i, integers.j) FROM integers +-- +ok +== +SELECT integers.* EXCEPT (integers.i, integers.j) FROM integers +-- +ok +== +SELECT * EXCEPT (INTEGERS.i, integers.J) FROM integers +-- +ok +== +SELECT * EXCEPT (integers.i, integers.j, integers2.i) FROM integers +-- +ok +== +SELECT * EXCEPT (integers2.i) FROM integers +-- +ok +== +SELECT * EXCEPT (i1.i, i2.i) FROM integers i1 JOIN integers i2 USING (i) +-- +ok +== +SELECT * EXCEPT (i, i) FROM integers +-- +error: Parser Error: Duplicate entry "i" in EXCLUDE list +== +SELECT * EXCEPT (integers.i, i) FROM integers +-- +error: Parser Error: Duplicate entry "i" in EXCLUDE list +== +SELECT * EXCEPT (blabla) FROM integers +-- +ok +== +SELECT integers.* EXCEPT (blabla) FROM integers +-- +ok +== +SELECT integers.* EXCLUDE (i, j), * EXCEPT (i, j), * EXCLUDE (i, k) FROM integers +-- +ok +== diff --git a/parser/testdata/corpus/sql/projection/select_star_exclude.test.metadata.json b/parser/testdata/corpus/sql/projection/select_star_exclude.test.metadata.json new file mode 100644 index 0000000..487029c --- /dev/null +++ b/parser/testdata/corpus/sql/projection/select_star_exclude.test.metadata.json @@ -0,0 +1,8 @@ +{ + "todo": { + "22eeceee377664af": "transformer-raised parser error: upstream rejects in the transformer, not the grammar; expected to clear as transformers land (milestones 3-5)", + "46579ff7104850c8": "transformer-raised parser error: upstream rejects in the transformer, not the grammar; expected to clear as transformers land (milestones 3-5)", + "7621034a2be8e898": "transformer-raised parser error: upstream rejects in the transformer, not the grammar; expected to clear as transformers land (milestones 3-5)", + "e3955ac3c8ea8bdf": "transformer-raised parser error: upstream rejects in the transformer, not the grammar; expected to clear as transformers land (milestones 3-5)" + } +} diff --git a/parser/testdata/corpus/sql/projection/select_star_like.test b/parser/testdata/corpus/sql/projection/select_star_like.test new file mode 100644 index 0000000..87bee33 --- /dev/null +++ b/parser/testdata/corpus/sql/projection/select_star_like.test @@ -0,0 +1,93 @@ +# source: test/sql/projection/select_star_like.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +SELECT COLUMNS(lambda x: x LIKE 'col%') FROM integers +-- +ok +== +SELECT * NOT LIKE 'col%' FROM integers +-- +ok +== +SELECT * ILIKE 'COL%' FROM integers +-- +ok +== +SELECT * SIMILAR TO '.*col.*' FROM integers +-- +ok +== +SELECT * EXCLUDE (col1) SIMILAR TO '.*col.*' FROM integers +-- +ok +== +SELECT c2, c1 FROM ( +SELECT * SIMILAR TO 'number(\d+)' AS 'c\1' FROM (SELECT 1 AS number1, 2 AS number2, 3 AS end) +) +-- +ok +== +SELECT val FROM ( +SELECT * NOT LIKE '%number%' AS val FROM (SELECT 1 AS number1, 2 AS number2, 3 AS end) +) +-- +ok +== +SELECT * LIKE '\_%' ESCAPE '\' AS val FROM (SELECT 1 AS number1, 2 AS _number2) +-- +ok +== +SELECT * NOT LIKE '\_%' ESCAPE '\' AS val FROM (SELECT 1 AS number1, 2 AS _number2) +-- +ok +== +SELECT * ILIKE '\_NUM%' ESCAPE '\' AS val FROM (SELECT 1 AS number1, 2 AS _number2) +-- +ok +== +SELECT * NOT ILIKE '\_NUM%' ESCAPE '\' AS val FROM (SELECT 1 AS number1, 2 AS _number2) +-- +ok +== +SELECT * SIMILAR TO pattern FROM integers, (SELECT '.*col.*') t(pattern) +-- +ok +== +SELECT * REPLACE (col1 + 42 AS col1) SIMILAR TO '.*col.*' FROM integers +-- +ok +== +SELECT * RENAME (col1 AS other_) SIMILAR TO '.*col.*' FROM integers +-- +ok +== +CREATE TABLE t1(id INTEGER, col1 INTEGER, col2 INTEGER) +-- +ok +== +INSERT INTO t1 VALUES (1, 10, 20) +-- +ok +== +CREATE TABLE t2(name VARCHAR, category VARCHAR, col2 INTEGER) +-- +ok +== +INSERT INTO t2 VALUES ('foo', 'bar', 30) +-- +ok +== +SELECT t1.* LIKE 'col%' FROM t1, t2 +-- +ok +== +SELECT t2.* LIKE 'col%' FROM t1, t2 +-- +ok +== +SELECT t1.* LIKE 'col%', t2.* LIKE 'col%' FROM t1, t2 +-- +ok +== diff --git a/parser/testdata/corpus/sql/projection/select_star_rename.test b/parser/testdata/corpus/sql/projection/select_star_rename.test new file mode 100644 index 0000000..9b212cf --- /dev/null +++ b/parser/testdata/corpus/sql/projection/select_star_rename.test @@ -0,0 +1,65 @@ +# source: test/sql/projection/select_star_rename.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +INSERT INTO integers VALUES (1, 2, 3); +-- +ok +== +SELECT renamed_col FROM (SELECT * RENAME i AS renamed_col FROM integers) +-- +ok +== +SELECT renamed_col FROM (SELECT COLUMNS(* RENAME i AS renamed_col) FROM integers) +-- +ok +== +SELECT renamed_col FROM (SELECT * RENAME integers.i AS renamed_col FROM integers) +-- +ok +== +SELECT renamed_col FROM (SELECT integers.* RENAME integers.i AS renamed_col FROM integers) +-- +ok +== +SELECT r1, r2 FROM (SELECT * RENAME (integers.i AS r1, j AS r2) FROM integers) +-- +ok +== +SELECT r1, r2 FROM (SELECT * RENAME (integers.i AS r1, j AS r2,) FROM integers) +-- +ok +== +SELECT i FROM (SELECT * EXCLUDE (i) RENAME (j AS i) FROM integers) +-- +ok +== +SELECT r FROM (SELECT struct.* RENAME (i AS r) FROM (SELECT {'i': 42} AS struct)) +-- +ok +== +SELECT new_col FROM (SELECT * RENAME (i AS new_col) FROM integers i1 JOIN integers i2 USING (i)) +-- +ok +== +SELECT new_col, new_col2 FROM (SELECT * RENAME (i1.i AS new_col, i1.j AS new_col2) FROM integers i1 JOIN integers i2 USING (i)) +-- +ok +== +SELECT new_col FROM (SELECT * RENAME (i AS new_col) FROM integers i1 LEFT JOIN integers i2 USING (i)) +-- +ok +== +SELECT new_col FROM (SELECT * RENAME (i1.i AS new_col) FROM integers i1 FULL OUTER JOIN integers i2 USING (i)) +-- +ok +== +SELECT * EXCLUDE (i) RENAME (i AS renamed_col) FROM integers +-- +error: Parser Error: Column "i" cannot occur in both EXCLUDE and RENAME list +== +SELECT * REPLACE (i + 1 AS i) RENAME (i AS renamed_col) FROM integers +-- +error: Parser Error: Column "i" cannot occur in both REPLACE and RENAME list +== diff --git a/parser/testdata/corpus/sql/projection/select_star_rename.test.metadata.json b/parser/testdata/corpus/sql/projection/select_star_rename.test.metadata.json new file mode 100644 index 0000000..28035b3 --- /dev/null +++ b/parser/testdata/corpus/sql/projection/select_star_rename.test.metadata.json @@ -0,0 +1,6 @@ +{ + "todo": { + "31eb836f73ef445b": "transformer-raised parser error: upstream rejects in the transformer, not the grammar; expected to clear as transformers land (milestones 3-5)", + "4958a48ec9cb90dc": "transformer-raised parser error: upstream rejects in the transformer, not the grammar; expected to clear as transformers land (milestones 3-5)" + } +} diff --git a/parser/testdata/corpus/sql/projection/select_star_replace.test b/parser/testdata/corpus/sql/projection/select_star_replace.test new file mode 100644 index 0000000..f6b1782 --- /dev/null +++ b/parser/testdata/corpus/sql/projection/select_star_replace.test @@ -0,0 +1,57 @@ +# source: test/sql/projection/select_star_replace.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +SELECT * REPLACE i+100 AS i FROM integers +-- +ok +== +SELECT * EXCLUDE (j, k) REPLACE (i+100 AS i), * EXCLUDE (j) REPLACE (i+100 AS i), * EXCLUDE (j, k) REPLACE (i+101 AS i) FROM integers +-- +ok +== +SELECT * REPLACE (i+100 AS i, j+200 AS "J") FROM integers +-- +ok +== +SELECT integers.* REPLACE (i+100 AS i) FROM integers +-- +ok +== +SELECT * REPLACE (i+100 AS i, i+200 AS i) FROM integers +-- +error: Parser Error: Duplicate entry "i" in REPLACE list +== +SELECT * REPLACE (i+100 AS blabla) FROM integers +-- +ok +== +SELECT integers.* REPLACE (i+100 AS blabla) FROM integers +-- +ok +== +SELECT * EXCLUDE (i) REPLACE (i+100 AS i) FROM integers +-- +error: Parser Error: Column "i" cannot occur in both EXCLUDE and REPLACE list +== +CREATE TABLE test_star(id INTEGER, col1 VARCHAR, col2 VARCHAR, col3 INTEGER); +-- +ok +== +INSERT INTO test_star VALUES (1, 'val1', 'val2', 42); +-- +ok +== +SELECT test_star.* REPLACE ('computed: ' || (id * 2)::VARCHAR AS col1) FROM test_star; +-- +ok +== +SELECT test_star.* EXCLUDE (col2) REPLACE (id * 2 AS col1) RENAME (col3 AS final3) FROM test_star; +-- +ok +== +SELECT test_star.* EXCLUDE (col2) REPLACE ('replaced: ' || col3::VARCHAR AS col1) RENAME (id AS renamed_id, col3 AS final3) FROM test_star; +-- +ok +== diff --git a/parser/testdata/corpus/sql/projection/select_star_replace.test.metadata.json b/parser/testdata/corpus/sql/projection/select_star_replace.test.metadata.json new file mode 100644 index 0000000..a2c7f17 --- /dev/null +++ b/parser/testdata/corpus/sql/projection/select_star_replace.test.metadata.json @@ -0,0 +1,6 @@ +{ + "todo": { + "57d617a3f910b633": "transformer-raised parser error: upstream rejects in the transformer, not the grammar; expected to clear as transformers land (milestones 3-5)", + "8024a9b092584d5b": "transformer-raised parser error: upstream rejects in the transformer, not the grammar; expected to clear as transformers land (milestones 3-5)" + } +} diff --git a/parser/testdata/corpus/sql/projection/select_struct_star.test b/parser/testdata/corpus/sql/projection/select_struct_star.test new file mode 100644 index 0000000..0f0f7cf --- /dev/null +++ b/parser/testdata/corpus/sql/projection/select_struct_star.test @@ -0,0 +1,41 @@ +# source: test/sql/projection/select_struct_star.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +CREATE TABLE test(a STRUCT(i INT, j INT)); +-- +ok +== +INSERT INTO test VALUES ({i: 1, j: 2}); +-- +ok +== +SELECT a.* FROM test; +-- +ok +== +SELECT a.* EXCLUDE(j) FROM test; +-- +ok +== +SELECT a.* EXCLUDE(i) FROM test; +-- +ok +== +SELECT a.* REPLACE(a.i + 3 AS i) FROM test; +-- +ok +== +CREATE TABLE a(i row(t int)); +-- +ok +== +CREATE TABLE b(i row(t int)); +-- +ok +== +SELECT i.* FROM a, b; +-- +ok +== diff --git a/parser/testdata/corpus/sql/projection/test_columns_replace_using.test b/parser/testdata/corpus/sql/projection/test_columns_replace_using.test new file mode 100644 index 0000000..76e80fd --- /dev/null +++ b/parser/testdata/corpus/sql/projection/test_columns_replace_using.test @@ -0,0 +1,69 @@ +# source: test/sql/projection/test_columns_replace_using.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +SELECT COLUMNS(* REPLACE a AS a) FROM range(1) t1(a) NATURAL JOIN range(1) t2(a) +-- +ok +== +SELECT * FROM range(1) t1(a) NATURAL JOIN range(1) t2(a) +-- +ok +== +SELECT COLUMNS(* REPLACE a AS a) FROM range(1) t1(a) JOIN range(1) t2(a) USING (a) +-- +ok +== +SELECT COLUMNS(* REPLACE (a + 1 AS a)) FROM range(1) t1(a) NATURAL JOIN range(1) t2(a) +-- +ok +== +SELECT COLUMNS(* REPLACE (a * 2 AS a)) FROM range(3) t1(a) NATURAL JOIN range(3) t2(a) +-- +ok +== +SELECT COLUMNS(* REPLACE (a + 100 AS a)) FROM (SELECT 1 as a, 2 as b) t1 NATURAL JOIN (SELECT 1 as a, 3 as c) t2 +-- +ok +== +SELECT COLUMNS(* REPLACE (b + 10 AS b)) FROM (SELECT 1 as a, 2 as b) t1 NATURAL JOIN (SELECT 1 as a, 3 as c) t2 +-- +ok +== +SELECT COLUMNS(* REPLACE (a AS a)) FROM range(1) t1(a) NATURAL JOIN range(1) t2(a) NATURAL JOIN range(1) t3(a) +-- +ok +== +SELECT COLUMNS(* REPLACE (a + 1 AS a)) FROM range(2) t1(a) NATURAL JOIN range(2) t2(a) NATURAL JOIN range(2) t3(a) +-- +ok +== +SELECT COLUMNS(* RENAME a AS b) FROM range(1) t1(a) NATURAL JOIN range(1) t2(a) +-- +ok +== +CREATE TABLE test_t1 AS SELECT 1 as a, 2 as b, 3 as c +-- +ok +== +CREATE TABLE test_t2 AS SELECT 1 as a, 4 as d, 5 as e +-- +ok +== +SELECT COLUMNS(* REPLACE (a + 10 AS a, b + 20 AS b)) FROM test_t1 NATURAL JOIN test_t2 +-- +ok +== +SELECT COLUMNS(* REPLACE (concat(a::VARCHAR, '_joined') AS a)) FROM test_t1 NATURAL JOIN test_t2 +-- +ok +== +DROP TABLE test_t1 +-- +ok +== +DROP TABLE test_t2 +-- +ok +== diff --git a/parser/testdata/corpus/sql/projection/test_complex_expressions.test b/parser/testdata/corpus/sql/projection/test_complex_expressions.test new file mode 100644 index 0000000..8a3f732 --- /dev/null +++ b/parser/testdata/corpus/sql/projection/test_complex_expressions.test @@ -0,0 +1,137 @@ +# source: test/sql/projection/test_complex_expressions.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +SELECT * FROM exprtest +-- +ok +== +SELECT a FROM exprtest WHERE a NOT BETWEEN 43 AND 44 +-- +ok +== +SELECT a FROM exprtest WHERE a BETWEEN b AND 44 +-- +ok +== +SELECT CASE WHEN a = 42 THEN 100 WHEN a = 43 THEN 200 ELSE 300 END FROM exprtest +-- +ok +== +SELECT CASE WHEN a = 42 THEN 100 WHEN a = 43 THEN 200 END FROM exprtest +-- +ok +== +SELECT ABS(1), ABS(-1), ABS(NULL) +-- +ok +== +SELECT ABS(b) FROM exprtest +-- +ok +== +CREATE TABLE intest (a INTEGER, b INTEGER, c INTEGER) +-- +ok +== +INSERT INTO intest VALUES (42, 42, 42), (43, 42, 42), (44, 41, 44); +-- +ok +== +SELECT * FROM intest WHERE a IN (42, 43) +-- +ok +== +SELECT a IN (42, 43) FROM intest +-- +ok +== +SELECT * FROM intest WHERE a IN (86, 103, 162) +-- +ok +== +SELECT * FROM intest WHERE a IN (NULL, NULL, NULL, NULL) +-- +ok +== +SELECT * FROM intest WHERE a IN (b) +-- +ok +== +SELECT * FROM intest WHERE a IN (b, c) +-- +ok +== +SELECT * FROM intest WHERE a IN (43, b) ORDER BY 1 +-- +ok +== +SELECT * FROM intest WHERE a NOT IN (42, 43) +-- +ok +== +SELECT * FROM intest WHERE a NOT IN (86, 103, 162) ORDER BY 1 +-- +ok +== +SELECT * FROM intest WHERE a NOT IN (NULL, NULL) +-- +ok +== +SELECT * FROM intest WHERE a NOT IN (b) ORDER BY 1 +-- +ok +== +SELECT * FROM intest WHERE a NOT IN (b, c) +-- +ok +== +SELECT * FROM intest WHERE a NOT IN (43, b) +-- +ok +== +SELECT * FROM intest WHERE NULL IN ('a', 'b') +-- +ok +== +SELECT * FROM intest WHERE NULL NOT IN ('a', 'b') +-- +ok +== +CREATE TABLE strtest (a INTEGER, b VARCHAR) +-- +ok +== +INSERT INTO strtest VALUES (1, 'a'), (2, 'h'), (3, 'd') +-- +ok +== +INSERT INTO strtest VALUES (4, NULL) +-- +ok +== +SELECT a FROM strtest WHERE b = 'a' +-- +ok +== +SELECT a FROM strtest WHERE b <> 'a' +-- +ok +== +SELECT a FROM strtest WHERE b < 'h' +-- +ok +== +SELECT a FROM strtest WHERE b <= 'h' +-- +ok +== +SELECT a FROM strtest WHERE b > 'h' +-- +ok +== +SELECT a FROM strtest WHERE b >= 'h' +-- +ok +== diff --git a/parser/testdata/corpus/sql/projection/test_row_id.test b/parser/testdata/corpus/sql/projection/test_row_id.test new file mode 100644 index 0000000..f3f4b9e --- /dev/null +++ b/parser/testdata/corpus/sql/projection/test_row_id.test @@ -0,0 +1,49 @@ +# source: test/sql/projection/test_row_id.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +insert into a values (42), (44); +-- +ok +== +SELECT rowid, * FROM a +-- +ok +== +SELECT rowid+1 FROM a WHERE CASE WHEN i=42 THEN rowid=0 ELSE rowid=1 END; +-- +ok +== +UPDATE a SET rowid=5 +-- +ok +== +INSERT INTO a (rowid, i) VALUES (5, 6) +-- +ok +== +create table b(rowid integer); +-- +ok +== +insert into b values (42), (22); +-- +ok +== +SELECT rowid FROM b ORDER BY 1 +-- +ok +== +UPDATE b SET rowid=5 +-- +ok +== +INSERT INTO b (rowid) VALUES (5) +-- +ok +== +SELECT * FROM b +-- +ok +== diff --git a/parser/testdata/corpus/sql/projection/test_row_id_expression.test b/parser/testdata/corpus/sql/projection/test_row_id_expression.test new file mode 100644 index 0000000..245559a --- /dev/null +++ b/parser/testdata/corpus/sql/projection/test_row_id_expression.test @@ -0,0 +1,113 @@ +# source: test/sql/projection/test_row_id_expression.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +SELECT rowid + 1, rowid - 1, rowid + rowid, i + rowid FROM a +-- +ok +== +SELECT -rowid, +rowid, abs(rowid) FROM a +-- +ok +== +SELECT rowid BETWEEN -1 AND 1, 0 BETWEEN rowid AND 1, 1 BETWEEN -3 AND rowid FROM a +-- +ok +== +SELECT rowid < i, rowid = NULL, rowid = i, rowid <> 0 FROM a +-- +ok +== +SELECT SUM(rowid), MIN(rowid), MAX(rowid), COUNT(rowid), FIRST(rowid) FROM a +-- +ok +== +SELECT SUM(rowid), MIN(rowid), MAX(rowid), COUNT(rowid), LAST(rowid) FROM a +-- +ok +== +SELECT SUM(rowid), MIN(rowid), MAX(rowid), COUNT(rowid), FIRST(rowid), LAST(rowid) FROM a GROUP BY i +-- +ok +== +SELECT SUM(i) FROM a GROUP BY rowid +-- +ok +== +SELECT * FROM a, a a2 WHERE a.rowid=a2.rowid +-- +ok +== +SELECT * FROM a, a a2 WHERE a.rowid<>a2.rowid +-- +ok +== +SELECT * FROM a, a a2 WHERE a.rowid>=a2.rowid +-- +ok +== +SELECT * FROM a ORDER BY rowid +-- +ok +== +INSERT INTO a SELECT rowid FROM a +-- +ok +== +SELECT * FROM a ORDER BY 1 +-- +ok +== +UPDATE a SET i=rowid +-- +ok +== +SELECT * FROM a WHERE rowid=0 +-- +ok +== +SELECT * FROM a WHERE rowid BETWEEN -100 AND 100 ORDER BY 1 +-- +ok +== +SELECT * FROM a WHERE rowid=0 OR rowid=1 +-- +ok +== +SELECT row_number() OVER (PARTITION BY rowid) FROM a ORDER BY rowid +-- +ok +== +SELECT row_number() OVER (ORDER BY rowid) FROM a ORDER BY rowid +-- +ok +== +SELECT row_number() OVER (ORDER BY rowid DESC) FROM a ORDER BY rowid +-- +ok +== +SELECT (SELECT rowid FROM a LIMIT 1) +-- +ok +== +SELECT 0 IN (SELECT rowid FROM a) +-- +ok +== +SELECT EXISTS(SELECT rowid FROM a) +-- +ok +== +SELECT (SELECT a2.rowid FROM a a2 WHERE a.rowid=a2.rowid) FROM a +-- +ok +== +SELECT a.rowid IN (SELECT a2.rowid FROM a a2 WHERE a.rowid>=a2.rowid) FROM a +-- +ok +== +SELECT EXISTS(SELECT a2.rowid FROM a a2 WHERE a.rowid>=a2.rowid) FROM a +-- +ok +== diff --git a/parser/testdata/corpus/sql/projection/test_scalar_projection.test b/parser/testdata/corpus/sql/projection/test_scalar_projection.test new file mode 100644 index 0000000..e564322 --- /dev/null +++ b/parser/testdata/corpus/sql/projection/test_scalar_projection.test @@ -0,0 +1,41 @@ +# source: test/sql/projection/test_scalar_projection.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +SELECT 42 + 1 +-- +ok +== +SELECT 2 * (42 + 1), 35 - 2 +-- +ok +== +SELECT 'hello' +-- +ok +== +SELECT cast('3' AS INTEGER) +-- +ok +== +SELECT cast(3 AS VARCHAR) +-- +ok +== +SELECT CASE WHEN 43 > 33 THEN 43 ELSE 33 END; +-- +ok +== +SELECT 1 AS a, a * 2 +-- +ok +== +SELECT FROM (SELECT 42) v1 +-- +error: Parser Error: SELECT clause without selection list +== +SELECT + CASE WHEN NOT + 84 NOT BETWEEN - 78 + 98 * 51 AND - ( ( - 28 ) ) * COUNT ( * ) + + - 65 THEN NULL ELSE 16 // + 34 + + - 98 END // + 70 - ( - - CASE - COALESCE ( + 73, + - 66 * - 89 * - 72 ) WHEN COUNT ( * ) // + 4 * CAST ( - - 18 AS INTEGER ) + + + COUNT ( * ) - - 88 THEN NULL WHEN 92 THEN NULL ELSE COUNT ( * ) END ) AS col0 +-- +ok +== diff --git a/parser/testdata/corpus/sql/projection/test_scalar_projection.test.metadata.json b/parser/testdata/corpus/sql/projection/test_scalar_projection.test.metadata.json new file mode 100644 index 0000000..f6e2580 --- /dev/null +++ b/parser/testdata/corpus/sql/projection/test_scalar_projection.test.metadata.json @@ -0,0 +1,5 @@ +{ + "todo": { + "6559f107dc71a9f1": "transformer-raised parser error: upstream rejects in the transformer, not the grammar; expected to clear as transformers land (milestones 3-5)" + } +} diff --git a/parser/testdata/corpus/sql/projection/test_simple_projection.test b/parser/testdata/corpus/sql/projection/test_simple_projection.test new file mode 100644 index 0000000..9d06c55 --- /dev/null +++ b/parser/testdata/corpus/sql/projection/test_simple_projection.test @@ -0,0 +1,33 @@ +# source: test/sql/projection/test_simple_projection.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +SELECT i, j FROM a; +-- +ok +== +INSERT INTO a VALUES (42, 84); +-- +ok +== +SELECT x, y FROM a i1(x, y); +-- +ok +== +SELECT a + 2, b FROM test WHERE a = 11; +-- +ok +== +SELECT a + 2, b FROM test WHERE a = 12; +-- +ok +== +SELECT cast(a AS VARCHAR) FROM test; +-- +ok +== +SELECT cast(cast(a AS VARCHAR) as INTEGER) FROM test; +-- +ok +== diff --git a/parser/testdata/corpus/sql/projection/test_table_star.test b/parser/testdata/corpus/sql/projection/test_table_star.test new file mode 100644 index 0000000..aacd8f5 --- /dev/null +++ b/parser/testdata/corpus/sql/projection/test_table_star.test @@ -0,0 +1,49 @@ +# source: test/sql/projection/test_table_star.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +SELECT test.* FROM test +-- +ok +== +SELECT t.* FROM test t +-- +ok +== +SELECT test.* FROM test t +-- +ok +== +SELECT xyz.* FROM test +-- +ok +== +SELECT xyz.* +-- +ok +== +create table r4 (i int, j int) +-- +ok +== +insert into r4 (i, j) values (1,1), (1,2), (1,3), (1,4), (1,5) +-- +ok +== +select t1.i, t1.j as a, t2.j as b from r4 t1 inner join r4 t2 using(i,j) ORDER BY a +-- +ok +== +select t1.i, t1.j as a, t2.j as b from r4 t1 inner join r4 t2 on t1.i=t2.i and t1.j=t2.j ORDER BY a +-- +ok +== +select t1.*, t2.j b from r4 t1 inner join r4 t2 using(i,j) ORDER BY t1.j +-- +ok +== +select t1.*, t2.j b from r4 t1 inner join r4 t2 on t1.i=t2.i and t1.j=t2.j ORDER BY t1.j +-- +ok +== diff --git a/parser/testdata/corpus/sql/projection/test_value_list.test b/parser/testdata/corpus/sql/projection/test_value_list.test new file mode 100644 index 0000000..19a8d3f --- /dev/null +++ b/parser/testdata/corpus/sql/projection/test_value_list.test @@ -0,0 +1,93 @@ +# source: test/sql/projection/test_value_list.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +(VALUES (1, 3), (2, 4)); +-- +ok +== +SELECT * FROM (VALUES (NULL, NULL), (3, 4), (3, 7)) v1; +-- +ok +== +SELECT * FROM (VALUES (1, 2, 3), (1, 2, 3)) v1; +-- +ok +== +SELECT * FROM (VALUES (1 + 1, 2, 3), (1 + 3, 2, 3)) v1; +-- +ok +== +SELECT * FROM (VALUES ((SELECT 42), 2, 3), (1 + 3,2,3)) v1; +-- +ok +== +SELECT * FROM (VALUES ((SELECT MIN(a) FROM test), 2, 3), ((SELECT MAX(b) FROM test), 2, 3)) v1; +-- +ok +== +SELECT * FROM (VALUES ('hello', 2), (1 + 3, '5'), (DATE '1992-09-20', 3)) v1; +-- +ok +== +SELECT * FROM (VALUES (DATE '1992-09-20', 3), (NULL, NULL)) v1; +-- +ok +== +SELECT * FROM (VALUES (NULL, NULL)) v1; +-- +ok +== +SELECT * FROM (VALUES (NULL, NULL), (3, 4)) v1; +-- +ok +== +SELECT * FROM (VALUES (3), ('42')) v1; +-- +ok +== +SELECT * FROM (VALUES (3), ('hello')) v1; +-- +ok +== +SELECT typeof(x) FROM (VALUES (DATE '1992-01-01'), ('1992-01-01')) v1(x) LIMIT 1; +-- +ok +== +SELECT * FROM (VALUES (NULL), ('hello')) v1; +-- +ok +== +SELECT * FROM (VALUES (1, 2, 3), (1,2)) v1; +-- +error: Parser Error: VALUES lists must all be the same length, expected 3 entries but found a list with 2 entries +== +SELECT * FROM (VALUES (DEFAULT, 2, 3), (1,2)) v1; +-- +error: Parser Error: VALUES lists must all be the same length, expected 3 entries but found a list with 2 entries +== +INSERT INTO varchars VALUES (1), ('hello'), (DEFAULT); +-- +ok +== +SELECT * FROM varchars ORDER BY 1 +-- +ok +== +INSERT INTO varchars VALUES (1, 2), ('hello', 3), (DEFAULT, DEFAULT); +-- +ok +== +INSERT INTO varchars (v) VALUES (1, 2), ('hello', 3), (DEFAULT, DEFAULT); +-- +ok +== +INSERT INTO varchars (v) VALUES (1, 2), ('hello'), (DEFAULT, DEFAULT); +-- +error: Parser Error: VALUES lists must all be the same length, expected 2 entries but found a list with 1 entry +== +INSERT INTO varchars (v) VALUES (DEFAULT IS NULL); +-- +ok +== diff --git a/parser/testdata/corpus/sql/projection/test_value_list.test.metadata.json b/parser/testdata/corpus/sql/projection/test_value_list.test.metadata.json new file mode 100644 index 0000000..5e97bce --- /dev/null +++ b/parser/testdata/corpus/sql/projection/test_value_list.test.metadata.json @@ -0,0 +1,7 @@ +{ + "todo": { + "47f657e68ce0d68b": "transformer-raised parser error: upstream rejects in the transformer, not the grammar; expected to clear as transformers land (milestones 3-5)", + "81dc2217bd936b5f": "transformer-raised parser error: upstream rejects in the transformer, not the grammar; expected to clear as transformers land (milestones 3-5)", + "95f244c05d756c13": "transformer-raised parser error: upstream rejects in the transformer, not the grammar; expected to clear as transformers land (milestones 3-5)" + } +} diff --git a/parser/testdata/corpus/sql/returning/no_crash_when_no_returning_columns.test b/parser/testdata/corpus/sql/returning/no_crash_when_no_returning_columns.test new file mode 100644 index 0000000..53f42b5 --- /dev/null +++ b/parser/testdata/corpus/sql/returning/no_crash_when_no_returning_columns.test @@ -0,0 +1,41 @@ +# source: test/sql/returning/no_crash_when_no_returning_columns.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +CREATE TABLE v0 ( c1 INT ); +-- +ok +== +INSERT INTO v0 VALUES (1), (2), (3), (4) RETURNING * EXCLUDE c1; +-- +ok +== +SELECT * FROM v0; +-- +ok +== +INSERT INTO v0 VALUES (1), (2), (3), (4), (0); +-- +ok +== +DELETE from v0 WHERE c1 = 0 RETURNING * EXCLUDE c1; +-- +ok +== +select * from v0 where c1 = 0; +-- +ok +== +UPDATE v0 SET c1 = 0 WHERE true RETURNING * EXCLUDE c1; +-- +ok +== +Select * from v0 order by all; +-- +ok +== +INSERT INTO v0 BY POSITION ( SELECT TRUE ) OFFSET 1 ROWS RETURNING v0 . * EXCLUDE c1 ; +-- +ok +== diff --git a/parser/testdata/corpus/sql/returning/returning_delete.test b/parser/testdata/corpus/sql/returning/returning_delete.test new file mode 100644 index 0000000..36ffe10 --- /dev/null +++ b/parser/testdata/corpus/sql/returning/returning_delete.test @@ -0,0 +1,603 @@ +# source: test/sql/returning/returning_delete.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +CREATE TABLE table1 (a INTEGER DEFAULT -1, b INTEGER DEFAULT -2, c INTEGER DEFAULT -3); +-- +ok +== +insert into table1(a) select * from range (0, 4000, 1) t1(a); +-- +ok +== +DELETE FROM table1 +WHERE a < 5 RETURNING a, b, c; +-- +ok +== +DELETE FROM table1 +WHERE a = 6 RETURNING a; +-- +ok +== +DELETE FROM table1 +WHERE a = 7 RETURNING *; +-- +ok +== +DELETE FROM table1 +WHERE a=8 AND b=-2 AND c=-3 RETURNING *, c, b, a; +-- +ok +== +DELETE FROM table1 +WHERE a=9 RETURNING c, b, a; +-- +ok +== +DELETE FROM table1 +WHERE a>=10 AND a <=13 RETURNING c as aliasc, a as aliasa, b as aliasb; +-- +ok +== +DELETE FROM table1 WHERE a >= 13 AND a <= 15 RETURNING SUM(a); +-- +ok +== +DELETE FROM table1 +WHERE a=14 +RETURNING a + b + c; +-- +ok +== +DELETE FROM table1 +WHERE a=10 +RETURNING 'duckdb'; +-- +ok +== +DELETE FROM table1 +WHERE a=15 +RETURNING 'duckdb'; +-- +ok +== +CREATE TABLE table2 (a2 INTEGER, b2 INTEGER, c2 INTEGER); +-- +ok +== +CREATE TABLE table3 (a3 INTEGER, b3 INTEGER, c3 INTEGER); +-- +ok +== +INSERT INTO table2 VALUES (1, 1, 1), (2, 2, 2), (3, 3, 3), (100, 100, 100), (200, 200, 200); +-- +ok +== +INSERT INTO table3 VALUES (1, 4, 4), (2, 6, 7), (8, 8, 8); +-- +ok +== +DELETE FROM table3 +WHERE a3 IN ( + SELECT a2 from table2 +) RETURNING *; +-- +ok +== +CREATE TABLE table4 (a4 INTEGER, b4 INTEGER, c4 INTEGER); +-- +ok +== +CREATE TABLE table5 (a5 INTEGER, b5 INTEGER, c5 INTEGER); +-- +ok +== +INSERT INTO table4 VALUES (1, 0, 2), (2, 0, 1), (3, 0, 0); +-- +ok +== +INSERT INTO table5 VALUES (1, 0, 0), (2, 0, 0), (3, 0, 1), (4, 0, 1), (5, 0, 2), (6, 0, 2); +-- +ok +== +DELETE FROM table4 +WHERE a4 IN (SELECT sum(a5) FROM table5 GROUP BY c5) +RETURNING *; +-- +ok +== +DELETE FROM table1 WHERE a = 14 RETURNING a IN (SELECT a FROM table1); +-- +ok +== +DELETE FROM table4 WHERE a4 = 1 RETURNING CASE WHEN b4=0 THEN a4 ELSE b4 END; +-- +ok +== +DELETE FROM table4 WHERE a4 = 2 RETURNING CASE WHEN b4=1 THEN a4 ELSE b4 END; +-- +ok +== +DROP TABLE table2; +-- +ok +== +DROP TABLE table3; +-- +ok +== +DROP TABLE table4; +-- +ok +== +DROP TABLE table5; +-- +ok +== +CREATE TABLE table2 (a VARCHAR DEFAULT 'hello world', b INT); +-- +ok +== +INSERT INTO table2 VALUES ('duckdb', 1), ('postgres', 2), ('sqlite', 3), ('mysql', 4), ('mongo', 5); +-- +ok +== +DELETE FROM table2 +WHERE b = 1 +RETURNING a, b; +-- +ok +== +DELETE FROM table2 +WHERE b = 2 +RETURNING b::VARCHAR; +-- +ok +== +DELETE FROM table2 +WHERE b=3 +RETURNING {'a': a, 'b': b}; +-- +ok +== +DELETE FROM table2 +WHERE b=4 +RETURNING [a, b::VARCHAR]; +-- +ok +== +CREATE TABLE table3 (a INTEGER DEFAULT nextval('seq'), b INTEGER); +-- +ok +== +INSERT INTO table3(b) VALUES (4), (5) RETURNING a, b; +-- +ok +== +DELETE FROM table3 +WHERE b = 4 +RETURNING *; +-- +ok +== +DROP TABLE table1; +-- +ok +== +SELECT count(*) FROM table1; +-- +ok +== +DELETE FROM table1 RETURNING a; +-- +ok +== +CREATE TABLE test_optimized (id INTEGER, name VARCHAR, value DOUBLE); +-- +ok +== +INSERT INTO test_optimized VALUES (1, 'one', 1.0), (2, 'two', 2.0), (3, 'three', 3.0), (4, 'four', 4.0), (5, 'five', 5.0); +-- +ok +== +DELETE FROM test_optimized WHERE id <= 2 RETURNING id, name; +-- +ok +== +DELETE FROM test_optimized WHERE id = 3 RETURNING *; +-- +ok +== +DELETE FROM test_optimized WHERE id = 4 RETURNING value, name, id; +-- +ok +== +DELETE FROM test_optimized WHERE id = 5 RETURNING id * 10 + value; +-- +ok +== +DROP TABLE test_optimized; +-- +ok +== +CREATE TABLE test_where_returning (id INTEGER, amount DOUBLE, customer VARCHAR); +-- +ok +== +INSERT INTO test_where_returning VALUES (1, 100.0, 'Alice'), (2, 200.0, 'Bob'), (3, 300.0, 'Charlie'); +-- +ok +== +DELETE FROM test_where_returning WHERE id < 3 RETURNING id, amount, customer; +-- +ok +== +DROP TABLE test_where_returning; +-- +ok +== +CREATE TABLE test_rowid_supported (id INTEGER, name VARCHAR); +-- +ok +== +INSERT INTO test_rowid_supported VALUES (1, 'one'), (2, 'two'), (3, 'three'); +-- +ok +== +DELETE FROM test_rowid_supported WHERE id = 1 RETURNING rowid; +-- +ok +== +DELETE FROM test_rowid_supported WHERE id = 2 RETURNING id, name, rowid; +-- +ok +== +DELETE FROM test_rowid_supported WHERE id = 3 RETURNING *, rowid; +-- +ok +== +DROP TABLE test_rowid_supported; +-- +ok +== +CREATE TABLE test_rowid_generated ( + id INTEGER, + val INTEGER, + computed INTEGER GENERATED ALWAYS AS (val * 2) VIRTUAL +); +-- +ok +== +INSERT INTO test_rowid_generated (id, val) VALUES (1, 10), (2, 20), (3, 30); +-- +ok +== +DELETE FROM test_rowid_generated WHERE id = 1 RETURNING rowid; +-- +ok +== +DELETE FROM test_rowid_generated WHERE id = 2 RETURNING *, rowid; +-- +ok +== +DELETE FROM test_rowid_generated WHERE id = 3 RETURNING computed, id, rowid; +-- +ok +== +DROP TABLE test_rowid_generated; +-- +ok +== +CREATE TABLE test_rowid_multi_gen ( + id INTEGER, + a INTEGER, + b INTEGER, + sum_ab INTEGER GENERATED ALWAYS AS (a + b) VIRTUAL, + prod_ab INTEGER GENERATED ALWAYS AS (a * b) VIRTUAL +); +-- +ok +== +INSERT INTO test_rowid_multi_gen (id, a, b) VALUES (1, 2, 3), (2, 4, 5); +-- +ok +== +DELETE FROM test_rowid_multi_gen WHERE id = 1 RETURNING *, rowid; +-- +ok +== +DELETE FROM test_rowid_multi_gen WHERE id = 2 RETURNING rowid, sum_ab, prod_ab; +-- +ok +== +DROP TABLE test_rowid_multi_gen; +-- +ok +== +CREATE TABLE test_rowid_gen_middle ( + a INTEGER, + gen INTEGER GENERATED ALWAYS AS (a + c) VIRTUAL, + c INTEGER +); +-- +ok +== +INSERT INTO test_rowid_gen_middle (a, c) VALUES (1, 100), (2, 200); +-- +ok +== +DELETE FROM test_rowid_gen_middle WHERE a = 1 RETURNING *, rowid; +-- +ok +== +DELETE FROM test_rowid_gen_middle WHERE a = 2 RETURNING rowid, gen; +-- +ok +== +DROP TABLE test_rowid_gen_middle; +-- +ok +== +CREATE TABLE test_generated_virtual ( + id INTEGER, + base_value INTEGER, + computed_value INTEGER GENERATED ALWAYS AS (base_value * 2) VIRTUAL +); +-- +ok +== +INSERT INTO test_generated_virtual (id, base_value) VALUES (1, 10), (2, 20), (3, 30); +-- +ok +== +DELETE FROM test_generated_virtual WHERE id = 1 RETURNING id, base_value; +-- +ok +== +DELETE FROM test_generated_virtual WHERE id = 2 RETURNING *; +-- +ok +== +DELETE FROM test_generated_virtual WHERE id = 3 RETURNING computed_value; +-- +ok +== +DROP TABLE test_generated_virtual; +-- +ok +== +CREATE TABLE test_generated_middle ( + a INTEGER, + gen INTEGER GENERATED ALWAYS AS (a + c) VIRTUAL, + c INTEGER +); +-- +ok +== +INSERT INTO test_generated_middle (a, c) VALUES (1, 100), (2, 200), (3, 300); +-- +ok +== +DELETE FROM test_generated_middle WHERE a <= 2 RETURNING *; +-- +ok +== +DELETE FROM test_generated_middle WHERE a = 3 RETURNING gen; +-- +ok +== +DROP TABLE test_generated_middle; +-- +ok +== +CREATE TABLE test_multi_generated ( + x INTEGER, + y INTEGER, + sum_xy INTEGER GENERATED ALWAYS AS (x + y) VIRTUAL, + prod_xy INTEGER GENERATED ALWAYS AS (x * y) VIRTUAL +); +-- +ok +== +INSERT INTO test_multi_generated (x, y) VALUES (2, 3), (4, 5), (6, 7); +-- +ok +== +DELETE FROM test_multi_generated WHERE x = 2 RETURNING *; +-- +ok +== +DELETE FROM test_multi_generated WHERE x = 4 RETURNING sum_xy, prod_xy; +-- +ok +== +DROP TABLE test_multi_generated; +-- +ok +== +CREATE TABLE test_generated_varchar ( + id INTEGER, + name VARCHAR, + greeting VARCHAR GENERATED ALWAYS AS ('Hello, ' || name || '!') VIRTUAL +); +-- +ok +== +INSERT INTO test_generated_varchar (id, name) VALUES (1, 'Alice'), (2, 'Bob'); +-- +ok +== +DELETE FROM test_generated_varchar WHERE id = 1 RETURNING *; +-- +ok +== +DELETE FROM test_generated_varchar WHERE id = 2 RETURNING greeting; +-- +ok +== +DROP TABLE test_generated_varchar; +-- +ok +== +CREATE TABLE merge_gen_target(id INT, x INT, gen AS (x * 2)); +-- +ok +== +INSERT INTO merge_gen_target(id, x) VALUES (1, 10), (2, 20), (3, 30); +-- +ok +== +CREATE TABLE merge_source(id INT); +-- +ok +== +INSERT INTO merge_source VALUES (1), (2); +-- +ok +== +MERGE INTO merge_gen_target USING merge_source ON merge_gen_target.id = merge_source.id +WHEN MATCHED THEN DELETE +RETURNING *, merge_action; +-- +ok +== +SELECT * FROM merge_gen_target; +-- +ok +== +DROP TABLE merge_gen_target; +-- +ok +== +DROP TABLE merge_source; +-- +ok +== +CREATE TABLE merge_multi_gen( + id INT, + a INT, + b INT, + sum_ab INT GENERATED ALWAYS AS (a + b) VIRTUAL, + prod_ab INT GENERATED ALWAYS AS (a * b) VIRTUAL +); +-- +ok +== +INSERT INTO merge_multi_gen(id, a, b) VALUES (1, 2, 3), (2, 4, 5), (3, 6, 7); +-- +ok +== +CREATE TABLE merge_delete_source(id INT); +-- +ok +== +INSERT INTO merge_delete_source VALUES (1), (3); +-- +ok +== +MERGE INTO merge_multi_gen t USING merge_delete_source s ON t.id = s.id +WHEN MATCHED THEN DELETE +RETURNING t.id, t.a, t.b, t.sum_ab, t.prod_ab, merge_action; +-- +ok +== +DROP TABLE merge_multi_gen; +-- +ok +== +DROP TABLE merge_delete_source; +-- +ok +== +CREATE TABLE merge_rowid_target (id INT, val INT); +-- +ok +== +INSERT INTO merge_rowid_target VALUES (1, 10), (2, 20); +-- +ok +== +CREATE TABLE merge_rowid_source (id INT); +-- +ok +== +INSERT INTO merge_rowid_source VALUES (1); +-- +ok +== +MERGE INTO merge_rowid_target t USING merge_rowid_source s ON t.id = s.id +WHEN MATCHED THEN DELETE +RETURNING t.rowid, t.id, t.val; +-- +ok +== +DROP TABLE merge_rowid_target; +-- +ok +== +DROP TABLE merge_rowid_source; +-- +ok +== +CREATE TABLE indexed_returning (id INT PRIMARY KEY, val VARCHAR, amount INT); +-- +ok +== +CREATE INDEX idx_amount ON indexed_returning(amount); +-- +ok +== +INSERT INTO indexed_returning VALUES (1, 'a', 100), (2, 'b', 200), (3, 'c', 300); +-- +ok +== +DELETE FROM indexed_returning WHERE amount >= 200 RETURNING val; +-- +ok +== +SELECT * FROM indexed_returning ORDER BY id; +-- +ok +== +SELECT * FROM indexed_returning WHERE amount = 100; +-- +ok +== +SELECT COUNT(*) FROM indexed_returning WHERE amount = 200; +-- +ok +== +INSERT INTO indexed_returning VALUES (2, 'new_b', 250), (3, 'new_c', 350); +-- +ok +== +SELECT * FROM indexed_returning WHERE amount = 250; +-- +ok +== +SELECT * FROM indexed_returning WHERE amount = 350; +-- +ok +== +DELETE FROM indexed_returning WHERE id = 2 RETURNING *; +-- +ok +== +INSERT INTO indexed_returning VALUES (2, 'tx_b', 225); +-- +ok +== +SELECT * FROM indexed_returning WHERE amount = 225; +-- +ok +== +SELECT * FROM indexed_returning WHERE id = 2; +-- +ok +== +DROP TABLE indexed_returning; +-- +ok +== diff --git a/parser/testdata/corpus/sql/returning/returning_delete_list.test b/parser/testdata/corpus/sql/returning/returning_delete_list.test new file mode 100644 index 0000000..c411fe3 --- /dev/null +++ b/parser/testdata/corpus/sql/returning/returning_delete_list.test @@ -0,0 +1,30 @@ +# source: test/sql/returning/returning_delete_list.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +CREATE TABLE all_types("varchar" VARCHAR, nested_int_array INTEGER[][]);; +-- +ok +== +INSERT INTO all_types VALUES('🦆🦆🦆🦆🦆🦆',[]); +-- +ok +== +INSERT INTO all_types VALUES('goo'||chr(0) || 'se' ,[[], [42, 999, NULL, NULL, -42], NULL, [], [42, 999, NULL, NULL, -42]]); +-- +ok +== +INSERT INTO all_types VALUES(NULL,NULL); +-- +ok +== +DELETE +FROM all_types +WHERE EXISTS + (SELECT all_types."varchar" AS c2 + FROM all_types AS ref_0) +RETURNING all_types.nested_int_array +-- +ok +== diff --git a/parser/testdata/corpus/sql/returning/returning_delete_same_transaction.test b/parser/testdata/corpus/sql/returning/returning_delete_same_transaction.test new file mode 100644 index 0000000..2a0a9b7 --- /dev/null +++ b/parser/testdata/corpus/sql/returning/returning_delete_same_transaction.test @@ -0,0 +1,81 @@ +# source: test/sql/returning/returning_delete_same_transaction.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +CREATE TABLE t1 (id INT PRIMARY KEY, name TEXT); +-- +ok +== +INSERT INTO t1 VALUES (1, 'alice'); +-- +ok +== +DELETE FROM t1 WHERE id = 1 RETURNING *; +-- +ok +== +CREATE TABLE t2 (id INT, name TEXT); +-- +ok +== +INSERT INTO t2 VALUES (1, 'alice'); +-- +ok +== +DELETE FROM t2 WHERE id = 1 RETURNING *; +-- +ok +== +CREATE TABLE t3 (id INT, name TEXT); +-- +ok +== +INSERT INTO t3 VALUES (1, 'alice'), (2, 'bob'), (3, 'charlie'); +-- +ok +== +DELETE FROM t3 RETURNING *; +-- +ok +== +CREATE TABLE t4 (id INT PRIMARY KEY, name TEXT); +-- +ok +== +INSERT INTO t4 VALUES (1, 'committed'); +-- +ok +== +INSERT INTO t4 VALUES (2, 'local'); +-- +ok +== +DELETE FROM t4 RETURNING *; +-- +ok +== +CREATE TABLE t5 (id INT, name TEXT, value INT); +-- +ok +== +INSERT INTO t5 VALUES (1, 'alice', 100); +-- +ok +== +DELETE FROM t5 WHERE id = 1 RETURNING id; +-- +ok +== +CREATE TABLE t6 (id INT, value INT); +-- +ok +== +INSERT INTO t6 VALUES (1, 10), (2, 20); +-- +ok +== +DELETE FROM t6 RETURNING id, value * 2; +-- +ok +== diff --git a/parser/testdata/corpus/sql/returning/returning_insert.test b/parser/testdata/corpus/sql/returning/returning_insert.test new file mode 100644 index 0000000..a9fa1dc --- /dev/null +++ b/parser/testdata/corpus/sql/returning/returning_insert.test @@ -0,0 +1,130 @@ +# source: test/sql/returning/returning_insert.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +INSERT INTO table1 VALUES (1, 2, 3); +-- +ok +== +INSERT INTO table1 VALUES (1, 2, 3) RETURNING a; +-- +ok +== +INSERT INTO table1 VALUES (1, 2, 3) RETURNING *; +-- +ok +== +INSERT INTO table1 VALUES (1, 2, 3) RETURNING COLUMNS('a|c'); +-- +ok +== +INSERT INTO table1 VALUES (1, 2, 3) RETURNING COLUMNS('a|c') + 42; +-- +ok +== +INSERT INTO table1 VALUES (10, 20, 30), (40, 50, 60), (70, 80, 90) RETURNING *, c, b, a; +-- +ok +== +INSERT INTO table1 VALUES (1, 2, 3) RETURNING c, a, b; +-- +ok +== +INSERT INTO table1 (c, b, a) VALUES (3, 2, 1) RETURNING a, b, c; +-- +ok +== +INSERT INTO table1 VALUES (1, 2, 3) RETURNING a AS alias1, b AS alias2; +-- +ok +== +INSERT INTO table1 VALUES (1, 1, 1), (2, 2, 2), (3, 3, 3) RETURNING SUM(a); +-- +ok +== +INSERT INTO table1(a) VALUES (10) RETURNING *; +-- +ok +== +INSERT INTO table1 (a, b, c) SELECT * from table1 WHERE a = 10 and b=-2 and c=-3 RETURNING *; +-- +ok +== +INSERT INTO table1 (SELECT row_number() OVER (ORDER BY a) as row_number, b, c FROM table1 LIMIT 1) RETURNING *; +-- +ok +== +INSERT INTO table1 (a, b, c) SELECT * from table1 WHERE a = 100000 and b = 10000 and c=100000 RETURNING a, b, c; +-- +ok +== +INSERT INTO table1 (a, b, c) VALUES (10, 1000, 1000) RETURNING a IN (SELECT a from table1 where b = -2); +-- +ok +== +INSERT INTO table1 VALUES (1, 2, 3) RETURNING CASE WHEN b=2 THEN a ELSE b END; +-- +ok +== +INSERT INTO table1 VALUES (1, 2, 3) RETURNING CASE WHEN b=3 THEN a ELSE b END; +-- +ok +== +INSERT INTO table1 VALUES (1, 1, -3) RETURNING a + b + c; +-- +ok +== +INSERT INTO table1 VALUES (1, 2, 3) RETURNING 'hello'; +-- +ok +== +INSERT INTO table1 VALUES (1, 2, 3) RETURNING [a, b, c]; +-- +ok +== +INSERT INTO table1 VALUES (1, 2, 3) RETURNING {'a':a, 'b':b, 'c':c}; +-- +ok +== +INSERT INTO table1(a) (SELECT 42) RETURNING a, b; +-- +ok +== +INSERT INTO table1(a) VALUES (SELECT 42) RETURNING a, b, (select 10); +-- +error: Parser Error: syntax error at or near "SELECT" +== +INSERT INTO table1 VALUES (1,2,3) RETURNING d, e, f +-- +ok +== +INSERT INTO table1 SELECT * from table1 RETURNING row_number() OVER (ORDER BY a) as row_number, a, b FROM table1; +-- +error: Parser Error: syntax error at or near "FROM" +== +INSERT INTO table1 VALUES (1, 2, 3) RETURNING [1, 2] IN (SELECT [a, b] from table1); +-- +ok +== +INSERT INTO table1(a, b) VALUES (42, 43) RETURNING (SELECT a), (SELECT b), NULL; +-- +ok +== +INSERT INTO table1 VALUES (-10, -20, -30) + RETURNING '-10.-20' IN (SELECT group_concat(a) OVER (ORDER BY b) as GC FROM table1); +-- +ok +== +INSERT INTO table2(a,b) VALUES ('hello duckdb', 1) RETURNING b, a; +-- +ok +== +INSERT INTO table2(b) VALUES (97) RETURNING b::VARCHAR; +-- +ok +== +INSERT INTO table2(a, b) VALUES ('duckdb', 97) RETURNING {'a': a, 'b': b}; +-- +ok +== diff --git a/parser/testdata/corpus/sql/returning/returning_large.test b/parser/testdata/corpus/sql/returning/returning_large.test new file mode 100644 index 0000000..5f73c9b --- /dev/null +++ b/parser/testdata/corpus/sql/returning/returning_large.test @@ -0,0 +1,9 @@ +# source: test/sql/returning/returning_large.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +INSERT INTO table1(a, b, c) SELECT a, b, c FROM table1 RETURNING a; +-- +ok +== diff --git a/parser/testdata/corpus/sql/returning/returning_update.test b/parser/testdata/corpus/sql/returning/returning_update.test new file mode 100644 index 0000000..9b4df4d --- /dev/null +++ b/parser/testdata/corpus/sql/returning/returning_update.test @@ -0,0 +1,186 @@ +# source: test/sql/returning/returning_update.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +UPDATE table1 +SET a=-10 +WHERE a = 1 RETURNING a, b, c; +-- +ok +== +UPDATE table1 +SET a=a*-2, b=b*2, c=c*2 +WHERE a = 2 RETURNING a, b, c; +-- +ok +== +UPDATE table1 +SET a=a*-2, b=b*2, c=c*2 +WHERE a = 3 RETURNING a; +-- +ok +== +UPDATE table1 +SET a=a*-2, b=b*2, c=c*2 +WHERE a = 4 RETURNING *; +-- +ok +== +UPDATE table1 +SET a=-5, b=2, c=1 +WHERE a=5 AND b=-2 AND c=-3 RETURNING *, c, b, a; +-- +ok +== +UPDATE table1 +SET c=1, b=2, a=3 +WHERE a=6 AND b=-2 AND c=-3 RETURNING c, b, a; +-- +ok +== +UPDATE table1 +SET c=1, b=2, a=3 +WHERE a=7 AND b=-2 AND c=-3 RETURNING c as aliasc, a as aliasa, b as aliasb; +-- +ok +== +UPDATE table1 SET c=1, b=5, a=7 WHERE a > 5 RETURNING SUM(a); +-- +ok +== +UPDATE table1 +SET c=15 +WHERE a=8 RETURNING *; +-- +ok +== +UPDATE table1 +SET a=-9, b=b+7 +WHERE a=9 +RETURNING a + b + c; +-- +ok +== +UPDATE table1 +SET a=-10 +WHERE a=10 +RETURNING 'duckdb'; +-- +ok +== +UPDATE table3 +SET c3 = t2.c2 +FROM table2 AS t2 +RETURNING a3, b3, c3 IN (1, 2, 3, 100, 200); +-- +ok +== +SELECT a3, b3, c3 IN (1, 2, 3, 100, 200) FROM table3; +-- +ok +== +UPDATE table3 +SET b3 = t2.b2 +FROM table2 AS t2 +WHERE table3.a3 = t2.a2 RETURNING a3, b3, c3 IN (1, 2, 3, 100, 200); +-- +ok +== +UPDATE table4 +SET b4 = temp_table.sum_a +FROM (SELECT sum(a5) as sum_a, c5 FROM table5 GROUP BY c5 ORDER BY sum_a) as temp_table +WHERE table4.c4 = temp_table.c5 +RETURNING *; +-- +ok +== +UPDATE table4 +SET b4 = temp_table.row_num +FROM (SELECT row_number() OVER (ORDER BY a4) as row_num, c4 from table4) as temp_table +WHERE table4.a4=temp_table.row_num +RETURNING *; +-- +ok +== +UPDATE table1 SET a = 0, b = 0, c = 0 WHERE a = 10 RETURNING a IN (SELECT a FROM table1); +-- +ok +== +UPDATE table3 SET a3 = 0, b3 = 0, c3 = 0 FROM table3 t3 WHERE t3.a3 = 0 returning *; +-- +ok +== +UPDATE table3 SET a3 = 0 WHERE a3 = 1 RETURNING CASE WHEN b3=1 THEN a3 ELSE b3 END; +-- +ok +== +UPDATE table3 SET a3 = -1 WHERE a3 = 0 RETURNING CASE WHEN b3=2 THEN a3 ELSE b3 END; +-- +ok +== +INSERT INTO table2 VALUES ('duckdb', 1); +-- +ok +== +UPDATE table2 +SET a='hello world' +WHERE b = 1 +RETURNING a, b; +-- +ok +== +UPDATE table2 +SET b=100 +WHERE b = 1 +RETURNING b::VARCHAR; +-- +ok +== +UPDATE table2 +SET a='Mr.Duck', b=99 +WHERE b=100 +RETURNING {'a': a, 'b': b}; +-- +ok +== +UPDATE table2 +SET b=98 +WHERE b=99 +RETURNING [a, b::VARCHAR]; +-- +ok +== +UPDATE table3 +SET b=b+1 +RETURNING *; +-- +ok +== +CREATE TABLE table4 (a INTEGER, b INTEGER, c INTEGER); +-- +ok +== +CREATE INDEX b_index ON table4(b); +-- +ok +== +INSERT INTO table4 VALUES (1, 2, 3), (4, 5, 6), (7, 8, 9); +-- +ok +== +UPDATE table4 +SET b = 10 +WHERE b = 2 +RETURNING *; +-- +ok +== +SELECT * FROM table4; +-- +ok +== +UPDATE table1 SET a=5 returning a; +-- +ok +== diff --git a/parser/testdata/corpus/sql/sample/can_sample_from_ingested_files.test b/parser/testdata/corpus/sql/sample/can_sample_from_ingested_files.test new file mode 100644 index 0000000..ff183f4 --- /dev/null +++ b/parser/testdata/corpus/sql/sample/can_sample_from_ingested_files.test @@ -0,0 +1,49 @@ +# source: test/sql/sample/can_sample_from_ingested_files.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +create table all_types as select * exclude(small_enum, medium_enum, large_enum, "union", bit, empty_struct) from test_all_types(); +-- +ok +== +copy all_types to '{TEST_DIR}/sample_all_types.csv' (FORMAT CSV); +-- +ok +== +Create table all_types_csv_1 as select * from read_csv_auto('{TEST_DIR}/sample_all_types.csv'); +-- +ok +== +Create table all_types_csv_2 as select * from read_csv_auto('{TEST_DIR}/sample_all_types.csv'); +-- +ok +== +select * from all_types_csv_1; +-- +ok +== +select * from all_types_csv_2; +-- +ok +== +copy (SELECT * from all_types) to '{TEST_DIR}/sample_all_types.parquet' (FORMAT PARQUET); +-- +ok +== +Create table all_types_parquet_1 as select * from read_parquet('{TEST_DIR}/sample_all_types.parquet'); +-- +ok +== +Create table all_types_parquet_2 as select * from read_parquet('{TEST_DIR}/sample_all_types.parquet'); +-- +ok +== +select * from all_types_parquet_1; +-- +ok +== +select * from all_types_parquet_2; +-- +ok +== diff --git a/parser/testdata/corpus/sql/sample/same_seed_same_sample.test b/parser/testdata/corpus/sql/sample/same_seed_same_sample.test new file mode 100644 index 0000000..e74ac4f --- /dev/null +++ b/parser/testdata/corpus/sql/sample/same_seed_same_sample.test @@ -0,0 +1,17 @@ +# source: test/sql/sample/same_seed_same_sample.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +CREATE OR REPLACE TABLE test AS SELECT UNNEST(RANGE(100000)) as x; +-- +ok +== +SELECT COUNT(*), min(x) FROM test TABLESAMPLE system (25 PERCENT) REPEATABLE (42); +-- +ok +== +SELECT COUNT(*), min(x) FROM test TABLESAMPLE BERNOULLI (25 PERCENT) REPEATABLE (42); +-- +ok +== diff --git a/parser/testdata/corpus/sql/sample/table_samples/basic_sample_tests.test b/parser/testdata/corpus/sql/sample/table_samples/basic_sample_tests.test new file mode 100644 index 0000000..295e5eb --- /dev/null +++ b/parser/testdata/corpus/sql/sample/table_samples/basic_sample_tests.test @@ -0,0 +1,65 @@ +# source: test/sql/sample/table_samples/basic_sample_tests.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +select count(*) from range(100000) using sample (10000); +-- +ok +== +select count(*) from range(100) using sample (10); +-- +ok +== +select count(*) from range(205000) using sample (10000); +-- +ok +== +create table t1 as select range a from range(204800); +-- +ok +== +select * from duckdb_table_sample('t1'); +-- +ok +== +create or replace table t1 as select range a from range(1000); +-- +ok +== +select avg(a) > 200, avg(a) < 800 from duckdb_table_sample('t1'); +-- +ok +== +create or replace table t1 as select range a from range(204800); +-- +ok +== +select avg(a) > (0.2*204800), avg(a) < (0.8*204800) from duckdb_table_sample('t1'); +-- +ok +== +select count(*) from duckdb_table_sample('t1') where a < 102400; +-- +ok +== +select count(*) from duckdb_table_sample('t1') where a > 102400; +-- +ok +== +select count(*) from t1 using sample (200000); +-- +ok +== +create or replace table materialized_range as select * from range(100); +-- +ok +== +create or replace table integers_1 as (select range b from materialized_range); +-- +ok +== +select count(b) from duckdb_table_sample('integers_1') where b in (select * from materialized_range); +-- +ok +== diff --git a/parser/testdata/corpus/sql/sample/table_samples/table_sample_converts_to_block_sample.test b/parser/testdata/corpus/sql/sample/table_samples/table_sample_converts_to_block_sample.test new file mode 100644 index 0000000..194bb7b --- /dev/null +++ b/parser/testdata/corpus/sql/sample/table_samples/table_sample_converts_to_block_sample.test @@ -0,0 +1,29 @@ +# source: test/sql/sample/table_samples/table_sample_converts_to_block_sample.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +create table materialized_range as select 1 a from range(102400); +-- +ok +== +select count(*) from duckdb_table_sample('materialized_range'); +-- +ok +== +insert into materialized_range select 2 a from range(102400); +-- +ok +== +select a, count(*) from duckdb_table_sample('materialized_range') group by all order by a; +-- +ok +== +insert into materialized_range select 3 a from range(102400); +-- +ok +== +select a, count(*) > 650 from duckdb_table_sample('materialized_range') group by all order by a; +-- +ok +== diff --git a/parser/testdata/corpus/sql/sample/table_samples/test_sample_is_destroyed_on_updates.test b/parser/testdata/corpus/sql/sample/table_samples/test_sample_is_destroyed_on_updates.test new file mode 100644 index 0000000..b693ff6 --- /dev/null +++ b/parser/testdata/corpus/sql/sample/table_samples/test_sample_is_destroyed_on_updates.test @@ -0,0 +1,53 @@ +# source: test/sql/sample/table_samples/test_sample_is_destroyed_on_updates.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +create or replace table integers_1 as select range a, range+1 b from range(102400); +-- +ok +== +select count(*) from duckdb_table_sample('integers_1') order by all; +-- +ok +== +delete from integers_1 where a = 3; +-- +ok +== +select count(*) from duckdb_table_sample('integers_1'); +-- +ok +== +update integers_1 set a = 5 where a = 1; +-- +ok +== +select * from duckdb_table_sample('integers_1'); +-- +ok +== +create or replace table integers_1 as select range a, range+1 b from range(204800); +-- +ok +== +Alter table integers_1 add column c DOUBLE; +-- +ok +== +Alter table integers_1 alter b TYPE VARCHAR +-- +ok +== +Alter table integers_1 drop b; +-- +ok +== +create or replace table integers_1 as select range a, range+1 b from range(500); +-- +ok +== +insert into integers_1 select range a from range(500); +-- +ok +== diff --git a/parser/testdata/corpus/sql/sample/table_samples/test_sample_types.test b/parser/testdata/corpus/sql/sample/table_samples/test_sample_types.test new file mode 100644 index 0000000..0aa902c --- /dev/null +++ b/parser/testdata/corpus/sql/sample/table_samples/test_sample_types.test @@ -0,0 +1,69 @@ +# source: test/sql/sample/table_samples/test_sample_types.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +create table string_samples as select range::Varchar a from range(204800); +-- +ok +== +select count(*) from duckdb_table_sample('string_samples') where a is NULL; +-- +ok +== +create table struct_samples as select {'key1': 'quack-a-lack', 'key2': range} a from range(204800); +-- +ok +== +select count(*) from duckdb_table_sample('struct_samples') where a is null; +-- +ok +== +create table blob_samples as select '\xAA\xAB\xAC'::BLOB a from range(204800); +-- +ok +== +select count(*) from duckdb_table_sample('blob_samples') where a is NULL; +-- +ok +== +create table integral_samples as select range::BIGINT a, range::DOUBLE b, range::FLOAT c, range::HUGEINT d, INTERVAL 1 YEAR e from range(204800); +-- +ok +== +select count(*) from duckdb_table_sample('integral_samples') where a NOT null; +-- +ok +== +select count(*) from duckdb_table_sample('integral_samples') where b NOT null; +-- +ok +== +select count(*) from duckdb_table_sample('integral_samples') where c NOT null; +-- +ok +== +select count(*) from duckdb_table_sample('integral_samples') where d NOT null; +-- +ok +== +select count(*) from duckdb_table_sample('integral_samples') where e IS null; +-- +ok +== +CREATE or replace TABLE t1 as select range a, [1, a, 2] b, a::VARCHAR || 'ducktastic' c, get_current_timestamp() d from range(1000000); +-- +ok +== +select count(*) from duckdb_table_sample('t1') where b is null; +-- +ok +== +select count(*) from duckdb_table_sample('t1') where c is null; +-- +ok +== +select count(*) from duckdb_table_sample('t1') where d is null; +-- +ok +== diff --git a/parser/testdata/corpus/sql/sample/table_samples/test_table_sample_errors.test b/parser/testdata/corpus/sql/sample/table_samples/test_table_sample_errors.test new file mode 100644 index 0000000..f069b6f --- /dev/null +++ b/parser/testdata/corpus/sql/sample/table_samples/test_table_sample_errors.test @@ -0,0 +1,17 @@ +# source: test/sql/sample/table_samples/test_table_sample_errors.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +create view v1 as select * from t1; +-- +ok +== +select * from duckdb_table_sample('v1'); +-- +ok +== +select * from duckdb_table_sample('a'); +-- +ok +== diff --git a/parser/testdata/corpus/sql/sample/test_sample_too_big.test b/parser/testdata/corpus/sql/sample/test_sample_too_big.test new file mode 100644 index 0000000..bf1a624 --- /dev/null +++ b/parser/testdata/corpus/sql/sample/test_sample_too_big.test @@ -0,0 +1,29 @@ +# source: test/sql/sample/test_sample_too_big.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +CREATE TABLE t1(a INT); +-- +ok +== +INSERT INTO t1 VALUES(1), (2), (3), (3), (5); +-- +ok +== +SELECT * FROM t1 TABLESAMPLE RESERVOIR(1222222220022220); +-- +error: Parser Error: Sample rows 1222222220022220 out of range, must be between 0 and 1000000000 +== +SELECT * FROM t1 WHERE a IN (SELECT * FROM t1 TABLESAMPLE RESERVOIR(1222222220022220)); +-- +error: Parser Error: Sample rows 1222222220022220 out of range, must be between 0 and 1000000000 +== +SELECT * FROM t1 WHERE a IN (SELECT * FROM t1 TABLESAMPLE RESERVOIR(1000000001)); +-- +error: Parser Error: Sample rows 1000000001 out of range, must be between 0 and 1000000000 +== +SELECT * FROM t1 WHERE a IN (SELECT * FROM t1 TABLESAMPLE RESERVOIR(1000000000)) order by all +-- +ok +== diff --git a/parser/testdata/corpus/sql/sample/test_sample_too_big.test.metadata.json b/parser/testdata/corpus/sql/sample/test_sample_too_big.test.metadata.json new file mode 100644 index 0000000..a22c946 --- /dev/null +++ b/parser/testdata/corpus/sql/sample/test_sample_too_big.test.metadata.json @@ -0,0 +1,7 @@ +{ + "todo": { + "3d93e9ac0604a93a": "transformer-raised parser error: upstream rejects in the transformer, not the grammar; expected to clear as transformers land (milestones 3-5)", + "576e9054512e0499": "transformer-raised parser error: upstream rejects in the transformer, not the grammar; expected to clear as transformers land (milestones 3-5)", + "79b103507c279c56": "transformer-raised parser error: upstream rejects in the transformer, not the grammar; expected to clear as transformers land (milestones 3-5)" + } +} diff --git a/parser/testdata/corpus/sql/sample/test_system_rows.test b/parser/testdata/corpus/sql/sample/test_system_rows.test new file mode 100644 index 0000000..a1c7d1a --- /dev/null +++ b/parser/testdata/corpus/sql/sample/test_system_rows.test @@ -0,0 +1,116 @@ +# source: test/sql/sample/test_system_rows.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +CREATE TABLE test_table AS SELECT i FROM range(10000) tbl(i); +-- +ok +== +SELECT COUNT(*) FROM test_table USING SAMPLE 100 ROWS (system); +-- +ok +== +SELECT COUNT(*) FROM test_table USING SAMPLE 500 ROWS (system); +-- +ok +== +EXPLAIN SELECT * FROM test_table USING SAMPLE 100 ROWS (system); +-- +ok +== +EXPLAIN SELECT * FROM test_table USING SAMPLE 500 ROWS (system, 42); +-- +ok +== +SELECT COUNT(*) FROM test_table USING SAMPLE 15000 ROWS (system); +-- +ok +== +SELECT COUNT(*) FROM test_table USING SAMPLE 0 ROWS (system); +-- +ok +== +SELECT COUNT(*) FROM test_table USING SAMPLE 1 ROWS (system); +-- +ok +== +SELECT COUNT(*) FROM test_table USING SAMPLE 250 ROWS (system, 42); +-- +ok +== +SELECT COUNT(*) FROM test_table USING SAMPLE 200 ROWS (system, 100); +-- +ok +== +SELECT COUNT(*) FROM test_table USING SAMPLE 200 ROWS (system, 999); +-- +ok +== +WITH s1 AS ( + SELECT i FROM test_table USING SAMPLE 10 ROWS (system, 1) +), s2 AS ( + SELECT i FROM test_table USING SAMPLE 10 ROWS (system, 999) +) +SELECT COUNT(*) > 0 FROM ( + (SELECT i FROM s1 EXCEPT SELECT i FROM s2) + UNION ALL + (SELECT i FROM s2 EXCEPT SELECT i FROM s1) +); +-- +ok +== +CREATE TABLE small_table AS SELECT i FROM range(10) tbl(i); +-- +ok +== +CREATE TABLE range_sample_src AS SELECT i FROM range(5000) tbl(i); +-- +ok +== +SELECT COUNT(*) FROM small_table USING SAMPLE 5 ROWS (system); +-- +ok +== +SELECT COUNT(*) FROM small_table USING SAMPLE 20 ROWS (system); +-- +ok +== +SELECT COUNT(*) FROM small_table USING SAMPLE 1 ROWS (system); +-- +ok +== +WITH base AS ( + SELECT i FROM test_table +) +SELECT COUNT(*) FROM base USING SAMPLE 37 ROWS (system); +-- +ok +== +SELECT COUNT(*) FROM range_sample_src USING SAMPLE 120 ROWS (system); +-- +ok +== +WITH x AS ( + SELECT * FROM test_table ORDER BY i LIMIT 200 +) +SELECT COUNT(*) FROM x USING SAMPLE 50 ROWS (system); +-- +ok +== +SELECT COUNT(*) FROM ( + SELECT i, row_number() OVER w + FROM test_table + WINDOW w AS (ORDER BY i) +) sq USING SAMPLE 50 ROWS (system); +-- +ok +== +SELECT COUNT(*) FROM test_table WHERE i < 5000 USING SAMPLE 100 ROWS (system); +-- +ok +== +SELECT COUNT(*) FROM (SELECT * FROM test_table WHERE i % 2 = 0) tbl(i) USING SAMPLE 200 ROWS (system); +-- +ok +== diff --git a/parser/testdata/corpus/sql/sample/test_system_rows_pushdown.test b/parser/testdata/corpus/sql/sample/test_system_rows_pushdown.test new file mode 100644 index 0000000..f46da48 --- /dev/null +++ b/parser/testdata/corpus/sql/sample/test_system_rows_pushdown.test @@ -0,0 +1,36 @@ +# source: test/sql/sample/test_system_rows_pushdown.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +CREATE TABLE pushdown_test AS SELECT i FROM range(1000000) tbl(i); +-- +ok +== +SELECT COUNT(*) > 0 AND COUNT(*) <= 50 FROM ( + SELECT * FROM pushdown_test WHERE i % 2 = 0 +) USING SAMPLE 50 ROWS (system); +-- +ok +== +SELECT COUNT(*) FROM (SELECT i FROM pushdown_test) USING SAMPLE 200 ROWS (system); +-- +ok +== +EXPLAIN SELECT COUNT(*) FROM (SELECT i FROM range(10000) tbl(i)) USING SAMPLE 100 ROWS (system) +-- +ok +== +EXPLAIN SELECT COUNT(*) FROM (SELECT i FROM pushdown_test) USING SAMPLE 100 ROWS (system) +-- +ok +== +SELECT COUNT(*) FROM ( + SELECT a.i FROM + (SELECT * FROM pushdown_test USING SAMPLE 1000 ROWS (system, 42)) a, + (SELECT * FROM pushdown_test USING SAMPLE 1000 ROWS (system, 42)) b + WHERE a.i = b.i +); +-- +ok +== diff --git a/parser/testdata/corpus/sql/secrets/create_secret_expression.test b/parser/testdata/corpus/sql/secrets/create_secret_expression.test new file mode 100644 index 0000000..dd94a01 --- /dev/null +++ b/parser/testdata/corpus/sql/secrets/create_secret_expression.test @@ -0,0 +1,93 @@ +# source: test/sql/secrets/create_secret_expression.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +CREATE SECRET a (TYPE http); +-- +ok +== +CREATE PERSISTENT SECRET a (TYPE http); +-- +ok +== +CREATE PERSISTENT SECRET b (TYPE http); +-- +ok +== +CREATE OR REPLACE SECRET a (TYPE http); +-- +ok +== +CREATE SECRET IF NOT EXISTS a (TYPE http); +-- +ok +== +CREATE OR REPLACE SECRET IF NOT EXISTS a (TYPE http); +-- +error: Parser Error: Cannot specify both OR REPLACE and IF NOT EXISTS within single create statement +== +CREATE TABLE bearer_tokens AS SELECT 'blablab' +-- +ok +== +SET VARIABLE my_bearer_token='hocus pocus this token is bogus'; +-- +ok +== +CREATE SECRET http (TYPE HTTP, BEARER_TOKEN getvariable('my_bearer_token')); +-- +ok +== +SELECT sum(#1 == 'bearer_token=redacted') FROM (SELECT unnest(secret_string.split(';')) FROM duckdb_secrets() where name='http'); +-- +ok +== +CREATE SECRET scope_as_struct (TYPE HTTP, BEARER_TOKEN some_field, scope ('hi', 'hello')); +-- +ok +== +select scope from duckdb_secrets() where name='scope_as_struct' +-- +ok +== +CREATE OR REPLACE SECRET my_secret (TYPE HTTP, SCOPE 'https://duckdb.org'); +-- +ok +== +CREATE OR REPLACE SECRET my_secret (TYPE HTTP, SCOPE ['https://duckdb.org', 'http://extensions.duckdb.org']); +-- +ok +== +CREATE OR REPLACE SECRET my_secret (TYPE HTTP, BEARER_TOKEN getvariable('my_bearer_token')); +-- +ok +== +CREATE OR REPLACE SECRET my_secret (TYPE HTTP, HTTP_PROXY 'http://some-proxy/'); +-- +ok +== +CREATE OR REPLACE SECRET my_secret (TYPE HTTP, VERIFY_SSL 0); +-- +ok +== +CREATE OR REPLACE SECRET my_secret (TYPE HTTP, VERIFY_SSL 1); +-- +ok +== +CREATE OR REPLACE SECRET my_secret (TYPE HTTP, VERIFY_SSL something); +-- +ok +== +CREATE OR REPLACE SECRET my_secret (TYPE HTTP, SCOPE ['https://duckdb.org', 'http://extensions.duckdb.org'], BEARER_TOKEN getvariable('my_bearer_token'), HTTP_PROXY 'http://some-proxy/', VERIFY_SSL 1); +-- +ok +== +CREATE SECRET test_redacted (TYPE HTTP, BEARER_TOKEN super_secret); +-- +ok +== +SELECT l[2] secret_value FROM (SELECT unnest(list_transform(split(secret_string, ';'), lambda x : split(x, '='))) l FROM duckdb_secrets() WHERE name='test_redacted') where l[1]='bearer_token' +-- +ok +== diff --git a/parser/testdata/corpus/sql/secrets/create_secret_expression.test.metadata.json b/parser/testdata/corpus/sql/secrets/create_secret_expression.test.metadata.json new file mode 100644 index 0000000..b24399a --- /dev/null +++ b/parser/testdata/corpus/sql/secrets/create_secret_expression.test.metadata.json @@ -0,0 +1,5 @@ +{ + "todo": { + "00565c04938f8649": "transformer-raised parser error: upstream rejects in the transformer, not the grammar; expected to clear as transformers land (milestones 3-5)" + } +} diff --git a/parser/testdata/corpus/sql/secrets/create_secret_filesystem_logging.test b/parser/testdata/corpus/sql/secrets/create_secret_filesystem_logging.test new file mode 100644 index 0000000..70b4f9b --- /dev/null +++ b/parser/testdata/corpus/sql/secrets/create_secret_filesystem_logging.test @@ -0,0 +1,21 @@ +# source: test/sql/secrets/create_secret_filesystem_logging.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +SET secret_directory='{TEST_DIR}/secret_fs_logging'; +-- +ok +== +CREATE PERSISTENT SECRET my_secret (TYPE HTTP); +-- +ok +== +SELECT fs, op FROM duckdb_logs_parsed('FileSystem') WHERE path LIKE '%my_secret%' ORDER BY timestamp; +-- +ok +== +FROM duckdb_secrets(); +-- +ok +== diff --git a/parser/testdata/corpus/sql/secrets/create_secret_hffs_autoload.test b/parser/testdata/corpus/sql/secrets/create_secret_hffs_autoload.test new file mode 100644 index 0000000..ba2f2b8 --- /dev/null +++ b/parser/testdata/corpus/sql/secrets/create_secret_hffs_autoload.test @@ -0,0 +1,31 @@ +# source: test/sql/secrets/create_secret_hffs_autoload.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +set allow_persistent_secrets=false; +-- +ok +== +CREATE SECRET hf1 ( + TYPE HUGGINGFACE, + TOKEN 'bla' +) +-- +ok +== +CREATE SECRET hf1 ( + TYPE HUGGINGFACE, + PROVIDER config, + TOKEN 'bla' +) +-- +ok +== +CREATE SECRET hf2 ( + TYPE HUGGINGFACE, + PROVIDER 'credential_chain' +) +-- +ok +== diff --git a/parser/testdata/corpus/sql/secrets/create_secret_persistence_no_client_context.test b/parser/testdata/corpus/sql/secrets/create_secret_persistence_no_client_context.test new file mode 100644 index 0000000..0d5ded1 --- /dev/null +++ b/parser/testdata/corpus/sql/secrets/create_secret_persistence_no_client_context.test @@ -0,0 +1,13 @@ +# source: test/sql/secrets/create_secret_persistence_no_client_context.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +set secret_directory='{TEST_DIR}/create_secret_persistence_no_client_context' +-- +ok +== +CREATE PERSISTENT SECRET s1 ( TYPE HTTP ) +-- +ok +== diff --git a/parser/testdata/corpus/sql/secrets/create_transaction_secret.test b/parser/testdata/corpus/sql/secrets/create_transaction_secret.test new file mode 100644 index 0000000..55f3d72 --- /dev/null +++ b/parser/testdata/corpus/sql/secrets/create_transaction_secret.test @@ -0,0 +1,13 @@ +# source: test/sql/secrets/create_transaction_secret.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +CREATE TRANSACTION SECRET transaction_secret (TYPE HTTP); +-- +error: Parser Error: syntax error at or near "TRANSACTION" +== +CREATE SECRET transaction_secret IN transaction (TYPE HTTP); +-- +ok +== diff --git a/parser/testdata/corpus/sql/secrets/drop_persistent_secret_if_exists.test b/parser/testdata/corpus/sql/secrets/drop_persistent_secret_if_exists.test new file mode 100644 index 0000000..6b44876 --- /dev/null +++ b/parser/testdata/corpus/sql/secrets/drop_persistent_secret_if_exists.test @@ -0,0 +1,21 @@ +# source: test/sql/secrets/drop_persistent_secret_if_exists.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +set secret_directory='{TEST_DIR}/drop_persistent_secret_if_exists' +-- +ok +== +CREATE PERSISTENT SECRET setup_secret (TYPE HTTP); +-- +ok +== +DROP PERSISTENT SECRET setup_secret FROM local_file; +-- +ok +== +DROP PERSISTENT SECRET IF EXISTS nonexistent_secret FROM local_file; +-- +ok +== diff --git a/parser/testdata/corpus/sql/secrets/secret_autoloading_errors.test b/parser/testdata/corpus/sql/secrets/secret_autoloading_errors.test new file mode 100644 index 0000000..6b157f2 --- /dev/null +++ b/parser/testdata/corpus/sql/secrets/secret_autoloading_errors.test @@ -0,0 +1,29 @@ +# source: test/sql/secrets/secret_autoloading_errors.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +CREATE SECRET (TYPE S3) +-- +ok +== +CREATE SECRET (TYPE S3, PROVIDER CONFIG) +-- +ok +== +CREATE SECRET (TYPE S3, PROVIDER CREDENTIAL_CHAIN) +-- +ok +== +CREATE SECRET (TYPE AZURE) +-- +ok +== +CREATE SECRET (TYPE AZURE, PROVIDER CONFIG) +-- +ok +== +CREATE SECRET (TYPE AZURE, PROVIDER CREDENTIAL_CHAIN) +-- +ok +== diff --git a/parser/testdata/corpus/sql/secrets/secret_compatibility_http.test b/parser/testdata/corpus/sql/secrets/secret_compatibility_http.test new file mode 100644 index 0000000..84eed9f --- /dev/null +++ b/parser/testdata/corpus/sql/secrets/secret_compatibility_http.test @@ -0,0 +1,13 @@ +# source: test/sql/secrets/secret_compatibility_http.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +set secret_directory='./data/secrets/http' +-- +ok +== +from duckdb_secrets(); +-- +ok +== diff --git a/parser/testdata/corpus/sql/select/test_multi_column_reference.test b/parser/testdata/corpus/sql/select/test_multi_column_reference.test new file mode 100644 index 0000000..4bd230e --- /dev/null +++ b/parser/testdata/corpus/sql/select/test_multi_column_reference.test @@ -0,0 +1,117 @@ +# source: test/sql/select/test_multi_column_reference.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +CREATE TABLE test.tbl(col INTEGER); +-- +ok +== +INSERT INTO test.tbl VALUES (1), (2), (3); +-- +ok +== +SELECT test.tbl.col FROM test.tbl; +-- +ok +== +SELECT test.t.col FROM test.tbl t; +-- +ok +== +SELECT test.tbl.col FROM test.tbl t; +-- +ok +== +CREATE SCHEMA t +-- +ok +== +CREATE TABLE t.t(t ROW(t INTEGER)); +-- +ok +== +INSERT INTO t.t VALUES ({'t': 42}); +-- +ok +== +SELECT t FROM t.t; +-- +ok +== +SELECT t.t FROM t.t; +-- +ok +== +SELECT t.t.t FROM t.t; +-- +ok +== +SELECT t.t.t.t FROM t.t; +-- +ok +== +DROP SCHEMA t CASCADE; +-- +ok +== +CREATE TABLE t.t AS SELECT {'t': {'t': {'t': {'t': {'t': 42}}}}} t +-- +ok +== +SELECT t.t.t.t.t.t.t.t FROM t.t; +-- +ok +== +SELECT t.t.t.t.t.t.t FROM t.t; +-- +ok +== +SELECT t.t.t.t.t.t FROM t.t; +-- +ok +== +SELECT t.t.t.t.t FROM t.t; +-- +ok +== +DROP SCHEMA t CASCADE +-- +ok +== +CREATE TABLE s1.t1 AS SELECT 42 t +-- +ok +== +CREATE TABLE s2.t1 AS SELECT 84 t +-- +ok +== +SELECT s1.t1.t FROM s1.t1, s2.t1 +-- +ok +== +SELECT * EXCLUDE (s1.t1.t) FROM s1.t1, s2.t1 +-- +ok +== +SELECT * EXCLUDE (S1.T1.T) FROM s1.t1, s2.t1 +-- +ok +== +SELECT s2.t1.t FROM s1.t1, s2.t1 +-- +ok +== +SELECT testX.tbl.col FROM test.tbl; +-- +ok +== +SELECT test.tblX.col FROM test.tbl; +-- +ok +== +SELECT test.tbl.colX FROM test.tbl; +-- +ok +== diff --git a/parser/testdata/corpus/sql/select/test_positional_reference.test b/parser/testdata/corpus/sql/select/test_positional_reference.test new file mode 100644 index 0000000..ec13995 --- /dev/null +++ b/parser/testdata/corpus/sql/select/test_positional_reference.test @@ -0,0 +1,37 @@ +# source: test/sql/select/test_positional_reference.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +SELECT #1 FROM range(1) +-- +ok +== +SELECT #1+#2 FROM range(1) tbl, range(1) tbl2 +-- +ok +== +SELECT #1 FROM (SELECT * FROM range(1)) tbl +-- +ok +== +select (select #1) from range(1); +-- +ok +== +SELECT #2 FROM range(1) +-- +ok +== +SELECT #1 +-- +ok +== +SELECT #0 FROM range(1) +-- +error: Parser Error: Positional reference node needs to be >= 1 +== +SELECT #-1 FROM range(1) +-- +error: Parser Error: syntax error at or near "-" +== diff --git a/parser/testdata/corpus/sql/select/test_positional_reference.test.metadata.json b/parser/testdata/corpus/sql/select/test_positional_reference.test.metadata.json new file mode 100644 index 0000000..76c44fb --- /dev/null +++ b/parser/testdata/corpus/sql/select/test_positional_reference.test.metadata.json @@ -0,0 +1,5 @@ +{ + "todo": { + "792528bd64867f08": "transformer-raised parser error: upstream rejects in the transformer, not the grammar; expected to clear as transformers land (milestones 3-5)" + } +} diff --git a/parser/testdata/corpus/sql/select/test_projection_names.test b/parser/testdata/corpus/sql/select/test_projection_names.test new file mode 100644 index 0000000..5a6f452 --- /dev/null +++ b/parser/testdata/corpus/sql/select/test_projection_names.test @@ -0,0 +1,33 @@ +# source: test/sql/select/test_projection_names.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +CREATE TABLE integers("COL1" INTEGER, "COL2" INTEGER) +-- +ok +== +CREATE TABLE tbl AS SELECT * FROM integers +-- +ok +== +SELECT name FROM pragma_table_info('tbl') ORDER BY name +-- +ok +== +CREATE TABLE tbl AS SELECT COL1, COL2 FROM integers +-- +ok +== +CREATE TABLE tbl AS SELECT integers.COL1, integers.COL2 FROM integers +-- +ok +== +CREATE TABLE s1.integers("COL1" INTEGER, "COL2" INTEGER) +-- +ok +== +CREATE TABLE tbl AS SELECT s1.integers.COL1, s1.integers.COL2 FROM s1.integers +-- +ok +== diff --git a/parser/testdata/corpus/sql/select/test_schema_reference.test b/parser/testdata/corpus/sql/select/test_schema_reference.test new file mode 100644 index 0000000..919d31b --- /dev/null +++ b/parser/testdata/corpus/sql/select/test_schema_reference.test @@ -0,0 +1,21 @@ +# source: test/sql/select/test_schema_reference.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +CREATE TABLE s1.tbl(i INTEGER) +-- +ok +== +SELECT s1.tbl.i FROM s1.tbl; +-- +ok +== +SELECT s2.tbl.i FROM s1.tbl; +-- +ok +== +SELECT a.tbl.i FROM range(10) tbl(i) +-- +ok +== diff --git a/parser/testdata/corpus/sql/select/test_select_alias_prefix_colon.test b/parser/testdata/corpus/sql/select/test_select_alias_prefix_colon.test new file mode 100644 index 0000000..40b656f --- /dev/null +++ b/parser/testdata/corpus/sql/select/test_select_alias_prefix_colon.test @@ -0,0 +1,89 @@ +# source: test/sql/select/test_select_alias_prefix_colon.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +SELECT j : 42; +-- +ok +== +select column_name from (describe SELECT j : 42) +-- +ok +== +SELECT "j" : 42; +-- +ok +== +SELECT 'j': 42 +-- +error: Parser Error: syntax error at or near ":" +== +SELECT "hel lo" : 42; +-- +ok +== +select column_name from (describe SELECT "hel lo" : 42) +-- +ok +== +SELECT j1 : 42, 42 AS j2, 42 j3; +-- +ok +== +CREATE TABLE a (i INTEGER); +-- +ok +== +SELECT j : i FROM a +-- +ok +== +SELECT "j" : "i" FROM a +-- +ok +== +SELECT * FROM b : a +-- +ok +== +SELECT * FROM "b" : a +-- +ok +== +SELECT i FROM b : a +-- +ok +== +SELECT b.i FROM b : a +-- +ok +== +SELECT a.i FROM b : a +-- +ok +== +SELECT a : 42 AS b +-- +error: Parser Error: syntax error at or near "AS" +== +from my_wonderful_values : (values(42)) +-- +ok +== +from 'my_wonderful_values' : (values(42)) +-- +ok +== +from "my_wonderful_values" : (values(42)) +-- +ok +== +from r : range(1) +-- +ok +== +from "r" : range(1) +-- +ok +== diff --git a/parser/testdata/corpus/sql/select/test_select_into.test b/parser/testdata/corpus/sql/select/test_select_into.test new file mode 100644 index 0000000..c0d96c2 --- /dev/null +++ b/parser/testdata/corpus/sql/select/test_select_into.test @@ -0,0 +1,17 @@ +# source: test/sql/select/test_select_into.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +CREATE TABLE t (t TEXT); +-- +ok +== +INSERT INTO t VALUES ('foo'), ('bar'), ('baz'); +-- +ok +== +SELECT * INTO t2 FROM t WHERE t LIKE 'b%'; +-- +error: Parser Error: syntax error at or near "INTO" +== diff --git a/parser/testdata/corpus/sql/select/test_select_locking.test b/parser/testdata/corpus/sql/select/test_select_locking.test new file mode 100644 index 0000000..054aa83 --- /dev/null +++ b/parser/testdata/corpus/sql/select/test_select_locking.test @@ -0,0 +1,21 @@ +# source: test/sql/select/test_select_locking.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +SELECT * FROM t FOR UPDATE; +-- +error: Parser Error: syntax error at or near "FOR" +== +SELECT * FROM t FOR NO KEY UPDATE; +-- +error: Parser Error: syntax error at or near "FOR" +== +SELECT * FROM t FOR SHARE; +-- +error: Parser Error: syntax error at or near "FOR" +== +SELECT * FROM t KEY SHARE; +-- +error: Parser Error: syntax error at or near "SHARE" +== diff --git a/parser/testdata/corpus/sql/select/test_select_qualified_view.test b/parser/testdata/corpus/sql/select/test_select_qualified_view.test new file mode 100644 index 0000000..e6a9a21 --- /dev/null +++ b/parser/testdata/corpus/sql/select/test_select_qualified_view.test @@ -0,0 +1,25 @@ +# source: test/sql/select/test_select_qualified_view.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +CREATE SCHEMA s; +-- +ok +== +create table s.a as select 'hello' as col1; +-- +ok +== +create view s.b as select * from s.a; +-- +ok +== +select s.b.col1 from s.b; +-- +ok +== +select b.col1 from s.b; +-- +ok +== diff --git a/parser/testdata/corpus/sql/setops/ambiguous_order_by.test b/parser/testdata/corpus/sql/setops/ambiguous_order_by.test new file mode 100644 index 0000000..928826f --- /dev/null +++ b/parser/testdata/corpus/sql/setops/ambiguous_order_by.test @@ -0,0 +1,13 @@ +# source: test/sql/setops/ambiguous_order_by.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +select * from (values(42, 84)) s1(c1, c2) union all select * from (values(84, 42)) s2(c2, c3) order by c1; +-- +ok +== +select * from (values(42, 84)) s1(c1, c2) union all select * from (values(84, 42)) s2(c2, c3) order by c3; +-- +ok +== diff --git a/parser/testdata/corpus/sql/setops/setops_pushdown.test b/parser/testdata/corpus/sql/setops/setops_pushdown.test new file mode 100644 index 0000000..1224126 --- /dev/null +++ b/parser/testdata/corpus/sql/setops/setops_pushdown.test @@ -0,0 +1,41 @@ +# source: test/sql/setops/setops_pushdown.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +SELECT 42 WHERE 1=0 EXCEPT SELECT 42 +-- +ok +== +SELECT 42 EXCEPT SELECT 42 WHERE 1=0 +-- +ok +== +SELECT 42 WHERE 1=0 EXCEPT SELECT 42 WHERE 1=0 +-- +ok +== +SELECT 42 WHERE 1=0 INTERSECT SELECT 42 +-- +ok +== +SELECT 42 INTERSECT SELECT 42 WHERE 1=0 +-- +ok +== +SELECT 42 WHERE 1=0 INTERSECT SELECT 42 WHERE 1=0 +-- +ok +== +SELECT 42 WHERE 1=0 UNION ALL SELECT 42 +-- +ok +== +SELECT 42 UNION ALL SELECT 42 WHERE 1=0 +-- +ok +== +SELECT 42 WHERE 1=0 UNION ALL SELECT 42 WHERE 1=0 +-- +ok +== diff --git a/parser/testdata/corpus/sql/setops/test_except.test b/parser/testdata/corpus/sql/setops/test_except.test new file mode 100644 index 0000000..66bc61d --- /dev/null +++ b/parser/testdata/corpus/sql/setops/test_except.test @@ -0,0 +1,53 @@ +# source: test/sql/setops/test_except.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +CREATE TABLE a(i INTEGER) +-- +ok +== +INSERT INTO a VALUES (41), (42), (43) +-- +ok +== +CREATE TABLE b(i INTEGER) +-- +ok +== +INSERT INTO b VALUES (40), (43), (43) +-- +ok +== +select * from a except select * from b order by 1 +-- +ok +== +select * from a intersect select * from b +-- +ok +== +CREATE TABLE t1(a VARCHAR COLLATE NOCASE); +-- +ok +== +INSERT INTO t1 VALUES ('ABC'), ('def'), ('GHI'); +-- +ok +== +CREATE TABLE t2(a VARCHAR COLLATE NOCASE); +-- +ok +== +INSERT INTO t2 VALUES ('abc'), ('DEF'); +-- +ok +== +SELECT * FROM t1 EXCEPT SELECT * FROM t2 ORDER BY a; +-- +ok +== +SELECT * FROM t1 INTERSECT SELECT * FROM t2 ORDER BY a; +-- +ok +== diff --git a/parser/testdata/corpus/sql/setops/test_full_outer_join_union.test b/parser/testdata/corpus/sql/setops/test_full_outer_join_union.test new file mode 100644 index 0000000..f030030 --- /dev/null +++ b/parser/testdata/corpus/sql/setops/test_full_outer_join_union.test @@ -0,0 +1,81 @@ +# source: test/sql/setops/test_full_outer_join_union.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +INSERT INTO integers VALUES (1), (2); +-- +ok +== +CREATE TABLE integers2(i INTEGER); +-- +ok +== +INSERT INTO integers2 VALUES (2), (3); +-- +ok +== +CREATE VIEW v1 AS SELECT * FROM integers UNION ALL SELECT * FROM integers; +-- +ok +== +CREATE VIEW v2 AS SELECT * FROM integers2 UNION ALL SELECT * FROM integers2; +-- +ok +== +SELECT COUNT(*) FROM v1 JOIN v2 USING (i); +-- +ok +== +SELECT COUNT(*) FROM v1 LEFT JOIN v2 USING (i); +-- +ok +== +SELECT COUNT(*) FROM v1 RIGHT JOIN v2 USING (i); +-- +ok +== +SELECT COUNT(*) FROM v1 FULL OUTER JOIN v2 USING (i); +-- +ok +== +SELECT COUNT(*) FROM v1 JOIN v1 v2 USING (i); +-- +ok +== +SELECT COUNT(*) FROM v1 FULL OUTER JOIN v1 v2 USING (i); +-- +ok +== +CREATE VIEW v3 AS SELECT (SELECT integers2.i-1) i FROM integers2 UNION ALL SELECT (SELECT integers2.i-1) i FROM integers2; +-- +ok +== +CREATE VIEW v4 AS SELECT (SELECT integers.i+1) i FROM integers UNION ALL SELECT (SELECT integers.i+1) i FROM integers; +-- +ok +== +SELECT COUNT(*) FROM v3 +-- +ok +== +SELECT COUNT(*) FROM v4 +-- +ok +== +SELECT COUNT(*) FROM v3 JOIN v4 USING (i); +-- +ok +== +SELECT COUNT(*) FROM v3 LEFT JOIN v4 USING (i); +-- +ok +== +SELECT COUNT(*) FROM v3 RIGHT JOIN v4 USING (i); +-- +ok +== +SELECT COUNT(*) FROM v3 FULL OUTER JOIN v4 USING (i); +-- +ok +== diff --git a/parser/testdata/corpus/sql/setops/test_nested_except.test b/parser/testdata/corpus/sql/setops/test_nested_except.test new file mode 100644 index 0000000..c6b9dd1 --- /dev/null +++ b/parser/testdata/corpus/sql/setops/test_nested_except.test @@ -0,0 +1,29 @@ +# source: test/sql/setops/test_nested_except.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +create table b(i integer) +-- +ok +== +create table c (i integer) +-- +ok +== +insert into a values(42), (43), (44) +-- +ok +== +insert into b values(43) +-- +ok +== +insert into c values(44) +-- +ok +== +select * from a except select * from b except select * from c +-- +ok +== diff --git a/parser/testdata/corpus/sql/setops/test_pg_union.test b/parser/testdata/corpus/sql/setops/test_pg_union.test new file mode 100644 index 0000000..ca21ef7 --- /dev/null +++ b/parser/testdata/corpus/sql/setops/test_pg_union.test @@ -0,0 +1,301 @@ +# source: test/sql/setops/test_pg_union.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +SELECT 1 AS two UNION SELECT 2 ORDER BY 1; +-- +ok +== +SELECT 1 AS one UNION SELECT 1 ORDER BY 1; +-- +ok +== +SELECT 1 AS two UNION ALL SELECT 2; +-- +ok +== +SELECT 1 AS two UNION ALL SELECT 1; +-- +ok +== +SELECT 1 AS three UNION SELECT 2 UNION SELECT 3 ORDER BY 1; +-- +ok +== +SELECT 1 AS two UNION SELECT 2 UNION SELECT 2 ORDER BY 1; +-- +ok +== +SELECT 1 AS three UNION SELECT 2 UNION ALL SELECT 2 ORDER BY 1; +-- +ok +== +SELECT 1.1 AS two UNION SELECT 2.2 ORDER BY 1; +-- +ok +== +SELECT 1.1 AS two UNION SELECT 2 ORDER BY 1; +-- +ok +== +SELECT 1 AS two UNION SELECT 2.2 ORDER BY 1; +-- +ok +== +SELECT 1 AS one UNION SELECT 1.0::float8 ORDER BY 1; +-- +ok +== +SELECT 1.1 AS two UNION ALL SELECT 2 ORDER BY 1; +-- +ok +== +SELECT 1.0::float8 AS two UNION ALL SELECT 1 ORDER BY 1; +-- +ok +== +SELECT 1.1 AS three UNION SELECT 2 UNION SELECT 3 ORDER BY 1; +-- +ok +== +SELECT 1.1::float8 AS two UNION SELECT 2 UNION SELECT 2.0::float8 ORDER BY 1; +-- +ok +== +SELECT 1.1 AS three UNION SELECT 2 UNION ALL SELECT 2 ORDER BY 1; +-- +ok +== +SELECT 1.1 AS two UNION (SELECT 2 UNION ALL SELECT 2) ORDER BY 1; +-- +ok +== +CREATE TABLE FLOAT8_TBL(f1 float8); +-- +ok +== +INSERT INTO FLOAT8_TBL(f1) VALUES + ('0.0'), + ('-34.84'), + ('-1004.30'), + ('-1.2345678901234e+200'), + ('-1.2345678901234e-200'); +-- +ok +== +CREATE TABLE INT4_TBL(f1 int4); +-- +ok +== +INSERT INTO INT4_TBL(f1) VALUES + (' 0 '), + ('123456 '), + (' -123456'), + ('2147483647'), -- largest and smallest values + ('-2147483647'); +-- +ok +== +CREATE TABLE INT8_TBL(q1 int8, q2 int8); +-- +ok +== +INSERT INTO INT8_TBL VALUES + (' 123 ',' 456'), + ('123 ','4567890123456789'), + ('4567890123456789','123'), + (+4567890123456789,'4567890123456789'), + ('+4567890123456789','-4567890123456789'); +-- +ok +== +CREATE TABLE CHAR_TBL(f1 char(4)); +-- +ok +== +INSERT INTO CHAR_TBL (f1) VALUES + ('a'), + ('ab'), + ('abcd'), + ('abcd '); +-- +ok +== +CREATE TABLE VARCHAR_TBL(f1 varchar(4)); +-- +ok +== +INSERT INTO VARCHAR_TBL (f1) VALUES + ('a'), + ('ab'), + ('abcd'), + ('abcd '); +-- +ok +== +SELECT f1 AS five FROM FLOAT8_TBL +UNION +SELECT f1 FROM FLOAT8_TBL +ORDER BY 1; +-- +ok +== +SELECT f1 AS ten FROM FLOAT8_TBL +UNION ALL +SELECT f1 FROM FLOAT8_TBL; +-- +ok +== +SELECT f1 AS nine FROM FLOAT8_TBL +UNION +SELECT f1 FROM INT4_TBL +ORDER BY 1; +-- +ok +== +SELECT f1 AS ten FROM FLOAT8_TBL +UNION ALL +SELECT f1 FROM INT4_TBL; +-- +ok +== +SELECT f1 AS five FROM FLOAT8_TBL + WHERE f1 BETWEEN -1e6 AND 1e6 +UNION +SELECT f1 FROM INT4_TBL + WHERE f1 BETWEEN 0 AND 1000000 +ORDER BY 1; +-- +ok +== +SELECT CAST(f1 AS char(4)) AS three FROM VARCHAR_TBL +UNION +SELECT f1 FROM CHAR_TBL +ORDER BY 1; +-- +ok +== +SELECT f1 AS three FROM VARCHAR_TBL +UNION +SELECT CAST(f1 AS varchar) FROM CHAR_TBL +ORDER BY 1; +-- +ok +== +SELECT f1 AS eight FROM VARCHAR_TBL +UNION ALL +SELECT f1 FROM CHAR_TBL; +-- +ok +== +SELECT f1 AS five FROM TEXT_TBL +UNION +SELECT f1 FROM VARCHAR_TBL +UNION +SELECT TRIM(TRAILING FROM f1) FROM CHAR_TBL +ORDER BY 1; +-- +ok +== +SELECT q2 FROM int8_tbl INTERSECT SELECT q1 FROM int8_tbl ORDER BY 1; +-- +ok +== +SELECT q2 FROM int8_tbl INTERSECT ALL SELECT q1 FROM int8_tbl ORDER BY 1; +-- +ok +== +SELECT q2 FROM int8_tbl EXCEPT SELECT q1 FROM int8_tbl ORDER BY 1; +-- +ok +== +SELECT q2 FROM int8_tbl EXCEPT ALL SELECT q1 FROM int8_tbl ORDER BY 1; +-- +ok +== +SELECT q2 FROM int8_tbl EXCEPT ALL SELECT DISTINCT q1 FROM int8_tbl ORDER BY 1; +-- +ok +== +SELECT q1 FROM int8_tbl EXCEPT SELECT q2 FROM int8_tbl ORDER BY 1; +-- +ok +== +SELECT q1 FROM int8_tbl EXCEPT ALL SELECT q2 FROM int8_tbl ORDER BY 1; +-- +ok +== +SELECT q1 FROM int8_tbl EXCEPT ALL SELECT DISTINCT q2 FROM int8_tbl ORDER BY 1; +-- +ok +== +SELECT q1 FROM int8_tbl EXCEPT ALL SELECT q1 FROM int8_tbl FOR NO KEY UPDATE; +-- +error: Parser Error: syntax error at or near "FOR" +== +(SELECT 1,2,3 UNION SELECT 4,5,6) INTERSECT SELECT 4,5,6; +-- +ok +== +(SELECT 1,2,3 UNION SELECT 4,5,6 ORDER BY 1,2) INTERSECT SELECT 4,5,6; +-- +ok +== +(SELECT 1,2,3 UNION SELECT 4,5,6) EXCEPT SELECT 4,5,6; +-- +ok +== +(SELECT 1,2,3 UNION SELECT 4,5,6 ORDER BY 1,2) EXCEPT SELECT 4,5,6; +-- +ok +== +SELECT f1 FROM float8_tbl INTERSECT SELECT f1 FROM int4_tbl ORDER BY 1; +-- +ok +== +SELECT f1 FROM float8_tbl EXCEPT SELECT f1 FROM int4_tbl ORDER BY 1; +-- +ok +== +SELECT q1 FROM int8_tbl INTERSECT SELECT q2 FROM int8_tbl UNION ALL SELECT q2 FROM int8_tbl ORDER BY 1; +-- +ok +== +SELECT q1 FROM int8_tbl INTERSECT (((SELECT q2 FROM int8_tbl UNION ALL SELECT q2 FROM int8_tbl))) ORDER BY 1; +-- +ok +== +(((SELECT q1 FROM int8_tbl INTERSECT SELECT q2 FROM int8_tbl ORDER BY 1))) UNION ALL SELECT q2 FROM int8_tbl; +-- +ok +== +SELECT q1 FROM int8_tbl UNION ALL SELECT q2 FROM int8_tbl EXCEPT SELECT q1 FROM int8_tbl ORDER BY 1; +-- +ok +== +SELECT q1 FROM int8_tbl UNION ALL (((SELECT q2 FROM int8_tbl EXCEPT SELECT q1 FROM int8_tbl ORDER BY 1))); +-- +ok +== +(((SELECT q1 FROM int8_tbl UNION ALL SELECT q2 FROM int8_tbl))) EXCEPT SELECT q1 FROM int8_tbl ORDER BY 1; +-- +ok +== +SELECT q1,q2 FROM int8_tbl EXCEPT SELECT q2,q1 FROM int8_tbl +ORDER BY q2,q1; +-- +ok +== +SELECT q1 FROM int8_tbl EXCEPT SELECT q2 FROM int8_tbl ORDER BY q2 LIMIT 1; +-- +ok +== +SELECT q1 FROM int8_tbl EXCEPT (((SELECT q2 FROM int8_tbl ORDER BY q2 LIMIT 1))) ORDER BY 1; +-- +ok +== +(((((select * from int8_tbl))))); +-- +ok +== diff --git a/parser/testdata/corpus/sql/setops/test_setops.test b/parser/testdata/corpus/sql/setops/test_setops.test new file mode 100644 index 0000000..e4f5134 --- /dev/null +++ b/parser/testdata/corpus/sql/setops/test_setops.test @@ -0,0 +1,79 @@ +# source: test/sql/setops/test_setops.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +SELECT 1 UNION ALL SELECT 2 +-- +ok +== +SELECT 1, 'a' UNION ALL SELECT 2, 'b' +-- +ok +== +SELECT 1, 'a' UNION ALL SELECT 2, 'b' UNION ALL SELECT 3, 'c' order by 1 +-- +ok +== +SELECT 1, 'a' UNION ALL SELECT 2, 'b' UNION ALL SELECT 3, 'c' UNION ALL SELECT 4, 'd' order by 1 +-- +ok +== +SELECT NULL UNION SELECT NULL +-- +ok +== +SELECT NULL EXCEPT SELECT NULL +-- +ok +== +SELECT NULL INTERSECT SELECT NULL +-- +ok +== +INSERT INTO test VALUES (11, 1), (12, 1), (13, 2) +-- +ok +== +SELECT a FROM test WHERE a < 13 UNION ALL SELECT a FROM test WHERE a = 13 +-- +ok +== +SELECT b FROM test WHERE a < 13 UNION ALL SELECT b FROM test WHERE a > 11 +-- +ok +== +SELECT 1 UNION ALL SELECT 'asdf' +-- +ok +== +SELECT NULL UNION ALL SELECT 'asdf' +-- +ok +== +SELECT 1 UNION SELECT 1 +-- +ok +== +SELECT 1, 'a' UNION SELECT 2, 'b' UNION SELECT 3, 'c' UNION SELECT 1, 'a' order by 1 +-- +ok +== +SELECT b FROM test WHERE a < 13 UNION SELECT b FROM test WHERE a > 11 ORDER BY 1 +-- +ok +== +SELECT 1, 'a' UNION ALL SELECT 1, 'a' UNION SELECT 2, 'b' UNION SELECT 1, 'a' ORDER BY 1 +-- +ok +== +SELECT 1, 'a' UNION ALL SELECT 1, 'a' UNION SELECT 2, 'b' UNION SELECT 1, 'a' ORDER BY 1 DESC +-- +ok +== +select x, count(*) as c +from ((select * from (values(1),(2),(2),(3),(3),(3),(4),(4),(4),(4)) s(x) except all select * from (values(1),(3),(3)) t(x)) intersect all select * from (values(2),(2),(2),(4),(3),(3)) u(x)) s +group by x order by x +-- +ok +== diff --git a/parser/testdata/corpus/sql/setops/test_union_all_by_name.test b/parser/testdata/corpus/sql/setops/test_union_all_by_name.test new file mode 100644 index 0000000..49c4242 --- /dev/null +++ b/parser/testdata/corpus/sql/setops/test_union_all_by_name.test @@ -0,0 +1,129 @@ +# source: test/sql/setops/test_union_all_by_name.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +CREATE TABLE t1 (x INT, y INT); +-- +ok +== +INSERT INTO t1 VALUES (3, 3), (1, 1); +-- +ok +== +CREATE TABLE t2 (y INT, z INT); +-- +ok +== +INSERT INTO t2 VALUES (2, 2), (4, 4); +-- +ok +== +SELECT x, y FROM t1 UNION ALL BY NAME SELECT y, z FROM t2; +-- +ok +== +SELECT t1.x FROM t1 UNION ALL BY NAME SELECT x FROM t1 ORDER BY t1.x; +-- +ok +== +SELECT x FROM t1 UNION ALL BY NAME SELECT x FROM t1 ORDER BY t1.x; +-- +ok +== +(SELECT x FROM t1 UNION ALL SELECT x FROM t1) UNION ALL BY NAME SELECT 5 ORDER BY t1.x; +-- +ok +== +(SELECT x FROM t1 UNION ALL SELECT y FROM t1) UNION ALL BY NAME SELECT 5 ORDER BY y; +-- +ok +== +SELECT x AS a FROM t1 UNION ALL BY NAME SELECT x AS b FROM t1 ORDER BY t1.x; +-- +ok +== +(SELECT x FROM t1 UNION ALL SELECT y FROM t1) UNION ALL BY NAME (SELECT z FROM t2 UNION ALL SELECT y FROM t2) ORDER BY y, z; +-- +ok +== +(SELECT x FROM t1 UNION ALL SELECT y FROM t1) UNION ALL BY NAME (SELECT z FROM t2 UNION ALL SELECT y FROM t2) ORDER BY t1.y; +-- +ok +== +SELECT 1 UNION ALL BY NAME SELECT * FROM range(2, 100) UNION ALL BY NAME SELECT 999 LIMIT 5; +-- +ok +== +SELECT x, y FROM t1 UNION ALL BY NAME SELECT y, z FROM t2 ORDER BY z DESC; +-- +ok +== +SELECT x, y FROM t1 UNION ALL BY NAME SELECT y, z FROM t2 ORDER BY y; +-- +ok +== +SELECT x, y FROM t1 UNION ALL BY NAME SELECT y, z FROM t2 ORDER BY 3; +-- +ok +== +SELECT x, y FROM t1 UNION ALL BY NAME SELECT y, z FROM t2 ORDER BY 4; +-- +ok +== +(SELECT x FROM t1 ORDER BY y) UNION ALL BY NAME (SELECT y FROM t2 ORDER BY z) ORDER BY x DESC; +-- +ok +== +SELECT 1 UNION ALL BY NAME SELECT x, y FROM t1 UNION ALL BY NAME SELECT y, z FROM t2; +-- +ok +== +SELECT 1, 2 FROM t1 UNION SELECT x, y FROM t1 UNION ALL BY NAME SELECT y, z FROM t2; +-- +ok +== +SELECT 1, 2 FROM t1 UNION (SELECT x, y FROM t1 UNION ALL BY NAME SELECT y, z FROM t2); +-- +ok +== +SELECT x, y FROM t1 UNION ALL BY NAME SELECT y, z FROM t2 INTERSECT SELECT 2, 2 FROM t1; +-- +ok +== +SELECT x, y FROM t1 UNION ALL BY NAME SELECT y, z FROM t2 EXCEPT SELECT 2, 2 FROM t1; +-- +ok +== +(SELECT x, y FROM t1 UNION ALL BY NAME SELECT y, z FROM t2) EXCEPT SELECT NULL, 2, 2 FROM t1; +-- +ok +== +SELECT x, x FROM t1 UNION ALL BY NAME SELECT y FROM t2; +-- +ok +== +SELECT x, x as a FROM t1 UNION ALL BY NAME SELECT y FROM t2; +-- +ok +== +SELECT x as a FROM t1 UNION ALL BY NAME SELECT x FROM t1; +-- +ok +== +SELECT DISTINCT ON(x) x FROM (SELECT 1 as x UNION ALL BY NAME SELECT '1' as x); +-- +ok +== +SELECT DISTINCT ON(x) x FROM (SELECT 1 as x UNION ALL BY NAME SELECT 1.1 as x); +-- +ok +== +CREATE TABLE new_table AS (SELECT x, y FROM t1 UNION ALL BY NAME SELECT y, z FROM t2); +-- +ok +== +SELECT * FROM new_table; +-- +ok +== diff --git a/parser/testdata/corpus/sql/setops/test_union_binding.test b/parser/testdata/corpus/sql/setops/test_union_binding.test new file mode 100644 index 0000000..7ef8692 --- /dev/null +++ b/parser/testdata/corpus/sql/setops/test_union_binding.test @@ -0,0 +1,125 @@ +# source: test/sql/setops/test_union_binding.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +CREATE TABLE test2(b INTEGER); +-- +ok +== +INSERT INTO test VALUES (1), (2), (3), (NULL); +-- +ok +== +INSERT INTO test2 VALUES (2), (3), (4), (NULL); +-- +ok +== +(SELECT a FROM test ORDER BY a+1) UNION SELECT b FROM test2 ORDER BY 1; +-- +ok +== +SELECT * FROM (SELECT * FROM test UNION SELECT * FROM test2) res ORDER BY 1; +-- +ok +== +SELECT a FROM (SELECT * FROM test UNION SELECT * FROM test2) res ORDER BY 1; +-- +ok +== +SELECT b FROM (SELECT * FROM test UNION SELECT * FROM test2) res ORDER BY 1; +-- +ok +== +SELECT b FROM (SELECT * FROM test2 UNION SELECT * FROM test) res ORDER BY 1; +-- +ok +== +SELECT col1 FROM (SELECT * FROM test2 UNION SELECT * FROM test) res(col1) ORDER BY 1; +-- +ok +== +SELECT a FROM test UNION SELECT b FROM test2 ORDER BY a; +-- +ok +== +SELECT a FROM test UNION SELECT b FROM test2 ORDER BY b; +-- +ok +== +SELECT 1, a FROM test UNION SELECT b AS a, 1 FROM test2 ORDER BY a, 1; +-- +ok +== +SELECT 1, a+1 FROM test UNION SELECT a+1, 1 FROM test ORDER BY a+1; +-- +ok +== +SELECT a FROM test UNION SELECT b FROM test2 UNION SELECT b AS c FROM test2 ORDER BY c; +-- +ok +== +SELECT a FROM test UNION SELECT b FROM test2 UNION SELECT b + 1 FROM test2 ORDER BY b + 1; +-- +ok +== +SELECT a, 10 - a AS b FROM test UNION SELECT b, b + 1 FROM test2 ORDER BY 2; +-- +ok +== +SELECT a, 10 - a AS b FROM test UNION SELECT b, b + 1 FROM test2 ORDER BY b; +-- +ok +== +SELECT a FROM test UNION SELECT b FROM test2 ORDER BY 1; +-- +ok +== +SELECT a FROM test UNION SELECT b FROM test2 ORDER BY 2; +-- +ok +== +SELECT * FROM test UNION SELECT * FROM test2 ORDER BY a; +-- +ok +== +SELECT * FROM test UNION SELECT * FROM test2 ORDER BY b; +-- +ok +== +SELECT a FROM test UNION SELECT * FROM test2 ORDER BY test.a; +-- +ok +== +SELECT a FROM test UNION SELECT b FROM test2 ORDER BY test2.b; +-- +ok +== +SELECT test.a FROM test UNION SELECT * FROM test2 ORDER BY a; +-- +ok +== +SELECT test.a FROM test UNION SELECT test2.b FROM test2 ORDER BY b; +-- +ok +== +SELECT a FROM test UNION SELECT * FROM test2 UNION SELECT * FROM test t1 ORDER BY test.a, test2.b, t1.a; +-- +ok +== +SELECT a FROM test UNION SELECT * FROM test2 UNION SELECT * FROM test t1 ORDER BY a; +-- +ok +== +SELECT a FROM (SELECT * FROM test) bla UNION SELECT * FROM test2 ORDER BY bla.a; +-- +ok +== +SELECT t1.a, t2.a FROM test t1, test t2 WHERE t1.a=t2.a UNION SELECT b, b - 1 FROM test2 ORDER BY t1.a, t2.a, test2.b; +-- +ok +== +SELECT NULL as a, NULL as b, 1 as id UNION SELECT CAST('2015-10-11 00:00:00' AS TIMESTAMP) as a, CAST('2015-10-11 12:34:56' AS TIMESTAMP) as b, 2 as id ORDER BY 3 +-- +ok +== diff --git a/parser/testdata/corpus/sql/setops/test_union_by_name.test b/parser/testdata/corpus/sql/setops/test_union_by_name.test new file mode 100644 index 0000000..6471f23 --- /dev/null +++ b/parser/testdata/corpus/sql/setops/test_union_by_name.test @@ -0,0 +1,93 @@ +# source: test/sql/setops/test_union_by_name.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +INSERT INTO t1 VALUES (3, 3), (3, 3), (1, 1); +-- +ok +== +SELECT t1.x FROM t1 UNION BY NAME SELECT x FROM t1 ORDER BY t1.x; +-- +ok +== +SELECT x FROM t1 UNION BY NAME SELECT x FROM t1 ORDER BY t1.x; +-- +ok +== +(SELECT x FROM t1 UNION ALL SELECT x FROM t1) UNION BY NAME SELECT 5 ORDER BY t1.x; +-- +ok +== +(SELECT x FROM t1 UNION ALL SELECT y FROM t1) UNION BY NAME SELECT 5 ORDER BY y; +-- +ok +== +SELECT x AS a FROM t1 UNION BY NAME SELECT x AS b FROM t1 ORDER BY t1.x; +-- +ok +== +(SELECT x FROM t1 UNION ALL SELECT y FROM t1) UNION BY NAME (SELECT z FROM t2 UNION ALL SELECT y FROM t2) ORDER BY y, z; +-- +ok +== +SELECT 1 UNION BY NAME SELECT * FROM range(2, 100) UNION BY NAME SELECT 999 ORDER BY #2, #1 LIMIT 5; +-- +ok +== +SELECT x, y FROM t1 UNION BY NAME SELECT y, z FROM t2 ORDER BY y; +-- +ok +== +SELECT x, y FROM t1 UNION BY NAME SELECT y, z FROM t2 ORDER BY 3, 1; +-- +ok +== +SELECT x, y FROM t1 UNION BY NAME SELECT y, z FROM t2 ORDER BY 4; +-- +ok +== +(SELECT 1 UNION BY NAME SELECT x, y FROM t1) UNION BY NAME SELECT y, z FROM t2 ORDER BY ALL; +-- +ok +== +SELECT x, y FROM t1 UNION BY NAME (SELECT y, z FROM t2 INTERSECT SELECT 2, 2 FROM t1 ORDER BY #1) ORDER BY #1; +-- +ok +== +(SELECT x, y FROM t1 UNION BY NAME SELECT y, z FROM t2 ORDER BY #1) EXCEPT SELECT NULL, 2, 2 FROM t1 ORDER BY #1; +-- +ok +== +SELECT x, x as a FROM t1 UNION BY NAME SELECT y FROM t2 ORDER BY #1, #3; +-- +ok +== +SELECT x as a FROM t1 UNION BY NAME SELECT x FROM t1 ORDER BY #1, #2; +-- +ok +== +select '0' as c union all select 0 as c; +-- +ok +== +select '0' as c union all by name select 0 as c; +-- +ok +== +select {'a': '0'} as c union all by name select {'a': 0} as c +-- +ok +== +SELECT {'a': 'hello'} AS c UNION ALL BY NAME SELECT {'b': 'hello'} AS c; +-- +ok +== +SELECT {'a': 'hello'} AS c UNION ALL BY NAME SELECT {'a': 'hello', 'b': 'world'} AS c; +-- +ok +== +SELECT [{'a': 42}, {'b': 84}]; +-- +ok +== diff --git a/parser/testdata/corpus/sql/setops/test_union_error.test b/parser/testdata/corpus/sql/setops/test_union_error.test new file mode 100644 index 0000000..71377cf --- /dev/null +++ b/parser/testdata/corpus/sql/setops/test_union_error.test @@ -0,0 +1,9 @@ +# source: test/sql/setops/test_union_error.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +SELECT x::INT FROM (SELECT x::VARCHAR x FROM range(10) tbl(x) UNION ALL SELECT 'hello' x) tbl(x); +-- +ok +== diff --git a/parser/testdata/corpus/sql/setops/test_union_except_empty.test b/parser/testdata/corpus/sql/setops/test_union_except_empty.test new file mode 100644 index 0000000..60c7670 --- /dev/null +++ b/parser/testdata/corpus/sql/setops/test_union_except_empty.test @@ -0,0 +1,21 @@ +# source: test/sql/setops/test_union_except_empty.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +create table t (i int); +-- +ok +== +insert into t values (1),(2),(3),(4),(4); +-- +ok +== +select i from t union select 1 where false order by 1; +-- +ok +== +select i from t except select 1 where false order by 1; +-- +ok +== diff --git a/parser/testdata/corpus/sql/setops/test_union_order.test b/parser/testdata/corpus/sql/setops/test_union_order.test new file mode 100644 index 0000000..fb4752e --- /dev/null +++ b/parser/testdata/corpus/sql/setops/test_union_order.test @@ -0,0 +1,13 @@ +# source: test/sql/setops/test_union_order.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +SELECT 1 UNION ALL SELECT 2 UNION ALL SELECT NULL UNION ALL SELECT 3 +-- +ok +== +SELECT MIN(1) FROM range(10) UNION ALL SELECT MIN(2) FROM range(10) UNION ALL SELECT MIN(NULL) FROM range(10) UNION ALL SELECT MIN(3) FROM range(10) +-- +ok +== diff --git a/parser/testdata/corpus/sql/setops/test_union_subquery.test b/parser/testdata/corpus/sql/setops/test_union_subquery.test new file mode 100644 index 0000000..84154df --- /dev/null +++ b/parser/testdata/corpus/sql/setops/test_union_subquery.test @@ -0,0 +1,13 @@ +# source: test/sql/setops/test_union_subquery.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +INSERT INTO t VALUES (42) +-- +ok +== +select i, j from (select i, 1 as j from t group by i union all select i, 2 as j from t group by i) sq1 +-- +ok +== diff --git a/parser/testdata/corpus/sql/setops/test_union_type_cast.test b/parser/testdata/corpus/sql/setops/test_union_type_cast.test new file mode 100644 index 0000000..d16fe20 --- /dev/null +++ b/parser/testdata/corpus/sql/setops/test_union_type_cast.test @@ -0,0 +1,29 @@ +# source: test/sql/setops/test_union_type_cast.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +SELECT 1 UNION SELECT 1.0 +-- +ok +== +SELECT 1 UNION ALL SELECT 1.0 +-- +ok +== +SELECT 1 UNION (SELECT 1 UNION SELECT 1 UNION SELECT 1) +-- +ok +== +SELECT 1 UNION (SELECT 1.0 UNION SELECT 1.0 UNION SELECT 1.0) UNION SELECT 1; +-- +ok +== +SELECT 1 UNION ALL (SELECT 1.0 UNION ALL SELECT 1.0 UNION ALL SELECT 1.0) UNION ALL SELECT 1; +-- +ok +== +SELECT 1 UNION (SELECT '1' UNION SELECT '1' UNION SELECT '1') UNION SELECT 1; +-- +ok +== diff --git a/parser/testdata/corpus/sql/setops/union_aggregate.test b/parser/testdata/corpus/sql/setops/union_aggregate.test new file mode 100644 index 0000000..fe0107d --- /dev/null +++ b/parser/testdata/corpus/sql/setops/union_aggregate.test @@ -0,0 +1,60 @@ +# source: test/sql/setops/union_aggregate.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +SELECT COUNT(*) FROM range(1) +UNION ALL SELECT COUNT(*) FROM range(1) +-- +ok +== +SELECT COUNT(*) FROM range(1) +UNION ALL SELECT COUNT(*) FROM range(1) +UNION ALL SELECT COUNT(*) FROM range(1) +UNION ALL SELECT COUNT(*) FROM range(1) +UNION ALL SELECT COUNT(*) FROM range(1) +-- +ok +== +SELECT COUNT(*) FROM range(1) UNION SELECT COUNT(*) FROM range(1) +-- +ok +== +SELECT COUNT(*) FROM range(1) +UNION SELECT COUNT(*) FROM range(2) +ORDER BY 1 +-- +ok +== +SELECT COUNT(*) FROM range(1) +UNION SELECT COUNT(*) FROM range(2) +UNION SELECT COUNT(*) FROM range(3) +UNION SELECT COUNT(*) FROM range(4) +UNION SELECT COUNT(*) FROM range(5) +ORDER BY 1 +-- +ok +== +SELECT * FROM ( + SELECT 1 + UNION ALL + SELECT 1 +) tbl(i) +-- +ok +== +SELECT * FROM ( + SELECT 1 + UNION + SELECT 2 + UNION + SELECT 3 + UNION + SELECT 4 + UNION + SELECT 5 +) tbl(i) +ORDER BY 1 +-- +ok +== diff --git a/parser/testdata/corpus/sql/setops/union_all_projection_pushdown.test b/parser/testdata/corpus/sql/setops/union_all_projection_pushdown.test new file mode 100644 index 0000000..ab873ad --- /dev/null +++ b/parser/testdata/corpus/sql/setops/union_all_projection_pushdown.test @@ -0,0 +1,65 @@ +# source: test/sql/setops/union_all_projection_pushdown.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +CREATE TABLE a AS SELECT i, i+1 AS j, i+2 AS k, i+3 AS l FROM range(42,43) t(i) +-- +ok +== +CREATE TABLE b AS SELECT i, i+1 AS j, i+2 AS k, i+3 AS l FROM range(40,41) t(i) +-- +ok +== +select COUNT(*) from (SELECT * FROM a UNION ALL SELECT * FROM b) t1 join (select 43) t2(l) on t1.l=t2.l +-- +ok +== +select COUNT(*) from (SELECT * FROM a UNION ALL SELECT * FROM b) t1 +-- +ok +== +select COUNT(*) from (SELECT i, j, MIN(k), MIN(l) FROM a GROUP BY i, j UNION ALL SELECT * FROM b) t1 +-- +ok +== +select COUNT(*) from (SELECT DISTINCT i, j, k, l FROM a UNION ALL SELECT * FROM b) t1 +-- +ok +== +select COUNT(*) from (SELECT DISTINCT * FROM (SELECT DISTINCT i, j, k, l FROM a UNION ALL SELECT * FROM b) t1) t2 +-- +ok +== +select COUNT(*) from (SELECT * FROM a UNION ALL SELECT * FROM b UNION ALL SELECT a.i,a.j,a.k,a.l FROM a,b) t1 +-- +ok +== +select COUNT(*) from (SELECT * FROM a UNION SELECT * FROM b UNION SELECT a.i,a.j,a.k,a.l FROM a,b) t1 +-- +ok +== +select COUNT(*) from (SELECT * FROM a WHERE 1=0 UNION ALL SELECT * FROM b) t1 +-- +ok +== +select j from (SELECT * FROM a WHERE i=42 UNION ALL SELECT * FROM b) t1 WHERE i=40 +-- +ok +== +select j from (SELECT i, COUNT(*) j, COUNT(*) k, COUNT(*) l FROM a WHERE i=42 GROUP BY i UNION ALL SELECT * FROM b) t1 WHERE i=40 +-- +ok +== +select j from (SELECT i i, i j, k, l FROM a UNION ALL SELECT * FROM b) t1 WHERE i=40 AND j=41 +-- +ok +== +select * from (select 'hello' i union all select 'h' i) t1 where i='h' +-- +ok +== +select MIN(t2.b) from (SELECT * FROM a UNION ALL SELECT * FROM b) t1 join (select 43, 'hello', 44, 'world') t2(l, a, b, c) on t1.l=t2.l +-- +ok +== diff --git a/parser/testdata/corpus/sql/setops/union_limit.test b/parser/testdata/corpus/sql/setops/union_limit.test new file mode 100644 index 0000000..91653cf --- /dev/null +++ b/parser/testdata/corpus/sql/setops/union_limit.test @@ -0,0 +1,115 @@ +# source: test/sql/setops/union_limit.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +SELECT 1 UNION ALL SELECT * FROM range(2, 100) UNION ALL SELECT 999 LIMIT 5; +-- +ok +== +SELECT 'select count(case'a union all select 'when a='||range||' then 1' from range(100) LIMIT 5; +-- +ok +== +SELECT STRING_AGG(a, ' ') FROM (SELECT 'select count(case'a union all select 'when a='||range||' then 1' from range(2) union all select 'end) from t') tbl; +-- +ok +== +SELECT 'select count(case'a union all select 'when a='||range||' then 1' from range(2) union all select 'end) from t' LIMIT 5; +-- +ok +== +SELECT 'select count(case'a union all select 'when a='||range||' then 1' from range(100) union all select 'end) from t' LIMIT 5; +-- +ok +== +SELECT 1 +UNION ALL +( + SELECT * FROM generate_series(10, 12, 1) + UNION ALL + ( + SELECT * FROM generate_series(100, 103, 1) + ) + UNION ALL + SELECT * FROM generate_series(1000, 1002, 1) +) +UNION ALL +SELECT * FROM generate_series(10000, 10002, 1) +UNION ALL +( + SELECT * FROM generate_series(100000, 100002, 1) + UNION ALL + SELECT * FROM generate_series(1000000, 1000003, 1) +); +-- +ok +== +SELECT ARRAY_AGG(1) +UNION ALL +( + SELECT ARRAY_AGG(i) FROM generate_series(10, 12, 1) tbl(i) + UNION ALL + ( + SELECT ARRAY_AGG(i) FROM generate_series(100, 103, 1) tbl(i) + ) + UNION ALL + SELECT ARRAY_AGG(i) FROM generate_series(1000, 1002, 1) tbl(i) +) +UNION ALL +SELECT ARRAY_AGG(i) FROM generate_series(10000, 10002, 1) tbl(i) +UNION ALL +( + SELECT ARRAY_AGG(i) FROM generate_series(100000, 100002, 1) tbl(i) + UNION ALL + SELECT ARRAY_AGG(i) FROM generate_series(1000000, 1000003, 1) tbl(i) +); +-- +ok +== +SELECT 1 +UNION ALL +( + SELECT * FROM generate_series(10, 12, 1) + UNION ALL + ( + SELECT * FROM generate_series(100, 103, 1) + ) + UNION ALL + SELECT * FROM generate_series(1000, 1002, 1) +) +UNION ALL +SELECT * FROM generate_series(10000, 10002, 1) +UNION ALL +( + SELECT * FROM generate_series(100000, 100002, 1) + UNION ALL + SELECT * FROM generate_series(1000000, 1000003, 1) +) +LIMIT 1000; +-- +ok +== +SELECT ARRAY_AGG(1) +UNION ALL +( + SELECT ARRAY_AGG(i) FROM generate_series(10, 12, 1) tbl(i) + UNION ALL + ( + SELECT ARRAY_AGG(i) FROM generate_series(100, 103, 1) tbl(i) + ) + UNION ALL + SELECT ARRAY_AGG(i) FROM generate_series(1000, 1002, 1) tbl(i) +) +UNION ALL +SELECT ARRAY_AGG(i) FROM generate_series(10000, 10002, 1) tbl(i) +UNION ALL +( + SELECT ARRAY_AGG(i) FROM generate_series(100000, 100002, 1) tbl(i) + UNION ALL + SELECT ARRAY_AGG(i) FROM generate_series(1000000, 1000003, 1) tbl(i) +) +LIMIT 1000; +-- +ok +== diff --git a/parser/testdata/corpus/sql/setops/union_pipeline.test b/parser/testdata/corpus/sql/setops/union_pipeline.test new file mode 100644 index 0000000..27eee65 --- /dev/null +++ b/parser/testdata/corpus/sql/setops/union_pipeline.test @@ -0,0 +1,17 @@ +# source: test/sql/setops/union_pipeline.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +SELECT COUNT(*) FROM (SELECT * FROM range(1000000) tbl(i) UNION ALL SELECT * FROM range(1000000) tbl(i)) tbl(i) +-- +ok +== +CREATE TABLE t1 AS SELECT COUNT(*) FROM (SELECT * FROM range(1000000) tbl(i) UNION ALL SELECT * FROM range(1000000) tbl(i)) tbl(i) +-- +ok +== +SELECT COUNT(*) FROM (SELECT * FROM range(1000000) tbl(i) UNION ALL SELECT * FROM range(1000000) tbl(i) UNION ALL SELECT * FROM range(1000000) tbl(i) UNION ALL SELECT * FROM range(1000000) tbl(i) UNION ALL SELECT * FROM range(1000000) tbl(i)) tbl(i) +-- +ok +== diff --git a/parser/testdata/corpus/sql/setops/union_shared_scan.test b/parser/testdata/corpus/sql/setops/union_shared_scan.test new file mode 100644 index 0000000..42fd96d --- /dev/null +++ b/parser/testdata/corpus/sql/setops/union_shared_scan.test @@ -0,0 +1,20 @@ +# source: test/sql/setops/union_shared_scan.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +CREATE TABLE tbl AS SELECT * FROM range(10000) tbl(i) UNION ALL SELECT NULL +-- +ok +== +SELECT SUM(i) FROM tbl +UNION ALL +SELECT COUNT(i) FROM tbl +UNION ALL +SELECT AVG(i) FROM tbl +UNION ALL +SELECT AVG(i) + SUM(i) FROM tbl +ORDER BY 1 +-- +ok +== diff --git a/parser/testdata/corpus/sql/setops/value_union.test b/parser/testdata/corpus/sql/setops/value_union.test new file mode 100644 index 0000000..3c3e896 --- /dev/null +++ b/parser/testdata/corpus/sql/setops/value_union.test @@ -0,0 +1,48 @@ +# source: test/sql/setops/value_union.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +CREATE VIEW vals AS SELECT * FROM (VALUES (1, 10), (2, 5), (3, 4)) tbl(i, j); +-- +ok +== +SELECT * FROM vals +-- +ok +== +CREATE VIEW vunion AS +SELECT * FROM vals +UNION ALL +SELECT * FROM vals; +-- +ok +== +SELECT * FROM vunion ORDER BY i +-- +ok +== +SELECT * FROM vunion ORDER BY i LIMIT 1 +-- +ok +== +SELECT * FROM (SELECT * FROM vunion ORDER BY i LIMIT 4) tbl ORDER BY j LIMIT 2 +-- +ok +== +SELECT * FROM vunion WHERE i=1 +-- +ok +== +SELECT DISTINCT * FROM (SELECT * FROM vunion UNION ALL SELECT * FROM vunion) tbl ORDER BY 1 +-- +ok +== +SELECT * FROM (SELECT * FROM vunion INTERSECT SELECT * FROM vunion) tbl ORDER BY 1; +-- +ok +== +SELECT * FROM (SELECT * FROM vunion EXCEPT SELECT * FROM vunion) tbl +-- +ok +== diff --git a/parser/testdata/corpus/sql/settings/access_mode.test b/parser/testdata/corpus/sql/settings/access_mode.test new file mode 100644 index 0000000..39bd5df --- /dev/null +++ b/parser/testdata/corpus/sql/settings/access_mode.test @@ -0,0 +1,9 @@ +# source: test/sql/settings/access_mode.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +SET access_mode='read_only' +-- +ok +== diff --git a/parser/testdata/corpus/sql/settings/allowed_configs.test b/parser/testdata/corpus/sql/settings/allowed_configs.test new file mode 100644 index 0000000..12b182f --- /dev/null +++ b/parser/testdata/corpus/sql/settings/allowed_configs.test @@ -0,0 +1,69 @@ +# source: test/sql/settings/allowed_configs.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +SET allowed_configs=['lock_configuration'] +-- +ok +== +SET allowed_configs=['allowed_configs'] +-- +ok +== +SET allowed_configs=[''] +-- +ok +== +SET allowed_configs=['not_a_real_setting'] +-- +ok +== +SET allowed_configs=['TimeZone'] +-- +ok +== +SET allowed_configs=['pivot_limit', 'EXPLAIN_output', 'memory_limit'] +-- +ok +== +SET lock_configuration=true +-- +ok +== +SET pivot_limit=20000 +-- +ok +== +SET explain_output='OPTIMIZED_ONLY' +-- +ok +== +SET memory_limit='2GB' +-- +ok +== +SET max_memory='2GB' +-- +ok +== +SET enable_external_access=true +-- +ok +== +SET allowed_configs=['threads'] +-- +ok +== +SET search_path='' +-- +ok +== +RESET allowed_configs +-- +ok +== +SET lock_configuration=false +-- +ok +== diff --git a/parser/testdata/corpus/sql/settings/allowed_configs_extensions.test b/parser/testdata/corpus/sql/settings/allowed_configs_extensions.test new file mode 100644 index 0000000..ec889d2 --- /dev/null +++ b/parser/testdata/corpus/sql/settings/allowed_configs_extensions.test @@ -0,0 +1,13 @@ +# source: test/sql/settings/allowed_configs_extensions.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +SET TimeZone='America/New_York' +-- +ok +== +SET Calendar='japanese' +-- +ok +== diff --git a/parser/testdata/corpus/sql/settings/allowed_directories.test b/parser/testdata/corpus/sql/settings/allowed_directories.test new file mode 100644 index 0000000..4e1ab82 --- /dev/null +++ b/parser/testdata/corpus/sql/settings/allowed_directories.test @@ -0,0 +1,133 @@ +# source: test/sql/settings/allowed_directories.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +SET allowed_directories=['{DATA_DIR}/csv/glob'] +-- +ok +== +RESET allowed_directories +-- +ok +== +SET allowed_directories=['{DATA_DIR}/csv/glob', '{DATA_DIR}/csv/glob/1', '{DATA_DIR}/parquet-testing/glob', '{DATA_DIR}/json', '{TEMP_DIR}'] +-- +ok +== +SET allowed_directories=[] +-- +ok +== +SELECT * FROM '{DATA_DIR}/csv/glob/f_1.csv' +-- +ok +== +SELECT * FROM '{DATA_DIR}/csv/glob/a1/a1.csv' +-- +ok +== +SELECT * FROM '{DATA_DIR}/csv/glob/a1/../f_1.csv' +-- +ok +== +SELECT * FROM '{DATA_DIR}/csv/glob/./f_1.csv' +-- +ok +== +SELECT * FROM '{DATA_DIR}/csv/glob/../../csv/glob/f_1.csv' +-- +ok +== +SELECT * FROM '{DATA_DIR}/csv/glob/./../bool.csv' +-- +ok +== +SELECT * FROM '{DATA_DIR}/csv/all_quotes.csv' +-- +ok +== +SELECT * FROM '{DATA_DIR}/csv/glob/../all_quotes.csv' +-- +ok +== +SELECT * FROM '{DATA_DIR}/csv/glob//../all_quotes.csv' +-- +ok +== +SELECT * FROM '{DATA_DIR}/csv/glob/a1/../../all_quotes.csv' +-- +ok +== +SELECT * FROM sniff_csv('{DATA_DIR}/csv/glob/f_1.csv') +-- +ok +== +SELECT * FROM sniff_csv('{DATA_DIR}/csv/all_quotes.csv') +-- +ok +== +SELECT parse_filename(fname) as fname FROM glob('{DATA_DIR}/csv/glob/*.csv') t(fname) +-- +ok +== +SELECT * FROM glob('{DATA_DIR}/csv/**.csv') +-- +ok +== +COPY (SELECT 42 i) TO '{TEMP_DIR}/permission_test.csv' (FORMAT csv) +-- +ok +== +COPY integers FROM '{TEMP_DIR}/permission_test.csv' +-- +ok +== +COPY (SELECT 42 i) TO 'permission_test.csv' (FORMAT csv) +-- +ok +== +COPY integers FROM 'permission_test.csv' +-- +ok +== +ATTACH '{TEMP_DIR}/attached_dir.db' AS a1 +-- +ok +== +CREATE TABLE a1.integers(i INTEGER); +-- +ok +== +ATTACH 'test.db' +-- +ok +== +LOAD my_ext +-- +ok +== +INSTALL my_ext +-- +ok +== +EXPORT DATABASE a1 TO '{TEMP_DIR}/export_test' +-- +ok +== +EXPORT DATABASE a1 TO 'export_test' +-- +ok +== +IMPORT DATABASE '{TEMP_DIR}/export_test' +-- +ok +== +IMPORT DATABASE 'export_test' +-- +ok +== +SELECT * FROM '{DATA_DIR}/parquet-testing/glob/t1.parquet' +-- +ok +== diff --git a/parser/testdata/corpus/sql/settings/allowed_paths.test b/parser/testdata/corpus/sql/settings/allowed_paths.test new file mode 100644 index 0000000..1bc4707 --- /dev/null +++ b/parser/testdata/corpus/sql/settings/allowed_paths.test @@ -0,0 +1,29 @@ +# source: test/sql/settings/allowed_paths.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +SET allowed_paths=['{DATA_DIR}/csv/glob/f_1.csv'] +-- +ok +== +RESET allowed_paths +-- +ok +== +SET allowed_paths=['{DATA_DIR}/csv/glob/f_1.csv', '{TEMP_DIR}/allowed_file.csv'] +-- +ok +== +SET allowed_paths=[] +-- +ok +== +COPY (SELECT 42 i) TO '{TEMP_DIR}/allowed_file.csv' +-- +ok +== +COPY (SELECT 42 i) TO '{TEMP_DIR}/not_allowed_file.csv' +-- +ok +== diff --git a/parser/testdata/corpus/sql/settings/block_allocator_memory.test b/parser/testdata/corpus/sql/settings/block_allocator_memory.test new file mode 100644 index 0000000..238e929 --- /dev/null +++ b/parser/testdata/corpus/sql/settings/block_allocator_memory.test @@ -0,0 +1,41 @@ +# source: test/sql/settings/block_allocator_memory.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +RESET block_allocator_memory; +-- +ok +== +SET block_allocator_memory='100MiB'; +-- +ok +== +SET block_allocator_memory='-3%'; +-- +ok +== +SET block_allocator_memory='150%'; +-- +ok +== +SET block_allocator_memory='75%'; +-- +ok +== +SELECT value FROM duckdb_settings() WHERE name = 'block_allocator_memory'; +-- +ok +== +SET block_allocator_memory='50MiB'; +-- +ok +== +SET block_allocator_memory='200MiB'; +-- +ok +== +SET block_allocator_memory='200TiB'; +-- +ok +== diff --git a/parser/testdata/corpus/sql/settings/connection_local_settings.test b/parser/testdata/corpus/sql/settings/connection_local_settings.test new file mode 100644 index 0000000..2f7f7c7 --- /dev/null +++ b/parser/testdata/corpus/sql/settings/connection_local_settings.test @@ -0,0 +1,37 @@ +# source: test/sql/settings/connection_local_settings.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +CREATE TABLE tbl AS FROM (VALUES (1), (2), (3), (NULL)) t(i) +-- +ok +== +SET default_order = 'ASCENDING'; +-- +ok +== +SET default_null_order = 'NULLS FIRST'; +-- +ok +== +SET SESSION default_order = 'DESCENDING'; +-- +ok +== +SET SESSION default_null_order = 'NULLS FIRST'; +-- +ok +== +SET SESSION default_order = 'ASCENDING' +-- +ok +== +SET SESSION default_null_order = 'NULLS LAST' +-- +ok +== +SELECT * FROM tbl ORDER BY i +-- +ok +== diff --git a/parser/testdata/corpus/sql/settings/default_null_order_extended.test b/parser/testdata/corpus/sql/settings/default_null_order_extended.test new file mode 100644 index 0000000..e335f57 --- /dev/null +++ b/parser/testdata/corpus/sql/settings/default_null_order_extended.test @@ -0,0 +1,33 @@ +# source: test/sql/settings/default_null_order_extended.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +SELECT * FROM integers ORDER BY i; +-- +ok +== +SELECT * FROM integers ORDER BY i DESC; +-- +ok +== +SELECT FIRST(i ORDER BY i), LAST(i ORDER BY i) FROM integers +-- +ok +== +SELECT FIRST(i ORDER BY i DESC), LAST(i ORDER BY i DESC) FROM integers +-- +ok +== +SELECT list_sort(LIST(i)), list_reverse_sort(LIST(i)) FROM integers +-- +ok +== +SET default_null_order='sqlite'; +-- +ok +== +SET default_null_order='postgres'; +-- +ok +== diff --git a/parser/testdata/corpus/sql/settings/dialect_compatibility_mode.test b/parser/testdata/corpus/sql/settings/dialect_compatibility_mode.test new file mode 100644 index 0000000..67ec5cb --- /dev/null +++ b/parser/testdata/corpus/sql/settings/dialect_compatibility_mode.test @@ -0,0 +1,29 @@ +# source: test/sql/settings/dialect_compatibility_mode.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +SELECT current_setting('dialect_compatibility_mode') +-- +ok +== +SET dialect_compatibility_mode='spark' +-- +ok +== +SET dialect_compatibility_mode='some_random_non_existing_thing' +-- +ok +== +RESET dialect_compatibility_mode +-- +ok +== +SET GLOBAL dialect_compatibility_mode='SPARK' +-- +ok +== +RESET GLOBAL dialect_compatibility_mode +-- +ok +== diff --git a/parser/testdata/corpus/sql/settings/drop_set_schema.test b/parser/testdata/corpus/sql/settings/drop_set_schema.test new file mode 100644 index 0000000..7d08914 --- /dev/null +++ b/parser/testdata/corpus/sql/settings/drop_set_schema.test @@ -0,0 +1,37 @@ +# source: test/sql/settings/drop_set_schema.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +select current_schema(); +-- +ok +== +SET schema='my_schema'; +-- +ok +== +drop schema my_schema; +-- +ok +== +drop schema schema2; +-- +ok +== +ATTACH ':memory:' as db2; +-- +ok +== +create schema db2.schema1; +-- +ok +== +drop schema db2.schema1; +-- +ok +== +drop schema schema1; +-- +ok +== diff --git a/parser/testdata/corpus/sql/settings/errors_as_json.test b/parser/testdata/corpus/sql/settings/errors_as_json.test new file mode 100644 index 0000000..a12dabe --- /dev/null +++ b/parser/testdata/corpus/sql/settings/errors_as_json.test @@ -0,0 +1,25 @@ +# source: test/sql/settings/errors_as_json.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +SET errors_as_json=true +-- +ok +== +SELECT * FROM nonexistent_table +-- +ok +== +SELECT cbl FROM (VALUES (42)) t(col) +-- +ok +== +SECT cbl FROM (VALUES (42)) t(col) +-- +error: Parser Error: syntax error at or near "cbl" +== +select corr('hello'::VARCHAR, 'world'::VARCHAR) +-- +ok +== diff --git a/parser/testdata/corpus/sql/settings/integer_division_setting.test b/parser/testdata/corpus/sql/settings/integer_division_setting.test new file mode 100644 index 0000000..dbbabb7 --- /dev/null +++ b/parser/testdata/corpus/sql/settings/integer_division_setting.test @@ -0,0 +1,25 @@ +# source: test/sql/settings/integer_division_setting.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +SELECT 1/2 +-- +ok +== +SELECT 1//2 +-- +ok +== +SET integer_division=true +-- +ok +== +SET integer_division=false +-- +ok +== +SELECT weighted_avg(v, w) FROM (VALUES (1, 1), (2, 2)) t(v, w) +-- +ok +== diff --git a/parser/testdata/corpus/sql/settings/lock_configuration_schema.test b/parser/testdata/corpus/sql/settings/lock_configuration_schema.test new file mode 100644 index 0000000..caf6195 --- /dev/null +++ b/parser/testdata/corpus/sql/settings/lock_configuration_schema.test @@ -0,0 +1,29 @@ +# source: test/sql/settings/lock_configuration_schema.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +create schema s2; +-- +ok +== +use s1; +-- +ok +== +use s2; +-- +ok +== +SET lock_configuration=true; +-- +ok +== +reset schema; +-- +ok +== +reset search_path +-- +ok +== diff --git a/parser/testdata/corpus/sql/settings/max_execution_time.test b/parser/testdata/corpus/sql/settings/max_execution_time.test new file mode 100644 index 0000000..166c185 --- /dev/null +++ b/parser/testdata/corpus/sql/settings/max_execution_time.test @@ -0,0 +1,84 @@ +# source: test/sql/settings/max_execution_time.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +SELECT current_setting('max_execution_time') +-- +ok +== +SELECT name, value, input_type FROM duckdb_settings() WHERE name = 'max_execution_time' +-- +ok +== +SET max_execution_time=100 +-- +ok +== +SET max_execution_time=50 +-- +ok +== +SELECT COUNT(*) FROM range(100000000) t1, range(1000) t2 +-- +ok +== +SELECT 1 +-- +ok +== +WITH RECURSIVE cte AS ( + SELECT 1 as n + UNION ALL + SELECT n+1 FROM cte WHERE n < 10000000 +) +SELECT COUNT(*) FROM cte +-- +ok +== +SELECT i % 10000000 as g, COUNT(*) FROM range(100000000) t(i) GROUP BY 1 +-- +ok +== +SELECT * FROM range(50000000) ORDER BY random() +-- +ok +== +SELECT i, SUM(i) OVER (PARTITION BY i % 1000000 ORDER BY i) FROM range(10000000) t(i) +-- +ok +== +SELECT + CASE WHEN i % 2 = 0 THEN + CASE WHEN i % 3 = 0 THEN + CASE WHEN i % 5 = 0 THEN 'FizzBuzz' + ELSE 'Fizz' END + ELSE CASE WHEN i % 5 = 0 THEN 'Buzz' + ELSE i::VARCHAR END END + ELSE i::VARCHAR END as result, + COUNT(*) +FROM range(100000000) t(i) +GROUP BY 1 +-- +ok +== +SELECT DISTINCT i FROM range(50000000) t(i) +-- +ok +== +SELECT COUNT(*) FROM range(1000) +-- +ok +== +SET GLOBAL max_execution_time=5000 +-- +ok +== +SET max_execution_time=9000 +-- +ok +== +SET GLOBAL max_execution_time=0 +-- +ok +== diff --git a/parser/testdata/corpus/sql/settings/operator_memory_limit.test b/parser/testdata/corpus/sql/settings/operator_memory_limit.test new file mode 100644 index 0000000..e0c42aa --- /dev/null +++ b/parser/testdata/corpus/sql/settings/operator_memory_limit.test @@ -0,0 +1,89 @@ +# source: test/sql/settings/operator_memory_limit.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +SELECT current_setting('operator_memory_limit') +-- +ok +== +SET operator_memory_limit='256MB' +-- +ok +== +RESET operator_memory_limit +-- +ok +== +SET operator_memory_limit='128MB' +-- +ok +== +SET operator_memory_limit=NULL +-- +ok +== +SELECT name, value, input_type FROM duckdb_settings() WHERE name = 'operator_memory_limit' +-- +ok +== +PRAGMA temp_directory='' +-- +ok +== +PRAGMA max_temp_directory_size='0B' +-- +ok +== +SET operator_memory_limit='1MB' +-- +ok +== +SELECT * FROM range(10000000) ORDER BY random(); +-- +ok +== +SELECT i % 1000000 as g, COUNT(*) FROM range(10000000) t(i) GROUP BY 1; +-- +ok +== +SELECT DISTINCT i FROM range(10000000) t(i); +-- +ok +== +SELECT i, SUM(i) OVER (PARTITION BY i % 100000 ORDER BY i) FROM range(5000000) t(i); +-- +ok +== +CREATE TABLE t1 AS SELECT * FROM range(1000000) +-- +ok +== +SELECT COUNT(*) FROM t1 +-- +ok +== +SELECT SUM(i) FROM range(1000000) t(i) +-- +ok +== +SELECT i % 10 as g, COUNT(*) FROM range(1000000) t(i) GROUP BY 1 ORDER BY 1 +-- +ok +== +SELECT COUNT(*) FROM (SELECT * FROM range(1000) ORDER BY random()) +-- +ok +== +SELECT LENGTH(string_agg(i::VARCHAR, ',')) > 0 FROM range(100000) t(i) +-- +ok +== +SELECT LENGTH(list(i)::VARCHAR) > 0 FROM range(50000) t(i) +-- +ok +== +SELECT COUNT(*) FROM range(100) a, range(100) b +-- +ok +== diff --git a/parser/testdata/corpus/sql/settings/reset/reset_memory_limit.test b/parser/testdata/corpus/sql/settings/reset/reset_memory_limit.test new file mode 100644 index 0000000..1152b60 --- /dev/null +++ b/parser/testdata/corpus/sql/settings/reset/reset_memory_limit.test @@ -0,0 +1,17 @@ +# source: test/sql/settings/reset/reset_memory_limit.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +PRAGMA temp_directory=''; +-- +ok +== +SET memory_limit='2MB'; +-- +ok +== +CREATE TABLE t1 AS SELECT * FROM range(1000000); +-- +ok +== diff --git a/parser/testdata/corpus/sql/settings/reset/reset_threads.test b/parser/testdata/corpus/sql/settings/reset/reset_threads.test new file mode 100644 index 0000000..9a4ac9b --- /dev/null +++ b/parser/testdata/corpus/sql/settings/reset/reset_threads.test @@ -0,0 +1,13 @@ +# source: test/sql/settings/reset/reset_threads.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +select current_setting('threads') +-- +ok +== +pragma threads=42 +-- +ok +== diff --git a/parser/testdata/corpus/sql/settings/set_schema_temp_main.test b/parser/testdata/corpus/sql/settings/set_schema_temp_main.test new file mode 100644 index 0000000..0bf4160 --- /dev/null +++ b/parser/testdata/corpus/sql/settings/set_schema_temp_main.test @@ -0,0 +1,21 @@ +# source: test/sql/settings/set_schema_temp_main.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +CREATE SCHEMA temp.s1; +-- +ok +== +CREATE SCHEMA system.s1; +-- +ok +== +set schema = 'temp'; +-- +ok +== +set schema = 'system'; +-- +ok +== diff --git a/parser/testdata/corpus/sql/settings/setting_alias.test b/parser/testdata/corpus/sql/settings/setting_alias.test new file mode 100644 index 0000000..447da21 --- /dev/null +++ b/parser/testdata/corpus/sql/settings/setting_alias.test @@ -0,0 +1,17 @@ +# source: test/sql/settings/setting_alias.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +SELECT current_setting('null_order'), (SELECT value FROM duckdb_settings() WHERE name='null_order') +-- +ok +== +SET null_order='NULLS_FIRST' +-- +ok +== +RESET null_order +-- +ok +== diff --git a/parser/testdata/corpus/sql/settings/setting_collation.test b/parser/testdata/corpus/sql/settings/setting_collation.test new file mode 100644 index 0000000..6021a4c --- /dev/null +++ b/parser/testdata/corpus/sql/settings/setting_collation.test @@ -0,0 +1,17 @@ +# source: test/sql/settings/setting_collation.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +PRAGMA default_collation='unknown' +-- +ok +== +SET GLOBAL default_collation='NOCASE' +-- +ok +== +SET SESSION default_collation='NOCASE' +-- +ok +== diff --git a/parser/testdata/corpus/sql/settings/setting_disabled_optimizer.test b/parser/testdata/corpus/sql/settings/setting_disabled_optimizer.test new file mode 100644 index 0000000..ed80f0c --- /dev/null +++ b/parser/testdata/corpus/sql/settings/setting_disabled_optimizer.test @@ -0,0 +1,25 @@ +# source: test/sql/settings/setting_disabled_optimizer.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +SET disabled_optimizers TO 'expression_rewriter' +-- +ok +== +SET disabled_optimizers TO 'expression_rewriter,filter_pushdown,join_order' +-- +ok +== +SELECT current_setting('disabled_optimizers'); +-- +ok +== +SET disabled_optimizers TO 'expression_rewriteX' +-- +error: Parser Error: Optimizer type "expression_rewritex" not recognized +== +SET disabled_optimizers TO 'unknown_optimizer' +-- +error: Parser Error: Optimizer type "unknown_optimizer" not recognized +== diff --git a/parser/testdata/corpus/sql/settings/setting_disabled_optimizer.test.metadata.json b/parser/testdata/corpus/sql/settings/setting_disabled_optimizer.test.metadata.json new file mode 100644 index 0000000..bb456eb --- /dev/null +++ b/parser/testdata/corpus/sql/settings/setting_disabled_optimizer.test.metadata.json @@ -0,0 +1,6 @@ +{ + "todo": { + "0b7b9ef146cccc48": "transformer-raised parser error: upstream rejects in the transformer, not the grammar; expected to clear as transformers land (milestones 3-5)", + "9579b94653bbead9": "transformer-raised parser error: upstream rejects in the transformer, not the grammar; expected to clear as transformers land (milestones 3-5)" + } +} diff --git a/parser/testdata/corpus/sql/settings/setting_exhaustive.test b/parser/testdata/corpus/sql/settings/setting_exhaustive.test new file mode 100644 index 0000000..96ae25b --- /dev/null +++ b/parser/testdata/corpus/sql/settings/setting_exhaustive.test @@ -0,0 +1,45 @@ +# source: test/sql/settings/setting_exhaustive.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +SET debug_window_mode='unknown'; +-- +ok +== +SET default_order='{default_order}'; +-- +ok +== +SELECT * FROM duckdb_settings(); +-- +ok +== +SET default_order='unknown'; +-- +ok +== +SET profile_output='{TEST_DIR}/profile_output.txt' +-- +ok +== +SET enable_profiling='{enable_profiling}'; +-- +ok +== +SET enable_profiling='unknown'; +-- +ok +== +SET enable_progress_bar=true; +-- +ok +== +SET explain_output='{explain_output}'; +-- +ok +== +SET explain_output='unknown'; +-- +ok +== diff --git a/parser/testdata/corpus/sql/settings/setting_null_order.test b/parser/testdata/corpus/sql/settings/setting_null_order.test new file mode 100644 index 0000000..313f1b2 --- /dev/null +++ b/parser/testdata/corpus/sql/settings/setting_null_order.test @@ -0,0 +1,17 @@ +# source: test/sql/settings/setting_null_order.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +{statement_type} {null_order_type}='nulls_last' +-- +error: Parser Error: syntax error at or near "}" +== +{statement_type} {null_order_type}='nulls_first' +-- +error: Parser Error: syntax error at or near "}" +== +{statement_type} {null_order_type}='unknown_null_order' +-- +error: Parser Error: syntax error at or near "}" +== diff --git a/parser/testdata/corpus/sql/settings/setting_order.test b/parser/testdata/corpus/sql/settings/setting_order.test new file mode 100644 index 0000000..fcfdc20 --- /dev/null +++ b/parser/testdata/corpus/sql/settings/setting_order.test @@ -0,0 +1,21 @@ +# source: test/sql/settings/setting_order.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +{statement_type} default_order='desc' +-- +error: Parser Error: syntax error at or near "}" +== +SELECT * FROM range(3) ORDER BY 1 +-- +ok +== +{statement_type} default_order='asc' +-- +error: Parser Error: syntax error at or near "}" +== +{statement_type} default_order='unknown_order' +-- +error: Parser Error: syntax error at or near "}" +== diff --git a/parser/testdata/corpus/sql/settings/setting_preserve_identifier_case.test b/parser/testdata/corpus/sql/settings/setting_preserve_identifier_case.test new file mode 100644 index 0000000..fa762aa --- /dev/null +++ b/parser/testdata/corpus/sql/settings/setting_preserve_identifier_case.test @@ -0,0 +1,29 @@ +# source: test/sql/settings/setting_preserve_identifier_case.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +SELECT value FROM duckdb_settings() WHERE name='preserve_identifier_case' +-- +ok +== +CREATE SCHEMA MYSCHEMA; +-- +ok +== +CREATE TABLE MYSCHEMA.INTEGERS(I INTEGER); +-- +ok +== +SELECT duckdb_tables.schema_name, duckdb_tables.table_name, column_name FROM duckdb_tables JOIN duckdb_columns USING (table_oid); +-- +ok +== +DROP SCHEMA MYSCHEMA CASCADE +-- +ok +== +SET preserve_identifier_case TO false; +-- +ok +== diff --git a/parser/testdata/corpus/sql/settings/setting_profiling_mode.test b/parser/testdata/corpus/sql/settings/setting_profiling_mode.test new file mode 100644 index 0000000..bbfcdee --- /dev/null +++ b/parser/testdata/corpus/sql/settings/setting_profiling_mode.test @@ -0,0 +1,13 @@ +# source: test/sql/settings/setting_profiling_mode.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +SET profiling_mode='detailed'; +-- +ok +== +SET profiling_mode='unknown'; +-- +error: Parser Error: Unrecognized profiling mode "unknown", supported formats: [standard, detailed, all] +== diff --git a/parser/testdata/corpus/sql/settings/setting_profiling_mode.test.metadata.json b/parser/testdata/corpus/sql/settings/setting_profiling_mode.test.metadata.json new file mode 100644 index 0000000..616dcd7 --- /dev/null +++ b/parser/testdata/corpus/sql/settings/setting_profiling_mode.test.metadata.json @@ -0,0 +1,5 @@ +{ + "todo": { + "788098fc8dfb03d5": "transformer-raised parser error: upstream rejects in the transformer, not the grammar; expected to clear as transformers land (milestones 3-5)" + } +} diff --git a/parser/testdata/corpus/sql/settings/setting_threads.test b/parser/testdata/corpus/sql/settings/setting_threads.test new file mode 100644 index 0000000..dbb2d5a --- /dev/null +++ b/parser/testdata/corpus/sql/settings/setting_threads.test @@ -0,0 +1,17 @@ +# source: test/sql/settings/setting_threads.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +SET {thread_type} TO '3' +-- +error: Parser Error: syntax error at or near "{" +== +SET {thread_type} TO '-1' +-- +error: Parser Error: syntax error at or near "{" +== +SET {thread_type} TO 'blabla' +-- +error: Parser Error: syntax error at or near "{" +== diff --git a/parser/testdata/corpus/sql/settings/settings_icu.test b/parser/testdata/corpus/sql/settings/settings_icu.test new file mode 100644 index 0000000..4c13b02 --- /dev/null +++ b/parser/testdata/corpus/sql/settings/settings_icu.test @@ -0,0 +1,29 @@ +# source: test/sql/settings/settings_icu.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +SET TimeZone='pacific/honolulu'; +-- +ok +== +SELECT name, value, description, input_type, scope FROM duckdb_settings() WHERE name = 'TimeZone'; +-- +ok +== +SET TimeZone='Pacific/Honolooloo'; +-- +ok +== +SET Calendar='Coptic'; +-- +ok +== +SELECT name, value, description, input_type, scope FROM duckdb_settings() WHERE name = 'Calendar'; +-- +ok +== +SET Calendar='muslim'; +-- +ok +== diff --git a/parser/testdata/corpus/sql/settings/test_disabled_file_systems.test b/parser/testdata/corpus/sql/settings/test_disabled_file_systems.test new file mode 100644 index 0000000..b9a6cfe --- /dev/null +++ b/parser/testdata/corpus/sql/settings/test_disabled_file_systems.test @@ -0,0 +1,41 @@ +# source: test/sql/settings/test_disabled_file_systems.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +SELECT current_setting('disabled_filesystems') +-- +ok +== +RESET disabled_filesystems; +-- +ok +== +SET disabled_filesystems=''; +-- +ok +== +SELECT * FROM read_csv_auto('{DATA_DIR}/csv/auto/skip_row.csv') +-- +ok +== +SET disabled_filesystems='LocalFileSystem'; +-- +ok +== +SET disabled_filesystems='LocalFileSystem,LocalFileSystem'; +-- +ok +== +SELECT * FROM abc.main.t1; +-- +ok +== +SELECT * FROM abc.t1; +-- +ok +== +SELECT * FROM abc.csv; +-- +ok +== diff --git a/parser/testdata/corpus/sql/settings/test_disabled_local_filesystem_metadata.test b/parser/testdata/corpus/sql/settings/test_disabled_local_filesystem_metadata.test new file mode 100644 index 0000000..fd3b49b --- /dev/null +++ b/parser/testdata/corpus/sql/settings/test_disabled_local_filesystem_metadata.test @@ -0,0 +1,17 @@ +# source: test/sql/settings/test_disabled_local_filesystem_metadata.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +SET secret_directory='{TEST_DIR}/disabled_fs_secrets'; +-- +ok +== +SELECT * FROM duckdb_secrets(); +-- +ok +== +SELECT * FROM duckdb_extensions(); +-- +ok +== diff --git a/parser/testdata/corpus/sql/settings/test_disabled_local_filesystem_secrets.test b/parser/testdata/corpus/sql/settings/test_disabled_local_filesystem_secrets.test new file mode 100644 index 0000000..a393b91 --- /dev/null +++ b/parser/testdata/corpus/sql/settings/test_disabled_local_filesystem_secrets.test @@ -0,0 +1,9 @@ +# source: test/sql/settings/test_disabled_local_filesystem_secrets.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +CREATE PERSISTENT SECRET my_s (TYPE S3); +-- +ok +== diff --git a/parser/testdata/corpus/sql/settings/test_external_access_secrets.test b/parser/testdata/corpus/sql/settings/test_external_access_secrets.test new file mode 100644 index 0000000..734f250 --- /dev/null +++ b/parser/testdata/corpus/sql/settings/test_external_access_secrets.test @@ -0,0 +1,13 @@ +# source: test/sql/settings/test_external_access_secrets.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +SET secret_directory='{TEST_DIR}/external_access_secrets'; +-- +ok +== +CREATE PERSISTENT SECRET my_secret (TYPE S3) +-- +ok +== diff --git a/parser/testdata/corpus/sql/settings/test_lock_configuration.test b/parser/testdata/corpus/sql/settings/test_lock_configuration.test new file mode 100644 index 0000000..ce96af3 --- /dev/null +++ b/parser/testdata/corpus/sql/settings/test_lock_configuration.test @@ -0,0 +1,25 @@ +# source: test/sql/settings/test_lock_configuration.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +SELECT current_setting('lock_configuration') +-- +ok +== +SET memory_limit='8GB'; +-- +ok +== +RESET lock_configuration; +-- +ok +== +SET lock_configuration=false; +-- +ok +== +SET memory_limit='10GB'; +-- +ok +== diff --git a/parser/testdata/corpus/sql/settings/user_agent.test b/parser/testdata/corpus/sql/settings/user_agent.test new file mode 100644 index 0000000..3e26ced --- /dev/null +++ b/parser/testdata/corpus/sql/settings/user_agent.test @@ -0,0 +1,25 @@ +# source: test/sql/settings/user_agent.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +SET custom_user_agent='something else' +-- +ok +== +RESET custom_user_agent +-- +ok +== +SELECT current_setting('custom_user_agent') +-- +ok +== +SET duckdb_api='something else' +-- +ok +== +SELECT regexp_matches(user_agent, '^duckdb/.*(.*)') FROM pragma_user_agent() +-- +ok +== diff --git a/parser/testdata/corpus/sql/show_select/describe_rowid.test b/parser/testdata/corpus/sql/show_select/describe_rowid.test new file mode 100644 index 0000000..0a07e3a --- /dev/null +++ b/parser/testdata/corpus/sql/show_select/describe_rowid.test @@ -0,0 +1,31 @@ +# source: test/sql/show_select/describe_rowid.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +create table sometable ( + column1 varchar +); +-- +ok +== +insert into sometable values + ('abc'); +-- +ok +== +create view someview as select + rowid as table_rowid, + * +from sometable; +-- +ok +== +select * from someview; +-- +ok +== +select column_name, column_type from (describe someview); +-- +ok +== diff --git a/parser/testdata/corpus/sql/show_select/describe_subquery.test b/parser/testdata/corpus/sql/show_select/describe_subquery.test new file mode 100644 index 0000000..2c1cdaf --- /dev/null +++ b/parser/testdata/corpus/sql/show_select/describe_subquery.test @@ -0,0 +1,37 @@ +# source: test/sql/show_select/describe_subquery.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +SELECT column_name FROM (DESCRIBE SELECT 42 AS a) +-- +ok +== +SELECT t.column_name FROM (DESCRIBE SELECT 42 AS a) t +-- +ok +== +(DESCRIBE SELECT 42 AS a) +-- +ok +== +CREATE TABLE t AS SELECT 42 AS a +-- +ok +== +SELECT t.column_name FROM (DESCRIBE t) t +-- +ok +== +FROM (SHOW databases) t +-- +ok +== +SELECT column_name FROM (DESCRIBE ( DESCRIBE SELECT * FROM (SELECT 32 as a))); +-- +ok +== +(DESCRIBE (values(42))) UNION ALL (DESCRIBE (values(42))); +-- +ok +== diff --git a/parser/testdata/corpus/sql/show_select/show_quote_identifier.test b/parser/testdata/corpus/sql/show_select/show_quote_identifier.test new file mode 100644 index 0000000..f0730d9 --- /dev/null +++ b/parser/testdata/corpus/sql/show_select/show_quote_identifier.test @@ -0,0 +1,13 @@ +# source: test/sql/show_select/show_quote_identifier.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +CREATE TABLE "s1"".tbl"(i INT); +-- +ok +== +SELECT column_name, column_type FROM (DESCRIBE "s1"".tbl") +-- +ok +== diff --git a/parser/testdata/corpus/sql/show_select/show_select_constraints.test b/parser/testdata/corpus/sql/show_select/show_select_constraints.test new file mode 100644 index 0000000..3672d6d --- /dev/null +++ b/parser/testdata/corpus/sql/show_select/show_select_constraints.test @@ -0,0 +1,89 @@ +# source: test/sql/show_select/show_select_constraints.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +CREATE TABLE integers(c1 INTEGER PRIMARY KEY, c2 INT NOT NULL, c3 INT DEFAULT 42, c4 INT UNIQUE, c5 INT); +-- +ok +== +INSERT INTO integers VALUES (42, 42, 42, 42, 42) +-- +ok +== +INSERT INTO integers VALUES (84, 84, 84, 84, 84) +-- +ok +== +DESCRIBE SELECT * FROM integers +-- +ok +== +DESCRIBE integers +-- +ok +== +SELECT column_name, key FROM (DESCRIBE SELECT c4, c1 FROM integers) +-- +ok +== +SELECT column_name, key FROM (DESCRIBE SELECT c4 FROM integers WHERE c1=42) +-- +ok +== +SELECT column_name, key FROM (DESCRIBE SELECT c4 FROM integers LIMIT 5) +-- +ok +== +SELECT column_name, key FROM (DESCRIBE SELECT c4 FROM integers ORDER BY c1 LIMIT 5) +-- +ok +== +SELECT column_name, key FROM (DESCRIBE SELECT c4 FROM integers USING SAMPLE 5) +-- +ok +== +SELECT column_name, key FROM (DESCRIBE SELECT c4 FROM integers, (SELECT 84)) +-- +ok +== +SELECT column_name, key FROM (DESCRIBE SELECT t.c1, integers.c1 FROM integers JOIN (SELECT 84 c1) t USING (c1)) +-- +ok +== +CREATE VIEW my_view AS SELECT * FROM integers +-- +ok +== +SELECT column_name, key FROM (DESCRIBE SELECT c4, c1 FROM my_view) +-- +ok +== +SELECT column_name, key FROM (DESCRIBE SELECT c4 + 1 AS expr FROM integers LIMIT 5) +-- +ok +== +CREATE TABLE base_table(base_name int); +-- +ok +== +DESCRIBE base_table +-- +ok +== +DESCRIBE SELECT base_name AS alias_name FROM base_table +-- +ok +== +DESCRIBE SELECT alias_name as alias_alias_name FROM (SELECT base_name AS alias_name FROM base_table) +-- +ok +== +DESCRIBE SELECT base_name AS alias_name FROM VALUES (1) AS base_table(base_name) +-- +ok +== +DESCRIBE WITH cte_rel AS (SELECT 1 as base_name) SELECT base_name as alias_name FROM cte_rel; +-- +ok +== diff --git a/parser/testdata/corpus/sql/show_select/summarize_subquery.test b/parser/testdata/corpus/sql/show_select/summarize_subquery.test new file mode 100644 index 0000000..1c838d1 --- /dev/null +++ b/parser/testdata/corpus/sql/show_select/summarize_subquery.test @@ -0,0 +1,17 @@ +# source: test/sql/show_select/summarize_subquery.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +SELECT column_name, min FROM (SUMMARIZE SELECT 42 AS a); +-- +ok +== +CREATE TABLE tbl AS SELECT 42 AS a +-- +ok +== +SELECT column_name, min FROM (SUMMARIZE tbl); +-- +ok +== diff --git a/parser/testdata/corpus/sql/show_select/test_describe_all.test b/parser/testdata/corpus/sql/show_select/test_describe_all.test new file mode 100644 index 0000000..696f61a --- /dev/null +++ b/parser/testdata/corpus/sql/show_select/test_describe_all.test @@ -0,0 +1,21 @@ +# source: test/sql/show_select/test_describe_all.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +CREATE TABLE integers(i INTEGER, j INTEGER, a INTEGER); +-- +ok +== +DESCRIBE; +-- +ok +== +DESCRIBE +-- +ok +== +CREATE TABLE t(plant TEXT, dt DATE, mwh BIGINT); +-- +ok +== diff --git a/parser/testdata/corpus/sql/show_select/test_describe_quoted.test b/parser/testdata/corpus/sql/show_select/test_describe_quoted.test new file mode 100644 index 0000000..21ec6c5 --- /dev/null +++ b/parser/testdata/corpus/sql/show_select/test_describe_quoted.test @@ -0,0 +1,73 @@ +# source: test/sql/show_select/test_describe_quoted.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +create table "a.b.c" (x int); +-- +ok +== +describe "a.b.c"; +-- +ok +== +create schema defg; +-- +ok +== +drop table "a.b.c"; +-- +ok +== +create table defg."a.b.c" (x int); +-- +ok +== +describe defg."a.b.c"; +-- +ok +== +drop table defg."a.b.c"; +-- +ok +== +create table defg.abc (x int); +-- +ok +== +describe defg.abc; +-- +ok +== +drop table defg.abc; +-- +ok +== +drop schema defg; +-- +ok +== +create schema "d.e.f.g"; +-- +ok +== +create table "d.e.f.g"."a.b.c" (x int); +-- +ok +== +describe "d.e.f.g"."a.b.c"; +-- +ok +== +drop table "d.e.f.g"."a.b.c" +-- +ok +== +create table "d.e.f.g".abc (x int); +-- +ok +== +describe "d.e.f.g".abc; +-- +ok +== diff --git a/parser/testdata/corpus/sql/show_select/test_show_select.test b/parser/testdata/corpus/sql/show_select/test_show_select.test new file mode 100644 index 0000000..a39d05a --- /dev/null +++ b/parser/testdata/corpus/sql/show_select/test_show_select.test @@ -0,0 +1,29 @@ +# source: test/sql/show_select/test_show_select.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +CREATE TABLE integers2 (i INTEGER, j INTEGER, st VARCHAR, d DATE) +-- +ok +== +INSERT INTO integers2 VALUES (1, 30, 'a', '1992-01-01'), (8, 12, 'b', '1992-01-01'), (3, 24, 'c', '1992-01-01'), (9, 16, 'd', '1992-01-01'), (10, NULL, 'e', '1992-01-01') +-- +ok +== +SHOW SELECT * FROM integers +-- +ok +== +SHOW SELECT i FROM integers +-- +ok +== +SHOW SELECT integers.i, integers2.st, integers2.d FROM integers, integers2 WHERE integers.i=integers2.i +-- +ok +== +SHOW SELECT SUM(i) AS sum1, j FROM integers GROUP BY j HAVING j < 10 +-- +ok +== diff --git a/parser/testdata/corpus/sql/show_select/test_summarize.test b/parser/testdata/corpus/sql/show_select/test_summarize.test new file mode 100644 index 0000000..2f97b79 --- /dev/null +++ b/parser/testdata/corpus/sql/show_select/test_summarize.test @@ -0,0 +1,67 @@ +# source: test/sql/show_select/test_summarize.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +CREATE TABLE types(i INTEGER, j VARCHAR, k HUGEINT, d DOUBLE, e BLOB); +-- +ok +== +INSERT INTO types VALUES + (1, 'hello', 12, 0.5, BLOB 'a\x00b\x00c'), + (2, 'world', -12, -0.5, BLOB ''), + (3, NULL, NULL, NULL, NULL); +-- +ok +== +SELECT UNNEST(['i', 'j', 'k', 'd', 'e']) column_names, + UNNEST(['INTEGER', 'VARCHAR', 'HUGEINT', 'DOUBLE', 'BLOB']) column_types, + UNNEST([MIN(i)::VARCHAR, MIN(j)::VARCHAR, MIN(k)::VARCHAR, MIN(d)::VARCHAR, MIN(e)::VARCHAR]) min, + UNNEST([MAX(i)::VARCHAR, MAX(j)::VARCHAR, MAX(k)::VARCHAR, MAX(d)::VARCHAR, MAX(e)::VARCHAR]) max +FROM (SELECT * FROM types) tbl +-- +ok +== +SUMMARIZE types; +-- +ok +== +SUMMARIZE SELECT * FROM types; +-- +ok +== +summarize +from range('2024-01-01'::TIMESTAMP, '2024-04-10'::TIMESTAMP, INTERVAL 1 DAY); +-- +ok +== +summarize +SELECT range::DATE AS range from range('2024-01-01'::DATE, '2024-04-10'::DATE, INTERVAL 1 DAY); +-- +ok +== +summarize +SELECT range::TIME AS range from range('2024-01-01'::DATE, '2024-04-10'::DATE, INTERVAL 1 HOUR); +-- +ok +== +SUMMARIZE (SELECT '1:02:03.000000+05:30'::TIMETZ AS ttz); +-- +ok +== +SUMMARIZE VALUES (1.0),(6754950520); +-- +ok +== +SUMMARIZE SELECT 9223372036854775296; +-- +ok +== +summarize select bigint from test_all_types(); +-- +ok +== +summarize select 9223372036854775295; +-- +ok +== diff --git a/parser/testdata/corpus/sql/show_select/test_summarize_quoted.test b/parser/testdata/corpus/sql/show_select/test_summarize_quoted.test new file mode 100644 index 0000000..1a3e246 --- /dev/null +++ b/parser/testdata/corpus/sql/show_select/test_summarize_quoted.test @@ -0,0 +1,25 @@ +# source: test/sql/show_select/test_summarize_quoted.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +summarize "a.b.c"; +-- +ok +== +summarize defg."a.b.c"; +-- +ok +== +summarize defg.abc; +-- +ok +== +summarize "d.e.f.g"."a.b.c"; +-- +ok +== +summarize "d.e.f.g".abc; +-- +ok +== diff --git a/parser/testdata/corpus/sql/storage/adaptive_segment_allocation.test b/parser/testdata/corpus/sql/storage/adaptive_segment_allocation.test new file mode 100644 index 0000000..c90af66 --- /dev/null +++ b/parser/testdata/corpus/sql/storage/adaptive_segment_allocation.test @@ -0,0 +1,175 @@ +# source: test/sql/storage/adaptive_segment_allocation.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +SET initial_column_segment_size = 7 +-- +ok +== +SET initial_column_segment_size = 9 +-- +ok +== +SET initial_column_segment_size = 8 +-- +ok +== +CREATE TABLE step_test (i INT NOT NULL) +-- +ok +== +INSERT INTO step_test VALUES (1), (2), (3), (4), (5) +-- +ok +== +SELECT segment_id, count +FROM pragma_storage_info('step_test') +WHERE column_name = 'i' AND segment_type = 'INTEGER' +ORDER BY segment_id +-- +ok +== +DROP TABLE step_test +-- +ok +== +CREATE TABLE mem_adaptive (a INT NOT NULL, b INT NOT NULL, c INT NOT NULL, d INT NOT NULL, e INT NOT NULL) +-- +ok +== +INSERT INTO mem_adaptive VALUES (1, 2, 3, 4, 5) +-- +ok +== +SELECT CASE WHEN memory_usage_bytes < 2000 + THEN 'ok' + ELSE error(concat('expected < 2000 bytes, got ', memory_usage_bytes)) + END +FROM duckdb_memory() +WHERE tag = 'IN_MEMORY_TABLE' +-- +ok +== +DROP TABLE mem_adaptive +-- +ok +== +CREATE TABLE overflow_test (i BIGINT NOT NULL) +-- +ok +== +INSERT INTO overflow_test SELECT range FROM range(100) +-- +ok +== +SELECT COUNT(*) FROM overflow_test +-- +ok +== +SELECT SUM(i) FROM overflow_test +-- +ok +== +SELECT MIN(i) = 0 AND MAX(i) = 99 FROM overflow_test +-- +ok +== +DROP TABLE overflow_test +-- +ok +== +CREATE TABLE validity_test (i INTEGER) +-- +ok +== +INSERT INTO validity_test + SELECT CASE WHEN range % 7 = 6 THEN NULL ELSE range END + FROM range(100) +-- +ok +== +SELECT COUNT(*) FROM validity_test +-- +ok +== +SELECT COUNT(*) FILTER (WHERE i IS NULL) FROM validity_test +-- +ok +== +SELECT COUNT(*) FILTER (WHERE i IS NOT NULL) FROM validity_test +-- +ok +== +SELECT COUNT(*) FROM ( + SELECT ROW_NUMBER() OVER () - 1 AS rn, i FROM validity_test +) WHERE (rn % 7 = 6) != (i IS NULL) +-- +ok +== +CREATE TABLE string_test (s VARCHAR) +-- +ok +== +INSERT INTO string_test + SELECT CASE WHEN range % 2 = 0 + THEN range::VARCHAR + ELSE repeat('x', 50) || range::VARCHAR + END + FROM range(100) +-- +ok +== +SELECT COUNT(*) FROM string_test +-- +ok +== +SELECT COUNT(*) FILTER (WHERE len(s) <= 12) FROM string_test +-- +ok +== +SELECT COUNT(*) FILTER (WHERE len(s) > 50) FROM string_test +-- +ok +== +SELECT s FROM string_test WHERE s = '42' +-- +ok +== +SELECT len(s) FROM string_test WHERE s = repeat('x', 50) || '1' +-- +ok +== +DROP TABLE validity_test +-- +ok +== +DROP TABLE string_test +-- +ok +== +CREATE TABLE post_checkpoint_mem (a INT NOT NULL, b INT NOT NULL, c INT NOT NULL, d INT NOT NULL, e INT NOT NULL) +-- +ok +== +INSERT INTO post_checkpoint_mem VALUES (1, 2, 3, 4, 5) +-- +ok +== +INSERT INTO post_checkpoint_mem VALUES (6, 7, 8, 9, 10) +-- +ok +== +SELECT CASE WHEN memory_usage_bytes < 2000 + THEN 'ok' + ELSE error(concat('expected < 2000 bytes after checkpoint, got ', memory_usage_bytes)) + END +FROM duckdb_memory() +WHERE tag = 'IN_MEMORY_TABLE' +-- +ok +== +DROP TABLE post_checkpoint_mem +-- +ok +== diff --git a/parser/testdata/corpus/sql/storage/alter/alter_add_col_defaultexpr_sequence.test b/parser/testdata/corpus/sql/storage/alter/alter_add_col_defaultexpr_sequence.test new file mode 100644 index 0000000..7dbd655 --- /dev/null +++ b/parser/testdata/corpus/sql/storage/alter/alter_add_col_defaultexpr_sequence.test @@ -0,0 +1,13 @@ +# source: test/sql/storage/alter/alter_add_col_defaultexpr_sequence.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +CREATE TABLE db1.tbl (id INTEGER DEFAULT nextval('seq'), s VARCHAR); +-- +ok +== +ALTER TABLE db1.tbl ADD COLUMN m INTEGER DEFAULT nextval('seq'); +-- +ok +== diff --git a/parser/testdata/corpus/sql/storage/alter/alter_based_on_unfinished_insert_fails.test b/parser/testdata/corpus/sql/storage/alter/alter_based_on_unfinished_insert_fails.test new file mode 100644 index 0000000..ef12b90 --- /dev/null +++ b/parser/testdata/corpus/sql/storage/alter/alter_based_on_unfinished_insert_fails.test @@ -0,0 +1,35 @@ +# source: test/sql/storage/alter/alter_based_on_unfinished_insert_fails.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +CREATE OR REPLACE TABLE t AS SELECT + range::INTEGER AS int_col, + md5(range::VARCHAR)::VARCHAR AS varchar_col +FROM range(200) +-- +ok +== +ALTER TABLE t ADD COLUMN IF NOT EXISTS int_col__tmp INTEGER; +-- +ok +== +UPDATE t SET int_col__tmp = int_col; +-- +ok +== +ALTER TABLE t DROP COLUMN int_col__tmp; +-- +ok +== +INSERT INTO t BY NAME SELECT + 1::INTEGER AS int_col, + 'x' AS varchar_col +FROM range(10); +-- +ok +== +SELECT count(*) FROM t +-- +ok +== diff --git a/parser/testdata/corpus/sql/storage/alter/alter_column_constraint.test b/parser/testdata/corpus/sql/storage/alter/alter_column_constraint.test new file mode 100644 index 0000000..2ba5d8e --- /dev/null +++ b/parser/testdata/corpus/sql/storage/alter/alter_column_constraint.test @@ -0,0 +1,41 @@ +# source: test/sql/storage/alter/alter_column_constraint.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +CREATE TABLE IF NOT EXISTS a(id INT PRIMARY KEY); +-- +ok +== +INSERT INTO a(id) VALUES (1); +-- +ok +== +ALTER TABLE a ADD COLUMN c REAL; +-- +ok +== +ALTER TABLE a ALTER COLUMN c SET DEFAULT 10; +-- +ok +== +ALTER TABLE a RENAME c TO d; +-- +ok +== +ALTER TABLE a RENAME TO b; +-- +ok +== +INSERT INTO b(id) VALUES (1); +-- +ok +== +ALTER TABLE b DROP d; +-- +ok +== +INSERT INTO b(id) VALUES (2); +-- +ok +== diff --git a/parser/testdata/corpus/sql/storage/alter/alter_lazy_metadata_load.test b/parser/testdata/corpus/sql/storage/alter/alter_lazy_metadata_load.test new file mode 100644 index 0000000..3d14d69 --- /dev/null +++ b/parser/testdata/corpus/sql/storage/alter/alter_lazy_metadata_load.test @@ -0,0 +1,29 @@ +# source: test/sql/storage/alter/alter_lazy_metadata_load.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +create table t as select i, i // 2 as j, i // 4 as k from range(1_000_000) t(i); +-- +ok +== +alter table t add column l integer; +-- +ok +== +select min(j), max(j) from t +-- +ok +== +select min(i), max(i) from t +-- +ok +== +select min(k), max(k) from t +-- +ok +== +select min(l), max(l) from t +-- +ok +== diff --git a/parser/testdata/corpus/sql/storage/append_strings_to_persistent.test b/parser/testdata/corpus/sql/storage/append_strings_to_persistent.test new file mode 100644 index 0000000..dfc3413 --- /dev/null +++ b/parser/testdata/corpus/sql/storage/append_strings_to_persistent.test @@ -0,0 +1,25 @@ +# source: test/sql/storage/append_strings_to_persistent.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +CREATE TABLE vals(i INTEGER, v VARCHAR) +-- +ok +== +INSERT INTO vals VALUES (1, 'hello') +-- +ok +== +INSERT INTO vals SELECT i, i::VARCHAR FROM generate_series(2,10000) t(i) +-- +ok +== +SELECT MIN(i), MAX(i), MIN(v), MAX(v) FROM vals +-- +ok +== +INSERT INTO vals SELECT i, i::VARCHAR FROM generate_series(10001,100000) t(i) +-- +ok +== diff --git a/parser/testdata/corpus/sql/storage/attach/attach_autocheckpoint_in_memory.test b/parser/testdata/corpus/sql/storage/attach/attach_autocheckpoint_in_memory.test new file mode 100644 index 0000000..113267d --- /dev/null +++ b/parser/testdata/corpus/sql/storage/attach/attach_autocheckpoint_in_memory.test @@ -0,0 +1,41 @@ +# source: test/sql/storage/attach/attach_autocheckpoint_in_memory.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +SET auto_checkpoint_skip_wal_threshold = 9999999999; +-- +ok +== +ATTACH ':memory:' AS m; +-- +ok +== +CREATE TABLE m.tbl(i INTEGER); +-- +ok +== +SET wal_autocheckpoint = '1B'; +-- +ok +== +PRAGMA debug_checkpoint_abort = 'IN_MEMORY_CHECKPOINT'; +-- +ok +== +INSERT INTO m.tbl SELECT range::INTEGER FROM range(10); +-- +ok +== +SELECT COUNT(*) FROM m.tbl; +-- +ok +== +PRAGMA debug_checkpoint_abort = 'NONE'; +-- +ok +== +DETACH m; +-- +ok +== diff --git a/parser/testdata/corpus/sql/storage/attach/attach_autocheckpoint_no_wal_writes.test b/parser/testdata/corpus/sql/storage/attach/attach_autocheckpoint_no_wal_writes.test new file mode 100644 index 0000000..1064d4d --- /dev/null +++ b/parser/testdata/corpus/sql/storage/attach/attach_autocheckpoint_no_wal_writes.test @@ -0,0 +1,41 @@ +# source: test/sql/storage/attach/attach_autocheckpoint_no_wal_writes.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +ATTACH '{TEST_DIR}/attach_autockpt_no_wal.db' AS nw (RECOVERY_MODE NO_WAL_WRITES); +-- +ok +== +CREATE TABLE nw.tbl(i INTEGER); +-- +ok +== +CHECKPOINT nw; +-- +ok +== +SET wal_autocheckpoint = '1KB'; +-- +ok +== +PRAGMA debug_checkpoint_abort = 'before_header_non_fatal'; +-- +ok +== +INSERT INTO nw.tbl SELECT range::INTEGER FROM range(10000); +-- +ok +== +PRAGMA debug_checkpoint_abort = 'none'; +-- +ok +== +DETACH nw; +-- +ok +== +SELECT COUNT(*) FROM nw.tbl; +-- +ok +== diff --git a/parser/testdata/corpus/sql/storage/attach/attach_autocheckpoint_propagation.test b/parser/testdata/corpus/sql/storage/attach/attach_autocheckpoint_propagation.test new file mode 100644 index 0000000..b93f09c --- /dev/null +++ b/parser/testdata/corpus/sql/storage/attach/attach_autocheckpoint_propagation.test @@ -0,0 +1,29 @@ +# source: test/sql/storage/attach/attach_autocheckpoint_propagation.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +ATTACH '{TEST_DIR}/attach_autockpt_prop.db' AS a; +-- +ok +== +CREATE TABLE a.tbl(i INTEGER); +-- +ok +== +SET wal_autocheckpoint_entries = 1; +-- +ok +== +INSERT INTO a.tbl VALUES (1), (2), (3); +-- +ok +== +SELECT COUNT(*) FROM a.tbl; +-- +ok +== +DETACH a; +-- +ok +== diff --git a/parser/testdata/corpus/sql/storage/attach/attach_invalidation.test b/parser/testdata/corpus/sql/storage/attach/attach_invalidation.test new file mode 100644 index 0000000..88a27f5 --- /dev/null +++ b/parser/testdata/corpus/sql/storage/attach/attach_invalidation.test @@ -0,0 +1,61 @@ +# source: test/sql/storage/attach/attach_invalidation.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +ATTACH '{TEST_DIR}/attach_invalidation_a_{abort_mode}.db' AS a; +-- +ok +== +ATTACH '{TEST_DIR}/attach_invalidation_b_{abort_mode}.db' AS b; +-- +ok +== +CREATE TABLE b.tbl(i INTEGER); +-- +ok +== +INSERT INTO a.tbl SELECT range::INTEGER FROM range(10); +-- +ok +== +INSERT INTO b.tbl VALUES (100); +-- +ok +== +CHECKPOINT a; +-- +ok +== +INSERT INTO a.tbl VALUES (10); +-- +ok +== +PRAGMA debug_checkpoint_abort = '{abort_mode}'; +-- +ok +== +INSERT INTO a.tbl VALUES (11); +-- +ok +== +INSERT INTO b.tbl VALUES (101); +-- +ok +== +SELECT COUNT(*) FROM b.tbl; +-- +ok +== +SET immediate_transaction_mode = false; +-- +ok +== +INSERT INTO a.tbl SELECT (range + 1000)::INTEGER FROM range(10000); +-- +ok +== +DETACH b; +-- +ok +== diff --git a/parser/testdata/corpus/sql/storage/attach/attach_invalidation_default_db.test b/parser/testdata/corpus/sql/storage/attach/attach_invalidation_default_db.test new file mode 100644 index 0000000..e7e3a3f --- /dev/null +++ b/parser/testdata/corpus/sql/storage/attach/attach_invalidation_default_db.test @@ -0,0 +1,33 @@ +# source: test/sql/storage/attach/attach_invalidation_default_db.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +PRAGMA wal_autocheckpoint = '1TB'; +-- +ok +== +INSERT INTO t VALUES (1); +-- +ok +== +ATTACH '{TEST_DIR}/attach_inval_default_sib_{abort_mode}.db' AS sib; +-- +ok +== +CREATE TABLE sib.t(i INTEGER); +-- +ok +== +INSERT INTO sib.t VALUES (100); +-- +ok +== +INSERT INTO t VALUES (2); +-- +ok +== +SELECT COUNT(*) FROM sib.t; +-- +ok +== diff --git a/parser/testdata/corpus/sql/storage/attach/attach_invalidation_sibling_commit.test b/parser/testdata/corpus/sql/storage/attach/attach_invalidation_sibling_commit.test new file mode 100644 index 0000000..e27db3a --- /dev/null +++ b/parser/testdata/corpus/sql/storage/attach/attach_invalidation_sibling_commit.test @@ -0,0 +1,37 @@ +# source: test/sql/storage/attach/attach_invalidation_sibling_commit.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +ATTACH '{TEST_DIR}/attach_invalidation_sibling_commit_a.db' AS a; +-- +ok +== +ATTACH '{TEST_DIR}/attach_invalidation_sibling_commit_b.db' AS b; +-- +ok +== +INSERT INTO a.tbl VALUES (1); +-- +ok +== +INSERT INTO b.tbl VALUES (99); +-- +ok +== +SET wal_autocheckpoint='1KB'; +-- +ok +== +SET auto_checkpoint_skip_wal_threshold=9999999999; +-- +ok +== +PRAGMA debug_checkpoint_abort='before_header'; +-- +ok +== +INSERT INTO a.tbl SELECT range FROM range(10000); +-- +ok +== diff --git a/parser/testdata/corpus/sql/storage/attach/attach_invalidation_sibling_rollback.test b/parser/testdata/corpus/sql/storage/attach/attach_invalidation_sibling_rollback.test new file mode 100644 index 0000000..4e24e9f --- /dev/null +++ b/parser/testdata/corpus/sql/storage/attach/attach_invalidation_sibling_rollback.test @@ -0,0 +1,13 @@ +# source: test/sql/storage/attach/attach_invalidation_sibling_rollback.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +ATTACH '{TEST_DIR}/attach_invalidation_sibling_rollback_a.db' AS a; +-- +ok +== +ATTACH '{TEST_DIR}/attach_invalidation_sibling_rollback_b.db' AS b; +-- +ok +== diff --git a/parser/testdata/corpus/sql/storage/attach_mmap.test b/parser/testdata/corpus/sql/storage/attach_mmap.test new file mode 100644 index 0000000..6faeb58 --- /dev/null +++ b/parser/testdata/corpus/sql/storage/attach_mmap.test @@ -0,0 +1,117 @@ +# source: test/sql/storage/attach_mmap.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +ATTACH '{TEST_DIR}/bogus.duckdb' AS bogus (IO_MODE 'NOPE') +-- +ok +== +ATTACH '{TEST_DIR}/buffered_attach.duckdb' AS buffered_db (IO_MODE 'BUFFERED_IO') +-- +ok +== +DETACH buffered_db +-- +ok +== +SELECT current_setting('default_io_mode') +-- +ok +== +SET default_io_mode = 'MMAP' +-- +ok +== +ATTACH '{TEST_DIR}/default_io_mode_mmap.duckdb' AS dim_db +-- +ok +== +CREATE TABLE dim_db.t (a INTEGER) +-- +ok +== +INSERT INTO dim_db.t VALUES (1), (2), (3) +-- +ok +== +SELECT a FROM dim_db.t ORDER BY a +-- +ok +== +DETACH dim_db +-- +ok +== +ATTACH '{TEST_DIR}/mmap_reserve_size.duckdb' AS rsize_db (IO_MODE 'MMAP', MMAP_RESERVE_SIZE '1GB') +-- +ok +== +CREATE TABLE rsize_db.t (a INTEGER) +-- +ok +== +INSERT INTO rsize_db.t VALUES (1), (2), (3) +-- +ok +== +DETACH rsize_db +-- +ok +== +ATTACH '{TEST_DIR}/mmap_reserve_size_bad.duckdb' AS rsize_bad (IO_MODE 'MMAP', MMAP_RESERVE_SIZE 'banana') +-- +error: Parser Error: Memory must have a number (e.g. 1GB) +== +RESET default_io_mode +-- +ok +== +SET default_io_mode = 'NOPE' +-- +ok +== +ATTACH '{TEST_DIR}/mmap_attach.duckdb' AS mmap_db (IO_MODE 'MMAP') +-- +ok +== +CREATE TABLE mmap_db.t (a INTEGER, b VARCHAR); +-- +ok +== +INSERT INTO mmap_db.t VALUES (1, 'one'), (2, 'two'), (3, 'three'); +-- +ok +== +SELECT a, b FROM mmap_db.t ORDER BY a +-- +ok +== +DETACH mmap_db +-- +ok +== +INSERT INTO mmap_db.t SELECT i, 'val_' || i FROM range(4, 1000) tbl(i) +-- +ok +== +SELECT COUNT(*) FROM mmap_db.t +-- +ok +== +SELECT a, b FROM mmap_db.t WHERE a IN (1, 500, 999) ORDER BY a +-- +ok +== +CHECKPOINT mmap_db +-- +ok +== +ATTACH '{TEST_DIR}/mmap_attach.duckdb' AS mmap_db +-- +ok +== +ATTACH '{TEST_DIR}/mmap_attach.duckdb' AS mmap_db (IO_MODE 'MMAP', READ_ONLY) +-- +ok +== diff --git a/parser/testdata/corpus/sql/storage/attach_mmap.test.metadata.json b/parser/testdata/corpus/sql/storage/attach_mmap.test.metadata.json new file mode 100644 index 0000000..ff99177 --- /dev/null +++ b/parser/testdata/corpus/sql/storage/attach_mmap.test.metadata.json @@ -0,0 +1,5 @@ +{ + "todo": { + "90777abc828a93d8": "transformer-raised parser error: upstream rejects in the transformer, not the grammar; expected to clear as transformers land (milestones 3-5)" + } +} diff --git a/parser/testdata/corpus/sql/storage/bc/internal_schemas_0102.test b/parser/testdata/corpus/sql/storage/bc/internal_schemas_0102.test new file mode 100644 index 0000000..bcd6215 --- /dev/null +++ b/parser/testdata/corpus/sql/storage/bc/internal_schemas_0102.test @@ -0,0 +1,9 @@ +# source: test/sql/storage/bc/internal_schemas_0102.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +SELECT database_name, schema_name FROM duckdb_schemas WHERE NOT internal +-- +ok +== diff --git a/parser/testdata/corpus/sql/storage/bc/test_broken_view_v092.test b/parser/testdata/corpus/sql/storage/bc/test_broken_view_v092.test new file mode 100644 index 0000000..3cbc217 --- /dev/null +++ b/parser/testdata/corpus/sql/storage/bc/test_broken_view_v092.test @@ -0,0 +1,9 @@ +# source: test/sql/storage/bc/test_broken_view_v092.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +FROM duckdb_columns(); +-- +ok +== diff --git a/parser/testdata/corpus/sql/storage/bc/test_view_v092.test b/parser/testdata/corpus/sql/storage/bc/test_view_v092.test new file mode 100644 index 0000000..f89e888 --- /dev/null +++ b/parser/testdata/corpus/sql/storage/bc/test_view_v092.test @@ -0,0 +1,17 @@ +# source: test/sql/storage/bc/test_view_v092.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +SELECT * FROM v3 +-- +ok +== +FROM duckdb_views() +-- +ok +== +FROM duckdb_columns() +-- +ok +== diff --git a/parser/testdata/corpus/sql/storage/buffer_manager_temp_dir.test b/parser/testdata/corpus/sql/storage/buffer_manager_temp_dir.test new file mode 100644 index 0000000..944bd12 --- /dev/null +++ b/parser/testdata/corpus/sql/storage/buffer_manager_temp_dir.test @@ -0,0 +1,17 @@ +# source: test/sql/storage/buffer_manager_temp_dir.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +PRAGMA memory_limit='2MB' +-- +ok +== +CREATE TABLE t2 AS SELECT * FROM range(1000000); +-- +ok +== +PRAGMA temp_directory='{TEST_DIR}/myfile.tmp' +-- +ok +== diff --git a/parser/testdata/corpus/sql/storage/catalog/generated_columns/virtual/basic.test b/parser/testdata/corpus/sql/storage/catalog/generated_columns/virtual/basic.test new file mode 100644 index 0000000..f21744d --- /dev/null +++ b/parser/testdata/corpus/sql/storage/catalog/generated_columns/virtual/basic.test @@ -0,0 +1,16 @@ +# source: test/sql/storage/catalog/generated_columns/virtual/basic.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +CREATE TABLE tbl ( + price INTEGER, + gcol AS (price) +); +-- +ok +== +SELECT gcol FROM tbl; +-- +ok +== diff --git a/parser/testdata/corpus/sql/storage/catalog/generated_columns/virtual/constraints.test b/parser/testdata/corpus/sql/storage/catalog/generated_columns/virtual/constraints.test new file mode 100644 index 0000000..ec09999 --- /dev/null +++ b/parser/testdata/corpus/sql/storage/catalog/generated_columns/virtual/constraints.test @@ -0,0 +1,91 @@ +# source: test/sql/storage/catalog/generated_columns/virtual/constraints.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +CREATE TABLE tbl ( + gcol_x AS (x), + gcol_y AS (y), + y INTEGER, + x TEXT + CHECK (y > 5) +); +-- +ok +== +INSERT INTO tbl VALUES (5, 'test'); +-- +ok +== +INSERT INTO tbl VALUES (6,'test'); +-- +ok +== +CREATE TABLE tbl ( + gcol_x AS (x), + gcol_y AS (y), + y INTEGER CHECK (y > 5), + x TEXT +); +-- +ok +== +CREATE TABLE tbl ( + gcol_x AS (x), + gcol_y AS (y), + y INTEGER UNIQUE, + x TEXT PRIMARY KEY +); +-- +ok +== +CREATE TABLE tbl ( + gcol_x AS (x), + gcol_y AS (y), + y INTEGER, + x TEXT, + PRIMARY KEY (y), + UNIQUE (x) +); +-- +ok +== +CREATE TABLE base ( + price INTEGER PRIMARY KEY +); +-- +ok +== +CREATE TABLE tbl ( + gcol_nest AS (gcol), + gcol AS (x), + x INTEGER, + FOREIGN KEY (x) REFERENCES base (price) +); +-- +ok +== +INSERT INTO base VALUES (5); +-- +ok +== +DROP TABLE base; +-- +ok +== +CREATE TABLE tbl ( + gcol2 AS (gcol1), + price INTEGER DEFAULT (5), + gcol1 AS (price), +); +-- +ok +== +ALTER TABLE tbl DROP COLUMN gcol1; +-- +ok +== +ALTER TABLE tbl DROP COLUMN gcol2; +-- +ok +== diff --git a/parser/testdata/corpus/sql/storage/catalog/test_check_constraint.test b/parser/testdata/corpus/sql/storage/catalog/test_check_constraint.test new file mode 100644 index 0000000..554f048 --- /dev/null +++ b/parser/testdata/corpus/sql/storage/catalog/test_check_constraint.test @@ -0,0 +1,29 @@ +# source: test/sql/storage/catalog/test_check_constraint.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +CREATE TABLE test(a INTEGER CHECK (a<10), b INTEGER CHECK(CASE WHEN b < 10 THEN a < b ELSE a + b < 100 END)); +-- +ok +== +INSERT INTO test VALUES (3, 7); +-- +ok +== +INSERT INTO test VALUES (12, 13); +-- +ok +== +INSERT INTO test VALUES (5, 3); +-- +ok +== +INSERT INTO test VALUES (9, 90); +-- +ok +== +INSERT INTO test VALUES (9, 99); +-- +ok +== diff --git a/parser/testdata/corpus/sql/storage/catalog/test_drop_table.test b/parser/testdata/corpus/sql/storage/catalog/test_drop_table.test new file mode 100644 index 0000000..860e5fa --- /dev/null +++ b/parser/testdata/corpus/sql/storage/catalog/test_drop_table.test @@ -0,0 +1,21 @@ +# source: test/sql/storage/catalog/test_drop_table.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +CREATE TABLE test.test (a INTEGER, b INTEGER); +-- +ok +== +INSERT INTO test.test VALUES (11, 22), (13, 22); +-- +ok +== +DROP TABLE test.test +-- +ok +== +DROP SCHEMA test +-- +ok +== diff --git a/parser/testdata/corpus/sql/storage/catalog/test_macro_storage.test b/parser/testdata/corpus/sql/storage/catalog/test_macro_storage.test new file mode 100644 index 0000000..c85ea87 --- /dev/null +++ b/parser/testdata/corpus/sql/storage/catalog/test_macro_storage.test @@ -0,0 +1,29 @@ +# source: test/sql/storage/catalog/test_macro_storage.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +CREATE MACRO plus1(a) AS a+1 +-- +ok +== +CREATE MACRO plus2(a, b := 2) AS a + b +-- +ok +== +SELECT plus2(3) +-- +ok +== +SELECT plus2(4) +-- +ok +== +CREATE MACRO addition(a) AS a, (a,b) AS a + b +-- +ok +== +SELECT addition(2), addition(1, 2) +-- +ok +== diff --git a/parser/testdata/corpus/sql/storage/catalog/test_not_distinct_from_default.test b/parser/testdata/corpus/sql/storage/catalog/test_not_distinct_from_default.test new file mode 100644 index 0000000..afea96a --- /dev/null +++ b/parser/testdata/corpus/sql/storage/catalog/test_not_distinct_from_default.test @@ -0,0 +1,17 @@ +# source: test/sql/storage/catalog/test_not_distinct_from_default.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +CREATE TABLE test_default (a BOOL DEFAULT nextval('seq') is not distinct from nextval('seq'), b INTEGER); +-- +ok +== +INSERT INTO test_default (b) VALUES (2), (4), (6); +-- +ok +== +select * from test_default; +-- +ok +== diff --git a/parser/testdata/corpus/sql/storage/catalog/test_not_null_constraint.test b/parser/testdata/corpus/sql/storage/catalog/test_not_null_constraint.test new file mode 100644 index 0000000..1e2eddc --- /dev/null +++ b/parser/testdata/corpus/sql/storage/catalog/test_not_null_constraint.test @@ -0,0 +1,9 @@ +# source: test/sql/storage/catalog/test_not_null_constraint.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +CREATE TABLE test(a INTEGER NOT NULL); +-- +ok +== diff --git a/parser/testdata/corpus/sql/storage/catalog/test_prepared_storage.test b/parser/testdata/corpus/sql/storage/catalog/test_prepared_storage.test new file mode 100644 index 0000000..228f9cc --- /dev/null +++ b/parser/testdata/corpus/sql/storage/catalog/test_prepared_storage.test @@ -0,0 +1,33 @@ +# source: test/sql/storage/catalog/test_prepared_storage.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +CREATE TABLE t (a INTEGER) +-- +ok +== +PREPARE p1 AS INSERT INTO t VALUES ($1) +-- +ok +== +EXECUTE p1(42) +-- +ok +== +EXECUTE p1(43) +-- +ok +== +SELECT a FROM t +-- +ok +== +PREPARE p1 AS DELETE FROM t WHERE a=$1 +-- +ok +== +PREPARE p1 AS UPDATE t SET a = $1 +-- +ok +== diff --git a/parser/testdata/corpus/sql/storage/catalog/test_store_add_column.test b/parser/testdata/corpus/sql/storage/catalog/test_store_add_column.test new file mode 100644 index 0000000..db5e4e5 --- /dev/null +++ b/parser/testdata/corpus/sql/storage/catalog/test_store_add_column.test @@ -0,0 +1,13 @@ +# source: test/sql/storage/catalog/test_store_add_column.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +SELECT k FROM test ORDER BY k +-- +ok +== +INSERT INTO test(a, b) VALUES (1, 1) +-- +ok +== diff --git a/parser/testdata/corpus/sql/storage/catalog/test_store_alter_type.test b/parser/testdata/corpus/sql/storage/catalog/test_store_alter_type.test new file mode 100644 index 0000000..92f2379 --- /dev/null +++ b/parser/testdata/corpus/sql/storage/catalog/test_store_alter_type.test @@ -0,0 +1,21 @@ +# source: test/sql/storage/catalog/test_store_alter_type.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +ALTER TABLE test ALTER b TYPE VARCHAR +-- +ok +== +INSERT INTO test VALUES (10, 'hello') +-- +ok +== +SELECT * FROM test WHERE b='hello' +-- +ok +== +DELETE FROM test WHERE b='hello' +-- +ok +== diff --git a/parser/testdata/corpus/sql/storage/catalog/test_store_default_sequence.test b/parser/testdata/corpus/sql/storage/catalog/test_store_default_sequence.test new file mode 100644 index 0000000..09daafe --- /dev/null +++ b/parser/testdata/corpus/sql/storage/catalog/test_store_default_sequence.test @@ -0,0 +1,33 @@ +# source: test/sql/storage/catalog/test_store_default_sequence.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +CREATE TABLE test (a INTEGER DEFAULT nextval('seq'), b INTEGER, c INTEGER DEFAULT currval('seq')); +-- +ok +== +INSERT INTO test (b) VALUES (11) +-- +ok +== +SELECT * FROM test ORDER BY b +-- +ok +== +INSERT INTO test (b) VALUES (12); +-- +ok +== +INSERT INTO test (b) VALUES (13); +-- +ok +== +INSERT INTO test (b) VALUES (14) +-- +ok +== +INSERT INTO test (b) VALUES (15) +-- +ok +== diff --git a/parser/testdata/corpus/sql/storage/catalog/test_store_defaults.test b/parser/testdata/corpus/sql/storage/catalog/test_store_defaults.test new file mode 100644 index 0000000..5844926 --- /dev/null +++ b/parser/testdata/corpus/sql/storage/catalog/test_store_defaults.test @@ -0,0 +1,13 @@ +# source: test/sql/storage/catalog/test_store_defaults.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +INSERT INTO test (b) VALUES (12), (13) +-- +ok +== +INSERT INTO test (b) VALUES (14), (15) +-- +ok +== diff --git a/parser/testdata/corpus/sql/storage/catalog/test_store_remove_column.test b/parser/testdata/corpus/sql/storage/catalog/test_store_remove_column.test new file mode 100644 index 0000000..1e1fe88 --- /dev/null +++ b/parser/testdata/corpus/sql/storage/catalog/test_store_remove_column.test @@ -0,0 +1,9 @@ +# source: test/sql/storage/catalog/test_store_remove_column.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +ALTER TABLE test DROP COLUMN b +-- +ok +== diff --git a/parser/testdata/corpus/sql/storage/catalog/test_store_rename_column.test b/parser/testdata/corpus/sql/storage/catalog/test_store_rename_column.test new file mode 100644 index 0000000..22d3b1d --- /dev/null +++ b/parser/testdata/corpus/sql/storage/catalog/test_store_rename_column.test @@ -0,0 +1,13 @@ +# source: test/sql/storage/catalog/test_store_rename_column.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +ALTER TABLE test RENAME COLUMN a TO k +-- +ok +== +SELECT a FROM test +-- +ok +== diff --git a/parser/testdata/corpus/sql/storage/catalog/test_store_rename_table.test b/parser/testdata/corpus/sql/storage/catalog/test_store_rename_table.test new file mode 100644 index 0000000..d9f9ca1 --- /dev/null +++ b/parser/testdata/corpus/sql/storage/catalog/test_store_rename_table.test @@ -0,0 +1,13 @@ +# source: test/sql/storage/catalog/test_store_rename_table.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +ALTER TABLE test RENAME TO new_name +-- +ok +== +SELECT a FROM new_name ORDER BY 1 +-- +ok +== diff --git a/parser/testdata/corpus/sql/storage/catalog/test_store_rename_view.test b/parser/testdata/corpus/sql/storage/catalog/test_store_rename_view.test new file mode 100644 index 0000000..564491d --- /dev/null +++ b/parser/testdata/corpus/sql/storage/catalog/test_store_rename_view.test @@ -0,0 +1,17 @@ +# source: test/sql/storage/catalog/test_store_rename_view.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +CREATE VIEW vtest AS SELECT * FROM test +-- +ok +== +SELECT a FROM vtest ORDER BY a +-- +ok +== +ALTER VIEW vtest RENAME TO new_name +-- +ok +== diff --git a/parser/testdata/corpus/sql/storage/catalog/test_store_sequences.test b/parser/testdata/corpus/sql/storage/catalog/test_store_sequences.test new file mode 100644 index 0000000..b8a5c75 --- /dev/null +++ b/parser/testdata/corpus/sql/storage/catalog/test_store_sequences.test @@ -0,0 +1,17 @@ +# source: test/sql/storage/catalog/test_store_sequences.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +CREATE SEQUENCE seq_cycle INCREMENT 1 MAXVALUE 3 START 2 CYCLE; +-- +ok +== +SELECT nextval('seq_cycle') +-- +ok +== +SELECT nextval('seq'), nextval('seq') +-- +ok +== diff --git a/parser/testdata/corpus/sql/storage/catalog/test_store_temporary.test b/parser/testdata/corpus/sql/storage/catalog/test_store_temporary.test new file mode 100644 index 0000000..0e36fc4 --- /dev/null +++ b/parser/testdata/corpus/sql/storage/catalog/test_store_temporary.test @@ -0,0 +1,57 @@ +# source: test/sql/storage/catalog/test_store_temporary.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +CREATE TABLE persistent (i INTEGER) +-- +ok +== +CREATE TEMPORARY TABLE temp.a (i INTEGER) +-- +ok +== +DELETE FROM temp.a +-- +ok +== +DELETE FROM asdf.a +-- +ok +== +CREATE TEMPORARY SEQUENCE seq2 +-- +ok +== +CREATE TEMPORARY VIEW v2 AS SELECT 42 +-- +ok +== +DROP VIEW v2 +-- +ok +== +INSERT INTO temp.a VALUES (43) +-- +ok +== +UPDATE temp.a SET i = 44 +-- +ok +== +UPDATE a SET i = 45 +-- +ok +== +ALTER TABLE a RENAME COLUMN i TO k +-- +ok +== +SELECT * FROM persistent +-- +ok +== +CREATE TEMPORARY TABLE a (i INTEGER) +-- +ok +== diff --git a/parser/testdata/corpus/sql/storage/catalog/test_table_macro_storage.test b/parser/testdata/corpus/sql/storage/catalog/test_table_macro_storage.test new file mode 100644 index 0000000..03012b6 --- /dev/null +++ b/parser/testdata/corpus/sql/storage/catalog/test_table_macro_storage.test @@ -0,0 +1,50 @@ +# source: test/sql/storage/catalog/test_table_macro_storage.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +CREATE TABLE test_tbl (id INT, name string, height double); +-- +ok +== +INSERT INTO test_tbl values (1,'tom', 1.1), (2,'dick',1.2),(3,'harry', 1.2), + (4,'mary',0.9), (5,'mungo', 0.8), (6,'midge', 0.5); +-- +ok +== +CREATE MACRO xt(a, _name) as TABLE SELECT * FROM test_tbl WHERE id<=a or name = _name; +-- +ok +== +SELECT * FROM xt(10, '*') ORDER BY height limit 1; +-- +ok +== +CREATE TEMPORARY MACRO my_seq(start , finish, stride:=3) as TABLE SELECT * FROM generate_series(start , finish , stride); +-- +ok +== +SELECT * FROM my_seq(0,6); +-- +ok +== +SELECT * FROM xt(100, 'joe'); +-- +ok +== +SELECT * from my_seq(0,10,2); +-- +ok +== +CREATE MACRO my_range(rend) AS TABLE SELECT * FROM range(rend); +-- +ok +== +SELECT * from my_range(2); +-- +ok +== +SELECT * FROM my_seq(0,3,2); +-- +ok +== diff --git a/parser/testdata/corpus/sql/storage/catalog/test_view_explicit_aliases.test b/parser/testdata/corpus/sql/storage/catalog/test_view_explicit_aliases.test new file mode 100644 index 0000000..0d9d2f0 --- /dev/null +++ b/parser/testdata/corpus/sql/storage/catalog/test_view_explicit_aliases.test @@ -0,0 +1,21 @@ +# source: test/sql/storage/catalog/test_view_explicit_aliases.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +CREATE VIEW test.v (b,c) AS SELECT * FROM test.t; +-- +ok +== +PRAGMA table_info('test.v') +-- +ok +== +SELECT * FROM test.t +-- +ok +== +SELECT b,c FROM test.v +-- +ok +== diff --git a/parser/testdata/corpus/sql/storage/catalog/test_view_storage.test b/parser/testdata/corpus/sql/storage/catalog/test_view_storage.test new file mode 100644 index 0000000..2ca16ff --- /dev/null +++ b/parser/testdata/corpus/sql/storage/catalog/test_view_storage.test @@ -0,0 +1,9 @@ +# source: test/sql/storage/catalog/test_view_storage.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +CREATE VIEW test.v AS SELECT * FROM test.t; +-- +ok +== diff --git a/parser/testdata/corpus/sql/storage/checkpoint/checkpoint_in_transaction.test b/parser/testdata/corpus/sql/storage/checkpoint/checkpoint_in_transaction.test new file mode 100644 index 0000000..39b6a91 --- /dev/null +++ b/parser/testdata/corpus/sql/storage/checkpoint/checkpoint_in_transaction.test @@ -0,0 +1,41 @@ +# source: test/sql/storage/checkpoint/checkpoint_in_transaction.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +SET wal_autocheckpoint='100GB' +-- +ok +== +ATTACH '{TEST_DIR}/checkpoint_in_transaction.db' AS db +-- +ok +== +CREATE TABLE db.t(a INTEGER) +-- +ok +== +INSERT INTO db.t VALUES (1) +-- +ok +== +SELECT * FROM db.t +-- +ok +== +INSERT INTO db.t VALUES (2) +-- +ok +== +CHECKPOINT db +-- +ok +== +INSERT INTO db.t VALUES (3) +-- +ok +== +SELECT * FROM db.t ORDER BY a +-- +ok +== diff --git a/parser/testdata/corpus/sql/storage/checkpoint/checkpoint_with_outstanding_insertions.test b/parser/testdata/corpus/sql/storage/checkpoint/checkpoint_with_outstanding_insertions.test new file mode 100644 index 0000000..bec465a --- /dev/null +++ b/parser/testdata/corpus/sql/storage/checkpoint/checkpoint_with_outstanding_insertions.test @@ -0,0 +1,33 @@ +# source: test/sql/storage/checkpoint/checkpoint_with_outstanding_insertions.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +create or replace table z(id integer); +-- +ok +== +insert into z from range(200_000); +-- +ok +== +set checkpoint_threshold='1TB' +-- +ok +== +set immediate_transaction_mode=true +-- +ok +== +begin +-- +ok +== +insert into z from range(200_000, 400_000) +-- +ok +== +select min(id), max(id) from z; +-- +ok +== diff --git a/parser/testdata/corpus/sql/storage/checkpoint/indexed_table_delete_insert_fragmentation.test b/parser/testdata/corpus/sql/storage/checkpoint/indexed_table_delete_insert_fragmentation.test new file mode 100644 index 0000000..190c547 --- /dev/null +++ b/parser/testdata/corpus/sql/storage/checkpoint/indexed_table_delete_insert_fragmentation.test @@ -0,0 +1,57 @@ +# source: test/sql/storage/checkpoint/indexed_table_delete_insert_fragmentation.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +ATTACH '{TEST_DIR}/test_rowgroup_append_mode_on_fragmented_tables.db' as snap (READ_WRITE, STORAGE_VERSION 'v1.5.0', ROW_GROUP_SIZE 2048); +-- +ok +== +CREATE OR REPLACE TABLE snap.snapshot(pk BIGINT PRIMARY KEY, val1 VARCHAR, val2 VARCHAR); +-- +ok +== +INSERT INTO snap.snapshot SELECT pk, uuid()::VARCHAR as val1, uuid()::VARCHAR as val2 FROM generate_series(1, 4096) t(pk); +-- +ok +== +CHECKPOINT snap; +-- +ok +== +DETACH snap; +-- +ok +== +CREATE OR REPLACE TABLE novelty_deletes AS SELECT pk FROM generate_series(1, 4096 + {i} * 2 * {novelty_multiplier}) t(pk) ORDER BY random() LIMIT 8 * {novelty_multiplier}; +-- +error: Parser Error: syntax error at or near "}" +== +CREATE OR REPLACE TABLE novelty_inserts AS SELECT pk, uuid()::VARCHAR as val1, uuid()::VARCHAR as val2 FROM novelty_deletes; +-- +ok +== +INSERT INTO novelty_inserts SELECT pk, uuid()::VARCHAR, uuid()::VARCHAR FROM generate_series(4096 + {i} * 2 * {novelty_multiplier} + 1, 4096 + {i} * 2 * {novelty_multiplier} + 2 * {novelty_multiplier}) t(pk) +-- +error: Parser Error: syntax error at or near "}" +== +ATTACH '{TEST_DIR}/test_rowgroup_append_mode_on_fragmented_tables.db' as snap (READ_WRITE, RECOVERY_MODE NO_WAL_WRITES, STORAGE_VERSION 'v1.5.0', ROW_GROUP_SIZE 2048); +-- +ok +== +DELETE FROM snap.snapshot WHERE pk IN (SELECT pk FROM novelty_deletes); +-- +ok +== +INSERT INTO snap.snapshot SELECT * FROM novelty_inserts; +-- +ok +== +ATTACH '{TEST_DIR}/test_rowgroup_append_mode_on_fragmented_tables.db' as snap; +-- +ok +== +SELECT COUNT(DISTINCT row_group_id) <= CEIL((4096 + 100 * {novelty_multiplier}) / 2048) FROM pragma_storage_info('snap.snapshot'); +-- +error: Parser Error: syntax error at or near "}" +== diff --git a/parser/testdata/corpus/sql/storage/checkpoint/initial_database_autocheckpoint_failure.test b/parser/testdata/corpus/sql/storage/checkpoint/initial_database_autocheckpoint_failure.test new file mode 100644 index 0000000..500d895 --- /dev/null +++ b/parser/testdata/corpus/sql/storage/checkpoint/initial_database_autocheckpoint_failure.test @@ -0,0 +1,9 @@ +# source: test/sql/storage/checkpoint/initial_database_autocheckpoint_failure.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +PRAGMA debug_checkpoint_abort = 'before_header'; +-- +ok +== diff --git a/parser/testdata/corpus/sql/storage/checkpoint/test_checkpoint_failure_delayed_commit.test b/parser/testdata/corpus/sql/storage/checkpoint/test_checkpoint_failure_delayed_commit.test new file mode 100644 index 0000000..f44d147 --- /dev/null +++ b/parser/testdata/corpus/sql/storage/checkpoint/test_checkpoint_failure_delayed_commit.test @@ -0,0 +1,17 @@ +# source: test/sql/storage/checkpoint/test_checkpoint_failure_delayed_commit.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +ATTACH '{TEST_DIR}/fail_detach_delayed' AS db; +-- +ok +== +CREATE TABLE db.integers AS SELECT * FROM range(100) tbl(i); +-- +ok +== +INSERT INTO db.integers VALUES (42); +-- +ok +== diff --git a/parser/testdata/corpus/sql/storage/checkpoint/test_checkpoint_failure_on_detach.test b/parser/testdata/corpus/sql/storage/checkpoint/test_checkpoint_failure_on_detach.test new file mode 100644 index 0000000..b5492b5 --- /dev/null +++ b/parser/testdata/corpus/sql/storage/checkpoint/test_checkpoint_failure_on_detach.test @@ -0,0 +1,17 @@ +# source: test/sql/storage/checkpoint/test_checkpoint_failure_on_detach.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +ATTACH '{TEST_DIR}/fail_detach'; +-- +ok +== +CREATE TABLE fail_detach.integers AS SELECT * FROM range(100) tbl(i); +-- +ok +== +DETACH fail_detach; +-- +ok +== diff --git a/parser/testdata/corpus/sql/storage/checkpointed_self_append.test b/parser/testdata/corpus/sql/storage/checkpointed_self_append.test new file mode 100644 index 0000000..738df23 --- /dev/null +++ b/parser/testdata/corpus/sql/storage/checkpointed_self_append.test @@ -0,0 +1,21 @@ +# source: test/sql/storage/checkpointed_self_append.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +CREATE TABLE vals(i INTEGER) +-- +ok +== +INSERT INTO vals SELECT CASE WHEN i % 2 = 0 THEN NULL ELSE i END FROM range(200000) tbl(i) +-- +ok +== +SELECT MIN(i), MAX(i), COUNT(i), COUNT(*) FROM vals +-- +ok +== +INSERT INTO vals SELECT * FROM vals; +-- +ok +== diff --git a/parser/testdata/corpus/sql/storage/checkpointed_self_append_tinyint.test b/parser/testdata/corpus/sql/storage/checkpointed_self_append_tinyint.test new file mode 100644 index 0000000..2a80dde --- /dev/null +++ b/parser/testdata/corpus/sql/storage/checkpointed_self_append_tinyint.test @@ -0,0 +1,13 @@ +# source: test/sql/storage/checkpointed_self_append_tinyint.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +CREATE TABLE vals(i TINYINT) +-- +ok +== +INSERT INTO vals SELECT (CASE WHEN i % 2 = 0 THEN NULL ELSE i % 100 END)::TINYINT i FROM range(200000) tbl(i) +-- +ok +== diff --git a/parser/testdata/corpus/sql/storage/commit_abort.test b/parser/testdata/corpus/sql/storage/commit_abort.test new file mode 100644 index 0000000..076f00b --- /dev/null +++ b/parser/testdata/corpus/sql/storage/commit_abort.test @@ -0,0 +1,37 @@ +# source: test/sql/storage/commit_abort.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +CREATE TABLE test (a INTEGER PRIMARY KEY, b INTEGER, c VARCHAR); +-- +ok +== +INSERT INTO test VALUES (11, 22, 'hello'), (13, 22, 'world'), (12, 21, 'test'), (10, NULL, NULL); +-- +ok +== +INSERT INTO test VALUES (14, 10, 'con') +-- +ok +== +INSERT INTO test VALUES (15, 10, 'con2') +-- +ok +== +INSERT INTO test VALUES (14, 10, 'con2') +-- +ok +== +INSERT INTO test VALUES (15, NULL, NULL) +-- +ok +== +SELECT COUNT(*), COUNT(a), COUNT(b), SUM(a), SUM(b), SUM(LENGTH(c)) FROM test +-- +ok +== +SELECT * FROM test ORDER BY a, b, c +-- +ok +== diff --git a/parser/testdata/corpus/sql/storage/commit_abort_medium.test b/parser/testdata/corpus/sql/storage/commit_abort_medium.test new file mode 100644 index 0000000..0ebcefe --- /dev/null +++ b/parser/testdata/corpus/sql/storage/commit_abort_medium.test @@ -0,0 +1,13 @@ +# source: test/sql/storage/commit_abort_medium.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +INSERT INTO test SELECT i, NULL, NULL FROM range(15, 10000) tbl(i); +-- +ok +== +INSERT INTO test VALUES (16, 24, 'blabla') +-- +ok +== diff --git a/parser/testdata/corpus/sql/storage/commit_index_deletes.test b/parser/testdata/corpus/sql/storage/commit_index_deletes.test new file mode 100644 index 0000000..2f8a733 --- /dev/null +++ b/parser/testdata/corpus/sql/storage/commit_index_deletes.test @@ -0,0 +1,13 @@ +# source: test/sql/storage/commit_index_deletes.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +DELETE FROM test WHERE a=14 +-- +ok +== +INSERT INTO test VALUES (14, 11, 'bla') +-- +ok +== diff --git a/parser/testdata/corpus/sql/storage/compact_block_size/block_size_with_rollback.test b/parser/testdata/corpus/sql/storage/compact_block_size/block_size_with_rollback.test new file mode 100644 index 0000000..015e9a5 --- /dev/null +++ b/parser/testdata/corpus/sql/storage/compact_block_size/block_size_with_rollback.test @@ -0,0 +1,17 @@ +# source: test/sql/storage/compact_block_size/block_size_with_rollback.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +ATTACH '{TEST_DIR}/rollback.db' (BLOCK_SIZE 16384); +-- +ok +== +CREATE TABLE rollback.tbl AS SELECT range AS i FROM range(100); +-- +ok +== +ATTACH '{TEST_DIR}/rollback.db' (BLOCK_SIZE 262144); +-- +ok +== diff --git a/parser/testdata/corpus/sql/storage/compact_block_size/compact_block_size.test b/parser/testdata/corpus/sql/storage/compact_block_size/compact_block_size.test new file mode 100644 index 0000000..639b228 --- /dev/null +++ b/parser/testdata/corpus/sql/storage/compact_block_size/compact_block_size.test @@ -0,0 +1,17 @@ +# source: test/sql/storage/compact_block_size/compact_block_size.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +ATTACH '{DATA_DIR}/storage/index_0-9-1.db' (TYPE DUCKDB, READONLY); +-- +ok +== +ATTACH '{DATA_DIR}/storage/block_size_16kb.db' (TYPE DUCKDB, READONLY); +-- +ok +== +SELECT * FROM block_size_16kb.tbl; +-- +ok +== diff --git a/parser/testdata/corpus/sql/storage/compact_block_size/compact_vector_size.test b/parser/testdata/corpus/sql/storage/compact_block_size/compact_vector_size.test new file mode 100644 index 0000000..76efd2a --- /dev/null +++ b/parser/testdata/corpus/sql/storage/compact_block_size/compact_vector_size.test @@ -0,0 +1,13 @@ +# source: test/sql/storage/compact_block_size/compact_vector_size.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +ATTACH '{DATA_DIR}/storage/vector_size_512.db' (TYPE DUCKDB, READONLY); +-- +ok +== +SELECT * FROM vector_size_512.tbl; +-- +ok +== diff --git a/parser/testdata/corpus/sql/storage/compact_block_size/create_table_compression.test b/parser/testdata/corpus/sql/storage/compact_block_size/create_table_compression.test new file mode 100644 index 0000000..fc43581 --- /dev/null +++ b/parser/testdata/corpus/sql/storage/compact_block_size/create_table_compression.test @@ -0,0 +1,15 @@ +# source: test/sql/storage/compact_block_size/create_table_compression.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +SELECT COUNT(*) > 0 FROM pragma_storage_info('T') +WHERE segment_type ILIKE 'INTEGER' AND compression = 'RLE'; +-- +ok +== +SELECT COUNT(*) > 0 FROM pragma_storage_info('T_1') +WHERE segment_type ILIKE 'INTEGER' AND compression = 'RLE'; +-- +ok +== diff --git a/parser/testdata/corpus/sql/storage/compact_block_size/default_block_size.test b/parser/testdata/corpus/sql/storage/compact_block_size/default_block_size.test new file mode 100644 index 0000000..412e701 --- /dev/null +++ b/parser/testdata/corpus/sql/storage/compact_block_size/default_block_size.test @@ -0,0 +1,13 @@ +# source: test/sql/storage/compact_block_size/default_block_size.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +ATTACH '{DATA_DIR}/storage/block_size_16kb.db' (TYPE DUCKDB, READONLY) +-- +ok +== +ATTACH '{DATA_DIR}/storage/vector_size_512.db' (TYPE DUCKDB, READONLY) +-- +ok +== diff --git a/parser/testdata/corpus/sql/storage/compact_block_size/ensure_bitpacking.test b/parser/testdata/corpus/sql/storage/compact_block_size/ensure_bitpacking.test new file mode 100644 index 0000000..faed8b1 --- /dev/null +++ b/parser/testdata/corpus/sql/storage/compact_block_size/ensure_bitpacking.test @@ -0,0 +1,33 @@ +# source: test/sql/storage/compact_block_size/ensure_bitpacking.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +ATTACH '{TEST_DIR}/smaller_block_size.db' (BLOCK_SIZE 16384); +-- +ok +== +CREATE TABLE smaller_block_size.tbl AS SELECT range AS i FROM range(10000); +-- +ok +== +ATTACH '{TEST_DIR}/larger_block_size.db' (BLOCK_SIZE 262144); +-- +ok +== +CREATE TABLE larger_block_size.tbl AS SELECT range AS i FROM range(10000); +-- +ok +== +CHECKPOINT smaller_block_size; +-- +ok +== +CHECKPOINT larger_block_size; +-- +ok +== +SELECT COUNT(*) > 0 FROM pragma_storage_info('larger_block_size.tbl') WHERE compression = 'BitPacking'; +-- +ok +== diff --git a/parser/testdata/corpus/sql/storage/compact_block_size/ensure_no_bitpacking.test b/parser/testdata/corpus/sql/storage/compact_block_size/ensure_no_bitpacking.test new file mode 100644 index 0000000..baadb0b --- /dev/null +++ b/parser/testdata/corpus/sql/storage/compact_block_size/ensure_no_bitpacking.test @@ -0,0 +1,33 @@ +# source: test/sql/storage/compact_block_size/ensure_no_bitpacking.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +ATTACH '{TEST_DIR}/no_bitpacking.db' (BLOCK_SIZE 16384); +-- +ok +== +CREATE TABLE no_bitpacking.tbl AS SELECT range AS i FROM range(10000); +-- +ok +== +ATTACH '{TEST_DIR}/has_bitpacking.db' (BLOCK_SIZE 262144); +-- +ok +== +CREATE TABLE has_bitpacking.tbl AS SELECT range AS i FROM range(10000); +-- +ok +== +CHECKPOINT has_bitpacking; +-- +ok +== +CHECKPOINT no_bitpacking; +-- +ok +== +SELECT COUNT(*) FROM pragma_storage_info('no_bitpacking.tbl') WHERE compression = 'BitPacking'; +-- +ok +== diff --git a/parser/testdata/corpus/sql/storage/compact_block_size/insertion_order_odd_batches.test b/parser/testdata/corpus/sql/storage/compact_block_size/insertion_order_odd_batches.test new file mode 100644 index 0000000..09ad0ea --- /dev/null +++ b/parser/testdata/corpus/sql/storage/compact_block_size/insertion_order_odd_batches.test @@ -0,0 +1,53 @@ +# source: test/sql/storage/compact_block_size/insertion_order_odd_batches.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +CREATE TABLE integers AS SELECT * FROM range(100000) tbl(i); +-- +ok +== +SELECT COUNT(DISTINCT block_id) < 60 FROM pragma_storage_info('integers'); +-- +ok +== +SELECT MEDIAN(count) FROM pragma_storage_info('integers'); +-- +ok +== +COPY integers TO '{TEST_DIR}/integers.parquet' (ROW_GROUP_SIZE 777) +-- +ok +== +CREATE TABLE integers_parquet AS FROM '{TEST_DIR}/integers.parquet'; +-- +ok +== +SELECT * FROM integers_parquet LIMIT 5 +-- +ok +== +SELECT * FROM integers_parquet LIMIT 5 OFFSET 73654 +-- +ok +== +SELECT COUNT(DISTINCT block_id) < 60 FROM pragma_storage_info('integers_parquet'); +-- +ok +== +SELECT MEDIAN(count) FROM pragma_storage_info('integers_parquet'); +-- +ok +== +CREATE TABLE integers_parquet_no_order AS FROM '{TEST_DIR}/integers.parquet' +-- +ok +== +SELECT COUNT(DISTINCT block_id) < 60 FROM pragma_storage_info('integers_parquet_no_order'); +-- +ok +== +SELECT MEDIAN(count) FROM pragma_storage_info('integers_parquet_no_order'); +-- +ok +== diff --git a/parser/testdata/corpus/sql/storage/compact_block_size/mixed_block_sizes.test b/parser/testdata/corpus/sql/storage/compact_block_size/mixed_block_sizes.test new file mode 100644 index 0000000..53fcdc3 --- /dev/null +++ b/parser/testdata/corpus/sql/storage/compact_block_size/mixed_block_sizes.test @@ -0,0 +1,26 @@ +# source: test/sql/storage/compact_block_size/mixed_block_sizes.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +ATTACH '{TEST_DIR}/small.db' (BLOCK_SIZE 16384); +-- +ok +== +CREATE TABLE small.tbl AS SELECT range AS i FROM range(10000); +-- +ok +== +ATTACH '{TEST_DIR}/large.db' (BLOCK_SIZE 262144); +-- +ok +== +CREATE TABLE large.tbl AS SELECT range AS i FROM range(10000); +-- +ok +== +SELECT list_sum(LIST(t1.i) || LIST(t2.i)) +FROM large.tbl AS t1 JOIN small.tbl AS t2 ON t1.i = t2.i; +-- +ok +== diff --git a/parser/testdata/corpus/sql/storage/compression/alp/alp_corrupted_exception_position.test b/parser/testdata/corpus/sql/storage/compression/alp/alp_corrupted_exception_position.test new file mode 100644 index 0000000..74cdcb8 --- /dev/null +++ b/parser/testdata/corpus/sql/storage/compression/alp/alp_corrupted_exception_position.test @@ -0,0 +1,17 @@ +# source: test/sql/storage/compression/alp/alp_corrupted_exception_position.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +ATTACH '{TEST_DIR}/alp_corrupt_exception_position.db' AS db2 +-- +ok +== +SELECT compression FROM pragma_storage_info('two_alp') WHERE compression='ALP'; +-- +ok +== +SELECT * FROM two_alp LIMIT 1; +-- +ok +== diff --git a/parser/testdata/corpus/sql/storage/compression/alp/alp_corrupted_file.test b/parser/testdata/corpus/sql/storage/compression/alp/alp_corrupted_file.test new file mode 100644 index 0000000..4b62fe0 --- /dev/null +++ b/parser/testdata/corpus/sql/storage/compression/alp/alp_corrupted_file.test @@ -0,0 +1,17 @@ +# source: test/sql/storage/compression/alp/alp_corrupted_file.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +ATTACH '{TEST_DIR}/alp_corrupted.db' AS db2 +-- +ok +== +SELECT compression FROM pragma_storage_info('alp') WHERE compression='ALP'; +-- +ok +== +SELECT * FROM alp LIMIT 1; +-- +ok +== diff --git a/parser/testdata/corpus/sql/storage/compression/alp/alp_corrupted_offsets.test b/parser/testdata/corpus/sql/storage/compression/alp/alp_corrupted_offsets.test new file mode 100644 index 0000000..36c83ff --- /dev/null +++ b/parser/testdata/corpus/sql/storage/compression/alp/alp_corrupted_offsets.test @@ -0,0 +1,17 @@ +# source: test/sql/storage/compression/alp/alp_corrupted_offsets.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +ATTACH '{TEST_DIR}/alp_corrupted_offsets.db' AS db2 +-- +ok +== +SELECT compression FROM pragma_storage_info('random_alp_double') WHERE compression='ALP'; +-- +ok +== +SELECT * FROM random_alp_double LIMIT 1; +-- +ok +== diff --git a/parser/testdata/corpus/sql/storage/compression/alp/alp_corrupted_vector_size.test b/parser/testdata/corpus/sql/storage/compression/alp/alp_corrupted_vector_size.test new file mode 100644 index 0000000..bd84a5f --- /dev/null +++ b/parser/testdata/corpus/sql/storage/compression/alp/alp_corrupted_vector_size.test @@ -0,0 +1,9 @@ +# source: test/sql/storage/compression/alp/alp_corrupted_vector_size.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +ATTACH '{TEST_DIR}/alp_corrupt_vector_size.db' AS db2 +-- +ok +== diff --git a/parser/testdata/corpus/sql/storage/compression/alp/alp_inf_null_nan.test b/parser/testdata/corpus/sql/storage/compression/alp/alp_inf_null_nan.test new file mode 100644 index 0000000..c311a1d --- /dev/null +++ b/parser/testdata/corpus/sql/storage/compression/alp/alp_inf_null_nan.test @@ -0,0 +1,316 @@ +# source: test/sql/storage/compression/alp/alp_inf_null_nan.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +pragma force_compression='{compression}' +-- +ok +== +create table tbl1_{compression}( + a INTEGER DEFAULT 5, + b VARCHAR DEFAULT 'test', + c BOOL DEFAULT false, + d DOUBLE, + e TEXT default 'null', + f FLOAT +); +-- +error: Parser Error: syntax error at or near "{" +== +create table tbl2_{compression}( + a INTEGER DEFAULT 5, + b VARCHAR DEFAULT 'test', + c BOOL DEFAULT false, + d DOUBLE, + e TEXT default 'null', + f FLOAT +); +-- +error: Parser Error: syntax error at or near "{" +== +create table tbl3_{compression}( + a INTEGER DEFAULT 5, + b VARCHAR DEFAULT 'test', + c BOOL DEFAULT false, + d DOUBLE, + e TEXT default 'null', + f FLOAT +); +-- +error: Parser Error: syntax error at or near "{" +== +insert into tbl1_{compression}(d,f) VALUES +('Infinity', 'Infinity'), +('Infinity', 'Infinity'), +('Infinity', 'Infinity'), +('Infinity', 'Infinity'), +('Infinity', 'Infinity'), +('Infinity', 'Infinity'), +('Infinity', 'Infinity'), +('Infinity', 'Infinity'), +('Infinity', 'Infinity'), +('Infinity', 'Infinity'), +('Infinity', 'Infinity'), +('Infinity', 'Infinity'), +('Infinity', 'Infinity'), +('Infinity', 'Infinity'), +('Infinity', 'Infinity'), +('Infinity', 'Infinity'), +('Infinity', 'Infinity'), +('Infinity', 'Infinity'), +('Infinity', 'Infinity'), +('Infinity', 'Infinity'), +('Infinity', 'Infinity'), +('Infinity', 'Infinity'), +('Infinity', 'Infinity'), +('Infinity', 'Infinity'), +('Infinity', 'Infinity'), +('Infinity', 'Infinity'), +('Infinity', 'Infinity'), +('Infinity', 'Infinity'), +('Infinity', 'Infinity'), +('Infinity', 'Infinity'), +('Infinity', 'Infinity'), +('Infinity', 'Infinity'), +('Infinity', 'Infinity'), +('Infinity', 'Infinity'), +('Infinity', 'Infinity'), +('Infinity', 'Infinity'), +('Infinity', 'Infinity'), +('Infinity', 'Infinity'), +('Infinity', 'Infinity'), +('Infinity', 'Infinity'), +('Infinity', 'Infinity'), +('Infinity', 'Infinity'), +('Infinity', 'Infinity'), +('Infinity', 'Infinity'), +('Infinity', 'Infinity'), +('Infinity', 'Infinity'), +('Infinity', 'Infinity'), +('Infinity', 'Infinity'), +('Infinity', 'Infinity'), +('Infinity', 'Infinity'), +('Infinity', 'Infinity'), +('Infinity', 'Infinity'), +('Infinity', 'Infinity'), +('Infinity', 'Infinity'), +('Infinity', 'Infinity'), +('Infinity', 'Infinity'), +('Infinity', 'Infinity'), +('Infinity', 'Infinity'), +('Infinity', 'Infinity'), +('Infinity', 'Infinity'), +('Infinity', 'Infinity'), +('Infinity', 'Infinity'), +('Infinity', 'Infinity'), +('Infinity', 'Infinity'), +('Infinity', 'Infinity'), +('Infinity', 'Infinity'), +('Infinity', 'Infinity'), +('Infinity', 'Infinity'), +('Infinity', 'Infinity'), +('Infinity', 'Infinity'), +('Infinity', 'Infinity'), +('Infinity', 'Infinity'); +-- +error: Parser Error: syntax error at or near "{" +== +insert into tbl2_{compression}(d,f) VALUES +(NULL, NULL), +('Infinity', 'Infinity'), +('Infinity', 'Infinity'), +('Infinity', 'Infinity'), +('Infinity', 'Infinity'), +('Infinity', 'Infinity'), +('Infinity', 'Infinity'), +('Infinity', 'Infinity'), +('Infinity', 'Infinity'), +('Infinity', '-Infinity'), +('Infinity', '-Infinity'), +('Infinity', '-Infinity'), +('Infinity', '-Infinity'), +('Infinity', '-Infinity'), +('-Infinity', '-Infinity'), +('-Infinity', '-Infinity'), +('-Infinity', '-Infinity'), +('-Infinity', '-Infinity'), +('-Infinity', '-Infinity'), +('-Infinity', '-Infinity'), +(0, 0), +(NULL, NULL), +(NULL, NULL), +(NULL, NULL), +(NULL, NULL), +(NULL, NULL), +(NULL, NULL), +(NULL, NULL), +(NULL, NULL), +(NULL, NULL), +(NULL, NULL), +(NULL, NULL), +(NULL, NULL), +(NULL, NULL), +(NULL, NULL), +(NULL, NULL), +(NULL, NULL), +(NULL, NULL), +(NULL, NULL), +(NULL, NULL), +(NULL, NULL), +(NULL, NULL), +(NULL, NULL), +(NULL, NULL), +(NULL, NULL), +(NULL, NULL), +(NULL, NULL), +(NULL, NULL), +(NULL, NULL), +(NULL, NULL), +(NULL, NULL), +(NULL, NULL), +(NULL, NULL), +(NULL, NULL), +(NULL, NULL), +(NULL, NULL), +(NULL, NULL), +(NULL, NULL), +(NULL, NULL), +(NULL, NULL), +(NULL, NULL), +(NULL, NULL), +(NULL, NULL), +(NULL, NULL), +(NULL, NULL), +(NULL, NULL), +(NULL, NULL), +(NULL, NULL), +(NULL, NULL), +(NULL, NULL), +(NULL, NULL), +(NULL, NULL), +(NULL, NULL); +-- +error: Parser Error: syntax error at or near "{" +== +insert into tbl3_{compression}(d,f) VALUES +(NULL, NULL), +(NULL, NULL), +(NULL, NULL), +(NULL, NULL), +(NULL, NULL), +(NULL, NULL), +(NULL, NULL), +(NULL, NULL), +(7034.34968234, 93472948.98034), +(1.213123, 1.232142), +(7034.34968234, 93472948.98034), +(7034.34968234, 93472948.98034), +(1.213123, 1.232142), +(7034.34968234, 93472948.98034), +(7034.34968234, 93472948.98034), +(1.213123, 1.232142), +(7034.34968234, 93472948.98034), +(7034.34968234, 93472948.98034), +(1.213123, 1.232142), +(7034.34968234, 93472948.98034), +(7034.34968234, 93472948.98034), +(1.213123, 1.232142), +(7034.34968234, 93472948.98034), +(7034.34968234, 93472948.98034), +(1.213123, 1.232142), +(7034.34968234, 93472948.98034), +(7034.34968234, 93472948.98034), +('-Infinity', '-Infinity'), +(7034.34968234, 93472948.98034), +(7034.34968234, 93472948.98034), +('-Infinity', '-Infinity'), +(7034.34968234, 93472948.98034), +(7034.34968234, 93472948.98034), +('-Infinity', '-Infinity'), +(7034.34968234, 93472948.98034), +(7034.34968234, 93472948.98034), +('-Infinity', '-Infinity'), +(7034.34968234, 93472948.98034), +(7034.34968234, 93472948.98034), +('-Infinity', '-Infinity'), +(7034.34968234, 93472948.98034), +(7034.34968234, 93472948.98034), +('-Infinity', 'Infinity'), +(7034.34968234, 93472948.98034), +(7034.34968234, 93472948.98034), +('-Infinity', 'Infinity'), +(7034.34968234, 93472948.98034), +(7034.34968234, 93472948.98034), +('-Infinity', 'Infinity'), +(7034.34968234, 93472948.98034), +(7034.34968234, 93472948.98034), +('-Infinity', 'Infinity'), +(7034.34968234, 93472948.98034), +(7034.34968234, 93472948.98034), +('Infinity', 'Infinity'), +(7034.34968234, 93472948.98034), +(7034.34968234, 93472948.98034), +('Infinity', 'Infinity'), +(7034.34968234, 93472948.98034), +(7034.34968234, 93472948.98034), +('Infinity', 'Infinity'), +(7034.34968234, 93472948.98034), +(7034.34968234, 93472948.98034), +('Infinity', 'Infinity'), +(7034.34968234, 93472948.98034), +(7034.34968234, 93472948.98034), +('Infinity', 'Infinity'), +(7034.34968234, 93472948.98034), +(7034.34968234, 93472948.98034), +('Infinity', 'Infinity'), +(7034.34968234, 93472948.98034), +(7034.34968234, 93472948.98034), +(NULL, NULL), +(7034.34968234, 93472948.98034), +(7034.34968234, 93472948.98034), +(1.213123, 1.232142), +(7034.34968234, 93472948.98034), +(7034.34968234, 93472948.98034), +(1.213123, 1.232142), +(7034.34968234, 93472948.98034), +(7034.34968234, 93472948.98034), +(1.213123, 1.232142), +(7034.34968234, 93472948.98034), +(7034.34968234, 93472948.98034), +(1.213123, 1.232142), +(7034.34968234, 93472948.98034), +(7034.34968234, 93472948.98034), +(1.213123, 1.232142), +(7034.34968234, 93472948.98034), +(7034.34968234, 93472948.98034), +('NaN', 'NaN'), +('NaN', 'NaN'), +('NaN', 'NaN'); +-- +error: Parser Error: syntax error at or near "{" +== +select d, f from tbl1_uncompressed; +-- +ok +== +select d, f from tbl1_alp; +-- +ok +== +select d, f from tbl2_uncompressed; +-- +ok +== +select d, f from tbl2_alp; +-- +ok +== +select d, f from tbl3_uncompressed; +-- +ok +== +select d, f from tbl3_alp; +-- +ok +== diff --git a/parser/testdata/corpus/sql/storage/compression/alp/alp_list_skip.test b/parser/testdata/corpus/sql/storage/compression/alp/alp_list_skip.test new file mode 100644 index 0000000..6470ad0 --- /dev/null +++ b/parser/testdata/corpus/sql/storage/compression/alp/alp_list_skip.test @@ -0,0 +1,17 @@ +# source: test/sql/storage/compression/alp/alp_list_skip.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +SET force_compression='{comp}' +-- +ok +== +create or replace table list_doubles as select 5700 i, [5700.0] l UNION ALL select i, CASE WHEN i%128=0 THEN [i::DOUBLE] ELSE []::DOUBLE[] END as data from range(10000) tbl(i) union all select 5700, [i] FROM range(100) tbl(i); +-- +ok +== +SELECT * FROM list_doubles WHERE i=5700 +-- +ok +== diff --git a/parser/testdata/corpus/sql/storage/compression/alp/alp_min_max.test b/parser/testdata/corpus/sql/storage/compression/alp/alp_min_max.test new file mode 100644 index 0000000..afac455 --- /dev/null +++ b/parser/testdata/corpus/sql/storage/compression/alp/alp_min_max.test @@ -0,0 +1,25 @@ +# source: test/sql/storage/compression/alp/alp_min_max.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +PRAGMA force_compression='alp'; +-- +ok +== +CREATE TABLE all_types AS SELECT {type} FROM test_all_types(); +-- +error: Parser Error: syntax error at or near "}" +== +INSERT INTO all_types SELECT {type} FROM all_types; +-- +error: Parser Error: syntax error at or near "}" +== +SELECT compression FROM pragma_storage_info('all_types') WHERE segment_type == '{type}' AND compression != 'ALP'; +-- +ok +== +DROP TABLE all_types; +-- +ok +== diff --git a/parser/testdata/corpus/sql/storage/compression/alp/alp_negative_numbers.test b/parser/testdata/corpus/sql/storage/compression/alp/alp_negative_numbers.test new file mode 100644 index 0000000..419a4b5 --- /dev/null +++ b/parser/testdata/corpus/sql/storage/compression/alp/alp_negative_numbers.test @@ -0,0 +1,38 @@ +# source: test/sql/storage/compression/alp/alp_negative_numbers.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +PRAGMA force_compression='uncompressed' +-- +ok +== +create table random_double as select round(cos(1 / (random() + 0.001)), 5)::DOUBLE * -1 as data from range(1023) tbl(i); +insert into random_double values (-0.0::DOUBLE); +-- +ok +== +SELECT compression FROM pragma_storage_info('random_double') WHERE segment_type == 'double' AND compression != 'Uncompressed'; +-- +ok +== +PRAGMA force_compression='alp' +-- +ok +== +create table random_alp_double as select * from random_double; +-- +ok +== +SELECT compression FROM pragma_storage_info('random_alp_double') WHERE segment_type == 'double' AND compression != 'ALP'; +-- +ok +== +select * from random_double; +-- +ok +== +select * from random_alp_double; +-- +ok +== diff --git a/parser/testdata/corpus/sql/storage/compression/alp/alp_nulls.test b/parser/testdata/corpus/sql/storage/compression/alp/alp_nulls.test new file mode 100644 index 0000000..458fd3b --- /dev/null +++ b/parser/testdata/corpus/sql/storage/compression/alp/alp_nulls.test @@ -0,0 +1,262 @@ +# source: test/sql/storage/compression/alp/alp_nulls.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +insert into tbl1_{compression}(d,f) VALUES +(NULL, 1.2314234), +(324213.23123, NULL), +(NULL, NULL), +(21312.23412, 12.123234), +(324213.23123, NULL), +(NULL, NULL), +(21312.23412, 12.123234), +(324213.23123, NULL), +(NULL, NULL), +(21312.23412, 12.123234), +(324213.23123, NULL), +(NULL, NULL), +(21312.23412, 12.123234), +(NULL, 1.2314234), +(324213.23123, NULL), +(NULL, NULL), +(21312.23412, 12.123234), +(324213.23123, NULL), +(NULL, NULL), +(21312.23412, 12.123234), +(324213.23123, NULL), +(NULL, NULL), +(21312.23412, 12.123234), +(324213.23123, NULL), +(NULL, NULL), +(21312.23412, 12.123234), +(NULL, 1.2314234), +(324213.23123, NULL), +(NULL, NULL), +(21312.23412, 12.123234), +(324213.23123, NULL), +(NULL, NULL), +(21312.23412, 12.123234), +(324213.23123, NULL), +(NULL, NULL), +(21312.23412, 12.123234), +(324213.23123, NULL), +(NULL, NULL), +(21312.23412, 12.123234), +(NULL, 1.2314234), +(324213.23123, NULL), +(NULL, NULL), +(21312.23412, 12.123234), +(324213.23123, NULL), +(NULL, NULL), +(21312.23412, 12.123234), +(324213.23123, NULL), +(NULL, NULL), +(21312.23412, 12.123234), +(324213.23123, NULL), +(NULL, NULL), +(21312.23412, 12.123234), +(NULL, 1.2314234), +(324213.23123, NULL), +(NULL, NULL), +(21312.23412, 12.123234), +(324213.23123, NULL), +(NULL, NULL), +(21312.23412, 12.123234), +(324213.23123, NULL), +(NULL, NULL), +(21312.23412, 12.123234), +(324213.23123, NULL), +(NULL, NULL), +(21312.23412, 12.123234), +(NULL, 1.2314234), +(324213.23123, NULL), +(NULL, NULL), +(21312.23412, 12.123234), +(324213.23123, NULL), +(NULL, NULL), +(21312.23412, 12.123234), +(324213.23123, NULL), +(NULL, NULL), +(21312.23412, 12.123234), +(324213.23123, NULL), +(NULL, NULL), +(21312.23412, 12.123234), +(NULL, NULL); +-- +error: Parser Error: syntax error at or near "{" +== +insert into tbl2_{compression}(d,f) VALUES +(NULL, NULL), +(NULL, NULL), +(NULL, NULL), +(NULL, NULL), +(NULL, NULL), +(NULL, NULL), +(NULL, NULL), +(NULL, NULL), +(NULL, NULL), +(NULL, NULL), +(NULL, NULL), +(NULL, NULL), +(NULL, NULL), +(NULL, NULL), +(NULL, NULL), +(NULL, NULL), +(NULL, NULL), +(NULL, NULL), +(NULL, NULL), +(NULL, NULL), +(NULL, NULL), +(NULL, NULL), +(NULL, NULL), +(NULL, NULL), +(NULL, NULL), +(NULL, NULL), +(NULL, NULL), +(NULL, NULL), +(NULL, NULL), +(NULL, NULL), +(NULL, NULL), +(NULL, NULL), +(NULL, NULL), +(NULL, NULL), +(NULL, NULL), +(NULL, NULL), +(NULL, NULL), +(NULL, NULL), +(NULL, NULL), +(NULL, NULL), +(NULL, NULL), +(NULL, NULL), +(NULL, NULL), +(NULL, NULL), +(NULL, NULL), +(NULL, NULL), +(NULL, NULL), +(NULL, NULL), +(NULL, NULL), +(NULL, NULL), +(NULL, NULL), +(NULL, NULL), +(NULL, NULL), +(NULL, NULL), +(NULL, NULL), +(NULL, NULL), +(NULL, NULL), +(NULL, NULL), +(NULL, NULL), +(NULL, NULL), +(NULL, NULL), +(NULL, NULL), +(NULL, NULL), +(NULL, NULL), +(NULL, NULL), +(NULL, NULL), +(NULL, NULL), +(NULL, NULL), +(NULL, NULL), +(NULL, NULL), +(NULL, NULL), +(NULL, NULL), +(NULL, NULL); +-- +error: Parser Error: syntax error at or near "{" +== +insert into tbl3_{compression}(d,f) VALUES +(NULL, NULL), +(NULL, NULL), +(NULL, NULL), +(NULL, NULL), +(NULL, NULL), +(NULL, NULL), +(NULL, NULL), +(NULL, NULL), +(7034.34968234, 93472948.98034), +(1.213123, 1.232142), +(7034.34968234, 93472948.98034), +(7034.34968234, 93472948.98034), +(1.213123, 1.232142), +(7034.34968234, 93472948.98034), +(7034.34968234, 93472948.98034), +(1.213123, 1.232142), +(7034.34968234, 93472948.98034), +(7034.34968234, 93472948.98034), +(1.213123, 1.232142), +(7034.34968234, 93472948.98034), +(7034.34968234, 93472948.98034), +(1.213123, 1.232142), +(7034.34968234, 93472948.98034), +(7034.34968234, 93472948.98034), +(1.213123, 1.232142), +(7034.34968234, 93472948.98034), +(7034.34968234, 93472948.98034), +(1.213123, 1.232142), +(7034.34968234, 93472948.98034), +(7034.34968234, 93472948.98034), +(1.213123, 1.232142), +(7034.34968234, 93472948.98034), +(7034.34968234, 93472948.98034), +(1.213123, 1.232142), +(7034.34968234, 93472948.98034), +(7034.34968234, 93472948.98034), +(1.213123, 1.232142), +(7034.34968234, 93472948.98034), +(7034.34968234, 93472948.98034), +(1.213123, 1.232142), +(7034.34968234, 93472948.98034), +(7034.34968234, 93472948.98034), +(1.213123, 1.232142), +(7034.34968234, 93472948.98034), +(7034.34968234, 93472948.98034), +(1.213123, 1.232142), +(7034.34968234, 93472948.98034), +(7034.34968234, 93472948.98034), +(1.213123, 1.232142), +(7034.34968234, 93472948.98034), +(7034.34968234, 93472948.98034), +(1.213123, 1.232142), +(7034.34968234, 93472948.98034), +(7034.34968234, 93472948.98034), +(1.213123, 1.232142), +(7034.34968234, 93472948.98034), +(7034.34968234, 93472948.98034), +(1.213123, 1.232142), +(7034.34968234, 93472948.98034), +(7034.34968234, 93472948.98034), +(1.213123, 1.232142), +(7034.34968234, 93472948.98034), +(7034.34968234, 93472948.98034), +(1.213123, 1.232142), +(7034.34968234, 93472948.98034), +(7034.34968234, 93472948.98034), +(1.213123, 1.232142), +(7034.34968234, 93472948.98034), +(7034.34968234, 93472948.98034), +(1.213123, 1.232142), +(7034.34968234, 93472948.98034), +(7034.34968234, 93472948.98034), +(1.213123, 1.232142), +(7034.34968234, 93472948.98034), +(7034.34968234, 93472948.98034), +(1.213123, 1.232142), +(7034.34968234, 93472948.98034), +(7034.34968234, 93472948.98034), +(1.213123, 1.232142), +(7034.34968234, 93472948.98034), +(7034.34968234, 93472948.98034), +(1.213123, 1.232142), +(7034.34968234, 93472948.98034), +(7034.34968234, 93472948.98034), +(1.213123, 1.232142), +(7034.34968234, 93472948.98034), +(7034.34968234, 93472948.98034), +(1.213123, 1.232142), +(7034.34968234, 93472948.98034), +(7034.34968234, 93472948.98034), +(1.213123, 1.232142), +(7034.34968234, 93472948.98034), +(1.213123, 1.232142); +-- +error: Parser Error: syntax error at or near "{" +== diff --git a/parser/testdata/corpus/sql/storage/compression/alp/alp_out_of_range.test b/parser/testdata/corpus/sql/storage/compression/alp/alp_out_of_range.test new file mode 100644 index 0000000..59425ab --- /dev/null +++ b/parser/testdata/corpus/sql/storage/compression/alp/alp_out_of_range.test @@ -0,0 +1,17 @@ +# source: test/sql/storage/compression/alp/alp_out_of_range.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +CREATE TABLE integers(v DOUBLE); +-- +ok +== +INSERT INTO integers SELECT 9223372036854775807.0 FROM range(3000); +-- +ok +== +SELECT count(*), count(*) FILTER (WHERE v != 9223372036854775807.0) FROM integers; +-- +ok +== diff --git a/parser/testdata/corpus/sql/storage/compression/alp/alp_simple.test b/parser/testdata/corpus/sql/storage/compression/alp/alp_simple.test new file mode 100644 index 0000000..c053470 --- /dev/null +++ b/parser/testdata/corpus/sql/storage/compression/alp/alp_simple.test @@ -0,0 +1,9 @@ +# source: test/sql/storage/compression/alp/alp_simple.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +create table random_double as select round(random(), 6)::DOUBLE as data from range(1024) tbl(i); +-- +ok +== diff --git a/parser/testdata/corpus/sql/storage/compression/alp/alp_simple_float.test b/parser/testdata/corpus/sql/storage/compression/alp/alp_simple_float.test new file mode 100644 index 0000000..36dbc37 --- /dev/null +++ b/parser/testdata/corpus/sql/storage/compression/alp/alp_simple_float.test @@ -0,0 +1,29 @@ +# source: test/sql/storage/compression/alp/alp_simple_float.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +create table random_float as select round(random(), 6)::FLOAT as data from range(1024) tbl(i); +-- +ok +== +SELECT compression FROM pragma_storage_info('random_float') WHERE segment_type == 'float' AND compression != 'Uncompressed'; +-- +ok +== +create table random_alp_float as select * from random_float; +-- +ok +== +SELECT compression FROM pragma_storage_info('random_alp_float') WHERE segment_type == 'float' AND compression != 'ALP'; +-- +ok +== +select * from random_float; +-- +ok +== +select * from random_alp_float; +-- +ok +== diff --git a/parser/testdata/corpus/sql/storage/compression/alp/alp_storage_version.test b/parser/testdata/corpus/sql/storage/compression/alp/alp_storage_version.test new file mode 100644 index 0000000..e89952f --- /dev/null +++ b/parser/testdata/corpus/sql/storage/compression/alp/alp_storage_version.test @@ -0,0 +1,57 @@ +# source: test/sql/storage/compression/alp/alp_storage_version.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +ATTACH '{TEST_DIR}/alp-v1_4_0-16k.db' AS alp_v1_4_0 (STORAGE_VERSION 'v1.4.0', BLOCK_SIZE 16384); +-- +ok +== +ATTACH '{TEST_DIR}/alp-v1_4_0-default.db' AS alp_v1_4_0_default (STORAGE_VERSION 'v1.4.0', BLOCK_SIZE 262144); +-- +ok +== +ATTACH '{TEST_DIR}/alp-v1_5_0-16k.db' AS alp_v1_5_0 (STORAGE_VERSION 'v1.5.0', BLOCK_SIZE 16384); +-- +ok +== +SET force_compression='alp'; +-- +ok +== +CREATE TABLE alp_v1_4_0.t AS SELECT round(i * 0.001, 6)::DOUBLE AS x FROM range(10000) t(i); +-- +ok +== +CREATE TABLE alp_v1_4_0_default.t AS SELECT round(i * 0.001, 6)::DOUBLE AS x FROM range(10000) t(i); +-- +ok +== +CREATE TABLE alp_v1_5_0.t AS SELECT round(i * 0.001, 6)::DOUBLE AS x FROM range(10000) t(i); +-- +ok +== +CHECKPOINT alp_v1_4_0; +-- +ok +== +CHECKPOINT alp_v1_4_0_default; +-- +ok +== +CHECKPOINT alp_v1_5_0; +-- +ok +== +SELECT compression FROM pragma_storage_info('alp_v1_4_0.t') WHERE segment_type = 'DOUBLE' ORDER BY compression LIMIT 1; +-- +ok +== +SELECT compression FROM pragma_storage_info('alp_v1_4_0_default.t') WHERE segment_type = 'DOUBLE' ORDER BY compression LIMIT 1; +-- +ok +== +SELECT compression FROM pragma_storage_info('alp_v1_5_0.t') WHERE segment_type = 'DOUBLE' ORDER BY compression LIMIT 1; +-- +ok +== diff --git a/parser/testdata/corpus/sql/storage/compression/alp/alp_zeros.test b/parser/testdata/corpus/sql/storage/compression/alp/alp_zeros.test new file mode 100644 index 0000000..bab1f2c --- /dev/null +++ b/parser/testdata/corpus/sql/storage/compression/alp/alp_zeros.test @@ -0,0 +1,9 @@ +# source: test/sql/storage/compression/alp/alp_zeros.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +create table random_double as select 0::DOUBLE as data from range(1024) tbl(i); +-- +ok +== diff --git a/parser/testdata/corpus/sql/storage/compression/alprd/alprd_corrupted_dict_size.test b/parser/testdata/corpus/sql/storage/compression/alprd/alprd_corrupted_dict_size.test new file mode 100644 index 0000000..acd3fbf --- /dev/null +++ b/parser/testdata/corpus/sql/storage/compression/alprd/alprd_corrupted_dict_size.test @@ -0,0 +1,17 @@ +# source: test/sql/storage/compression/alprd/alprd_corrupted_dict_size.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +ATTACH '{TEST_DIR}/alprd_corrupted_dict_size.db' AS db2 +-- +ok +== +SELECT compression FROM pragma_storage_info('t') WHERE segment_type = 'DOUBLE' AND compression != 'ALPRD'; +-- +ok +== +SELECT * FROM t LIMIT 1; +-- +ok +== diff --git a/parser/testdata/corpus/sql/storage/compression/alprd/alprd_corrupted_exception_position.test b/parser/testdata/corpus/sql/storage/compression/alprd/alprd_corrupted_exception_position.test new file mode 100644 index 0000000..50176ea --- /dev/null +++ b/parser/testdata/corpus/sql/storage/compression/alprd/alprd_corrupted_exception_position.test @@ -0,0 +1,13 @@ +# source: test/sql/storage/compression/alprd/alprd_corrupted_exception_position.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +ATTACH '{TEST_DIR}/alprd_corrupt_exception_position.db' AS db2 +-- +ok +== +SELECT compression FROM pragma_storage_info('two_alp') WHERE compression='ALPRD'; +-- +ok +== diff --git a/parser/testdata/corpus/sql/storage/compression/alprd/alprd_inf_null_nan.test b/parser/testdata/corpus/sql/storage/compression/alprd/alprd_inf_null_nan.test new file mode 100644 index 0000000..6728446 --- /dev/null +++ b/parser/testdata/corpus/sql/storage/compression/alprd/alprd_inf_null_nan.test @@ -0,0 +1,17 @@ +# source: test/sql/storage/compression/alprd/alprd_inf_null_nan.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +select d, f from tbl1_alprd; +-- +ok +== +select d, f from tbl2_alprd; +-- +ok +== +select d, f from tbl3_alprd; +-- +ok +== diff --git a/parser/testdata/corpus/sql/storage/compression/alprd/alprd_min_max.test b/parser/testdata/corpus/sql/storage/compression/alprd/alprd_min_max.test new file mode 100644 index 0000000..cd923fe --- /dev/null +++ b/parser/testdata/corpus/sql/storage/compression/alprd/alprd_min_max.test @@ -0,0 +1,13 @@ +# source: test/sql/storage/compression/alprd/alprd_min_max.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +PRAGMA force_compression='alprd'; +-- +ok +== +SELECT compression FROM pragma_storage_info('all_types') WHERE segment_type == '{type}' AND compression != 'ALPRD'; +-- +ok +== diff --git a/parser/testdata/corpus/sql/storage/compression/alprd/alprd_negative_numbers.test b/parser/testdata/corpus/sql/storage/compression/alprd/alprd_negative_numbers.test new file mode 100644 index 0000000..2755720 --- /dev/null +++ b/parser/testdata/corpus/sql/storage/compression/alprd/alprd_negative_numbers.test @@ -0,0 +1,17 @@ +# source: test/sql/storage/compression/alprd/alprd_negative_numbers.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +create table random_double as select round(cos(1 / (random() + 0.001)), 15)::DOUBLE * -1 as data from range(1024) tbl(i); +-- +ok +== +PRAGMA force_compression='alprd' +-- +ok +== +SELECT compression FROM pragma_storage_info('random_alp_double') WHERE segment_type == 'double' AND compression != 'ALPRD'; +-- +ok +== diff --git a/parser/testdata/corpus/sql/storage/compression/alprd/alprd_nulls.test b/parser/testdata/corpus/sql/storage/compression/alprd/alprd_nulls.test new file mode 100644 index 0000000..7066158 --- /dev/null +++ b/parser/testdata/corpus/sql/storage/compression/alprd/alprd_nulls.test @@ -0,0 +1,103 @@ +# source: test/sql/storage/compression/alprd/alprd_nulls.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +insert into tbl3_{compression}(d,f) VALUES +(NULL, NULL), +(NULL, NULL), +(NULL, NULL), +(NULL, NULL), +(NULL, NULL), +(NULL, NULL), +(NULL, NULL), +(NULL, NULL), +(7034.34968234, 93472948.98034), +(1.213123, 1.232142), +(7034.34968234, 93472948.98034), +(7034.34968234, 93472948.98034), +(1.213123, 1.232142), +(7034.34968234, 93472948.98034), +(7034.34968234, 93472948.98034), +(7034.34968234, 93472948.98034), +(1.213123, 1.232142), +(7034.34968234, 93472948.98034), +(7034.34968234, 93472948.98034), +(1.213123, 1.232142), +(7034.34968234, 93472948.98034), +(7034.34968234, 93472948.98034), +(1.213123, 1.232142), +(7034.34968234, 93472948.98034), +(7034.34968234, 93472948.98034), +(1.213123, 1.232142), +(7034.34968234, 93472948.98034), +(7034.34968234, 93472948.98034), +(1.213123, 1.232142), +(7034.34968234, 93472948.98034), +(7034.34968234, 93472948.98034), +(1.213123, 1.232142), +(7034.34968234, 93472948.98034), +(7034.34968234, 93472948.98034), +(1.213123, 1.232142), +(7034.34968234, 93472948.98034), +(7034.34968234, 93472948.98034), +(1.213123, 1.232142), +(7034.34968234, 93472948.98034), +(7034.34968234, 93472948.98034), +(1.213123, 1.232142), +(7034.34968234, 93472948.98034), +(7034.34968234, 93472948.98034), +(1.213123, 1.232142), +(7034.34968234, 93472948.98034), +(7034.34968234, 93472948.98034), +(1.213123, 1.232142), +(7034.34968234, 93472948.98034), +(7034.34968234, 93472948.98034), +(1.213123, 1.232142), +(7034.34968234, 93472948.98034), +(7034.34968234, 93472948.98034), +(1.213123, 1.232142), +(7034.34968234, 93472948.98034), +(7034.34968234, 93472948.98034), +(1.213123, 1.232142), +(7034.34968234, 93472948.98034), +(7034.34968234, 93472948.98034), +(1.213123, 1.232142), +(7034.34968234, 93472948.98034), +(7034.34968234, 93472948.98034), +(1.213123, 1.232142), +(7034.34968234, 93472948.98034), +(7034.34968234, 93472948.98034), +(1.213123, 1.232142), +(7034.34968234, 93472948.98034), +(7034.34968234, 93472948.98034), +(1.213123, 1.232142), +(7034.34968234, 93472948.98034), +(7034.34968234, 93472948.98034), +(1.213123, 1.232142), +(7034.34968234, 93472948.98034), +(7034.34968234, 93472948.98034), +(1.213123, 1.232142), +(7034.34968234, 93472948.98034), +(7034.34968234, 93472948.98034), +(1.213123, 1.232142), +(7034.34968234, 93472948.98034), +(7034.34968234, 93472948.98034), +(1.213123, 1.232142), +(7034.34968234, 93472948.98034), +(7034.34968234, 93472948.98034), +(1.213123, 1.232142), +(7034.34968234, 93472948.98034), +(7034.34968234, 93472948.98034), +(1.213123, 1.232142), +(7034.34968234, 93472948.98034), +(7034.34968234, 93472948.98034), +(1.213123, 1.232142), +(7034.34968234, 93472948.98034), +(7034.34968234, 93472948.98034), +(1.213123, 1.232142), +(7034.34968234, 93472948.98034), +(1.213123, 1.232142); +-- +error: Parser Error: syntax error at or near "{" +== diff --git a/parser/testdata/corpus/sql/storage/compression/alprd/alprd_simple.test b/parser/testdata/corpus/sql/storage/compression/alprd/alprd_simple.test new file mode 100644 index 0000000..1423edc --- /dev/null +++ b/parser/testdata/corpus/sql/storage/compression/alprd/alprd_simple.test @@ -0,0 +1,21 @@ +# source: test/sql/storage/compression/alprd/alprd_simple.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +create table random_double as select random()::DOUBLE as data from range(1024) tbl(i); +-- +ok +== +create table random_alprd_double as select * from random_double; +-- +ok +== +SELECT compression FROM pragma_storage_info('random_alprd_double') WHERE segment_type == 'double' AND compression != 'ALPRD'; +-- +ok +== +select * from random_alprd_double; +-- +ok +== diff --git a/parser/testdata/corpus/sql/storage/compression/alprd/alprd_simple_float.test b/parser/testdata/corpus/sql/storage/compression/alprd/alprd_simple_float.test new file mode 100644 index 0000000..798d783 --- /dev/null +++ b/parser/testdata/corpus/sql/storage/compression/alprd/alprd_simple_float.test @@ -0,0 +1,13 @@ +# source: test/sql/storage/compression/alprd/alprd_simple_float.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +create table random_float as select random()::FLOAT as data from range(1024) tbl(i); +-- +ok +== +SELECT compression FROM pragma_storage_info('random_alp_float') WHERE segment_type == 'float' AND compression != 'ALPRD'; +-- +ok +== diff --git a/parser/testdata/corpus/sql/storage/compression/alprd/alprd_storage_version.test b/parser/testdata/corpus/sql/storage/compression/alprd/alprd_storage_version.test new file mode 100644 index 0000000..528a9b6 --- /dev/null +++ b/parser/testdata/corpus/sql/storage/compression/alprd/alprd_storage_version.test @@ -0,0 +1,57 @@ +# source: test/sql/storage/compression/alprd/alprd_storage_version.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +ATTACH '{TEST_DIR}/alprd-v1_4_0-16k.db' AS alprd_v1_4_0 (STORAGE_VERSION 'v1.4.0', BLOCK_SIZE 16384); +-- +ok +== +ATTACH '{TEST_DIR}/alprd-v1_4_0-default.db' AS alprd_v1_4_0_default (STORAGE_VERSION 'v1.4.0', BLOCK_SIZE 262144); +-- +ok +== +ATTACH '{TEST_DIR}/alprd-v1_5_0-16k.db' AS alprd_v1_5_0 (STORAGE_VERSION 'v1.5.0', BLOCK_SIZE 16384); +-- +ok +== +SET force_compression='alprd'; +-- +ok +== +CREATE TABLE alprd_v1_4_0.t AS SELECT round(i * 0.001, 6)::DOUBLE AS x FROM range(10000) t(i); +-- +ok +== +CREATE TABLE alprd_v1_4_0_default.t AS SELECT round(i * 0.001, 6)::DOUBLE AS x FROM range(10000) t(i); +-- +ok +== +CREATE TABLE alprd_v1_5_0.t AS SELECT round(i * 0.001, 6)::DOUBLE AS x FROM range(10000) t(i); +-- +ok +== +CHECKPOINT alprd_v1_4_0; +-- +ok +== +CHECKPOINT alprd_v1_4_0_default; +-- +ok +== +CHECKPOINT alprd_v1_5_0; +-- +ok +== +SELECT compression FROM pragma_storage_info('alprd_v1_4_0.t') WHERE segment_type = 'DOUBLE' ORDER BY compression LIMIT 1; +-- +ok +== +SELECT compression FROM pragma_storage_info('alprd_v1_4_0_default.t') WHERE segment_type = 'DOUBLE' ORDER BY compression LIMIT 1; +-- +ok +== +SELECT compression FROM pragma_storage_info('alprd_v1_5_0.t') WHERE segment_type = 'DOUBLE' ORDER BY compression LIMIT 1; +-- +ok +== diff --git a/parser/testdata/corpus/sql/storage/compression/bitpacking/bitpacking_constant_delta.test b/parser/testdata/corpus/sql/storage/compression/bitpacking/bitpacking_constant_delta.test new file mode 100644 index 0000000..95942ab --- /dev/null +++ b/parser/testdata/corpus/sql/storage/compression/bitpacking/bitpacking_constant_delta.test @@ -0,0 +1,37 @@ +# source: test/sql/storage/compression/bitpacking/bitpacking_constant_delta.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +PRAGMA force_compression = 'bitpacking' +-- +ok +== +PRAGMA force_bitpacking_mode='{bitpacking_mode}' +-- +ok +== +CREATE TABLE test (c {type}); +-- +error: Parser Error: syntax error at or near "{" +== +INSERT INTO test SELECT 2+i*2::{type} FROM range(0,5) tbl(i); +-- +error: Parser Error: syntax error at or near "{" +== +SELECT compression FROM pragma_storage_info('test') where segment_type != 'VALIDITY' and compression != 'BitPacking' +-- +ok +== +CREATE TABLE test (c INT64); +-- +ok +== +INSERT INTO test SELECT i from range(0,130000) tbl(i); +-- +ok +== +SELECT avg(c) FROM test; +-- +ok +== diff --git a/parser/testdata/corpus/sql/storage/compression/bitpacking/bitpacking_delta_for.test b/parser/testdata/corpus/sql/storage/compression/bitpacking/bitpacking_delta_for.test new file mode 100644 index 0000000..8c7e279 --- /dev/null +++ b/parser/testdata/corpus/sql/storage/compression/bitpacking/bitpacking_delta_for.test @@ -0,0 +1,21 @@ +# source: test/sql/storage/compression/bitpacking/bitpacking_delta_for.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +PRAGMA force_compression='bitpacking' +-- +ok +== +create table aux as select range::INT x from range(-2_000_000_000, 2_000_000_000, 2_000_000); +-- +ok +== +create table tt as select (x + if (random() > 0.5, 1, -1)) x from aux; +-- +ok +== +select compression from pragma_storage_info('tt') where segment_type != 'VALIDITY'; +-- +ok +== diff --git a/parser/testdata/corpus/sql/storage/compression/bitpacking/bitpacking_filter_pushdown.test b/parser/testdata/corpus/sql/storage/compression/bitpacking/bitpacking_filter_pushdown.test new file mode 100644 index 0000000..9e33e69 --- /dev/null +++ b/parser/testdata/corpus/sql/storage/compression/bitpacking/bitpacking_filter_pushdown.test @@ -0,0 +1,37 @@ +# source: test/sql/storage/compression/bitpacking/bitpacking_filter_pushdown.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +CREATE TABLE test (id VARCHAR, col INTEGER) +-- +ok +== +INSERT INTO test SELECT i::VARCHAR id, i b FROM range(10000) tbl(i) +-- +ok +== +INSERT INTO test SELECT i::VARCHAR id, 1337 FROM range(20000, 30000) tbl(i) +-- +ok +== +INSERT INTO test SELECT i::VARCHAR id, i b FROM range(30000,40000) tbl(i) +-- +ok +== +SELECT compression FROM pragma_storage_info('test') where segment_type = 'INTEGER' and compression != 'BitPacking' +-- +ok +== +SELECT SUM(col), MIN(col), MAX(col), COUNT(*) FROM test WHERE col=1337 +-- +ok +== +SELECT MIN(id), MAX(id), SUM(col), MIN(col), MAX(col), COUNT(*) FROM test WHERE id='5000' +-- +ok +== +SELECT MIN(id), MAX(id), SUM(col), MIN(col), MAX(col), COUNT(*) FROM test WHERE id::INT64%1000=0; +-- +ok +== diff --git a/parser/testdata/corpus/sql/storage/compression/bitpacking/bitpacking_hugeint.test b/parser/testdata/corpus/sql/storage/compression/bitpacking/bitpacking_hugeint.test new file mode 100644 index 0000000..134e017 --- /dev/null +++ b/parser/testdata/corpus/sql/storage/compression/bitpacking/bitpacking_hugeint.test @@ -0,0 +1,61 @@ +# source: test/sql/storage/compression/bitpacking/bitpacking_hugeint.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +PRAGMA force_bitpacking_mode='constant' +-- +ok +== +CREATE TABLE test (id VARCHAR, a HUGEINT); +-- +ok +== +INSERT INTO test SELECT i::VARCHAR, i::HUGEINT FROM range(0, 16) tbl(i); +INSERT INTO test SELECT i::VARCHAR, 13371337 FROM range(0, 16) tbl(i); +-- +ok +== +select a from test limit 5; +-- +ok +== +SELECT compression FROM pragma_storage_info('test') WHERE segment_type ILIKE 'HUGEINT'; +-- +ok +== +INSERT INTO test SELECT i::VARCHAR, i::HUGEINT + 3000000000 FROM range(0, 16) tbl(i); +INSERT INTO test SELECT i::VARCHAR, 13371337 FROM range(0, 16) tbl(i); +-- +ok +== +INSERT INTO test SELECT i::VARCHAR, i::HUGEINT + 200000000000 FROM range(0, 16) tbl(i); +INSERT INTO test SELECT i::VARCHAR, 13371337 FROM range(0, 16) tbl(i); +-- +ok +== +INSERT INTO test SELECT i::VARCHAR, i::HUGEINT + 10000000000000000000 FROM range(0, 16) tbl(i); +INSERT INTO test SELECT i::VARCHAR, 13371337 FROM range(0, 16) tbl(i); +-- +ok +== +INSERT INTO test SELECT i::VARCHAR, i::HUGEINT + 500000000000000000000 FROM range(0, 16) tbl(i); +INSERT INTO test SELECT i::VARCHAR, 13371337 FROM range(0, 16) tbl(i); +-- +ok +== +INSERT INTO test SELECT i::VARCHAR, i::HUGEINT + 50000000000000000000000000000 FROM range(0, 16) tbl(i); +INSERT INTO test SELECT i::VARCHAR, 13371337 FROM range(0, 16) tbl(i); +-- +ok +== +INSERT INTO test SELECT i::VARCHAR, i::HUGEINT + 300000000000000000000000000000000 FROM range(0, 16) tbl(i); +INSERT INTO test SELECT i::VARCHAR, 13371337 FROM range(0, 16) tbl(i); +-- +ok +== +INSERT INTO test SELECT i::VARCHAR, i::HUGEINT + 20000000000000000000000000000000000000 FROM range(0, 16) tbl(i); +INSERT INTO test SELECT i::VARCHAR, 13371337 FROM range(0, 16) tbl(i); +-- +ok +== diff --git a/parser/testdata/corpus/sql/storage/compression/bitpacking/bitpacking_mode.test b/parser/testdata/corpus/sql/storage/compression/bitpacking/bitpacking_mode.test new file mode 100644 index 0000000..4dd88b4 --- /dev/null +++ b/parser/testdata/corpus/sql/storage/compression/bitpacking/bitpacking_mode.test @@ -0,0 +1,25 @@ +# source: test/sql/storage/compression/bitpacking/bitpacking_mode.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +SET force_compression = 'bitpacking' +-- +ok +== +SELECT current_setting('force_bitpacking_mode') +-- +ok +== +SET force_bitpacking_mode='xxx' +-- +ok +== +SET force_bitpacking_mode='{mode}' +-- +ok +== +SELECT current_setting('force_bitpacking_mode')='{mode}' +-- +ok +== diff --git a/parser/testdata/corpus/sql/storage/compression/bitpacking/bitpacking_nulls.test b/parser/testdata/corpus/sql/storage/compression/bitpacking/bitpacking_nulls.test new file mode 100644 index 0000000..54cd4dd --- /dev/null +++ b/parser/testdata/corpus/sql/storage/compression/bitpacking/bitpacking_nulls.test @@ -0,0 +1,29 @@ +# source: test/sql/storage/compression/bitpacking/bitpacking_nulls.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +CREATE TABLE test (a BIGINT); +-- +ok +== +INSERT INTO test SELECT case when i%5=0 then null else 1337 end FROM range(0,10000) tbl(i); +-- +ok +== +INSERT INTO test SELECT case when i%5=0 then null else i end FROM range(0,10000) tbl(i); +-- +ok +== +INSERT INTO test SELECT case when i%5=0 then null else i//2 end FROM range(0,10000) tbl(i); +-- +ok +== +SELECT compression FROM pragma_storage_info('test') WHERE segment_type ILIKE 'BIGINT' and compression != 'BitPacking'; +-- +ok +== +select sum(a), min(a), max(a) from test; +-- +ok +== diff --git a/parser/testdata/corpus/sql/storage/compression/bitpacking/bitpacking_simple.test b/parser/testdata/corpus/sql/storage/compression/bitpacking/bitpacking_simple.test new file mode 100644 index 0000000..3ed18d2 --- /dev/null +++ b/parser/testdata/corpus/sql/storage/compression/bitpacking/bitpacking_simple.test @@ -0,0 +1,29 @@ +# source: test/sql/storage/compression/bitpacking/bitpacking_simple.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +CREATE TABLE test (id VARCHAR, a BIGINT); +-- +ok +== +INSERT INTO test SELECT i::VARCHAR, -i FROM range(0,10000) tbl(i); +-- +ok +== +INSERT INTO test SELECT i::VARCHAR, 13371337 FROM range(0,10000) tbl(i); +-- +ok +== +select a from test limit 5 offset 12000; +-- +ok +== +select avg(a) from test; +-- +ok +== +SELECT compression FROM pragma_storage_info('test') WHERE segment_type ILIKE 'BIGINT'; +-- +ok +== diff --git a/parser/testdata/corpus/sql/storage/compression/bitpacking/bitpacking_simple_hugeint.test b/parser/testdata/corpus/sql/storage/compression/bitpacking/bitpacking_simple_hugeint.test new file mode 100644 index 0000000..579fc2c --- /dev/null +++ b/parser/testdata/corpus/sql/storage/compression/bitpacking/bitpacking_simple_hugeint.test @@ -0,0 +1,9 @@ +# source: test/sql/storage/compression/bitpacking/bitpacking_simple_hugeint.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +INSERT INTO test SELECT i::VARCHAR, -i::HUGEINT + -1234567891011121314151617180000::HUGEINT FROM range(0, 10000) tbl(i); +-- +ok +== diff --git a/parser/testdata/corpus/sql/storage/compression/bitpacking/bitpacking_size_calculation.test b/parser/testdata/corpus/sql/storage/compression/bitpacking/bitpacking_size_calculation.test new file mode 100644 index 0000000..a267ba9 --- /dev/null +++ b/parser/testdata/corpus/sql/storage/compression/bitpacking/bitpacking_size_calculation.test @@ -0,0 +1,15 @@ +# source: test/sql/storage/compression/bitpacking/bitpacking_size_calculation.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +pragma force_compression='bitpacking' +-- +ok +== +CREATE OR REPLACE TABLE toy_table AS + SELECT * + FROM 'https://github.com/duckdb/duckdb-data/releases/download/v1.0/bp_bug.parquet' ; +-- +ok +== diff --git a/parser/testdata/corpus/sql/storage/compression/bitpacking/bitpacking_storage_info.test b/parser/testdata/corpus/sql/storage/compression/bitpacking/bitpacking_storage_info.test new file mode 100644 index 0000000..b060b2b --- /dev/null +++ b/parser/testdata/corpus/sql/storage/compression/bitpacking/bitpacking_storage_info.test @@ -0,0 +1,53 @@ +# source: test/sql/storage/compression/bitpacking/bitpacking_storage_info.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +INSERT INTO test VALUES (11, 22), (11, 22), (12, 21), (NULL, NULL) +-- +ok +== +SELECT compression FROM pragma_storage_info('test') WHERE segment_type ILIKE 'INTEGER' LIMIT 1 +-- +ok +== +CREATE TABLE test_bp (a INTEGER) +-- +ok +== +INSERT INTO test_bp SELECT 1 FROM range(0, 10000) tbl(i) +-- +ok +== +INSERT INTO test_bp SELECT 2 FROM range(0, 10000) tbl(i) +-- +ok +== +SELECT + segment_info +FROM + pragma_storage_info('test_bp', include_segment_info=true) +WHERE segment_type NOT IN ('VALIDITY') +-- +ok +== +PRAGMA force_bitpacking_mode = 'delta_for' +-- +ok +== +SET SESSION force_bitpacking_mode = 'delta_for' +-- +ok +== +RESET SESSION force_bitpacking_mode +-- +ok +== +CREATE OR REPLACE TABLE test_bp (a INTEGER) +-- +ok +== +INSERT INTO test_bp SELECT 3*(i // 1000) + (i%10) FROM range(0, 10000) tbl(i) +-- +ok +== diff --git a/parser/testdata/corpus/sql/storage/compression/bitpacking/bitpacking_table_copy.test b/parser/testdata/corpus/sql/storage/compression/bitpacking/bitpacking_table_copy.test new file mode 100644 index 0000000..c154f28 --- /dev/null +++ b/parser/testdata/corpus/sql/storage/compression/bitpacking/bitpacking_table_copy.test @@ -0,0 +1,29 @@ +# source: test/sql/storage/compression/bitpacking/bitpacking_table_copy.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +CREATE TABLE test (a integer); +-- +ok +== +INSERT INTO test SELECT i FROM range(0,150000) tbl(i); +-- +ok +== +CREATE TABLE test_2 AS SELECT a FROM test; +-- +ok +== +select sum(a) from test; +-- +ok +== +select sum(a) from test_2; +-- +ok +== +drop table test_2 +-- +ok +== diff --git a/parser/testdata/corpus/sql/storage/compression/bitpacking/bitpacking_uhugeint.test b/parser/testdata/corpus/sql/storage/compression/bitpacking/bitpacking_uhugeint.test new file mode 100644 index 0000000..9319208 --- /dev/null +++ b/parser/testdata/corpus/sql/storage/compression/bitpacking/bitpacking_uhugeint.test @@ -0,0 +1,53 @@ +# source: test/sql/storage/compression/bitpacking/bitpacking_uhugeint.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +CREATE TABLE test (id VARCHAR, a UHUGEINT); +-- +ok +== +INSERT INTO test SELECT i::VARCHAR, i::UHUGEINT FROM range(0, 16) tbl(i); +INSERT INTO test SELECT i::VARCHAR, 13371337 FROM range(0, 16) tbl(i); +-- +ok +== +SELECT compression FROM pragma_storage_info('test') WHERE segment_type ILIKE 'UHUGEINT'; +-- +ok +== +INSERT INTO test SELECT i::VARCHAR, i::UHUGEINT + 3000000000::UHUGEINT FROM range(0, 16) tbl(i); +INSERT INTO test SELECT i::VARCHAR, 13371337 FROM range(0, 16) tbl(i); +-- +ok +== +INSERT INTO test SELECT i::VARCHAR, i::UHUGEINT + 200000000000::UHUGEINT FROM range(0, 16) tbl(i); +INSERT INTO test SELECT i::VARCHAR, 13371337 FROM range(0, 16) tbl(i); +-- +ok +== +INSERT INTO test SELECT i::VARCHAR, i::UHUGEINT + 10000000000000000000::UHUGEINT FROM range(0, 16) tbl(i); +INSERT INTO test SELECT i::VARCHAR, 13371337 FROM range(0, 16) tbl(i); +-- +ok +== +INSERT INTO test SELECT i::VARCHAR, i::UHUGEINT + 500000000000000000000::UHUGEINT FROM range(0, 16) tbl(i); +INSERT INTO test SELECT i::VARCHAR, 13371337 FROM range(0, 16) tbl(i); +-- +ok +== +INSERT INTO test SELECT i::VARCHAR, i::UHUGEINT + 50000000000000000000000000000::UHUGEINT FROM range(0, 16) tbl(i); +INSERT INTO test SELECT i::VARCHAR, 13371337 FROM range(0, 16) tbl(i); +-- +ok +== +INSERT INTO test SELECT i::VARCHAR, i::UHUGEINT + 300000000000000000000000000000000::UHUGEINT FROM range(0, 16) tbl(i); +INSERT INTO test SELECT i::VARCHAR, 13371337 FROM range(0, 16) tbl(i); +-- +ok +== +INSERT INTO test SELECT i::VARCHAR, i::UHUGEINT + 20000000000000000000000000000000000000::UHUGEINT FROM range(0, 16) tbl(i); +INSERT INTO test SELECT i::VARCHAR, 13371337 FROM range(0, 16) tbl(i); +-- +ok +== diff --git a/parser/testdata/corpus/sql/storage/compression/bitpacking/force_bitpacking.test b/parser/testdata/corpus/sql/storage/compression/bitpacking/force_bitpacking.test new file mode 100644 index 0000000..b2dec23 --- /dev/null +++ b/parser/testdata/corpus/sql/storage/compression/bitpacking/force_bitpacking.test @@ -0,0 +1,21 @@ +# source: test/sql/storage/compression/bitpacking/force_bitpacking.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +CREATE TABLE test_bp (a INTEGER); +-- +ok +== +INSERT INTO test_bp SELECT 1 FROM range(0, 1000) tbl(i); +-- +ok +== +INSERT INTO test_bp SELECT 2 FROM range(0, 1000) tbl(i); +-- +ok +== +SELECT compression FROM pragma_storage_info('test_bp') WHERE segment_type ILIKE 'INTEGER' LIMIT 1 +-- +ok +== diff --git a/parser/testdata/corpus/sql/storage/compression/bitpacking/struct_bitpacking.test b/parser/testdata/corpus/sql/storage/compression/bitpacking/struct_bitpacking.test new file mode 100644 index 0000000..c20a0ee --- /dev/null +++ b/parser/testdata/corpus/sql/storage/compression/bitpacking/struct_bitpacking.test @@ -0,0 +1,20 @@ +# source: test/sql/storage/compression/bitpacking/struct_bitpacking.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +CREATE TABLE test (s ROW(a INTEGER)); +-- +ok +== +INSERT INTO test SELECT {'a': i} FROM range(0, 10000) tbl(i); +INSERT INTO test SELECT {'a': i} FROM range(22767, 32767) tbl(i); +INSERT INTO test SELECT {'a': 1337} FROM range(2147473647, 2147483647) tbl(i); +INSERT INTO test SELECT {'a': i} FROM range(2147473647, 2147483647) tbl(i); +-- +ok +== +SELECT SUM(s['a']), MIN(s['a']), MAX(s['a']), COUNT(*) FROM test +-- +ok +== diff --git a/parser/testdata/corpus/sql/storage/compression/compression_selection.test b/parser/testdata/corpus/sql/storage/compression/compression_selection.test new file mode 100644 index 0000000..1648719 --- /dev/null +++ b/parser/testdata/corpus/sql/storage/compression/compression_selection.test @@ -0,0 +1,49 @@ +# source: test/sql/storage/compression/compression_selection.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +CREATE TABLE test_rle (a INTEGER); +-- +ok +== +INSERT INTO test_rle SELECT 2147480000 FROM range(0, 10000) tbl(i); +-- +ok +== +INSERT INTO test_rle SELECT 2147480001 FROM range(0, 10000) tbl(i); +-- +ok +== +SELECT compression FROM pragma_storage_info('test_rle') WHERE segment_type ILIKE 'INTEGER' LIMIT 1 +-- +ok +== +CREATE TABLE test_constant (a INTEGER); +-- +ok +== +INSERT INTO test_constant SELECT 1 FROM range(0, 2000) tbl(i); +-- +ok +== +SELECT compression FROM pragma_storage_info('test_constant') WHERE segment_type ILIKE 'INTEGER' LIMIT 1 +-- +ok +== +CREATE TABLE test_dict (a VARCHAR); +-- +ok +== +INSERT INTO test_dict SELECT concat('foobar-', (i%2)::VARCHAR) FROM range(0, 2000) tbl(i); +-- +ok +== +SELECT compression FROM pragma_storage_info('test_dict') WHERE segment_type ILIKE 'VARCHAR' LIMIT 1 +-- +ok +== +INSERT INTO test_bp SELECT i FROM range(0, 2000) tbl(i); +-- +ok +== diff --git a/parser/testdata/corpus/sql/storage/compression/default_storage_dict_fsst.test b/parser/testdata/corpus/sql/storage/compression/default_storage_dict_fsst.test new file mode 100644 index 0000000..6c0777c --- /dev/null +++ b/parser/testdata/corpus/sql/storage/compression/default_storage_dict_fsst.test @@ -0,0 +1,23 @@ +# source: test/sql/storage/compression/default_storage_dict_fsst.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +CREATE TABLE t AS +SELECT concat('foobar-', (i % 2)::VARCHAR) AS s +FROM range(0, 2000) tbl(i); +-- +ok +== +SELECT count(*) FROM pragma_storage_info('t') +WHERE segment_type = 'VARCHAR' + AND compression = 'DICT_FSST' +-- +ok +== +SELECT count(*) FROM pragma_storage_info('t') +WHERE segment_type = 'VARCHAR' + AND compression IN ('Dictionary', 'FSST') +-- +ok +== diff --git a/parser/testdata/corpus/sql/storage/compression/dict_fsst/dict_fsst_expression_filter.test b/parser/testdata/corpus/sql/storage/compression/dict_fsst/dict_fsst_expression_filter.test new file mode 100644 index 0000000..ffac65a --- /dev/null +++ b/parser/testdata/corpus/sql/storage/compression/dict_fsst/dict_fsst_expression_filter.test @@ -0,0 +1,104 @@ +# source: test/sql/storage/compression/dict_fsst/dict_fsst_expression_filter.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +CREATE TABLE partial_segment AS +SELECT concat('HumanEval/', i::VARCHAR) AS task_id +FROM range(0, 164) tbl(i) +-- +ok +== +CREATE TABLE full_vector AS +SELECT concat('HumanEval/', i::VARCHAR) AS task_id +FROM range(0, 2048) tbl(i) +-- +ok +== +SELECT count(*) FROM pragma_storage_info('partial_segment') +WHERE column_name = 'task_id' + AND segment_type = 'VARCHAR' + AND compression = 'DICT_FSST' +-- +ok +== +SELECT count(*) FROM pragma_storage_info('full_vector') +WHERE column_name = 'task_id' + AND segment_type = 'VARCHAR' + AND compression = 'DICT_FSST' +-- +ok +== +SELECT count(*) FROM partial_segment +WHERE split_part(task_id, '/', 2)::INTEGER >= 10 +-- +ok +== +SELECT count(*) FROM partial_segment +WHERE split_part(task_id, '/', 2)::INTEGER >= 10000 +-- +ok +== +DELETE FROM partial_segment +WHERE split_part(task_id, '/', 2)::INTEGER >= 10 +-- +ok +== +SELECT count(*) FROM partial_segment +-- +ok +== +SELECT count(*) FROM full_vector +WHERE split_part(task_id, '/', 2)::INTEGER >= 10 +-- +ok +== +SELECT count(*) FROM full_vector +WHERE split_part(task_id, '/', 2)::INTEGER >= 10000 +-- +ok +== +DELETE FROM full_vector +WHERE split_part(task_id, '/', 2)::INTEGER >= 10 +-- +ok +== +SELECT count(*) FROM full_vector +-- +ok +== +SET force_mbedtls_unsafe = true +-- +ok +== +ATTACH '{TEST_DIR}/dict_fsst_multi_segment_encrypted.db' AS encrypted (ENCRYPTION_KEY 'asdf') +-- +ok +== +USE encrypted +-- +ok +== +CREATE TABLE multi_segment AS +SELECT i, concat('Comment number ', i::VARCHAR, + ' has repeated words special requests alpha beta gamma') AS comment +FROM range(0, 50000) tbl(i) +-- +ok +== +USE dict_fsst_expression_filter +-- +ok +== +SELECT count(*) > 1 FROM pragma_storage_info('multi_segment') +WHERE column_name = 'comment' + AND segment_type = 'VARCHAR' + AND compression = 'DICT_FSST' +-- +ok +== +SELECT count(*), sum(i) FROM multi_segment +WHERE split_part(comment, ' ', 3)::INTEGER % 2 = 0 +-- +ok +== diff --git a/parser/testdata/corpus/sql/storage/compression/dict_fsst/dict_fsst_test.test b/parser/testdata/corpus/sql/storage/compression/dict_fsst/dict_fsst_test.test new file mode 100644 index 0000000..e27062d --- /dev/null +++ b/parser/testdata/corpus/sql/storage/compression/dict_fsst/dict_fsst_test.test @@ -0,0 +1,47 @@ +# source: test/sql/storage/compression/dict_fsst/dict_fsst_test.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +pragma force_compression='uncompressed'; +-- +ok +== +create table uncompressed_data as +select + i, repeat( + (i % 200)::INTEGER::VARCHAR, + 2047 // len((i % 200)::INTEGER::VARCHAR) + ) a +from range(20000) t(i); +-- +ok +== +select * from uncompressed_data order by i; +-- +ok +== +pragma force_compression='dict_fsst'; +-- +ok +== +create table compressed_data as select * from uncompressed_data; +-- +ok +== +select count(distinct a) from compressed_data; +-- +ok +== +select * from compressed_data order by i; +-- +ok +== +select count(distinct a) from compressed_data where contains(a, '11') +-- +ok +== +select count(distinct a) from compressed_data where i%10=0 +-- +ok +== diff --git a/parser/testdata/corpus/sql/storage/compression/dict_fsst/dictionary_covers_validity.test b/parser/testdata/corpus/sql/storage/compression/dict_fsst/dictionary_covers_validity.test new file mode 100644 index 0000000..8b723de --- /dev/null +++ b/parser/testdata/corpus/sql/storage/compression/dict_fsst/dictionary_covers_validity.test @@ -0,0 +1,63 @@ +# source: test/sql/storage/compression/dict_fsst/dictionary_covers_validity.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +set checkpoint_threshold='10mb'; +-- +ok +== +CREATE TABLE tbl AS SELECT + { + 'a': i, + 'b': NULL::VARCHAR + } col +FROM range(5000) t(i) +union all +select + { + 'a': 10000, + 'b': 'hello' + } +-- +ok +== +set force_compression='dict_fsst'; +-- +ok +== +force checkpoint; +-- +ok +== +SELECT segment_type, compression FROM pragma_storage_info('tbl') WHERE segment_type != 'BIGINT'; +-- +ok +== +set force_compression='zstd'; +-- +ok +== +CREATE OR REPLACE TABLE tbl AS SELECT + { + 'a': i, + 'b': NULL::VARCHAR + } col +FROM range(5000) t(i) +union all +select + { + 'a': 10000, + 'b': 'hello' + } FROM range(2) +-- +ok +== +select segment_type, compression from pragma_storage_info('tbl') where segment_type IN ('VARCHAR', 'VALIDITY') order by all; +-- +ok +== +SELECT col FROM tbl ORDER BY col.a DESC LIMIT 3; +-- +ok +== diff --git a/parser/testdata/corpus/sql/storage/compression/dict_fsst/dictionary_storage_info.test b/parser/testdata/corpus/sql/storage/compression/dict_fsst/dictionary_storage_info.test new file mode 100644 index 0000000..6cd8af6 --- /dev/null +++ b/parser/testdata/corpus/sql/storage/compression/dict_fsst/dictionary_storage_info.test @@ -0,0 +1,21 @@ +# source: test/sql/storage/compression/dict_fsst/dictionary_storage_info.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +PRAGMA force_compression = 'dict_fsst' +-- +ok +== +CREATE TABLE test (a VARCHAR, b VARCHAR); +-- +ok +== +INSERT INTO test VALUES ('11', '22'), ('11', '22'), ('12', '21'), (NULL, NULL) +-- +ok +== +SELECT compression FROM pragma_storage_info('test') WHERE segment_type ILIKE 'VARCHAR' LIMIT 1 +-- +ok +== diff --git a/parser/testdata/corpus/sql/storage/compression/dict_fsst/fetch_row.test b/parser/testdata/corpus/sql/storage/compression/dict_fsst/fetch_row.test new file mode 100644 index 0000000..42de63c --- /dev/null +++ b/parser/testdata/corpus/sql/storage/compression/dict_fsst/fetch_row.test @@ -0,0 +1,31 @@ +# source: test/sql/storage/compression/dict_fsst/fetch_row.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +PRAGMA force_compression = 'dict_fsst'; +-- +ok +== +CREATE TABLE test (a INTEGER, b VARCHAR); +-- +ok +== +INSERT INTO test (a, b) +SELECT + x AS a, + CASE x % 5 + WHEN 0 THEN 'aaaa' + WHEN 1 THEN 'bbbb' + WHEN 2 THEN 'cccc' + WHEN 3 THEN 'this is not an inlined string' + WHEN 4 THEN NULL + END AS b +FROM range(80) t(x); +-- +ok +== +SELECT DISTINCT b FROM test ORDER BY a % 5; +-- +ok +== diff --git a/parser/testdata/corpus/sql/storage/compression/dict_fsst/force_dictionary.test b/parser/testdata/corpus/sql/storage/compression/dict_fsst/force_dictionary.test new file mode 100644 index 0000000..1f9bc6d --- /dev/null +++ b/parser/testdata/corpus/sql/storage/compression/dict_fsst/force_dictionary.test @@ -0,0 +1,9 @@ +# source: test/sql/storage/compression/dict_fsst/force_dictionary.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +INSERT INTO test_dict SELECT i::VARCHAR FROM range(0, 2000) tbl(i); +-- +ok +== diff --git a/parser/testdata/corpus/sql/storage/compression/dict_fsst/invalid_symbol_table.test b/parser/testdata/corpus/sql/storage/compression/dict_fsst/invalid_symbol_table.test new file mode 100644 index 0000000..cbc1f43 --- /dev/null +++ b/parser/testdata/corpus/sql/storage/compression/dict_fsst/invalid_symbol_table.test @@ -0,0 +1,17 @@ +# source: test/sql/storage/compression/dict_fsst/invalid_symbol_table.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +ATTACH '{TEST_DIR}/dict_fsst_invalid_symbol_table.db' AS db2 +-- +ok +== +SELECT compression FROM pragma_storage_info('t') WHERE compression='DICT_FSST' LIMIT 1; +-- +ok +== +SELECT sum(length(s)) FROM t; +-- +ok +== diff --git a/parser/testdata/corpus/sql/storage/compression/dict_fsst/issue_5675.test b/parser/testdata/corpus/sql/storage/compression/dict_fsst/issue_5675.test new file mode 100644 index 0000000..06f7465 --- /dev/null +++ b/parser/testdata/corpus/sql/storage/compression/dict_fsst/issue_5675.test @@ -0,0 +1,37 @@ +# source: test/sql/storage/compression/dict_fsst/issue_5675.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +pragma threads=1 +-- +ok +== +CREATE TABLE TEST (col VARCHAR); +-- +ok +== +INSERT INTO TEST + SELECT '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' + FROM range(0,1) tbl(i); +-- +ok +== +INSERT INTO TEST + SELECT '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' + FROM range(0,90) tbl(i); +-- +ok +== +INSERT INTO TEST SELECT '' FROM range(0,100000) tbl(i); +-- +ok +== +INSERT INTO TEST values ('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'); +-- +ok +== +CREATE TABLE TEST2 as SELECT * FROM TEST; +-- +ok +== diff --git a/parser/testdata/corpus/sql/storage/compression/dict_fsst/issue_5675_followup.test b/parser/testdata/corpus/sql/storage/compression/dict_fsst/issue_5675_followup.test new file mode 100644 index 0000000..8a36b6a --- /dev/null +++ b/parser/testdata/corpus/sql/storage/compression/dict_fsst/issue_5675_followup.test @@ -0,0 +1,14 @@ +# source: test/sql/storage/compression/dict_fsst/issue_5675_followup.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +INSERT INTO TEST SELECT CASE WHEN i%2==0 + THEN + 'aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa' + ELSE + 'aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa' +END FROM range(0,2214) tbl(i); +-- +ok +== diff --git a/parser/testdata/corpus/sql/storage/compression/dict_fsst/issue_5759.test b/parser/testdata/corpus/sql/storage/compression/dict_fsst/issue_5759.test new file mode 100644 index 0000000..68ce275 --- /dev/null +++ b/parser/testdata/corpus/sql/storage/compression/dict_fsst/issue_5759.test @@ -0,0 +1,13 @@ +# source: test/sql/storage/compression/dict_fsst/issue_5759.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +pragma force_compression='dict_fsst' +-- +ok +== +CREATE TABLE trigger5759 AS SELECT CASE WHEN RANDOM() > 0.95 THEN repeat('ab', 1500) ELSE 'c' END FROM range(0,1000); +-- +ok +== diff --git a/parser/testdata/corpus/sql/storage/compression/dict_fsst/repeated_string_stats.test b/parser/testdata/corpus/sql/storage/compression/dict_fsst/repeated_string_stats.test new file mode 100644 index 0000000..e5fb928 --- /dev/null +++ b/parser/testdata/corpus/sql/storage/compression/dict_fsst/repeated_string_stats.test @@ -0,0 +1,32 @@ +# source: test/sql/storage/compression/dict_fsst/repeated_string_stats.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +CREATE TABLE repeated AS +SELECT repeat(lpad((i % 200)::VARCHAR, 3, '0'), 20) AS value +FROM range(100000) t(i) +-- +ok +== +SELECT s.min_string_length, s.max_string_length, s.total_string_length +FROM (SELECT stats(value) s FROM repeated LIMIT 1) +-- +ok +== +CREATE TABLE repeated_unicode AS +SELECT CASE i % 4 + WHEN 0 THEN 'alpha' + WHEN 1 THEN 'βeta' + WHEN 2 THEN 'zebra-long' + ELSE NULL +END AS value +FROM range(10000) t(i) +-- +ok +== +SELECT s.min_string_length, s.max_string_length, s.total_string_length, s.has_unicode, s.has_null, s.has_no_null +FROM (SELECT stats(value) s FROM repeated_unicode LIMIT 1) +-- +ok +== diff --git a/parser/testdata/corpus/sql/storage/compression/dict_fsst/test_dict_fsst_with_smaller_block_size.test b/parser/testdata/corpus/sql/storage/compression/dict_fsst/test_dict_fsst_with_smaller_block_size.test new file mode 100644 index 0000000..ea0a4cd --- /dev/null +++ b/parser/testdata/corpus/sql/storage/compression/dict_fsst/test_dict_fsst_with_smaller_block_size.test @@ -0,0 +1,33 @@ +# source: test/sql/storage/compression/dict_fsst/test_dict_fsst_with_smaller_block_size.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +SET storage_compatibility_version='latest'; +-- +ok +== +ATTACH '{TEMP_DIR}/partial_manager.db' AS db (BLOCK_SIZE 16384); +-- +ok +== +CREATE TABLE db.t AS FROM read_csv('{DATA_DIR}/csv/rabo-anon.csv.gz', strict_mode=FALSE); +-- +ok +== +ATTACH '{TEMP_DIR}/partial_manager.db' AS db; +-- +ok +== +SELECT COUNT("XXX XXX/XXX") FROM db.t WHERE "XXX XXX/XXX" IS NOT NULL; +-- +ok +== +SELECT COUNT(*) FROM db.t WHERE "XXX XXX/XXX" IS NULL; +-- +ok +== +SELECT * FROM db.t; +-- +ok +== diff --git a/parser/testdata/corpus/sql/storage/compression/dict_fsst/test_null_filter_pushdown.test b/parser/testdata/corpus/sql/storage/compression/dict_fsst/test_null_filter_pushdown.test new file mode 100644 index 0000000..5a50f23 --- /dev/null +++ b/parser/testdata/corpus/sql/storage/compression/dict_fsst/test_null_filter_pushdown.test @@ -0,0 +1,21 @@ +# source: test/sql/storage/compression/dict_fsst/test_null_filter_pushdown.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +pragma force_compression='DICT_FSST'; +-- +ok +== +CREATE OR REPLACE TABLE t1(type VARCHAR, id VARCHAR, problem VARCHAR); +-- +ok +== +INSERT INTO t1(type,id,problem) select 'events', 'test', NULL from range(40) +-- +ok +== +SELECT COUNT(*) FROM t1 WHERE problem IS NULL; +-- +ok +== diff --git a/parser/testdata/corpus/sql/storage/compression/dict_fsst/test_null_update.test b/parser/testdata/corpus/sql/storage/compression/dict_fsst/test_null_update.test new file mode 100644 index 0000000..dbb0558 --- /dev/null +++ b/parser/testdata/corpus/sql/storage/compression/dict_fsst/test_null_update.test @@ -0,0 +1,24 @@ +# source: test/sql/storage/compression/dict_fsst/test_null_update.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +CREATE OR REPLACE TABLE t( + compressed VARCHAR USING COMPRESSION 'DICT_FSST' +); +-- +ok +== +INSERT INTO t VALUES + ('Error3'); +-- +ok +== +UPDATE t SET compressed = NULL; +-- +ok +== +SELECT * FROM t AS e WHERE e.compressed IS NULL; +-- +ok +== diff --git a/parser/testdata/corpus/sql/storage/compression/dictionary/dict_corrupted_offset.test b/parser/testdata/corpus/sql/storage/compression/dictionary/dict_corrupted_offset.test new file mode 100644 index 0000000..733f6a6 --- /dev/null +++ b/parser/testdata/corpus/sql/storage/compression/dictionary/dict_corrupted_offset.test @@ -0,0 +1,13 @@ +# source: test/sql/storage/compression/dictionary/dict_corrupted_offset.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +ATTACH '{TEST_DIR}/dict_corrupted_offset.db' AS db2 +-- +ok +== +SELECT compression FROM pragma_storage_info('t') WHERE compression='Dictionary' LIMIT 1; +-- +ok +== diff --git a/parser/testdata/corpus/sql/storage/compression/dictionary/dictionary_storage_info.test b/parser/testdata/corpus/sql/storage/compression/dictionary/dictionary_storage_info.test new file mode 100644 index 0000000..dd73105 --- /dev/null +++ b/parser/testdata/corpus/sql/storage/compression/dictionary/dictionary_storage_info.test @@ -0,0 +1,9 @@ +# source: test/sql/storage/compression/dictionary/dictionary_storage_info.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +PRAGMA force_compression = 'dictionary' +-- +ok +== diff --git a/parser/testdata/corpus/sql/storage/compression/dictionary/fetch_row.test b/parser/testdata/corpus/sql/storage/compression/dictionary/fetch_row.test new file mode 100644 index 0000000..7aae443 --- /dev/null +++ b/parser/testdata/corpus/sql/storage/compression/dictionary/fetch_row.test @@ -0,0 +1,30 @@ +# source: test/sql/storage/compression/dictionary/fetch_row.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +CREATE TABLE test ( + a INTEGER, + b VARCHAR +); +-- +ok +== +INSERT INTO test (a, b) +SELECT + x AS a, + CASE x % 5 + WHEN 0 THEN 'aaaa' + WHEN 1 THEN 'bbbb' + WHEN 2 THEN 'cccc' + WHEN 3 THEN 'dddd' + WHEN 4 THEN NULL + END AS b +FROM range(10_000) t(x); +-- +ok +== +select distinct b from test order by a % 5; +-- +ok +== diff --git a/parser/testdata/corpus/sql/storage/compression/dictionary/invalid_dictionary_metadata.test b/parser/testdata/corpus/sql/storage/compression/dictionary/invalid_dictionary_metadata.test new file mode 100644 index 0000000..96f0a81 --- /dev/null +++ b/parser/testdata/corpus/sql/storage/compression/dictionary/invalid_dictionary_metadata.test @@ -0,0 +1,77 @@ +# source: test/sql/storage/compression/dictionary/invalid_dictionary_metadata.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +ATTACH '{TEST_DIR}/dictionary_invalid_offset.db' AS offset_db +-- +ok +== +SELECT count(*) FROM pragma_storage_info('offset_db.tbl') WHERE compression='Dictionary' +-- +ok +== +SELECT sum(length(STREET)) FROM offset_db.tbl +-- +ok +== +ATTACH '{TEST_DIR}/dictionary_invalid_index.db' AS index_db +-- +ok +== +SELECT count(*) FROM pragma_storage_info('index_db.tbl') WHERE compression='Dictionary' +-- +ok +== +SELECT sum(length(STREET)) FROM index_db.tbl +-- +ok +== +ATTACH '{TEST_DIR}/dictionary_invalid_dict_end.db' AS dict_end_db +-- +ok +== +SELECT count(*) FROM pragma_storage_info('dict_end_db.tbl') WHERE compression='Dictionary' +-- +ok +== +SELECT sum(length(STREET)) FROM dict_end_db.tbl +-- +ok +== +ATTACH '{TEST_DIR}/dictionary_invalid_bitpacking_width.db' AS bitpacking_width_db +-- +ok +== +SELECT count(*) FROM pragma_storage_info('bitpacking_width_db.tbl') WHERE compression='Dictionary' +-- +ok +== +SELECT sum(length(STREET)) FROM bitpacking_width_db.tbl +-- +ok +== +ATTACH '{TEST_DIR}/dictionary_invalid_selection_buffer.db' AS selection_buffer_db +-- +ok +== +SELECT count(*) FROM pragma_storage_info('selection_buffer_db.tbl') WHERE compression='Dictionary' +-- +ok +== +SELECT sum(length(STREET)) FROM selection_buffer_db.tbl +-- +ok +== +ATTACH '{TEST_DIR}/dictionary_invalid_segment_end.db' AS segment_end_db +-- +ok +== +SELECT block_offset FROM pragma_storage_info('segment_end_db.tbl') WHERE compression='Dictionary' AND column_name='street' +-- +ok +== +SELECT sum(length(STREET)) FROM segment_end_db.tbl +-- +ok +== diff --git a/parser/testdata/corpus/sql/storage/compression/dictionary/total_string_length_dictionary.test b/parser/testdata/corpus/sql/storage/compression/dictionary/total_string_length_dictionary.test new file mode 100644 index 0000000..fd3c17f --- /dev/null +++ b/parser/testdata/corpus/sql/storage/compression/dictionary/total_string_length_dictionary.test @@ -0,0 +1,21 @@ +# source: test/sql/storage/compression/dictionary/total_string_length_dictionary.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +CREATE TABLE t (s VARCHAR); +-- +ok +== +INSERT INTO t SELECT 'hello' FROM range(10000); +-- +ok +== +SELECT compression FROM pragma_storage_info('t') WHERE segment_type ILIKE 'VARCHAR' LIMIT 1 +-- +ok +== +select s.total_string_length from (select stats(s) s from t limit 1) +-- +ok +== diff --git a/parser/testdata/corpus/sql/storage/compression/fsst/fsst_disable_compression.test b/parser/testdata/corpus/sql/storage/compression/fsst/fsst_disable_compression.test new file mode 100644 index 0000000..de34e56 --- /dev/null +++ b/parser/testdata/corpus/sql/storage/compression/fsst/fsst_disable_compression.test @@ -0,0 +1,21 @@ +# source: test/sql/storage/compression/fsst/fsst_disable_compression.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +CREATE TABLE test AS SELECT concat('longprefix', i) FROM range(30000) t(i); +-- +ok +== +SELECT DISTINCT compression FROM pragma_storage_info('test') where segment_type = 'VARCHAR'; +-- +ok +== +SET disabled_compression_methods='fsst' +-- +ok +== +SELECT BOOL_OR(compression ILIKE 'fsst%') FROM pragma_storage_info('test') +-- +ok +== diff --git a/parser/testdata/corpus/sql/storage/compression/fsst/fsst_greedy_long_strings.test b/parser/testdata/corpus/sql/storage/compression/fsst/fsst_greedy_long_strings.test new file mode 100644 index 0000000..d156145 --- /dev/null +++ b/parser/testdata/corpus/sql/storage/compression/fsst/fsst_greedy_long_strings.test @@ -0,0 +1,27 @@ +# source: test/sql/storage/compression/fsst/fsst_greedy_long_strings.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +SET force_compression = 'fsst'; +-- +ok +== +ATTACH '{TEST_DIR}/fsst_greedy.db' AS db + (BLOCK_SIZE 262144, STORAGE_VERSION 'v1.2.0'); +-- +ok +== +CREATE TABLE db.t AS SELECT + repeat('x', 510) || 'abcdefghij' || lpad(i::VARCHAR, 8, '0') AS s +FROM range(3500) t(i); +-- +ok +== +SELECT count(*) +FROM pragma_storage_info('db.t') +WHERE column_name = 's' + AND compression = 'FSST'; +-- +ok +== diff --git a/parser/testdata/corpus/sql/storage/compression/fsst/fsst_small_symbol_table.test b/parser/testdata/corpus/sql/storage/compression/fsst/fsst_small_symbol_table.test new file mode 100644 index 0000000..f600095 --- /dev/null +++ b/parser/testdata/corpus/sql/storage/compression/fsst/fsst_small_symbol_table.test @@ -0,0 +1,31 @@ +# source: test/sql/storage/compression/fsst/fsst_small_symbol_table.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +ATTACH '{TEST_DIR}/fsst_small_symbol_table.db' AS db1 (BLOCK_SIZE 16384, STORAGE_VERSION 'v1.0.0') +-- +ok +== +PRAGMA force_compression='fsst' +-- +ok +== +CREATE TABLE t AS +SELECT CASE WHEN i % 997 = 0 THEN concat('BEEPBOOP-', (i % 3)::VARCHAR) ELSE '' END AS c0 +FROM range(200000) tab(i); +-- +ok +== +SELECT DISTINCT compression FROM pragma_storage_info('t') WHERE segment_type ILIKE 'VARCHAR' +-- +ok +== +SELECT count(*) FILTER (WHERE c0 <> '') FROM t +-- +ok +== +SELECT c0, count(*) FROM t WHERE c0 <> '' GROUP BY c0 ORDER BY c0 +-- +ok +== diff --git a/parser/testdata/corpus/sql/storage/compression/fsst/fsst_storage_info.test b/parser/testdata/corpus/sql/storage/compression/fsst/fsst_storage_info.test new file mode 100644 index 0000000..2ad0928 --- /dev/null +++ b/parser/testdata/corpus/sql/storage/compression/fsst/fsst_storage_info.test @@ -0,0 +1,9 @@ +# source: test/sql/storage/compression/fsst/fsst_storage_info.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +PRAGMA force_compression = 'fsst' +-- +ok +== diff --git a/parser/testdata/corpus/sql/storage/compression/fsst/invalid_fsst_bitpacking_width.test b/parser/testdata/corpus/sql/storage/compression/fsst/invalid_fsst_bitpacking_width.test new file mode 100644 index 0000000..21d1beb --- /dev/null +++ b/parser/testdata/corpus/sql/storage/compression/fsst/invalid_fsst_bitpacking_width.test @@ -0,0 +1,17 @@ +# source: test/sql/storage/compression/fsst/invalid_fsst_bitpacking_width.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +ATTACH '{TEST_DIR}/fsst_invalid_bitpacking_width.db' AS invalid_fsst_db +-- +ok +== +USE invalid_fsst_db +-- +ok +== +SELECT sum(length(STREET)) FROM tbl +-- +ok +== diff --git a/parser/testdata/corpus/sql/storage/compression/fsst/issue_5675.test b/parser/testdata/corpus/sql/storage/compression/fsst/issue_5675.test new file mode 100644 index 0000000..d57c49d --- /dev/null +++ b/parser/testdata/corpus/sql/storage/compression/fsst/issue_5675.test @@ -0,0 +1,9 @@ +# source: test/sql/storage/compression/fsst/issue_5675.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +pragma force_compression='fsst'; +-- +ok +== diff --git a/parser/testdata/corpus/sql/storage/compression/fsst/issue_5759.test b/parser/testdata/corpus/sql/storage/compression/fsst/issue_5759.test new file mode 100644 index 0000000..9766767 --- /dev/null +++ b/parser/testdata/corpus/sql/storage/compression/fsst/issue_5759.test @@ -0,0 +1,9 @@ +# source: test/sql/storage/compression/fsst/issue_5759.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +pragma force_compression='fsst' +-- +ok +== diff --git a/parser/testdata/corpus/sql/storage/compression/patas/patas_corrupted_file.test b/parser/testdata/corpus/sql/storage/compression/patas/patas_corrupted_file.test new file mode 100644 index 0000000..8444f59 --- /dev/null +++ b/parser/testdata/corpus/sql/storage/compression/patas/patas_corrupted_file.test @@ -0,0 +1,13 @@ +# source: test/sql/storage/compression/patas/patas_corrupted_file.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +SELECT compression FROM pragma_storage_info('temperatures_double') WHERE compression='Patas'; +-- +ok +== +SELECT * FROM temperatures_double LIMIT 1; +-- +ok +== diff --git a/parser/testdata/corpus/sql/storage/compression/rle/force_rle.test b/parser/testdata/corpus/sql/storage/compression/rle/force_rle.test new file mode 100644 index 0000000..c743a3c --- /dev/null +++ b/parser/testdata/corpus/sql/storage/compression/rle/force_rle.test @@ -0,0 +1,17 @@ +# source: test/sql/storage/compression/rle/force_rle.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +PRAGMA force_compression = 'rle' +-- +ok +== +INSERT INTO test_rle SELECT i FROM range(0, 2000) tbl(i); +-- +ok +== +SELECT compression FROM pragma_storage_info('test_rle') WHERE segment_type ILIKE 'INTEGER' +-- +ok +== diff --git a/parser/testdata/corpus/sql/storage/compression/rle/rle_bool.test b/parser/testdata/corpus/sql/storage/compression/rle/rle_bool.test new file mode 100644 index 0000000..8de0144 --- /dev/null +++ b/parser/testdata/corpus/sql/storage/compression/rle/rle_bool.test @@ -0,0 +1,21 @@ +# source: test/sql/storage/compression/rle/rle_bool.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +CREATE TABLE test (a BOOLEAN); +-- +ok +== +INSERT INTO test select false from range(2048); +-- +ok +== +INSERT INTO test select true from range(2048); +-- +ok +== +SELECT COUNT(*) FROM test WHERE a=false +-- +ok +== diff --git a/parser/testdata/corpus/sql/storage/compression/rle/rle_constant.test b/parser/testdata/corpus/sql/storage/compression/rle/rle_constant.test new file mode 100644 index 0000000..114251a --- /dev/null +++ b/parser/testdata/corpus/sql/storage/compression/rle/rle_constant.test @@ -0,0 +1,53 @@ +# source: test/sql/storage/compression/rle/rle_constant.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +INSERT INTO test select 0 from range(4096); +-- +ok +== +INSERT INTO test select 1 from range(2048); +-- +ok +== +INSERT INTO test select 2 from range(2048); +-- +ok +== +INSERT INTO test select 3 from range(1024) +-- +ok +== +INSERT INTO test select 4 from range(1024) +-- +ok +== +INSERT INTO test select 5 from range(512) +-- +ok +== +INSERT INTO test select 6 from range(512) +-- +ok +== +INSERT INTO test select 7 from range(512) +-- +ok +== +INSERT INTO test select 8 from range(512) +-- +ok +== +select distinct on (types) vector_type(a) as types from test order by all; +-- +ok +== +select distinct on (types) types from (select vector_type(a) from test limit 8192) tbl(types) +-- +ok +== +select distinct on (types) types from (select vector_type(a) from test offset 8192) tbl(types) +-- +ok +== diff --git a/parser/testdata/corpus/sql/storage/compression/rle/rle_corrupted_count_offset.test b/parser/testdata/corpus/sql/storage/compression/rle/rle_corrupted_count_offset.test new file mode 100644 index 0000000..39a03a7 --- /dev/null +++ b/parser/testdata/corpus/sql/storage/compression/rle/rle_corrupted_count_offset.test @@ -0,0 +1,9 @@ +# source: test/sql/storage/compression/rle/rle_corrupted_count_offset.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +SELECT compression FROM pragma_storage_info('t') WHERE compression='RLE'; +-- +ok +== diff --git a/parser/testdata/corpus/sql/storage/compression/rle/rle_filter.test b/parser/testdata/corpus/sql/storage/compression/rle/rle_filter.test new file mode 100644 index 0000000..09e9780 --- /dev/null +++ b/parser/testdata/corpus/sql/storage/compression/rle/rle_filter.test @@ -0,0 +1,25 @@ +# source: test/sql/storage/compression/rle/rle_filter.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +CREATE TABLE tbl AS SELECT i id, i // 50 rle_val, case when i%8=0 then null else i // 50 end rle_val_null FROM range(100000) t(i); +-- +ok +== +SELECT * FROM tbl WHERE id = 5040 AND rle_val=100 +-- +ok +== +SELECT * FROM tbl WHERE id = 5040 AND substr(rle_val::VARCHAR, 1, 3)='100' +-- +ok +== +SELECT * FROM tbl WHERE id >= 5020 AND rle_val=100 +-- +ok +== +SELECT * FROM tbl WHERE rle_val=100 +-- +ok +== diff --git a/parser/testdata/corpus/sql/storage/compression/rle/rle_filter_pushdown.test b/parser/testdata/corpus/sql/storage/compression/rle/rle_filter_pushdown.test new file mode 100644 index 0000000..a86132f --- /dev/null +++ b/parser/testdata/corpus/sql/storage/compression/rle/rle_filter_pushdown.test @@ -0,0 +1,21 @@ +# source: test/sql/storage/compression/rle/rle_filter_pushdown.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +CREATE TABLE test (id VARCHAR, col INTEGER); +-- +ok +== +INSERT INTO test SELECT i::VARCHAR id, 1 b FROM range(5000) tbl(i) +-- +ok +== +INSERT INTO test SELECT (5000 + i)::VARCHAR id, 2 b FROM range(5000) tbl(i) +-- +ok +== +SELECT SUM(col), MIN(col), MAX(col), COUNT(*) FROM test WHERE col=2 +-- +ok +== diff --git a/parser/testdata/corpus/sql/storage/compression/rle/rle_index_fetch.test b/parser/testdata/corpus/sql/storage/compression/rle/rle_index_fetch.test new file mode 100644 index 0000000..7f8e4e9 --- /dev/null +++ b/parser/testdata/corpus/sql/storage/compression/rle/rle_index_fetch.test @@ -0,0 +1,9 @@ +# source: test/sql/storage/compression/rle/rle_index_fetch.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +CREATE TABLE test(id INTEGER PRIMARY KEY, col INTEGER); +-- +ok +== diff --git a/parser/testdata/corpus/sql/storage/compression/rle/rle_medium.test b/parser/testdata/corpus/sql/storage/compression/rle/rle_medium.test new file mode 100644 index 0000000..aa643df --- /dev/null +++ b/parser/testdata/corpus/sql/storage/compression/rle/rle_medium.test @@ -0,0 +1,18 @@ +# source: test/sql/storage/compression/rle/rle_medium.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +INSERT INTO test SELECT * FROM repeat(1, 1000); +INSERT INTO test SELECT * FROM repeat(2, 1000); +INSERT INTO test SELECT * FROM repeat(3, 1000); +INSERT INTO test SELECT * FROM repeat(4, 1000); +INSERT INTO test SELECT * FROM repeat(5, 1000); +INSERT INTO test SELECT * FROM repeat(6, 1000); +-- +ok +== +SELECT SUM(a), MIN(a), MAX(a), COUNT(*) FROM test +-- +ok +== diff --git a/parser/testdata/corpus/sql/storage/compression/rle/rle_nulls_edge_case.test b/parser/testdata/corpus/sql/storage/compression/rle/rle_nulls_edge_case.test new file mode 100644 index 0000000..8880657 --- /dev/null +++ b/parser/testdata/corpus/sql/storage/compression/rle/rle_nulls_edge_case.test @@ -0,0 +1,29 @@ +# source: test/sql/storage/compression/rle/rle_nulls_edge_case.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +PRAGMA force_compression='RLE'; +-- +ok +== +INSERT INTO integers SELECT NULL FROM range(65535); +-- +ok +== +INSERT INTO integers SELECT 1; +-- +ok +== +INSERT INTO integers SELECT 2; +-- +ok +== +INSERT INTO integers SELECT 3; +-- +ok +== +SELECT MIN(i), MAX(i), COUNT(*), COUNT(i) FROM integers; +-- +ok +== diff --git a/parser/testdata/corpus/sql/storage/compression/rle/rle_select.test b/parser/testdata/corpus/sql/storage/compression/rle/rle_select.test new file mode 100644 index 0000000..3ab058b --- /dev/null +++ b/parser/testdata/corpus/sql/storage/compression/rle/rle_select.test @@ -0,0 +1,25 @@ +# source: test/sql/storage/compression/rle/rle_select.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +SELECT * FROM tbl WHERE id >= 75 and id <= 125 and id%4=0 +-- +ok +== +SELECT * FROM tbl WHERE id >= 33380 and id <= 33410 and id%4=0 +-- +ok +== +CREATE TABLE tbl2 AS SELECT i id, i%5 id_modulo, i // 50 rle_val, case when i%8=0 then null else i // 50 end rle_val_null FROM range(100000) t(i); +-- +ok +== +SELECT COUNT(*), SUM(rle_val), MIN(rle_val), MAX(rle_val), SUM(rle_val_null), COUNT(rle_val_null) FROM tbl2 WHERE id >= 1500 and id <= 2500 AND id_modulo=3; +-- +ok +== +SELECT COUNT(*), SUM(rle_val), MIN(rle_val), MAX(rle_val), SUM(rle_val_null), COUNT(rle_val_null) FROM tbl2 WHERE id >= 1500 and id <= 19500 AND id_modulo<=2; +-- +ok +== diff --git a/parser/testdata/corpus/sql/storage/compression/rle/rle_select_list.test b/parser/testdata/corpus/sql/storage/compression/rle/rle_select_list.test new file mode 100644 index 0000000..3b2dc6b --- /dev/null +++ b/parser/testdata/corpus/sql/storage/compression/rle/rle_select_list.test @@ -0,0 +1,31 @@ +# source: test/sql/storage/compression/rle/rle_select_list.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +pragma force_compression='rle'; +-- +ok +== +create table tbl as SELECT * FROM ( + VALUES + (['first name', 'last name', 'username'], 60), + (['first name'], 0), + (['username'], 0), + (['first name', 'last name', 'username'], 0), + (['first name', 'last name', 'username'], 0), + (['username'], 0), + (['username'], 0) +) AS t(attributes, minutes_duration); +-- +ok +== +SELECT + "minutes_duration" +FROM + tbl +WHERE NOT list_sort(['first name']) = tbl."attributes" +ORDER BY ALL +-- +ok +== diff --git a/parser/testdata/corpus/sql/storage/compression/rle/struct_rle.test b/parser/testdata/corpus/sql/storage/compression/rle/struct_rle.test new file mode 100644 index 0000000..ce90adb --- /dev/null +++ b/parser/testdata/corpus/sql/storage/compression/rle/struct_rle.test @@ -0,0 +1,14 @@ +# source: test/sql/storage/compression/rle/struct_rle.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +INSERT INTO test SELECT {'a': i} s FROM repeat(1, 1000) tbl(i); +INSERT INTO test SELECT {'a': i} s FROM repeat(2, 1000) tbl(i); +INSERT INTO test SELECT {'a': i} s FROM repeat(3, 1000) tbl(i); +INSERT INTO test SELECT {'a': i} s FROM repeat(4, 1000) tbl(i); +INSERT INTO test SELECT {'a': i} s FROM repeat(5, 1000) tbl(i); +INSERT INTO test SELECT {'a': i} s FROM repeat(6, 1000) tbl(i); +-- +ok +== diff --git a/parser/testdata/corpus/sql/storage/compression/roaring/roaring_analyze_array.test b/parser/testdata/corpus/sql/storage/compression/roaring/roaring_analyze_array.test new file mode 100644 index 0000000..55cfcb1 --- /dev/null +++ b/parser/testdata/corpus/sql/storage/compression/roaring/roaring_analyze_array.test @@ -0,0 +1,49 @@ +# source: test/sql/storage/compression/roaring/roaring_analyze_array.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +set variable dataset_size = 122880; +-- +ok +== +CALL enable_logging(level='trace') +-- +ok +== +CREATE TABLE test_uncompressed AS SELECT + case + when i%25=0 + then 1337 + else null + end + FROM range(getvariable('dataset_size')) tbl(i); +-- +ok +== +SELECT message.split(': ')[2]::INTEGER FROM duckdb_logs +where + message.starts_with('ColumnDataCheckpointer FinalAnalyze') and + message.contains('test_uncompressed') and + message.contains('VALIDITY') and + message.contains('UNCOMPRESSED'); +-- +ok +== +PRAGMA force_compression='roaring' +-- +ok +== +CREATE TABLE test_roaring AS select * from test_uncompressed; +-- +ok +== +SELECT message.split(': ')[2]::INTEGER FROM duckdb_logs +where + message.starts_with('ColumnDataCheckpointer FinalAnalyze') and + message.contains('test_roaring') and + message.contains('VALIDITY') and + message.contains('ROARING'); +-- +ok +== diff --git a/parser/testdata/corpus/sql/storage/compression/roaring/roaring_analyze_bitset.test b/parser/testdata/corpus/sql/storage/compression/roaring/roaring_analyze_bitset.test new file mode 100644 index 0000000..b8df7ef --- /dev/null +++ b/parser/testdata/corpus/sql/storage/compression/roaring/roaring_analyze_bitset.test @@ -0,0 +1,15 @@ +# source: test/sql/storage/compression/roaring/roaring_analyze_bitset.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +CREATE TABLE test_uncompressed AS SELECT + case + when i%3=0 + then 1337 + else null + end + FROM range(getvariable('dataset_size')) tbl(i); +-- +ok +== diff --git a/parser/testdata/corpus/sql/storage/compression/roaring/roaring_analyze_run.test b/parser/testdata/corpus/sql/storage/compression/roaring/roaring_analyze_run.test new file mode 100644 index 0000000..a4a7fdb --- /dev/null +++ b/parser/testdata/corpus/sql/storage/compression/roaring/roaring_analyze_run.test @@ -0,0 +1,15 @@ +# source: test/sql/storage/compression/roaring/roaring_analyze_run.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +CREATE TABLE test_uncompressed AS SELECT + case + when i = 0 or (i % 512 != 0 and (i % 512) < 350 or (i % 512) > 450) + then null + else 1337 + end + FROM range(getvariable('dataset_size')) tbl(i); +-- +ok +== diff --git a/parser/testdata/corpus/sql/storage/compression/roaring/roaring_array_simple.test b/parser/testdata/corpus/sql/storage/compression/roaring/roaring_array_simple.test new file mode 100644 index 0000000..02111e4 --- /dev/null +++ b/parser/testdata/corpus/sql/storage/compression/roaring/roaring_array_simple.test @@ -0,0 +1,36 @@ +# source: test/sql/storage/compression/roaring/roaring_array_simple.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +INSERT INTO test SELECT case when i%25=0 then 1337 else null end FROM range(0,10000) tbl(i); +-- +ok +== +SELECT compression FROM pragma_storage_info('test') WHERE segment_type ILIKE 'VALIDITY' and compression != 'Roaring'; +-- +ok +== +select count(*) from test WHERE a IS NOT NULL; +-- +ok +== +delete from test +-- +ok +== +with intermediates as ( + select i % 2048 as i + from range(0, 10_000) t(i) +) +insert into test select case when + i = 0 or + i = 6 or + i = 1000 or + i = 1500 or + i = 2000 + then 1337 +else null end from intermediates; +-- +ok +== diff --git a/parser/testdata/corpus/sql/storage/compression/roaring/roaring_bitset_simple.test b/parser/testdata/corpus/sql/storage/compression/roaring/roaring_bitset_simple.test new file mode 100644 index 0000000..5c3db4b --- /dev/null +++ b/parser/testdata/corpus/sql/storage/compression/roaring/roaring_bitset_simple.test @@ -0,0 +1,21 @@ +# source: test/sql/storage/compression/roaring/roaring_bitset_simple.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +INSERT INTO test SELECT CASE WHEN i % 3 = 0 THEN 1337 ELSE NULL END FROM range(0, 10000) tbl(i); +-- +ok +== +SELECT compression FROM pragma_storage_info('test') WHERE segment_type ILIKE 'VALIDITY' AND compression != 'Roaring'; +-- +ok +== +SELECT COUNT(*) FROM test WHERE a IS NOT NULL; +-- +ok +== +SELECT SUM(a), MIN(a), MAX(a) FROM test; +-- +ok +== diff --git a/parser/testdata/corpus/sql/storage/compression/roaring/roaring_bool_analyze_array.test b/parser/testdata/corpus/sql/storage/compression/roaring/roaring_bool_analyze_array.test new file mode 100644 index 0000000..e0fd087 --- /dev/null +++ b/parser/testdata/corpus/sql/storage/compression/roaring/roaring_bool_analyze_array.test @@ -0,0 +1,37 @@ +# source: test/sql/storage/compression/roaring/roaring_bool_analyze_array.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +PRAGMA force_compression='BitPacking' +-- +ok +== +CREATE TABLE test_uncompressed AS SELECT + case + when i%25=0 + then true + else false + end + FROM range(getvariable('dataset_size')) tbl(i); +-- +ok +== +SELECT message.split(': ')[2]::INTEGER FROM duckdb_logs +where + message.starts_with('ColumnDataCheckpointer FinalAnalyze') and + message.contains('test_uncompressed') and + message.contains('BOOLEAN') and + message.contains('BITPACKING'); +-- +ok +== +SELECT message.split(': ')[2]::INTEGER FROM duckdb_logs +where + message.starts_with('ColumnDataCheckpointer FinalAnalyze') and + message.contains('test_roaring') and + message.contains('BOOLEAN') and + message.contains('ROARING'); +-- +ok +== diff --git a/parser/testdata/corpus/sql/storage/compression/roaring/roaring_bool_analyze_bitset.test b/parser/testdata/corpus/sql/storage/compression/roaring/roaring_bool_analyze_bitset.test new file mode 100644 index 0000000..4b346d9 --- /dev/null +++ b/parser/testdata/corpus/sql/storage/compression/roaring/roaring_bool_analyze_bitset.test @@ -0,0 +1,15 @@ +# source: test/sql/storage/compression/roaring/roaring_bool_analyze_bitset.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +CREATE TABLE test_uncompressed AS SELECT + case + when i%3=0 + then true + else false + end + FROM range(getvariable('dataset_size')) tbl(i); +-- +ok +== diff --git a/parser/testdata/corpus/sql/storage/compression/roaring/roaring_bool_analyze_run.test b/parser/testdata/corpus/sql/storage/compression/roaring/roaring_bool_analyze_run.test new file mode 100644 index 0000000..71dbef3 --- /dev/null +++ b/parser/testdata/corpus/sql/storage/compression/roaring/roaring_bool_analyze_run.test @@ -0,0 +1,15 @@ +# source: test/sql/storage/compression/roaring/roaring_bool_analyze_run.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +CREATE TABLE test_uncompressed AS SELECT + case + when i = 0 or (i % 512 != 0 and (i % 512) < 350 or (i % 512) > 450) + then false + else true + end + FROM range(getvariable('dataset_size')) tbl(i); +-- +ok +== diff --git a/parser/testdata/corpus/sql/storage/compression/roaring/roaring_bool_array_simple.test b/parser/testdata/corpus/sql/storage/compression/roaring/roaring_bool_array_simple.test new file mode 100644 index 0000000..dc4abe3 --- /dev/null +++ b/parser/testdata/corpus/sql/storage/compression/roaring/roaring_bool_array_simple.test @@ -0,0 +1,36 @@ +# source: test/sql/storage/compression/roaring/roaring_bool_array_simple.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +CREATE TABLE test (a BOOL); +-- +ok +== +INSERT INTO test SELECT case when i%25=0 then true else false end FROM range(0,10000) tbl(i); +-- +ok +== +SELECT compression FROM pragma_storage_info('test') WHERE segment_type ILIKE 'BOOLEAN' and compression != 'Roaring'; +-- +ok +== +select count(*) from test WHERE a IS true; +-- +ok +== +with intermediates as ( + select i % 2048 as i + from range(0, 10_000) t(i) +) +insert into test select case when + i = 0 or + i = 6 or + i = 1000 or + i = 1500 or + i = 2000 + then true +else false end from intermediates; +-- +ok +== diff --git a/parser/testdata/corpus/sql/storage/compression/roaring/roaring_bool_array_simple_w_null.test b/parser/testdata/corpus/sql/storage/compression/roaring/roaring_bool_array_simple_w_null.test new file mode 100644 index 0000000..9d64293 --- /dev/null +++ b/parser/testdata/corpus/sql/storage/compression/roaring/roaring_bool_array_simple_w_null.test @@ -0,0 +1,35 @@ +# source: test/sql/storage/compression/roaring/roaring_bool_array_simple_w_null.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +INSERT INTO test SELECT +case + when i%50=0 then false + when i%25=0 then true + else NULL +end +FROM range(0,10_000) tbl(i); +-- +ok +== +select count(*) from test WHERE a IS NULL; +-- +ok +== +select count(*) from test WHERE a IS false; +-- +ok +== +with intermediates as ( + select i % 2048 as i + from range(0, 10_000) t(i) +) +insert into test select case + when i = 0 or i = 6 or i = 1000 then false + when i = 1500 or i = 2000 then true + else null +end from intermediates; +-- +ok +== diff --git a/parser/testdata/corpus/sql/storage/compression/roaring/roaring_bool_bitset_simple.test b/parser/testdata/corpus/sql/storage/compression/roaring/roaring_bool_bitset_simple.test new file mode 100644 index 0000000..e6a9a25 --- /dev/null +++ b/parser/testdata/corpus/sql/storage/compression/roaring/roaring_bool_bitset_simple.test @@ -0,0 +1,21 @@ +# source: test/sql/storage/compression/roaring/roaring_bool_bitset_simple.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +INSERT INTO test SELECT CASE WHEN i % 3 = 0 THEN true ELSE false END FROM range(0, 10000) tbl(i); +-- +ok +== +SELECT compression FROM pragma_storage_info('test') WHERE segment_type ILIKE 'BOOL' AND compression != 'Roaring'; +-- +ok +== +SELECT COUNT(*) FROM test WHERE a IS true; +-- +ok +== +SELECT COUNT(*) FROM test WHERE a IS false; +-- +ok +== diff --git a/parser/testdata/corpus/sql/storage/compression/roaring/roaring_bool_bitset_simple_w_null.test b/parser/testdata/corpus/sql/storage/compression/roaring/roaring_bool_bitset_simple_w_null.test new file mode 100644 index 0000000..64715db --- /dev/null +++ b/parser/testdata/corpus/sql/storage/compression/roaring/roaring_bool_bitset_simple_w_null.test @@ -0,0 +1,23 @@ +# source: test/sql/storage/compression/roaring/roaring_bool_bitset_simple_w_null.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +INSERT INTO test SELECT +CASE + WHEN i % 6 = 0 THEN true + WHEN i % 3 = 0 THEN false + ELSE NULL +END +FROM range(0, 10000) tbl(i); +-- +ok +== +SELECT compression FROM pragma_storage_info('test') WHERE segment_type ILIKE 'BOOLEAN' AND compression != 'Roaring'; +-- +ok +== +SELECT COUNT(*) FROM test WHERE a IS null; +-- +ok +== diff --git a/parser/testdata/corpus/sql/storage/compression/roaring/roaring_bool_fetch_row.test b/parser/testdata/corpus/sql/storage/compression/roaring/roaring_bool_fetch_row.test new file mode 100644 index 0000000..4768c14 --- /dev/null +++ b/parser/testdata/corpus/sql/storage/compression/roaring/roaring_bool_fetch_row.test @@ -0,0 +1,35 @@ +# source: test/sql/storage/compression/roaring/roaring_bool_fetch_row.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +CREATE TABLE test ( + a BOOL +); +-- +ok +== +pragma force_compression='roaring' +-- +ok +== +SELECT compression FROM pragma_storage_info('test') WHERE segment_type ILIKE 'VALIDITY' and compression != 'Constant'; +-- +ok +== +SELECT compression FROM pragma_storage_info('test') WHERE segment_type ILIKE 'BOOLEAN' and compression != 'Roaring'; +-- +ok +== +delete from test; +-- +ok +== +INSERT INTO test SELECT case when i = 0 or (i % 512 != 0 and (i % 512) < 350 or (i % 512) > 450) then false else true end FROM range(0,10000) tbl(i); +-- +ok +== +INSERT INTO test SELECT case when i%3=0 then true else false end FROM range(0,10000) tbl(i); +-- +ok +== diff --git a/parser/testdata/corpus/sql/storage/compression/roaring/roaring_bool_first_is_null.test b/parser/testdata/corpus/sql/storage/compression/roaring/roaring_bool_first_is_null.test new file mode 100644 index 0000000..e3d52ef --- /dev/null +++ b/parser/testdata/corpus/sql/storage/compression/roaring/roaring_bool_first_is_null.test @@ -0,0 +1,21 @@ +# source: test/sql/storage/compression/roaring/roaring_bool_first_is_null.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +PRAGMA force_compression='roaring'; +-- +ok +== +INSERT INTO test VALUES +(null), (true), (true), (true), +(true), (true), (true), (true), +(null), (null), (null), (null), +(null), (null), (null), (null), +(false), (false), (false), (false), +(false), (false), (false), (false), +(null), (true), (null), (false), +(false), (false), (false), (false); +-- +ok +== diff --git a/parser/testdata/corpus/sql/storage/compression/roaring/roaring_bool_inverted_array_simple.test b/parser/testdata/corpus/sql/storage/compression/roaring/roaring_bool_inverted_array_simple.test new file mode 100644 index 0000000..a7eee27 --- /dev/null +++ b/parser/testdata/corpus/sql/storage/compression/roaring/roaring_bool_inverted_array_simple.test @@ -0,0 +1,24 @@ +# source: test/sql/storage/compression/roaring/roaring_bool_inverted_array_simple.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +INSERT INTO test SELECT case when i%25=0 then false else true end FROM range(0,10000) tbl(i); +-- +ok +== +with intermediates as ( + select i % 2048 as i + from range(0, 10_000) t(i) +) +insert into test select case when + i = 0 or + i = 6 or + i = 1000 or + i = 1500 or + i = 2000 + then false +else true end from intermediates; +-- +ok +== diff --git a/parser/testdata/corpus/sql/storage/compression/roaring/roaring_bool_inverted_run_simple.test b/parser/testdata/corpus/sql/storage/compression/roaring/roaring_bool_inverted_run_simple.test new file mode 100644 index 0000000..0a301a4 --- /dev/null +++ b/parser/testdata/corpus/sql/storage/compression/roaring/roaring_bool_inverted_run_simple.test @@ -0,0 +1,9 @@ +# source: test/sql/storage/compression/roaring/roaring_bool_inverted_run_simple.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +INSERT INTO test SELECT case when i = 0 or (i % 512 != 0 and (i % 512) < 350 or (i % 512) > 450) then true else false end FROM range(0,10000) tbl(i); +-- +ok +== diff --git a/parser/testdata/corpus/sql/storage/compression/roaring/roaring_bool_run_simple.test b/parser/testdata/corpus/sql/storage/compression/roaring/roaring_bool_run_simple.test new file mode 100644 index 0000000..93dd378 --- /dev/null +++ b/parser/testdata/corpus/sql/storage/compression/roaring/roaring_bool_run_simple.test @@ -0,0 +1,13 @@ +# source: test/sql/storage/compression/roaring/roaring_bool_run_simple.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +with intermediates as ( + select i % 2048 as i + from range(0, 10_000) t(i) +) +INSERT INTO test SELECT case when (i >= 0 and i < 110) or (i >= 1500 and i < 1800) or (i >= 2000) then false else true end FROM intermediates; +-- +ok +== diff --git a/parser/testdata/corpus/sql/storage/compression/roaring/roaring_bool_run_simple_w_null.test b/parser/testdata/corpus/sql/storage/compression/roaring/roaring_bool_run_simple_w_null.test new file mode 100644 index 0000000..0c7830f --- /dev/null +++ b/parser/testdata/corpus/sql/storage/compression/roaring/roaring_bool_run_simple_w_null.test @@ -0,0 +1,24 @@ +# source: test/sql/storage/compression/roaring/roaring_bool_run_simple_w_null.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +INSERT INTO test +SELECT + CASE + WHEN i % 1000 < 100 THEN true + WHEN i % 1000 < 200 THEN false + ELSE NULL + END +FROM range(0, 10000) tbl(i); +-- +ok +== +SELECT compression FROM pragma_storage_info('test') WHERE segment_type ILIKE 'BOOL' and compression != 'Roaring'; +-- +ok +== +select count(*) from test WHERE a IS null; +-- +ok +== diff --git a/parser/testdata/corpus/sql/storage/compression/roaring/roaring_bool_smaller_than_vector.test b/parser/testdata/corpus/sql/storage/compression/roaring/roaring_bool_smaller_than_vector.test new file mode 100644 index 0000000..90c48c7 --- /dev/null +++ b/parser/testdata/corpus/sql/storage/compression/roaring/roaring_bool_smaller_than_vector.test @@ -0,0 +1,13 @@ +# source: test/sql/storage/compression/roaring/roaring_bool_smaller_than_vector.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +set checkpoint_threshold = '10mb'; +-- +ok +== +INSERT INTO test SELECT case when i%25=0 then true else false end FROM range(0,1025) tbl(i); +-- +ok +== diff --git a/parser/testdata/corpus/sql/storage/compression/roaring/roaring_bool_uncompressed_under_v1_5_0.test b/parser/testdata/corpus/sql/storage/compression/roaring/roaring_bool_uncompressed_under_v1_5_0.test new file mode 100644 index 0000000..5fb73c8 --- /dev/null +++ b/parser/testdata/corpus/sql/storage/compression/roaring/roaring_bool_uncompressed_under_v1_5_0.test @@ -0,0 +1,9 @@ +# source: test/sql/storage/compression/roaring/roaring_bool_uncompressed_under_v1_5_0.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +SELECT compression FROM pragma_storage_info('test') WHERE segment_type ILIKE 'BOOLEAN' and compression != 'Uncompressed'; +-- +ok +== diff --git a/parser/testdata/corpus/sql/storage/compression/roaring/roaring_corrupted_file.test b/parser/testdata/corpus/sql/storage/compression/roaring/roaring_corrupted_file.test new file mode 100644 index 0000000..0dd47c4 --- /dev/null +++ b/parser/testdata/corpus/sql/storage/compression/roaring/roaring_corrupted_file.test @@ -0,0 +1,9 @@ +# source: test/sql/storage/compression/roaring/roaring_corrupted_file.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +ATTACH '{TEST_DIR}/roaring_corrupt.db' AS db2 +-- +ok +== diff --git a/parser/testdata/corpus/sql/storage/compression/roaring/roaring_fetch_row.test b/parser/testdata/corpus/sql/storage/compression/roaring/roaring_fetch_row.test new file mode 100644 index 0000000..b3e3a90 --- /dev/null +++ b/parser/testdata/corpus/sql/storage/compression/roaring/roaring_fetch_row.test @@ -0,0 +1,19 @@ +# source: test/sql/storage/compression/roaring/roaring_fetch_row.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +CREATE TABLE test ( + a INT +); +-- +ok +== +INSERT INTO test SELECT case when i = 0 or (i % 512 != 0 and (i % 512) < 350 or (i % 512) > 450) then null else 1337 end FROM range(0,10000) tbl(i); +-- +ok +== +INSERT INTO test SELECT case when i%3=0 then 1337 else null end FROM range(0,10000) tbl(i); +-- +ok +== diff --git a/parser/testdata/corpus/sql/storage/compression/roaring/roaring_inverted_array_simple.test b/parser/testdata/corpus/sql/storage/compression/roaring/roaring_inverted_array_simple.test new file mode 100644 index 0000000..e5c8cce --- /dev/null +++ b/parser/testdata/corpus/sql/storage/compression/roaring/roaring_inverted_array_simple.test @@ -0,0 +1,24 @@ +# source: test/sql/storage/compression/roaring/roaring_inverted_array_simple.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +INSERT INTO test SELECT case when i%25=0 then null else 1337 end FROM range(0,10000) tbl(i); +-- +ok +== +with intermediates as ( + select i % 2048 as i + from range(0, 10_000) t(i) +) +insert into test select case when + i = 0 or + i = 6 or + i = 1000 or + i = 1500 or + i = 2000 + then null +else 1337 end from intermediates; +-- +ok +== diff --git a/parser/testdata/corpus/sql/storage/compression/roaring/roaring_inverted_run_simple.test b/parser/testdata/corpus/sql/storage/compression/roaring/roaring_inverted_run_simple.test new file mode 100644 index 0000000..ab16d8e --- /dev/null +++ b/parser/testdata/corpus/sql/storage/compression/roaring/roaring_inverted_run_simple.test @@ -0,0 +1,9 @@ +# source: test/sql/storage/compression/roaring/roaring_inverted_run_simple.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +INSERT INTO test SELECT case when i = 0 or (i % 512 != 0 and (i % 512) < 350 or (i % 512) > 450) then 1337 else null end FROM range(0,10000) tbl(i); +-- +ok +== diff --git a/parser/testdata/corpus/sql/storage/compression/roaring/roaring_run_simple.test b/parser/testdata/corpus/sql/storage/compression/roaring/roaring_run_simple.test new file mode 100644 index 0000000..fc1c245 --- /dev/null +++ b/parser/testdata/corpus/sql/storage/compression/roaring/roaring_run_simple.test @@ -0,0 +1,13 @@ +# source: test/sql/storage/compression/roaring/roaring_run_simple.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +with intermediates as ( + select i % 2048 as i + from range(0, 10_000) t(i) +) +INSERT INTO test SELECT case when (i >= 0 and i < 110) or (i >= 1500 and i < 1800) or (i >= 2000) then null else 1337 end FROM intermediates; +-- +ok +== diff --git a/parser/testdata/corpus/sql/storage/compression/roaring/roaring_smaller_than_vector.test b/parser/testdata/corpus/sql/storage/compression/roaring/roaring_smaller_than_vector.test new file mode 100644 index 0000000..33ec49c --- /dev/null +++ b/parser/testdata/corpus/sql/storage/compression/roaring/roaring_smaller_than_vector.test @@ -0,0 +1,9 @@ +# source: test/sql/storage/compression/roaring/roaring_smaller_than_vector.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +INSERT INTO test SELECT case when i%25=0 then 1337 else null end FROM range(0,1025) tbl(i); +-- +ok +== diff --git a/parser/testdata/corpus/sql/storage/compression/simple_compression.test b/parser/testdata/corpus/sql/storage/compression/simple_compression.test new file mode 100644 index 0000000..7d28306 --- /dev/null +++ b/parser/testdata/corpus/sql/storage/compression/simple_compression.test @@ -0,0 +1,13 @@ +# source: test/sql/storage/compression/simple_compression.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +PRAGMA force_compression = '{compression}' +-- +ok +== +SELECT SUM(a), SUM(b) FROM test +-- +ok +== diff --git a/parser/testdata/corpus/sql/storage/compression/skip_explicit_compression_analyze.test b/parser/testdata/corpus/sql/storage/compression/skip_explicit_compression_analyze.test new file mode 100644 index 0000000..c63377f --- /dev/null +++ b/parser/testdata/corpus/sql/storage/compression/skip_explicit_compression_analyze.test @@ -0,0 +1,70 @@ +# source: test/sql/storage/compression/skip_explicit_compression_analyze.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +SET checkpoint_threshold='9999GB' +-- +ok +== +CREATE TABLE test( + id BIGINT, + n INTEGER USING COMPRESSION RLE, + z VARCHAR USING COMPRESSION ZSTD, + d VARCHAR USING COMPRESSION DICTIONARY) +-- +ok +== +INSERT INTO test +SELECT i, + CASE WHEN i%257=0 THEN NULL ELSE (i%2)::INTEGER END, + CASE + WHEN i%997=0 THEN NULL + WHEN i%997=1 THEN '' + WHEN i=2048 THEN repeat('L', 300000) + ELSE concat(repeat('value-', 8), i::VARCHAR) + END, + CASE WHEN i=32 THEN repeat('x', 300000) ELSE concat('value-', (i%7)::VARCHAR) END +FROM range(4097) t(i) +-- +ok +== +SELECT count(*) FILTER ( + WHERE column_name='n' AND segment_type='INTEGER' AND compression!='RLE'), + count(*) FILTER ( + WHERE column_name='z' AND segment_type='VARCHAR' AND compression!='ZSTD'), + count(*) FILTER ( + WHERE column_name='d' AND segment_type='VARCHAR' AND compression!='Uncompressed') +FROM pragma_storage_info('test') +-- +ok +== +UPDATE test SET n=NULL WHERE id=1 +-- +ok +== +UPDATE test SET n=1 WHERE id=257 +-- +ok +== +SELECT (count(*)=4097)::INTEGER, + (count(*) FILTER (WHERE n IS DISTINCT FROM CASE + WHEN id=1 THEN NULL + WHEN id=257 THEN 1 + WHEN id%257=0 THEN NULL + ELSE (id%2)::INTEGER + END)=0)::INTEGER, + (count(*) FILTER (WHERE z IS DISTINCT FROM CASE + WHEN id%997=0 THEN NULL + WHEN id%997=1 THEN '' + WHEN id=2048 THEN repeat('L', 300000) + ELSE concat(repeat('value-', 8), id::VARCHAR) + END)=0)::INTEGER, + (count(*) FILTER (WHERE d IS DISTINCT FROM CASE + WHEN id=32 THEN repeat('x', 300000) + ELSE concat('value-', (id%7)::VARCHAR) + END)=0)::INTEGER +FROM test +-- +ok +== diff --git a/parser/testdata/corpus/sql/storage/compression/string/big_strings.test b/parser/testdata/corpus/sql/storage/compression/string/big_strings.test new file mode 100644 index 0000000..3f24394 --- /dev/null +++ b/parser/testdata/corpus/sql/storage/compression/string/big_strings.test @@ -0,0 +1,67 @@ +# source: test/sql/storage/compression/string/big_strings.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +ATTACH '{TEST_DIR}/test_big_strings_new.db' AS db_v13 (STORAGE_VERSION 'v1.3.0'); +-- +ok +== +ATTACH '{TEST_DIR}/test_big_strings_old.db' AS db_v1 (STORAGE_VERSION 'v1.0.0'); +-- +ok +== +USE db_v1 +-- +ok +== +USE db_v13 +-- +ok +== +CREATE TABLE normal_string (a VARCHAR); +-- +ok +== +INSERT INTO normal_string values (repeat('a', 3900)); +INSERT INTO normal_string values (repeat('b', 3900)); +INSERT INTO normal_string values (repeat('a', 3900)); +INSERT INTO normal_string values (repeat('b', 3900)); +-- +ok +== +SELECT list_aggr(str_split(a,''),'min'), list_aggr(str_split(a,''),'min'), strlen(a) from normal_string +-- +ok +== +SELECT lower(compression)='{compression}' FROM pragma_storage_info('normal_string') WHERE segment_type ILIKE 'VARCHAR' LIMIT 1 +-- +ok +== +CREATE TABLE big_string (a VARCHAR); +-- +ok +== +INSERT INTO big_string values (repeat('a', 8000)); +INSERT INTO big_string values (repeat('b', 8000)); +INSERT INTO big_string values (repeat('a', 8000)); +INSERT INTO big_string values (repeat('b', 8000)); +-- +ok +== +SELECT list_aggr(str_split(a,''),'min'), list_aggr(str_split(a,''),'min'), strlen(a) from big_string +-- +ok +== +SELECT lower(compression) FROM pragma_storage_info('big_string') WHERE segment_type ILIKE 'VARCHAR' LIMIT 1 +-- +ok +== +DROP TABLE big_string; +-- +ok +== +DROP TABLE normal_string; +-- +ok +== diff --git a/parser/testdata/corpus/sql/storage/compression/string/blob.test b/parser/testdata/corpus/sql/storage/compression/string/blob.test new file mode 100644 index 0000000..fcf1abd --- /dev/null +++ b/parser/testdata/corpus/sql/storage/compression/string/blob.test @@ -0,0 +1,77 @@ +# source: test/sql/storage/compression/string/blob.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +ATTACH '{TEST_DIR}/test_blob_new.db' AS db_v13 (STORAGE_VERSION 'v1.3.0'); +-- +ok +== +ATTACH '{TEST_DIR}/test_blob_old.db' AS db_v1 (STORAGE_VERSION 'v1.0.0'); +-- +ok +== +INSERT INTO blobs VALUES('\xaa\xff\xaa'), ('\xAA\xFF\xAA\xAA\xFF\xAA'), ('\xAA\xFF\xAA\xAA\xFF\xAA\xAA\xFF\xAA') +-- +ok +== +SELECT * FROM blobs +-- +ok +== +INSERT INTO blobs VALUES('\xaa\xff\xaa'), ('\xaa\xff\xaa\xaa\xff\xaa'), ('\xaa\xff\xaa\xaa\xff\xaa\xaa\xff\xaa') +-- +ok +== +SELECT lower(compression)='{compression}' FROM pragma_storage_info('blobs') WHERE segment_type ILIKE 'BLOB' LIMIT 1 +-- +ok +== +INSERT INTO blobs VALUES('\xaa1199'), ('\xaa1199aa1199'), ('\xaa1199aa1199aa1199') +-- +ok +== +INSERT INTO blobs VALUES('\xGA\xFF\xAA') +-- +ok +== +INSERT INTO blobs VALUES('\xA') +-- +ok +== +INSERT INTO blobs VALUES('\xAA\xA') +-- +ok +== +INSERT INTO blobs VALUES('blablabla\x') +-- +ok +== +CREATE TABLE blob_empty (b BYTEA); +-- +ok +== +INSERT INTO blob_empty VALUES(''), (''::BLOB) +-- +ok +== +INSERT INTO blob_empty VALUES(NULL), (NULL::BLOB) +-- +ok +== +SELECT * FROM blob_empty +-- +ok +== +SELECT lower(compression)!='fsst' FROM pragma_storage_info('blob_empty') WHERE segment_type ILIKE 'BLOB' LIMIT 1 +-- +ok +== +DROP TABLE blobs; +-- +ok +== +DROP TABLE blob_empty; +-- +ok +== diff --git a/parser/testdata/corpus/sql/storage/compression/string/empty.test b/parser/testdata/corpus/sql/storage/compression/string/empty.test new file mode 100644 index 0000000..798c325 --- /dev/null +++ b/parser/testdata/corpus/sql/storage/compression/string/empty.test @@ -0,0 +1,54 @@ +# source: test/sql/storage/compression/string/empty.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +ATTACH '{TEST_DIR}/test_empty_new.db' AS db_v13 (STORAGE_VERSION 'v1.3.0'); +-- +ok +== +ATTACH '{TEST_DIR}/test_empty_old.db' AS db_v1 (STORAGE_VERSION 'v1.0.0'); +-- +ok +== +CREATE TABLE test_empty (a VARCHAR); +-- +ok +== +INSERT INTO test_empty VALUES(''); +INSERT INTO test_empty VALUES('A'); +INSERT INTO test_empty VALUES(NULL); +INSERT INTO test_empty VALUES('B'); +INSERT INTO test_empty VALUES(''); +INSERT INTO test_empty VALUES('A'); +-- +ok +== +select * from test_empty; +-- +ok +== +SELECT lower(compression)='{compression}' FROM pragma_storage_info('test_empty') WHERE segment_type ILIKE 'VARCHAR' LIMIT 1 +-- +ok +== +CREATE TABLE test_empty_large AS SELECT '' as a from range(0,10000) union all select 'A' union all select ''; +-- +ok +== +select count(*), min(a[1]), max(a[1]) from test_empty_large limit 5; +-- +ok +== +SELECT lower(compression)='{compression}' FROM pragma_storage_info('test_empty_large') WHERE segment_type ILIKE 'VARCHAR' LIMIT 1 +-- +ok +== +DROP TABLE test_empty +-- +ok +== +DROP TABLE test_empty_large +-- +ok +== diff --git a/parser/testdata/corpus/sql/storage/compression/string/filter_pushdown.test b/parser/testdata/corpus/sql/storage/compression/string/filter_pushdown.test new file mode 100644 index 0000000..e3c2342 --- /dev/null +++ b/parser/testdata/corpus/sql/storage/compression/string/filter_pushdown.test @@ -0,0 +1,33 @@ +# source: test/sql/storage/compression/string/filter_pushdown.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +ATTACH '{TEST_DIR}/test_filter_pushdown_new.db' AS db_v13 (STORAGE_VERSION 'v1.3.0'); +-- +ok +== +ATTACH '{TEST_DIR}/test_filter_pushdown_old.db' AS db_v1 (STORAGE_VERSION 'v1.0.0'); +-- +ok +== +CREATE TABLE test (id INT, col VARCHAR) +-- +ok +== +INSERT INTO test SELECT i::INT id, concat('BLEEPBLOOP-', (i%10)::VARCHAR) col FROM range(10000) tbl(i) +-- +ok +== +SELECT MIN(col), MAX(col), COUNT(*) FROM test WHERE col >= 'BLEEPBLOOP-5' +-- +ok +== +SELECT MIN(id), MAX(id), MIN(col), MAX(col), COUNT(*) FROM test WHERE id='5000' +-- +ok +== +SELECT lower(compression)='{compression}' FROM pragma_storage_info('test') WHERE segment_type ILIKE 'VARCHAR' LIMIT 1 +-- +ok +== diff --git a/parser/testdata/corpus/sql/storage/compression/string/index_fetch.test b/parser/testdata/corpus/sql/storage/compression/string/index_fetch.test new file mode 100644 index 0000000..411c7cf --- /dev/null +++ b/parser/testdata/corpus/sql/storage/compression/string/index_fetch.test @@ -0,0 +1,51 @@ +# source: test/sql/storage/compression/string/index_fetch.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +ATTACH '{TEST_DIR}/test_index_fetch_new.db' AS db_v13 (STORAGE_VERSION 'v1.3.0'); +-- +ok +== +ATTACH '{TEST_DIR}/test_index_fetch_old.db' AS db_v1 (STORAGE_VERSION 'v1.0.0'); +-- +ok +== +drop type if exists test_result +-- +ok +== +create type test_result as UNION( + ok BOOL, + err STRUCT( + expected VARCHAR, + actual VARCHAR + ) +); +-- +ok +== +CREATE TABLE test(id INTEGER PRIMARY KEY, col VARCHAR) +-- +ok +== +INSERT INTO test SELECT i id, i::VARCHAR b FROM range(10000) tbl(i) +-- +ok +== +SELECT MIN(id), MAX(id), SUM(col::INT), MIN(col::INT), MAX(col::INT), COUNT(*) FROM test WHERE id=5000 +-- +ok +== +SELECT + CASE WHEN lower(compression)='{compression}' + THEN true::test_result + ELSE { + 'expected': '{compression}', + 'actual': lower(compression) + }::test_result + END +FROM pragma_storage_info('test') WHERE segment_type ILIKE 'VARCHAR' LIMIT 1 +-- +ok +== diff --git a/parser/testdata/corpus/sql/storage/compression/string/medium.test b/parser/testdata/corpus/sql/storage/compression/string/medium.test new file mode 100644 index 0000000..e9a89bc --- /dev/null +++ b/parser/testdata/corpus/sql/storage/compression/string/medium.test @@ -0,0 +1,21 @@ +# source: test/sql/storage/compression/string/medium.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +SET storage_compatibility_version='v1.3.0' +-- +ok +== +CREATE TABLE test (a VARCHAR); +-- +ok +== +INSERT INTO test SELECT (i%500)::VARCHAR FROM range(0, 10000) tbl(i); +-- +ok +== +SELECT SUM(a::INT), MIN(a::INT), MAX(a::INT), COUNT(*) FROM test +-- +ok +== diff --git a/parser/testdata/corpus/sql/storage/compression/string/simple.test b/parser/testdata/corpus/sql/storage/compression/string/simple.test new file mode 100644 index 0000000..0be0bbc --- /dev/null +++ b/parser/testdata/corpus/sql/storage/compression/string/simple.test @@ -0,0 +1,17 @@ +# source: test/sql/storage/compression/string/simple.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +INSERT INTO test SELECT CONCAT('A-',(i%5)::VARCHAR) FROM range(0,1025) tbl(i); +-- +ok +== +select * from test limit 5; +-- +ok +== +select a[3] from test limit 5; +-- +ok +== diff --git a/parser/testdata/corpus/sql/storage/compression/string/struct.test b/parser/testdata/corpus/sql/storage/compression/string/struct.test new file mode 100644 index 0000000..a6209ea --- /dev/null +++ b/parser/testdata/corpus/sql/storage/compression/string/struct.test @@ -0,0 +1,20 @@ +# source: test/sql/storage/compression/string/struct.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +CREATE TABLE test (s ROW(a VARCHAR)); +-- +ok +== +INSERT INTO test SELECT {'a': concat('0000000000000000000', (i%250)::VARCHAR)} FROM range(0, 10000) tbl(i); +INSERT INTO test SELECT {'a': concat('0000000000000000000', (i%250)::VARCHAR)} FROM range(22767, 32767) tbl(i); +INSERT INTO test SELECT {'a': concat('0000000000000000000', (i%250)::VARCHAR)} FROM range(2147473647, 2147483647) tbl(i); +INSERT INTO test SELECT {'a': concat('0000000000000000000', (i%250)::VARCHAR)} FROM range(2147473647, 2147483647) tbl(i); +-- +ok +== +SELECT SUM(s['a']::INT), MIN(s['a']::INT), MAX(s['a']::INT), COUNT(*) FROM test +-- +ok +== diff --git a/parser/testdata/corpus/sql/storage/compression/string/table_copy.test b/parser/testdata/corpus/sql/storage/compression/string/table_copy.test new file mode 100644 index 0000000..6c6f673 --- /dev/null +++ b/parser/testdata/corpus/sql/storage/compression/string/table_copy.test @@ -0,0 +1,25 @@ +# source: test/sql/storage/compression/string/table_copy.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +INSERT INTO test SELECT (i%500)::VARCHAR FROM range(0,150000) tbl(i); +-- +ok +== +select sum(a::INT) from test; +-- +ok +== +select sum(a::INT) from test_2; +-- +ok +== +SELECT lower(compression)='{compression}' FROM pragma_storage_info('test_2') WHERE segment_type ILIKE 'VARCHAR' LIMIT 1 +-- +ok +== +DROP TABLE test_2; +-- +ok +== diff --git a/parser/testdata/corpus/sql/storage/compression/test_using_compression.test b/parser/testdata/corpus/sql/storage/compression/test_using_compression.test new file mode 100644 index 0000000..7615c6e --- /dev/null +++ b/parser/testdata/corpus/sql/storage/compression/test_using_compression.test @@ -0,0 +1,27 @@ +# source: test/sql/storage/compression/test_using_compression.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +CREATE OR REPLACE TABLE t( + x VARCHAR USING COMPRESSION chimp +); +-- +ok +== +CREATE OR REPLACE TABLE t( + x BIGINT USING COMPRESSION Dictionary +); +-- +ok +== +CREATE OR REPLACE TABLE t( + x VARCHAR USING COMPRESSION Dictionary +); +-- +ok +== +create table foo (str VARCHAR USING COMPRESSION 'dict_fsst'); +-- +ok +== diff --git a/parser/testdata/corpus/sql/storage/compression/zstd/fetch_row.test b/parser/testdata/corpus/sql/storage/compression/zstd/fetch_row.test new file mode 100644 index 0000000..bdb105d --- /dev/null +++ b/parser/testdata/corpus/sql/storage/compression/zstd/fetch_row.test @@ -0,0 +1,45 @@ +# source: test/sql/storage/compression/zstd/fetch_row.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +CREATE TABLE big_string ( + a VARCHAR, + id INT +); +-- +ok +== +pragma force_compression='zstd' +-- +ok +== +INSERT INTO big_string values (repeat('a', 8000), 1); +INSERT INTO big_string values (repeat('b', 10), 2); +INSERT INTO big_string values (repeat('c', 8000), 3); +INSERT INTO big_string values (repeat('d', 10), 4); +INSERT INTO big_string values (repeat('a', 8000), 1); +INSERT INTO big_string values (repeat('b', 10), 2); +INSERT INTO big_string values (repeat('c', 8000), 3); +INSERT INTO big_string values (repeat('d', 10), 4); +INSERT INTO big_string values (repeat('a', 8000), 1); +INSERT INTO big_string values (repeat('b', 10), 2); +INSERT INTO big_string values (repeat('c', 8000), 3); +INSERT INTO big_string values (repeat('d', 10), 4); +-- +ok +== +INSERT INTO big_string values (concat(range(0,500000)::VARCHAR), 5); +-- +ok +== +INSERT INTO big_string values (repeat('f', 1), 6); +INSERT INTO big_string values (repeat('g', 8000), 7); +INSERT INTO big_string values (repeat('h', 10000), 8); +-- +ok +== +SELECT a[1], strlen(a) from big_string; +-- +ok +== diff --git a/parser/testdata/corpus/sql/storage/compression/zstd/nulls.test b/parser/testdata/corpus/sql/storage/compression/zstd/nulls.test new file mode 100644 index 0000000..b4c3c9f --- /dev/null +++ b/parser/testdata/corpus/sql/storage/compression/zstd/nulls.test @@ -0,0 +1,30 @@ +# source: test/sql/storage/compression/zstd/nulls.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +create table tbl ( + a varchar +); +-- +ok +== +set variable my_string = ( + select concat(range(0,1000)::VARCHAR) +); +-- +ok +== +INSERT INTO tbl (a) +SELECT CASE + WHEN (i % 7) = 0 THEN NULL + ELSE getvariable('my_string') || i +END +FROM range(5000) t(i); +-- +ok +== +select count(*) from tbl where a IS NULL; +-- +ok +== diff --git a/parser/testdata/corpus/sql/storage/compression/zstd/test_skipping.test b/parser/testdata/corpus/sql/storage/compression/zstd/test_skipping.test new file mode 100644 index 0000000..e5efbda --- /dev/null +++ b/parser/testdata/corpus/sql/storage/compression/zstd/test_skipping.test @@ -0,0 +1,21 @@ +# source: test/sql/storage/compression/zstd/test_skipping.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +pragma force_compression='zstd'; +-- +ok +== +create table tbl as +select + i // 5_000 as num, + num::VARCHAR || list_reduce([uuid()::varchar for x in range(10)], lambda x, y: concat(x, y)) str +from range(20_000) t(i) order by num +-- +ok +== +select str[0:1]::BIGINT from tbl where num = 1 limit 10; +-- +ok +== diff --git a/parser/testdata/corpus/sql/storage/compression/zstd/zstd.test b/parser/testdata/corpus/sql/storage/compression/zstd/zstd.test new file mode 100644 index 0000000..7c2b452 --- /dev/null +++ b/parser/testdata/corpus/sql/storage/compression/zstd/zstd.test @@ -0,0 +1,13 @@ +# source: test/sql/storage/compression/zstd/zstd.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +PRAGMA force_compression = 'zstd' +-- +ok +== +INSERT INTO test VALUES ('11'), ('11'), ('12'), (NULL); +-- +ok +== diff --git a/parser/testdata/corpus/sql/storage/compression/zstd/zstd_force_compression.test b/parser/testdata/corpus/sql/storage/compression/zstd/zstd_force_compression.test new file mode 100644 index 0000000..33ea551 --- /dev/null +++ b/parser/testdata/corpus/sql/storage/compression/zstd/zstd_force_compression.test @@ -0,0 +1,13 @@ +# source: test/sql/storage/compression/zstd/zstd_force_compression.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +CREATE TABLE zstd_data AS SELECT concat('thisisalongstring', i) str FROM range(1000) t(i); +-- +ok +== +select count(*) from pragma_storage_info('zstd_data') where compression='ZSTD'; +-- +ok +== diff --git a/parser/testdata/corpus/sql/storage/concurrent_attach_if_not_exists_create.test b/parser/testdata/corpus/sql/storage/concurrent_attach_if_not_exists_create.test new file mode 100644 index 0000000..53b2dbe --- /dev/null +++ b/parser/testdata/corpus/sql/storage/concurrent_attach_if_not_exists_create.test @@ -0,0 +1,13 @@ +# source: test/sql/storage/concurrent_attach_if_not_exists_create.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +attach if not exists '{TEST_DIR}/concurrent_attach_{name}.duckdb' AS {name} +-- +error: Parser Error: syntax error at or near "{" +== +create table {name}.tbl{x}(i INTEGER) +-- +error: Parser Error: syntax error at or near "{" +== diff --git a/parser/testdata/corpus/sql/storage/constraints/foreignkey/foreign_key_persistent.test b/parser/testdata/corpus/sql/storage/constraints/foreignkey/foreign_key_persistent.test new file mode 100644 index 0000000..52072a0 --- /dev/null +++ b/parser/testdata/corpus/sql/storage/constraints/foreignkey/foreign_key_persistent.test @@ -0,0 +1,41 @@ +# source: test/sql/storage/constraints/foreignkey/foreign_key_persistent.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +CREATE TABLE pk_integers (i INTEGER PRIMARY KEY); +-- +ok +== +INSERT INTO pk_integers VALUES (1), (2), (3); +-- +ok +== +CREATE TABLE fk_integers (j INTEGER, FOREIGN KEY (j) REFERENCES pk_integers(i)); +-- +ok +== +INSERT INTO fk_integers VALUES (1), (2); +-- +ok +== +INSERT INTO fk_integers VALUES (4); +-- +ok +== +DELETE FROM pk_integers WHERE i = 3; +-- +ok +== +DELETE FROM fk_integers WHERE j = 3; +-- +ok +== +UPDATE pk_integers SET i = 5 WHERE i = 2; +-- +ok +== +UPDATE fk_integers SET j = 4 WHERE j = 2; +-- +ok +== diff --git a/parser/testdata/corpus/sql/storage/constraints/foreignkey/foreign_key_persistent_memory_limit.test b/parser/testdata/corpus/sql/storage/constraints/foreignkey/foreign_key_persistent_memory_limit.test new file mode 100644 index 0000000..42662dd --- /dev/null +++ b/parser/testdata/corpus/sql/storage/constraints/foreignkey/foreign_key_persistent_memory_limit.test @@ -0,0 +1,9 @@ +# source: test/sql/storage/constraints/foreignkey/foreign_key_persistent_memory_limit.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +SET memory_limit = '1792kB'; +-- +ok +== diff --git a/parser/testdata/corpus/sql/storage/corrupt/corrupt_catalog_entry.test b/parser/testdata/corpus/sql/storage/corrupt/corrupt_catalog_entry.test new file mode 100644 index 0000000..44d42fe --- /dev/null +++ b/parser/testdata/corpus/sql/storage/corrupt/corrupt_catalog_entry.test @@ -0,0 +1,9 @@ +# source: test/sql/storage/corrupt/corrupt_catalog_entry.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +ATTACH '{TEST_DIR}/duckdb_fuzzer_4671.db' AS corrupt_db (READ_ONLY) +-- +ok +== diff --git a/parser/testdata/corpus/sql/storage/corrupt/corrupt_encoding_overflow.test b/parser/testdata/corpus/sql/storage/corrupt/corrupt_encoding_overflow.test new file mode 100644 index 0000000..f377905 --- /dev/null +++ b/parser/testdata/corpus/sql/storage/corrupt/corrupt_encoding_overflow.test @@ -0,0 +1,9 @@ +# source: test/sql/storage/corrupt/corrupt_encoding_overflow.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +ATTACH '{TEST_DIR}/corrupt_wal_encoding.db' +-- +ok +== diff --git a/parser/testdata/corpus/sql/storage/delete/load_delete_modify.test b/parser/testdata/corpus/sql/storage/delete/load_delete_modify.test new file mode 100644 index 0000000..4776689 --- /dev/null +++ b/parser/testdata/corpus/sql/storage/delete/load_delete_modify.test @@ -0,0 +1,33 @@ +# source: test/sql/storage/delete/load_delete_modify.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +CREATE TABLE integers AS SELECT * FROM generate_series(0,599999) t(i); +-- +ok +== +DELETE FROM integers WHERE i%2=0 +-- +ok +== +ALTER TABLE integers ADD COLUMN k INTEGER +-- +ok +== +SELECT COUNT(*), COUNT(i), COUNT(k) FROM integers +-- +ok +== +UPDATE integers SET k=i+1 +-- +ok +== +SELECT COUNT(*), COUNT(i), COUNT(k), SUM(k) - SUM(i) FROM integers +-- +ok +== +DELETE FROM integers WHERE i%3=0 +-- +ok +== diff --git a/parser/testdata/corpus/sql/storage/delete/repeated_deletes.test b/parser/testdata/corpus/sql/storage/delete/repeated_deletes.test new file mode 100644 index 0000000..a658b36 --- /dev/null +++ b/parser/testdata/corpus/sql/storage/delete/repeated_deletes.test @@ -0,0 +1,57 @@ +# source: test/sql/storage/delete/repeated_deletes.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +CREATE TABLE test (i INTEGER); +-- +ok +== +INSERT INTO test SELECT * FROM generate_series(0, 999); +-- +ok +== +DELETE FROM test WHERE i%2=0; +-- +ok +== +SELECT COUNT(*), SUM(i), MIN(i), MAX(i) FROM test; +-- +ok +== +INSERT INTO test SELECT * FROM generate_series(1000, 1099); +-- +ok +== +DELETE FROM test WHERE i%3=0; +-- +ok +== +INSERT INTO test SELECT * FROM generate_series(1000, 1999); +-- +ok +== +SELECT COUNT(*) FROM test WHERE i%7=0 +-- +ok +== +DELETE FROM test WHERE i%7=0; +-- +ok +== +INSERT INTO test SELECT 1 FROM generate_series(0, 4000); +-- +ok +== +INSERT INTO test SELECT 2 FROM generate_series(0, 4000); +-- +ok +== +DELETE FROM test WHERE i=1; +-- +ok +== +DELETE FROM test WHERE i=2; +-- +ok +== diff --git a/parser/testdata/corpus/sql/storage/delete/test_store_deletes.test b/parser/testdata/corpus/sql/storage/delete/test_store_deletes.test new file mode 100644 index 0000000..3d92c87 --- /dev/null +++ b/parser/testdata/corpus/sql/storage/delete/test_store_deletes.test @@ -0,0 +1,21 @@ +# source: test/sql/storage/delete/test_store_deletes.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +INSERT INTO test VALUES (11, 22), (12, 21), (13, 22), (12, 21) +-- +ok +== +DELETE FROM test WHERE a=12 +-- +ok +== +SELECT a, b FROM test ORDER BY a +-- +ok +== +INSERT INTO test VALUES (11, 24), (12, 25) +-- +ok +== diff --git a/parser/testdata/corpus/sql/storage/delete/test_unchanged_deletes.test b/parser/testdata/corpus/sql/storage/delete/test_unchanged_deletes.test new file mode 100644 index 0000000..4c7b780 --- /dev/null +++ b/parser/testdata/corpus/sql/storage/delete/test_unchanged_deletes.test @@ -0,0 +1,17 @@ +# source: test/sql/storage/delete/test_unchanged_deletes.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +CREATE TABLE integers AS FROM range(4) t(i) +-- +ok +== +CREATE TABLE integers2(i int); +-- +ok +== +INSERT INTO integers2 VALUES ({i}); +-- +error: Parser Error: syntax error at or near "}" +== diff --git a/parser/testdata/corpus/sql/storage/delete/test_unchanged_deletes_large.test b/parser/testdata/corpus/sql/storage/delete/test_unchanged_deletes_large.test new file mode 100644 index 0000000..d9393b7 --- /dev/null +++ b/parser/testdata/corpus/sql/storage/delete/test_unchanged_deletes_large.test @@ -0,0 +1,13 @@ +# source: test/sql/storage/delete/test_unchanged_deletes_large.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +INSERT INTO integers VALUES (84) +-- +ok +== +SELECT COUNT(*) - {i} FROM integers +-- +error: Parser Error: syntax error at or near "}" +== diff --git a/parser/testdata/corpus/sql/storage/distinct_statistics_storage.test b/parser/testdata/corpus/sql/storage/distinct_statistics_storage.test new file mode 100644 index 0000000..50b34ca --- /dev/null +++ b/parser/testdata/corpus/sql/storage/distinct_statistics_storage.test @@ -0,0 +1,13 @@ +# source: test/sql/storage/distinct_statistics_storage.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +create table test as select range % 10 i, range % 30 j from range(100) +-- +ok +== +select stats(i), stats(j) from test limit 1 +-- +ok +== diff --git a/parser/testdata/corpus/sql/storage/encryption/temp_files/encrypted_tmp_file_setting.test b/parser/testdata/corpus/sql/storage/encryption/temp_files/encrypted_tmp_file_setting.test new file mode 100644 index 0000000..27363fe --- /dev/null +++ b/parser/testdata/corpus/sql/storage/encryption/temp_files/encrypted_tmp_file_setting.test @@ -0,0 +1,33 @@ +# source: test/sql/storage/encryption/temp_files/encrypted_tmp_file_setting.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +SET temp_directory='{TEST_DIR}/test_temp_dir' +-- +ok +== +SET temp_file_encryption = false; +-- +ok +== +SET memory_limit = '8MB'; +-- +ok +== +SET temp_directory='{TEST_DIR}/new_temp_dir' +-- +ok +== +RESET temp_directory +-- +ok +== +CREATE TEMPORARY TABLE tbl AS FROM range(10_000_000) +-- +ok +== +SET temp_file_encryption = true; +-- +ok +== diff --git a/parser/testdata/corpus/sql/storage/encryption/temp_files/temp_directory_enable_external_access.test b/parser/testdata/corpus/sql/storage/encryption/temp_files/temp_directory_enable_external_access.test new file mode 100644 index 0000000..3941022 --- /dev/null +++ b/parser/testdata/corpus/sql/storage/encryption/temp_files/temp_directory_enable_external_access.test @@ -0,0 +1,13 @@ +# source: test/sql/storage/encryption/temp_files/temp_directory_enable_external_access.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +ATTACH '{TEST_DIR}/encrypted_temp_files_{cipher}.db' AS enc (ENCRYPTION_KEY 'asdf', ENCRYPTION_CIPHER 'GCM'); +-- +ok +== +USE enc; +-- +ok +== diff --git a/parser/testdata/corpus/sql/storage/encryption/wal/encrypted_wal_blob_storage.test b/parser/testdata/corpus/sql/storage/encryption/wal/encrypted_wal_blob_storage.test new file mode 100644 index 0000000..6d2fcc8 --- /dev/null +++ b/parser/testdata/corpus/sql/storage/encryption/wal/encrypted_wal_blob_storage.test @@ -0,0 +1,21 @@ +# source: test/sql/storage/encryption/wal/encrypted_wal_blob_storage.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +ATTACH '{TEST_DIR}/encrypted_blob_storage_{cipher}.db' AS enc (ENCRYPTION_KEY 'asdf', ENCRYPTION_CIPHER '{cipher}'); +-- +ok +== +CREATE TABLE enc.blobs (b BLOB); +-- +ok +== +INSERT INTO enc.blobs VALUES('a'), ('\xAA'), ('\xAA\xFF\xAA'), (''), (NULL), ('\x55\xAA\xFF\x55\xAA\xFF\x55\xAA\xFF\x01'), ('\x55\xAA\xFF\x55\xAA\xFF\x55\xAA\xFF\x01') +-- +ok +== +SELECT * FROM enc.blobs +-- +ok +== diff --git a/parser/testdata/corpus/sql/storage/encryption/wal/encrypted_wal_lazy_creation.test b/parser/testdata/corpus/sql/storage/encryption/wal/encrypted_wal_lazy_creation.test new file mode 100644 index 0000000..28e68f4 --- /dev/null +++ b/parser/testdata/corpus/sql/storage/encryption/wal/encrypted_wal_lazy_creation.test @@ -0,0 +1,29 @@ +# source: test/sql/storage/encryption/wal/encrypted_wal_lazy_creation.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +ATTACH '{TEST_DIR}/attach_no_wal_{cipher}.db' AS attach_no_wal (ENCRYPTION_KEY 'asdf', ENCRYPTION_CIPHER '{cipher}'); +-- +ok +== +CREATE TABLE attach_no_wal.integers(i INTEGER); +-- +ok +== +INSERT INTO attach_no_wal.integers FROM range(10000); +-- +ok +== +DETACH attach_no_wal; +-- +ok +== +SELECT COUNT(*) FROM glob('{TEST_DIR}/attach_no_wal_{cipher}.db.wal'); +-- +ok +== +SELECT COUNT(*) FROM attach_no_wal.integers; +-- +ok +== diff --git a/parser/testdata/corpus/sql/storage/encryption/wal/encrypted_wal_pragmas.test b/parser/testdata/corpus/sql/storage/encryption/wal/encrypted_wal_pragmas.test new file mode 100644 index 0000000..0c001e3 --- /dev/null +++ b/parser/testdata/corpus/sql/storage/encryption/wal/encrypted_wal_pragmas.test @@ -0,0 +1,37 @@ +# source: test/sql/storage/encryption/wal/encrypted_wal_pragmas.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +ATTACH '{TEST_DIR}/encrypted_wal_restart_{cipher}.db' as enc (ENCRYPTION_KEY 'asdf', ENCRYPTION_CIPHER '{cipher}'); +-- +ok +== +CREATE TABLE enc.test (a INTEGER, b INTEGER); +-- +ok +== +INSERT INTO enc.test VALUES (11, 22), (13, 22), (12, 21) +-- +ok +== +ALTER TABLE enc.test ALTER b TYPE VARCHAR +-- +ok +== +SELECT * FROM enc.test ORDER BY 1 +-- +ok +== +INSERT INTO enc.test VALUES (10, 'hello') +-- +ok +== +ATTACH '{TEST_DIR}/encrypted_wal_restart_new_{cipher}.db' as enc (ENCRYPTION_KEY 'asdf', ENCRYPTION_CIPHER '{cipher}'); +-- +ok +== +ATTACH '{TEST_DIR}/encrypted_wal_disable_enable_{cipher}.db' as enc (ENCRYPTION_KEY 'asdf', ENCRYPTION_CIPHER '{cipher}'); +-- +ok +== diff --git a/parser/testdata/corpus/sql/storage/extended_string_stats.test b/parser/testdata/corpus/sql/storage/extended_string_stats.test new file mode 100644 index 0000000..41fb6b0 --- /dev/null +++ b/parser/testdata/corpus/sql/storage/extended_string_stats.test @@ -0,0 +1,43 @@ +# source: test/sql/storage/extended_string_stats.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +create table test as from (values + ('hello world'), + (NULL), + ('this is a long string') + ) t(s) + ; +-- +ok +== +select s.min, s.max, s.min_string_length, s.max_string_length, s.total_string_length from (select stats(s) s from test limit 1) +-- +ok +== +insert into test values ('how about this one'), ('') +-- +ok +== +select s.min_string_length, s.total_string_length from (select stats(s) s from test limit 1) +-- +ok +== +update test set s='my new bigger string' where s='hello world' +-- +ok +== +select s.total_string_length from (select stats(s) s from test limit 1) +-- +ok +== +insert into test from (values + ('hello world'), + (NULL), + ('this is a long string') + ) t(s) + ; +-- +ok +== diff --git a/parser/testdata/corpus/sql/storage/extensions/extension_default.test b/parser/testdata/corpus/sql/storage/extensions/extension_default.test new file mode 100644 index 0000000..7598dcd --- /dev/null +++ b/parser/testdata/corpus/sql/storage/extensions/extension_default.test @@ -0,0 +1,13 @@ +# source: test/sql/storage/extensions/extension_default.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +CREATE TABLE t1(v VARCHAR DEFAULT CURRENT_SCHEMA()) +-- +ok +== +INSERT INTO t1 VALUES (DEFAULT) +-- +ok +== diff --git a/parser/testdata/corpus/sql/storage/extensions/extension_views.test b/parser/testdata/corpus/sql/storage/extensions/extension_views.test new file mode 100644 index 0000000..192eea8 --- /dev/null +++ b/parser/testdata/corpus/sql/storage/extensions/extension_views.test @@ -0,0 +1,9 @@ +# source: test/sql/storage/extensions/extension_views.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +CREATE VIEW v1 AS SELECT current_schema(); +-- +ok +== diff --git a/parser/testdata/corpus/sql/storage/external_file_cache/external_file_cache_async_toggle.test b/parser/testdata/corpus/sql/storage/external_file_cache/external_file_cache_async_toggle.test new file mode 100644 index 0000000..54cb37d --- /dev/null +++ b/parser/testdata/corpus/sql/storage/external_file_cache/external_file_cache_async_toggle.test @@ -0,0 +1,42 @@ +# source: test/sql/storage/external_file_cache/external_file_cache_async_toggle.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +SET async_threads=4 +-- +ok +== +SET cache_local_files=true +-- +ok +== +SET GLOBAL debug_fs_random_seed=424242 +-- +ok +== +COPY ( + SELECT i + FROM range(1000000) t(i) +) TO '{TEST_DIR}/external_file_cache_async_toggle.parquet' +(FORMAT PARQUET, ROW_GROUP_SIZE 50000) +-- +ok +== +SET GLOBAL debug_fs_delay_mean_ms=5 +-- +ok +== +SET GLOBAL debug_fs_delay_stddev_ms=5 +-- +ok +== +SET enable_external_file_cache={enabled} +-- +error: Parser Error: syntax error at or near "}" +== +SELECT count(*), sum(i) +FROM read_parquet('{TEST_DIR}/external_file_cache_async_toggle.parquet', prefetch_strategy='whole_group') +-- +ok +== diff --git a/parser/testdata/corpus/sql/storage/external_file_cache/external_file_cache_block_size.test b/parser/testdata/corpus/sql/storage/external_file_cache/external_file_cache_block_size.test new file mode 100644 index 0000000..b08e8ff --- /dev/null +++ b/parser/testdata/corpus/sql/storage/external_file_cache/external_file_cache_block_size.test @@ -0,0 +1,65 @@ +# source: test/sql/storage/external_file_cache/external_file_cache_block_size.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +set cache_local_files=true; +-- +ok +== +set enable_external_file_cache=true; +-- +ok +== +copy (select range i, range % 100 j from range(10000)) to '{TEST_DIR}/test_block_size.parquet'; +-- +ok +== +select * from '{TEST_DIR}/test_block_size.parquet'; +-- +ok +== +select count(*) > 0 from duckdb_external_file_cache(); +-- +ok +== +create temp table cached_bytes_before as select sum(nr_bytes) as total from duckdb_external_file_cache(); +-- +ok +== +set external_file_cache_local_block_size=4096; +-- +ok +== +select (select sum(nr_bytes) from duckdb_external_file_cache()) = (select total from cached_bytes_before); +-- +ok +== +select count(*), sum(i) from '{TEST_DIR}/test_block_size.parquet'; +-- +ok +== +drop table cached_bytes_before; +-- +ok +== +set external_file_cache_local_block_size=16384; +-- +ok +== +reset external_file_cache_local_block_size; +-- +ok +== +set external_file_cache_local_block_size=8192; +-- +ok +== +set external_file_cache_local_block_size=0; +-- +ok +== +set external_file_cache_remote_block_size=0; +-- +ok +== diff --git a/parser/testdata/corpus/sql/storage/external_file_cache/external_file_cache_validate.test b/parser/testdata/corpus/sql/storage/external_file_cache/external_file_cache_validate.test new file mode 100644 index 0000000..e3c7c56 --- /dev/null +++ b/parser/testdata/corpus/sql/storage/external_file_cache/external_file_cache_validate.test @@ -0,0 +1,37 @@ +# source: test/sql/storage/external_file_cache/external_file_cache_validate.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +copy (select 1 as col1, 2 as col2 from range(100)) to '{TEST_DIR}/test_validate_cache.parquet'; +-- +ok +== +select current_setting('validate_external_file_cache'); +-- +ok +== +set validate_external_file_cache='VALIDATE_REMOTE'; +-- +ok +== +select sum(col1) from '{TEST_DIR}/test_validate_cache.parquet'; +-- +ok +== +set validate_external_file_cache='NO_VALIDATION'; +-- +ok +== +copy (select 100 as col1, 200 as col2 from range(10)) to '{TEST_DIR}/test_validate_cache.parquet'; +-- +ok +== +set validate_external_file_cache='VALIDATE_ALL'; +-- +ok +== +set validate_external_file_cache='INVALID_VALUE'; +-- +ok +== diff --git a/parser/testdata/corpus/sql/storage/filter_pushdown_struct.test b/parser/testdata/corpus/sql/storage/filter_pushdown_struct.test new file mode 100644 index 0000000..c513c73 --- /dev/null +++ b/parser/testdata/corpus/sql/storage/filter_pushdown_struct.test @@ -0,0 +1,25 @@ +# source: test/sql/storage/filter_pushdown_struct.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +CREATE TABLE tbl (a STRUCT("id" VARCHAR), b STRUCT("id" VARCHAR)); +-- +ok +== +INSERT INTO tbl SELECT {'id': LPAD(i::VARCHAR, 4, '0')}, {'id': 'abc'} FROM range(10000) t(i) +-- +ok +== +SELECT COUNT(*) FROM (SELECT * FROM tbl WHERE b.id='abc') t +-- +ok +== +INSERT INTO tbl SELECT {'id': LPAD((i + 10000)::VARCHAR, 4, '0')}, {'id': 'bcd'} FROM range(10000) t(i) +-- +ok +== +SELECT COUNT(*) FROM (SELECT * FROM tbl WHERE b.id='bcd') t +-- +ok +== diff --git a/parser/testdata/corpus/sql/storage/full_vector_delete_checkpoint.test b/parser/testdata/corpus/sql/storage/full_vector_delete_checkpoint.test new file mode 100644 index 0000000..e201f29 --- /dev/null +++ b/parser/testdata/corpus/sql/storage/full_vector_delete_checkpoint.test @@ -0,0 +1,13 @@ +# source: test/sql/storage/full_vector_delete_checkpoint.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +CREATE TABLE tbl AS SELECT i FROM range(8192) t(i); +-- +ok +== +DELETE FROM tbl WHERE i < 5000 +-- +ok +== diff --git a/parser/testdata/corpus/sql/storage/issue3789_node_segment_tree.test b/parser/testdata/corpus/sql/storage/issue3789_node_segment_tree.test new file mode 100644 index 0000000..8365d6b --- /dev/null +++ b/parser/testdata/corpus/sql/storage/issue3789_node_segment_tree.test @@ -0,0 +1,21 @@ +# source: test/sql/storage/issue3789_node_segment_tree.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +CREATE TABLE table1 (column1 integer, column2 integer) +-- +ok +== +INSERT INTO table1(column1, column2) values(1, 1) +-- +ok +== +INSERT INTO table1(column1, column2) values(1, 2) +-- +ok +== +UPDATE table1 SET column2 = 3 FROM table1 s WHERE s.column1 = 1 +-- +ok +== diff --git a/parser/testdata/corpus/sql/storage/issue7582_list_storage.test b/parser/testdata/corpus/sql/storage/issue7582_list_storage.test new file mode 100644 index 0000000..bc43fb6 --- /dev/null +++ b/parser/testdata/corpus/sql/storage/issue7582_list_storage.test @@ -0,0 +1,17 @@ +# source: test/sql/storage/issue7582_list_storage.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +SET wal_autocheckpoint='1GB'; +-- +ok +== +CREATE TABLE tbl (n TEXT[]); +-- +ok +== +INSERT INTO tbl (n) SELECT CASE WHEN i < 100 THEN ['a', 'b'] ELSE [] END l FROM range(1026) t(i); +-- +ok +== diff --git a/parser/testdata/corpus/sql/storage/lazy_load/lazy_load_limit.test b/parser/testdata/corpus/sql/storage/lazy_load/lazy_load_limit.test new file mode 100644 index 0000000..7eba0a5 --- /dev/null +++ b/parser/testdata/corpus/sql/storage/lazy_load/lazy_load_limit.test @@ -0,0 +1,13 @@ +# source: test/sql/storage/lazy_load/lazy_load_limit.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +INSERT INTO vals SELECT i, i::VARCHAR FROM generate_series(1000000) t(i) +-- +ok +== +SELECT COUNT(*)=({i}*100000) FROM (FROM vals LIMIT {i}*100000) +-- +error: Parser Error: syntax error at or near "}" +== diff --git a/parser/testdata/corpus/sql/storage/many_checkpoints.test b/parser/testdata/corpus/sql/storage/many_checkpoints.test new file mode 100644 index 0000000..b1e090e --- /dev/null +++ b/parser/testdata/corpus/sql/storage/many_checkpoints.test @@ -0,0 +1,17 @@ +# source: test/sql/storage/many_checkpoints.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +SELECT COUNT(*) FROM test +-- +ok +== +INSERT INTO test VALUES (11, 22, 'hello'); +-- +ok +== +SELECT * FROM test ORDER BY 1, 2, 3 +-- +ok +== diff --git a/parser/testdata/corpus/sql/storage/many_self_append.test b/parser/testdata/corpus/sql/storage/many_self_append.test new file mode 100644 index 0000000..b224135 --- /dev/null +++ b/parser/testdata/corpus/sql/storage/many_self_append.test @@ -0,0 +1,9 @@ +# source: test/sql/storage/many_self_append.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +INSERT INTO vals SELECT (CASE WHEN i % 2 = 0 THEN NULL ELSE i % 100 END)::TINYINT i FROM range(10) tbl(i) +-- +ok +== diff --git a/parser/testdata/corpus/sql/storage/memory/in_memory_disabled_zstd.test b/parser/testdata/corpus/sql/storage/memory/in_memory_disabled_zstd.test new file mode 100644 index 0000000..acb5a7c --- /dev/null +++ b/parser/testdata/corpus/sql/storage/memory/in_memory_disabled_zstd.test @@ -0,0 +1,21 @@ +# source: test/sql/storage/memory/in_memory_disabled_zstd.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +attach ':memory:' as db2 (compress); +-- +ok +== +create table tbl as +select + i // 5_000 as num, + num::varchar || list_reduce([uuid()::varchar for x in range(10)], lambda x, y: concat(x, y)) str +from range(20_000) t(i) order by num; +-- +ok +== +select distinct compression = 'Uncompressed' from pragma_storage_info('tbl') where segment_type = 'VARCHAR' +-- +ok +== diff --git a/parser/testdata/corpus/sql/storage/metadata/full_table_metadata_reuse.test b/parser/testdata/corpus/sql/storage/metadata/full_table_metadata_reuse.test new file mode 100644 index 0000000..bf9d120 --- /dev/null +++ b/parser/testdata/corpus/sql/storage/metadata/full_table_metadata_reuse.test @@ -0,0 +1,29 @@ +# source: test/sql/storage/metadata/full_table_metadata_reuse.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +CREATE TABLE bigtbl(i INT); +-- +ok +== +INSERT INTO bigtbl FROM range(1000000) +-- +ok +== +CREATE TABLE little_tbl(i INT); +-- +ok +== +INSERT INTO little_tbl VALUES (1) +-- +ok +== +SELECT SUM(i)={i} FROM little_tbl +-- +error: Parser Error: syntax error at or near "}" +== +SELECT COUNT(*), SUM(i) FROM bigtbl +-- +ok +== diff --git a/parser/testdata/corpus/sql/storage/metadata/full_table_metadata_reuse_v7.test b/parser/testdata/corpus/sql/storage/metadata/full_table_metadata_reuse_v7.test new file mode 100644 index 0000000..7662b14 --- /dev/null +++ b/parser/testdata/corpus/sql/storage/metadata/full_table_metadata_reuse_v7.test @@ -0,0 +1,35 @@ +# source: test/sql/storage/metadata/full_table_metadata_reuse_v7.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +SET force_column_metadata_reuse=true +-- +ok +== +CREATE TABLE tbl AS SELECT + i AS c0, i AS c1, i AS c2, i AS c3, i AS c4 +FROM range(200000) t(i); +-- +ok +== +SELECT COUNT(DISTINCT column_name) FROM pragma_storage_info('tbl', include_segment_info=true, loaded_segments_only=true) +-- +ok +== +SELECT COUNT(*), SUM(c0) FROM tbl +-- +ok +== +CREATE TABLE other_tbl AS SELECT i AS x FROM range(1000) t(i); +-- +ok +== +INSERT INTO other_tbl SELECT i FROM range(1000, 2000) t(i); +-- +ok +== +SELECT COUNT(*), SUM(x) FROM other_tbl +-- +ok +== diff --git a/parser/testdata/corpus/sql/storage/metadata/multi_table_metadata_reuse.test b/parser/testdata/corpus/sql/storage/metadata/multi_table_metadata_reuse.test new file mode 100644 index 0000000..06fc12e --- /dev/null +++ b/parser/testdata/corpus/sql/storage/metadata/multi_table_metadata_reuse.test @@ -0,0 +1,37 @@ +# source: test/sql/storage/metadata/multi_table_metadata_reuse.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +SET experimental_metadata_reuse=true; +-- +ok +== +CREATE TABLE ducklake_table(end_snapshot BIGINT); +-- +ok +== +CREATE TABLE ducklake_column(end_snapshot BIGINT); +-- +ok +== +INSERT INTO ducklake_table VALUES (1); +-- +ok +== +INSERT INTO ducklake_column VALUES (1); +-- +ok +== +UPDATE ducklake_table SET end_snapshot = 3 +-- +ok +== +UPDATE ducklake_column SET end_snapshot = 3 +-- +ok +== +CREATE TABLE my_table (a INTEGER, b INTEGER); +-- +ok +== diff --git a/parser/testdata/corpus/sql/storage/metadata/partial_column_metadata_reuse.test b/parser/testdata/corpus/sql/storage/metadata/partial_column_metadata_reuse.test new file mode 100644 index 0000000..aff855d --- /dev/null +++ b/parser/testdata/corpus/sql/storage/metadata/partial_column_metadata_reuse.test @@ -0,0 +1,70 @@ +# source: test/sql/storage/metadata/partial_column_metadata_reuse.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +CREATE TABLE wide_tbl AS SELECT + i AS c0, i AS c1, i AS c2, i AS c3, i AS c4, + i AS c5, i AS c6, i AS c7, i AS c8, i AS c9, + i AS c10, i AS c11, i AS c12, i AS c13, i AS c14, + i AS c15, i AS c16, i AS c17, i AS c18, i AS c19 +FROM range(200000) t(i); +-- +ok +== +SELECT COUNT(DISTINCT column_name) FROM pragma_storage_info('wide_tbl', include_segment_info=true, loaded_segments_only=true) +-- +ok +== +ALTER TABLE wide_tbl ADD COLUMN c20 INTEGER DEFAULT 42 +-- +ok +== +SELECT DISTINCT column_name FROM pragma_storage_info('wide_tbl', include_segment_info=true, loaded_segments_only=true) +-- +ok +== +SELECT COUNT(*), SUM(c0), SUM(c20) FROM wide_tbl +-- +ok +== +ALTER TABLE wide_tbl ADD COLUMN c21 INTEGER DEFAULT 100 +-- +ok +== +ALTER TABLE wide_tbl DROP COLUMN c10 +-- +ok +== +SELECT COUNT(*), SUM(c0), SUM(c20), SUM(c21) FROM wide_tbl +-- +ok +== +UPDATE wide_tbl SET c0 = c0 + 1 WHERE c0 < 100 +-- +ok +== +SELECT COUNT(*), SUM(c0), SUM(c21) FROM wide_tbl +-- +ok +== +UPDATE wide_tbl SET c5 = c5 + 100 WHERE c5 < 1000 +-- +ok +== +SELECT COUNT(*), SUM(c5) FROM wide_tbl +-- +ok +== +ALTER TABLE wide_tbl ALTER c1 TYPE BIGINT +-- +ok +== +SELECT COUNT(*), SUM(c0), SUM(c1) FROM wide_tbl +-- +ok +== +SELECT COUNT(*), SUM(c1) FROM wide_tbl +-- +ok +== diff --git a/parser/testdata/corpus/sql/storage/metadata/partial_column_metadata_reuse_drop_column.test b/parser/testdata/corpus/sql/storage/metadata/partial_column_metadata_reuse_drop_column.test new file mode 100644 index 0000000..8c9cce8 --- /dev/null +++ b/parser/testdata/corpus/sql/storage/metadata/partial_column_metadata_reuse_drop_column.test @@ -0,0 +1,62 @@ +# source: test/sql/storage/metadata/partial_column_metadata_reuse_drop_column.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +ATTACH '{TEST_DIR}/partial_reuse_drop_column.db' AS db1 (BLOCK_SIZE 16384, STORAGE_VERSION 'latest') +-- +ok +== +SET debug_verify_blocks=true +-- +ok +== +CREATE TABLE db1.wide_tbl AS SELECT + i AS id, + md5(i::VARCHAR || 'c0') AS c0, + md5(i::VARCHAR || 'c1') AS c1, + md5(i::VARCHAR || 'c2') AS c2, + md5(i::VARCHAR || 'c3') AS c3, + md5(i::VARCHAR || 'c4') AS c4, + md5(i::VARCHAR || 'c5') AS c5 +FROM range(50000) t(i) +-- +ok +== +ALTER TABLE db1.wide_tbl DROP COLUMN c1 +-- +ok +== +UPDATE db1.wide_tbl SET c4 = md5((id * 7)::VARCHAR) WHERE id BETWEEN 100 AND 600 +-- +ok +== +SELECT count(*) FROM db1.wide_tbl +WHERE c0 != md5(id::VARCHAR || 'c0') + OR c2 != md5(id::VARCHAR || 'c2') + OR c3 != md5(id::VARCHAR || 'c3') + OR c4 != CASE WHEN id BETWEEN 100 AND 600 THEN md5((id * 7)::VARCHAR) ELSE md5(id::VARCHAR || 'c4') END + OR c5 != md5(id::VARCHAR || 'c5') +-- +ok +== +ALTER TABLE db1.wide_tbl DROP COLUMN c3 +-- +ok +== +UPDATE db1.wide_tbl SET c5 = md5((id * 13)::VARCHAR) WHERE id BETWEEN 1000 AND 1500 +-- +ok +== +ATTACH '{TEST_DIR}/partial_reuse_drop_column.db' AS db1 +-- +ok +== +SELECT count(*) FROM db1.wide_tbl +WHERE c0 != md5(id::VARCHAR || 'c0') + OR c2 != md5(id::VARCHAR || 'c2') + OR c4 != CASE WHEN id BETWEEN 100 AND 600 THEN md5((id * 7)::VARCHAR) ELSE md5(id::VARCHAR || 'c4') END + OR c5 != CASE WHEN id BETWEEN 1000 AND 1500 THEN md5((id * 13)::VARCHAR) ELSE md5(id::VARCHAR || 'c5') END +-- +ok +== diff --git a/parser/testdata/corpus/sql/storage/metadata/partial_column_metadata_reuse_small_block.test b/parser/testdata/corpus/sql/storage/metadata/partial_column_metadata_reuse_small_block.test new file mode 100644 index 0000000..f25e310 --- /dev/null +++ b/parser/testdata/corpus/sql/storage/metadata/partial_column_metadata_reuse_small_block.test @@ -0,0 +1,29 @@ +# source: test/sql/storage/metadata/partial_column_metadata_reuse_small_block.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +ATTACH '{TEST_DIR}/partial_reuse_carries_column_extras.db' (BLOCK_SIZE 16384, STORAGE_VERSION 'latest') +-- +ok +== +USE partial_reuse_carries_column_extras +-- +ok +== +CREATE TABLE wide_tbl AS SELECT + i AS c0, i AS c1, i AS c2, i AS c3, i AS c4, + i AS c5, i AS c6, i AS c7, i AS c8, i AS c9, + i AS c10, i AS c11, i AS c12, i AS c13, i AS c14, i AS c15 +FROM range(500000) t(i) +-- +ok +== +UPDATE wide_tbl SET c6 = c6 + 1, c7 = c7 + 1 WHERE c0 < 100 +-- +ok +== +SELECT COUNT(*), SUM(c0) FROM wide_tbl +-- +ok +== diff --git a/parser/testdata/corpus/sql/storage/metadata/partial_column_metadata_reuse_v7.test b/parser/testdata/corpus/sql/storage/metadata/partial_column_metadata_reuse_v7.test new file mode 100644 index 0000000..79f996b --- /dev/null +++ b/parser/testdata/corpus/sql/storage/metadata/partial_column_metadata_reuse_v7.test @@ -0,0 +1,13 @@ +# source: test/sql/storage/metadata/partial_column_metadata_reuse_v7.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +SELECT COUNT(DISTINCT column_name) FROM pragma_storage_info('wide_tbl', loaded_segments_only=true) +-- +ok +== +SELECT DISTINCT column_name FROM pragma_storage_info('wide_tbl', loaded_segments_only=true) +-- +ok +== diff --git a/parser/testdata/corpus/sql/storage/metadata/partial_table_metadata_reuse.test b/parser/testdata/corpus/sql/storage/metadata/partial_table_metadata_reuse.test new file mode 100644 index 0000000..7a6264a --- /dev/null +++ b/parser/testdata/corpus/sql/storage/metadata/partial_table_metadata_reuse.test @@ -0,0 +1,13 @@ +# source: test/sql/storage/metadata/partial_table_metadata_reuse.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +INSERT INTO bigtbl VALUES (NULL) +-- +ok +== +SELECT COUNT(*) - {i}, SUM(i) FROM bigtbl +-- +error: Parser Error: syntax error at or near "}" +== diff --git a/parser/testdata/corpus/sql/storage/mix/test_update_delete_string.test b/parser/testdata/corpus/sql/storage/mix/test_update_delete_string.test new file mode 100644 index 0000000..04156a3 --- /dev/null +++ b/parser/testdata/corpus/sql/storage/mix/test_update_delete_string.test @@ -0,0 +1,33 @@ +# source: test/sql/storage/mix/test_update_delete_string.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +CREATE TABLE test (a INTEGER, b STRING); +-- +ok +== +INSERT INTO test VALUES (NULL, 'hello'), (13, 'abcdefgh'), (12, NULL) +-- +ok +== +SELECT * FROM test WHERE a IS NULL +-- +ok +== +UPDATE test SET b=NULL WHERE a IS NULL +-- +ok +== +INSERT INTO test VALUES (12, NULL) +-- +ok +== +UPDATE test SET b='test123' WHERE a=12 +-- +ok +== +UPDATE test SET a=a+1 +-- +ok +== diff --git a/parser/testdata/corpus/sql/storage/mix/updates_deletes_big_table.test b/parser/testdata/corpus/sql/storage/mix/updates_deletes_big_table.test new file mode 100644 index 0000000..077d0b3 --- /dev/null +++ b/parser/testdata/corpus/sql/storage/mix/updates_deletes_big_table.test @@ -0,0 +1,37 @@ +# source: test/sql/storage/mix/updates_deletes_big_table.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +INSERT INTO test SELECT a FROM range(0, 1000) tbl1(a), repeat(0, 100) tbl2(b) +-- +ok +== +UPDATE test SET a=2000 WHERE a=1 +-- +ok +== +DELETE FROM test WHERE a=2 OR a=17 +-- +ok +== +SELECT SUM(a), COUNT(a) FROM test +-- +ok +== +SELECT COUNT(a) FROM test WHERE a=0 +-- +ok +== +SELECT COUNT(a) FROM test WHERE a=1 +-- +ok +== +SELECT COUNT(a) FROM test WHERE a=2 +-- +ok +== +SELECT COUNT(a) FROM test WHERE a=17 +-- +ok +== diff --git a/parser/testdata/corpus/sql/storage/mix/updates_deletes_persistent_segments.test b/parser/testdata/corpus/sql/storage/mix/updates_deletes_persistent_segments.test new file mode 100644 index 0000000..1500271 --- /dev/null +++ b/parser/testdata/corpus/sql/storage/mix/updates_deletes_persistent_segments.test @@ -0,0 +1,33 @@ +# source: test/sql/storage/mix/updates_deletes_persistent_segments.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +CREATE TABLE test(a INTEGER, b INTEGER); +-- +ok +== +INSERT INTO test VALUES (1, 3), (NULL, NULL) +-- +ok +== +UPDATE test SET b=4 WHERE a=1 +-- +ok +== +UPDATE test SET a=4, b=4 WHERE a=1 +-- +ok +== +UPDATE test SET b=5, a=6 WHERE a=4 +-- +ok +== +DELETE FROM test WHERE a=2 +-- +ok +== +UPDATE test SET b=7 WHERE a=3 +-- +ok +== diff --git a/parser/testdata/corpus/sql/storage/multiple_clients_checkpoint_pending_updates.test b/parser/testdata/corpus/sql/storage/multiple_clients_checkpoint_pending_updates.test new file mode 100644 index 0000000..d560e5f --- /dev/null +++ b/parser/testdata/corpus/sql/storage/multiple_clients_checkpoint_pending_updates.test @@ -0,0 +1,33 @@ +# source: test/sql/storage/multiple_clients_checkpoint_pending_updates.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +INSERT INTO test SELECT * FROM range(1000000); +-- +ok +== +UPDATE test SET i=i+1; +-- +ok +== +SELECT MIN(i), MAX(i), COUNT(*) FROM test; +-- +ok +== +UPDATE test SET i=i+1 WHERE i < 1000 +-- +ok +== +UPDATE test SET i=i+1 WHERE i > 1000 AND i < 2000 +-- +ok +== +UPDATE test SET i=i+1 WHERE i > 2000 AND i < 3000 +-- +ok +== +UPDATE test SET i=i+1 WHERE i > 3000 AND i < 4000 +-- +ok +== diff --git a/parser/testdata/corpus/sql/storage/nested/struct_of_lists_unaligned.test b/parser/testdata/corpus/sql/storage/nested/struct_of_lists_unaligned.test new file mode 100644 index 0000000..fa9b1e3 --- /dev/null +++ b/parser/testdata/corpus/sql/storage/nested/struct_of_lists_unaligned.test @@ -0,0 +1,13 @@ +# source: test/sql/storage/nested/struct_of_lists_unaligned.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +CREATE TABLE test_list_2 (a integer, b STRUCT(c VARCHAR[], d VARCHAR[], e INTEGER[])); +-- +ok +== +INSERT INTO test_list_2 SELECT 1, row(['a', 'b', 'c', 'd', 'e', 'f'], ['A', 'B'], [1, 5, 9]) FROM range(10); +-- +ok +== diff --git a/parser/testdata/corpus/sql/storage/null_byte_storage.test b/parser/testdata/corpus/sql/storage/null_byte_storage.test new file mode 100644 index 0000000..ded2cda --- /dev/null +++ b/parser/testdata/corpus/sql/storage/null_byte_storage.test @@ -0,0 +1,29 @@ +# source: test/sql/storage/null_byte_storage.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +PRAGMA force_compression='{compr}' +-- +ok +== +CREATE TABLE null_byte AS SELECT concat('goo', chr(0), i) AS v FROM range(10000) tbl(i) +-- +ok +== +SELECT MIN(v), MAX(v) FROM null_byte +-- +ok +== +SELECT * FROM null_byte WHERE v=concat('goo', chr(0), 42) +-- +ok +== +CREATE INDEX i_index ON null_byte(v) +-- +ok +== +DROP TABLE null_byte +-- +ok +== diff --git a/parser/testdata/corpus/sql/storage/optimistic_write/optimistic_write_delete.test b/parser/testdata/corpus/sql/storage/optimistic_write/optimistic_write_delete.test new file mode 100644 index 0000000..614cb9f --- /dev/null +++ b/parser/testdata/corpus/sql/storage/optimistic_write/optimistic_write_delete.test @@ -0,0 +1,21 @@ +# source: test/sql/storage/optimistic_write/optimistic_write_delete.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +INSERT INTO test SELECT * FROM range(1000000) +-- +ok +== +DELETE FROM test WHERE a=0 +-- +ok +== +SELECT SUM(a) FROM test +-- +ok +== +DELETE FROM test WHERE a=1 +-- +ok +== diff --git a/parser/testdata/corpus/sql/storage/optimistic_write/optimistic_write_large_strings.test b/parser/testdata/corpus/sql/storage/optimistic_write/optimistic_write_large_strings.test new file mode 100644 index 0000000..7583204 --- /dev/null +++ b/parser/testdata/corpus/sql/storage/optimistic_write/optimistic_write_large_strings.test @@ -0,0 +1,32 @@ +# source: test/sql/storage/optimistic_write/optimistic_write_large_strings.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +SET debug_skip_checkpoint_on_commit={skip_checkpoint} +-- +error: Parser Error: syntax error at or near "}" +== +CREATE TABLE test(val VARCHAR); +-- +ok +== +INSERT INTO test VALUES (NULL); +-- +ok +== +COPY (SELECT repeat('X', len) FROM (VALUES (903), (4932)) t(len)) TO '{TEST_DIR}/large_strings.parquet'; +-- +ok +== +INSERT INTO test FROM read_parquet([ + '{TEST_DIR}/large_strings.parquet', + '{TEST_DIR}/large_strings.parquet'] +); +-- +ok +== +SELECT strlen(val) FROM test +-- +ok +== diff --git a/parser/testdata/corpus/sql/storage/optimistic_write/optimistic_write_not_trigger_checkpoint.test b/parser/testdata/corpus/sql/storage/optimistic_write/optimistic_write_not_trigger_checkpoint.test new file mode 100644 index 0000000..c9fcf02 --- /dev/null +++ b/parser/testdata/corpus/sql/storage/optimistic_write/optimistic_write_not_trigger_checkpoint.test @@ -0,0 +1,25 @@ +# source: test/sql/storage/optimistic_write/optimistic_write_not_trigger_checkpoint.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +SET checkpoint_threshold = '5 KB' +-- +ok +== +SELECT wal_size == '0 bytes' FROM pragma_database_size(); +-- +ok +== +CREATE TABLE t1 (id INTEGER, c0 DOUBLE) +-- +ok +== +INSERT INTO t1 SELECT *, random() FROM range(200000) +-- +ok +== +SELECT wal_size != '0 bytes' FROM pragma_database_size(); +-- +ok +== diff --git a/parser/testdata/corpus/sql/storage/optimistic_write/optimistic_write_temp_table.test b/parser/testdata/corpus/sql/storage/optimistic_write/optimistic_write_temp_table.test new file mode 100644 index 0000000..023c25f --- /dev/null +++ b/parser/testdata/corpus/sql/storage/optimistic_write/optimistic_write_temp_table.test @@ -0,0 +1,25 @@ +# source: test/sql/storage/optimistic_write/optimistic_write_temp_table.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +CREATE TABLE integers AS SELECT 42 i +-- +ok +== +SELECT total_blocks < 10 FROM pragma_database_size(); +-- +ok +== +CREATE TEMPORARY TABLE test (a INTEGER); +-- +ok +== +CREATE TEMPORARY TABLE test2 (a INTEGER); +-- +ok +== +INSERT INTO test2 SELECT * FROM range(1000000) +-- +ok +== diff --git a/parser/testdata/corpus/sql/storage/optimistic_write/optimistic_write_update.test b/parser/testdata/corpus/sql/storage/optimistic_write/optimistic_write_update.test new file mode 100644 index 0000000..7e4d9dd --- /dev/null +++ b/parser/testdata/corpus/sql/storage/optimistic_write/optimistic_write_update.test @@ -0,0 +1,9 @@ +# source: test/sql/storage/optimistic_write/optimistic_write_update.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +UPDATE test SET a=500000 WHERE a=0 +-- +ok +== diff --git a/parser/testdata/corpus/sql/storage/partial_blocks/many_columns_drop_table.test b/parser/testdata/corpus/sql/storage/partial_blocks/many_columns_drop_table.test new file mode 100644 index 0000000..471309f --- /dev/null +++ b/parser/testdata/corpus/sql/storage/partial_blocks/many_columns_drop_table.test @@ -0,0 +1,45 @@ +# source: test/sql/storage/partial_blocks/many_columns_drop_table.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +CREATE TABLE integers(i0 INTEGER, i1 INTEGER, i2 INTEGER, i3 INTEGER, i4 INTEGER, i5 INTEGER, i6 INTEGER, i7 INTEGER, i8 INTEGER, i9 INTEGER, i10 INTEGER, i11 INTEGER, i12 INTEGER, i13 INTEGER, i14 INTEGER, i15 INTEGER, i16 INTEGER, i17 INTEGER, i18 INTEGER, i19 INTEGER, i20 INTEGER, i21 INTEGER, i22 INTEGER, i23 INTEGER, i24 INTEGER, i25 INTEGER, i26 INTEGER, i27 INTEGER, i28 INTEGER, i29 INTEGER, i30 INTEGER, i31 INTEGER, i32 INTEGER, i33 INTEGER, i34 INTEGER, i35 INTEGER, i36 INTEGER, i37 INTEGER, i38 INTEGER, i39 INTEGER, i40 INTEGER, i41 INTEGER, i42 INTEGER, i43 INTEGER, i44 INTEGER, i45 INTEGER, i46 INTEGER, i47 INTEGER, i48 INTEGER, i49 INTEGER, i50 INTEGER, i51 INTEGER, i52 INTEGER, i53 INTEGER, i54 INTEGER, i55 INTEGER, i56 INTEGER, i57 INTEGER, i58 INTEGER, i59 INTEGER, i60 INTEGER, i61 INTEGER, i62 INTEGER, i63 INTEGER, i64 INTEGER, i65 INTEGER, i66 INTEGER, i67 INTEGER, i68 INTEGER, i69 INTEGER, i70 INTEGER, i71 INTEGER, i72 INTEGER, i73 INTEGER, i74 INTEGER, i75 INTEGER, i76 INTEGER, i77 INTEGER, i78 INTEGER, i79 INTEGER, i80 INTEGER, i81 INTEGER, i82 INTEGER, i83 INTEGER, i84 INTEGER, i85 INTEGER, i86 INTEGER, i87 INTEGER, i88 INTEGER, i89 INTEGER, i90 INTEGER, i91 INTEGER, i92 INTEGER, i93 INTEGER, i94 INTEGER, i95 INTEGER, i96 INTEGER, i97 INTEGER, i98 INTEGER, i99 INTEGER); +-- +ok +== +INSERT INTO integers VALUES (0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47, 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 58, 59, 60, 61, 62, 63, 64, 65, 66, 67, 68, 69, 70, 71, 72, 73, 74, 75, 76, 77, 78, 79, 80, 81, 82, 83, 84, 85, 86, 87, 88, 89, 90, 91, 92, 93, 94, 95, 96, 97, 98, 99); +-- +ok +== +INSERT INTO integers VALUES (1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47, 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 58, 59, 60, 61, 62, 63, 64, 65, 66, 67, 68, 69, 70, 71, 72, 73, 74, 75, 76, 77, 78, 79, 80, 81, 82, 83, 84, 85, 86, 87, 88, 89, 90, 91, 92, 93, 94, 95, 96, 97, 98, 99, 100); +-- +ok +== +CREATE TABLE integers2(i0 INTEGER, i1 INTEGER, i2 INTEGER, i3 INTEGER, i4 INTEGER, i5 INTEGER, i6 INTEGER, i7 INTEGER, i8 INTEGER, i9 INTEGER, i10 INTEGER, i11 INTEGER, i12 INTEGER, i13 INTEGER, i14 INTEGER, i15 INTEGER, i16 INTEGER, i17 INTEGER, i18 INTEGER, i19 INTEGER, i20 INTEGER, i21 INTEGER, i22 INTEGER, i23 INTEGER, i24 INTEGER, i25 INTEGER, i26 INTEGER, i27 INTEGER, i28 INTEGER, i29 INTEGER, i30 INTEGER, i31 INTEGER, i32 INTEGER, i33 INTEGER, i34 INTEGER, i35 INTEGER, i36 INTEGER, i37 INTEGER, i38 INTEGER, i39 INTEGER, i40 INTEGER, i41 INTEGER, i42 INTEGER, i43 INTEGER, i44 INTEGER, i45 INTEGER, i46 INTEGER, i47 INTEGER, i48 INTEGER, i49 INTEGER, i50 INTEGER, i51 INTEGER, i52 INTEGER, i53 INTEGER, i54 INTEGER, i55 INTEGER, i56 INTEGER, i57 INTEGER, i58 INTEGER, i59 INTEGER, i60 INTEGER, i61 INTEGER, i62 INTEGER, i63 INTEGER, i64 INTEGER, i65 INTEGER, i66 INTEGER, i67 INTEGER, i68 INTEGER, i69 INTEGER, i70 INTEGER, i71 INTEGER, i72 INTEGER, i73 INTEGER, i74 INTEGER, i75 INTEGER, i76 INTEGER, i77 INTEGER, i78 INTEGER, i79 INTEGER, i80 INTEGER, i81 INTEGER, i82 INTEGER, i83 INTEGER, i84 INTEGER, i85 INTEGER, i86 INTEGER, i87 INTEGER, i88 INTEGER, i89 INTEGER, i90 INTEGER, i91 INTEGER, i92 INTEGER, i93 INTEGER, i94 INTEGER, i95 INTEGER, i96 INTEGER, i97 INTEGER, i98 INTEGER, i99 INTEGER); +-- +ok +== +INSERT INTO integers2 VALUES (0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47, 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 58, 59, 60, 61, 62, 63, 64, 65, 66, 67, 68, 69, 70, 71, 72, 73, 74, 75, 76, 77, 78, 79, 80, 81, 82, 83, 84, 85, 86, 87, 88, 89, 90, 91, 92, 93, 94, 95, 96, 97, 98, 99); +-- +ok +== +INSERT INTO integers2 VALUES (1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47, 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 58, 59, 60, 61, 62, 63, 64, 65, 66, 67, 68, 69, 70, 71, 72, 73, 74, 75, 76, 77, 78, 79, 80, 81, 82, 83, 84, 85, 86, 87, 88, 89, 90, 91, 92, 93, 94, 95, 96, 97, 98, 99, 100); +-- +ok +== +SELECT i{i}={i} FROM integers +-- +error: Parser Error: syntax error at or near "{" +== +SELECT i{i}={i}+1 FROM integers +-- +error: Parser Error: syntax error at or near "{" +== +SELECT i{i}={i} FROM integers2 +-- +error: Parser Error: syntax error at or near "{" +== +SELECT i{i}={i}+1 FROM integers2 +-- +error: Parser Error: syntax error at or near "{" +== diff --git a/parser/testdata/corpus/sql/storage/partial_blocks/many_columns_rle.test b/parser/testdata/corpus/sql/storage/partial_blocks/many_columns_rle.test new file mode 100644 index 0000000..5ce382d --- /dev/null +++ b/parser/testdata/corpus/sql/storage/partial_blocks/many_columns_rle.test @@ -0,0 +1,13 @@ +# source: test/sql/storage/partial_blocks/many_columns_rle.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +PRAGMA force_compression='rle' +-- +ok +== +SELECT total_blocks * block_size < 10 * 262144 FROM pragma_database_size() +-- +ok +== diff --git a/parser/testdata/corpus/sql/storage/partial_blocks/many_columns_storage.test b/parser/testdata/corpus/sql/storage/partial_blocks/many_columns_storage.test new file mode 100644 index 0000000..77cfc3e --- /dev/null +++ b/parser/testdata/corpus/sql/storage/partial_blocks/many_columns_storage.test @@ -0,0 +1,13 @@ +# source: test/sql/storage/partial_blocks/many_columns_storage.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +select count(*) from pragma_storage_info('integers') where block_id IS NULL; +-- +ok +== +SELECT total_blocks FROM pragma_database_size() +-- +ok +== diff --git a/parser/testdata/corpus/sql/storage/partial_blocks/many_columns_strings.test b/parser/testdata/corpus/sql/storage/partial_blocks/many_columns_strings.test new file mode 100644 index 0000000..9badde3 --- /dev/null +++ b/parser/testdata/corpus/sql/storage/partial_blocks/many_columns_strings.test @@ -0,0 +1,33 @@ +# source: test/sql/storage/partial_blocks/many_columns_strings.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +CREATE TABLE strings(i0 VARCHAR, i1 VARCHAR, i2 VARCHAR, i3 VARCHAR, i4 VARCHAR, i5 VARCHAR, i6 VARCHAR, i7 VARCHAR, i8 VARCHAR, i9 VARCHAR, i10 VARCHAR, i11 VARCHAR, i12 VARCHAR, i13 VARCHAR, i14 VARCHAR, i15 VARCHAR, i16 VARCHAR, i17 VARCHAR, i18 VARCHAR, i19 VARCHAR, i20 VARCHAR, i21 VARCHAR, i22 VARCHAR, i23 VARCHAR, i24 VARCHAR, i25 VARCHAR, i26 VARCHAR, i27 VARCHAR, i28 VARCHAR, i29 VARCHAR, i30 VARCHAR, i31 VARCHAR, i32 VARCHAR, i33 VARCHAR, i34 VARCHAR, i35 VARCHAR, i36 VARCHAR, i37 VARCHAR, i38 VARCHAR, i39 VARCHAR, i40 VARCHAR, i41 VARCHAR, i42 VARCHAR, i43 VARCHAR, i44 VARCHAR, i45 VARCHAR, i46 VARCHAR, i47 VARCHAR, i48 VARCHAR, i49 VARCHAR, i50 VARCHAR, i51 VARCHAR, i52 VARCHAR, i53 VARCHAR, i54 VARCHAR, i55 VARCHAR, i56 VARCHAR, i57 VARCHAR, i58 VARCHAR, i59 VARCHAR, i60 VARCHAR, i61 VARCHAR, i62 VARCHAR, i63 VARCHAR, i64 VARCHAR, i65 VARCHAR, i66 VARCHAR, i67 VARCHAR, i68 VARCHAR, i69 VARCHAR, i70 VARCHAR, i71 VARCHAR, i72 VARCHAR, i73 VARCHAR, i74 VARCHAR, i75 VARCHAR, i76 VARCHAR, i77 VARCHAR, i78 VARCHAR, i79 VARCHAR, i80 VARCHAR, i81 VARCHAR, i82 VARCHAR, i83 VARCHAR, i84 VARCHAR, i85 VARCHAR, i86 VARCHAR, i87 VARCHAR, i88 VARCHAR, i89 VARCHAR, i90 VARCHAR, i91 VARCHAR, i92 VARCHAR, i93 VARCHAR, i94 VARCHAR, i95 VARCHAR, i96 VARCHAR, i97 VARCHAR, i98 VARCHAR, i99 VARCHAR); +-- +ok +== +INSERT INTO strings VALUES (0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47, 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 58, 59, 60, 61, 62, 63, 64, 65, 66, 67, 68, 69, 70, 71, 72, 73, 74, 75, 76, 77, 78, 79, 80, 81, 82, 83, 84, 85, 86, 87, 88, 89, 90, 91, 92, 93, 94, 95, 96, 97, 98, 99); +-- +ok +== +SELECT total_blocks * block_size < 15 * 262144 FROM pragma_database_size() +-- +ok +== +INSERT INTO strings VALUES (1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47, 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 58, 59, 60, 61, 62, 63, 64, 65, 66, 67, 68, 69, 70, 71, 72, 73, 74, 75, 76, 77, 78, 79, 80, 81, 82, 83, 84, 85, 86, 87, 88, 89, 90, 91, 92, 93, 94, 95, 96, 97, 98, 99, 100); +-- +ok +== +SELECT i{i}='{i}' FROM strings +-- +error: Parser Error: syntax error at or near "{" +== +SELECT i{i}=({i}+1)::VARCHAR FROM strings +-- +error: Parser Error: syntax error at or near "{" +== +SELECT i{i}={i}::VARCHAR FROM strings +-- +error: Parser Error: syntax error at or near "{" +== diff --git a/parser/testdata/corpus/sql/storage/partial_blocks/many_columns_validity.test b/parser/testdata/corpus/sql/storage/partial_blocks/many_columns_validity.test new file mode 100644 index 0000000..7e628ed --- /dev/null +++ b/parser/testdata/corpus/sql/storage/partial_blocks/many_columns_validity.test @@ -0,0 +1,9 @@ +# source: test/sql/storage/partial_blocks/many_columns_validity.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +INSERT INTO integers (i1) VALUES (NULL); +-- +ok +== diff --git a/parser/testdata/corpus/sql/storage/partial_delete_checkpoint_mask.test b/parser/testdata/corpus/sql/storage/partial_delete_checkpoint_mask.test new file mode 100644 index 0000000..2a67609 --- /dev/null +++ b/parser/testdata/corpus/sql/storage/partial_delete_checkpoint_mask.test @@ -0,0 +1,17 @@ +# source: test/sql/storage/partial_delete_checkpoint_mask.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +CREATE TABLE tbl AS SELECT i FROM range(1228800) t(i) +-- +ok +== +DELETE FROM tbl WHERE i % 2 = 0 +-- +ok +== +SELECT COUNT(*) FILTER (WHERE i % 2 = 0) FROM tbl +-- +ok +== diff --git a/parser/testdata/corpus/sql/storage/partial_delete_pending_compress.test b/parser/testdata/corpus/sql/storage/partial_delete_pending_compress.test new file mode 100644 index 0000000..8ab082e --- /dev/null +++ b/parser/testdata/corpus/sql/storage/partial_delete_pending_compress.test @@ -0,0 +1,25 @@ +# source: test/sql/storage/partial_delete_pending_compress.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +PRAGMA force_checkpoint +-- +ok +== +CREATE TABLE p AS SELECT i FROM range(1228800) t(i) +-- +ok +== +DELETE FROM p WHERE i % 2 = 0 +-- +ok +== +SELECT COUNT(*) FROM p +-- +ok +== +SELECT COUNT(*), MIN(i) FROM p +-- +ok +== diff --git a/parser/testdata/corpus/sql/storage/piecemeal_delete_checkpoint_compress.test b/parser/testdata/corpus/sql/storage/piecemeal_delete_checkpoint_compress.test new file mode 100644 index 0000000..bce7e9a --- /dev/null +++ b/parser/testdata/corpus/sql/storage/piecemeal_delete_checkpoint_compress.test @@ -0,0 +1,17 @@ +# source: test/sql/storage/piecemeal_delete_checkpoint_compress.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +DELETE FROM tbl WHERE i < 61440 AND i % 2 = 0 +-- +ok +== +DELETE FROM tbl WHERE i < 61440 AND i % 2 = 1 +-- +ok +== +DELETE FROM tbl WHERE i < 100000 +-- +ok +== diff --git a/parser/testdata/corpus/sql/storage/pragma_storage_info_scan_type.test b/parser/testdata/corpus/sql/storage/pragma_storage_info_scan_type.test new file mode 100644 index 0000000..8f21fcd --- /dev/null +++ b/parser/testdata/corpus/sql/storage/pragma_storage_info_scan_type.test @@ -0,0 +1,50 @@ +# source: test/sql/storage/pragma_storage_info_scan_type.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +CREATE TABLE bp_tbl (a INTEGER) +-- +ok +== +INSERT INTO bp_tbl SELECT 1 FROM range(0, 10000) tbl(i) +-- +ok +== +INSERT INTO bp_tbl SELECT 2 FROM range(0, 10000) tbl(i) +-- +ok +== +SELECT segment_info FROM pragma_storage_info('bp_tbl') LIMIT 1 +-- +ok +== +SELECT segment_info FROM pragma_storage_info('bp_tbl', include_segment_info=false) LIMIT 1 +-- +ok +== +SELECT COUNT(*) > 0 FROM pragma_storage_info('bp_tbl') WHERE segment_type NOT IN ('VALIDITY') +-- +ok +== +SELECT segment_info FROM pragma_storage_info('bp_tbl', include_segment_info=true) WHERE segment_type NOT IN ('VALIDITY') +-- +ok +== +SELECT COUNT(*) = (SELECT COUNT(*) FROM pragma_storage_info('bp_tbl', include_segment_info=true)) +FROM pragma_storage_info('bp_tbl') +-- +ok +== +SELECT * FROM pragma_storage_info('bp_tbl', include_segment_info=true, loaded_segments_only=true) +-- +ok +== +SELECT * FROM pragma_storage_info('bp_tbl', loaded_segments_only=true) +-- +ok +== +SELECT segment_info FROM pragma_storage_info('bp_tbl', loaded_segments_only=true) LIMIT 1 +-- +ok +== diff --git a/parser/testdata/corpus/sql/storage/prefetch/async_native_scan_pool.test b/parser/testdata/corpus/sql/storage/prefetch/async_native_scan_pool.test new file mode 100644 index 0000000..f29c2a6 --- /dev/null +++ b/parser/testdata/corpus/sql/storage/prefetch/async_native_scan_pool.test @@ -0,0 +1,17 @@ +# source: test/sql/storage/prefetch/async_native_scan_pool.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +CREATE TABLE integers AS SELECT range AS i FROM range(1000000); +-- +ok +== +SET storage_block_prefetch='debug_force_always' +-- +ok +== +SELECT sum(i) FROM integers +-- +ok +== diff --git a/parser/testdata/corpus/sql/storage/prefetch/async_native_scan_positional.test b/parser/testdata/corpus/sql/storage/prefetch/async_native_scan_positional.test new file mode 100644 index 0000000..30fb9e3 --- /dev/null +++ b/parser/testdata/corpus/sql/storage/prefetch/async_native_scan_positional.test @@ -0,0 +1,17 @@ +# source: test/sql/storage/prefetch/async_native_scan_positional.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +CREATE TABLE t1 AS SELECT range AS i FROM range(100000); +-- +ok +== +CREATE TABLE t2 AS SELECT range * 2 AS j FROM range(100000); +-- +ok +== +SELECT sum(i + j) FROM (SELECT * FROM t1 POSITIONAL JOIN t2) +-- +ok +== diff --git a/parser/testdata/corpus/sql/storage/read_duckdb/read_duckdb_basic.test b/parser/testdata/corpus/sql/storage/read_duckdb/read_duckdb_basic.test new file mode 100644 index 0000000..3031b01 --- /dev/null +++ b/parser/testdata/corpus/sql/storage/read_duckdb/read_duckdb_basic.test @@ -0,0 +1,65 @@ +# source: test/sql/storage/read_duckdb/read_duckdb_basic.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +ATTACH '{TEST_DIR}/read_duckdb_test.db' +-- +ok +== +CREATE TABLE read_duckdb_test.my_tbl AS SELECT 42 i +-- +ok +== +SELECT * FROM read_duckdb('{TEST_DIR}/read_duckdb_test.db') +-- +ok +== +DETACH read_duckdb_test +-- +ok +== +SELECT COUNT(*) FROM duckdb_databases +-- +ok +== +ATTACH '{TEST_DIR}/read_duckdb_test2.db' +-- +ok +== +CREATE TABLE read_duckdb_test2.other_tbl AS SELECT 100 i +-- +ok +== +DETACH read_duckdb_test2 +-- +ok +== +SELECT * FROM read_duckdb('{TEST_DIR}/read_duckdb_test*.db') +-- +ok +== +SELECT * FROM '{TEST_DIR}/read_duckdb_test*.db' +-- +ok +== +PREPARE v1 AS FROM read_duckdb('{TEST_DIR}/read_duckdb_test*.db') +-- +ok +== +CREATE TABLE read_duckdb_test.my_tbl2 AS SELECT 84 j +-- +ok +== +SELECT * FROM read_duckdb('{TEST_DIR}/read_duckdb_test.db', table_name='my_tbl') +-- +ok +== +SELECT * FROM read_duckdb('{TEST_DIR}/read_duckdb_test.db', table_name='my_tbl2') +-- +ok +== +SELECT * FROM read_duckdb('{TEST_DIR}/read_duckdb_test.db', table_name='my_tblx') +-- +ok +== diff --git a/parser/testdata/corpus/sql/storage/read_duckdb/read_duckdb_generated.test b/parser/testdata/corpus/sql/storage/read_duckdb/read_duckdb_generated.test new file mode 100644 index 0000000..5d5792b --- /dev/null +++ b/parser/testdata/corpus/sql/storage/read_duckdb/read_duckdb_generated.test @@ -0,0 +1,34 @@ +# source: test/sql/storage/read_duckdb/read_duckdb_generated.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +ATTACH '{TEST_DIR}/read_duckdb_generated.db' AS rd +-- +ok +== +CREATE TABLE rd.tbl ( + price INTEGER, + amount_sold INTEGER, + total_profit AS (price * amount_sold), + non_generated INTEGER +); +-- +ok +== +INSERT INTO rd.tbl VALUES (5,4, 100); +-- +ok +== +DETACH rd +-- +ok +== +SELECT * FROM read_duckdb('{TEST_DIR}/read_duckdb_generated.db') +-- +ok +== +SELECT non_generated + 42, price, amount_sold FROM read_duckdb('{TEST_DIR}/read_duckdb_generated.db') +-- +ok +== diff --git a/parser/testdata/corpus/sql/storage/read_duckdb/read_duckdb_index.test b/parser/testdata/corpus/sql/storage/read_duckdb/read_duckdb_index.test new file mode 100644 index 0000000..ba3a8de --- /dev/null +++ b/parser/testdata/corpus/sql/storage/read_duckdb/read_duckdb_index.test @@ -0,0 +1,29 @@ +# source: test/sql/storage/read_duckdb/read_duckdb_index.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +ATTACH '{TEST_DIR}/read_duckdb_index.db' +-- +ok +== +CREATE TABLE read_duckdb_index.my_tbl(i INTEGER PRIMARY KEY); +-- +ok +== +INSERT INTO read_duckdb_index.my_tbl SELECT i + 1 FROM range(1000000) t(i); +-- +ok +== +DETACH read_duckdb_index +-- +ok +== +SELECT * FROM read_duckdb('{TEST_DIR}/read_duckdb_index.db') WHERE i=42873 +-- +ok +== +SELECT *, rowid FROM read_duckdb('{TEST_DIR}/read_duckdb_index.db') WHERE i=42873 +-- +ok +== diff --git a/parser/testdata/corpus/sql/storage/read_duckdb/read_duckdb_schema.test b/parser/testdata/corpus/sql/storage/read_duckdb/read_duckdb_schema.test new file mode 100644 index 0000000..6cec372 --- /dev/null +++ b/parser/testdata/corpus/sql/storage/read_duckdb/read_duckdb_schema.test @@ -0,0 +1,41 @@ +# source: test/sql/storage/read_duckdb/read_duckdb_schema.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +ATTACH '{TEST_DIR}/read_duckdb_schema.db' AS rd +-- +ok +== +CREATE SCHEMA rd.s1; +-- +ok +== +CREATE SCHEMA rd.s2; +-- +ok +== +CREATE TABLE rd.s1.my_tbl AS SELECT 42 i +-- +ok +== +CREATE TABLE rd.s2.my_tbl AS SELECT 84 i +-- +ok +== +SELECT * FROM read_duckdb('{TEST_DIR}/read_duckdb_schema.db') +-- +ok +== +SELECT * FROM read_duckdb('{TEST_DIR}/read_duckdb_schema.db', schema_name='s1', table_name='my_tbl') +-- +ok +== +SELECT * FROM read_duckdb('{TEST_DIR}/read_duckdb_schema.db', schema_name='s2', table_name='my_tbl') +-- +ok +== +SELECT * FROM read_duckdb('{TEST_DIR}/read_duckdb_schema.db', schema_name='s3', table_name='my_tbl') +-- +ok +== diff --git a/parser/testdata/corpus/sql/storage/read_duckdb/read_duckdb_suggested.test b/parser/testdata/corpus/sql/storage/read_duckdb/read_duckdb_suggested.test new file mode 100644 index 0000000..52ec2da --- /dev/null +++ b/parser/testdata/corpus/sql/storage/read_duckdb/read_duckdb_suggested.test @@ -0,0 +1,25 @@ +# source: test/sql/storage/read_duckdb/read_duckdb_suggested.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +ATTACH '{TEST_DIR}/read_duckdb_suggested.db' AS suggested +-- +ok +== +CREATE TABLE suggested.{table_name} AS SELECT 42 i +-- +error: Parser Error: syntax error at or near "{" +== +DETACH suggested +-- +ok +== +SELECT * FROM read_duckdb('{TEST_DIR}/read_duckdb_suggested.db', table_name='ffg') +-- +ok +== +SELECT * FROM read_duckdb('{TEST_DIR}/read_duckdb_suggested.db', table_name='vvx') +-- +ok +== diff --git a/parser/testdata/corpus/sql/storage/read_duckdb/read_duckdb_top_n.test b/parser/testdata/corpus/sql/storage/read_duckdb/read_duckdb_top_n.test new file mode 100644 index 0000000..7be3a92 --- /dev/null +++ b/parser/testdata/corpus/sql/storage/read_duckdb/read_duckdb_top_n.test @@ -0,0 +1,33 @@ +# source: test/sql/storage/read_duckdb/read_duckdb_top_n.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +ATTACH '{TEST_DIR}/read_duckdb_top_n{i}.db' AS rd +-- +ok +== +CREATE TABLE rd.tbl AS SELECT {i} grp, i val FROM range({i} * 1000, {i} * 1000 + 1000) t(i) +-- +error: Parser Error: syntax error at or near "}" +== +FROM '{TEST_DIR}/read_duckdb_top_n*.db' ORDER BY val DESC LIMIT 5 +-- +ok +== +FROM '{TEST_DIR}/read_duckdb_top_n*.db' WHERE grp<=2 ORDER BY val DESC LIMIT 5 +-- +ok +== +SELECT val FROM '{TEST_DIR}/read_duckdb_top_n*.db' WHERE grp<=2 ORDER BY val DESC LIMIT 5 +-- +ok +== +SELECT SUM(val) FROM '{TEST_DIR}/read_duckdb_top_n*.db' WHERE grp%2=0 +-- +ok +== +SELECT SUM(val) FROM '{TEST_DIR}/read_duckdb_top_n*.db' WHERE grp::VARCHAR = '2' +-- +ok +== diff --git a/parser/testdata/corpus/sql/storage/read_duckdb/read_duckdb_transaction.test b/parser/testdata/corpus/sql/storage/read_duckdb/read_duckdb_transaction.test new file mode 100644 index 0000000..2d2f1b0 --- /dev/null +++ b/parser/testdata/corpus/sql/storage/read_duckdb/read_duckdb_transaction.test @@ -0,0 +1,17 @@ +# source: test/sql/storage/read_duckdb/read_duckdb_transaction.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +ATTACH '{TEST_DIR}/read_duckdb_transaction.db' AS rd +-- +ok +== +CREATE TABLE rd.my_tbl AS SELECT 42 i +-- +ok +== +SELECT * FROM read_duckdb('{TEST_DIR}/read_duckdb_transaction.db') +-- +ok +== diff --git a/parser/testdata/corpus/sql/storage/read_duckdb/read_duckdb_union_by_name.test b/parser/testdata/corpus/sql/storage/read_duckdb/read_duckdb_union_by_name.test new file mode 100644 index 0000000..0e5dae6 --- /dev/null +++ b/parser/testdata/corpus/sql/storage/read_duckdb/read_duckdb_union_by_name.test @@ -0,0 +1,29 @@ +# source: test/sql/storage/read_duckdb/read_duckdb_union_by_name.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +ATTACH '{TEST_DIR}/read_duckdb_unionbyname1.db' AS rd +-- +ok +== +CREATE TABLE rd.my_tbl AS SELECT 100 i, 84 col1 +-- +ok +== +ATTACH '{TEST_DIR}/read_duckdb_unionbyname2.db' AS rd +-- +ok +== +CREATE TABLE rd.my_tbl AS SELECT 200 i, 84 col2 +-- +ok +== +SELECT * FROM read_duckdb(['{TEST_DIR}/read_duckdb_unionbyname1.db', '{TEST_DIR}/read_duckdb_unionbyname2.db'], union_by_name=true); +-- +ok +== +SELECT * FROM read_duckdb(['{TEST_DIR}/read_duckdb_unionbyname1.db', '{TEST_DIR}/read_duckdb_unionbyname2.db']); +-- +ok +== diff --git a/parser/testdata/corpus/sql/storage/read_duckdb/read_duckdb_virtual_columns.test b/parser/testdata/corpus/sql/storage/read_duckdb/read_duckdb_virtual_columns.test new file mode 100644 index 0000000..a503d05 --- /dev/null +++ b/parser/testdata/corpus/sql/storage/read_duckdb/read_duckdb_virtual_columns.test @@ -0,0 +1,17 @@ +# source: test/sql/storage/read_duckdb/read_duckdb_virtual_columns.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +ATTACH '{TEST_DIR}/read_duckdb_virt{dbindex}.db' AS rd +-- +ok +== +CREATE TABLE rd.my_tbl AS SELECT 42 + i AS v FROM range(0, {dbindex}) t(i) +-- +error: Parser Error: syntax error at or near "}" +== +SELECT rowid, (filename.replace('\', '/').split('/')[-1]), * FROM read_duckdb('{TEST_DIR}/read_duckdb_virt[1-2].db') ORDER BY filename, rowid +-- +ok +== diff --git a/parser/testdata/corpus/sql/storage/reclaim_space/test_reclaim_space_update_large_string.test b/parser/testdata/corpus/sql/storage/reclaim_space/test_reclaim_space_update_large_string.test new file mode 100644 index 0000000..20b1664 --- /dev/null +++ b/parser/testdata/corpus/sql/storage/reclaim_space/test_reclaim_space_update_large_string.test @@ -0,0 +1,25 @@ +# source: test/sql/storage/reclaim_space/test_reclaim_space_update_large_string.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +PRAGMA force_checkpoint; +-- +ok +== +INSERT INTO test VALUES (repeat('a', 1000000)); +-- +ok +== +SELECT LENGTH(SUBSTRING(a, 0, 1000000)) FROM test +-- +ok +== +UPDATE test SET a=concat(a, 'a') +-- +ok +== +select total_blocks from pragma_database_size(); +-- +ok +== diff --git a/parser/testdata/corpus/sql/storage/row_group_fetch_bulk.test b/parser/testdata/corpus/sql/storage/row_group_fetch_bulk.test new file mode 100644 index 0000000..ad478b1 --- /dev/null +++ b/parser/testdata/corpus/sql/storage/row_group_fetch_bulk.test @@ -0,0 +1,111 @@ +# source: test/sql/storage/row_group_fetch_bulk.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +CREATE TABLE big ( + k INTEGER PRIMARY KEY, + v BIGINT, + s VARCHAR, + n INTEGER +); +-- +ok +== +INSERT INTO big SELECT + range::INTEGER, + (range * 10)::BIGINT, + 'val_' || range::VARCHAR, + CASE WHEN range % 7 = 0 THEN NULL ELSE range::INTEGER END +FROM range(500000); +-- +ok +== +SELECT k, v FROM big WHERE k IN (10, 11, 12, 13, 14, 15, 16, 17, 18, 19) ORDER BY k; +-- +ok +== +SELECT k, v FROM big WHERE k IN (10, 150000, 280000, 410000) ORDER BY k; +-- +ok +== +SELECT k, v FROM big WHERE k IN (10, 200000, 11, 200001, 12, 200002) ORDER BY k; +-- +ok +== +SELECT k, v FROM big WHERE k IN (42, 7, 99, 13); +-- +ok +== +SELECT k, v, s, n FROM big WHERE k IN (3, 4, 5, 6, 7) ORDER BY k; +-- +ok +== +SELECT k, n FROM big WHERE k IN (0, 1, 7, 14, 21, 28) ORDER BY k; +-- +ok +== +DELETE FROM big WHERE k IN (501, 503, 505); +-- +ok +== +SELECT k, v FROM big WHERE k IN (500, 501, 502, 503, 504, 505, 506) ORDER BY k; +-- +ok +== +DELETE FROM big WHERE k IN (200000, 200002); +-- +ok +== +SELECT k, v FROM big WHERE k IN (200000, 200001, 200002, 200003) ORDER BY k; +-- +ok +== +SELECT count(*), sum(v) FROM big WHERE k IN (500, 501, 502, 503, 504, 505, 506); +-- +ok +== +UPDATE big SET v = v + 1 WHERE k IN (12, 14, 16); +-- +ok +== +UPDATE big SET v = -1, s = 'updated', n = 999 WHERE k IN (101, 103, 105); +-- +ok +== +SELECT k, v, s, n FROM big WHERE k IN (100, 101, 102, 103, 104, 105, 106) ORDER BY k; +-- +ok +== +SELECT k, v, s, n FROM big WHERE k IN (101, 103, 105) ORDER BY k; +-- +ok +== +UPDATE big SET s = 'boundary', n = -7 WHERE k IN (122879, 122880, 122881); +-- +ok +== +SELECT k, v, s, n FROM big WHERE k IN (122878, 122879, 122880, 122881, 122882) ORDER BY k; +-- +ok +== +CREATE TABLE del (k INTEGER PRIMARY KEY, v BIGINT); +-- +ok +== +INSERT INTO del SELECT range::INTEGER, (range * 10)::BIGINT FROM range(300000); +-- +ok +== +DELETE FROM del WHERE k BETWEEN 100 AND 200099; +-- +ok +== +SELECT count(*) FROM del; +-- +ok +== +SELECT k, v FROM del WHERE k IN (50, 99, 100, 200099, 200100, 200101) ORDER BY k; +-- +ok +== diff --git a/parser/testdata/corpus/sql/storage/rowid_gaps/alter_preserves_rowid_gaps.test b/parser/testdata/corpus/sql/storage/rowid_gaps/alter_preserves_rowid_gaps.test new file mode 100644 index 0000000..56e53d7 --- /dev/null +++ b/parser/testdata/corpus/sql/storage/rowid_gaps/alter_preserves_rowid_gaps.test @@ -0,0 +1,73 @@ +# source: test/sql/storage/rowid_gaps/alter_preserves_rowid_gaps.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +ATTACH '{TEST_DIR}/rowid_gap_alter.db' AS rowid_gap_alter (STORAGE_VERSION 'latest', ROW_GROUP_SIZE 2048); +-- +ok +== +CREATE TABLE rowid_gap_alter.t AS SELECT i, CAST(i AS INTEGER) AS v, i + 10 AS drop_me FROM range(6144) tbl(i); +-- +ok +== +CREATE UNIQUE INDEX idx_i ON rowid_gap_alter.t(i); +-- +ok +== +CHECKPOINT rowid_gap_alter; +-- +ok +== +DELETE FROM rowid_gap_alter.t WHERE i >= 2048 AND i < 4096; +-- +ok +== +DETACH rowid_gap_alter; +-- +ok +== +ATTACH '{TEST_DIR}/rowid_gap_alter.db' AS rowid_gap_alter; +-- +ok +== +ALTER TABLE rowid_gap_alter.t ADD COLUMN added INTEGER DEFAULT 7; +-- +ok +== +SELECT rowid, i, v, added FROM rowid_gap_alter.t WHERE i IN (2047, 4096) ORDER BY i; +-- +ok +== +DROP INDEX rowid_gap_alter.idx_i; +-- +ok +== +ALTER TABLE rowid_gap_alter.t DROP COLUMN drop_me; +-- +ok +== +ALTER TABLE rowid_gap_alter.t ALTER v SET DATA TYPE BIGINT; +-- +ok +== +INSERT INTO rowid_gap_alter.t VALUES (999999, 9999990, 7); +-- +ok +== +SELECT rowid, i FROM rowid_gap_alter.t WHERE i = 999999; +-- +ok +== +CREATE UNIQUE INDEX idx_i_after_alter ON rowid_gap_alter.t(i); +-- +ok +== +SELECT rowid, i, v, added FROM rowid_gap_alter.t WHERE i IN (2047, 4096, 999999) ORDER BY i; +-- +ok +== +SELECT count(*) FROM rowid_gap_alter.t WHERE rowid >= 2048 AND rowid < 4096; +-- +ok +== diff --git a/parser/testdata/corpus/sql/storage/rowid_gaps/append_after_gap_checkpoint.test b/parser/testdata/corpus/sql/storage/rowid_gaps/append_after_gap_checkpoint.test new file mode 100644 index 0000000..ad17348 --- /dev/null +++ b/parser/testdata/corpus/sql/storage/rowid_gaps/append_after_gap_checkpoint.test @@ -0,0 +1,89 @@ +# source: test/sql/storage/rowid_gaps/append_after_gap_checkpoint.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +ATTACH '{TEST_DIR}/rowid_gap_append_latest.db' AS rowid_gap_append_latest (STORAGE_VERSION 'latest', ROW_GROUP_SIZE 2048); +-- +ok +== +CREATE TABLE rowid_gap_append_latest.t AS SELECT i FROM range(6144) tbl(i); +-- +ok +== +CREATE UNIQUE INDEX idx_i ON rowid_gap_append_latest.t(i); +-- +ok +== +CHECKPOINT rowid_gap_append_latest; +-- +ok +== +DELETE FROM rowid_gap_append_latest.t WHERE i >= 2048 AND i < 4096; +-- +ok +== +DETACH rowid_gap_append_latest; +-- +ok +== +ATTACH '{TEST_DIR}/rowid_gap_append_latest.db' AS rowid_gap_append_latest; +-- +ok +== +SELECT min(rowid), max(rowid), count(*) FROM rowid_gap_append_latest.t; +-- +ok +== +INSERT INTO rowid_gap_append_latest.t VALUES (999999); +-- +ok +== +SELECT rowid, i FROM rowid_gap_append_latest.t WHERE i = 999999; +-- +ok +== +SET max_vacuum_tasks = 99; +-- +ok +== +DROP INDEX rowid_gap_append_latest.idx_i; +-- +ok +== +ATTACH '{TEST_DIR}/rowid_gap_append_old_storage.db' AS rowid_gap_append_old_storage (STORAGE_VERSION 'v1.5.0', ROW_GROUP_SIZE 2048); +-- +ok +== +CREATE TABLE rowid_gap_append_old_storage.t AS SELECT i FROM range(6144) tbl(i); +-- +ok +== +CHECKPOINT rowid_gap_append_old_storage; +-- +ok +== +DELETE FROM rowid_gap_append_old_storage.t WHERE i >= 2048 AND i < 4096; +-- +ok +== +DETACH rowid_gap_append_old_storage; +-- +ok +== +ATTACH '{TEST_DIR}/rowid_gap_append_old_storage.db' AS rowid_gap_append_old_storage; +-- +ok +== +SELECT min(rowid), max(rowid), count(*) FROM rowid_gap_append_old_storage.t; +-- +ok +== +INSERT INTO rowid_gap_append_old_storage.t VALUES (999999); +-- +ok +== +SELECT rowid, i FROM rowid_gap_append_old_storage.t WHERE i = 999999; +-- +ok +== diff --git a/parser/testdata/corpus/sql/storage/rowid_gaps/bulk_append_after_gap_checkpoint.test b/parser/testdata/corpus/sql/storage/rowid_gaps/bulk_append_after_gap_checkpoint.test new file mode 100644 index 0000000..5225cf7 --- /dev/null +++ b/parser/testdata/corpus/sql/storage/rowid_gaps/bulk_append_after_gap_checkpoint.test @@ -0,0 +1,49 @@ +# source: test/sql/storage/rowid_gaps/bulk_append_after_gap_checkpoint.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +ATTACH '{TEST_DIR}/rowid_gap_bulk_append.db' AS rowid_gap_bulk_append (STORAGE_VERSION 'latest', ROW_GROUP_SIZE 2048); +-- +ok +== +CREATE TABLE rowid_gap_bulk_append.t AS SELECT i FROM range(6144) tbl(i); +-- +ok +== +CREATE UNIQUE INDEX idx_i ON rowid_gap_bulk_append.t(i); +-- +ok +== +CHECKPOINT rowid_gap_bulk_append; +-- +ok +== +DELETE FROM rowid_gap_bulk_append.t WHERE i >= 2048 AND i < 4096; +-- +ok +== +DETACH rowid_gap_bulk_append; +-- +ok +== +ATTACH '{TEST_DIR}/rowid_gap_bulk_append.db' AS rowid_gap_bulk_append; +-- +ok +== +SELECT min(rowid), max(rowid), count(*) FROM rowid_gap_bulk_append.t; +-- +ok +== +INSERT INTO rowid_gap_bulk_append.t SELECT 1000000 + i FROM range(4096) tbl(i); +-- +ok +== +SELECT min(rowid), max(rowid), count(*) FROM rowid_gap_bulk_append.t WHERE i >= 1000000; +-- +ok +== +SELECT rowid, i FROM rowid_gap_bulk_append.t WHERE i IN (1000000, 1004095) ORDER BY i; +-- +ok +== diff --git a/parser/testdata/corpus/sql/storage/rowid_gaps/indexed_checkpoint_drop_row_group.test b/parser/testdata/corpus/sql/storage/rowid_gaps/indexed_checkpoint_drop_row_group.test new file mode 100644 index 0000000..8c7086d --- /dev/null +++ b/parser/testdata/corpus/sql/storage/rowid_gaps/indexed_checkpoint_drop_row_group.test @@ -0,0 +1,53 @@ +# source: test/sql/storage/rowid_gaps/indexed_checkpoint_drop_row_group.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +ATTACH '{TEST_DIR}/rowid_gap_vacuum_indexed.db' AS rowid_gap_vacuum_idx (STORAGE_VERSION 'latest', ROW_GROUP_SIZE 2048); +-- +ok +== +CREATE TABLE rowid_gap_vacuum_idx.t AS SELECT i FROM range(6144) tbl(i); +-- +ok +== +CHECKPOINT rowid_gap_vacuum_idx; +-- +ok +== +CREATE INDEX t_i_idx ON rowid_gap_vacuum_idx.t(i); +-- +ok +== +DELETE FROM rowid_gap_vacuum_idx.t WHERE i >= 2048 AND i < 4096; +-- +ok +== +DETACH rowid_gap_vacuum_idx; +-- +ok +== +ATTACH '{TEST_DIR}/rowid_gap_vacuum_indexed.db' AS rowid_gap_vacuum_idx; +-- +ok +== +SELECT min(rowid), max(rowid), count(*) FROM rowid_gap_vacuum_idx.t; +-- +ok +== +SELECT min(rowid), max(rowid), count(*) FROM rowid_gap_vacuum_idx.t WHERE i >= 4096; +-- +ok +== +SELECT COUNT(DISTINCT row_group_id) FROM pragma_storage_info('rowid_gap_vacuum_idx.t'); +-- +ok +== +SELECT count(*) FROM rowid_gap_vacuum_idx.t WHERE rowid >= 2048 AND rowid < 4096; +-- +ok +== +SELECT rowid, i FROM rowid_gap_vacuum_idx.t WHERE i = 4096; +-- +ok +== diff --git a/parser/testdata/corpus/sql/storage/rowid_gaps/indexed_dense_vacuum_merge.test b/parser/testdata/corpus/sql/storage/rowid_gaps/indexed_dense_vacuum_merge.test new file mode 100644 index 0000000..69ff671 --- /dev/null +++ b/parser/testdata/corpus/sql/storage/rowid_gaps/indexed_dense_vacuum_merge.test @@ -0,0 +1,49 @@ +# source: test/sql/storage/rowid_gaps/indexed_dense_vacuum_merge.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +ATTACH '{TEST_DIR}/rowid_gap_dense_vacuum_indexed.db' AS rowid_gap_dense_vacuum (ROW_GROUP_SIZE 4096); +-- +ok +== +CREATE TABLE rowid_gap_dense_vacuum.t(i INTEGER); +-- +ok +== +INSERT INTO rowid_gap_dense_vacuum.t SELECT i FROM range(1000) tbl(i); +-- +ok +== +CHECKPOINT rowid_gap_dense_vacuum; +-- +ok +== +INSERT INTO rowid_gap_dense_vacuum.t SELECT i FROM range(1000, 2000) tbl(i); +-- +ok +== +INSERT INTO rowid_gap_dense_vacuum.t SELECT i FROM range(2000, 3000) tbl(i); +-- +ok +== +SELECT COUNT(DISTINCT row_group_id) FROM pragma_storage_info('rowid_gap_dense_vacuum.t'); +-- +ok +== +CREATE INDEX t_i_idx ON rowid_gap_dense_vacuum.t(i); +-- +ok +== +FORCE CHECKPOINT rowid_gap_dense_vacuum; +-- +ok +== +SELECT i, rowid FROM rowid_gap_dense_vacuum.t WHERE i IN (0, 999, 1000, 1999, 2000, 2999) ORDER BY i; +-- +ok +== +EXPLAIN ANALYZE SELECT i, rowid FROM rowid_gap_dense_vacuum.t WHERE i = 2000; +-- +ok +== diff --git a/parser/testdata/corpus/sql/storage/rowid_gaps/indexed_geometry_legacy_no_remap.test b/parser/testdata/corpus/sql/storage/rowid_gaps/indexed_geometry_legacy_no_remap.test new file mode 100644 index 0000000..0b371db --- /dev/null +++ b/parser/testdata/corpus/sql/storage/rowid_gaps/indexed_geometry_legacy_no_remap.test @@ -0,0 +1,83 @@ +# source: test/sql/storage/rowid_gaps/indexed_geometry_legacy_no_remap.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +ATTACH '{TEST_DIR}/rowid_gap_geom_legacy.db' AS geom_legacy (STORAGE_VERSION 'v1.4.0', ROW_GROUP_SIZE 2048); +-- +ok +== +CREATE TABLE geom_legacy.t(i INTEGER, geom GEOMETRY); +-- +ok +== +INSERT INTO geom_legacy.t +SELECT i, ('POINT (' || i || ' ' || i || ')')::GEOMETRY FROM range(2048) tbl(i); +-- +ok +== +CHECKPOINT geom_legacy; +-- +ok +== +INSERT INTO geom_legacy.t +SELECT i, ('POINT (' || i || ' ' || i || ')')::GEOMETRY FROM range(2048, 3048) tbl(i); +-- +ok +== +CREATE UNIQUE INDEX t_i_idx ON geom_legacy.t(i); +-- +ok +== +CREATE INDEX t_geom_idx ON geom_legacy.t(geom); +-- +ok +== +DETACH geom_legacy; +-- +ok +== +ATTACH '{TEST_DIR}/rowid_gap_geom_legacy.db' AS geom_legacy (STORAGE_VERSION 'latest', ROW_GROUP_SIZE 2048); +-- +ok +== +SELECT rowid, i FROM geom_legacy.t WHERE geom = 'POINT (1500 1500)'::GEOMETRY; +-- +ok +== +DELETE FROM geom_legacy.t WHERE i >= 1048 AND i < 2048; +-- +ok +== +FORCE CHECKPOINT geom_legacy; +-- +ok +== +SELECT COUNT(DISTINCT row_group_id) FROM pragma_storage_info('geom_legacy.t'); +-- +ok +== +SELECT rowid, i FROM geom_legacy.t WHERE i IN (1023, 2548, 3047) ORDER BY i; +-- +ok +== +SELECT rowid, i FROM geom_legacy.t WHERE geom = 'POINT (2548 2548)'::GEOMETRY; +-- +ok +== +DROP INDEX geom_legacy.t_geom_idx; +-- +ok +== +EXPLAIN ANALYZE SELECT rowid, i FROM geom_legacy.t WHERE geom = 'POINT (2548 2548)'::GEOMETRY; +-- +ok +== +SELECT rowid, i FROM geom_legacy.t WHERE i = 2548; +-- +ok +== +ATTACH '{TEST_DIR}/rowid_gap_geom_legacy.db' AS geom_legacy; +-- +ok +== diff --git a/parser/testdata/corpus/sql/storage/rowid_gaps/indexed_geometry_vacuum_remap.test b/parser/testdata/corpus/sql/storage/rowid_gaps/indexed_geometry_vacuum_remap.test new file mode 100644 index 0000000..11b32ad --- /dev/null +++ b/parser/testdata/corpus/sql/storage/rowid_gaps/indexed_geometry_vacuum_remap.test @@ -0,0 +1,63 @@ +# source: test/sql/storage/rowid_gaps/indexed_geometry_vacuum_remap.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +ATTACH '{TEST_DIR}/rowid_gap_remap_geom.db' AS remap_geom (STORAGE_VERSION 'latest', ROW_GROUP_SIZE 2048); +-- +ok +== +CREATE TABLE remap_geom.t(i INTEGER, geom GEOMETRY); +-- +ok +== +INSERT INTO remap_geom.t +SELECT i, ('POINT (' || i || ' ' || i || ')')::GEOMETRY FROM range(2048) tbl(i); +-- +ok +== +CHECKPOINT remap_geom; +-- +ok +== +INSERT INTO remap_geom.t +SELECT i, ('POINT (' || i || ' ' || i || ')')::GEOMETRY FROM range(2048, 3048) tbl(i); +-- +ok +== +CREATE UNIQUE INDEX t_i_idx ON remap_geom.t(i); +-- +ok +== +CREATE INDEX t_geom_idx ON remap_geom.t(geom); +-- +ok +== +SELECT rowid, i FROM remap_geom.t WHERE geom = 'POINT (1500 1500)'::GEOMETRY; +-- +ok +== +SELECT rowid, i FROM remap_geom.t WHERE i = 2048; +-- +ok +== +DELETE FROM remap_geom.t WHERE i < 1000; +-- +ok +== +FORCE CHECKPOINT remap_geom; +-- +ok +== +SELECT COUNT(DISTINCT row_group_id) FROM pragma_storage_info('remap_geom.t'); +-- +ok +== +SELECT min(rowid), max(rowid), count(*) FROM remap_geom.t; +-- +ok +== +EXPLAIN ANALYZE SELECT rowid, i FROM remap_geom.t WHERE geom = 'POINT (1500 1500)'::GEOMETRY; +-- +ok +== diff --git a/parser/testdata/corpus/sql/storage/rowid_gaps/indexed_incremental_vacuum_remap.test b/parser/testdata/corpus/sql/storage/rowid_gaps/indexed_incremental_vacuum_remap.test new file mode 100644 index 0000000..829992a --- /dev/null +++ b/parser/testdata/corpus/sql/storage/rowid_gaps/indexed_incremental_vacuum_remap.test @@ -0,0 +1,91 @@ +# source: test/sql/storage/rowid_gaps/indexed_incremental_vacuum_remap.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +ATTACH '{TEST_DIR}/rowid_gap_incremental_remap.db' AS rowid_gap_remap (STORAGE_VERSION 'latest', ROW_GROUP_SIZE 2048); +-- +ok +== +CREATE TABLE rowid_gap_remap.t(i INTEGER, g INTEGER, n INTEGER); +-- +ok +== +INSERT INTO rowid_gap_remap.t +SELECT + i, + CASE WHEN i IN (1000, 1001) THEN 7 ELSE i + 10000 END, + CASE WHEN i BETWEEN 1000 AND 1010 THEN NULL ELSE i END +FROM range(2048) tbl(i); +-- +ok +== +CHECKPOINT rowid_gap_remap; +-- +ok +== +INSERT INTO rowid_gap_remap.t +SELECT i, i + 10000, i FROM range(2048, 3048) tbl(i); +-- +ok +== +CREATE UNIQUE INDEX t_i_idx ON rowid_gap_remap.t(i); +-- +ok +== +CREATE INDEX t_g_idx ON rowid_gap_remap.t(g); +-- +ok +== +CREATE INDEX t_n_idx ON rowid_gap_remap.t(n); +-- +ok +== +SELECT rowid, i FROM rowid_gap_remap.t WHERE i IN (1000, 1001, 2048, 3047) ORDER BY i; +-- +ok +== +DELETE FROM rowid_gap_remap.t WHERE i < 1000; +-- +ok +== +FORCE CHECKPOINT rowid_gap_remap; +-- +ok +== +SELECT COUNT(DISTINCT row_group_id) FROM pragma_storage_info('rowid_gap_remap.t'); +-- +ok +== +EXPLAIN ANALYZE SELECT rowid, i FROM rowid_gap_remap.t WHERE i = 2048; +-- +ok +== +EXPLAIN ANALYZE SELECT rowid, i FROM rowid_gap_remap.t WHERE g = 7; +-- +ok +== +SELECT rowid, i FROM rowid_gap_remap.t WHERE g = 7 ORDER BY i; +-- +ok +== +SELECT count(*) FROM rowid_gap_remap.t WHERE n IS NULL; +-- +ok +== +SELECT rowid, n FROM rowid_gap_remap.t WHERE n = 2048; +-- +ok +== +DETACH rowid_gap_remap; +-- +ok +== +ATTACH '{TEST_DIR}/rowid_gap_incremental_remap.db' AS rowid_gap_remap; +-- +ok +== +SELECT rowid, i FROM rowid_gap_remap.t WHERE i IN (1000, 3047) ORDER BY i; +-- +ok +== diff --git a/parser/testdata/corpus/sql/storage/rowid_gaps/indexed_live_vacuum_no_rebuild.test b/parser/testdata/corpus/sql/storage/rowid_gaps/indexed_live_vacuum_no_rebuild.test new file mode 100644 index 0000000..608af0a --- /dev/null +++ b/parser/testdata/corpus/sql/storage/rowid_gaps/indexed_live_vacuum_no_rebuild.test @@ -0,0 +1,82 @@ +# source: test/sql/storage/rowid_gaps/indexed_live_vacuum_no_rebuild.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +ATTACH '{TEST_DIR}/rowid_gap_live_vacuum_no_rebuild.db' AS rowid_gap_live_vacuum (STORAGE_VERSION 'v1.4.0'); +-- +ok +== +CREATE TABLE rowid_gap_live_vacuum.t AS +SELECT range::BIGINT AS i, (range * 2)::BIGINT AS j, (range * 3)::BIGINT AS k FROM range(368640); +-- +ok +== +CHECKPOINT rowid_gap_live_vacuum; +-- +ok +== +INSERT INTO rowid_gap_live_vacuum.t +SELECT 368640 + range, (368640 + range) * 2, (368640 + range) * 3 FROM range(40000); +-- +ok +== +INSERT INTO rowid_gap_live_vacuum.t +SELECT 408640 + range, (408640 + range) * 2, (408640 + range) * 3 FROM range(40000); +-- +ok +== +INSERT INTO rowid_gap_live_vacuum.t +SELECT 448640 + range, (448640 + range) * 2, (448640 + range) * 3 FROM range(40000); +-- +ok +== +CREATE INDEX t_i_idx ON rowid_gap_live_vacuum.t(i); +-- +ok +== +CREATE INDEX t_j_idx ON rowid_gap_live_vacuum.t(j); +-- +ok +== +CREATE INDEX t_k_idx ON rowid_gap_live_vacuum.t(k); +-- +ok +== +SELECT COUNT(DISTINCT row_group_id) FROM pragma_storage_info('rowid_gap_live_vacuum.t'); +-- +ok +== +SET profiling_coverage = 'ALL'; +-- +ok +== +SET tracked_metrics = ['storage.total_vacuum_time', 'storage.checkpoint_latency', 'query.total_time']; +-- +ok +== +PRAGMA profiling_output = '{TEST_DIR}/rowid_gap_live_vacuum_no_rebuild.json'; +-- +error: Parser Error: Profiler file type ({TEST_DIR}/rowid_gap_live_vacuum_no_rebuild.json) must either have the same file extension as the profiling output type (query_tree), or be a '.txt' file. Set "enable_profiling = 'json'" first. +== +FORCE CHECKPOINT rowid_gap_live_vacuum; +-- +ok +== +CREATE TABLE rowid_gap_live_vacuum.metrics AS +SELECT + storage.total_vacuum_time AS vacuum_time, + storage.checkpoint_latency AS checkpoint_latency, + query.total_time AS total_time +FROM '{TEST_DIR}/rowid_gap_live_vacuum_no_rebuild.json'; +-- +ok +== +SELECT CASE WHEN vacuum_time < 0.4 THEN 'ok' + ELSE 'vacuum_time=' || CAST(vacuum_time AS VARCHAR) || + ', checkpoint_latency=' || CAST(checkpoint_latency AS VARCHAR) || + ', total_time=' || CAST(total_time AS VARCHAR) END +FROM rowid_gap_live_vacuum.metrics; +-- +ok +== diff --git a/parser/testdata/corpus/sql/storage/rowid_gaps/indexed_live_vacuum_no_rebuild.test.metadata.json b/parser/testdata/corpus/sql/storage/rowid_gaps/indexed_live_vacuum_no_rebuild.test.metadata.json new file mode 100644 index 0000000..ed68d71 --- /dev/null +++ b/parser/testdata/corpus/sql/storage/rowid_gaps/indexed_live_vacuum_no_rebuild.test.metadata.json @@ -0,0 +1,5 @@ +{ + "todo": { + "b4ebde4c163973d5": "transformer-raised parser error: upstream rejects in the transformer, not the grammar; expected to clear as transformers land (milestones 3-5)" + } +} diff --git a/parser/testdata/corpus/sql/storage/rowid_gaps/indexed_old_storage_keeps_deleted_row_group.test b/parser/testdata/corpus/sql/storage/rowid_gaps/indexed_old_storage_keeps_deleted_row_group.test new file mode 100644 index 0000000..5f10602 --- /dev/null +++ b/parser/testdata/corpus/sql/storage/rowid_gaps/indexed_old_storage_keeps_deleted_row_group.test @@ -0,0 +1,58 @@ +# source: test/sql/storage/rowid_gaps/indexed_old_storage_keeps_deleted_row_group.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +ATTACH '{TEST_DIR}/rowid_gap_indexed_old_storage.db' AS rowid_gap_old_storage_idx (STORAGE_VERSION 'v1.5.0', ROW_GROUP_SIZE 2048); +-- +ok +== +CREATE TABLE rowid_gap_old_storage_idx.t AS SELECT i FROM range(6144) tbl(i); +-- +ok +== +CHECKPOINT rowid_gap_old_storage_idx; +-- +ok +== +CREATE INDEX t_i_idx ON rowid_gap_old_storage_idx.t(i); +-- +ok +== +DELETE FROM rowid_gap_old_storage_idx.t WHERE i >= 2048 AND i < 4096; +-- +ok +== +DETACH rowid_gap_old_storage_idx; +-- +ok +== +ATTACH '{TEST_DIR}/rowid_gap_indexed_old_storage.db' AS rowid_gap_old_storage_idx; +-- +ok +== +SELECT COUNT(DISTINCT row_group_id) FROM pragma_storage_info('rowid_gap_old_storage_idx.t'); +-- +ok +== +SELECT min(rowid), max(rowid), count(*) FROM rowid_gap_old_storage_idx.t; +-- +ok +== +SELECT count(*) FROM rowid_gap_old_storage_idx.t WHERE rowid >= 2048 AND rowid < 4096; +-- +ok +== +EXPLAIN ANALYZE SELECT rowid, i FROM rowid_gap_old_storage_idx.t WHERE i = 4096; +-- +ok +== +SELECT rowid, i FROM rowid_gap_old_storage_idx.t WHERE i = 4096; +-- +ok +== +SELECT CASE rowid WHEN 4096 THEN 'preserved' WHEN 2048 THEN 'dense-renumbered' ELSE CAST(rowid AS VARCHAR) END +FROM rowid_gap_old_storage_idx.t WHERE i = 4096; +-- +ok +== diff --git a/parser/testdata/corpus/sql/storage/rowid_gaps/indexed_rebuild_fallback_then_remap.test b/parser/testdata/corpus/sql/storage/rowid_gaps/indexed_rebuild_fallback_then_remap.test new file mode 100644 index 0000000..ee61c0c --- /dev/null +++ b/parser/testdata/corpus/sql/storage/rowid_gaps/indexed_rebuild_fallback_then_remap.test @@ -0,0 +1,78 @@ +# source: test/sql/storage/rowid_gaps/indexed_rebuild_fallback_then_remap.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +ATTACH '{TEST_DIR}/rowid_gap_rebuild_then_remap.db' AS rebuild_then_remap (STORAGE_VERSION 'v1.5.0', ROW_GROUP_SIZE 2048, vacuum_rebuild_indexes 100000); +-- +ok +== +CREATE TABLE rebuild_then_remap.t AS SELECT i FROM range(6144) tbl(i); +-- +ok +== +CHECKPOINT rebuild_then_remap; +-- +ok +== +CREATE INDEX t_i_idx ON rebuild_then_remap.t(i); +-- +ok +== +SELECT rowid, i FROM rebuild_then_remap.t WHERE i = 4096; +-- +ok +== +DELETE FROM rebuild_then_remap.t WHERE i >= 2048 AND i < 4096; +-- +ok +== +SELECT COUNT(DISTINCT row_group_id) FROM pragma_storage_info('rebuild_then_remap.t'); +-- +ok +== +SELECT CASE rowid WHEN 2048 THEN 'dense-renumbered' WHEN 4096 THEN 'preserved' ELSE CAST(rowid AS VARCHAR) END +FROM rebuild_then_remap.t WHERE i = 4096; +-- +ok +== +EXPLAIN ANALYZE SELECT rowid, i FROM rebuild_then_remap.t WHERE i = 4096; +-- +ok +== +DETACH rebuild_then_remap; +-- +ok +== +ATTACH '{TEST_DIR}/rowid_gap_rebuild_then_remap.db' AS rebuild_then_remap (STORAGE_VERSION 'latest'); +-- +ok +== +SELECT rowid, i FROM rebuild_then_remap.t WHERE i IN (0, 1023, 5120, 6143) ORDER BY i; +-- +ok +== +DELETE FROM rebuild_then_remap.t WHERE i >= 1024 AND i < 5120; +-- +ok +== +FORCE CHECKPOINT rebuild_then_remap; +-- +ok +== +EXPLAIN ANALYZE SELECT rowid, i FROM rebuild_then_remap.t WHERE i = 5120; +-- +ok +== +SELECT rowid, i FROM rebuild_then_remap.t WHERE i = 5120; +-- +ok +== +ATTACH '{TEST_DIR}/rowid_gap_rebuild_then_remap.db' AS rebuild_then_remap; +-- +ok +== +SELECT rowid, i FROM rebuild_then_remap.t WHERE i IN (1023, 5120, 6143) ORDER BY i; +-- +ok +== diff --git a/parser/testdata/corpus/sql/storage/rowid_gaps/indexed_remap_duplicate_key_across_tasks.test b/parser/testdata/corpus/sql/storage/rowid_gaps/indexed_remap_duplicate_key_across_tasks.test new file mode 100644 index 0000000..9654cad --- /dev/null +++ b/parser/testdata/corpus/sql/storage/rowid_gaps/indexed_remap_duplicate_key_across_tasks.test @@ -0,0 +1,63 @@ +# source: test/sql/storage/rowid_gaps/indexed_remap_duplicate_key_across_tasks.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +ATTACH '{TEST_DIR}/rowid_gap_remap_tasks.db' AS remap_tasks (STORAGE_VERSION 'latest', ROW_GROUP_SIZE 2048); +-- +ok +== +CREATE TABLE remap_tasks.t AS +SELECT i, CASE WHEN i IN (1, 3, 8193, 8195) THEN 7 ELSE i + 100000 END AS g +FROM range(16384) tbl(i); +-- +ok +== +CHECKPOINT remap_tasks; +-- +ok +== +CREATE UNIQUE INDEX t_i_idx ON remap_tasks.t(i); +-- +ok +== +CREATE INDEX t_g_idx ON remap_tasks.t(g); +-- +ok +== +SELECT rowid, i FROM remap_tasks.t WHERE g = 7 ORDER BY i; +-- +ok +== +DELETE FROM remap_tasks.t WHERE i % 4 = 0; +-- +ok +== +FORCE CHECKPOINT remap_tasks; +-- +ok +== +SELECT COUNT(DISTINCT row_group_id) FROM pragma_storage_info('remap_tasks.t'); +-- +ok +== +SELECT min(rowid), max(rowid), count(*) FROM remap_tasks.t; +-- +ok +== +SELECT count(*) FROM remap_tasks.t WHERE rowid >= 6144 AND rowid < 8192; +-- +ok +== +EXPLAIN ANALYZE SELECT rowid, i FROM remap_tasks.t WHERE g = 7; +-- +ok +== +SELECT rowid, i FROM remap_tasks.t WHERE i = 8195; +-- +ok +== +EXPLAIN ANALYZE SELECT rowid, i FROM remap_tasks.t WHERE i = 8195; +-- +ok +== diff --git a/parser/testdata/corpus/sql/storage/rowid_gaps/indexed_remap_merges_across_gap.test b/parser/testdata/corpus/sql/storage/rowid_gaps/indexed_remap_merges_across_gap.test new file mode 100644 index 0000000..fd57db9 --- /dev/null +++ b/parser/testdata/corpus/sql/storage/rowid_gaps/indexed_remap_merges_across_gap.test @@ -0,0 +1,61 @@ +# source: test/sql/storage/rowid_gaps/indexed_remap_merges_across_gap.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +ATTACH '{TEST_DIR}/rowid_gap_remap_across_gap.db' AS remap_across_gap (STORAGE_VERSION 'latest', ROW_GROUP_SIZE 4096); +-- +ok +== +CREATE TABLE remap_across_gap.t(i INTEGER); +-- +ok +== +INSERT INTO remap_across_gap.t SELECT i FROM range(1000) tbl(i); +-- +ok +== +CHECKPOINT remap_across_gap; +-- +ok +== +INSERT INTO remap_across_gap.t SELECT i FROM range(1000, 2000) tbl(i); +-- +ok +== +INSERT INTO remap_across_gap.t SELECT i FROM range(2000, 3000) tbl(i); +-- +ok +== +SELECT COUNT(DISTINCT row_group_id) FROM pragma_storage_info('remap_across_gap.t'); +-- +ok +== +CREATE INDEX t_i_idx ON remap_across_gap.t(i); +-- +ok +== +DELETE FROM remap_across_gap.t WHERE i >= 1000 AND i < 2000; +-- +ok +== +SELECT rowid, i FROM remap_across_gap.t WHERE i IN (999, 2000) ORDER BY i; +-- +ok +== +FORCE CHECKPOINT remap_across_gap; +-- +ok +== +SELECT min(rowid), max(rowid), count(*) FROM remap_across_gap.t; +-- +ok +== +SELECT count(*) FROM remap_across_gap.t WHERE rowid >= 1000 AND rowid < 2000; +-- +ok +== +EXPLAIN ANALYZE SELECT rowid, i FROM remap_across_gap.t WHERE i = 2000; +-- +ok +== diff --git a/parser/testdata/corpus/sql/storage/rowid_gaps/indexed_remap_partial_chunk.test b/parser/testdata/corpus/sql/storage/rowid_gaps/indexed_remap_partial_chunk.test new file mode 100644 index 0000000..faa8af3 --- /dev/null +++ b/parser/testdata/corpus/sql/storage/rowid_gaps/indexed_remap_partial_chunk.test @@ -0,0 +1,67 @@ +# source: test/sql/storage/rowid_gaps/indexed_remap_partial_chunk.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +ATTACH '{TEST_DIR}/rowid_gap_remap_partial.db' AS remap_partial (STORAGE_VERSION 'latest', ROW_GROUP_SIZE 2048); +-- +ok +== +CREATE TABLE remap_partial.t(i INTEGER, g INTEGER); +-- +ok +== +INSERT INTO remap_partial.t +SELECT i, CASE WHEN i IN (99, 2100) THEN 7 ELSE i + 10000 END FROM range(2048) tbl(i); +-- +ok +== +CHECKPOINT remap_partial; +-- +ok +== +INSERT INTO remap_partial.t +SELECT i, CASE WHEN i IN (99, 2100) THEN 7 ELSE i + 10000 END FROM range(2048, 2148) tbl(i); +-- +ok +== +CREATE UNIQUE INDEX t_i_idx ON remap_partial.t(i); +-- +ok +== +CREATE INDEX t_g_idx ON remap_partial.t(g); +-- +ok +== +SELECT rowid, i FROM remap_partial.t WHERE i IN (0, 99, 200, 2047, 2048, 2147) ORDER BY i; +-- +ok +== +SELECT rowid, i FROM remap_partial.t WHERE g = 7 ORDER BY i; +-- +ok +== +DELETE FROM remap_partial.t WHERE i >= 100 AND i < 200; +-- +ok +== +FORCE CHECKPOINT remap_partial; +-- +ok +== +SELECT COUNT(DISTINCT row_group_id) FROM pragma_storage_info('remap_partial.t'); +-- +ok +== +SELECT min(rowid), max(rowid), count(*) FROM remap_partial.t; +-- +ok +== +EXPLAIN ANALYZE SELECT rowid, i FROM remap_partial.t WHERE i = 200; +-- +ok +== +EXPLAIN ANALYZE SELECT rowid, i FROM remap_partial.t WHERE g = 7; +-- +ok +== diff --git a/parser/testdata/corpus/sql/storage/rowid_gaps/indexed_remap_same_key_rowid_collision.test b/parser/testdata/corpus/sql/storage/rowid_gaps/indexed_remap_same_key_rowid_collision.test new file mode 100644 index 0000000..231974a --- /dev/null +++ b/parser/testdata/corpus/sql/storage/rowid_gaps/indexed_remap_same_key_rowid_collision.test @@ -0,0 +1,63 @@ +# source: test/sql/storage/rowid_gaps/indexed_remap_same_key_rowid_collision.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +ATTACH '{TEST_DIR}/rowid_gap_remap_collision.db' AS remap_collision (STORAGE_VERSION 'latest', ROW_GROUP_SIZE 2048); +-- +ok +== +CREATE TABLE remap_collision.t AS +SELECT i, CASE WHEN i IN (2, 6143) THEN 9 ELSE 7 END AS g +FROM range(6144) tbl(i); +-- +ok +== +CHECKPOINT remap_collision; +-- +ok +== +CREATE UNIQUE INDEX t_i_idx ON remap_collision.t(i); +-- +ok +== +CREATE INDEX t_g_idx ON remap_collision.t(g); +-- +ok +== +SELECT rowid, i FROM remap_collision.t WHERE i IN (2, 5, 2045, 2048, 4094, 4096, 6143) ORDER BY i; +-- +ok +== +SELECT rowid, i FROM remap_collision.t WHERE g = 9 ORDER BY i; +-- +ok +== +DELETE FROM remap_collision.t WHERE i < 4096 AND i % 3 <> 2; +-- +ok +== +FORCE CHECKPOINT remap_collision; +-- +ok +== +SELECT COUNT(DISTINCT row_group_id) FROM pragma_storage_info('remap_collision.t'); +-- +ok +== +SELECT min(rowid), max(rowid), count(*) FROM remap_collision.t; +-- +ok +== +EXPLAIN ANALYZE SELECT rowid, i FROM remap_collision.t WHERE i = 4096; +-- +ok +== +EXPLAIN ANALYZE SELECT rowid, i FROM remap_collision.t WHERE g = 9; +-- +ok +== +SELECT count(*) FROM remap_collision.t WHERE g = 7; +-- +ok +== diff --git a/parser/testdata/corpus/sql/storage/rowid_gaps/indexes_geometry_legacy_no_merge_across_gap.test b/parser/testdata/corpus/sql/storage/rowid_gaps/indexes_geometry_legacy_no_merge_across_gap.test new file mode 100644 index 0000000..cc77417 --- /dev/null +++ b/parser/testdata/corpus/sql/storage/rowid_gaps/indexes_geometry_legacy_no_merge_across_gap.test @@ -0,0 +1,92 @@ +# source: test/sql/storage/rowid_gaps/indexes_geometry_legacy_no_merge_across_gap.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +ATTACH '{TEST_DIR}/rowid_gap_geom_no_merge.db' AS geom_no_merge (STORAGE_VERSION 'v1.4.0', ROW_GROUP_SIZE 4096); +-- +ok +== +CREATE TABLE geom_no_merge.t(i INTEGER, geom GEOMETRY); +-- +ok +== +INSERT INTO geom_no_merge.t +SELECT i, ('POINT (' || i || ' ' || i || ')')::GEOMETRY FROM range(1000) tbl(i); +-- +ok +== +CHECKPOINT geom_no_merge; +-- +ok +== +INSERT INTO geom_no_merge.t +SELECT i, ('POINT (' || i || ' ' || i || ')')::GEOMETRY FROM range(1000, 2000) tbl(i); +-- +ok +== +INSERT INTO geom_no_merge.t +SELECT i, ('POINT (' || i || ' ' || i || ')')::GEOMETRY FROM range(2000, 3000) tbl(i); +-- +ok +== +SELECT COUNT(DISTINCT row_group_id) FROM pragma_storage_info('geom_no_merge.t'); +-- +ok +== +CREATE INDEX t_i_idx ON geom_no_merge.t(i); +-- +ok +== +CREATE INDEX t_geom_idx ON geom_no_merge.t(geom); +-- +ok +== +DETACH geom_no_merge; +-- +ok +== +ATTACH '{TEST_DIR}/rowid_gap_geom_no_merge.db' AS geom_no_merge (STORAGE_VERSION 'latest'); +-- +ok +== +SELECT rowid, i FROM geom_no_merge.t WHERE geom = 'POINT (1500 1500)'::GEOMETRY; +-- +ok +== +DELETE FROM geom_no_merge.t WHERE i >= 1000 AND i < 2000; +-- +ok +== +FORCE CHECKPOINT geom_no_merge; +-- +ok +== +SELECT min(rowid), max(rowid), count(*) FROM geom_no_merge.t; +-- +ok +== +SELECT count(*) FROM geom_no_merge.t WHERE rowid >= 1000 AND rowid < 2000; +-- +ok +== +SELECT rowid, i FROM geom_no_merge.t WHERE i IN (999, 2000) ORDER BY i; +-- +ok +== +EXPLAIN ANALYZE SELECT rowid, i FROM geom_no_merge.t WHERE i = 2000; +-- +ok +== +SELECT rowid, i FROM geom_no_merge.t WHERE i = 2000; +-- +ok +== +SELECT rowid, i FROM geom_no_merge.t WHERE geom = 'POINT (2000 2000)'::GEOMETRY; +-- +ok +== +ATTACH '{TEST_DIR}/rowid_gap_geom_no_merge.db' AS geom_no_merge; +-- +ok +== diff --git a/parser/testdata/corpus/sql/storage/rowid_gaps/leading_gap_lookup.test b/parser/testdata/corpus/sql/storage/rowid_gaps/leading_gap_lookup.test new file mode 100644 index 0000000..72970a0 --- /dev/null +++ b/parser/testdata/corpus/sql/storage/rowid_gaps/leading_gap_lookup.test @@ -0,0 +1,101 @@ +# source: test/sql/storage/rowid_gaps/leading_gap_lookup.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +ATTACH '{TEST_DIR}/rowid_gap_lookup.db' AS rowid_gap_lookup_db (STORAGE_VERSION 'latest'); +-- +ok +== +CREATE TABLE rowid_gap_lookup_db.leading AS SELECT i FROM range(245760) tbl(i); +-- +ok +== +DELETE FROM rowid_gap_lookup_db.leading WHERE rowid < 122880; +-- +ok +== +CHECKPOINT rowid_gap_lookup_db; +-- +ok +== +SELECT min(rowid), count(*) FROM rowid_gap_lookup_db.leading; +-- +ok +== +SELECT count(*) FROM rowid_gap_lookup_db.leading WHERE rowid = 0; +-- +ok +== +SELECT count(*) FROM rowid_gap_lookup_db.leading WHERE rowid BETWEEN 0 AND 10; +-- +ok +== +SELECT count(*) FROM rowid_gap_lookup_db.leading WHERE rowid = 122879; +-- +ok +== +SELECT rowid, i FROM rowid_gap_lookup_db.leading WHERE rowid IN (122879, 122880) ORDER BY rowid; +-- +ok +== +SELECT i FROM rowid_gap_lookup_db.leading WHERE rowid IN (0, 122880) ORDER BY rowid; +-- +ok +== +UPDATE rowid_gap_lookup_db.leading SET i = i WHERE rowid = 0; +-- +ok +== +DELETE FROM rowid_gap_lookup_db.leading WHERE rowid = 0; +-- +ok +== +SELECT count(*) FROM rowid_gap_lookup_db.leading; +-- +ok +== +CREATE TABLE rowid_gap_lookup_db.middle AS SELECT i FROM range(368640) tbl(i); +-- +ok +== +DELETE FROM rowid_gap_lookup_db.middle WHERE rowid >= 122880 AND rowid < 245760; +-- +ok +== +SELECT min(rowid), max(rowid), count(*) FROM rowid_gap_lookup_db.middle; +-- +ok +== +SELECT count(*) FROM rowid_gap_lookup_db.middle WHERE rowid = 122880; +-- +ok +== +SELECT count(*) FROM rowid_gap_lookup_db.middle WHERE rowid BETWEEN 122880 AND 122890; +-- +ok +== +SELECT count(*) FROM rowid_gap_lookup_db.middle WHERE rowid = 245759; +-- +ok +== +SELECT rowid, i FROM rowid_gap_lookup_db.middle WHERE rowid = 245760; +-- +ok +== +SELECT rowid, i FROM rowid_gap_lookup_db.middle WHERE rowid IN (245759, 245760) ORDER BY rowid; +-- +ok +== +SELECT rowid, i FROM rowid_gap_lookup_db.middle WHERE rowid IN (42, 122880, 245760, 368640) ORDER BY rowid; +-- +ok +== +SELECT rowid, i FROM rowid_gap_lookup_db.middle WHERE rowid IN (368639, 368640) ORDER BY rowid; +-- +ok +== +SELECT count(*) FROM rowid_gap_lookup_db.middle WHERE rowid >= 368640; +-- +ok +== diff --git a/parser/testdata/corpus/sql/storage/rowid_gaps/old_storage_dense_rewrite.test b/parser/testdata/corpus/sql/storage/rowid_gaps/old_storage_dense_rewrite.test new file mode 100644 index 0000000..9737bcb --- /dev/null +++ b/parser/testdata/corpus/sql/storage/rowid_gaps/old_storage_dense_rewrite.test @@ -0,0 +1,45 @@ +# source: test/sql/storage/rowid_gaps/old_storage_dense_rewrite.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +ATTACH '{TEST_DIR}/rowid_gap_old_storage_dense.db' AS rowid_gap_old_storage_dense (STORAGE_VERSION 'v1.5.0', ROW_GROUP_SIZE 2048); +-- +ok +== +CREATE TABLE rowid_gap_old_storage_dense.t AS SELECT i FROM range(6144) tbl(i); +-- +ok +== +CHECKPOINT rowid_gap_old_storage_dense; +-- +ok +== +DELETE FROM rowid_gap_old_storage_dense.t WHERE i >= 2048 AND i < 4096; +-- +ok +== +DETACH rowid_gap_old_storage_dense; +-- +ok +== +ATTACH '{TEST_DIR}/rowid_gap_old_storage_dense.db' AS rowid_gap_old_storage_dense; +-- +ok +== +SELECT COUNT(DISTINCT row_group_id) FROM pragma_storage_info('rowid_gap_old_storage_dense.t'); +-- +ok +== +SELECT min(rowid), max(rowid), count(*) FROM rowid_gap_old_storage_dense.t; +-- +ok +== +SELECT rowid, i FROM rowid_gap_old_storage_dense.t WHERE i = 4096; +-- +ok +== +SELECT count(*) FROM rowid_gap_old_storage_dense.t WHERE rowid >= 4096; +-- +ok +== diff --git a/parser/testdata/corpus/sql/storage/rowid_gaps/wal_replay_after_gap_checkpoint.test b/parser/testdata/corpus/sql/storage/rowid_gaps/wal_replay_after_gap_checkpoint.test new file mode 100644 index 0000000..cfd05c5 --- /dev/null +++ b/parser/testdata/corpus/sql/storage/rowid_gaps/wal_replay_after_gap_checkpoint.test @@ -0,0 +1,29 @@ +# source: test/sql/storage/rowid_gaps/wal_replay_after_gap_checkpoint.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +CREATE TABLE t AS SELECT i FROM range(368640) tbl(i); +-- +ok +== +CREATE UNIQUE INDEX idx_i ON t(i); +-- +ok +== +DELETE FROM t WHERE i >= 122880 AND i < 245760; +-- +ok +== +SELECT min(rowid), max(rowid), count(*) FROM t; +-- +ok +== +INSERT INTO t VALUES (999999); +-- +ok +== +SELECT rowid, i FROM t WHERE i = 999999; +-- +ok +== diff --git a/parser/testdata/corpus/sql/storage/shutdown_create_index.test b/parser/testdata/corpus/sql/storage/shutdown_create_index.test new file mode 100644 index 0000000..188c09e --- /dev/null +++ b/parser/testdata/corpus/sql/storage/shutdown_create_index.test @@ -0,0 +1,37 @@ +# source: test/sql/storage/shutdown_create_index.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +INSERT INTO test VALUES (11, 22), (13, 22); +-- +ok +== +CREATE INDEX i_index ON test using art(a) +-- +ok +== +INSERT INTO test VALUES (11, 24) +-- +ok +== +SELECT a, b FROM test WHERE a=11 ORDER BY b +-- +ok +== +SELECT a, b FROM test WHERE a>11 ORDER BY b +-- +ok +== +DELETE FROM test WHERE a=11 AND b=24 +-- +ok +== +DELETE FROM test WHERE a=11 AND b=22 +-- +ok +== +UPDATE test SET b=22 WHERE a=11 +-- +ok +== diff --git a/parser/testdata/corpus/sql/storage/shutdown_running_transaction.test b/parser/testdata/corpus/sql/storage/shutdown_running_transaction.test new file mode 100644 index 0000000..bd9f8f9 --- /dev/null +++ b/parser/testdata/corpus/sql/storage/shutdown_running_transaction.test @@ -0,0 +1,9 @@ +# source: test/sql/storage/shutdown_running_transaction.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +INSERT INTO test VALUES (22, 23); +-- +ok +== diff --git a/parser/testdata/corpus/sql/storage/shutdown_unique_index.test b/parser/testdata/corpus/sql/storage/shutdown_unique_index.test new file mode 100644 index 0000000..0581194 --- /dev/null +++ b/parser/testdata/corpus/sql/storage/shutdown_unique_index.test @@ -0,0 +1,13 @@ +# source: test/sql/storage/shutdown_unique_index.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +INSERT INTO test VALUES (12, 24) +-- +ok +== +SELECT * FROM test WHERE a=12 +-- +ok +== diff --git a/parser/testdata/corpus/sql/storage/storage_exceeds_block_large_string.test b/parser/testdata/corpus/sql/storage/storage_exceeds_block_large_string.test new file mode 100644 index 0000000..9216eea --- /dev/null +++ b/parser/testdata/corpus/sql/storage/storage_exceeds_block_large_string.test @@ -0,0 +1,29 @@ +# source: test/sql/storage/storage_exceeds_block_large_string.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +SET force_compression='uncompressed' +-- +ok +== +CREATE TABLE test (a VARCHAR, j BIGINT); +-- +ok +== +INSERT INTO test VALUES (repeat('a', 64), 1) +-- +ok +== +INSERT INTO test SELECT a||a||a||a||a||a||a||a||a||a, {i} FROM test +-- +error: Parser Error: syntax error at or near "}" +== +DELETE FROM test WHERE j={i} - 1 +-- +error: Parser Error: syntax error at or near "}" +== +SELECT LENGTH(a) FROM test +-- +ok +== diff --git a/parser/testdata/corpus/sql/storage/storage_exceeds_single_block.test b/parser/testdata/corpus/sql/storage/storage_exceeds_single_block.test new file mode 100644 index 0000000..e8a1456 --- /dev/null +++ b/parser/testdata/corpus/sql/storage/storage_exceeds_single_block.test @@ -0,0 +1,17 @@ +# source: test/sql/storage/storage_exceeds_single_block.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +INSERT INTO test VALUES (11, 22), (13, 22), (12, 21), (NULL, NULL) +-- +ok +== +INSERT INTO test FROM test +-- +ok +== +SELECT SUM(a) + SUM(b) FROM test +-- +ok +== diff --git a/parser/testdata/corpus/sql/storage/storage_exceeds_single_block_strings.test b/parser/testdata/corpus/sql/storage/storage_exceeds_single_block_strings.test new file mode 100644 index 0000000..77e39ae --- /dev/null +++ b/parser/testdata/corpus/sql/storage/storage_exceeds_single_block_strings.test @@ -0,0 +1,21 @@ +# source: test/sql/storage/storage_exceeds_single_block_strings.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +INSERT INTO test VALUES ('a'), ('bb'), ('ccc'), ('dddd'), ('eeeee') +-- +ok +== +SELECT a, COUNT(*) FROM test GROUP BY a ORDER BY a +-- +ok +== +SELECT count(a) FROM test WHERE a='a' +-- +ok +== +UPDATE test SET a='aaa' WHERE a='a' +-- +ok +== diff --git a/parser/testdata/corpus/sql/storage/storage_exceeds_single_block_types.test b/parser/testdata/corpus/sql/storage/storage_exceeds_single_block_types.test new file mode 100644 index 0000000..c6b04cf --- /dev/null +++ b/parser/testdata/corpus/sql/storage/storage_exceeds_single_block_types.test @@ -0,0 +1,9 @@ +# source: test/sql/storage/storage_exceeds_single_block_types.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +CREATE TABLE test (a INTEGER, b BIGINT); +-- +ok +== diff --git a/parser/testdata/corpus/sql/storage/storage_types.test b/parser/testdata/corpus/sql/storage/storage_types.test new file mode 100644 index 0000000..bcb7344 --- /dev/null +++ b/parser/testdata/corpus/sql/storage/storage_types.test @@ -0,0 +1,41 @@ +# source: test/sql/storage/storage_types.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +CREATE TABLE a_{type} AS SELECT range::{type} i FROM range(100) +-- +error: Parser Error: syntax error at or near "{" +== +SELECT MIN(i), MAX(i), COUNT(*), COUNT(i) FROM a_{type} +-- +error: Parser Error: syntax error at or near "{" +== +SELECT MIN(i), MAX(i), COUNT(*), COUNT(i) FROM a_{type} WHERE i = 1 +-- +error: Parser Error: syntax error at or near "{" +== +CREATE TABLE a_interval AS SELECT interval (range) year i FROM range(1,1001) +-- +ok +== +SELECT MIN(i), MAX(i), COUNT(*), COUNT(i) FROM a_interval +-- +ok +== +SELECT MIN(i), MAX(i), COUNT(*), COUNT(i) FROM a_interval WHERE i = interval 1 year +-- +ok +== +CREATE TABLE a_bool AS SELECT range % 2 = 0 AS i FROM range(1000) +-- +ok +== +SELECT MIN(i), MAX(i), COUNT(*), COUNT(i) FROM a_bool +-- +ok +== +SELECT MIN(i), MAX(i), COUNT(*), COUNT(i) FROM a_bool WHERE NOT i +-- +ok +== diff --git a/parser/testdata/corpus/sql/storage/storage_version_65.test b/parser/testdata/corpus/sql/storage/storage_version_65.test new file mode 100644 index 0000000..4b3f4ec --- /dev/null +++ b/parser/testdata/corpus/sql/storage/storage_version_65.test @@ -0,0 +1,37 @@ +# source: test/sql/storage/storage_version_65.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +ATTACH '{TEST_DIR}/storage_versions65.db' +-- +ok +== +SELECT tags FROM duckdb_databases() WHERE database_name = 'storage_versions65'; +-- +ok +== +ATTACH '{TEST_DIR}/regular_file.db' +-- +ok +== +SELECT tags FROM duckdb_databases() WHERE database_name = 'regular_file'; +-- +ok +== +ATTACH '{TEST_DIR}/bc_0102.db.gz' AS storage_version64; +-- +ok +== +SELECT tags FROM duckdb_databases() WHERE database_name = 'storage_version64'; +-- +ok +== +ATTACH '{TEST_DIR}/storage_versions66.db' +-- +ok +== +SELECT tags FROM duckdb_databases() WHERE database_name = 'storage_versions66'; +-- +ok +== diff --git a/parser/testdata/corpus/sql/storage/storage_versions.test b/parser/testdata/corpus/sql/storage/storage_versions.test new file mode 100644 index 0000000..99c93b2 --- /dev/null +++ b/parser/testdata/corpus/sql/storage/storage_versions.test @@ -0,0 +1,29 @@ +# source: test/sql/storage/storage_versions.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +ATTACH '{DATA_DIR}/storage/empty64.db' (READ_ONLY); +-- +ok +== +ATTACH '{DATA_DIR}/storage/empty65.db' (READ_ONLY); +-- +ok +== +ATTACH '{DATA_DIR}/storage/empty66.db' (READ_ONLY); +-- +ok +== +SELECT tags FROM duckdb_databases() WHERE database_name LIKE 'empty%' ORDER BY database_name; +-- +ok +== +ATTACH '{TEST_DIR}/my1.duckdb' as v1_0_0 (storage_version 'v1.0.0'); +-- +ok +== +SELECT tags.storage_version FROM duckdb_databases() WHERE database_name LIKE 'v%'; +-- +ok +== diff --git a/parser/testdata/corpus/sql/storage/store_group_order_all.test b/parser/testdata/corpus/sql/storage/store_group_order_all.test new file mode 100644 index 0000000..723d4d1 --- /dev/null +++ b/parser/testdata/corpus/sql/storage/store_group_order_all.test @@ -0,0 +1,40 @@ +# source: test/sql/storage/store_group_order_all.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +CREATE TABLE integers( + g integer, + i integer +); +-- +ok +== +INSERT INTO integers values + (0, 1), + (0, 2), + (1, 3), + (1, NULL); +-- +ok +== +CREATE VIEW v1 AS SELECT + g, + i, + g%2, + SUM(i), + SUM(g) +FROM integers GROUP BY ALL ORDER BY ALL; +-- +ok +== +CREATE VIEW v2 AS SELECT + g, + i, + g%2, + SUM(i), + SUM(g) +FROM integers GROUP BY ALL ORDER BY ALL DESC NULLS LAST; +-- +ok +== diff --git a/parser/testdata/corpus/sql/storage/temp_directory/max_swap_space_error.test b/parser/testdata/corpus/sql/storage/temp_directory/max_swap_space_error.test new file mode 100644 index 0000000..b12c932 --- /dev/null +++ b/parser/testdata/corpus/sql/storage/temp_directory/max_swap_space_error.test @@ -0,0 +1,61 @@ +# source: test/sql/storage/temp_directory/max_swap_space_error.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +set temp_directory='{TEST_DIR}/max_swap_space_reached' +-- +ok +== +PRAGMA memory_limit='4MB' +-- +ok +== +set max_temp_directory_size='0KiB' +-- +ok +== +CREATE OR REPLACE TABLE t2 AS SELECT random() FROM range(1000000); +-- +ok +== +select "size" from duckdb_temporary_files() +-- +ok +== +set max_temp_directory_size='256KiB' +-- +ok +== +set max_temp_directory_size='4MB' +-- +ok +== +pragma threads=2; +-- +ok +== +set preserve_insertion_order=true; +-- +ok +== +CREATE OR REPLACE TABLE t2 AS SELECT random() FROM range(200000); +-- +ok +== +CREATE OR REPLACE TABLE t2 AS SELECT * FROM range(1000000); +-- +ok +== +SELECT CASE WHEN sum("size") > 1000000 THEN true ELSE CONCAT('Expected size 1000000, but got ', sum("size"))::UNION(msg VARCHAR, b BOOLEAN) END FROM duckdb_temporary_files(); +-- +ok +== +select current_setting('max_temp_directory_size') +-- +ok +== +set max_temp_directory_size='2550KiB' +-- +ok +== diff --git a/parser/testdata/corpus/sql/storage/temp_directory/max_swap_space_explicit.test b/parser/testdata/corpus/sql/storage/temp_directory/max_swap_space_explicit.test new file mode 100644 index 0000000..0573ed4 --- /dev/null +++ b/parser/testdata/corpus/sql/storage/temp_directory/max_swap_space_explicit.test @@ -0,0 +1,13 @@ +# source: test/sql/storage/temp_directory/max_swap_space_explicit.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +set max_temp_directory_size='15gb' +-- +ok +== +set temp_directory = '{TEST_DIR}/this_directory_should_not_exist__swap_space' +-- +ok +== diff --git a/parser/testdata/corpus/sql/storage/temp_directory/max_swap_space_inmemory.test b/parser/testdata/corpus/sql/storage/temp_directory/max_swap_space_inmemory.test new file mode 100644 index 0000000..ed7e522 --- /dev/null +++ b/parser/testdata/corpus/sql/storage/temp_directory/max_swap_space_inmemory.test @@ -0,0 +1,41 @@ +# source: test/sql/storage/temp_directory/max_swap_space_inmemory.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +set temp_directory=''; +-- +ok +== +PRAGMA memory_limit='3MB' +-- +ok +== +select current_setting('max_temp_directory_size') a where a == '0 bytes' +-- +ok +== +reset max_temp_directory_size; +-- +ok +== +set temp_directory = '{TEST_DIR}'; +-- +ok +== +set temp_directory = '{TEST_DIR}/does_not_exist3' +-- +ok +== +set temp_directory = '{TEST_DIR}' +-- +ok +== +reset temp_directory; +-- +ok +== +set temp_directory = '{TEST_DIR}/does_not_exist4' +-- +ok +== diff --git a/parser/testdata/corpus/sql/storage/temp_directory/max_swap_space_persistent.test b/parser/testdata/corpus/sql/storage/temp_directory/max_swap_space_persistent.test new file mode 100644 index 0000000..eb18080 --- /dev/null +++ b/parser/testdata/corpus/sql/storage/temp_directory/max_swap_space_persistent.test @@ -0,0 +1,45 @@ +# source: test/sql/storage/temp_directory/max_swap_space_persistent.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +SELECT current_setting('temp_directory').split('/')[-1]; +-- +ok +== +PRAGMA memory_limit='3MiB'; +-- +ok +== +SELECT current_setting('max_temp_directory_size'); +-- +ok +== +SET max_temp_directory_size='15GB'; +-- +ok +== +SELECT current_setting('max_temp_directory_size') a WHERE a == '0 bytes'; +-- +ok +== +RESET max_temp_directory_size; +-- +ok +== +SET temp_directory = '{TEST_DIR}'; +-- +ok +== +SET temp_directory = '{TEST_DIR}/does_not_exist5'; +-- +ok +== +SET temp_directory = '{TEST_DIR}/does_not_exist6'; +-- +ok +== +SELECT current_setting('max_temp_directory_size') a where a == '0 bytes'; +-- +ok +== diff --git a/parser/testdata/corpus/sql/storage/temp_directory/max_swap_space_unlimited.test b/parser/testdata/corpus/sql/storage/temp_directory/max_swap_space_unlimited.test new file mode 100644 index 0000000..984c658 --- /dev/null +++ b/parser/testdata/corpus/sql/storage/temp_directory/max_swap_space_unlimited.test @@ -0,0 +1,9 @@ +# source: test/sql/storage/temp_directory/max_swap_space_unlimited.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +PRAGMA max_temp_directory_size='-1'; +-- +ok +== diff --git a/parser/testdata/corpus/sql/storage/temp_directory/temp_directory_null.test b/parser/testdata/corpus/sql/storage/temp_directory/temp_directory_null.test new file mode 100644 index 0000000..c5df652 --- /dev/null +++ b/parser/testdata/corpus/sql/storage/temp_directory/temp_directory_null.test @@ -0,0 +1,17 @@ +# source: test/sql/storage/temp_directory/temp_directory_null.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +set temp_directory='' +-- +ok +== +select value from duckdb_settings() where name = 'temp_directory' +-- +ok +== +set temp_directory=null +-- +ok +== diff --git a/parser/testdata/corpus/sql/storage/temp_directory/test_default_temp_directory.test b/parser/testdata/corpus/sql/storage/temp_directory/test_default_temp_directory.test new file mode 100644 index 0000000..f8e72b8 --- /dev/null +++ b/parser/testdata/corpus/sql/storage/temp_directory/test_default_temp_directory.test @@ -0,0 +1,9 @@ +# source: test/sql/storage/temp_directory/test_default_temp_directory.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +CREATE TEMPORARY TABLE t AS FROM range(1_000_000); +-- +ok +== diff --git a/parser/testdata/corpus/sql/storage/test_empty_table.test b/parser/testdata/corpus/sql/storage/test_empty_table.test new file mode 100644 index 0000000..5071fd6 --- /dev/null +++ b/parser/testdata/corpus/sql/storage/test_empty_table.test @@ -0,0 +1,9 @@ +# source: test/sql/storage/test_empty_table.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +CREATE TABLE test (a INTEGER, b VARCHAR) +-- +ok +== diff --git a/parser/testdata/corpus/sql/storage/test_eviction_queue_dead_nodes_underflow.test b/parser/testdata/corpus/sql/storage/test_eviction_queue_dead_nodes_underflow.test new file mode 100644 index 0000000..50239bc --- /dev/null +++ b/parser/testdata/corpus/sql/storage/test_eviction_queue_dead_nodes_underflow.test @@ -0,0 +1,12 @@ +# source: test/sql/storage/test_eviction_queue_dead_nodes_underflow.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +SELECT COUNT(*) = 0 +FROM duckdb_eviction_queues() +WHERE dead_nodes < 0 + OR dead_nodes > total_insertions; +-- +ok +== diff --git a/parser/testdata/corpus/sql/storage/test_ignore_duplicate_deletes_unique_index.test b/parser/testdata/corpus/sql/storage/test_ignore_duplicate_deletes_unique_index.test new file mode 100644 index 0000000..3ec838e --- /dev/null +++ b/parser/testdata/corpus/sql/storage/test_ignore_duplicate_deletes_unique_index.test @@ -0,0 +1,25 @@ +# source: test/sql/storage/test_ignore_duplicate_deletes_unique_index.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +CREATE TABLE TBL (id INT NOT NULL, age INT NOT NULL, PRIMARY KEY ( id )) +-- +ok +== +INSERT INTO TBL VALUES (1, 1); +-- +ok +== +DELETE FROM TBL WHERE id = 1; +-- +ok +== +SELECT * FROM TBL +-- +ok +== +SELECT * FROM TBL WHERE id=1 +-- +ok +== diff --git a/parser/testdata/corpus/sql/storage/test_index_checkpoint.test b/parser/testdata/corpus/sql/storage/test_index_checkpoint.test new file mode 100644 index 0000000..308a952 --- /dev/null +++ b/parser/testdata/corpus/sql/storage/test_index_checkpoint.test @@ -0,0 +1,21 @@ +# source: test/sql/storage/test_index_checkpoint.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +CREATE TABLE t2 (i INTEGER, uid VARCHAR); +-- +ok +== +INSERT INTO t2 SELECT i.range AS i, gen_random_uuid() AS uid FROM range(50000) AS i; +-- +ok +== +CREATE UNIQUE INDEX iu ON t2(uid); +-- +ok +== +SELECT total_blocks < 6291456 / get_block_size('index_checkpoint') * 1.2 FROM pragma_database_size(); +-- +ok +== diff --git a/parser/testdata/corpus/sql/storage/test_large_commits.test b/parser/testdata/corpus/sql/storage/test_large_commits.test new file mode 100644 index 0000000..c3cf51f --- /dev/null +++ b/parser/testdata/corpus/sql/storage/test_large_commits.test @@ -0,0 +1,21 @@ +# source: test/sql/storage/test_large_commits.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +PRAGMA wal_autocheckpoint='10KB' +-- +ok +== +CREATE TABLE test(i INTEGER); +-- +ok +== +INSERT INTO test SELECT * FROM range(100000) tbl(i) +-- +ok +== +SELECT MIN(i), MAX(i), COUNT(*) FROM test +-- +ok +== diff --git a/parser/testdata/corpus/sql/storage/test_read_only_wal_replay.test b/parser/testdata/corpus/sql/storage/test_read_only_wal_replay.test new file mode 100644 index 0000000..c659eaf --- /dev/null +++ b/parser/testdata/corpus/sql/storage/test_read_only_wal_replay.test @@ -0,0 +1,117 @@ +# source: test/sql/storage/test_read_only_wal_replay.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +SET checkpoint_threshold='1TB'; +-- +ok +== +ATTACH '{TEST_DIR}/read_only_wal_replay.db' AS db; +-- +ok +== +CREATE TABLE db.my_tbl(i INTEGER PRIMARY KEY); +-- +ok +== +INSERT INTO db.my_tbl FROM range(200_000); +-- +ok +== +ATTACH '{TEST_DIR}/read_only_wal_replay.db' AS db (READ_ONLY) +-- +ok +== +DETACH db +-- +ok +== +ATTACH '{TEST_DIR}/read_only_wal_replay_index.db' AS db; +-- +ok +== +CREATE TABLE db.index_tbl(id INTEGER PRIMARY KEY, grp INTEGER); +-- +ok +== +INSERT INTO db.index_tbl VALUES (1, 10), (2, 20), (3, 10); +-- +ok +== +CREATE INDEX idx_grp ON db.index_tbl(grp); +-- +ok +== +ATTACH '{TEST_DIR}/read_only_wal_replay_index.db' AS db (READ_ONLY); +-- +ok +== +SELECT count(*) FROM db.index_tbl; +-- +ok +== +SELECT id FROM db.index_tbl WHERE grp = 10 ORDER BY id; +-- +ok +== +ATTACH '{TEST_DIR}/read_only_wal_replay_create_index_add_column.db' AS db; +-- +ok +== +CREATE TABLE db.tbl(i INTEGER); +-- +ok +== +INSERT INTO db.tbl VALUES (1), (2); +-- +ok +== +CREATE INDEX idx ON db.tbl(i); +-- +ok +== +ALTER TABLE db.tbl ADD COLUMN j INTEGER DEFAULT 42; +-- +ok +== +ATTACH '{TEST_DIR}/read_only_wal_replay_create_index_add_column.db' AS db (READ_ONLY); +-- +ok +== +SET index_scan_percentage=1; +-- +ok +== +SET index_scan_max_count=999999999; +-- +ok +== +SELECT i, j FROM db.tbl WHERE i = 2; +-- +ok +== +ATTACH '{TEST_DIR}/read_only_wal_replay_alter_primary_key.db' AS db; +-- +ok +== +CREATE TABLE db.pk_tbl(i INTEGER); +-- +ok +== +INSERT INTO db.pk_tbl VALUES (1), (2); +-- +ok +== +ALTER TABLE db.pk_tbl ADD PRIMARY KEY(i); +-- +ok +== +ATTACH '{TEST_DIR}/read_only_wal_replay_alter_primary_key.db' AS db (READ_ONLY); +-- +ok +== +SELECT i FROM db.pk_tbl WHERE i = 2; +-- +ok +== diff --git a/parser/testdata/corpus/sql/storage/test_restart_extension.test b/parser/testdata/corpus/sql/storage/test_restart_extension.test new file mode 100644 index 0000000..05b13c7 --- /dev/null +++ b/parser/testdata/corpus/sql/storage/test_restart_extension.test @@ -0,0 +1,9 @@ +# source: test/sql/storage/test_restart_extension.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +CREATE TABLE t1 AS SELECT * FROM parquet_scan('{DATA_DIR}/parquet-testing/arrow/alltypes_plain.parquet') +-- +ok +== diff --git a/parser/testdata/corpus/sql/storage/test_show_tables_persistent.test b/parser/testdata/corpus/sql/storage/test_show_tables_persistent.test new file mode 100644 index 0000000..53ed0fb --- /dev/null +++ b/parser/testdata/corpus/sql/storage/test_show_tables_persistent.test @@ -0,0 +1,21 @@ +# source: test/sql/storage/test_show_tables_persistent.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +show tables +-- +ok +== +select current_user +-- +ok +== +create table anno as select 42 +-- +ok +== +drop table if exists anno +-- +ok +== diff --git a/parser/testdata/corpus/sql/storage/test_storage_scan.test b/parser/testdata/corpus/sql/storage/test_storage_scan.test new file mode 100644 index 0000000..1708467 --- /dev/null +++ b/parser/testdata/corpus/sql/storage/test_storage_scan.test @@ -0,0 +1,13 @@ +# source: test/sql/storage/test_storage_scan.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +INSERT INTO test VALUES (11), (12), (13), (14), (15), (NULL) +-- +ok +== +DELETE FROM test WHERE a=13 +-- +ok +== diff --git a/parser/testdata/corpus/sql/storage/test_store_integers.test b/parser/testdata/corpus/sql/storage/test_store_integers.test new file mode 100644 index 0000000..ce63ba2 --- /dev/null +++ b/parser/testdata/corpus/sql/storage/test_store_integers.test @@ -0,0 +1,25 @@ +# source: test/sql/storage/test_store_integers.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +CREATE TABLE test2 (a INTEGER); +-- +ok +== +INSERT INTO test2 VALUES (13), (12), (11) +-- +ok +== +SELECT * FROM test2 ORDER BY a +-- +ok +== +INSERT INTO test VALUES (14, 23) +-- +ok +== +DROP TABLE test2 +-- +ok +== diff --git a/parser/testdata/corpus/sql/storage/test_store_nulls_strings.test b/parser/testdata/corpus/sql/storage/test_store_nulls_strings.test new file mode 100644 index 0000000..247f2ab --- /dev/null +++ b/parser/testdata/corpus/sql/storage/test_store_nulls_strings.test @@ -0,0 +1,9 @@ +# source: test/sql/storage/test_store_nulls_strings.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +CREATE TABLE IF NOT EXISTS test (a INTEGER, b STRING); +-- +ok +== diff --git a/parser/testdata/corpus/sql/storage/test_truncate_persistent.test b/parser/testdata/corpus/sql/storage/test_truncate_persistent.test new file mode 100644 index 0000000..e48c4f4 --- /dev/null +++ b/parser/testdata/corpus/sql/storage/test_truncate_persistent.test @@ -0,0 +1,17 @@ +# source: test/sql/storage/test_truncate_persistent.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +CREATE TABLE test AS FROM range(250000) t(i); +-- +ok +== +DELETE FROM test WHERE i < 150000 +-- +ok +== +TRUNCATE test +-- +ok +== diff --git a/parser/testdata/corpus/sql/storage/test_unaligned_scan.test b/parser/testdata/corpus/sql/storage/test_unaligned_scan.test new file mode 100644 index 0000000..333bcfa --- /dev/null +++ b/parser/testdata/corpus/sql/storage/test_unaligned_scan.test @@ -0,0 +1,13 @@ +# source: test/sql/storage/test_unaligned_scan.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +INSERT INTO test SELECT CASE WHEN i%2=0 THEN i ELSE NULL END, CASE WHEN i%2=0 THEN 'hello'||i::VARCHAR ELSE NULL END FROM range(10000) tbl(i) +-- +ok +== +SELECT COUNT(*), SUM(a), MIN(a), MAX(a), MIN(b), MAX(b), COUNT(a), COUNT(b) FROM test +-- +ok +== diff --git a/parser/testdata/corpus/sql/storage/test_unique_index_checkpoint.test b/parser/testdata/corpus/sql/storage/test_unique_index_checkpoint.test new file mode 100644 index 0000000..903edf8 --- /dev/null +++ b/parser/testdata/corpus/sql/storage/test_unique_index_checkpoint.test @@ -0,0 +1,34 @@ +# source: test/sql/storage/test_unique_index_checkpoint.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +CREATE TABLE test(i INTEGER, j INTEGER); +-- +ok +== +INSERT INTO test VALUES (1,100),(2,200); +-- +ok +== +CREATE UNIQUE INDEX idx ON test (i); +-- +ok +== +INSERT INTO test VALUES (1,101),(2,201); +-- +ok +== +CREATE TABLE IF NOT EXISTS unique_index_test AS +SELECT i AS ordernumber, j AS quantity FROM test; +-- +ok +== +CREATE UNIQUE INDEX unique_index_test_ordernumber_idx_unique ON unique_index_test (ordernumber); +-- +ok +== +INSERT INTO unique_index_test VALUES (1,101),(2,201); +-- +ok +== diff --git a/parser/testdata/corpus/sql/storage/total_string_length_nested_types.test b/parser/testdata/corpus/sql/storage/total_string_length_nested_types.test new file mode 100644 index 0000000..0ca483e --- /dev/null +++ b/parser/testdata/corpus/sql/storage/total_string_length_nested_types.test @@ -0,0 +1,49 @@ +# source: test/sql/storage/total_string_length_nested_types.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +CREATE TABLE test(a VARCHAR[], b STRUCT(s VARCHAR), c VARCHAR[3]); +-- +ok +== +INSERT INTO test SELECT ['abc'], {'s': 'de'}, ['fg', 'hi', 'jk'] FROM range(10_000); +-- +ok +== +SELECT COALESCE(s.child_stats.total_string_length, 30000) FROM (SELECT stats(a) s FROM test LIMIT 1) +-- +ok +== +SELECT COALESCE(s.child_stats.s.total_string_length, 20000) FROM (SELECT stats(b) s FROM test LIMIT 1) +-- +ok +== +SELECT COALESCE(s.child_stats.total_string_length, 60000) FROM (SELECT stats(c) s FROM test LIMIT 1) +-- +ok +== +SELECT COALESCE(s.child_stats.total_string_length, 60000) FROM (SELECT stats(a) s FROM test LIMIT 1) +-- +ok +== +SELECT COALESCE(s.child_stats.s.total_string_length, 40000) FROM (SELECT stats(b) s FROM test LIMIT 1) +-- +ok +== +SELECT COALESCE(s.child_stats.total_string_length, 120000) FROM (SELECT stats(c) s FROM test LIMIT 1) +-- +ok +== +SELECT COALESCE(s.child_stats.total_string_length, 90000) FROM (SELECT stats(a) s FROM test LIMIT 1) +-- +ok +== +SELECT COALESCE(s.child_stats.s.total_string_length, 60000) FROM (SELECT stats(b) s FROM test LIMIT 1) +-- +ok +== +SELECT COALESCE(s.child_stats.total_string_length, 180000) FROM (SELECT stats(c) s FROM test LIMIT 1) +-- +ok +== diff --git a/parser/testdata/corpus/sql/storage/total_string_length_repeated_insert.test b/parser/testdata/corpus/sql/storage/total_string_length_repeated_insert.test new file mode 100644 index 0000000..0914d65 --- /dev/null +++ b/parser/testdata/corpus/sql/storage/total_string_length_repeated_insert.test @@ -0,0 +1,17 @@ +# source: test/sql/storage/total_string_length_repeated_insert.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +create table test(s VARCHAR); +-- +ok +== +set checkpoint_threshold='1TB'; +-- +ok +== +INSERT INTO test SELECT 'abc' FROM range(10_000); +-- +ok +== diff --git a/parser/testdata/corpus/sql/storage/types/list/default_list.test b/parser/testdata/corpus/sql/storage/types/list/default_list.test new file mode 100644 index 0000000..4fddac3 --- /dev/null +++ b/parser/testdata/corpus/sql/storage/types/list/default_list.test @@ -0,0 +1,13 @@ +# source: test/sql/storage/types/list/default_list.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +CREATE TABLE a(i INT[] DEFAULT ([1, 2, 3])) +-- +ok +== +INSERT INTO a VALUES (DEFAULT) +-- +ok +== diff --git a/parser/testdata/corpus/sql/storage/types/list/empty_float_arrays.test b/parser/testdata/corpus/sql/storage/types/list/empty_float_arrays.test new file mode 100644 index 0000000..993272a --- /dev/null +++ b/parser/testdata/corpus/sql/storage/types/list/empty_float_arrays.test @@ -0,0 +1,25 @@ +# source: test/sql/storage/types/list/empty_float_arrays.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +CREATE TABLE test_table ( + id INTEGER, + emb FLOAT[], + emb_arr FLOAT[3] +); +-- +ok +== +INSERT INTO test_table (id) VALUES (42); +-- +ok +== +FROM test_table +-- +ok +== +SET force_compression='{compression}' +-- +ok +== diff --git a/parser/testdata/corpus/sql/storage/types/list/list_index_compression.test b/parser/testdata/corpus/sql/storage/types/list/list_index_compression.test new file mode 100644 index 0000000..c90fcd9 --- /dev/null +++ b/parser/testdata/corpus/sql/storage/types/list/list_index_compression.test @@ -0,0 +1,73 @@ +# source: test/sql/storage/types/list/list_index_compression.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +CREATE TABLE a(id INTEGER PRIMARY KEY, c INT[]); +-- +ok +== +INSERT INTO a VALUES (1, [1, 2, 3]) +-- +ok +== +SELECT * FROM a WHERE id=1 +-- +ok +== +INSERT INTO a VALUES (2, NULL) +-- +ok +== +INSERT INTO a VALUES (3, [NULL]) +-- +ok +== +INSERT INTO a VALUES (4, [4, 5, NULL, 6]) +-- +ok +== +SELECT * FROM a WHERE id=2 +-- +ok +== +SELECT * FROM a WHERE id=3 +-- +ok +== +SELECT * FROM a WHERE id=4 +-- +ok +== +DROP TABLE a; +-- +ok +== +CREATE TABLE a(id INTEGER, c INT[]); +-- +ok +== +CREATE INDEX a_index ON a(id); +-- +ok +== +INSERT INTO a VALUES (1, [4, 5, NULL]) +-- +ok +== +INSERT INTO a VALUES (1, NULL) +-- +ok +== +INSERT INTO a VALUES (1, [NULL]) +-- +ok +== +INSERT INTO a VALUES (1, [7, 8, 9, 10, 11, 12, 13, 14, 15]) +-- +ok +== +SELECT * FROM a WHERE id=1 ORDER BY c[1] NULLS FIRST +-- +ok +== diff --git a/parser/testdata/corpus/sql/storage/types/list/persistent_list_storage.test b/parser/testdata/corpus/sql/storage/types/list/persistent_list_storage.test new file mode 100644 index 0000000..9e830c4 --- /dev/null +++ b/parser/testdata/corpus/sql/storage/types/list/persistent_list_storage.test @@ -0,0 +1,41 @@ +# source: test/sql/storage/types/list/persistent_list_storage.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +CREATE TABLE a(b INTEGER[]); +-- +ok +== +INSERT INTO a VALUES ([1, 2]), (NULL), ([3, 4, 5, 6]), ([NULL, 7]); +-- +ok +== +DELETE FROM a WHERE b[1]=1 +-- +ok +== +CREATE TABLE b(b INTEGER[][]); +-- +ok +== +INSERT INTO b VALUES ([[1, 2], [3, 4]]), (NULL), ([NULL, [7, 8, NULL], [2, 3]]), ([[NULL, 6], NULL, [1, 2, NULL]]); +-- +ok +== +DELETE FROM b WHERE b[1][1]=1 +-- +ok +== +CREATE TABLE c(b VARCHAR[]); +-- +ok +== +INSERT INTO c VALUES (['hello', 'world']), (NULL), (['fejwfoaejwfoijwafew', 'b', 'c']), ([NULL, 'XXXXXXXXXXXXXXXXXXXXXXXX']); +-- +ok +== +SELECT * FROM c +-- +ok +== diff --git a/parser/testdata/corpus/sql/storage/types/list/store_list_of_struct.test b/parser/testdata/corpus/sql/storage/types/list/store_list_of_struct.test new file mode 100644 index 0000000..254c8a9 --- /dev/null +++ b/parser/testdata/corpus/sql/storage/types/list/store_list_of_struct.test @@ -0,0 +1,21 @@ +# source: test/sql/storage/types/list/store_list_of_struct.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +CREATE TABLE a(id INTEGER, b ROW(a INTEGER, b INTEGER)[]); +-- +ok +== +INSERT INTO a VALUES (1, [{'a': 3, 'b': 7}, {'a': NULL, 'b': 7}, NULL]), (2, []), (3, NULL), (4, [NULL, {'a': 7, 'b': NULL}, {'a': 1, 'b': 1}]) +-- +ok +== +SELECT * FROM a ORDER BY id; +-- +ok +== +UPDATE a SET b=[] WHERE id=3 +-- +ok +== diff --git a/parser/testdata/corpus/sql/storage/types/map/map_storage.test b/parser/testdata/corpus/sql/storage/types/map/map_storage.test new file mode 100644 index 0000000..e0ca6f2 --- /dev/null +++ b/parser/testdata/corpus/sql/storage/types/map/map_storage.test @@ -0,0 +1,13 @@ +# source: test/sql/storage/types/map/map_storage.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +CREATE TABLE a(b MAP(INTEGER,INTEGER)); +-- +ok +== +INSERT INTO a VALUES (MAP([1], [2])), (MAP([1, 2, 3], [4, 5, 6])); +-- +ok +== diff --git a/parser/testdata/corpus/sql/storage/types/struct/default_struct.test b/parser/testdata/corpus/sql/storage/types/struct/default_struct.test new file mode 100644 index 0000000..a8faa03 --- /dev/null +++ b/parser/testdata/corpus/sql/storage/types/struct/default_struct.test @@ -0,0 +1,150 @@ +# source: test/sql/storage/types/struct/default_struct.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +CREATE TABLE a( + i ROW( + a INT, + b INT + ) DEFAULT ( + { + 'a': 7, + 'b': 2 + } + ) +) +-- +ok +== +CREATE TABLE b( + i ROW( + a INT, + b INT + ) DEFAULT ( + { + 'a': 7, + 'b': 2 + } + ), + j INT DEFAULT 42 +) +-- +ok +== +INSERT INTO b(i) VALUES ( + {'a': 11} +) +-- +ok +== +INSERT INTO b(i) SELECT {'b': 12} +-- +ok +== +INSERT INTO b(i) VALUES (NULL) +-- +ok +== +SELECT * FROM b ORDER BY j, i.a NULLS LAST +-- +ok +== +CREATE TABLE c( + i ROW( + a INT, + n ROW( + x INT, + y INT + ), + z INT + ) DEFAULT ( + { + 'a': 1, + 'n': { + 'x': 2, + 'y': 3 + }, + 'z': 4 + } + ) +) +-- +ok +== +INSERT INTO c(i) VALUES ({'n': {'x': 10}}) +-- +ok +== +CREATE TABLE d( + i ROW( + a INT, + b INT + ) DEFAULT ( + { + 'a': 7 + 1, + 'b': 2 + 3 + } + ) +) +-- +ok +== +INSERT INTO d(i) VALUES ({'a': 11}) +-- +ok +== +SELECT * FROM d +-- +ok +== +CREATE TABLE e( + i ROW( + a INT, + b INT, + c INT + ) DEFAULT ( + { + 'a': 7 + } + ) +) +-- +ok +== +INSERT INTO e(i) VALUES ({'b': 12}) +-- +ok +== +SELECT * FROM e +-- +ok +== +CREATE TABLE f( + i ROW( + a INT, + n ROW( + x INT, + y INT, + z INT + ), + b INT + ) DEFAULT ( + { + 'n': { + 'y': 3 + } + } + ) +) +-- +ok +== +INSERT INTO f(i) VALUES ({'n': {'x': 10}}) +-- +ok +== +SELECT * FROM f +-- +ok +== diff --git a/parser/testdata/corpus/sql/storage/types/struct/nested_struct_storage.test b/parser/testdata/corpus/sql/storage/types/struct/nested_struct_storage.test new file mode 100644 index 0000000..7931a3c --- /dev/null +++ b/parser/testdata/corpus/sql/storage/types/struct/nested_struct_storage.test @@ -0,0 +1,78 @@ +# source: test/sql/storage/types/struct/nested_struct_storage.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +CREATE TABLE a AS SELECT { + 'r1': { + 'a': 'hello', + 'b': 3 + }, + 'r2': { + 'a': 'world', + 'b': 17, + 'c': NULL + } +} c +-- +ok +== +SELECT c['r1']['a'] from a +-- +ok +== +UPDATE a SET c={ + 'r1': { + 'a': 'blabla', + 'b': 3 + }, + 'r2': { + 'a': 'world', + 'b': 18, + 'c': NULL + } +} +-- +ok +== +INSERT INTO a VALUES ( +{ + 'r1': { + 'a': NULL, + 'b': 3 + }, + 'r2': { + 'a': NULL, + 'b': 17, + 'c': NULL + } +}) +-- +ok +== +INSERT INTO a VALUES ({ + 'r1': NULL, + 'r2': { + 'a': NULL, + 'b': 17, + 'c': NULL + } +}) +-- +ok +== +INSERT INTO a VALUES ({ + 'r1': NULL, + 'r2': NULL +}) +-- +ok +== +INSERT INTO a VALUES(NULL) +-- +ok +== +select column_path, stats from pragma_storage_info('a') where stats LIKE '%[Min: -2147483648, Max: -2147483648]%' +-- +ok +== diff --git a/parser/testdata/corpus/sql/storage/types/struct/pushdown_extract_validity.test b/parser/testdata/corpus/sql/storage/types/struct/pushdown_extract_validity.test new file mode 100644 index 0000000..ab545c6 --- /dev/null +++ b/parser/testdata/corpus/sql/storage/types/struct/pushdown_extract_validity.test @@ -0,0 +1,29 @@ +# source: test/sql/storage/types/struct/pushdown_extract_validity.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +CREATE TABLE structs(s STRUCT(id INT)); +-- +ok +== +INSERT INTO structs +SELECT {'id': CASE WHEN r%3=0 THEN NULL ELSE i END } +FROM ( + SELECT UNNEST(range(1200)) r, UNNEST(repeat([1], 1000)) i UNION ALL SELECT UNNEST(range(1000)) r, UNNEST(repeat([2], 1000)) i +) +-- +ok +== +INSERT INTO structs +SELECT CASE WHEN r%13=0 THEN NULL ELSE {'id': CASE WHEN r%7=0 THEN NULL ELSE i END } END +FROM ( + SELECT UNNEST(range(2000)) r, UNNEST(repeat([1], 2000)) i +) +-- +ok +== +SELECT DISTINCT s.id FROM structs ORDER BY ALL +-- +ok +== diff --git a/parser/testdata/corpus/sql/storage/types/struct/struct_of_empty_list.test b/parser/testdata/corpus/sql/storage/types/struct/struct_of_empty_list.test new file mode 100644 index 0000000..5f95a7a --- /dev/null +++ b/parser/testdata/corpus/sql/storage/types/struct/struct_of_empty_list.test @@ -0,0 +1,13 @@ +# source: test/sql/storage/types/struct/struct_of_empty_list.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +create table tbl (col STRUCT(a VARCHAR[])) +-- +ok +== +insert into tbl SELECT {'a': []} from range(122881) +-- +ok +== diff --git a/parser/testdata/corpus/sql/storage/types/struct/struct_storage.test b/parser/testdata/corpus/sql/storage/types/struct/struct_storage.test new file mode 100644 index 0000000..27599e0 --- /dev/null +++ b/parser/testdata/corpus/sql/storage/types/struct/struct_storage.test @@ -0,0 +1,21 @@ +# source: test/sql/storage/types/struct/struct_storage.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +INSERT INTO a VALUES ({'i': 1, 'j': 2}), (NULL), ({'i': NULL, 'j': 2}), (ROW(1, NULL)); +-- +ok +== +SELECT COUNT(*) FROM a WHERE b IS NULL; +-- +ok +== +DELETE FROM a WHERE (b).i=1 +-- +ok +== +UPDATE a SET b={i: 7, j: 9} WHERE b IS NULL +-- +ok +== diff --git a/parser/testdata/corpus/sql/storage/types/test_bit_storage.test b/parser/testdata/corpus/sql/storage/types/test_bit_storage.test new file mode 100644 index 0000000..bd45a53 --- /dev/null +++ b/parser/testdata/corpus/sql/storage/types/test_bit_storage.test @@ -0,0 +1,17 @@ +# source: test/sql/storage/types/test_bit_storage.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +CREATE TABLE bits (b BIT); +-- +ok +== +INSERT INTO bits VALUES('1'), ('010111'), ('111110010011'), (NULL), ('000000000000000000'), ('00100110010100100101001010010101010011110101000000000111100100110') +-- +ok +== +SELECT * FROM bits +-- +ok +== diff --git a/parser/testdata/corpus/sql/storage/types/test_blob_storage.test b/parser/testdata/corpus/sql/storage/types/test_blob_storage.test new file mode 100644 index 0000000..23a747b --- /dev/null +++ b/parser/testdata/corpus/sql/storage/types/test_blob_storage.test @@ -0,0 +1,13 @@ +# source: test/sql/storage/types/test_blob_storage.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +CREATE TABLE blobs (b BLOB); +-- +ok +== +INSERT INTO blobs VALUES('a'), ('\xAA'), ('\xAA\xFF\xAA'), (''), (NULL), ('\x55\xAA\xFF\x55\xAA\xFF\x55\xAA\xFF\x01'), ('\x55\xAA\xFF\x55\xAA\xFF\x55\xAA\xFF\x01') +-- +ok +== diff --git a/parser/testdata/corpus/sql/storage/types/test_hugeint_storage.test b/parser/testdata/corpus/sql/storage/types/test_hugeint_storage.test new file mode 100644 index 0000000..ab861c4 --- /dev/null +++ b/parser/testdata/corpus/sql/storage/types/test_hugeint_storage.test @@ -0,0 +1,25 @@ +# source: test/sql/storage/types/test_hugeint_storage.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +CREATE TABLE hugeints (h HUGEINT); +-- +ok +== +INSERT INTO hugeints VALUES (1043178439874412422424), (42), (NULL), (47289478944894789472897441242); +-- +ok +== +SELECT * FROM hugeints +-- +ok +== +SELECT * FROM hugeints WHERE h = 42 +-- +ok +== +SELECT h FROM hugeints WHERE h < 10 ORDER BY 1; +-- +ok +== diff --git a/parser/testdata/corpus/sql/storage/types/test_interval_storage.test b/parser/testdata/corpus/sql/storage/types/test_interval_storage.test new file mode 100644 index 0000000..4605e01 --- /dev/null +++ b/parser/testdata/corpus/sql/storage/types/test_interval_storage.test @@ -0,0 +1,29 @@ +# source: test/sql/storage/types/test_interval_storage.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +CREATE TABLE interval (t INTERVAL); +-- +ok +== +INSERT INTO interval VALUES (INTERVAL '1' DAY), (NULL), (INTERVAL '3 months 2 days 5 seconds') +-- +ok +== +SELECT * FROM interval +-- +ok +== +SELECT t FROM interval WHERE t = INTERVAL '1' DAY; +-- +ok +== +SELECT t FROM interval WHERE t >= INTERVAL '1' DAY ORDER BY 1; +-- +ok +== +SELECT t FROM interval WHERE t > INTERVAL '10' YEAR ORDER BY 1; +-- +ok +== diff --git a/parser/testdata/corpus/sql/storage/types/test_timestamp_storage.test b/parser/testdata/corpus/sql/storage/types/test_timestamp_storage.test new file mode 100644 index 0000000..1141cd9 --- /dev/null +++ b/parser/testdata/corpus/sql/storage/types/test_timestamp_storage.test @@ -0,0 +1,37 @@ +# source: test/sql/storage/types/test_timestamp_storage.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +CREATE TABLE timestamp (sec TIMESTAMP_S, milli TIMESTAMP_MS,micro TIMESTAMP_US, nano TIMESTAMP_NS ); +-- +ok +== +INSERT INTO timestamp VALUES (NULL,NULL,NULL,NULL ) +-- +ok +== +INSERT INTO timestamp VALUES ('2008-01-01 00:00:01','2008-01-01 00:00:01.594','2008-01-01 00:00:01.88926','2008-01-01 00:00:01.889268321' ) +-- +ok +== +INSERT INTO timestamp VALUES ('2008-01-01 00:00:51','2008-01-01 00:00:01.894','2008-01-01 00:00:01.99926','2008-01-01 00:00:01.999268321' ) +-- +ok +== +INSERT INTO timestamp VALUES ('2008-01-01 00:00:11','2008-01-01 00:00:01.794','2008-01-01 00:00:01.98926','2008-01-01 00:00:01.899268321' ) +-- +ok +== +SELECT * FROM timestamp ORDER BY sec +-- +ok +== +SELECT * FROM timestamp WHERE micro=TIMESTAMP '2008-01-01 00:00:01.88926' ORDER BY micro +-- +ok +== +SELECT * FROM timestamp WHERE micro=TIMESTAMP '2020-01-01 00:00:01.88926' ORDER BY micro +-- +ok +== diff --git a/parser/testdata/corpus/sql/storage/types/test_uhugeint_storage.test b/parser/testdata/corpus/sql/storage/types/test_uhugeint_storage.test new file mode 100644 index 0000000..bbe7d3e --- /dev/null +++ b/parser/testdata/corpus/sql/storage/types/test_uhugeint_storage.test @@ -0,0 +1,25 @@ +# source: test/sql/storage/types/test_uhugeint_storage.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +CREATE TABLE uhugeints (h UHUGEINT); +-- +ok +== +INSERT INTO uhugeints VALUES (0), (42), (NULL), ('340282366920938463463374607431768211455'::UHUGEINT); +-- +ok +== +SELECT * FROM uhugeints +-- +ok +== +SELECT * FROM uhugeints WHERE h = 42 +-- +ok +== +SELECT h FROM uhugeints WHERE h < 10 ORDER BY 1; +-- +ok +== diff --git a/parser/testdata/corpus/sql/storage/types/test_unsigned_storage.test b/parser/testdata/corpus/sql/storage/types/test_unsigned_storage.test new file mode 100644 index 0000000..3491aac --- /dev/null +++ b/parser/testdata/corpus/sql/storage/types/test_unsigned_storage.test @@ -0,0 +1,55 @@ +# source: test/sql/storage/types/test_unsigned_storage.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +CREATE TABLE unsigned (a utinyint, b usmallint, c uinteger, d ubigint); +-- +ok +== +INSERT INTO unsigned VALUES (1,1,1,1), (42,42,42,42), (NULL,NULL,NULL,NULL), (255,65535,4294967295,18446744073709551615); +-- +ok +== +SELECT * FROM unsigned +-- +ok +== +SELECT * FROM unsigned WHERE a = 42 +-- +ok +== +SELECT a FROM unsigned WHERE a < 10 ORDER BY 1; +-- +ok +== +SELECT * FROM unsigned WHERE b = 42 +-- +ok +== +SELECT b FROM unsigned WHERE b < 10 ORDER BY 1; +-- +ok +== +SELECT * FROM unsigned WHERE c = 42 +-- +ok +== +SELECT c FROM unsigned WHERE c < 10 ORDER BY 1; +-- +ok +== +SELECT * FROM unsigned WHERE d = 42 +-- +ok +== +SELECT d FROM unsigned WHERE d < 10 ORDER BY 1; +-- +ok +== +UPDATE unsigned +SET a = 10, b = 9, c = 8, d = 7 +WHERE a = 1; +-- +ok +== diff --git a/parser/testdata/corpus/sql/storage/types/test_uuid.storage.test b/parser/testdata/corpus/sql/storage/types/test_uuid.storage.test new file mode 100644 index 0000000..cfdee0f --- /dev/null +++ b/parser/testdata/corpus/sql/storage/types/test_uuid.storage.test @@ -0,0 +1,29 @@ +# source: test/sql/storage/types/test_uuid.storage.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +CREATE TABLE uuids (u uuid); +-- +ok +== +INSERT INTO uuids VALUES ('A0EEBC99-9C0B-4EF8-BB6D-6BB9BD380A11'), (NULL), ('47183823-2574-4bfd-b411-99ed177d3e43'), ('{10203040506070800102030405060708}'); +-- +ok +== +SELECT * FROM uuids +-- +ok +== +SELECT * FROM uuids WHERE u = 'A0EEBC99-9C0B-4EF8-BB6D-6BB9BD380A11' +-- +ok +== +SELECT * FROM uuids WHERE u = 'a0eebc99-9c0b-4ef8-bb6d-6bb9bd380a11' +-- +ok +== +SELECT u FROM uuids WHERE u > '10203040-5060-7080-0102-030405060708' ORDER BY 1; +-- +ok +== diff --git a/parser/testdata/corpus/sql/storage/types/variant/append_shredded.test b/parser/testdata/corpus/sql/storage/types/variant/append_shredded.test new file mode 100644 index 0000000..d44325a --- /dev/null +++ b/parser/testdata/corpus/sql/storage/types/variant/append_shredded.test @@ -0,0 +1,17 @@ +# source: test/sql/storage/types/variant/append_shredded.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +create table tbl (col VARIANT) +-- +ok +== +insert into tbl SELECT NULL from range(154840) +-- +ok +== +insert into tbl SELECT True from range(5000) +-- +ok +== diff --git a/parser/testdata/corpus/sql/storage/types/variant/extension_types.test b/parser/testdata/corpus/sql/storage/types/variant/extension_types.test new file mode 100644 index 0000000..880a28c --- /dev/null +++ b/parser/testdata/corpus/sql/storage/types/variant/extension_types.test @@ -0,0 +1,21 @@ +# source: test/sql/storage/types/variant/extension_types.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +CREATE TABLE tbl (col VARIANT) +-- +ok +== +INSERT into tbl select '127.0.0.1'::INET +-- +ok +== +select * from tbl +-- +ok +== +select COLUMNS(*)::INET from tbl +-- +ok +== diff --git a/parser/testdata/corpus/sql/storage/types/variant/index_fetch.test b/parser/testdata/corpus/sql/storage/types/variant/index_fetch.test new file mode 100644 index 0000000..4503017 --- /dev/null +++ b/parser/testdata/corpus/sql/storage/types/variant/index_fetch.test @@ -0,0 +1,33 @@ +# source: test/sql/storage/types/variant/index_fetch.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +CREATE TABLE tbl(i INT PRIMARY KEY, v VARIANT); +-- +ok +== +INSERT INTO tbl select i, {'a': i, 'b': i % 5} from range(100) t(i) +-- +ok +== +SELECT v FROM tbl WHERE i=42; +-- +ok +== +SELECT v['a']::INTEGER FROM tbl WHERE i=42; +-- +ok +== +ATTACH '{TEST_DIR}/variant_index_fetch.db' as db2 (STORAGE_VERSION 'v1.5.0'); +-- +ok +== +SET debug_force_fetch_row=true; +-- +ok +== +select v from tbl WHERE i < 10 +-- +ok +== diff --git a/parser/testdata/corpus/sql/storage/types/variant/struct_of_variant.test b/parser/testdata/corpus/sql/storage/types/variant/struct_of_variant.test new file mode 100644 index 0000000..251d4c5 --- /dev/null +++ b/parser/testdata/corpus/sql/storage/types/variant/struct_of_variant.test @@ -0,0 +1,37 @@ +# source: test/sql/storage/types/variant/struct_of_variant.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +CREATE TABLE variant_list( + col STRUCT( + f1 INTEGER, + f2 VARIANT, + f3 VARCHAR, + f4 BOOL + ) +); +-- +ok +== +INSERT INTO variant_list SELECT { + 'f1': i, + 'f2': {'a': i::INTEGER, 'b': 'val' || i}, + 'f3': 'test', + 'f4': i % 2 == 0 +} from range(1000) t(i) +-- +ok +== +INSERT INTO variant_list VALUES(row(3000, 'test', 'hello world', 42)); +-- +ok +== +select + col.f2.a::INTEGER, + col.f2.b::VARCHAR, + col.f4 +from variant_list order by col.f1 limit 10 +-- +ok +== diff --git a/parser/testdata/corpus/sql/storage/types/variant/test_all_types.test b/parser/testdata/corpus/sql/storage/types/variant/test_all_types.test new file mode 100644 index 0000000..cfe3a2e --- /dev/null +++ b/parser/testdata/corpus/sql/storage/types/variant/test_all_types.test @@ -0,0 +1,13 @@ +# source: test/sql/storage/types/variant/test_all_types.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +create table table_{col} as select "{col}"::VARIANT col from test_all_types() +-- +error: Parser Error: syntax error at or near "{" +== +select col = (select "{col}"::VARIANT as "{col}" from test_all_types() offset {i} limit 1) from table_{col} t1 offset {i} limit 1 +-- +error: Parser Error: syntax error at or near "}" +== diff --git a/parser/testdata/corpus/sql/storage/types/variant/test_all_types_single_object.test b/parser/testdata/corpus/sql/storage/types/variant/test_all_types_single_object.test new file mode 100644 index 0000000..facfde0 --- /dev/null +++ b/parser/testdata/corpus/sql/storage/types/variant/test_all_types_single_object.test @@ -0,0 +1,40 @@ +# source: test/sql/storage/types/variant/test_all_types_single_object.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +create table tbl ( + col VARIANT +) +-- +ok +== +insert into tbl select t::VARIANT var from test_all_types() t +-- +ok +== +set variable col_type = (select typeof("{col}") from test_all_types() limit 1); +-- +ok +== +set variable col_name = (select '{col}'); +-- +ok +== +select "{col}" from test_all_types(); +-- +ok +== +from query($$select col."$$ || getvariable('col_name') || $$"::$$ || getvariable('col_type') || ' from tbl'); +-- +ok +== +create or replace table intermediate as + from query($$select col."$$ || getvariable('col_name') || $$" extracted from tbl$$); +-- +ok +== +from query('select extracted::' || getvariable('col_type') || ' from intermediate'); +-- +ok +== diff --git a/parser/testdata/corpus/sql/storage/types/variant/test_all_types_single_table.test b/parser/testdata/corpus/sql/storage/types/variant/test_all_types_single_table.test new file mode 100644 index 0000000..03c6fca --- /dev/null +++ b/parser/testdata/corpus/sql/storage/types/variant/test_all_types_single_table.test @@ -0,0 +1,39 @@ +# source: test/sql/storage/types/variant/test_all_types_single_table.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +insert into tbl select "{col}"::VARIANT from test_all_types() +-- +ok +== +set variable my_type = ( + select column_type from ( + describe from test_all_types() + ) + where + column_type NOT ILIKE '%union%' AND + column_type NOT ILIKE '%enum%' AND + column_type NOT ILIKE '%map%' AND + column_type <> 'STRUCT' + limit 1 offset {i} +); +-- +error: Parser Error: syntax error at or near "}" +== +SET force_variant_shredding = getvariable('my_type'); +-- +ok +== +create or replace table "tbl2" as select * from tbl; +-- +ok +== +select * from "tbl2"; +-- +ok +== +SET variant_minimum_shredding_size = -1; +-- +ok +== diff --git a/parser/testdata/corpus/sql/storage/types/variant/test_all_types_variant.test b/parser/testdata/corpus/sql/storage/types/variant/test_all_types_variant.test new file mode 100644 index 0000000..83709ef --- /dev/null +++ b/parser/testdata/corpus/sql/storage/types/variant/test_all_types_variant.test @@ -0,0 +1,17 @@ +# source: test/sql/storage/types/variant/test_all_types_variant.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +create table tbl as select COLUMNS(*)::VARIANT from test_all_types() +-- +ok +== +select "{col}"::VARIANT from test_all_types() +-- +ok +== +select "{col}" from tbl +-- +ok +== diff --git a/parser/testdata/corpus/sql/storage/types/variant/update.test b/parser/testdata/corpus/sql/storage/types/variant/update.test new file mode 100644 index 0000000..b8d0077 --- /dev/null +++ b/parser/testdata/corpus/sql/storage/types/variant/update.test @@ -0,0 +1,17 @@ +# source: test/sql/storage/types/variant/update.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +create table tbl (a VARIANT) +-- +ok +== +insert into tbl VALUES (42) +-- +ok +== +update tbl SET a = 21 +-- +ok +== diff --git a/parser/testdata/corpus/sql/storage/types/variant/variant_case_sensitive_fields_shredded.test b/parser/testdata/corpus/sql/storage/types/variant/variant_case_sensitive_fields_shredded.test new file mode 100644 index 0000000..a8c7702 --- /dev/null +++ b/parser/testdata/corpus/sql/storage/types/variant/variant_case_sensitive_fields_shredded.test @@ -0,0 +1,49 @@ +# source: test/sql/storage/types/variant/variant_case_sensitive_fields_shredded.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +set variant_minimum_shredding_size = 0; +-- +ok +== +create or replace table test_structs( + id int, + s VARIANT +); +-- +ok +== +insert into test_structs +values + (1, { + 'name': { + 'v': 'row 1', + 'id': 1 + }, + 'nested_struct': { + 'a': 42, + 'b': true + } + }), + (2, null), + (3, { + 'name': { + 'v': 'row 3', + 'id': 3 + }, + 'nested_struct': { + 'a': 84, + 'b': null + } + }), + (4, { + 'name': null, + 'nested_struct': { + 'A': null, + 'b': false + } + }); +-- +ok +== diff --git a/parser/testdata/corpus/sql/storage/types/variant/variant_comparator_shredded.test b/parser/testdata/corpus/sql/storage/types/variant/variant_comparator_shredded.test new file mode 100644 index 0000000..8b3c5f2 --- /dev/null +++ b/parser/testdata/corpus/sql/storage/types/variant/variant_comparator_shredded.test @@ -0,0 +1,84 @@ +# source: test/sql/storage/types/variant/variant_comparator_shredded.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +SET force_variant_shredding = 'STRUCT(a INTEGER, b VARCHAR)'; +-- +ok +== +CREATE TABLE shredded(id INTEGER, v VARIANT); +-- +ok +== +INSERT INTO shredded VALUES + (1, '{"a": 1, "b": "x", "c": 100}'::VARIANT), + (2, '{"a": 2, "b": "y"}'::VARIANT), + (3, '{"a": 3, "b": "z", "d": [1, 2, 3]}'::VARIANT), + (4, NULL::VARIANT), + (5, '{"a": 40, "b": "m"}'::VARIANT), + (6, '{"a": 6, "b": "hello", "g": "extra"}'::VARIANT), + (7, '{"a": 7, "b": "aaa"}'::VARIANT), + (8, '{"a": 5, "b": "q", "e": {"nested": true}}'::VARIANT), + (9, '{"a": 5, "b": "q"}'::VARIANT), + (10, '{"a": 100, "b": "z"}'::VARIANT); +-- +ok +== +SELECT id FROM (VALUES + (1, '{"a": 1, "b": "x", "c": 100}'::VARIANT), + (2, '{"a": 2, "b": "y"}'::VARIANT), + (3, '{"a": 3, "b": "z", "d": [1, 2, 3]}'::VARIANT), + (4, NULL::VARIANT), + (5, '{"a": 40, "b": "m"}'::VARIANT), + (6, '{"a": 6, "b": "hello", "g": "extra"}'::VARIANT), + (7, '{"a": 7, "b": "aaa"}'::VARIANT), + (8, '{"a": 5, "b": "q", "e": {"nested": true}}'::VARIANT), + (9, '{"a": 5, "b": "q"}'::VARIANT), + (10, '{"a": 100, "b": "z"}'::VARIANT) +) tbl(id, v) ORDER BY v, id; +-- +ok +== +SELECT id FROM shredded ORDER BY v, id; +-- +ok +== +SELECT v::VARCHAR FROM (VALUES + (1, '{"a": 1, "b": "x", "c": 100}'::VARIANT), + (2, '{"a": 2, "b": "y"}'::VARIANT), + (3, '{"a": 3, "b": "z", "d": [1, 2, 3]}'::VARIANT), + (4, NULL::VARIANT), + (5, '{"a": 40, "b": "m"}'::VARIANT), + (6, '{"a": 6, "b": "hello", "g": "extra"}'::VARIANT), + (7, '{"a": 7, "b": "aaa"}'::VARIANT), + (8, '{"a": 5, "b": "q", "e": {"nested": true}}'::VARIANT), + (9, '{"a": 5, "b": "q"}'::VARIANT), + (10, '{"a": 100, "b": "z"}'::VARIANT) +) tbl(id, v) ORDER BY v, id; +-- +ok +== +SELECT v::VARCHAR FROM shredded ORDER BY v, id; +-- +ok +== +SELECT id FROM (VALUES + (1, '{"a": 1, "b": "x", "c": 100}'::VARIANT), + (2, '{"a": 2, "b": "y"}'::VARIANT), + (3, '{"a": 3, "b": "z", "d": [1, 2, 3]}'::VARIANT), + (4, NULL::VARIANT), + (5, '{"a": 40, "b": "m"}'::VARIANT), + (6, '{"a": 6, "b": "hello", "g": "extra"}'::VARIANT), + (7, '{"a": 7, "b": "aaa"}'::VARIANT), + (8, '{"a": 5, "b": "q", "e": {"nested": true}}'::VARIANT), + (9, '{"a": 5, "b": "q"}'::VARIANT), + (10, '{"a": 100, "b": "z"}'::VARIANT) +) tbl(id, v) WHERE v > '{"a": 5, "b": "q"}'::VARIANT ORDER BY id; +-- +ok +== +SELECT id FROM shredded WHERE v > '{"a": 5, "b": "q"}'::VARIANT ORDER BY id; +-- +ok +== diff --git a/parser/testdata/corpus/sql/storage/types/variant/variant_comparator_stats.test b/parser/testdata/corpus/sql/storage/types/variant/variant_comparator_stats.test new file mode 100644 index 0000000..3cb28ec --- /dev/null +++ b/parser/testdata/corpus/sql/storage/types/variant/variant_comparator_stats.test @@ -0,0 +1,114 @@ +# source: test/sql/storage/types/variant/variant_comparator_stats.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +CREATE TABLE ints(col VARIANT); +-- +ok +== +INSERT INTO ints SELECT (i + 1)::INTEGER FROM range(100) t(i); +-- +ok +== +SELECT + s.min::VARCHAR = variant_comparator(1::INTEGER::VARIANT)::VARCHAR, + s.max::VARCHAR = variant_comparator(100::INTEGER::VARIANT)::VARCHAR +FROM (SELECT stats(variant_comparator(col)) s FROM ints LIMIT 1); +-- +ok +== +SELECT count(*) FROM ints WHERE col > 50::INTEGER::VARIANT; +-- +ok +== +SELECT count(*) FROM ints WHERE col <= 10::INTEGER::VARIANT; +-- +ok +== +SELECT count(*) FROM ints WHERE col = 1000::INTEGER::VARIANT; +-- +ok +== +SET force_variant_shredding = 'VARCHAR'; +-- +ok +== +CREATE TABLE strs(col VARIANT); +-- +ok +== +INSERT INTO strs VALUES ('apple'::VARIANT), ('mango'::VARIANT), ('cherry'::VARIANT); +-- +ok +== +SELECT s.min IS NOT NULL, s.max IS NOT NULL +FROM (SELECT stats(variant_comparator(col)) s FROM strs LIMIT 1); +-- +ok +== +SELECT count(*) FROM strs WHERE col > 'cherry'::VARIANT; +-- +ok +== +SELECT count(*) FROM strs WHERE col >= 'apple'::VARIANT; +-- +ok +== +SELECT count(*) FROM strs WHERE col > 'zzzzz'::VARIANT; +-- +ok +== +CREATE TABLE nullable_ints(col VARIANT); +-- +ok +== +INSERT INTO nullable_ints SELECT (i + 1)::INTEGER FROM range(10) t(i); +-- +ok +== +INSERT INTO nullable_ints VALUES (NULL::VARIANT); +-- +ok +== +SELECT + s.min::VARCHAR = variant_comparator(1::INTEGER::VARIANT)::VARCHAR, + s.max::VARCHAR = variant_comparator(10::INTEGER::VARIANT)::VARCHAR +FROM (SELECT stats(variant_comparator(col)) s FROM nullable_ints LIMIT 1); +-- +ok +== +CREATE TABLE mixed(col VARIANT); +-- +ok +== +INSERT INTO mixed SELECT (i + 1)::INTEGER FROM range(10) t(i); +-- +ok +== +INSERT INTO mixed VALUES ('hello'::VARIANT); +-- +ok +== +SELECT s.min IS NULL, s.max IS NULL +FROM (SELECT stats(variant_comparator(col)) s FROM mixed LIMIT 1); +-- +ok +== +SET force_variant_shredding = 'STRUCT(a INTEGER)'; +-- +ok +== +CREATE TABLE objs(col VARIANT); +-- +ok +== +INSERT INTO objs SELECT {'a': (i + 1)::INTEGER} FROM range(10) t(i); +-- +ok +== +SELECT s.min IS NULL +FROM (SELECT stats(variant_comparator(col)) s FROM objs LIMIT 1); +-- +ok +== diff --git a/parser/testdata/corpus/sql/storage/types/variant/variant_duplicate_keys_shredding.test b/parser/testdata/corpus/sql/storage/types/variant/variant_duplicate_keys_shredding.test new file mode 100644 index 0000000..f02e224 --- /dev/null +++ b/parser/testdata/corpus/sql/storage/types/variant/variant_duplicate_keys_shredding.test @@ -0,0 +1,14 @@ +# source: test/sql/storage/types/variant/variant_duplicate_keys_shredding.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +CREATE TABLE variants AS +SELECT '{"a":1,"a":2}'::JSON::VARIANT AS v; +-- +ok +== +SELECT (v).a, variant_keys(v), v::JSON FROM variants; +-- +ok +== diff --git a/parser/testdata/corpus/sql/storage/types/variant/variant_extract_filter_pushdown.test b/parser/testdata/corpus/sql/storage/types/variant/variant_extract_filter_pushdown.test new file mode 100644 index 0000000..80f042b --- /dev/null +++ b/parser/testdata/corpus/sql/storage/types/variant/variant_extract_filter_pushdown.test @@ -0,0 +1,62 @@ +# source: test/sql/storage/types/variant/variant_extract_filter_pushdown.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +CREATE TABLE variant_extract_pushdown(v VARIANT); +-- +ok +== +INSERT INTO variant_extract_pushdown +SELECT {'x': i, 'y': i * 100, 'z': i * 10000}::VARIANT FROM range(100) t(i) +-- +ok +== +SELECT COUNT(*) FROM variant_extract_pushdown WHERE v.x=5 +-- +ok +== +SELECT v.x FROM variant_extract_pushdown WHERE v.x=5 +-- +ok +== +SELECT v.y FROM variant_extract_pushdown WHERE v.x=5 +-- +ok +== +SELECT COUNT(*) FROM variant_extract_pushdown WHERE v.x=5 AND v.y=500 +-- +ok +== +SELECT v.x FROM variant_extract_pushdown WHERE v.x=5 AND v.y=500 +-- +ok +== +SELECT v.z FROM variant_extract_pushdown WHERE v.x=5 AND v.y=500 +-- +ok +== +SELECT COUNT(*) FROM variant_extract_pushdown WHERE v.x + v.y = 505 +-- +ok +== +SELECT v.x FROM variant_extract_pushdown WHERE v.x + v.y = 505 +-- +ok +== +SELECT v.z FROM variant_extract_pushdown WHERE v.x + v.y = 505 +-- +ok +== +SELECT COUNT(*) FROM variant_extract_pushdown WHERE v.x = 5 OR v.y = 400 +-- +ok +== +SELECT v.x FROM variant_extract_pushdown WHERE v.x = 5 OR v.y = 400 ORDER BY ALL +-- +ok +== +SELECT v.z FROM variant_extract_pushdown WHERE v.x = 5 OR v.y = 400 ORDER BY ALL +-- +ok +== diff --git a/parser/testdata/corpus/sql/storage/types/variant/variant_extract_stats.test b/parser/testdata/corpus/sql/storage/types/variant/variant_extract_stats.test new file mode 100644 index 0000000..ed3e032 --- /dev/null +++ b/parser/testdata/corpus/sql/storage/types/variant/variant_extract_stats.test @@ -0,0 +1,117 @@ +# source: test/sql/storage/types/variant/variant_extract_stats.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +SET force_variant_shredding = 'VARCHAR[]'; +-- +ok +== +insert into tbl select + ['hello', 'world'] +from range(5) t(i) +-- +ok +== +select s.fully_shredded.stats.min, s.fully_shredded.stats.max from (select stats(col[1]) s from tbl limit 1); +-- +ok +== +insert into tbl select 42::INTEGER from range(5) t(i) +-- +ok +== +select s.fully_shredded from (select stats(col) s from tbl limit 1); +-- +ok +== +select stats(col[1]).shredding_state from tbl offset 5 limit 1; +-- +ok +== +delete from tbl where not variant_typeof(col).starts_with('ARRAY') +-- +ok +== +insert into tbl select + [42, 21, 1337] +from range(5) +-- +ok +== +delete from tbl; +-- +ok +== +insert into tbl select {'a': 42, 'b': false} from range(5) +-- +ok +== +select stats(col.a).shredding_state from tbl limit 1; +-- +ok +== +SET force_variant_shredding = 'STRUCT(a VARCHAR, b INTEGER)'; +-- +ok +== +insert into tbl select {'a': 'test', 'b': false} +-- +ok +== +select s.fully_shredded.stats.min, s.fully_shredded.stats.max_string_length from (select stats(col.a) s from tbl limit 1); +-- +ok +== +select stats(col.b).shredding_state from tbl limit 1; +-- +ok +== +select s.fully_shredded.a.stats.min from (select stats(col) s from tbl limit 1); +-- +ok +== +insert into tbl select {'a': 42::INTEGER, 'b': false} +-- +ok +== +select stats(col).shredding_state from tbl limit 1; +-- +ok +== +insert into tbl select {'a': 'test', 'c': [42], 'b': false} +-- +ok +== +insert into tbl select {'b': 1337::INTEGER} +-- +ok +== +insert into tbl select 42::INTEGER +-- +ok +== +select stats(col.c).shredding_state from tbl order by rowid offset 2 limit 1; +-- +ok +== +SET force_variant_shredding = 'STRUCT(a STRUCT(b VARCHAR, c VARCHAR))'; +-- +ok +== +insert into tbl select {'a': {'b': 'hello', 'c': 'world'}} from range(5) +-- +ok +== +select s.fully_shredded.stats.min, s.fully_shredded.stats.max from (select stats(col.a.b) s from tbl limit 1); +-- +ok +== +select s.fully_shredded.stats.min, s.fully_shredded.stats.max from (select stats(col.a.c) s from tbl limit 1); +-- +ok +== +select stats(col.a.b).shredding_state from tbl limit 1; +-- +ok +== diff --git a/parser/testdata/corpus/sql/storage/types/variant/variant_index.test b/parser/testdata/corpus/sql/storage/types/variant/variant_index.test new file mode 100644 index 0000000..fd5a8a9 --- /dev/null +++ b/parser/testdata/corpus/sql/storage/types/variant/variant_index.test @@ -0,0 +1,17 @@ +# source: test/sql/storage/types/variant/variant_index.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +CREATE TABLE tbl(col VARIANT UNIQUE, b INTEGER) +-- +ok +== +INSERT into tbl select {'a': i, 'b': i % 5} col, i from range(1000) t(i) +-- +ok +== +select b from tbl where col == {'b': 2, 'a': 2} +-- +ok +== diff --git a/parser/testdata/corpus/sql/storage/types/variant/variant_null_missing.test b/parser/testdata/corpus/sql/storage/types/variant/variant_null_missing.test new file mode 100644 index 0000000..07bb0a7 --- /dev/null +++ b/parser/testdata/corpus/sql/storage/types/variant/variant_null_missing.test @@ -0,0 +1,73 @@ +# source: test/sql/storage/types/variant/variant_null_missing.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +SET force_variant_shredding = 'STRUCT(a INT, b INT)'; +-- +ok +== +create table shredded_values (col VARIANT) +-- +ok +== +insert into shredded_values values + ({'a': 1, 'b': 100}), + ({'a': 10, 'b': NULL}), + ({'a': 100}), + ({'a': NULL, 'b': NULL}) +; +-- +ok +== +FROM shredded_values +-- +ok +== +SET force_variant_shredding = 'STRUCT(id INT, s STRUCT(a INT, b INT))'; +-- +ok +== +create table nested_shredded_values (col VARIANT) +-- +ok +== +insert into nested_shredded_values values + ({'id': 1, 's': {'a': 1, 'b': 100}}), + ({'id': 2, 's': {'a': 10, 'b': NULL}}), + ({'id': 3, 's': {'a': 100}}), + ({'id': 4, 's': {'a': NULL, 'b': NULL}}), + ({'id': 5, 's': NULL}), + ({'id': 6}) +; +-- +ok +== +FROM nested_shredded_values +-- +ok +== +SET force_variant_shredding = 'STRUCT(a INT, b INT)[]'; +-- +ok +== +create table shredded_array (col VARIANT) +-- +ok +== +insert into shredded_array values + ([{'a': 1, 'b': 100}]), + ([{'a': 10, 'b': NULL}]), + ([{'a': 100}]), + ([{'a': NULL, 'b': NULL}]), + ([]), + ([NULL]), + (NULL) +; +-- +ok +== +FROM shredded_array +-- +ok +== diff --git a/parser/testdata/corpus/sql/storage/types/variant/variant_null_shredding_inconsistency_issue.test b/parser/testdata/corpus/sql/storage/types/variant/variant_null_shredding_inconsistency_issue.test new file mode 100644 index 0000000..a33dd44 --- /dev/null +++ b/parser/testdata/corpus/sql/storage/types/variant/variant_null_shredding_inconsistency_issue.test @@ -0,0 +1,28 @@ +# source: test/sql/storage/types/variant/variant_null_shredding_inconsistency_issue.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +CREATE TABLE messages AS +SELECT ( + CASE + WHEN i % 100 = 0 THEN '{"action": "block", "extra_field": null}' + ELSE '{"action": "build"}' + END +)::JSON AS msg_json +FROM range(10000) t(i); +-- +ok +== +ALTER TABLE messages ADD COLUMN msg VARIANT; +-- +ok +== +UPDATE messages SET msg = msg_json::VARIANT; +-- +ok +== +select count(*) from messages where msg.action::VARCHAR = 'block'; +-- +ok +== diff --git a/parser/testdata/corpus/sql/storage/types/variant/variant_shredded_extract_non_object.test b/parser/testdata/corpus/sql/storage/types/variant/variant_shredded_extract_non_object.test new file mode 100644 index 0000000..fdc735c --- /dev/null +++ b/parser/testdata/corpus/sql/storage/types/variant/variant_shredded_extract_non_object.test @@ -0,0 +1,26 @@ +# source: test/sql/storage/types/variant/variant_shredded_extract_non_object.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +create table t( + col struct( + f1 integer, + f2 VARIANT + ) +); +-- +ok +== +insert into t select { + 'f1': 1 +}; +-- +ok +== +select + col.f2.a::integer +from t; +-- +ok +== diff --git a/parser/testdata/corpus/sql/storage/types/variant/variant_shredded_slice.test b/parser/testdata/corpus/sql/storage/types/variant/variant_shredded_slice.test new file mode 100644 index 0000000..c3dfb12 --- /dev/null +++ b/parser/testdata/corpus/sql/storage/types/variant/variant_shredded_slice.test @@ -0,0 +1,30 @@ +# source: test/sql/storage/types/variant/variant_shredded_slice.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +create table bluesky (j VARIANT) +-- +ok +== +insert into bluesky select + case when i%3=0 + then {'kind':'commit','did':'c'|| (i%4),'commit':{'collection':'coll'|| (i%2),'operation':'create'}}::VARIANT + else {'kind':'identity','did':'d'|| (i%5)}::VARIANT + end +from range(4096) t(i) +-- +ok +== +SELECT count(DISTINCT j.did), count(*) FROM bluesky; +-- +ok +== +SELECT j.commit.collection AS event, count() AS count, count(DISTINCT j.did) AS users +FROM bluesky +WHERE (j.kind = 'commit') AND (j.commit.operation = 'create') +GROUP BY event +ORDER BY count DESC, event +-- +ok +== diff --git a/parser/testdata/corpus/sql/storage/types/variant/variant_shredding_empty_keys.test b/parser/testdata/corpus/sql/storage/types/variant/variant_shredding_empty_keys.test new file mode 100644 index 0000000..6fd8643 --- /dev/null +++ b/parser/testdata/corpus/sql/storage/types/variant/variant_shredding_empty_keys.test @@ -0,0 +1,25 @@ +# source: test/sql/storage/types/variant/variant_shredding_empty_keys.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +SET variant_minimum_shredding_size=0; +-- +ok +== +create table succeeds as SELECT '{"": 1, "x": {"y": "t"}}'::JSON::VARIANT; +-- +ok +== +select * from succeeds; +-- +ok +== +create table fails as SELECT '{"x": "hello", "": "world"}'::JSON::VARIANT AS j; +-- +ok +== +select * from fails; +-- +ok +== diff --git a/parser/testdata/corpus/sql/storage/types/variant/variant_shredding_inconsistent.test b/parser/testdata/corpus/sql/storage/types/variant/variant_shredding_inconsistent.test new file mode 100644 index 0000000..066ea9a --- /dev/null +++ b/parser/testdata/corpus/sql/storage/types/variant/variant_shredding_inconsistent.test @@ -0,0 +1,23 @@ +# source: test/sql/storage/types/variant/variant_shredding_inconsistent.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +create table bluesky (col VARIANT) +-- +ok +== +insert into bluesky from read_ndjson_objects('{DATA_DIR}/json/bluesky.json.gz') +-- +ok +== +SELECT STRING_AGG(CASE WHEN v=j THEN NULL ELSE CONCAT('v: ', v, ' +j: ', j) END, ' +') +FROM ( + SELECT variant_normalize(col)::JSON AS v, variant_normalize(json::VARIANT)::JSON AS j + FROM bluesky POSITIONAL JOIN read_ndjson_objects('{DATA_DIR}/json/bluesky.json.gz') +) +-- +ok +== diff --git a/parser/testdata/corpus/sql/storage/types/variant/variant_shredding_omit_untyped.test b/parser/testdata/corpus/sql/storage/types/variant/variant_shredding_omit_untyped.test new file mode 100644 index 0000000..0f780df --- /dev/null +++ b/parser/testdata/corpus/sql/storage/types/variant/variant_shredding_omit_untyped.test @@ -0,0 +1,25 @@ +# source: test/sql/storage/types/variant/variant_shredding_omit_untyped.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +create table shredded_integer (col VARIANT) +-- +ok +== +insert into shredded_integer select (i % 100)::INTEGER from range(100) t(i) +-- +ok +== +SELECT COUNT(*) FROM pragma_storage_info('shredded_integer') WHERE column_path = '[0, 2, 2]' +-- +ok +== +SELECT SUM(TRY_CAST(col AS INT)), COUNT(*) FROM shredded_integer +-- +ok +== +insert into shredded_integer values ('hello world'); +-- +ok +== diff --git a/parser/testdata/corpus/sql/storage/types/variant/variant_shredding_small.test b/parser/testdata/corpus/sql/storage/types/variant/variant_shredding_small.test new file mode 100644 index 0000000..67fad48 --- /dev/null +++ b/parser/testdata/corpus/sql/storage/types/variant/variant_shredding_small.test @@ -0,0 +1,33 @@ +# source: test/sql/storage/types/variant/variant_shredding_small.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +create table tbl (id INT PRIMARY KEY, col VARIANT) +-- +ok +== +insert into tbl select i id, {'i': i, 'j': i * 100} FROm range(5) t(i); +-- +ok +== +SELECT col FROM tbl +-- +ok +== +SELECT col.j FROM tbl +-- +ok +== +SELECT col.j::INT FROM tbl +-- +ok +== +SELECT col FROM tbl WHERE id=3 +-- +ok +== +SELECT col FROM tbl WHERE col.i=3 +-- +ok +== diff --git a/parser/testdata/corpus/sql/storage/types/variant/variant_storage_version.test b/parser/testdata/corpus/sql/storage/types/variant/variant_storage_version.test new file mode 100644 index 0000000..9477958 --- /dev/null +++ b/parser/testdata/corpus/sql/storage/types/variant/variant_storage_version.test @@ -0,0 +1,33 @@ +# source: test/sql/storage/types/variant/variant_storage_version.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +attach '{TEST_DIR}/variant.db' (STORAGE_VERSION 'v1.4.4'); +-- +ok +== +use variant; +-- +ok +== +create table t1 (v VARIANT); +-- +ok +== +create table t2 as select '1'::VARIANT v; +-- +ok +== +create table t3 (i INT); +-- +ok +== +alter table t3 add column v VARIANT; +-- +ok +== +alter table t3 alter column i set type VARIANT; +-- +ok +== diff --git a/parser/testdata/corpus/sql/storage/unzip.test b/parser/testdata/corpus/sql/storage/unzip.test new file mode 100644 index 0000000..0c167cb --- /dev/null +++ b/parser/testdata/corpus/sql/storage/unzip.test @@ -0,0 +1,13 @@ +# source: test/sql/storage/unzip.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +SELECT a+1 FROM tbl; +-- +ok +== +SELECT a+2 FROM tbl; +-- +ok +== diff --git a/parser/testdata/corpus/sql/storage/update/dictionary_update_null.test b/parser/testdata/corpus/sql/storage/update/dictionary_update_null.test new file mode 100644 index 0000000..923de70 --- /dev/null +++ b/parser/testdata/corpus/sql/storage/update/dictionary_update_null.test @@ -0,0 +1,22 @@ +# source: test/sql/storage/update/dictionary_update_null.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +SET force_compression='dictionary' +-- +ok +== +CREATE OR REPLACE TABLE 'everflow_daily' AS SELECT case when i%10=0 THEN uuid()::VARCHAR ELSE 'N/A' END sub4 FROM range(10000) t(i) +-- +ok +== +UPDATE everflow_daily SET sub4 = NULL WHERE sub4 = 'N/A'; +-- +ok +== +select count(*) from everflow_daily +where sub4 = 'N/A' +-- +ok +== diff --git a/parser/testdata/corpus/sql/storage/update/test_store_null_updates.test b/parser/testdata/corpus/sql/storage/update/test_store_null_updates.test new file mode 100644 index 0000000..d737831 --- /dev/null +++ b/parser/testdata/corpus/sql/storage/update/test_store_null_updates.test @@ -0,0 +1,17 @@ +# source: test/sql/storage/update/test_store_null_updates.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +INSERT INTO test VALUES (11, 22), (NULL, 22), (12, 21) +-- +ok +== +UPDATE test SET b=b+1 WHERE a=11 +-- +ok +== +UPDATE test SET b=NULL WHERE a=11 +-- +ok +== diff --git a/parser/testdata/corpus/sql/storage/update/wal_restart_update_insert.test b/parser/testdata/corpus/sql/storage/update/wal_restart_update_insert.test new file mode 100644 index 0000000..93d9b4e --- /dev/null +++ b/parser/testdata/corpus/sql/storage/update/wal_restart_update_insert.test @@ -0,0 +1,33 @@ +# source: test/sql/storage/update/wal_restart_update_insert.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +CREATE TABLE test(i INTEGER PRIMARY KEY, j INTEGER); +-- +ok +== +INSERT INTO test SELECT r, r FROM range(2000) t(r); +-- +ok +== +SET checkpoint_threshold='1TB' +-- +ok +== +INSERT INTO test SELECT r, r FROM range(2000,200000) t(r) +-- +ok +== +UPDATE test SET j=j+1 +-- +ok +== +INSERT INTO test SELECT r, r FROM range(200000,400000) t(r) +-- +ok +== +select count(*) FROM test +-- +ok +== diff --git a/parser/testdata/corpus/sql/storage/wal/wal_autocheckpoint_entries.test b/parser/testdata/corpus/sql/storage/wal/wal_autocheckpoint_entries.test new file mode 100644 index 0000000..3eff376 --- /dev/null +++ b/parser/testdata/corpus/sql/storage/wal/wal_autocheckpoint_entries.test @@ -0,0 +1,101 @@ +# source: test/sql/storage/wal/wal_autocheckpoint_entries.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +ATTACH '{TEST_DIR}/wal_autocheckpoint.db' AS autocheckpoint_db; +-- +ok +== +CREATE TABLE autocheckpoint_db.tbl(x INTEGER); +-- +ok +== +CREATE TABLE autocheckpoint_db.delete_tbl(x INTEGER); +-- +ok +== +INSERT INTO autocheckpoint_db.delete_tbl SELECT * FROM range(100); +-- +ok +== +CHECKPOINT autocheckpoint_db; +-- +ok +== +SELECT wal_size FROM pragma_database_size() WHERE database_name = 'autocheckpoint_db'; +-- +ok +== +SET wal_autocheckpoint_entries=100; +-- +ok +== +INSERT INTO autocheckpoint_db.tbl VALUES ({i}); +-- +error: Parser Error: syntax error at or near "}" +== +DELETE FROM autocheckpoint_db.delete_tbl WHERE x = {i}; +-- +error: Parser Error: syntax error at or near "}" +== +SELECT wal_size != '0 bytes' FROM pragma_database_size() WHERE database_name = 'autocheckpoint_db'; +-- +ok +== +INSERT INTO autocheckpoint_db.tbl VALUES (9999); +-- +ok +== +SELECT COUNT(*) FROM autocheckpoint_db.tbl; +-- +ok +== +DETACH autocheckpoint_db; +-- +ok +== +SET wal_autocheckpoint_entries=0; +-- +ok +== +ATTACH '{TEST_DIR}/wal_entry_count.db' AS entry_count_db; +-- +ok +== +CREATE TABLE entry_count_db.tbl(x INTEGER); +-- +ok +== +CREATE TABLE entry_count_db.delete_tbl(x INTEGER); +-- +ok +== +INSERT INTO entry_count_db.delete_tbl SELECT * FROM range(10000); +-- +ok +== +CHECKPOINT entry_count_db; +-- +ok +== +INSERT INTO entry_count_db.tbl VALUES ({i}); +-- +error: Parser Error: syntax error at or near "}" +== +DELETE FROM entry_count_db.delete_tbl WHERE x = {i}; +-- +error: Parser Error: syntax error at or near "}" +== +DETACH entry_count_db; +-- +ok +== +SET tracked_metrics = ['storage.wal_replay_entry_count']; +-- +ok +== +SELECT storage.wal_replay_entry_count FROM replay_metrics; +-- +ok +== diff --git a/parser/testdata/corpus/sql/storage/wal/wal_create_index.test b/parser/testdata/corpus/sql/storage/wal/wal_create_index.test new file mode 100644 index 0000000..e3e05e0 --- /dev/null +++ b/parser/testdata/corpus/sql/storage/wal/wal_create_index.test @@ -0,0 +1,41 @@ +# source: test/sql/storage/wal/wal_create_index.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +INSERT INTO integers VALUES (1, 1), (2, 2), (3, 3); +-- +ok +== +EXPLAIN ANALYZE SELECT i, j FROM integers WHERE i = 1; +-- +ok +== +SELECT i, j FROM integers WHERE i = 1; +-- +ok +== +INSERT INTO integers VALUES (1, 1); +-- +ok +== +CREATE UNIQUE INDEX i_index ON integers USING art((i + j)); +-- +ok +== +SELECT i, j FROM integers WHERE i + j = 2; +-- +ok +== +CREATE UNIQUE INDEX i_index ON integers USING art((j + i)); +-- +ok +== +SELECT i, j FROM integers WHERE j + i = 2; +-- +ok +== +CREATE UNIQUE INDEX i_index ON integers USING art((j + i), j, i); +-- +ok +== diff --git a/parser/testdata/corpus/sql/storage/wal/wal_create_insert_drop.test b/parser/testdata/corpus/sql/storage/wal/wal_create_insert_drop.test new file mode 100644 index 0000000..85b74d6 --- /dev/null +++ b/parser/testdata/corpus/sql/storage/wal/wal_create_insert_drop.test @@ -0,0 +1,49 @@ +# source: test/sql/storage/wal/wal_create_insert_drop.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +SET checkpoint_threshold='999999GB'; +-- +ok +== +create table bla as select 42; +-- +ok +== +drop table bla; +-- +ok +== +create table bla as select 84; +-- +ok +== +SELECT * FROM bla +-- +ok +== +drop table bla +-- +ok +== +alter table bla rename to bla2 +-- +ok +== +from bla2 +-- +ok +== +create or replace table bla as select 84; +-- +ok +== +create or replace table bla as select 42; +-- +ok +== +from bla +-- +ok +== diff --git a/parser/testdata/corpus/sql/storage/wal/wal_index_delete.test b/parser/testdata/corpus/sql/storage/wal/wal_index_delete.test new file mode 100644 index 0000000..b8235d3 --- /dev/null +++ b/parser/testdata/corpus/sql/storage/wal/wal_index_delete.test @@ -0,0 +1,53 @@ +# source: test/sql/storage/wal/wal_index_delete.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +CREATE TABLE tbl(a INTEGER, b VARCHAR, c DOUBLE, d TIMESTAMP); +-- +ok +== +CREATE INDEX idx_ab ON tbl(a, b); +-- +ok +== +CREATE INDEX idx_a ON tbl(a); +-- +ok +== +INSERT INTO tbl SELECT range, 'value_' || range, range * 1.5, '2023-01-01 10:00:00'::TIMESTAMP + INTERVAL (range) DAY FROM range(10); +-- +ok +== +DELETE FROM tbl WHERE a % 5 = 0; +-- +ok +== +EXPLAIN ANALYZE SELECT a, b, c, d FROM tbl WHERE (a) = 1; +-- +ok +== +SELECT a, b, c, d FROM tbl WHERE (a) = 1; +-- +ok +== +EXPLAIN ANALYZE SELECT a, b, c, d FROM tbl WHERE (a) = 5; +-- +ok +== +SELECT a, b, c, d FROM tbl WHERE (a) = 5; +-- +ok +== +INSERT INTO tbl VALUES (5, 'value_5', 7.5, '2023-01-06 10:00:00'); +-- +ok +== +EXPLAIN ANALYZE SELECT a, b, c, d FROM tbl WHERE (a) = 2; +-- +ok +== +SELECT COUNT(*) FROM tbl where (a) = 2; +-- +ok +== diff --git a/parser/testdata/corpus/sql/storage/wal/wal_index_delete_gen.test b/parser/testdata/corpus/sql/storage/wal/wal_index_delete_gen.test new file mode 100644 index 0000000..62ae855 --- /dev/null +++ b/parser/testdata/corpus/sql/storage/wal/wal_index_delete_gen.test @@ -0,0 +1,37 @@ +# source: test/sql/storage/wal/wal_index_delete_gen.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +CREATE TABLE tbl(a BIGINT, b INT AS (2*a), c VARCHAR, d DOUBLE, e as (d + 2), f TIMESTAMP); +-- +ok +== +CREATE INDEX idx_cd ON tbl(c,d); +-- +ok +== +CREATE INDEX idx_df ON tbl(d, f) +-- +ok +== +INSERT INTO tbl VALUES (1, 'foo', 10.5, '2023-01-01 10:00:00'), (2, 'bar', 20.5, '2023-02-01 11:00:00'), (3, 'baz', 30.5, '2023-03-01 12:00:00'); +-- +ok +== +SELECT a, b, c, d, e, f FROM tbl ORDER BY a; +-- +ok +== +DELETE FROM tbl WHERE a in (2); +-- +ok +== +INSERT INTO tbl VALUES (1, 'foo', 10.5, '2023-01-01 10:00:00') +-- +ok +== +SELECT b, e FROM tbl WHERE (c,d) = ('baz', 30.5) +-- +ok +== diff --git a/parser/testdata/corpus/sql/storage/wal/wal_index_interleaved.test b/parser/testdata/corpus/sql/storage/wal/wal_index_interleaved.test new file mode 100644 index 0000000..3c54d0c --- /dev/null +++ b/parser/testdata/corpus/sql/storage/wal/wal_index_interleaved.test @@ -0,0 +1,61 @@ +# source: test/sql/storage/wal/wal_index_interleaved.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +INSERT INTO tbl VALUES ({i} * 10); +-- +error: Parser Error: syntax error at or near "}" +== +DELETE FROM tbl WHERE a = {i} * 10 AND ({i} * 10) % 30 = 0; +-- +error: Parser Error: syntax error at or near "}" +== +EXPLAIN ANALYZE SELECT * FROM tbl WHERE a = 10; +-- +ok +== +EXPLAIN ANALYZE SELECT * FROM tbl WHERE a = 0; +-- +ok +== +SELECT * FROM tbl WHERE a = 0; +-- +ok +== +EXPLAIN ANALYZE SELECT * FROM tbl WHERE a = {i} * 10; +-- +error: Parser Error: syntax error at or near "}" +== +SELECT * FROM tbl WHERE a = 10; +-- +ok +== +SELECT * FROM tbl WHERE a = 70; +-- +ok +== +SELECT * FROM tbl WHERE a = 140; +-- +ok +== +SELECT * FROM tbl WHERE a = 30; +-- +ok +== +SELECT * FROM tbl WHERE a = 90; +-- +ok +== +INSERT INTO tbl VALUES (150); +-- +ok +== +EXPLAIN ANALYZE SELECT * FROM tbl WHERE a = 150; +-- +ok +== +SELECT * FROM tbl WHERE a = 150; +-- +ok +== diff --git a/parser/testdata/corpus/sql/storage/wal/wal_index_large_batch_interleaved.test b/parser/testdata/corpus/sql/storage/wal/wal_index_large_batch_interleaved.test new file mode 100644 index 0000000..5a19a8d --- /dev/null +++ b/parser/testdata/corpus/sql/storage/wal/wal_index_large_batch_interleaved.test @@ -0,0 +1,25 @@ +# source: test/sql/storage/wal/wal_index_large_batch_interleaved.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +INSERT INTO tbl SELECT r FROM range({i}*10000, {i}*10000 + 5120) t(r); +-- +error: Parser Error: syntax error at or near "}" +== +DELETE FROM tbl WHERE a >= {i}*10000 AND a <= {i}*10000 + 5000; +-- +error: Parser Error: syntax error at or near "}" +== +EXPLAIN ANALYZE SELECT * FROM tbl WHERE a = 25010; +-- +ok +== +SELECT * FROM tbl WHERE a = 25010; +-- +ok +== +SELECT * FROM tbl WHERE a = 24999; +-- +ok +== diff --git a/parser/testdata/corpus/sql/storage/wal/wal_index_replay.test b/parser/testdata/corpus/sql/storage/wal/wal_index_replay.test new file mode 100644 index 0000000..9af1b09 --- /dev/null +++ b/parser/testdata/corpus/sql/storage/wal/wal_index_replay.test @@ -0,0 +1,29 @@ +# source: test/sql/storage/wal/wal_index_replay.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +INSERT INTO tbl SELECT range FROM range(100); +-- +ok +== +INSERT INTO tbl SELECT range + 100 FROM range(50); +-- +ok +== +EXPLAIN ANALYZE SELECT * FROM tbl WHERE a = 1; +-- +ok +== +SELECT * FROM tbl WHERE a = 1; +-- +ok +== +EXPLAIN ANALYZE SELECT * FROM tbl WHERE a = 5; +-- +ok +== +SELECT * FROM tbl WHERE a = 5; +-- +ok +== diff --git a/parser/testdata/corpus/sql/storage/wal/wal_lazy_creation.test b/parser/testdata/corpus/sql/storage/wal/wal_lazy_creation.test new file mode 100644 index 0000000..16fcaa5 --- /dev/null +++ b/parser/testdata/corpus/sql/storage/wal/wal_lazy_creation.test @@ -0,0 +1,13 @@ +# source: test/sql/storage/wal/wal_lazy_creation.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +ATTACH '{TEST_DIR}/attach_no_wal.db'; +-- +ok +== +SELECT COUNT(*) FROM glob('{TEST_DIR}/attach_no_wal.db.wal'); +-- +ok +== diff --git a/parser/testdata/corpus/sql/storage/wal/wal_null_update_row_group_pruning.test b/parser/testdata/corpus/sql/storage/wal/wal_null_update_row_group_pruning.test new file mode 100644 index 0000000..47ea1e5 --- /dev/null +++ b/parser/testdata/corpus/sql/storage/wal/wal_null_update_row_group_pruning.test @@ -0,0 +1,37 @@ +# source: test/sql/storage/wal/wal_null_update_row_group_pruning.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +CREATE TABLE test AS SELECT i::BIGINT AS a FROM range(2048) tbl(i); +-- +ok +== +CREATE TABLE distinct_test AS SELECT 1::BIGINT AS a FROM range(2048); +-- +ok +== +UPDATE test SET a = NULL WHERE a = 3; +-- +ok +== +UPDATE distinct_test SET a = NULL WHERE rowid = 3; +-- +ok +== +SELECT count(*) FROM test WHERE a IS NULL; +-- +ok +== +SELECT count(*) FROM distinct_test WHERE a IS DISTINCT FROM 1; +-- +ok +== +SELECT count(*) FROM test WHERE CASE WHEN a IS NULL THEN true ELSE false END; +-- +ok +== +SELECT count(*) FROM distinct_test WHERE CASE WHEN a IS DISTINCT FROM 1 THEN true ELSE false END; +-- +ok +== diff --git a/parser/testdata/corpus/sql/storage/wal/wal_promote_version.test b/parser/testdata/corpus/sql/storage/wal/wal_promote_version.test new file mode 100644 index 0000000..71ce086 --- /dev/null +++ b/parser/testdata/corpus/sql/storage/wal/wal_promote_version.test @@ -0,0 +1,25 @@ +# source: test/sql/storage/wal/wal_promote_version.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +ATTACH '{TEST_DIR}/wal_promote.db'; +-- +ok +== +CREATE TABLE wal_promote.T AS (FROM range(10)); +-- +ok +== +DETACH wal_promote; +-- +ok +== +ATTACH '{TEST_DIR}/wal_promote.db' (STORAGE_VERSION 'latest'); +-- +ok +== +INSERT INTO wal_promote.T VALUES (42); +-- +ok +== diff --git a/parser/testdata/corpus/sql/storage/wal/wal_replay_consistency_add_column_current_timestamp.test b/parser/testdata/corpus/sql/storage/wal/wal_replay_consistency_add_column_current_timestamp.test new file mode 100644 index 0000000..66e0ce8 --- /dev/null +++ b/parser/testdata/corpus/sql/storage/wal/wal_replay_consistency_add_column_current_timestamp.test @@ -0,0 +1,41 @@ +# source: test/sql/storage/wal/wal_replay_consistency_add_column_current_timestamp.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +ATTACH '{TEST_DIR}/wal_replay.db'; +-- +ok +== +USE wal_replay; +-- +ok +== +CREATE TABLE t AS SELECT range::INT AS id FROM range(10); +-- +ok +== +ALTER TABLE t ADD COLUMN d TIMESTAMP WITH TIME ZONE DEFAULT CURRENT_TIMESTAMP; +-- +ok +== +CREATE TABLE original AS SELECT d FROM t; +-- +ok +== +DETACH wal_replay; +-- +ok +== +select COUNT(d) != 0 from t; +-- +ok +== +select d from t; +-- +ok +== +select d from original; +-- +ok +== diff --git a/parser/testdata/corpus/sql/storage/wal/wal_replay_consistency_add_column_random.test b/parser/testdata/corpus/sql/storage/wal/wal_replay_consistency_add_column_random.test new file mode 100644 index 0000000..f9ade6e --- /dev/null +++ b/parser/testdata/corpus/sql/storage/wal/wal_replay_consistency_add_column_random.test @@ -0,0 +1,25 @@ +# source: test/sql/storage/wal/wal_replay_consistency_add_column_random.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +ALTER TABLE t ADD COLUMN r DOUBLE DEFAULT RANDOM(); +-- +ok +== +CREATE TABLE original AS SELECT id, r FROM t; +-- +ok +== +select COUNT(r) != 0 from t; +-- +ok +== +select r from t; +-- +ok +== +select r from original; +-- +ok +== diff --git a/parser/testdata/corpus/sql/storage/wal/wal_replay_unbound_index_create_index_during_wal.test b/parser/testdata/corpus/sql/storage/wal/wal_replay_unbound_index_create_index_during_wal.test new file mode 100644 index 0000000..eedb28d --- /dev/null +++ b/parser/testdata/corpus/sql/storage/wal/wal_replay_unbound_index_create_index_during_wal.test @@ -0,0 +1,53 @@ +# source: test/sql/storage/wal/wal_replay_unbound_index_create_index_during_wal.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +SET checkpoint_threshold='999999GB' +-- +ok +== +CREATE TABLE t(a BIGINT, b VARCHAR) +-- +ok +== +CREATE INDEX i1 ON t(b) +-- +ok +== +INSERT INTO t VALUES (1, 'one') +-- +ok +== +CREATE INDEX i2 ON t(a) +-- +ok +== +INSERT INTO t VALUES (2, 'two') +-- +ok +== +SET index_scan_percentage=1 +-- +ok +== +SET index_scan_max_count=999999999 +-- +ok +== +SELECT count(*) FROM t WHERE b='one' +-- +ok +== +SELECT count(*) FROM t WHERE b='two' +-- +ok +== +SELECT count(*) FROM t WHERE a=1 +-- +ok +== +SELECT count(*) FROM t WHERE a=2 +-- +ok +== diff --git a/parser/testdata/corpus/sql/storage/wal/wal_replay_unbound_index_generated_column.test b/parser/testdata/corpus/sql/storage/wal/wal_replay_unbound_index_generated_column.test new file mode 100644 index 0000000..e4ea882 --- /dev/null +++ b/parser/testdata/corpus/sql/storage/wal/wal_replay_unbound_index_generated_column.test @@ -0,0 +1,33 @@ +# source: test/sql/storage/wal/wal_replay_unbound_index_generated_column.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +CREATE TABLE t(a INTEGER, g AS (a + 1), b VARCHAR) +-- +ok +== +CREATE INDEX i ON t(b) +-- +ok +== +INSERT INTO t SELECT v, 'x' || v FROM range(122880) r(v) +-- +ok +== +INSERT INTO t VALUES (7, 'y') +-- +ok +== +SELECT count(*) FROM t WHERE b='y' +-- +ok +== +SELECT count(*) FROM t WHERE b='x123' +-- +ok +== +SELECT g, b FROM t WHERE b='y' +-- +ok +== diff --git a/parser/testdata/corpus/sql/storage/wal/wal_replay_unbound_index_mixed_inserts.test b/parser/testdata/corpus/sql/storage/wal/wal_replay_unbound_index_mixed_inserts.test new file mode 100644 index 0000000..2dd26dc --- /dev/null +++ b/parser/testdata/corpus/sql/storage/wal/wal_replay_unbound_index_mixed_inserts.test @@ -0,0 +1,45 @@ +# source: test/sql/storage/wal/wal_replay_unbound_index_mixed_inserts.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +CREATE TABLE t(b TIMESTAMP, a VARCHAR) +-- +ok +== +CREATE INDEX i ON t(a) +-- +ok +== +INSERT INTO t SELECT TIMESTAMP '2026-01-01' + INTERVAL (v) SECOND, 'x' || v FROM range(122880) r(v) +-- +ok +== +INSERT INTO t VALUES (TIMESTAMP '2026-02-01', 'y') +-- +ok +== +SELECT count(*) FROM t WHERE a='y' +-- +ok +== +SELECT count(*) FROM t WHERE a='x123' +-- +ok +== +INSERT INTO t VALUES (TIMESTAMP '2026-03-01', 'w') +-- +ok +== +INSERT INTO t SELECT TIMESTAMP '2026-04-01' + INTERVAL (v) SECOND, 'z' || v FROM range(122880) r(v) +-- +ok +== +SELECT count(*) FROM t WHERE a='w' +-- +ok +== +SELECT count(*) FROM t WHERE a='z123' +-- +ok +== diff --git a/parser/testdata/corpus/sql/storage/wal/wal_replay_unbound_index_multi_index.test b/parser/testdata/corpus/sql/storage/wal/wal_replay_unbound_index_multi_index.test new file mode 100644 index 0000000..446bdce --- /dev/null +++ b/parser/testdata/corpus/sql/storage/wal/wal_replay_unbound_index_multi_index.test @@ -0,0 +1,49 @@ +# source: test/sql/storage/wal/wal_replay_unbound_index_multi_index.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +CREATE TABLE t(a INTEGER, b VARCHAR, c INTEGER) +-- +ok +== +CREATE INDEX i2 ON t(c) +-- +ok +== +CREATE INDEX i3 ON t(upper(b)) +-- +ok +== +INSERT INTO t SELECT v, 'x' || v, v + 1000000 FROM range(123000) r(v) +-- +ok +== +INSERT INTO t VALUES (999999999, 'y', 999) +-- +ok +== +DELETE FROM t WHERE b='x7' +-- +ok +== +SELECT count(*) FROM t WHERE b='x7' +-- +ok +== +SELECT count(*) FROM t WHERE c=999 +-- +ok +== +SELECT count(*) FROM t WHERE c=1000007 +-- +ok +== +SELECT count(*) FROM t WHERE upper(b)='Y' +-- +ok +== +SELECT count(*) FROM t WHERE upper(b)='X7' +-- +ok +== diff --git a/parser/testdata/corpus/sql/storage/wal/wal_replay_with_function.test b/parser/testdata/corpus/sql/storage/wal/wal_replay_with_function.test new file mode 100644 index 0000000..c608618 --- /dev/null +++ b/parser/testdata/corpus/sql/storage/wal/wal_replay_with_function.test @@ -0,0 +1,21 @@ +# source: test/sql/storage/wal/wal_replay_with_function.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +CREATE TABLE test (id INTEGER); +-- +ok +== +ALTER TABLE test ADD COLUMN r double DEFAULT pi(); +-- +ok +== +ALTER TABLE test ADD COLUMN data BIGINT DEFAULT length('duck'); +-- +ok +== +from test; +-- +ok +== diff --git a/parser/testdata/corpus/sql/storage/wal/wal_storage_types.test b/parser/testdata/corpus/sql/storage/wal/wal_storage_types.test new file mode 100644 index 0000000..596743e --- /dev/null +++ b/parser/testdata/corpus/sql/storage/wal/wal_storage_types.test @@ -0,0 +1,55 @@ +# source: test/sql/storage/wal/wal_storage_types.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +SELECT MIN(i), MAX(i), COUNT(*), COUNT(i) FROM a_{type} WHERE i=1 +-- +error: Parser Error: syntax error at or near "{" +== +SELECT MIN(i), MAX(i), COUNT(*), COUNT(i) FROM a_interval WHERE i=interval 1 year +-- +ok +== +CREATE TABLE a_bool AS SELECT range%2=0 i FROM range(1000) +-- +ok +== +SELECT MIN(i), MAX(i), COUNT(*), COUNT(i) FROM a_bool WHERE not i +-- +ok +== +CREATE TABLE person ( + name text, + current_mood mood +); +-- +ok +== +INSERT INTO person VALUES ('Moe', 'happy'); +-- +ok +== +select * from person +-- +ok +== +begin transaction +-- +ok +== +drop table person; +-- +ok +== +drop TYPE mood; +-- +ok +== +CREATE TABLE aliens ( + name text, + current_mood mood +); +-- +ok +== diff --git a/parser/testdata/corpus/sql/storage/wal/wal_store_mixed_updates_big.test b/parser/testdata/corpus/sql/storage/wal/wal_store_mixed_updates_big.test new file mode 100644 index 0000000..684f5ff --- /dev/null +++ b/parser/testdata/corpus/sql/storage/wal/wal_store_mixed_updates_big.test @@ -0,0 +1,49 @@ +# source: test/sql/storage/wal/wal_store_mixed_updates_big.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +CREATE TABLE test AS SELECT -i a, -i b FROM range(100000) tbl(i) +-- +ok +== +INSERT INTO test SELECT i+1 a, i+1 b FROM range(1000) tbl(i) +-- +ok +== +SELECT COUNT(*), SUM(a), SUM(b), MIN(a), MAX(a), MIN(b), MAX(b) FROM test WHERE a>0 +-- +ok +== +SELECT COUNT(*) FROM test WHERE a>0 +-- +ok +== +SELECT COUNT(*) FROM test WHERE a>0 AND a<>b +-- +ok +== +SELECT SUM(CASE WHEN b IS NULL THEN 1 ELSE 0 END) FROM test WHERE a>0 AND a%2=0 +-- +ok +== +UPDATE test SET b=b+1 WHERE a>0 AND a%2=0 +-- +ok +== +SELECT * FROM test WHERE a>0 ORDER BY 1,2 +-- +ok +== +SELECT COUNT(*) FROM test WHERE a>0 AND a%2=0 +-- +ok +== +SELECT COUNT(*) FROM test WHERE a IS NULL OR b IS NULL +-- +ok +== +UPDATE test SET b=NULL WHERE a>0 AND a%2=1 +-- +ok +== diff --git a/parser/testdata/corpus/sql/storage/wal/wal_store_mixed_updates_big_null.test b/parser/testdata/corpus/sql/storage/wal/wal_store_mixed_updates_big_null.test new file mode 100644 index 0000000..8582e87 --- /dev/null +++ b/parser/testdata/corpus/sql/storage/wal/wal_store_mixed_updates_big_null.test @@ -0,0 +1,17 @@ +# source: test/sql/storage/wal/wal_store_mixed_updates_big_null.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +UPDATE test SET b=NULL WHERE a>0 AND a%2=0 +-- +ok +== +SELECT COUNT(*) FROM test WHERE a>0 AND b IS NULL +-- +ok +== +SELECT COUNT(*), SUM(a), SUM(b), MIN(a), MAX(a), MIN(b), MAX(b), COUNT(b) FROM test WHERE a>0 +-- +ok +== diff --git a/parser/testdata/corpus/sql/storage/wal/wal_store_sequences.test b/parser/testdata/corpus/sql/storage/wal/wal_store_sequences.test new file mode 100644 index 0000000..395377a --- /dev/null +++ b/parser/testdata/corpus/sql/storage/wal/wal_store_sequences.test @@ -0,0 +1,9 @@ +# source: test/sql/storage/wal/wal_store_sequences.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +SELECT nextval('seq2') +-- +ok +== diff --git a/parser/testdata/corpus/sql/storage/wal/wal_store_updates_big.test b/parser/testdata/corpus/sql/storage/wal/wal_store_updates_big.test new file mode 100644 index 0000000..258b0fc --- /dev/null +++ b/parser/testdata/corpus/sql/storage/wal/wal_store_updates_big.test @@ -0,0 +1,9 @@ +# source: test/sql/storage/wal/wal_store_updates_big.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +SELECT a, b FROM test WHERE a>0 OR a IS NULL ORDER BY a +-- +ok +== diff --git a/parser/testdata/corpus/sql/storage/wal/wal_store_updates_big_varchar.test b/parser/testdata/corpus/sql/storage/wal/wal_store_updates_big_varchar.test new file mode 100644 index 0000000..6fbc94a --- /dev/null +++ b/parser/testdata/corpus/sql/storage/wal/wal_store_updates_big_varchar.test @@ -0,0 +1,25 @@ +# source: test/sql/storage/wal/wal_store_updates_big_varchar.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +CREATE TABLE test AS SELECT (-i)::VARCHAR a, (-i)::VARCHAR b FROM range(100000) tbl(i) +-- +ok +== +INSERT INTO test VALUES ('11', '22'), (NULL, '22'), ('12', '21') +-- +ok +== +UPDATE test SET b=(b::INT+1)::VARCHAR WHERE a='11' +-- +ok +== +SELECT a, b FROM test WHERE a::INTEGER>0 OR a IS NULL ORDER BY a +-- +ok +== +UPDATE test SET b=NULL WHERE a='11' +-- +ok +== diff --git a/parser/testdata/corpus/sql/storage/wal/wal_timestamp_storage.test b/parser/testdata/corpus/sql/storage/wal/wal_timestamp_storage.test new file mode 100644 index 0000000..85749a9 --- /dev/null +++ b/parser/testdata/corpus/sql/storage/wal/wal_timestamp_storage.test @@ -0,0 +1,21 @@ +# source: test/sql/storage/wal/wal_timestamp_storage.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +CREATE TABLE timestamp (t TIMESTAMP) +-- +ok +== +SELECT * FROM timestamp ORDER BY t +-- +ok +== +SELECT * FROM timestamp WHERE t=TIMESTAMP '2007-01-01 00:00:01' ORDER BY t +-- +ok +== +SELECT * FROM timestamp WHERE t=TIMESTAMP '2000-01-01 00:00:01' ORDER BY t +-- +ok +== diff --git a/parser/testdata/corpus/sql/storage/wal/wal_uhugeint_storage.test b/parser/testdata/corpus/sql/storage/wal/wal_uhugeint_storage.test new file mode 100644 index 0000000..a0be051 --- /dev/null +++ b/parser/testdata/corpus/sql/storage/wal/wal_uhugeint_storage.test @@ -0,0 +1,9 @@ +# source: test/sql/storage/wal/wal_uhugeint_storage.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +INSERT INTO uhugeints VALUES (1043178439874412422424), (42), (NULL), (47289478944894789472897441242); +-- +ok +== diff --git a/parser/testdata/corpus/sql/storage/wal/wal_view_storage.test b/parser/testdata/corpus/sql/storage/wal/wal_view_storage.test new file mode 100644 index 0000000..7b6d1e3 --- /dev/null +++ b/parser/testdata/corpus/sql/storage/wal/wal_view_storage.test @@ -0,0 +1,31 @@ +# source: test/sql/storage/wal/wal_view_storage.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +CREATE SCHEMA test; +CREATE TABLE test.t (a INTEGER, b INTEGER); +CREATE VIEW test.v AS SELECT * FROM test.t; +-- +ok +== +drop table test.t; +-- +ok +== +drop table test.t cascade; +-- +ok +== +CREATE VIEW test.v2 AS SELECT 42 +-- +ok +== +DROP VIEW test.v2 +-- +ok +== +SELECT * FROM test.v2 +-- +ok +== diff --git a/parser/testdata/corpus/sql/storage_version/storage_hyperloglog.test b/parser/testdata/corpus/sql/storage_version/storage_hyperloglog.test new file mode 100644 index 0000000..b7bee53 --- /dev/null +++ b/parser/testdata/corpus/sql/storage_version/storage_hyperloglog.test @@ -0,0 +1,49 @@ +# source: test/sql/storage_version/storage_hyperloglog.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +ATTACH '{TEST_DIR}/hll_v110.db' AS db_v110 (STORAGE_VERSION 'v1.1.0'); +-- +ok +== +CREATE TABLE db_v110.tbl AS SELECT range i FROM range(1000); +-- +ok +== +ATTACH '{TEST_DIR}/hll_v110.db' AS db_v110; +-- +ok +== +SELECT count(*) FROM db_v110.tbl; +-- +ok +== +SELECT sum(i) FROM db_v110.tbl; +-- +ok +== +ATTACH '{TEST_DIR}/hll_v120.db' AS db_v120 (STORAGE_VERSION 'v1.2.0'); +-- +ok +== +CREATE TABLE db_v120.tbl AS SELECT range i FROM range(1000); +-- +ok +== +ATTACH '{TEST_DIR}/hll_v120.db' AS db_v120; +-- +ok +== +SELECT count(*) FROM db_v120.tbl; +-- +ok +== +SELECT sum(i) FROM db_v120.tbl; +-- +ok +== +SELECT (SELECT count(*) FROM db_v110.tbl), (SELECT count(*) FROM db_v120.tbl); +-- +ok +== diff --git a/parser/testdata/corpus/sql/storage_version/storage_version_bump.test b/parser/testdata/corpus/sql/storage_version/storage_version_bump.test new file mode 100644 index 0000000..8162fec --- /dev/null +++ b/parser/testdata/corpus/sql/storage_version/storage_version_bump.test @@ -0,0 +1,25 @@ +# source: test/sql/storage_version/storage_version_bump.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +ATTACH '{TEST_DIR}/v1_5_2_0.db' as db (STORAGE_VERSION 'v1.5.0'); +-- +ok +== +CREATE TABLE db.tbl AS SELECT 52 answer; +-- +ok +== +ATTACH '{TEST_DIR}/v1_5_2_0.db' as db (STORAGE_VERSION 'v2.0.0'); +-- +ok +== +CREATE TABLE db.tbl2 AS SELECT 52 answer; +-- +ok +== +ATTACH '{TEST_DIR}/v1_5_2_0.db' as db; +-- +ok +== diff --git a/parser/testdata/corpus/sql/subquery/any_all/issue_2999.test b/parser/testdata/corpus/sql/subquery/any_all/issue_2999.test new file mode 100644 index 0000000..05c06b5 --- /dev/null +++ b/parser/testdata/corpus/sql/subquery/any_all/issue_2999.test @@ -0,0 +1,9 @@ +# source: test/sql/subquery/any_all/issue_2999.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +SELECT 1 = ANY(SELECT 1 FROM t1 JOIN (SELECT count(*) GROUP BY t0.c0) AS x(x) ON TRUE) FROM t0; +-- +ok +== diff --git a/parser/testdata/corpus/sql/subquery/any_all/subquery_in.test b/parser/testdata/corpus/sql/subquery/any_all/subquery_in.test new file mode 100644 index 0000000..45f140d --- /dev/null +++ b/parser/testdata/corpus/sql/subquery/any_all/subquery_in.test @@ -0,0 +1,17 @@ +# source: test/sql/subquery/any_all/subquery_in.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +CREATE TABLE t0 (c0 TIME,c1 DOUBLE PRECISION); +-- +ok +== +INSERT INTO t1 VALUES (1),(10),(7),(9),(NULL),(1),(7),(7),(0),(8),(0),(9),(NULL),(5),(3),(8),(0); +-- +ok +== +SELECT (FALSE) IN (TRUE, (SELECT TIME '13:35:07' FROM t1) BETWEEN t0.c0 AND t0.c0) FROM t0; +-- +ok +== diff --git a/parser/testdata/corpus/sql/subquery/any_all/test_any_all.test b/parser/testdata/corpus/sql/subquery/any_all/test_any_all.test new file mode 100644 index 0000000..7cb70ea --- /dev/null +++ b/parser/testdata/corpus/sql/subquery/any_all/test_any_all.test @@ -0,0 +1,37 @@ +# source: test/sql/subquery/any_all/test_any_all.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +SELECT 2 > ANY(SELECT * FROM integers) +-- +ok +== +SELECT 1 > ANY(SELECT * FROM integers) +-- +ok +== +SELECT 4 > ALL(SELECT * FROM integers) +-- +ok +== +SELECT 1 > ALL(SELECT * FROM integers) +-- +ok +== +SELECT NULL > ANY(SELECT * FROM integers) +-- +ok +== +SELECT NULL > ALL(SELECT * FROM integers) +-- +ok +== +SELECT 2 ^ ANY(SELECT * FROM integers) +-- +error: Parser Error: ANY and ALL operators require one of =,<>,>,<,>=,<= comparisons! +== +SELECT 2 ^ ANY([1, 2, 3]) +-- +error: Parser Error: Unsupported comparison "^" for ANY/ALL subquery +== diff --git a/parser/testdata/corpus/sql/subquery/any_all/test_any_all.test.metadata.json b/parser/testdata/corpus/sql/subquery/any_all/test_any_all.test.metadata.json new file mode 100644 index 0000000..cf03d82 --- /dev/null +++ b/parser/testdata/corpus/sql/subquery/any_all/test_any_all.test.metadata.json @@ -0,0 +1,6 @@ +{ + "todo": { + "3dc601b65efbaeef": "transformer-raised parser error: upstream rejects in the transformer, not the grammar; expected to clear as transformers land (milestones 3-5)", + "b735d58672d395c1": "transformer-raised parser error: upstream rejects in the transformer, not the grammar; expected to clear as transformers land (milestones 3-5)" + } +} diff --git a/parser/testdata/corpus/sql/subquery/any_all/test_correlated_any_all.test b/parser/testdata/corpus/sql/subquery/any_all/test_correlated_any_all.test new file mode 100644 index 0000000..0cb5259 --- /dev/null +++ b/parser/testdata/corpus/sql/subquery/any_all/test_correlated_any_all.test @@ -0,0 +1,85 @@ +# source: test/sql/subquery/any_all/test_correlated_any_all.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +SELECT i=ANY(SELECT i FROM integers WHERE i=i1.i) FROM integers i1 ORDER BY i; +-- +ok +== +SELECT i>ALL(SELECT (i+i1.i-1)/2 FROM integers WHERE i IS NOT NULL) FROM integers i1 ORDER BY i; +-- +ok +== +SELECT i=ALL(SELECT i FROM integers WHERE i<>i1.i) FROM integers i1 ORDER BY i; +-- +ok +== +SELECT i FROM integers i1 WHERE i=ANY(SELECT i FROM integers WHERE i=i1.i) ORDER BY i; +-- +ok +== +SELECT i FROM integers i1 WHERE i<>ANY(SELECT i FROM integers WHERE i=i1.i) ORDER BY i; +-- +ok +== +SELECT i FROM integers i1 WHERE i=ANY(SELECT i FROM integers WHERE i<>i1.i) ORDER BY i; +-- +ok +== +SELECT i FROM integers i1 WHERE i>ANY(SELECT i FROM integers WHERE i<>i1.i) ORDER BY i; +-- +ok +== +SELECT i FROM integers i1 WHERE i>ALL(SELECT (i+i1.i-1)/2 FROM integers WHERE i IS NOT NULL) ORDER BY i; +-- +ok +== +SELECT i=ALL(SELECT i FROM integers WHERE i=i1.i) FROM integers i1 ORDER BY i; +-- +ok +== +SELECT i<>ALL(SELECT i FROM integers WHERE i=i1.i) FROM integers i1 ORDER BY i; +-- +ok +== +SELECT i<>ANY(SELECT i FROM integers WHERE i=i1.i) FROM integers i1 ORDER BY i; +-- +ok +== +SELECT i=ANY(SELECT i FROM integers WHERE i<>i1.i) FROM integers i1 ORDER BY i; +-- +ok +== +SELECT i>ANY(SELECT i FROM integers WHERE i<>i1.i) FROM integers i1 ORDER BY i; +-- +ok +== +SELECT i>ALL(SELECT (i+i1.i-1)/2 FROM integers) FROM integers i1 ORDER BY i; +-- +ok +== +SELECT i=ANY(SELECT i FROM integers WHERE i=i1.i OR i IS NULL) FROM integers i1 ORDER BY i; +-- +ok +== +SELECT i=ALL(SELECT i FROM integers WHERE i=i1.i OR i IS NULL) FROM integers i1 ORDER BY i; +-- +ok +== +SELECT MIN(i)>ANY(SELECT i FROM integers WHERE i>MIN(i1.i)) FROM integers i1; +-- +ok +== +SELECT SUM(i)>ANY(SELECT i FROM integers WHERE i>MIN(i1.i)) FROM integers i1; +-- +ok +== +SELECT (SELECT SUM(i)+SUM(i1.i) FROM integers)>ANY(SELECT i FROM integers WHERE i>MIN(i1.i)) FROM integers i1; +-- +ok +== +SELECT i=ANY(SELECT i FROM integers WHERE i=i1.i AND i>10) FROM integers i1 ORDER BY i; +-- +ok +== diff --git a/parser/testdata/corpus/sql/subquery/any_all/test_multi_column_mark_join_nulls.test b/parser/testdata/corpus/sql/subquery/any_all/test_multi_column_mark_join_nulls.test new file mode 100644 index 0000000..5c0d5a0 --- /dev/null +++ b/parser/testdata/corpus/sql/subquery/any_all/test_multi_column_mark_join_nulls.test @@ -0,0 +1,214 @@ +# source: test/sql/subquery/any_all/test_multi_column_mark_join_nulls.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +SELECT a, b, + row(a, b) IN (SELECT * FROM (VALUES (2, 6), (3, 7), (3, NULL::INT), (4, 8)) rhs(x, y)), + row(a, b) NOT IN (SELECT * FROM (VALUES (2, 6), (3, 7), (3, NULL::INT), (4, 8)) rhs(x, y)) +FROM (VALUES (1, 5), (2, 6), (3, 9), (9, 8), (3, NULL::INT), + (NULL::INT, 8), (NULL::INT, NULL::INT)) lhs(a, b) +-- +ok +== +SELECT a, b, + row(a, b) IN (SELECT * FROM (VALUES (2, 6), (NULL::INT, 7), (4, NULL::INT), + (NULL::INT, NULL::INT)) rhs(x, y)), + row(a, b) NOT IN (SELECT * FROM (VALUES (2, 6), (NULL::INT, 7), (4, NULL::INT), + (NULL::INT, NULL::INT)) rhs(x, y)) +FROM (VALUES (1, 5), (2, 6), (3, 7), (4, 8)) lhs(a, b) +-- +ok +== +SELECT row(NULL::INT, 8) IN (SELECT * FROM (VALUES (2, 6), (3, 7)) rhs(x, y)), + row(NULL::INT, 8) NOT IN (SELECT * FROM (VALUES (2, 6), (3, 7)) rhs(x, y)) +-- +ok +== +SELECT k, + row(a, b, c, d, e, f) IN ( + SELECT * FROM (VALUES (1, 1, 1, 1, 1, 1), + (0, NULL::INT, NULL::INT, 0, NULL::INT, 0)) rhs(a, b, c, d, e, f)), + row(a, b, c, d, e, f) NOT IN ( + SELECT * FROM (VALUES (1, 1, 1, 1, 1, 1), + (0, NULL::INT, NULL::INT, 0, NULL::INT, 0)) rhs(a, b, c, d, e, f)) +FROM (VALUES ('k1', 1, 1, 1, 1, 1, 1), + ('k2', 0, 0, 0, 0, 0, 0), + ('k4', 1, 0, 0, 0, 0, 0), + ('k8', 0, 1, 1, 0, 1, 0)) lhs(k, a, b, c, d, e, f) +-- +ok +== +SELECT row(1, 2) IN (SELECT * FROM (VALUES (1, 2)) rhs(x, y) WHERE false), + row(1, 2) NOT IN (SELECT * FROM (VALUES (1, 2)) rhs(x, y) WHERE false) +-- +ok +== +SELECT row(1, 2) IN (SELECT * FROM (VALUES (NULL::INT, NULL::INT)) rhs(x, y)), + row(1, 2) NOT IN (SELECT * FROM (VALUES (NULL::INT, NULL::INT)) rhs(x, y)) +-- +ok +== +SELECT * +FROM (VALUES (0, 0), (1, 0)) outer_tab(f1, f2) +WHERE (f1, f2) NOT IN ( + SELECT * FROM (VALUES (0, NULL::INT)) inner_tab(c1, c2) +) +ORDER BY ALL +-- +ok +== +CREATE TABLE mark_join_rhs AS SELECT i::INT AS a, i::INT AS b FROM range(3000) t(i); +-- +ok +== +INSERT INTO mark_join_rhs VALUES (NULL, 7); +-- +ok +== +SELECT row(4000, 7) IN (SELECT a, b FROM mark_join_rhs), + row(4000, 7) NOT IN (SELECT a, b FROM mark_join_rhs) +-- +ok +== +SELECT row(NULL::INT, 4001) IN (SELECT a, b FROM mark_join_rhs), + row(NULL::INT, 4001) NOT IN (SELECT a, b FROM mark_join_rhs) +-- +ok +== +SELECT row([1, NULL::INT], 0) IN ( + SELECT * FROM (VALUES ([1, 2], 0)) rhs(a, b) +) +-- +ok +== +SELECT row([1, NULL::INT], 0) IN ( + SELECT * FROM (VALUES ([1, NULL::INT], 0)) rhs(a, b) +) +-- +ok +== +SELECT row([1, 2], 0) IN ( + SELECT * FROM (VALUES ([1, NULL::INT], 0)) rhs(a, b) +) +-- +ok +== +SELECT row(array_value(1, 2), 0) IN ( + SELECT * FROM (VALUES (array_value(1, NULL::INT), 0)) rhs(a, b) + ), + row(map([1, 2], [1, 2]), 0) IN ( + SELECT * FROM (VALUES (map([1, 2], [1, NULL::INT]), 0)) rhs(a, b) + ), + row({'a': 1, 'b': 2}, 0) IN ( + SELECT * FROM (VALUES ({'a': 1, 'b': NULL::INT}, 0)) rhs(a, b) + ), + row(union_value(num := 1)::UNION(num INT, str VARCHAR), 0) IN ( + SELECT * + FROM (VALUES (union_value(num := NULL::INT)::UNION(num INT, str VARCHAR), 0)) rhs(a, b) + ) +-- +ok +== +SELECT row(array_value(1, NULL::INT), 0) IN ( + SELECT * FROM (VALUES (array_value(1, 2), 0)) rhs(a, b) +) +-- +ok +== +SELECT row(map([1, 2], [1, NULL::INT]), 0) IN ( + SELECT * FROM (VALUES (map([1, 2], [1, 2]), 0)) rhs(a, b) +) +-- +ok +== +SELECT row({'a': 1, 'b': NULL::INT}, 0) IN ( + SELECT * FROM (VALUES ({'a': 1, 'b': 2}, 0)) rhs(a, b) +) +-- +ok +== +SELECT row(union_value(num := NULL::INT)::UNION(num INT, str VARCHAR), 0) IN ( + SELECT * FROM (VALUES (union_value(num := 1)::UNION(num INT, str VARCHAR), 0)) rhs(a, b) +) +-- +ok +== +SELECT row([9, NULL::INT], 0) IN ( + SELECT * FROM (VALUES ([1, 2], 0)) rhs(a, b) +) +-- +ok +== +SELECT count(*) +FROM range(10000) lhs(i) +WHERE row(list_value(i), 0::INT) NOT IN ( + SELECT list_value((i + 100000)::BIGINT), 0::INT + FROM range(10000) rhs(i) +) +-- +ok +== +SELECT count(*), count(marker), count_if(marker) +FROM ( + SELECT row(i, 0::INT) IN ( + SELECT a, b + FROM ( + SELECT i::BIGINT AS a, 0::INT AS b FROM range(100000) rhs(i) + UNION ALL + SELECT NULL::BIGINT, 0::INT + ) + ) AS marker + FROM range(100000) lhs(i) +) +-- +ok +== +SELECT row(1, 2) = ANY ( + SELECT s FROM (VALUES (row(1, NULL::INT))) rhs(s) +) +-- +ok +== +SELECT row(NULL::INT, 3) = ANY ( + SELECT s FROM (VALUES (row(1, 2))) rhs(s) +) +-- +ok +== +SELECT row(NULL::INT, 2) = ANY ( + SELECT s FROM (VALUES (row(1, 2))) rhs(s) +) +-- +ok +== +WITH RECURSIVE r(i, j) AS ( + VALUES (0, 0) + UNION ALL + SELECT outer_r.i + 1, 0 + FROM r outer_r + WHERE outer_r.i < 3 + AND row(outer_r.i + 1, 0) NOT IN ( + SELECT inner_r.i, NULL::INT FROM r inner_r + ) +) +SELECT * FROM r ORDER BY i +-- +ok +== +SELECT a, row(a, b) IN ( + SELECT x, y FROM (VALUES (1, 1), (2, 2)) rhs(x, y) WHERE x = a +) +FROM (VALUES (1, 1), (2, 3)) lhs(a, b); +-- +ok +== +SELECT row(a, b) = ANY ( + SELECT s + FROM (VALUES (1, row(1, NULL::INT))) rhs(k, s) + WHERE k = lhs.a +) +FROM (VALUES (1, 1)) lhs(a, b) +-- +ok +== diff --git a/parser/testdata/corpus/sql/subquery/any_all/test_row_comparison_any_all.test b/parser/testdata/corpus/sql/subquery/any_all/test_row_comparison_any_all.test new file mode 100644 index 0000000..cccbb7b --- /dev/null +++ b/parser/testdata/corpus/sql/subquery/any_all/test_row_comparison_any_all.test @@ -0,0 +1,181 @@ +# source: test/sql/subquery/any_all/test_row_comparison_any_all.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +CREATE TABLE test_data(a INTEGER, b INTEGER); +-- +ok +== +INSERT INTO test_data VALUES (1, 0), (0, 2), (2, 1), (NULL, 1); +-- +ok +== +SELECT (0, 0) < ANY(SELECT 1, 0); +-- +ok +== +SELECT (0, 0) < ANY(SELECT a, b FROM test_data); +-- +ok +== +SELECT (0, 1) < ANY(SELECT a, b FROM test_data); +-- +ok +== +SELECT (0, NULL) < ANY(SELECT 1, NULL); +-- +ok +== +SELECT (0, NULL) < ANY(SELECT a, b FROM test_data WHERE a IS NOT NULL); +-- +ok +== +SELECT (2, 0) > ANY(SELECT 1, 0); +-- +ok +== +SELECT (2, 0) > ANY(SELECT a, b FROM test_data WHERE a IS NOT NULL); +-- +ok +== +SELECT (1, 1) > ANY(SELECT 0, 2); +-- +ok +== +SELECT (1, 0) <= ANY(SELECT 1, 0); +-- +ok +== +SELECT (0, 5) <= ANY(SELECT 1, 0); +-- +ok +== +SELECT (1, 0) >= ANY(SELECT 1, 0); +-- +ok +== +SELECT (2, 0) >= ANY(SELECT 1, 5); +-- +ok +== +SELECT (0, 0) < ALL(SELECT 1, 0); +-- +ok +== +SELECT (0, 0) < ALL(SELECT * FROM (VALUES (1, 0), (2, 0), (3, 0))); +-- +ok +== +SELECT (1, 0) < ALL(SELECT * FROM (VALUES (0, 0), (2, 0))); +-- +ok +== +SELECT (2, 0) > ALL(SELECT 1, 0); +-- +ok +== +SELECT (3, 0) > ALL(SELECT * FROM (VALUES (1, 0), (2, 0))); +-- +ok +== +SELECT (2, 0) > ALL(SELECT * FROM (VALUES (1, 0), (3, 0))); +-- +ok +== +SELECT (1, 1) <= ALL(SELECT 1, 2); +-- +ok +== +SELECT (1, 1) <= ALL(SELECT * FROM (VALUES (1, 2), (2, 0))); +-- +ok +== +SELECT (2, 0) <= ALL(SELECT * FROM (VALUES (1, 0), (3, 0))); +-- +ok +== +SELECT (1, 1) >= ALL(SELECT 1, 0); +-- +ok +== +SELECT (2, 0) >= ALL(SELECT * FROM (VALUES (1, 0), (1, 5))); +-- +ok +== +SELECT (1, 0) >= ALL(SELECT * FROM (VALUES (0, 0), (2, 0))); +-- +ok +== +SELECT (1, 2) = ANY(SELECT 1, 2); +-- +ok +== +SELECT (1, 2) = ANY(SELECT 1, 3); +-- +ok +== +SELECT (1, 2) != ANY(SELECT 1, 3); +-- +ok +== +SELECT (1, 2) = ALL(SELECT 1, 2); +-- +ok +== +SELECT (1, 2) = ALL(SELECT * FROM (VALUES (1, 2), (1, 3))); +-- +ok +== +SELECT ROW(0, 0) < ANY(SELECT 1, 0); +-- +ok +== +SELECT ROW(2, 0) > ANY(SELECT 1, 0); +-- +ok +== +SELECT (0, 0, 0) < ANY(SELECT 1, 0, 0); +-- +ok +== +SELECT (0, 0, 1) < ANY(SELECT 0, 1, 0); +-- +ok +== +SELECT (1, 0, 0) < ANY(SELECT 1, 0, 1); +-- +ok +== +SELECT (1, 0) < ANY(SELECT 1, 1); +-- +ok +== +SELECT (1, 2) > ANY(SELECT 1, 1); +-- +ok +== +SELECT (1, 1) < ANY(SELECT 1, 1); +-- +ok +== +SELECT (1, 1) <= ANY(SELECT 1, 1); +-- +ok +== +SELECT (1, 1) > ANY(SELECT 1, 1); +-- +ok +== +SELECT (1, 1) >= ANY(SELECT 1, 1); +-- +ok +== +SELECT (1, 1) < ANY(SELECT * FROM (VALUES (0, 0), (2, 0), (1, 2))); +-- +ok +== +SELECT (1, 1) > ANY(SELECT * FROM (VALUES (0, 0), (2, 0), (1, 0))); +-- +ok +== diff --git a/parser/testdata/corpus/sql/subquery/any_all/test_row_not_equal_any_null_semantics.test b/parser/testdata/corpus/sql/subquery/any_all/test_row_not_equal_any_null_semantics.test new file mode 100644 index 0000000..5c84623 --- /dev/null +++ b/parser/testdata/corpus/sql/subquery/any_all/test_row_not_equal_any_null_semantics.test @@ -0,0 +1,94 @@ +# source: test/sql/subquery/any_all/test_row_not_equal_any_null_semantics.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +SELECT (1, 2) <> ANY (SELECT * FROM (VALUES (1, NULL::INT)) t(x, y)) +-- +ok +== +SELECT (1, 2) <> ANY (SELECT * FROM (VALUES (NULL::INT, 2)) t(x, y)) +-- +ok +== +SELECT (1, 2) <> ANY (SELECT * FROM (VALUES (1, NULL::INT), (1, 2)) t(x, y)) +-- +ok +== +SELECT (NULL::INT, 3) <> ANY ( + SELECT * FROM (VALUES (1, 2)) rhs(a, b) +) +-- +ok +== +SELECT (3, NULL::INT) <> ANY ( + SELECT * FROM (VALUES (2, 1)) rhs(a, b) +) +-- +ok +== +SELECT (NULL::INT, 2) <> ANY ( + SELECT * FROM (VALUES (1, 2)) rhs(a, b) +) +-- +ok +== +SELECT (1, NULL::INT) <> ANY (SELECT * FROM (VALUES (1, 2)) t(x, y)) +-- +ok +== +SELECT (NULL::INT, 2) <> ANY (SELECT * FROM (VALUES (1, 2)) t(x, y)) +-- +ok +== +SELECT (1, NULL::INT) <> ANY (SELECT * FROM (VALUES (2, 2)) t(x, y)) +-- +ok +== +SELECT (1, NULL::INT) <> ANY (SELECT * FROM (VALUES (1, 2), (2, 2)) t(x, y)) +-- +ok +== +SELECT (1, 2) <> ANY (SELECT * FROM (VALUES (1, 2)) t(x, y) WHERE false) +-- +ok +== +SELECT (1::SMALLINT, 2::SMALLINT) <> ANY ( + SELECT * FROM (VALUES (1::BIGINT, 3::BIGINT)) rhs(a, b) +) +-- +ok +== +SELECT (union_value(num := 1)::UNION(num INT, str VARCHAR), 2) <> ANY ( + SELECT * FROM (VALUES (union_value(num := 1)::UNION(num INT, str VARCHAR), 3)) rhs(u, v) +) +-- +ok +== +SELECT i, (1, 10) <> ANY ( + SELECT x, y + FROM (VALUES (1, NULL::INT), (2, 20)) t(x, y) + WHERE x = i +) FROM (VALUES (1), (2), (3)) outer_t(i) +ORDER BY i; +-- +ok +== +SELECT i, (union_value(num := 1)::UNION(num INT, str VARCHAR), 2) <> ANY ( + SELECT u, v + FROM (VALUES (1, union_value(num := 1)::UNION(num INT, str VARCHAR), 3)) rhs(k, u, v) + WHERE rhs.k = outer_t.i +) +FROM (VALUES (1)) outer_t(i); +-- +ok +== +SELECT row(a, b) <> ANY ( + SELECT s + FROM (VALUES (1, row(1, NULL::INT))) rhs(k, s) + WHERE k = lhs.a +) +FROM (VALUES (1, 1)) lhs(a, b) +-- +ok +== diff --git a/parser/testdata/corpus/sql/subquery/any_all/test_scalar_any_all.test b/parser/testdata/corpus/sql/subquery/any_all/test_scalar_any_all.test new file mode 100644 index 0000000..8ad1e75 --- /dev/null +++ b/parser/testdata/corpus/sql/subquery/any_all/test_scalar_any_all.test @@ -0,0 +1,37 @@ +# source: test/sql/subquery/any_all/test_scalar_any_all.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +SELECT 1 = ANY(SELECT 1) +-- +ok +== +SELECT 1 = ANY(SELECT NULL) +-- +ok +== +SELECT 1 = ANY(SELECT 2) +-- +ok +== +SELECT NULL = ANY(SELECT 2) +-- +ok +== +SELECT 1 = ALL(SELECT 1) +-- +ok +== +SELECT 1 = ALL(SELECT NULL) +-- +ok +== +SELECT 1 = ALL(SELECT 2) +-- +ok +== +SELECT NULL = ALL(SELECT 2) +-- +ok +== diff --git a/parser/testdata/corpus/sql/subquery/any_all/test_scalar_in.test b/parser/testdata/corpus/sql/subquery/any_all/test_scalar_in.test new file mode 100644 index 0000000..ca57eef --- /dev/null +++ b/parser/testdata/corpus/sql/subquery/any_all/test_scalar_in.test @@ -0,0 +1,41 @@ +# source: test/sql/subquery/any_all/test_scalar_in.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +SELECT 1 IN (SELECT 1) +-- +ok +== +SELECT NULL IN (SELECT 1) +-- +ok +== +SELECT 1 IN (SELECT NULL) +-- +ok +== +SELECT 1 IN (SELECT 2) +-- +ok +== +SELECT 4 IN (SELECT * FROM integers) +-- +ok +== +SELECT 1 IN (SELECT * FROM integers) +-- +ok +== +SELECT 1 IN (SELECT * FROM integers) FROM integers +-- +ok +== +SELECT * FROM integers WHERE (4 IN (SELECT * FROM integers)) IS NULL ORDER BY 1 +-- +ok +== +SELECT * FROM integers WHERE (i IN (SELECT * FROM integers)) IS NULL ORDER BY 1 +-- +ok +== diff --git a/parser/testdata/corpus/sql/subquery/any_all/test_simple_not_in.test b/parser/testdata/corpus/sql/subquery/any_all/test_simple_not_in.test new file mode 100644 index 0000000..f8889a4 --- /dev/null +++ b/parser/testdata/corpus/sql/subquery/any_all/test_simple_not_in.test @@ -0,0 +1,33 @@ +# source: test/sql/subquery/any_all/test_simple_not_in.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +SELECT 1 AS one WHERE 1 IN (SELECT 1); +-- +ok +== +CREATE TABLE test (id INTEGER, b INTEGER); +-- +ok +== +INSERT INTO test VALUES (1, 22) +-- +ok +== +INSERT INTO test VALUES (2, 21) +-- +ok +== +INSERT INTO test VALUES (3, 23) +-- +ok +== +SELECT * FROM test WHERE b IN (SELECT b FROM test WHERE b * id < 30) ORDER BY id, b +-- +ok +== +SELECT * FROM test WHERE b NOT IN (SELECT b FROM test WHERE b * id < 30) ORDER BY id, b +-- +ok +== diff --git a/parser/testdata/corpus/sql/subquery/any_all/test_uncorrelated_all_subquery.test b/parser/testdata/corpus/sql/subquery/any_all/test_uncorrelated_all_subquery.test new file mode 100644 index 0000000..aea9fac --- /dev/null +++ b/parser/testdata/corpus/sql/subquery/any_all/test_uncorrelated_all_subquery.test @@ -0,0 +1,125 @@ +# source: test/sql/subquery/any_all/test_uncorrelated_all_subquery.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +SELECT i FROM integers WHERE i >= ALL(SELECT i FROM integers) +-- +ok +== +SELECT i, i >= ALL(SELECT i FROM integers) FROM integers ORDER BY i +-- +ok +== +SELECT i FROM integers WHERE i >= ALL(SELECT i FROM integers WHERE i IS NOT NULL) +-- +ok +== +SELECT i, i >= ALL(SELECT i FROM integers WHERE i IS NOT NULL) FROM integers ORDER BY i +-- +ok +== +SELECT i FROM integers WHERE i > ALL(SELECT MIN(i) FROM integers) +-- +ok +== +SELECT i FROM integers WHERE i < ALL(SELECT MAX(i) FROM integers) ORDER BY 1 +-- +ok +== +SELECT i FROM integers WHERE i <= ALL(SELECT i FROM integers) +-- +ok +== +SELECT i FROM integers WHERE i <= ALL(SELECT i FROM integers WHERE i IS NOT NULL) +-- +ok +== +SELECT i FROM integers WHERE i = ALL(SELECT i FROM integers WHERE i=1) +-- +ok +== +SELECT i FROM integers WHERE i <> ALL(SELECT i FROM integers WHERE i=1) +-- +ok +== +SELECT i FROM integers WHERE i = ALL(SELECT i FROM integers WHERE i IS NOT NULL) +-- +ok +== +SELECT i FROM integers WHERE i <> ALL(SELECT i FROM integers WHERE i IS NOT NULL) +-- +ok +== +SELECT i FROM integers WHERE i <> ALL(SELECT i FROM integers WHERE i>10) ORDER BY i; +-- +ok +== +SELECT i, i <> ALL(SELECT i FROM integers WHERE i>10) FROM integers ORDER BY i; +-- +ok +== +SELECT i, i > ANY(SELECT i FROM integers WHERE i>10) FROM integers ORDER BY i; +-- +ok +== +SELECT i, i = ANY(SELECT i FROM integers WHERE i>10) FROM integers ORDER BY i; +-- +ok +== +SELECT i, i >= ANY(SELECT i FROM integers WHERE i>10) FROM integers ORDER BY i; +-- +ok +== +SELECT i, i <= ANY(SELECT i FROM integers WHERE i>10) FROM integers ORDER BY i; +-- +ok +== +SELECT i, i < ANY(SELECT i FROM integers WHERE i>10) FROM integers ORDER BY i; +-- +ok +== +SELECT i, i <> ANY(SELECT i FROM integers WHERE i>10) FROM integers ORDER BY i; +-- +ok +== +SELECT (SELECT (SELECT (SELECT 42))) +-- +ok +== +SELECT (SELECT EXISTS(SELECT * FROM integers WHERE i>2)) FROM integers; +-- +ok +== +SELECT (SELECT MAX(i) FROM integers) AS k, SUM(i) FROM integers GROUP BY k; +-- +ok +== +SELECT i >= ALL(SELECT i FROM integers WHERE i IS NOT NULL) AS k, SUM(i) FROM integers GROUP BY k ORDER BY k; +-- +ok +== +SELECT SUM(i) FROM integers GROUP BY (i >= ALL(SELECT i FROM integers WHERE i IS NOT NULL)) ORDER BY 1; +-- +ok +== +SELECT i >= ALL(SELECT MIN(i) FROM integers WHERE i IS NOT NULL) AS k, SUM(i) FROM integers GROUP BY k ORDER BY k; +-- +ok +== +SELECT i, SUM(CASE WHEN (i >= ALL(SELECT i FROM integers WHERE i=2)) THEN 1 ELSE 0 END) FROM integers GROUP BY i ORDER BY i; +-- +ok +== +SELECT i % 2 AS k, SUM(i) FROM integers GROUP BY k HAVING SUM(i) > (SELECT MAX(i) FROM integers) +-- +ok +== +SELECT i FROM integers WHERE NOT(i IN (SELECT i FROM integers WHERE i>1)); +-- +ok +== +SELECT (SELECT SUM(i) FROM integers), (SELECT 42) +-- +ok +== diff --git a/parser/testdata/corpus/sql/subquery/any_all/test_uncorrelated_any_subquery.test b/parser/testdata/corpus/sql/subquery/any_all/test_uncorrelated_any_subquery.test new file mode 100644 index 0000000..8f1778b --- /dev/null +++ b/parser/testdata/corpus/sql/subquery/any_all/test_uncorrelated_any_subquery.test @@ -0,0 +1,65 @@ +# source: test/sql/subquery/any_all/test_uncorrelated_any_subquery.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +SELECT i FROM integers WHERE i <= ANY(SELECT i FROM integers) +-- +ok +== +SELECT i FROM integers WHERE i > ANY(SELECT i FROM integers) ORDER BY 1 +-- +ok +== +SELECT i, i > ANY(SELECT i FROM integers) FROM integers ORDER BY i +-- +ok +== +SELECT i, i > ANY(SELECT i FROM integers WHERE i IS NOT NULL) FROM integers ORDER BY i +-- +ok +== +SELECT i, NULL > ANY(SELECT i FROM integers) FROM integers ORDER BY i +-- +ok +== +SELECT i, NULL > ANY(SELECT i FROM integers WHERE i IS NOT NULL) FROM integers ORDER BY i +-- +ok +== +SELECT i FROM integers WHERE i = ANY(SELECT i FROM integers) order by i +-- +ok +== +SELECT i, i = ANY(SELECT i FROM integers WHERE i>2) FROM integers ORDER BY i +-- +ok +== +SELECT i, i = ANY(SELECT i FROM integers WHERE i>2 OR i IS NULL) FROM integers ORDER BY i +-- +ok +== +SELECT i, i <> ANY(SELECT i FROM integers WHERE i>2) FROM integers ORDER BY i +-- +ok +== +SELECT i, i <> ANY(SELECT i FROM integers WHERE i>2 OR i IS NULL) FROM integers ORDER BY i +-- +ok +== +SELECT i, i = ANY(SELECT i1.i FROM integers i1, integers i2, integers i3, integers i4, integers i5, integers i6 WHERE i1.i IS NOT NULL) FROM integers ORDER BY i +-- +ok +== +SELECT i, i = ANY(SELECT i1.i FROM integers i1, integers i2, integers i3, integers i4, integers i5, integers i6 WHERE i1.i IS NOT NULL AND i1.i <> 2) FROM integers ORDER BY i +-- +ok +== +SELECT i, i >= ANY(SELECT i1.i FROM integers i1, integers i2, integers i3, integers i4, integers i5, integers i6 WHERE i1.i IS NOT NULL) FROM integers ORDER BY i +-- +ok +== +SELECT i, i >= ANY(SELECT i1.i FROM integers i1, integers i2, integers i3, integers i4, integers i5, integers i6 WHERE i1.i IS NOT NULL AND i1.i <> 1 LIMIT 1) FROM integers ORDER BY i +-- +ok +== diff --git a/parser/testdata/corpus/sql/subquery/complex/complex_correlated_subquery_issue.test b/parser/testdata/corpus/sql/subquery/complex/complex_correlated_subquery_issue.test new file mode 100644 index 0000000..0df3e29 --- /dev/null +++ b/parser/testdata/corpus/sql/subquery/complex/complex_correlated_subquery_issue.test @@ -0,0 +1,65 @@ +# source: test/sql/subquery/complex/complex_correlated_subquery_issue.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +CREATE TABLE t2(c0 INT); +-- +ok +== +SELECT * FROM t2, t1, ( SELECT t2.c0 AS col_1, t1.c0 AS col_2) as subQuery0 INNER JOIN t0 ON ((subQuery0.col_2)) CROSS JOIN (SELECT t0.c0 AS col_1); +-- +ok +== +INSERT INTO t2(c0) VALUES (2); +-- +ok +== +INSERT INTO t1(c0) VALUES (1); +-- +ok +== +SELECT * FROM t2, t0 LEFT JOIN Lateral(SELECT t0.c0 AS col_0, t2.c0 AS col_1) as subQuery1 ON ((subQuery1.col_1)<(t0.c0)); +-- +ok +== +drop table t0; +-- +ok +== +drop table t1; +-- +ok +== +CREATE TABLE t0(c0 DATE); +-- +ok +== +CREATE TABLE t1(c0 DATETIME, c1 DOUBLE); +-- +ok +== +SELECT * FROM t0, t1 CROSS JOIN (SELECT t0.c0 AS col_0 WHERE t1.c1) as subQuery0; +-- +ok +== +drop table t2; +-- +ok +== +CREATE TABLE t2(c2 DOUBLE); +-- +ok +== +INSERT INTO t2(c2) VALUES (7.5); +-- +ok +== +INSERT INTO t0(c0) VALUES (0); +-- +ok +== +SELECT * FROM t0, t2, t1, (SELECT DISTINCT t1.c0 AS col_0, t2.c2 AS col_1 FROM t1) as subQuery0 CROSS JOIN (SELECT t0.c0 AS col_0); +-- +ok +== diff --git a/parser/testdata/corpus/sql/subquery/complex/correlated_internal_issue_5975.test b/parser/testdata/corpus/sql/subquery/complex/correlated_internal_issue_5975.test new file mode 100644 index 0000000..a35e524 --- /dev/null +++ b/parser/testdata/corpus/sql/subquery/complex/correlated_internal_issue_5975.test @@ -0,0 +1,187 @@ +# source: test/sql/subquery/complex/correlated_internal_issue_5975.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +CREATE TABLE my_logs ( + featherEventId UUID, + "duckInfo.gooseEmail" VARCHAR, + "duckInfo.gooseSubject" VARCHAR +); +-- +ok +== +CREATE TYPE MY_ENUM AS ENUM ( + 'EnumField1', + 'EnumField2', + 'EnumField3', + 'EnumField4', + 'EnumField5', + 'EnumField6', + 'EnumField7', + 'EnumField8' +); +-- +ok +== +CREATE OR REPLACE MACRO swan_MY_ENUM (sa) AS ( + WITH sa_parts AS ( + SELECT STRING_SPLIT(sa, '@') AS emailParts + ) + SELECT 'EnumField2'::MY_ENUM + FROM sa_parts +); +-- +ok +== +CREATE OR REPLACE MACRO swan_email_info (duckEmail) AS ( + SELECT + CASE + WHEN ENDS_WITH(duckEmail, 'duckdblabs.com') THEN STRUCT_PACK( + subject := 'serviceAccount:' || duckEmail, + type := swan_MY_ENUM (duckEmail) + ) + WHEN duckEmail = 'my@duckdblabs.com' + OR duckEmail = 'EnumField8' THEN STRUCT_PACK( + subject := 'EnumField8', + type := 'EnumField8'::MY_ENUM + ) + WHEN REGEXP_MATCHES(duckEmail, '[\w-.+]+@(([\w-]+).)+[\w-]{2,4}') THEN STRUCT_PACK( + subject := 'user:' || duckEmail, + type := 'EnumField1'::MY_ENUM + ) + END AS duckInfo +); +-- +ok +== +CREATE OR REPLACE MACRO swan_subject_info (duckSubject) AS ( + WITH + subjectComponents AS ( + SELECT + duckSubject AS subject, + STRING_SPLIT(duckSubject, ':') AS parts + ) + SELECT + CASE + WHEN parts[1] = 'EnumField2' THEN STRUCT_PACK( + subject := subject, + type := swan_MY_ENUM (parts[2]) + ) + WHEN parts[1] = 'EnumField1' THEN STRUCT_PACK(subject := subject, type := 'EnumField1'::MY_ENUM) + WHEN REGEXP_MATCHES( + subject, + 'duckdb.org' + ) THEN STRUCT_PACK( + subject := subject, + type := 'EnumField6'::MY_ENUM + ) + WHEN NOT REGEXP_FULL_MATCH(subject, '.+@.+\..+') THEN STRUCT_PACK( + subject := subject, + type := 'EnumField7'::MY_ENUM + ) + END AS duckInfo + FROM + subjectComponents +); +-- +ok +== +WITH + duck_info AS ( + SELECT + featherEventId, + "duckInfo.gooseEmail" AS email, + "duckInfo.gooseSubject" AS subject, + HASH('email' || "duckInfo.gooseEmail") AS emailHash, + HASH( + 'subject' || "duckInfo.gooseSubject" + ) AS subjectHash, + FROM + my_logs + ), + unique_emails AS ( + SELECT + email, + emailHash + FROM + duck_info + WHERE + email IS NOT NULL + GROUP BY + 1, + 2 + ), + email_info AS ( + SELECT + emailHash AS swanHash, + swan_email_info (email) AS swanInfo + FROM + unique_emails + ), + unique_subjects AS ( + SELECT + subject, + subjectHash + FROM + duck_info + WHERE + subject IS NOT NULL + GROUP BY + 1, + 2 + ), + subject_info AS ( + SELECT + subjectHash AS swanHash, + swan_subject_info (subject) AS swanInfo + FROM + unique_subjects + ), + swan_info AS ( + SELECT + * + FROM + email_info + UNION ALL + SELECT + * + FROM + subject_info + ), + goose_id AS ( + SELECT + featherEventId, + CASE + WHEN subject IS NOT NULL THEN subjectHash + WHEN email IS NOT NULL THEN emailHash + END AS swanHash, + FROM + duck_info + ), + normalized_ids AS ( + SELECT + featherEventId, + swanInfo.subject AS featherIdentityId, + swanInfo.type AS featherIdentityType, + FROM + goose_id + LEFT JOIN swan_info USING (swanHash) + ), + chicken_info AS ( + SELECT + featherEventId, + featherIdentityId, + featherIdentityType, + FROM + normalized_ids + ) +SELECT + featherEventId, + featherIdentityId, + featherIdentityType, +FROM + chicken_info; +-- +ok +== diff --git a/parser/testdata/corpus/sql/subquery/complex/correlated_list_any_join.test b/parser/testdata/corpus/sql/subquery/complex/correlated_list_any_join.test new file mode 100644 index 0000000..afc027e --- /dev/null +++ b/parser/testdata/corpus/sql/subquery/complex/correlated_list_any_join.test @@ -0,0 +1,45 @@ +# source: test/sql/subquery/complex/correlated_list_any_join.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +CREATE TABLE lists(l INTEGER[]); +-- +ok +== +INSERT INTO lists VALUES (ARRAY[1]), (ARRAY[2]), (ARRAY[3]), (NULL); +-- +ok +== +SELECT l, l IN (SELECT i1.l FROM (SELECT * FROM lists i1 WHERE i1.l=lists.l) i1 JOIN generate_series(1, 2, 1) tbl(s) ON i1.l=ARRAY[tbl.s]) FROM lists ORDER BY l NULLS LAST; +-- +ok +== +SELECT l IN (SELECT i1.l FROM (SELECT * FROM lists i1 WHERE i1.l=lists.l) i1 LEFT JOIN generate_series(1, 2, 1) tbl(s) ON i1.l=ARRAY[tbl.s]) FROM lists ORDER BY l NULLS LAST; +-- +ok +== +SELECT l IN (SELECT i1.l FROM (SELECT * FROM lists i1 WHERE i1.l=lists.l) i1 RIGHT JOIN generate_series(1, 2, 1) tbl(s) ON i1.l=ARRAY[tbl.s]) FROM lists ORDER BY l NULLS LAST; +-- +ok +== +SELECT l IN (SELECT i1.l FROM generate_series(1, 2, 1) tbl(s) LEFT JOIN (SELECT * FROM lists i1 WHERE i1.l=lists.l) i1 ON i1.l=ARRAY[tbl.s]) FROM lists ORDER BY l NULLS LAST; +-- +ok +== +SELECT l IN (SELECT i1.l FROM generate_series(1, 2, 1) tbl(s) RIGHT JOIN (SELECT * FROM lists i1 WHERE i1.l=lists.l) i1 ON i1.l=ARRAY[tbl.s]) FROM lists ORDER BY l NULLS LAST; +-- +ok +== +SELECT l IN (SELECT i1.l FROM (SELECT * FROM lists i1 WHERE i1.l IS NOT DISTINCT FROM lists.l) i1 JOIN generate_series(1, 2, 1) tbl(s) ON i1.l=ARRAY[tbl.s] OR (i1.l IS NULL AND tbl.s IS NULL)) FROM lists ORDER BY l NULLS LAST; +-- +ok +== +SELECT l IN (SELECT i1.l FROM (SELECT * FROM lists i1 WHERE i1.l IS NOT DISTINCT FROM lists.l) i1 LEFT JOIN generate_series(1, 2, 1) tbl(s) ON i1.l=ARRAY[tbl.s] OR (i1.l IS NULL AND tbl.s IS NULL)) FROM lists ORDER BY l NULLS LAST; +-- +ok +== +SELECT l IN (SELECT i1.l FROM (SELECT * FROM lists i1 WHERE i1.l IS NOT DISTINCT FROM lists.l) i1 RIGHT JOIN generate_series(1, 2, 1) tbl(s) ON i1.l=ARRAY[tbl.s] OR (i1.l IS NULL AND tbl.s IS NULL)) FROM lists ORDER BY l NULLS LAST; +-- +ok +== diff --git a/parser/testdata/corpus/sql/subquery/complex/nested_unnest_subquery.test b/parser/testdata/corpus/sql/subquery/complex/nested_unnest_subquery.test new file mode 100644 index 0000000..2628fa8 --- /dev/null +++ b/parser/testdata/corpus/sql/subquery/complex/nested_unnest_subquery.test @@ -0,0 +1,21 @@ +# source: test/sql/subquery/complex/nested_unnest_subquery.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +CREATE TABLE nested_lists(l INTEGER[][]); +-- +ok +== +INSERT INTO nested_lists VALUES (ARRAY[ARRAY[0], ARRAY[1]]), (ARRAY[ARRAY[2], ARRAY[NULL, 3]]), (ARRAY[ARRAY[4, 5], ARRAY[6, 7], ARRAY[], ARRAY[8]]), (NULL), (ARRAY[NULL]::INT[][]); +-- +ok +== +SELECT UNNEST(l) FROM nested_lists +-- +ok +== +SELECT l, (SELECT SUM(a) FROM (SELECT UNNEST(b) AS a FROM (SELECT UNNEST(l) AS b))) FROM nested_lists ORDER BY l +-- +ok +== diff --git a/parser/testdata/corpus/sql/subquery/exists/test_correlated_exists.test b/parser/testdata/corpus/sql/subquery/exists/test_correlated_exists.test new file mode 100644 index 0000000..af3c48c --- /dev/null +++ b/parser/testdata/corpus/sql/subquery/exists/test_correlated_exists.test @@ -0,0 +1,141 @@ +# source: test/sql/subquery/exists/test_correlated_exists.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +SELECT i, EXISTS(SELECT i FROM integers WHERE i1.i>2) FROM integers i1 ORDER BY i; +-- +ok +== +SELECT i, EXISTS(SELECT i FROM integers WHERE i=i1.i) FROM integers i1 ORDER BY i; +-- +ok +== +SELECT i, EXISTS(SELECT i FROM integers WHERE i IS NULL OR i>i1.i*10) FROM integers i1 ORDER BY i; +-- +ok +== +SELECT i, EXISTS(SELECT i FROM integers WHERE i1.i>i OR i1.i IS NULL) FROM integers i1 ORDER BY i; +-- +ok +== +SELECT i FROM integers i1 WHERE EXISTS(SELECT i FROM integers WHERE i=i1.i) ORDER BY i; +-- +ok +== +CREATE TEMP VIEW x(x1, x2) AS VALUES + (2, 1), + (1, 1), + (3, 4); +-- +ok +== +CREATE TEMP VIEW y(y1, y2) AS VALUES + (0, 2), + (1, 4), + (4, 11); +-- +ok +== +CREATE TEMP VIEW z(z1, z2) AS VALUES + (4, 2), + (3, 3), + (8, 1); +-- +ok +== +SELECT * +FROM x +LEFT JOIN y ON x1 = y1 AND EXISTS (SELECT * FROM z WHERE z2 = x2) +ORDER BY x1, x2, y1, y2; +-- +ok +== +SELECT * +FROM x +LEFT JOIN y ON EXISTS (SELECT * FROM z WHERE z2 = x2) +ORDER BY x1, x2, y1, y2; +-- +ok +== +SELECT * +FROM x +LEFT JOIN y ON y1 IN (SELECT z1 FROM z) +ORDER BY x1, x2, y1, y2; +-- +ok +== +SELECT * +FROM x +LEFT JOIN y ON x1 IN (SELECT z1 FROM z) +ORDER BY x1, x2, y1, y2; +-- +ok +== +SELECT EXISTS(SELECT i FROM integers WHERE i>MIN(i1.i)) FROM integers i1; +-- +ok +== +SELECT i, SUM(i) FROM integers i1 GROUP BY i HAVING EXISTS(SELECT i FROM integers WHERE i>MIN(i1.i)) ORDER BY i; +-- +ok +== +SELECT EXISTS(SELECT i+MIN(i1.i) FROM integers WHERE i=3) FROM integers i1; +-- +ok +== +SELECT EXISTS(SELECT i+MIN(i1.i) FROM integers WHERE i=5) FROM integers i1; +-- +ok +== +SELECT EXISTS(SELECT i FROM integers WHERE i=i1.i) AS g, COUNT(*) FROM integers i1 GROUP BY g ORDER BY g; +-- +ok +== +SELECT SUM(CASE WHEN EXISTS(SELECT i FROM integers WHERE i=i1.i) THEN 1 ELSE 0 END) FROM integers i1; +-- +ok +== +SELECT (SELECT COVAR_POP(i1.i, i2.i) FROM integers i2) FROM integers i1 ORDER BY 1 +-- +ok +== +SELECT (SELECT COVAR_POP(i2.i, i1.i) FROM integers i2) FROM integers i1 ORDER BY 1 +-- +ok +== +SELECT (SELECT COVAR_POP(i1.i+i2.i, i1.i+i2.i) FROM integers i2) FROM integers i1 ORDER BY 1 +-- +ok +== +SELECT (SELECT COVAR_POP(i2.i, i2.i) FROM integers i2) FROM integers i1 ORDER BY 1; +-- +ok +== +SELECT (SELECT COVAR_POP(i1.i, i1.i) FROM integers i2 LIMIT 1) FROM integers i1 ORDER BY 1; +-- +ok +== +CREATE TABLE exists_sales(o INTEGER, ship_date INTEGER, wh INTEGER); +-- +ok +== +INSERT INTO exists_sales VALUES + (1, 1, NULL), (1, 0, 1), (1, 0, 2), + (2, 1, 2), (2, 0, 2), + (3, 1, 3), (3, 0, 4); +-- +ok +== +SELECT o, wh, EXISTS( + SELECT 1 + FROM exists_sales s2 + WHERE s1.o=s2.o + AND s1.wh<>s2.wh +) AS ex +FROM exists_sales s1 +WHERE ship_date=1 +ORDER BY o; +-- +ok +== diff --git a/parser/testdata/corpus/sql/subquery/exists/test_correlated_exists_with_derived_table.test b/parser/testdata/corpus/sql/subquery/exists/test_correlated_exists_with_derived_table.test new file mode 100644 index 0000000..24f25da --- /dev/null +++ b/parser/testdata/corpus/sql/subquery/exists/test_correlated_exists_with_derived_table.test @@ -0,0 +1,33 @@ +# source: test/sql/subquery/exists/test_correlated_exists_with_derived_table.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +CREATE TABLE t0(c2 INT); +-- +ok +== +INSERT INTO t0(c2) VALUES (NULL), (1); +-- +ok +== +SELECT t0.c2 FROM t0 +WHERE NOT EXISTS ( + SELECT 1 FROM ( + SELECT t0.c2 AS col0 FROM t0 + ) AS subQuery + WHERE ((t0.c2) IS DISTINCT FROM (subQuery.col0)) +); +-- +ok +== +SELECT t0.c2 FROM t0 +WHERE NOT EXISTS ( + SELECT 1 FROM ( + SELECT t0.c2 AS col0 FROM t0 + ) AS subQuery + WHERE NOT ((t0.c2) IS DISTINCT FROM (subQuery.col0)) +); +-- +ok +== diff --git a/parser/testdata/corpus/sql/subquery/exists/test_exists_union_by_name.test b/parser/testdata/corpus/sql/subquery/exists/test_exists_union_by_name.test new file mode 100644 index 0000000..0835351 --- /dev/null +++ b/parser/testdata/corpus/sql/subquery/exists/test_exists_union_by_name.test @@ -0,0 +1,23 @@ +# source: test/sql/subquery/exists/test_exists_union_by_name.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +SELECT ( + EXISTS( + ( + SELECT + DISTINCT outer_alltypes."BIGINT", outer_alltypes."INT" + FROM all_types inner_alltypes_1 + WHERE inner_alltypes_1."BIGINT" GROUP BY NULL + ) + UNION BY NAME + ( + SELECT inner2."FLOAT" from all_types inner2 + ) + ) IS DISTINCT FROM outer_alltypes."struct" + ) +FROM all_types outer_alltypes GROUP BY ALL; +-- +ok +== diff --git a/parser/testdata/corpus/sql/subquery/exists/test_issue_22267.test b/parser/testdata/corpus/sql/subquery/exists/test_issue_22267.test new file mode 100644 index 0000000..d9b3f12 --- /dev/null +++ b/parser/testdata/corpus/sql/subquery/exists/test_issue_22267.test @@ -0,0 +1,64 @@ +# source: test/sql/subquery/exists/test_issue_22267.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +CREATE TABLE posts ( + id INTEGER, + user_id INTEGER, + title VARCHAR, + content VARCHAR, + views INTEGER, + likes INTEGER, + created_at TIMESTAMP, + rating DOUBLE +); +-- +ok +== +INSERT INTO posts VALUES + (1, 1, 'Hello World', 'First post', 100, 10, '2022-01-10 10:00:00', 4.5), + (2, 1, 'Another Post', NULL, 150, 20, '2022-01-11 11:00:00', 3.0), + (3, 2, 'Bob Post', 'Content', NULL, 5, '2022-01-12 12:00:00', NULL), + (4, 3, NULL, 'Empty', 50, 2, '2022-01-13 13:00:00', 5.0), + (5, 4, 'Last Post', 'Last', 300, 30, '2022-01-14 14:00:00', 4.9); +-- +ok +== +SELECT count(*) +FROM posts AS ref_0 +WHERE EXISTS ( + SELECT 1 + FROM ( + SELECT + ref_0.id AS c0, + ref_1.views AS c1, + ref_1.views AS c2 + FROM posts AS ref_1 + WHERE ref_0.likes > ref_1.likes + ) AS subq_0 + WHERE subq_0.c1 != ref_0.likes +); +-- +ok +== +SELECT count(*) +FROM posts AS ref_0 +WHERE EXISTS ( + SELECT 1 + FROM ( + SELECT + ref_0.id AS c0, + ref_1.views AS c1 + FROM posts AS ref_1 + WHERE ref_0.likes > ref_1.likes + ) AS subq_0 + WHERE subq_0.c1 != ref_0.likes +); +-- +ok +== +DROP TABLE posts; +-- +ok +== diff --git a/parser/testdata/corpus/sql/subquery/exists/test_issue_23979.test b/parser/testdata/corpus/sql/subquery/exists/test_issue_23979.test new file mode 100644 index 0000000..f5e50ce --- /dev/null +++ b/parser/testdata/corpus/sql/subquery/exists/test_issue_23979.test @@ -0,0 +1,51 @@ +# source: test/sql/subquery/exists/test_issue_23979.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +CREATE TABLE issue23979_l(o INTEGER PRIMARY KEY); +-- +ok +== +INSERT INTO issue23979_l VALUES (1), (2); +-- +ok +== +CREATE TABLE issue23979_r(o INTEGER PRIMARY KEY, wh INTEGER NOT NULL); +-- +ok +== +INSERT INTO issue23979_r VALUES (1, 1); +-- +ok +== +CREATE TABLE issue23979_s2(o INTEGER, wh INTEGER); +-- +ok +== +INSERT INTO issue23979_s2 VALUES (1, 2), (2, 3); +-- +ok +== +SELECT l.o, + r.wh, + r.wh <> s2.wh AS direct_comparison, + EXISTS ( + SELECT 1 + FROM issue23979_s2 x + WHERE x.o = l.o + AND r.wh <> x.wh + ) AS correlated_exists, + EXISTS ( + SELECT 1 + FROM issue23979_s2 x + WHERE x.o = l.o + AND (r.wh + 0) <> x.wh + ) AS equivalent_rewrite +FROM issue23979_l l +LEFT JOIN issue23979_r r USING (o) +JOIN issue23979_s2 s2 USING (o) +ORDER BY l.o; +-- +ok +== diff --git a/parser/testdata/corpus/sql/subquery/exists/test_issue_9308.test b/parser/testdata/corpus/sql/subquery/exists/test_issue_9308.test new file mode 100644 index 0000000..0b390db --- /dev/null +++ b/parser/testdata/corpus/sql/subquery/exists/test_issue_9308.test @@ -0,0 +1,25 @@ +# source: test/sql/subquery/exists/test_issue_9308.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +create or replace table t1(c1 int64); +-- +ok +== +create or replace table t2(c1 int64); +-- +ok +== +select c1, not exists (select 1 from t2 where t1.c1 <= t2.c1) from t1; +-- +ok +== +select c1 from t1 where not exists (select 1 from t2 where t1.c1 <= t2.c1); +-- +ok +== +select c1 from t1 anti join t2 on (t1.c1 <= t2.c1) +-- +ok +== diff --git a/parser/testdata/corpus/sql/subquery/exists/test_scalar_exists.test b/parser/testdata/corpus/sql/subquery/exists/test_scalar_exists.test new file mode 100644 index 0000000..4874797 --- /dev/null +++ b/parser/testdata/corpus/sql/subquery/exists/test_scalar_exists.test @@ -0,0 +1,21 @@ +# source: test/sql/subquery/exists/test_scalar_exists.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +SELECT EXISTS(SELECT 1) +-- +ok +== +SELECT EXISTS(SELECT 1) FROM integers +-- +ok +== +SELECT EXISTS(SELECT * FROM integers) +-- +ok +== +SELECT EXISTS(SELECT * FROM integers WHERE i IS NULL) +-- +ok +== diff --git a/parser/testdata/corpus/sql/subquery/exists/test_uncorrelated_exists_subquery.test b/parser/testdata/corpus/sql/subquery/exists/test_uncorrelated_exists_subquery.test new file mode 100644 index 0000000..3ed8494 --- /dev/null +++ b/parser/testdata/corpus/sql/subquery/exists/test_uncorrelated_exists_subquery.test @@ -0,0 +1,61 @@ +# source: test/sql/subquery/exists/test_uncorrelated_exists_subquery.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +SELECT * FROM integers WHERE EXISTS(SELECT 1) ORDER BY i +-- +ok +== +SELECT * FROM integers WHERE EXISTS(SELECT * FROM integers) ORDER BY i +-- +ok +== +SELECT * FROM integers WHERE NOT EXISTS(SELECT * FROM integers) ORDER BY i +-- +ok +== +SELECT * FROM integers WHERE EXISTS(SELECT NULL) ORDER BY i +-- +ok +== +SELECT EXISTS(SELECT * FROM integers WHERE i>10) +-- +ok +== +SELECT EXISTS(SELECT * FROM integers), EXISTS(SELECT * FROM integers) +-- +ok +== +SELECT EXISTS(SELECT * FROM integers) AND EXISTS(SELECT * FROM integers) +-- +ok +== +SELECT EXISTS(SELECT EXISTS(SELECT * FROM integers)) +-- +ok +== +SELECT * FROM integers WHERE 1 IN (SELECT 1) ORDER BY i +-- +ok +== +SELECT * FROM integers WHERE 1 IN (SELECT * FROM integers) ORDER BY i +-- +ok +== +SELECT * FROM integers WHERE 1 IN (SELECT NULL::INTEGER) ORDER BY i +-- +ok +== +SELECT 1 IN (SELECT NULL::INTEGER) FROM integers +-- +ok +== +SELECT NULL IN (SELECT * FROM integers) FROM integers +-- +ok +== +SELECT SUM(i) FROM integers WHERE 1 IN (SELECT * FROM integers) +-- +ok +== diff --git a/parser/testdata/corpus/sql/subquery/lateral/lateral_arrays.test b/parser/testdata/corpus/sql/subquery/lateral/lateral_arrays.test new file mode 100644 index 0000000..db84114 --- /dev/null +++ b/parser/testdata/corpus/sql/subquery/lateral/lateral_arrays.test @@ -0,0 +1,41 @@ +# source: test/sql/subquery/lateral/lateral_arrays.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +CREATE TABLE tbl(i INTEGER, arr INT[]); +-- +ok +== +INSERT INTO tbl VALUES (1, ARRAY[1, 3, 7]), (2, ARRAY[8, NULL]), (3, ARRAY[3, NULL, 4]), (NULL, ARRAY[]::INT[]); +-- +ok +== +SELECT * FROM tbl JOIN LATERAL (SELECT UNNEST(tbl.arr)) t(b) ON (i=b) ORDER BY i; +-- +ok +== +SELECT * FROM tbl JOIN LATERAL (SELECT UNNEST(tbl.arr)) t(b) ON (i<>b) ORDER BY i, b; +-- +ok +== +SELECT * FROM tbl JOIN LATERAL (SELECT UNNEST(tbl.arr)) t(b) ON (i=b) ORDER BY i, b; +-- +ok +== +SELECT * FROM tbl JOIN LATERAL (SELECT UNNEST(ARRAY[tbl.i * tbl.i])) t(b) ON (i>=b) ORDER BY i, b; +-- +ok +== +SELECT * FROM tbl JOIN LATERAL (SELECT x FROM generate_series(0,5,1) t(x) WHERE x>i) t(b) ON (i>=b) ORDER BY i, b; +-- +ok +== +SELECT * FROM tbl JOIN LATERAL (SELECT x FROM generate_series(0,5,1) t(x) WHERE x=b) ORDER BY i, b; +-- +ok +== diff --git a/parser/testdata/corpus/sql/subquery/lateral/lateral_binding_views.test b/parser/testdata/corpus/sql/subquery/lateral/lateral_binding_views.test new file mode 100644 index 0000000..9b4c10c --- /dev/null +++ b/parser/testdata/corpus/sql/subquery/lateral/lateral_binding_views.test @@ -0,0 +1,21 @@ +# source: test/sql/subquery/lateral/lateral_binding_views.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +copy (select date '2000-01-01' as dt) to '{TEST_DIR}/datetest.csv'; +-- +ok +== +create view v1 as select * from read_csv('{TEST_DIR}/datetest.csv', columns={'dt': date}); +-- +ok +== +from v1 +-- +ok +== +select * from (select date '1992-01-01' as date), v1; +-- +ok +== diff --git a/parser/testdata/corpus/sql/subquery/lateral/lateral_fuzzer_1463.test b/parser/testdata/corpus/sql/subquery/lateral/lateral_fuzzer_1463.test new file mode 100644 index 0000000..789428f --- /dev/null +++ b/parser/testdata/corpus/sql/subquery/lateral/lateral_fuzzer_1463.test @@ -0,0 +1,27 @@ +# source: test/sql/subquery/lateral/lateral_fuzzer_1463.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +SELECT * +FROM + (SELECT 42 AS c1) AS ref, + (SELECT a + b + 1 + FROM + (SELECT 1) t1(a), + (SELECT (SELECT (SELECT ref.c1 + 1)) + 1) t2(b) + ) +; +-- +ok +== +SELECT NULL +FROM + (SELECT 42 AS c1) AS ref, + LATERAL (SELECT NULL + FROM + (SELECT NULL) AS r2, + (SELECT (SELECT (SELECT ref.c1))) AS r3) AS r4; +-- +ok +== diff --git a/parser/testdata/corpus/sql/subquery/lateral/lateral_fuzzer_5984_23.test b/parser/testdata/corpus/sql/subquery/lateral/lateral_fuzzer_5984_23.test new file mode 100644 index 0000000..6038d95 --- /dev/null +++ b/parser/testdata/corpus/sql/subquery/lateral/lateral_fuzzer_5984_23.test @@ -0,0 +1,13 @@ +# source: test/sql/subquery/lateral/lateral_fuzzer_5984_23.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +SELECT 1 FROM (SELECT 1) t1(c1), (SELECT TRUE IN (TRUE, t1.c1::VARCHAR LIKE 'a' ESCAPE NULL)); +-- +ok +== +SELECT (SELECT t1.c1::VARCHAR LIKE 'a' ESCAPE NULL) FROM (SELECT 1) t1(c1) +-- +ok +== diff --git a/parser/testdata/corpus/sql/subquery/lateral/lateral_grouping_sets.test b/parser/testdata/corpus/sql/subquery/lateral/lateral_grouping_sets.test new file mode 100644 index 0000000..2b09467 --- /dev/null +++ b/parser/testdata/corpus/sql/subquery/lateral/lateral_grouping_sets.test @@ -0,0 +1,35 @@ +# source: test/sql/subquery/lateral/lateral_grouping_sets.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +select x, a, b +from +(values (1), (2)) t2(x), +lateral (select count(*), count(a) from (select 1, 2 where 1 = x) t(a, b) group by grouping sets ((), (b), (a, b))) t3(a, b) +order by all; +-- +ok +== +select x, a +from +(values (1), (2)) t2(x), +lateral (select sum(a) from (select 1, 2 where 1 = x) t(a, b) group by grouping sets ((), (b), (a, b))) t3(a) +order by all; +-- +ok +== +select * + from + (values (1), (2)) t2(x), lateral (select sum(a) from (select 42 a) where x=1) +order by all +-- +ok +== +select * + from + (values (1), (2)) t2(x) left join (select sum(a) from (select 42 a) where x=1) on (1=1) +order by all +-- +ok +== diff --git a/parser/testdata/corpus/sql/subquery/lateral/lateral_join_aggregate.test b/parser/testdata/corpus/sql/subquery/lateral/lateral_join_aggregate.test new file mode 100644 index 0000000..2139a6b --- /dev/null +++ b/parser/testdata/corpus/sql/subquery/lateral/lateral_join_aggregate.test @@ -0,0 +1,17 @@ +# source: test/sql/subquery/lateral/lateral_join_aggregate.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +SELECT * FROM integers, (SELECT SUM(i)) t(sum); +-- +ok +== +SELECT * FROM integers, LATERAL (SELECT SUM(i)) t(sum); +-- +ok +== +SELECT * FROM integers i1, LATERAL (SELECT SUM(i + i1.i) FROM integers) t(sum) ORDER BY i; +-- +ok +== diff --git a/parser/testdata/corpus/sql/subquery/lateral/lateral_join_chain.test b/parser/testdata/corpus/sql/subquery/lateral/lateral_join_chain.test new file mode 100644 index 0000000..a40b3ca --- /dev/null +++ b/parser/testdata/corpus/sql/subquery/lateral/lateral_join_chain.test @@ -0,0 +1,29 @@ +# source: test/sql/subquery/lateral/lateral_join_chain.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +SELECT * FROM integers, (SELECT [i + 1]) t(k), (SELECT UNNEST(k)) t2(l) ORDER BY i; +-- +ok +== +SELECT * FROM integers, LATERAL (SELECT [i + 1]) t(k), LATERAL (SELECT UNNEST(k)) t2(l) ORDER BY i; +-- +ok +== +SELECT * FROM integers CROSS JOIN LATERAL (SELECT [i + 1]) t(k) CROSS JOIN LATERAL (SELECT UNNEST(k)) t2(l) ORDER BY i; +-- +ok +== +SELECT * FROM integers, (SELECT integers) ORDER BY i +-- +ok +== +SELECT * FROM integers, LATERAL (SELECT integers.*) t2(k) ORDER BY i; +-- +ok +== +SELECT * FROM integers, LATERAL (SELECT *) t2(k) ORDER BY i; +-- +ok +== diff --git a/parser/testdata/corpus/sql/subquery/lateral/lateral_join_generated_columns.test b/parser/testdata/corpus/sql/subquery/lateral/lateral_join_generated_columns.test new file mode 100644 index 0000000..b71a655 --- /dev/null +++ b/parser/testdata/corpus/sql/subquery/lateral/lateral_join_generated_columns.test @@ -0,0 +1,20 @@ +# source: test/sql/subquery/lateral/lateral_join_generated_columns.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +CREATE TABLE tbl ( + x INTEGER, + gen_x AS (x + 5) +); +-- +ok +== +INSERT INTO tbl VALUES (1), (2), (3), (NULL); +-- +ok +== +SELECT * FROM tbl, (SELECT gen_x + 10) ORDER BY x NULLS LAST +-- +ok +== diff --git a/parser/testdata/corpus/sql/subquery/lateral/lateral_join_macro.test b/parser/testdata/corpus/sql/subquery/lateral/lateral_join_macro.test new file mode 100644 index 0000000..477ef50 --- /dev/null +++ b/parser/testdata/corpus/sql/subquery/lateral/lateral_join_macro.test @@ -0,0 +1,19 @@ +# source: test/sql/subquery/lateral/lateral_join_macro.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +CREATE FUNCTION my_func(x) AS (x + x) +-- +ok +== +CREATE TABLE tbl ( + x INTEGER +); +-- +ok +== +SELECT * FROM tbl, (SELECT my_func(x)) ORDER BY x NULLS LAST +-- +ok +== diff --git a/parser/testdata/corpus/sql/subquery/lateral/lateral_large_lists.test b/parser/testdata/corpus/sql/subquery/lateral/lateral_large_lists.test new file mode 100644 index 0000000..cd3484c --- /dev/null +++ b/parser/testdata/corpus/sql/subquery/lateral/lateral_large_lists.test @@ -0,0 +1,17 @@ +# source: test/sql/subquery/lateral/lateral_large_lists.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +SELECT total_seats +FROM ( +SELECT list(distinct {'key': gen_random_uuid(), 'val': 1 }) as l FROM range(0, 1600) +) as m, ( + select sum(a.val) as value + FROM ( + SELECT UNNEST(l) a + ) x +) as l(total_seats) +-- +ok +== diff --git a/parser/testdata/corpus/sql/subquery/lateral/lateral_left_join.test b/parser/testdata/corpus/sql/subquery/lateral/lateral_left_join.test new file mode 100644 index 0000000..c0e3492 --- /dev/null +++ b/parser/testdata/corpus/sql/subquery/lateral/lateral_left_join.test @@ -0,0 +1,61 @@ +# source: test/sql/subquery/lateral/lateral_left_join.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +SELECT * FROM integers LEFT JOIN LATERAL (SELECT integers.i + 1) t(b) ON (i=b) ORDER BY i; +-- +ok +== +SELECT * FROM integers LEFT JOIN LATERAL (SELECT integers.i) t(b) ON (i=b) ORDER BY i; +-- +ok +== +SELECT * FROM integers LEFT JOIN LATERAL (SELECT * FROM integers WHERE i<>integers.i) t(b) ON (i=b) ORDER BY i; +-- +ok +== +SELECT * FROM integers INNER JOIN LATERAL (SELECT integers.i WHERE integers.i IN (1, 3)) t(b) ON (i=b) ORDER BY i; +-- +ok +== +SELECT * FROM integers LEFT JOIN LATERAL (SELECT integers.i WHERE integers.i IN (1, 3)) t(b) ON (i=b) ORDER BY i; +-- +ok +== +SELECT * FROM integers LEFT JOIN LATERAL (SELECT integers.i WHERE integers.i IN (1, 3)) t(b) ON (i+b 1) + where ss1.loc = ss1.lat) as ss2 +where i41.f1 > 0; +-- +ok +== +select ss1.d1 from + tenk1 as t1 + inner join tenk1 as t2 + on t1.tenthous = t2.ten + inner join + int8_tbl as i8 + left join int4_tbl as i4 + inner join (select 64 as d1 + from tenk1 t3, + lateral (select abs(t3.unique1) + random()) ss0(x) + where t3.fivethous < 0) as ss1 + on i4.f1 = ss1.d1 + on i8.q1 = i4.f1 + on t1.tenthous = ss1.d1 +where t1.unique1 < i4.f1; +-- +ok +== +select * from + (select 1 as x) ss1 left join (select 2 as y) ss2 on (true), + lateral (select ss2.y as z limit 1) ss3; +-- +ok +== +select * from + (select 0 as z) as t1 + left join + (select true as a) as t2 + on true, + lateral (select true as b + union all + select a as b) as t3 +where b; +-- +ok +== +select * from + text_tbl t1 + left join int8_tbl i8 + on i8.q2 = 123, + lateral (select i8.q1, t2.f1 from text_tbl t2 limit 1) as ss +where t1.f1 = ss.f1; +-- +ok +== +select * from + text_tbl t1 + left join int8_tbl i8 + on i8.q2 = 123, + lateral (select i8.q1, t2.f1 from text_tbl t2 limit 1) as ss1, + lateral (select ss1.* from text_tbl t3 limit 1) as ss2 +where t1.f1 = ss2.f1; +-- +ok +== +select 1 from + text_tbl as tt1 + inner join text_tbl as tt2 on (tt1.f1 = 'foo') + left join text_tbl as tt3 on (tt3.f1 = 'foo') + left join text_tbl as tt4 on (tt3.f1 = tt4.f1), + lateral (select tt4.f1 as c0 from text_tbl as tt5 limit 1) as ss1 +where tt1.f1 = ss1.c0; +-- +ok +== +select ss2.* from + int4_tbl i41 + left join int8_tbl i8 + join (select i42.f1 as c1, i43.f1 as c2, 42 as c3 + from int4_tbl i42, int4_tbl i43) ss1 + on i8.q1 = ss1.c2 + on i41.f1 = ss1.c1, + lateral (select i41.*, i8.*, ss1.* from text_tbl limit 1) ss2 +where ss1.c2 = 0; +-- +ok +== +select i8.*, ss.v, t.unique2 + from int8_tbl i8 + left join int4_tbl i4 on i4.f1 = 1 + left join lateral (select i4.f1 + 1 as v) as ss on true + left join tenk1 t on t.unique2 = ss.v +where q2 = 456; +-- +ok +== +select unique2, x.* +from tenk1 a, lateral (select * from int4_tbl b where f1 = a.unique1) x; +-- +ok +== +select unique2, x.* +from int4_tbl x, lateral (select unique2 from tenk1 where f1 = unique1) ss; +-- +ok +== +select unique2, x.* +from int4_tbl x left join lateral (select unique1, unique2 from tenk1 where f1 = unique1) ss on true +order by all; +-- +ok +== +select *, (select r from (select q1 as q2) x, (select q2 as r) y) from int8_tbl; +-- +ok +== +select *, (select r from (select q1 as q2) x, lateral (select q2 as r) y) from int8_tbl; +-- +ok +== +select count(*) from tenk1 a, lateral generate_series(1,two) g; +-- +ok +== +select * from generate_series(100,200) g(g), + lateral (select * from int8_tbl a where g = q1 union all + select * from int8_tbl b where g = q2) ss; +-- +ok +== +select count(*) from tenk1 a, + tenk1 b join lateral (values(a.unique1)) ss(x) on b.unique2 = ss.x; +-- +ok +== +select count(*) from tenk1 a, + tenk1 b join lateral (values(a.unique1),(-1)) ss(x) on b.unique2 = ss.x; +-- +ok +== +select * from (select f1/2 as x from int4_tbl) ss1 join int4_tbl i4 on x = f1, + lateral (select x) ss2(y); +-- +ok +== +select * from (select f1 as x from int4_tbl) ss1 join int4_tbl i4 on x = f1, + lateral (values(x)) ss2(y); +-- +ok +== +select * from ((select f1/2 as x from int4_tbl) ss1 join int4_tbl i4 on x = f1) j, + lateral (select x) ss2(y); +-- +ok +== +select * from (values(1)) x(lb), + lateral generate_series(lb,4) x4 +ORDER BY ALL; +-- +ok +== +select * from (select f1/1000000000 from int4_tbl) x(lb), + lateral generate_series(lb,4) x4 +ORDER BY ALL; +-- +ok +== +select * from (values(1)) x(lb), + lateral (values(lb)) y(lbcopy); +-- +ok +== +select * from (values(1)) x(lb), + lateral (select lb from int4_tbl) y(lbcopy); +-- +ok +== +select x.* from + int8_tbl x left join (select q1,coalesce(q2,0) q2 from int8_tbl) y on x.q2 = y.q1, + lateral (select x.q1,y.q1,y.q2) v(xq1,yq1,yq2) order by 1, 2; +-- +ok +== +select 1 from tenk1 a, lateral (select max(a.unique1) from int4_tbl b) ss; +-- +ok +== +create table xx1 as select f1 as x1, -f1 as x2 from int4_tbl; +-- +ok +== +select * from xx1; +-- +ok +== +update xx1 set x2 = f1 from (select * from int4_tbl where f1 = x1) ss; +-- +ok +== +update xx1 set x2 = f1 from (select * from int4_tbl where f1 = xx1.x1) ss; +-- +ok +== +update xx1 set x2 = f1 from lateral (select * from int4_tbl where f1 = x1) ss; +-- +ok +== +update xx1 set x2 = f1 from xx1 AS xx2, lateral (select * from int4_tbl where f1 = xx2.x1 AND f1=-2147483647) ss; +-- +ok +== +delete from xx1 using (select * from int4_tbl where f1 = x1) ss; +-- +ok +== +delete from xx1 using (select * from int4_tbl where f1 = xx1.x1) ss; +-- +ok +== +delete from xx1 using lateral (select * from int4_tbl where f1 = x1) ss; +-- +ok +== diff --git a/parser/testdata/corpus/sql/subquery/lateral/test_lateral_join.test b/parser/testdata/corpus/sql/subquery/lateral/test_lateral_join.test new file mode 100644 index 0000000..67e6a2b --- /dev/null +++ b/parser/testdata/corpus/sql/subquery/lateral/test_lateral_join.test @@ -0,0 +1,148 @@ +# source: test/sql/subquery/lateral/test_lateral_join.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +select (select MIN(val) from unnest((select a)) t(val)) from (select ARRAY[1, 2, 3, NULL]) t(a); +-- +ok +== +select (select MIN(val) from unnest((select (select a))) t(val)) from (select ARRAY[1, 2, 3, NULL]) t(a); +-- +ok +== +select * from (select array[1, 2, 3] a), unnest((select (select (select a)))) +-- +ok +== +select (select MIN(val) from unnest(a) t(val)) from (select ARRAY[1, 2, 3, NULL]) t(a); +-- +ok +== +select * from (select 42) t(a), (select t.a + 1); +-- +ok +== +select * from (select 42) t(a) cross join lateral (select t.a + 1); +-- +ok +== +select * from (select 42 union all select 84) t(a), (select t.a + 1) ORDER BY ALL; +-- +ok +== +select * from (select [42, 43, 44]) t(a), (select unnest(t.a)) order by all; +-- +ok +== +select * from (select [42, 43, 44]) t(a), (select unnest(t.a)) t2(b) where b=43; +-- +ok +== +select * from (select [42, 43, 44] union all select [45, NULL, 46]) t(a), (select unnest(t.a)) t2(b) order by all; +-- +ok +== +select sum(b) from (select [42, 43, 44] union all select [45, NULL, 46]) t(a), (select unnest(t.a)) t2(b); +-- +ok +== +select a, sum(b) from (select [42, 43, 44] union all select [45, NULL, 46]) t(a), (select unnest(t.a)) t2(b) group by a order by a; +-- +ok +== +select * from (select array[42, 43, 44]) t(a) join (select unnest(t.a)) t2(b) on (true) order by all; +-- +ok +== +select * from (select array[42, 43, 44]) t(a) join lateral (select unnest(t.a)) t2(b) on (true) order by all; +-- +ok +== +select * from (select array[42, 43, 44]) t(a) join lateral (select unnest(t.a)) t2(b) on (a[1]=b); +-- +ok +== +select * from (select array[42, 43, 44]) t(a) join lateral (select unnest(t.a)) t2(b) on (a[1]=80); +-- +ok +== +select * from (select ARRAY[42, 43, 44]) t(a) join lateral (select * from unnest(t.a)) t2(b) on (true) ORDER BY b; +-- +ok +== +SELECT * +FROM generate_series(1,3) AS input(n), +LATERAL ( + WITH RECURSIVE subquery(x) AS ( + (SELECT n, true AS exists) + UNION ALL + SELECT x - 1, y + FROM subquery AS _(x), + LATERAL ( + SELECT NOT EXISTS ( + SELECT 1 + FROM subquery AS input(a) + WHERE a > _.x + ) + ) AS __(y) + WHERE x > 0 + ) + TABLE subquery +) +ORDER BY n, x; +-- +ok +== +CREATE TABLE students(id INTEGER, name VARCHAR, major VARCHAR, year INTEGER) +-- +ok +== +CREATE TABLE exams(sid INTEGER, course VARCHAR, curriculum VARCHAR, grade INTEGER, year INTEGER) +-- +ok +== +INSERT INTO students VALUES (1, 'Mark', 'CS', 2017) +-- +ok +== +INSERT INTO students VALUES (2, 'Dirk', 'CS', 2017) +-- +ok +== +INSERT INTO exams VALUES (1, 'Database Systems', 'CS', 10, 2015) +-- +ok +== +INSERT INTO exams VALUES (1, 'Graphics', 'CS', 9, 2016) +-- +ok +== +INSERT INTO exams VALUES (2, 'Database Systems', 'CS', 7, 2015) +-- +ok +== +INSERT INTO exams VALUES (2, 'Graphics', 'CS', 7, 2016) +-- +ok +== +SELECT name, total FROM students JOIN LATERAL (SELECT SUM(grade) AS total FROM exams WHERE exams.sid=students.id) grades ON true ORDER BY total DESC; +-- +ok +== +SELECT name, total FROM students, (SELECT SUM(grade) AS total FROM exams WHERE exams.sid=students.id) grades ORDER BY total DESC; +-- +ok +== diff --git a/parser/testdata/corpus/sql/subquery/scalar/array_order_subquery.test b/parser/testdata/corpus/sql/subquery/scalar/array_order_subquery.test new file mode 100644 index 0000000..f6dcf02 --- /dev/null +++ b/parser/testdata/corpus/sql/subquery/scalar/array_order_subquery.test @@ -0,0 +1,91 @@ +# source: test/sql/subquery/scalar/array_order_subquery.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +select + array(select distinct i from t order by i desc) as a, + array(select distinct i from t order by i desc) as b, + array(select distinct i from t order by i desc) as c; +-- +ok +== +select array(select unnest(l) AS i order by i desc nulls last) as a from (values ([NULL, 1, 2, 3, 4]), ([5, 6, NULL, 7, 8]), ([]), ([10, 11, 12])) t(l) ORDER BY ALL; +-- +ok +== +select array(select unnest(l) AS i order by i desc nulls first) as a from (values ([NULL, 1, 2, 3, 4]), ([5, 6, NULL, 7, 8]), ([]), ([10, 11, 12])) t(l) ORDER BY ALL; +-- +ok +== +SELECT ARRAY(SELECT i FROM t ORDER BY rowid DESC) +-- +ok +== +SELECT ARRAY(SELECT i FROM t ORDER BY t.rowid) +-- +ok +== +SELECT ARRAY + (SELECT 1 UNION ALL + SELECT 2 UNION ALL + SELECT 3 + ORDER by 1) AS new_array; +-- +ok +== +select + array(select distinct i from t order by t.i desc) as a +-- +ok +== +select + array(select distinct i from t union all select distinct i from t order by t.i desc) as a +-- +ok +== +select + array(select distinct i from t order by x.i desc) as a +-- +ok +== +SELECT ARRAY + (SELECT 1 UNION ALL + SELECT 2 UNION ALL + SELECT 3 + ORDER by 1 DESC) AS new_array; +-- +ok +== +select array(select * from unnest(['a', 'b']) as _t(u) order by if(u='a',100, 1)) as out; +-- +ok +== +select array(select * from unnest(['a', 'b']) as _t(u) order by if(u='a',100, 1) desc) as out; +-- +ok +== +SELECT ARRAY + (SELECT 1 UNION ALL + SELECT 2 UNION ALL + SELECT 3 + ORDER by -1) AS new_array; +-- +ok +== +SELECT ARRAY + (SELECT 1 UNION ALL + SELECT 2 UNION ALL + SELECT 3 + ORDER by 2) AS new_array; +-- +ok +== +SELECT ARRAY + (SELECT 1 UNION ALL + SELECT 2 UNION ALL + SELECT 3 + ORDER by 'hello world') AS new_array; +-- +ok +== diff --git a/parser/testdata/corpus/sql/subquery/scalar/array_subquery.test b/parser/testdata/corpus/sql/subquery/scalar/array_subquery.test new file mode 100644 index 0000000..f143d30 --- /dev/null +++ b/parser/testdata/corpus/sql/subquery/scalar/array_subquery.test @@ -0,0 +1,57 @@ +# source: test/sql/subquery/scalar/array_subquery.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +SELECT i, ARRAY( + SELECT 42 +) top +FROM integers i1 +ORDER BY i +-- +ok +== +SELECT i, ARRAY( + SELECT i FROM integers WHERE i1.i=i +) top +FROM integers i1 +ORDER BY i +-- +ok +== +SELECT i, ARRAY( + SELECT i FROM integers WHERE i>i1.i ORDER BY i ASC NULLS FIRST +) top +FROM integers i1 +ORDER BY i +-- +ok +== +SELECT i, ARRAY( + SELECT i1.i FROM integers i1, integers i2, integers i3, integers i4 WHERE i1.i=integers.i LIMIT 3 +) top +FROM integers +ORDER BY i +-- +ok +== +SELECT i, ARRAY( + SELECT i1.i FROM integers i1, integers i2, integers i3, integers i4 WHERE i1.i=integers.i LIMIT 3 OFFSET 3 +) top +FROM integers +ORDER BY i +-- +ok +== +SELECT i, ARRAY( + SELECT i1.i FROM integers i1, integers i2, integers i3, integers i4 WHERE i1.i=integers.i LIMIT 3 OFFSET 62 +) top +FROM integers +ORDER BY i +-- +ok +== +select array(select 1,2) +-- +ok +== diff --git a/parser/testdata/corpus/sql/subquery/scalar/coalesce_subquery.test b/parser/testdata/corpus/sql/subquery/scalar/coalesce_subquery.test new file mode 100644 index 0000000..09b0dcc --- /dev/null +++ b/parser/testdata/corpus/sql/subquery/scalar/coalesce_subquery.test @@ -0,0 +1,9 @@ +# source: test/sql/subquery/scalar/coalesce_subquery.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +SELECT 1 FROM (select 4) v1(vc0) WHERE (3) NOT IN (COALESCE((SELECT 1 WHERE FALSE), v1.vc0)); +-- +ok +== diff --git a/parser/testdata/corpus/sql/subquery/scalar/correlated_missing_columns.test b/parser/testdata/corpus/sql/subquery/scalar/correlated_missing_columns.test new file mode 100644 index 0000000..0fe988b --- /dev/null +++ b/parser/testdata/corpus/sql/subquery/scalar/correlated_missing_columns.test @@ -0,0 +1,37 @@ +# source: test/sql/subquery/scalar/correlated_missing_columns.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +SELECT (SELECT l_linestat FROM orders) FROM lineitem +-- +ok +== +SELECT (SELECT l_returnfla FROM orders) FROM lineitem +-- +ok +== +SELECT (SELECT o_totalp FROM orders) FROM lineitem +-- +ok +== +SELECT * FROM lineitem WHERE (SELECT SUM(l_orderkey) > 0) +-- +ok +== +SELECT * FROM lineitem WHERE (SELECT SUM(o_orderke) FROM orders) +-- +ok +== +SELECT * FROM lineitem WHERE (SELECT SUM(o_orderke) OVER () FROM orders) +-- +ok +== +SELECT * FROM lineitem GROUP BY (SELECT SUM(o_orderke) OVER () FROM orders) +-- +ok +== +SELECT * FROM lineitem LIMIT (SELECT SUM(o_orderke) FROM orders LIMIT 1) +-- +ok +== diff --git a/parser/testdata/corpus/sql/subquery/scalar/correlated_pivot.test b/parser/testdata/corpus/sql/subquery/scalar/correlated_pivot.test new file mode 100644 index 0000000..0e9e2cc --- /dev/null +++ b/parser/testdata/corpus/sql/subquery/scalar/correlated_pivot.test @@ -0,0 +1,57 @@ +# source: test/sql/subquery/scalar/correlated_pivot.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +SELECT DaysToManufacture, StandardCost, (SELECT ["0", "1", "2", "3", "4"] FROM + (SELECT DaysToManufacture, StandardCost) AS SourceTable + PIVOT + ( + AVG(StandardCost) + FOR DaysToManufacture IN (0, 1, 2, 3, 4) + ) AS PivotTable +) +FROM Product +-- +ok +== +SELECT DaysToManufacture, StandardCost, (SELECT cost FROM + (SELECT DaysToManufacture, StandardCost) AS SourceTable + PIVOT + ( + AVG(StandardCost) + FOR DaysToManufacture IN (0, 1, 2, 3, 4) + ) AS PivotTable + UNPIVOT + ( + cost FOR days IN (0, 1, 2, 3, 4) + ) +) +FROM Product +-- +ok +== +SELECT DaysToManufacture, StandardCost, (SELECT LIST(cost) FROM + (SELECT DaysToManufacture, StandardCost) AS SourceTable + PIVOT + ( + AVG(StandardCost) + FOR DaysToManufacture IN (0, 1, 2, 3, 4) + ) AS PivotTable + UNPIVOT INCLUDE NULLS + ( + cost FOR days IN (0, 1, 2, 3, 4) + ) +) +FROM Product +-- +ok +== +SET pivot_filter_threshold TO DEFAULT +-- +ok +== +RESET SESSION pivot_filter_threshold +-- +ok +== diff --git a/parser/testdata/corpus/sql/subquery/scalar/correlated_pivot_error.test b/parser/testdata/corpus/sql/subquery/scalar/correlated_pivot_error.test new file mode 100644 index 0000000..93350ab --- /dev/null +++ b/parser/testdata/corpus/sql/subquery/scalar/correlated_pivot_error.test @@ -0,0 +1,17 @@ +# source: test/sql/subquery/scalar/correlated_pivot_error.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +SELECT DaysToManufacture, StandardCost, (SELECT ["0", "1", "2", "3", "4"] FROM + (SELECT DaysToManufacture < StandardCost) AS SourceTable + PIVOT + ( + AVG(StandardCost) + FOR DaysToManufacture IN (0, 1, 2, 3, 4) + ) AS PivotTable +) +FROM Product +-- +ok +== diff --git a/parser/testdata/corpus/sql/subquery/scalar/in_multiple_columns.test b/parser/testdata/corpus/sql/subquery/scalar/in_multiple_columns.test new file mode 100644 index 0000000..1156e11 --- /dev/null +++ b/parser/testdata/corpus/sql/subquery/scalar/in_multiple_columns.test @@ -0,0 +1,25 @@ +# source: test/sql/subquery/scalar/in_multiple_columns.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +CREATE TABLE table1(x INTEGER, y INTEGER); +-- +ok +== +INSERT INTO table1 VALUES (NULL, 2), (1, NULL); +-- +ok +== +CREATE TABLE table2(i INTEGER); +-- +ok +== +INSERT INTO table2 VALUES (1), (2), (3); +-- +ok +== +SELECT (x, y) IN (SELECT i, i + 1 FROM table2) from table1; +-- +ok +== diff --git a/parser/testdata/corpus/sql/subquery/scalar/nested_subquery_window.test b/parser/testdata/corpus/sql/subquery/scalar/nested_subquery_window.test new file mode 100644 index 0000000..44e40e9 --- /dev/null +++ b/parser/testdata/corpus/sql/subquery/scalar/nested_subquery_window.test @@ -0,0 +1,17 @@ +# source: test/sql/subquery/scalar/nested_subquery_window.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +SELECT (SELECT max((SELECT subq_0.c0 AS c1))) FROM (SELECT NULL AS c0) AS subq_0; +-- +ok +== +SELECT (SELECT max(42) OVER (PARTITION BY (SELECT subq_0.c0 AS c1)) AS c6) FROM (SELECT NULL AS c0) AS subq_0; +-- +ok +== +SELECT (SELECT max((SELECT subq_0.c0 AS c1)) OVER () AS c6) FROM (SELECT NULL AS c0) AS subq_0; +-- +ok +== diff --git a/parser/testdata/corpus/sql/subquery/scalar/order_by_correlated.test b/parser/testdata/corpus/sql/subquery/scalar/order_by_correlated.test new file mode 100644 index 0000000..5f1fb6e --- /dev/null +++ b/parser/testdata/corpus/sql/subquery/scalar/order_by_correlated.test @@ -0,0 +1,29 @@ +# source: test/sql/subquery/scalar/order_by_correlated.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +SELECT i, ( + SELECT * FROM integers WHERE i>i1.i ORDER BY i ASC NULLS FIRST LIMIT 1 +) top +FROM integers i1 +ORDER BY i +-- +ok +== +SELECT i, ( + SELECT * FROM integers WHERE i>i1.i ORDER BY i DESC NULLS FIRST LIMIT 1 +) top +FROM integers i1 +ORDER BY i +-- +ok +== +SELECT i, ARRAY( + SELECT * FROM integers WHERE i>i1.i ORDER BY i +) top +FROM integers i1 +ORDER BY i +-- +ok +== diff --git a/parser/testdata/corpus/sql/subquery/scalar/subquery_row_in_any.test b/parser/testdata/corpus/sql/subquery/scalar/subquery_row_in_any.test new file mode 100644 index 0000000..4f82f6e --- /dev/null +++ b/parser/testdata/corpus/sql/subquery/scalar/subquery_row_in_any.test @@ -0,0 +1,50 @@ +# source: test/sql/subquery/scalar/subquery_row_in_any.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +SELECT (1, 2) IN (SELECT i, i + 1 FROM integers) +-- +ok +== +SELECT (date '1992-01-02', 2) IN (SELECT date '1992-01-01' + interval (i) days, i + 1 FROM integers) +-- +ok +== +SELECT (1, 2) IN (SELECT (i, i + 1) FROM integers) +-- +ok +== +SELECT row(1) IN (SELECT i FROM integers) +-- +ok +== +SELECT ROW(1, 2) IN (SELECT i, i + 1 FROM integers) +-- +ok +== +SELECT ROW(1, 2) IN (SELECT i, i + 2 FROM integers) +-- +ok +== +SELECT ROW(1, 2) IN (SELECT i, i + 2 FROM integers WHERE i IS NOT NULL) +-- +ok +== +select 1 where (1,2) in (select 1,2); +-- +ok +== +select 1 where (1,2) not in (select 1,2); +-- +ok +== +SELECT (1, 2) IN (SELECT (i, i + 1, i + 2) FROM integers) +-- +ok +== +SELECT ROW(1, 2) IN (SELECT i1.i, i1.i + 1) +FROM integers i1 +-- +ok +== diff --git a/parser/testdata/corpus/sql/subquery/scalar/test_complex_correlated_subquery.test b/parser/testdata/corpus/sql/subquery/scalar/test_complex_correlated_subquery.test new file mode 100644 index 0000000..939d999 --- /dev/null +++ b/parser/testdata/corpus/sql/subquery/scalar/test_complex_correlated_subquery.test @@ -0,0 +1,115 @@ +# source: test/sql/subquery/scalar/test_complex_correlated_subquery.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +SELECT i, (SELECT s1.i FROM (SELECT * FROM integers WHERE i=i1.i) s1) AS j FROM integers i1 ORDER BY i; +-- +ok +== +SELECT i, (SELECT s1.i FROM (SELECT i FROM integers WHERE i=i1.i) s1 INNER JOIN (SELECT i FROM integers WHERE i=4-i1.i) s2 ON s1.i>s2.i) AS j FROM integers i1 ORDER BY i; +-- +ok +== +SELECT i, (SELECT s1.i FROM integers s1, integers s2 WHERE s1.i=s2.i AND s1.i=4-i1.i) AS j FROM integers i1 ORDER BY i; +-- +ok +== +SELECT i, (SELECT s1.i FROM integers s1 INNER JOIN integers s2 ON s1.i=s2.i AND s1.i=4-i1.i) AS j FROM integers i1 ORDER BY i; +-- +ok +== +SELECT * FROM integers s1 INNER JOIN integers s2 ON (SELECT 2*SUM(i)*s1.i FROM integers)=(SELECT SUM(i)*s2.i FROM integers) ORDER BY s1.i; +-- +ok +== +SELECT * FROM integers s1 INNER JOIN integers s2 ON (SELECT s1.i=s2.i) ORDER BY s1.i; +-- +ok +== +SELECT * FROM integers s1 INNER JOIN integers s2 ON (SELECT s1.i=i FROM integers WHERE s2.i=i) ORDER BY s1.i; +-- +ok +== +SELECT * FROM integers s1 LEFT OUTER JOIN integers s2 ON (SELECT 2*SUM(i)*s1.i FROM integers)=(SELECT SUM(i)*s2.i FROM integers) ORDER BY s1.i; +-- +ok +== +SELECT * FROM integers s1 LEFT OUTER JOIN integers s2 ON (SELECT CASE WHEN s1.i+s2.i>10 THEN TRUE ELSE FALSE END) ORDER BY s1.i; +-- +ok +== +SELECT * FROM integers s1 LEFT OUTER JOIN integers s2 ON s1.i=s2.i AND (SELECT CASE WHEN s2.i>2 THEN TRUE ELSE FALSE END) ORDER BY s1.i; +-- +ok +== +SELECT * +FROM integers s1 +LEFT OUTER JOIN integers s2 + ON s1.i=s2.i AND (SELECT CASE WHEN s1.i>2 THEN TRUE ELSE FALSE END) +ORDER BY s1.i; +-- +ok +== +SELECT i, + (SELECT SUM(s2.i) + FROM integers s1 + LEFT OUTER JOIN integers s2 + ON s1.i=s2.i AND EXISTS(SELECT 1 WHERE i1.i > 1)) AS j +FROM integers i1 +ORDER BY i; +-- +ok +== +SELECT i, (SELECT SUM(s1.i) FROM integers s1 LEFT OUTER JOIN integers s2 ON s1.i=s2.i OR s1.i=i1.i-1) AS j FROM integers i1 ORDER BY i; +-- +ok +== +SELECT i, (SELECT SUM(s1.i) FROM integers s1 FULL OUTER JOIN integers s2 ON s1.i=s2.i OR s1.i=i1.i-1) AS j FROM integers i1 ORDER BY i; +-- +ok +== +SELECT i, (SELECT row_number() OVER (ORDER BY i)) FROM integers i1 ORDER BY i; +-- +ok +== +SELECT i1.i, + (SELECT SUM(s1.i) + FROM integers s1 + WHERE s1.i = i1.i + AND s1.i = ANY (SELECT i2.i FROM integers i2 WHERE i2.i = s1.i)) +FROM integers i1 +ORDER BY i1.i; +-- +ok +== +SELECT i1.i, + (SELECT SUM(s1.i) + FROM integers s1 + WHERE s1.i = i1.i + AND EXISTS (SELECT 1 FROM integers i2 WHERE i2.i = s1.i)) +FROM integers i1 +ORDER BY i1.i; +-- +ok +== +SELECT i, (SELECT i FROM integers WHERE i=i1.i UNION SELECT i FROM integers WHERE i=i1.i) AS j FROM integers i1 ORDER BY i; +-- +ok +== +SELECT i, (SELECT i FROM integers WHERE i IS NOT NULL EXCEPT SELECT i FROM integers WHERE i<>i1.i) AS j FROM integers i1 WHERE i IS NOT NULL ORDER BY i; +-- +ok +== +SELECT i, (SELECT i FROM integers WHERE i=i1.i INTERSECT SELECT i FROM integers WHERE i=i1.i) AS j FROM integers i1 ORDER BY i; +-- +ok +== +SELECT i, (SELECT i FROM integers WHERE i=i1.i UNION SELECT i FROM integers WHERE i<>i1.i EXCEPT SELECT i FROM integers WHERE i<>i1.i) AS j FROM integers i1 ORDER BY i; +-- +ok +== +SELECT i, (SELECT (SELECT SUM(i) FROM integers)+42+i1.i) AS j FROM integers i1 ORDER BY i; +-- +ok +== diff --git a/parser/testdata/corpus/sql/subquery/scalar/test_complex_nested_correlated_subquery.test b/parser/testdata/corpus/sql/subquery/scalar/test_complex_nested_correlated_subquery.test new file mode 100644 index 0000000..a451d38 --- /dev/null +++ b/parser/testdata/corpus/sql/subquery/scalar/test_complex_nested_correlated_subquery.test @@ -0,0 +1,41 @@ +# source: test/sql/subquery/scalar/test_complex_nested_correlated_subquery.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +CREATE TABLE tbl(a TINYINT, b SMALLINT, c INTEGER, d BIGINT, e VARCHAR, f DATE, g TIMESTAMP) +-- +ok +== +INSERT INTO tbl VALUES (1, 2, 3, 4, '5', DATE '1992-01-01', TIMESTAMP '1992-01-01 00:00:00') +-- +ok +== +SELECT EXISTS(SELECT t1.b+t1.c) FROM tbl t1 +-- +ok +== +SELECT t1.c+(SELECT t1.b FROM tbl t2 WHERE EXISTS(SELECT t1.b+t2.a)) FROM tbl t1 +-- +ok +== +SELECT 1 FROM tbl t1 JOIN tbl t2 ON (t1.d=t2.d) WHERE EXISTS(SELECT t1.c FROM tbl t3 WHERE t1.d+t3.c<100 AND EXISTS(SELECT t2.f < DATE '2000-01-01')) +-- +ok +== +SELECT EXISTS(SELECT 1 WHERE (t1.c>100 OR 1) AND t1.d<100) FROM tbl t1 +-- +ok +== +SELECT EXISTS(SELECT t1.c,t1.d WHERE t1.d<100) FROM tbl t1 +-- +ok +== +SELECT * FROM tbl t1 LEFT JOIN tbl t2 ON (SELECT t2.a)<100 +-- +ok +== +SELECT * FROM tbl t1 LEFT JOIN tbl t2 ON (SELECT t2.a)>100 +-- +ok +== diff --git a/parser/testdata/corpus/sql/subquery/scalar/test_correlated_grouping_set.test b/parser/testdata/corpus/sql/subquery/scalar/test_correlated_grouping_set.test new file mode 100644 index 0000000..63166d9 --- /dev/null +++ b/parser/testdata/corpus/sql/subquery/scalar/test_correlated_grouping_set.test @@ -0,0 +1,25 @@ +# source: test/sql/subquery/scalar/test_correlated_grouping_set.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +SELECT i, (SELECT COUNT(*) FROM (SELECT i1.i FROM integers GROUP BY GROUPING SETS(i1.i)) tbl) AS j FROM integers i1 ORDER BY i; +-- +ok +== +SELECT i, (SELECT COUNT(*) FROM (SELECT i1.i FROM integers GROUP BY GROUPING SETS((i1.i), (), (i1.i), (i1.i, i1.i))) tbl) AS j FROM integers i1 ORDER BY i; +-- +ok +== +SELECT i, (SELECT COUNT(*) FROM (SELECT i1.i FROM integers GROUP BY ROLLUP (i1.i, i1.i, i1.i, i1.i)) tbl) AS j FROM integers i1 ORDER BY i; +-- +ok +== +SELECT i, (SELECT COUNT(*) FROM (SELECT i1.i FROM integers GROUP BY CUBE (i1.i, i1.i, i1.i, i1.i)) tbl) AS j FROM integers i1 ORDER BY i; +-- +ok +== +SELECT i, (SELECT MIN(i) FROM integers GROUP BY GROUPING SETS(i1.i, i) HAVING i1.i=i) AS j FROM integers i1 ORDER BY i; +-- +ok +== diff --git a/parser/testdata/corpus/sql/subquery/scalar/test_correlated_set_op.test b/parser/testdata/corpus/sql/subquery/scalar/test_correlated_set_op.test new file mode 100644 index 0000000..5a40d67 --- /dev/null +++ b/parser/testdata/corpus/sql/subquery/scalar/test_correlated_set_op.test @@ -0,0 +1,17 @@ +# source: test/sql/subquery/scalar/test_correlated_set_op.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +SELECT i, (SELECT SUM(x) FROM (SELECT 1 UNION ALL SELECT 2 UNION ALL SELECT i1.i) t(x)) FROM integers i1 ORDER BY i; +-- +ok +== +SELECT i, (SELECT SUM(x) FROM (SELECT i1.i UNION ALL SELECT 2 UNION ALL SELECT 1) t(x)) FROM integers i1 ORDER BY i; +-- +ok +== +SELECT i, (SELECT SUM(x) FROM (SELECT 2 UNION ALL SELECT i1.i UNION ALL SELECT 1) t(x)) FROM integers i1 ORDER BY i; +-- +ok +== diff --git a/parser/testdata/corpus/sql/subquery/scalar/test_correlated_side_effects.test b/parser/testdata/corpus/sql/subquery/scalar/test_correlated_side_effects.test new file mode 100644 index 0000000..2f3af8a --- /dev/null +++ b/parser/testdata/corpus/sql/subquery/scalar/test_correlated_side_effects.test @@ -0,0 +1,28 @@ +# source: test/sql/subquery/scalar/test_correlated_side_effects.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +SELECT COUNT(DISTINCT + (SELECT concat(gen_random_uuid()::VARCHAR, r::VARCHAR)) + ) as total_seats +FROM (SELECT 1 FROM generate_series(1, 100, 1)) AS t(r) +-- +ok +== +CREATE SEQUENCE correlated_effect_seq START 1; +-- +ok +== +SELECT count(*) FILTER (WHERE result), currval('correlated_effect_seq') +FROM ( + SELECT EXISTS ( + SELECT 1 + WHERE nextval('correlated_effect_seq') = 2 + AND outer_values.a = 1 + ) AS result + FROM (VALUES (1, 1), (2, 1)) outer_values(id, a) +); +-- +ok +== diff --git a/parser/testdata/corpus/sql/subquery/scalar/test_correlated_subquery.test b/parser/testdata/corpus/sql/subquery/scalar/test_correlated_subquery.test new file mode 100644 index 0000000..74fac54 --- /dev/null +++ b/parser/testdata/corpus/sql/subquery/scalar/test_correlated_subquery.test @@ -0,0 +1,89 @@ +# source: test/sql/subquery/scalar/test_correlated_subquery.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +SELECT i, (SELECT 42+i1.i) AS j FROM integers i1 ORDER BY i; +-- +ok +== +SELECT i FROM integers i1 ORDER BY (SELECT 100-i1.i); +-- +ok +== +SELECT i, (SELECT 42+i1.i FROM integers) AS j FROM integers i1 ORDER BY i; +-- +ok +== +SET scalar_subquery_error_on_multiple_rows=true +-- +ok +== +SELECT i, (SELECT 42+i1.i FROM integers LIMIT 1) AS j FROM integers i1 ORDER BY i; +-- +ok +== +SELECT i, (SELECT 42+i1.i FROM integers LIMIT 0) AS j FROM integers i1 ORDER BY i; +-- +ok +== +SELECT i, (SELECT i FROM integers WHERE 1=0 AND i1.i=i) AS j FROM integers i1 ORDER BY i; +-- +ok +== +SELECT i, EXISTS(SELECT i FROM integers WHERE 1=0 AND i1.i=i) AS j FROM integers i1 ORDER BY i; +-- +ok +== +SELECT i, i=ANY(SELECT i FROM integers WHERE 1=0 AND i1.i=i) AS j FROM integers i1 ORDER BY i; +-- +ok +== +SELECT i, (SELECT i+i1.i FROM integers ORDER BY ALL LIMIT 1 OFFSET 1) AS j FROM integers i1 ORDER BY i; +-- +ok +== +select (select val + i from generate_series(1, 2, 1) t(i) offset 1) from (select 42 val) t; +-- +ok +== +select i, (select i1.i + i + i from generate_series(1, 100, 1) t(i) ORDER BY i DESC OFFSET 99) from integers i1 order by i; +-- +ok +== +SELECT i, (SELECT i+i1.i FROM integers ORDER BY i NULLS LAST LIMIT 1) AS j FROM integers i1 ORDER BY i; +-- +ok +== +SELECT i, (SELECT i+i1.i FROM integers ORDER BY i NULLS LAST LIMIT 1 OFFSET 1) AS j FROM integers i1 ORDER BY i; +-- +ok +== +SELECT i, (SELECT 42 WHERE i1.i>2) AS j FROM integers i1 ORDER BY i; +-- +ok +== +SELECT i, (SELECT 42 WHERE i1.i IS NULL) AS j FROM integers i1 ORDER BY i; +-- +ok +== +SELECT i, (SELECT i+i1.i FROM integers WHERE i=1) AS j FROM integers i1 ORDER BY i; +-- +ok +== +SELECT i, (SELECT i FROM integers WHERE i=i1.i) AS j FROM integers i1 ORDER BY i; +-- +ok +== +SELECT i, (SELECT i+1 FROM integers WHERE i=i1.i) AS j FROM integers i1 ORDER BY i; +-- +ok +== +SELECT i, (SELECT 42 FROM integers WHERE i=i1.i) AS j FROM integers i1 ORDER BY i; +-- +ok +== +SELECT i, (SELECT CASE WHEN sum(i) > 1 THEN 0 ELSE 1 END FROM integers WHERE i=i1.i) FROM integers i1 ORDER BY ALL; +-- +ok +== diff --git a/parser/testdata/corpus/sql/subquery/scalar/test_correlated_subquery_cte.test b/parser/testdata/corpus/sql/subquery/scalar/test_correlated_subquery_cte.test new file mode 100644 index 0000000..a7e41f2 --- /dev/null +++ b/parser/testdata/corpus/sql/subquery/scalar/test_correlated_subquery_cte.test @@ -0,0 +1,131 @@ +# source: test/sql/subquery/scalar/test_correlated_subquery_cte.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +SELECT i, (WITH i2 AS (SELECT 42+i1.i AS j) SELECT j FROM i2) AS j FROM integers i1 ORDER BY i; +-- +ok +== +SELECT ( + WITH nt AS (SELECT length(s) AS n) + SELECT ( + FROM (FROM nt) + WHERE 'a' = s[n] + ) +) AS ends_in_a +FROM unnest(['a', 'ab']) _(s); +-- +ok +== +SELECT ( + WITH nt AS (SELECT length(s) AS n) + SELECT ( + SELECT 1 + FROM (SELECT n FROM nt) t + WHERE 'a' = s[n] + ) +) AS ends_in_a +FROM unnest(['a', 'ab']) _(s); +-- +ok +== +SELECT ( + WITH nt AS (SELECT length(s) AS n) + SELECT ( + FROM (FROM nt) + WHERE 'a' = s[n] + ) +) AS ends_in_a +FROM unnest(['a','ab','ba']) _(s) +ORDER BY ALL; +-- +ok +== +SELECT + ( + WITH nt AS (SELECT length(s) AS n) + SELECT (FROM (FROM nt) WHERE 'a' = s[n]) + ) AS a1, + ( + WITH nt AS (SELECT length(s) AS n) + SELECT (FROM (FROM nt) WHERE 'a' = s[n]) + ) AS a2 +FROM unnest(['a','ab']) _(s); +-- +ok +== +SELECT * +FROM generate_series(1,2) AS t1(a), +LATERAL ( + SELECT * + FROM generate_series(1,2) AS t2(b), + LATERAL ( + WITH cte AS (SELECT a + b AS x) + SELECT (FROM (FROM cte) WHERE x = a + b) + ) +) +ORDER BY a, b; +-- +ok +== +SELECT i FROM integers i1 ORDER BY (WITH i2 AS (SELECT 100-i1.i as j) SELECT j FROM i2); +-- +ok +== +SELECT i, (WITH i2 AS (SELECT 42+i1.i AS j FROM integers) SELECT j FROM i2) AS j FROM integers i1 ORDER BY i; +-- +ok +== +SELECT i, (WITH i2 AS (SELECT 42+i1.i AS j FROM integers) SELECT j FROM i2 LIMIT 1) AS j FROM integers i1 ORDER BY i; +-- +ok +== +SELECT i, (WITH i2 AS (SELECT 42+i1.i AS j FROM integers) SELECT j FROM i2 LIMIT 0) AS j FROM integers i1 ORDER BY i; +-- +ok +== +SELECT i, (WITH i2 AS (SELECT i FROM integers WHERE 1=0 AND i1.i=i) SELECT i FROM i2) AS j FROM integers i1 ORDER BY i; +-- +ok +== +SELECT i, EXISTS(WITH i2 AS (SELECT i FROM integers WHERE 1=0 AND i1.i=i) SELECT i FROM i2) AS j FROM integers i1 ORDER BY i; +-- +ok +== +SELECT i, i=ANY(WITH i2 AS (SELECT i FROM integers WHERE 1=0 AND i1.i=i) SELECT i FROM i2) AS j FROM integers i1 ORDER BY i; +-- +ok +== +SELECT i, (WITH i2 AS (SELECT i+i1.i FROM integers ORDER BY ALL LIMIT 1 OFFSET 1) SELECT * FROM i2) AS j FROM integers i1 ORDER BY i; +-- +ok +== +SELECT i, (WITH i2 AS (SELECT i+i1.i FROM integers ORDER BY 1 NULLS LAST LIMIT 1 OFFSET 1) SELECT * FROM i2) AS j FROM integers i1 ORDER BY i; +-- +ok +== +SELECT i, (WITH i2 AS (SELECT 42 WHERE i1.i>2) SELECT * FROM i2) AS j FROM integers i1 ORDER BY i; +-- +ok +== +SELECT i, (WITH i2 AS (SELECT 42 WHERE i1.i IS NULL) SELECT * FROM i2) AS j FROM integers i1 ORDER BY i; +-- +ok +== +SELECT i, (WITH i2 AS (SELECT i+i1.i FROM integers WHERE i=1) SELECT * FROM i2) AS j FROM integers i1 ORDER BY i; +-- +ok +== +SELECT i, (WITH i2 AS (SELECT i FROM integers WHERE i=i1.i) SELECT * FROM i2) AS j FROM integers i1 ORDER BY i; +-- +ok +== +SELECT i, (WITH i2 AS (SELECT i+1 FROM integers WHERE i=i1.i) SELECT * FROM i2) AS j FROM integers i1 ORDER BY i; +-- +ok +== +SELECT i, (WITH i2 AS (SELECT 42 FROM integers WHERE i=i1.i) SELECT * FROM i2) AS j FROM integers i1 ORDER BY i; +-- +ok +== diff --git a/parser/testdata/corpus/sql/subquery/scalar/test_correlated_subquery_where.test b/parser/testdata/corpus/sql/subquery/scalar/test_correlated_subquery_where.test new file mode 100644 index 0000000..848a431 --- /dev/null +++ b/parser/testdata/corpus/sql/subquery/scalar/test_correlated_subquery_where.test @@ -0,0 +1,17 @@ +# source: test/sql/subquery/scalar/test_correlated_subquery_where.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +CREATE TABLE test AS FROM VALUES (1, 22), (1, 21), (2, 22) v(id, b); +-- +ok +== +SELECT * FROM test WHERE b=(SELECT MIN(b) FROM test AS a WHERE a.id=test.id) +-- +ok +== +SELECT * FROM test WHERE b=(SELECT MIN(b) FROM test AS a WHERE a.id=test.id AND a.id < test.b) +-- +ok +== diff --git a/parser/testdata/corpus/sql/subquery/scalar/test_correlated_window.test b/parser/testdata/corpus/sql/subquery/scalar/test_correlated_window.test new file mode 100644 index 0000000..55748ff --- /dev/null +++ b/parser/testdata/corpus/sql/subquery/scalar/test_correlated_window.test @@ -0,0 +1,25 @@ +# source: test/sql/subquery/scalar/test_correlated_window.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +SELECT i, (SELECT SUM(i + 1) OVER ()) FROM integers ORDER BY i +-- +ok +== +SELECT i, (SELECT SUM((SELECT i + 1)) OVER ()) FROM integers ORDER BY i +-- +ok +== +SELECT i, (SELECT SUM((SELECT i + 1)) OVER () WHERE i>=2) FROM integers ORDER BY i +-- +ok +== +SELECT i, (SELECT SUM((SELECT SUM(i))) OVER ()) FROM integers GROUP BY i ORDER BY i +-- +ok +== +SELECT i, (SELECT SUM(win) FROM (SELECT SUM((SELECT i1.i + integers.i)) OVER () AS win FROM integers i1) t) FROM integers ORDER BY i +-- +ok +== diff --git a/parser/testdata/corpus/sql/subquery/scalar/test_count_star_subquery.test b/parser/testdata/corpus/sql/subquery/scalar/test_count_star_subquery.test new file mode 100644 index 0000000..bf9d679 --- /dev/null +++ b/parser/testdata/corpus/sql/subquery/scalar/test_count_star_subquery.test @@ -0,0 +1,45 @@ +# source: test/sql/subquery/scalar/test_count_star_subquery.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +SELECT i, (SELECT i FROM integers i2 WHERE i=(SELECT SUM(i) FROM integers i2 WHERE i2.i>i1.i)) FROM integers i1 ORDER BY 1; +-- +ok +== +SELECT i, (SELECT SUM(i) IS NULL FROM integers i2 WHERE i2.i>i1.i) FROM integers i1 ORDER BY i; +-- +ok +== +SELECT i, (SELECT COUNT(*) FROM integers i2 WHERE i2.i>i1.i) FROM integers i1 ORDER BY i; +-- +ok +== +SELECT i, (SELECT COUNT(i) FROM integers i2 WHERE i2.i>i1.i OR i2.i IS NULL) FROM integers i1 ORDER BY i; +-- +ok +== +SELECT i, (SELECT COUNT(*) FROM integers i2 WHERE i2.i>i1.i OR i2.i IS NULL) FROM integers i1 ORDER BY i; +-- +ok +== +SELECT i, (SELECT COUNT(*) FROM integers i2 WHERE i2.i>i1.i OR (i1.i IS NULL AND i2.i IS NULL)) FROM integers i1 ORDER BY i; +-- +ok +== +SELECT i FROM integers i1 WHERE (SELECT COUNT(*) FROM integers i2 WHERE i2.i>i1.i)=0 ORDER BY i; +-- +ok +== +SELECT i, (SELECT i FROM integers i2 WHERE i-2=(SELECT COUNT(*) FROM integers i2 WHERE i2.i>i1.i)) FROM integers i1 ORDER BY 1; +-- +ok +== +SELECT i, (SELECT COUNT(*) FROM integers i2 WHERE i2.i>i1.i GROUP BY i1.i) FROM integers i1 ORDER BY i; +-- +ok +== +SELECT i, (SELECT CASE WHEN (SELECT COUNT(*) FROM integers i2 WHERE i2.i>i1.i)=0 THEN 1 ELSE 0 END) FROM integers i1 ORDER BY i; +-- +ok +== diff --git a/parser/testdata/corpus/sql/subquery/scalar/test_delete_subquery.test b/parser/testdata/corpus/sql/subquery/scalar/test_delete_subquery.test new file mode 100644 index 0000000..1a0cafa --- /dev/null +++ b/parser/testdata/corpus/sql/subquery/scalar/test_delete_subquery.test @@ -0,0 +1,25 @@ +# source: test/sql/subquery/scalar/test_delete_subquery.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +CREATE TABLE integers(id INTEGER, i INTEGER) +-- +ok +== +INSERT INTO integers VALUES (1, 1), (2, 2), (3, 3), (4, NULL) +-- +ok +== +DELETE FROM integers i1 WHERE i>(SELECT MAX(i) FROM integers WHERE i1.i<>i) +-- +ok +== +SELECT id, i FROM integers ORDER BY id +-- +ok +== +DELETE FROM integers i1 WHERE i=(SELECT MAX(i) FROM integers) +-- +ok +== diff --git a/parser/testdata/corpus/sql/subquery/scalar/test_grouped_correlated_subquery.test b/parser/testdata/corpus/sql/subquery/scalar/test_grouped_correlated_subquery.test new file mode 100644 index 0000000..68dde78 --- /dev/null +++ b/parser/testdata/corpus/sql/subquery/scalar/test_grouped_correlated_subquery.test @@ -0,0 +1,110 @@ +# source: test/sql/subquery/scalar/test_grouped_correlated_subquery.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +CREATE TABLE tbl_ProductSales (ColID int, Product_Category varchar(64), Product_Name varchar(64), TotalSales int); +-- +ok +== +CREATE TABLE another_T (col1 INT, col2 INT, col3 INT, col4 INT, col5 INT, col6 INT, col7 INT, col8 INT); +-- +ok +== +INSERT INTO tbl_ProductSales VALUES (1,'Game','Mobo Game',200),(2,'Game','PKO Game',400),(3,'Fashion','Shirt',500),(4,'Fashion','Shorts',100); +-- +ok +== +INSERT INTO another_T VALUES (1,2,3,4,5,6,7,8), (11,22,33,44,55,66,77,88), (111,222,333,444,555,666,777,888), (1111,2222,3333,4444,5555,6666,7777,8888); +-- +ok +== +SELECT col1 IN (SELECT ColID FROM tbl_ProductSales) FROM another_T; +-- +ok +== +SELECT col1 IN (SELECT ColID + col1 FROM tbl_ProductSales) FROM another_T; +-- +ok +== +SELECT col1 IN (SELECT ColID + col1 FROM tbl_ProductSales) FROM another_T GROUP BY col1; +-- +ok +== +SELECT col1 IN (SELECT ColID + another_T.col1 FROM tbl_ProductSales) FROM another_T GROUP BY col1; +-- +ok +== +SELECT (col1 + 1) AS k, k IN (SELECT ColID + k FROM tbl_ProductSales) FROM another_T GROUP BY k ORDER BY 1; +-- +ok +== +SELECT (col1 + 1) IN (SELECT ColID + (col1 + 1) FROM tbl_ProductSales) FROM another_T GROUP BY (col1 + 1); +-- +ok +== +SELECT col1+1, col1+42 FROM another_T GROUP BY col1+1; +-- +ok +== +SELECT (col1 + 1) IN (SELECT ColID + (col1 + 42) FROM tbl_ProductSales) FROM another_T GROUP BY (col1 + 1); +-- +ok +== +SELECT col5 = ALL (SELECT 1 FROM tbl_ProductSales HAVING MIN(col8) IS NULL) FROM another_T GROUP BY col1, col2, col5, col8; +-- +ok +== +SELECT CASE WHEN 1 IN (SELECT MAX(col7) UNION ALL (SELECT MIN(ColID) FROM tbl_ProductSales INNER JOIN another_T t2 ON t2.col5 = t2.col1)) THEN 2 ELSE NULL END FROM another_T t1; +-- +ok +== +SELECT CASE WHEN 1 IN (SELECT (SELECT MAX(col7))) THEN 2 ELSE NULL END FROM another_T t1; +-- +ok +== +SELECT CASE WHEN 1 IN (SELECT (SELECT MAX(col7)) UNION ALL (SELECT MIN(ColID) FROM tbl_ProductSales INNER JOIN another_T t2 ON t2.col5 = t2.col1)) THEN 2 ELSE NULL END FROM another_T t1; +-- +ok +== +SELECT CASE WHEN 1 IN (SELECT (SELECT MIN(ColID) FROM tbl_ProductSales INNER JOIN another_T t2 ON t2.col5 = t2.col1) UNION ALL (SELECT MAX(col7))) THEN 2 ELSE NULL END FROM another_T t1; +-- +ok +== +SELECT (SELECT MIN(ColID) FROM tbl_ProductSales INNER JOIN another_T t2 ON t1.col7 <> (SELECT MAX(t1.col1 + t3.col4) FROM another_T t3)) FROM another_T t1; +-- +ok +== +SELECT (SELECT MIN(ColID) FROM tbl_ProductSales INNER JOIN another_T t2 ON t1.col7 <> ANY(SELECT MAX(t1.col1 + t3.col4) FROM another_T t3)) FROM another_T t1; +-- +ok +== +WITH outer_t(x) AS (SELECT 1) +SELECT (SELECT count(*) FROM range(1, 3) t(i) LEFT JOIN range(1, 2) u(j) ON t.i = outer_t.x) FROM outer_t; +-- +ok +== +WITH outer_t(x) AS (SELECT 1) +SELECT q.cnt +FROM outer_t +CROSS JOIN LATERAL ( + SELECT count(*) AS cnt + FROM (SELECT 1 AS r) e + CROSS JOIN (SELECT 1 AS v) d + LEFT JOIN (SELECT 1 AS r, 1 AS v) e2 ON e2.r = outer_t.x AND e2.v = d.v +) q; +-- +ok +== +SELECT CASE WHEN NOT col1 NOT IN (SELECT (SELECT MAX(col7)) UNION (SELECT MIN(ColID) FROM tbl_ProductSales LEFT JOIN another_T t2 ON t2.col5 = t1.col1)) THEN 1 ELSE 2 END FROM another_T t1 GROUP BY col1 ORDER BY 1; +-- +ok +== +SELECT EXISTS (SELECT RANK() OVER (PARTITION BY SUM(DISTINCT col5))) FROM another_T t1; +-- +ok +== +SELECT (SELECT SUM(col2) OVER (PARTITION BY SUM(col2) ORDER BY MAX(col1 + ColID) ROWS UNBOUNDED PRECEDING) FROM tbl_ProductSales) FROM another_T t1 GROUP BY col1 +-- +ok +== diff --git a/parser/testdata/corpus/sql/subquery/scalar/test_issue_4216.test b/parser/testdata/corpus/sql/subquery/scalar/test_issue_4216.test new file mode 100644 index 0000000..f812f6e --- /dev/null +++ b/parser/testdata/corpus/sql/subquery/scalar/test_issue_4216.test @@ -0,0 +1,21 @@ +# source: test/sql/subquery/scalar/test_issue_4216.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +CREATE TABLE test (x INT, y INT) +-- +ok +== +SELECT (SELECT y FROM test t2 WHERE t1.x = 5) FROM test t1 +-- +ok +== +SELECT (SELECT y FROM test t2 WHERE t1.x = 5) IS NULL FROM test t1 +-- +ok +== +SELECT (SELECT y FROM test t2 WHERE t1.x = 5) IS NOT NULL FROM test t1 +-- +ok +== diff --git a/parser/testdata/corpus/sql/subquery/scalar/test_issue_6136.test b/parser/testdata/corpus/sql/subquery/scalar/test_issue_6136.test new file mode 100644 index 0000000..55f71b2 --- /dev/null +++ b/parser/testdata/corpus/sql/subquery/scalar/test_issue_6136.test @@ -0,0 +1,42 @@ +# source: test/sql/subquery/scalar/test_issue_6136.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +create table r as select * from values (1, 1, 'a', 'A'), (1, null, 'b', 'B'), (1, 2, 'c', 'C'), (2, null, 'd', 'D') t(ra, rb, x, y); +-- +ok +== +create table b as select * from values (1, 1, 1), (2, 1, 2), (3, 1, 3), (4, 1, null), (5, 2, 1), (6, 2, null), (7, 99, 99) t(id, ba, bb); +-- +ok +== +select + (select {'__matches': count(*)} from r where ba = ra and bb = rb group by ra, rb) as ref1, +from b; +-- +ok +== +select + id, + ba, + bb, + coalesce((select {'x': first(x), 'y': first(y), '__matches': count(*)} from r where ba = ra and bb = rb group by ra, rb), {'x': null, 'y': null, '__matches': 0}) as ref1, + coalesce((select {'x': first(x), 'y': first(y), '__matches': count(*)} from r where ba = ra and (bb = rb or rb is null) group by ra, rb order by bb = rb), {'x': null, 'y': null, '__matches': 0}) as ref2, + coalesce((select {'x': first(x), 'y': first(y), '__matches': count(*)} from r where (ba = ra or ra is null) and (bb = rb or rb is null) group by ra, rb order by ba = ra, bb = rb), {'x': null, 'y': null, '__matches': 0}) as ref3, + coalesce((select {'x': first(x), 'y': first(y), '__matches': count(*)} from r where (ba = ra or ra is null) group by ra order by ba = ra), {'x': null, 'y': null, '__matches': 0}) as ref4, +from b +-- +ok +== +select + id, + ba, + bb, + coalesce((select ROW(min(x), min(y), count(*)) from r where ba = ra and bb = rb group by ra, rb), ROW(null, null, 0)) as ref1, + coalesce((select ROW(min(x), min(y), count(*)) from r where (ba = ra or ra is null) group by ra order by ba = ra), ROW(null, null, 0)) as ref4 +from b +ORDER BY 1, 2, 3; +-- +ok +== diff --git a/parser/testdata/corpus/sql/subquery/scalar/test_issue_6184.test b/parser/testdata/corpus/sql/subquery/scalar/test_issue_6184.test new file mode 100644 index 0000000..b433a17 --- /dev/null +++ b/parser/testdata/corpus/sql/subquery/scalar/test_issue_6184.test @@ -0,0 +1,88 @@ +# source: test/sql/subquery/scalar/test_issue_6184.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +CREATE TABLE t1(fuel_type VARCHAR, location_country VARCHAR); +-- +ok +== +INSERT INTO t1 VALUES('natural_gas', 'US'); +-- +ok +== +CREATE TABLE t2(__input_row_id BIGINT, "__input.fuel" VARCHAR); +-- +ok +== +INSERT INTO t2 VALUES(1, 'natural_gas'); +-- +ok +== +SELECT ( +SELECT NULL + FROM + ( + SELECT fuel_type, location_country + FROM "t1" + WHERE "fuel_type" IS NOT DISTINCT FROM "__input.fuel" + LIMIT 1 + ) t1) +FROM t2 AS __p; +-- +ok +== +WITH __activity_data AS +( + SELECT * + FROM + ( + VALUES ( 'natural_gas', 'US', 'PGE', 'CA', 'SF', json('{}')) + ) AS t("fuel", "country", "grid", "state", "city", tags) +), "fuel_kgco2e_per_mmbtu" AS +( + SELECT * + ,ROW_NUMBER() over () AS row_id + FROM + ( VALUES ('natural_gas', 'US', NULL, 'CA', 'SF', 2), + ) AS t( fuel_type, location_country, location_grid, location_state, location_city, kgco2e_per_mmbtu) +), __input AS +( + SELECT * + ,ROW_NUMBER() OVER () AS __input_row_id + FROM "__activity_data" +), "fuel_kgco2e_per_mmbtu__1" AS +( + SELECT * + ,ROW_NUMBER() OVER () AS __row_id + FROM "fuel_kgco2e_per_mmbtu" +), __stage0 AS +( + SELECT __input_row_id + ,fuel AS "__input.fuel" + ,country AS "__input.country" + ,grid AS "__input.grid" + ,state AS "__input.state" + ,city AS "__input.city" + FROM __input +) +SELECT __p.* + ,( +SELECT { 'kgco2e_per_mmbtu': FIRST("kgco2e_per_mmbtu") + ,__row_id: FIRST(__row_id) + ,__candidates: LIST(__row_id) } +FROM +( + SELECT * + FROM "fuel_kgco2e_per_mmbtu__1" + WHERE "fuel_type" IS NOT DISTINCT + FROM "__input.fuel" + ORDER BY "location_country" IS NOT NULL DESC, "location_grid" IS NOT NULL DESC, "location_state" IS NOT NULL DESC, "location_city" IS NOT NULL DESC + LIMIT 1 +) +GROUP BY TRUE ) AS __ref1 + ,CAST(1 AS DOUBLE) AS "__p.__functional_unit__" +FROM __stage0 AS __p; +-- +ok +== diff --git a/parser/testdata/corpus/sql/subquery/scalar/test_issue_7079.test b/parser/testdata/corpus/sql/subquery/scalar/test_issue_7079.test new file mode 100644 index 0000000..9056332 --- /dev/null +++ b/parser/testdata/corpus/sql/subquery/scalar/test_issue_7079.test @@ -0,0 +1,41 @@ +# source: test/sql/subquery/scalar/test_issue_7079.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +CREATE MACRO array_rv(arr) AS ( + SELECT CASE WHEN l IS NOT NULL THEN l ELSE arr END + FROM ( + SELECT array_agg(elm ORDER BY g DESC) as l + FROM (SELECT generate_subscripts(arr, 1) AS g, arr[g] AS elm) + ) +); +-- +ok +== +CREATE MACRO array_rv_coal(arr) AS ( + SELECT COALESCE(l,arr) + FROM ( + SELECT array_agg(elm ORDER BY g DESC) as l + FROM (SELECT generate_subscripts(arr, 1) AS g, arr[g] AS elm) + ) +); +-- +ok +== +CREATE TABLE t AS ( + SELECT [1, 2, 3] AS arr UNION ALL + SELECT [4, 5] AS arr UNION ALL + SELECT [] AS arr +); +-- +ok +== +SELECT array_rv(arr) FROM t ORDER BY arr; +-- +ok +== +SELECT array_rv_coal(arr) FROM t ORDER BY arr; +-- +ok +== diff --git a/parser/testdata/corpus/sql/subquery/scalar/test_join_in_subquery.test b/parser/testdata/corpus/sql/subquery/scalar/test_join_in_subquery.test new file mode 100644 index 0000000..4f0e7e6 --- /dev/null +++ b/parser/testdata/corpus/sql/subquery/scalar/test_join_in_subquery.test @@ -0,0 +1,17 @@ +# source: test/sql/subquery/scalar/test_join_in_subquery.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +CREATE TABLE test AS FROM VALUES (1, 22), (1, 21), (2, 22) v(id, test_value); +-- +ok +== +CREATE TABLE test2 AS FROM VALUES (1, 44), (2, 42) v(id, test2_value); +-- +ok +== +SELECT * FROM test, test2 WHERE test.id=test2.id AND test_value*test2_value=(SELECT MIN(test_value*test2_value) FROM test AS a, test2 WHERE a.id=test.id AND a.id=test2.id) +-- +ok +== diff --git a/parser/testdata/corpus/sql/subquery/scalar/test_many_correlated_columns.test b/parser/testdata/corpus/sql/subquery/scalar/test_many_correlated_columns.test new file mode 100644 index 0000000..2a52256 --- /dev/null +++ b/parser/testdata/corpus/sql/subquery/scalar/test_many_correlated_columns.test @@ -0,0 +1,33 @@ +# source: test/sql/subquery/scalar/test_many_correlated_columns.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +INSERT INTO test2 VALUES (11, 1, 'a'), (12, 1, 'b'), (13, 4, 'b') +-- +ok +== +SELECT a, SUM(a), (SELECT SUM(a)+SUM(t1.b) FROM test) FROM test t1 GROUP BY a ORDER BY a; +-- +ok +== +SELECT (SELECT test.a+test.b+SUM(test2.a) FROM test2 WHERE str=str2) FROM test ORDER BY 1; +-- +ok +== +SELECT * FROM test WHERE EXISTS(SELECT * FROM test2 WHERE test.a=test2.a AND test.b<>test2.c) order by b; +-- +ok +== +SELECT a, a>=ANY(SELECT test2.a+c-b FROM test2 WHERE c>=b AND str=str2) FROM test ORDER BY 1; +-- +ok +== +SELECT str, str=ANY(SELECT str2 FROM test2) FROM test ORDER BY ALL +-- +ok +== +SELECT str, str=ANY(SELECT str2 FROM test2 WHERE test.a<>test2.a) FROM test ORDER BY ALL +-- +ok +== diff --git a/parser/testdata/corpus/sql/subquery/scalar/test_scalar_subquery.test b/parser/testdata/corpus/sql/subquery/scalar/test_scalar_subquery.test new file mode 100644 index 0000000..2335de5 --- /dev/null +++ b/parser/testdata/corpus/sql/subquery/scalar/test_scalar_subquery.test @@ -0,0 +1,133 @@ +# source: test/sql/subquery/scalar/test_scalar_subquery.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +SELECT 1+(SELECT 1) +-- +ok +== +SELECT 1=(SELECT 1) +-- +ok +== +SELECT 1<>(SELECT 1) +-- +ok +== +SELECT 1=(SELECT NULL) +-- +ok +== +SELECT NULL=(SELECT 1) +-- +ok +== +SELECT (SELECT 42) +-- +ok +== +EXPLAIN SELECT (SELECT 42) +-- +ok +== +EXPLAIN SELECT (SELECT 42 LIMIT 1) +-- +ok +== +EXPLAIN SELECT (SELECT NULL) +-- +ok +== +SELECT (SELECT 42 WHERE false LIMIT 1) +-- +ok +== +EXPLAIN SELECT (SELECT 42 WHERE false LIMIT 1) +-- +ok +== +SELECT (SELECT (SELECT 42)) +-- +ok +== +SELECT * FROM (SELECT 42) v1(a); +-- +ok +== +SELECT * FROM (SELECT 42, 41 AS x) v1(a); +-- +ok +== +SELECT * FROM (SELECT 42, 41 AS x) v1(a, b, c); +-- +ok +== +INSERT INTO test VALUES (11, 22) +-- +ok +== +INSERT INTO test VALUES (12, 21) +-- +ok +== +INSERT INTO test VALUES (13, 22) +-- +ok +== +SELECT (SELECT a * 42 FROM test) +-- +ok +== +SELECT a*(SELECT 42) FROM test +-- +ok +== +CREATE TABLE t1(a INTEGER, b INTEGER, c INTEGER, d INTEGER, e INTEGER) +-- +ok +== +INSERT INTO t1(e,c,b,d,a) VALUES(103,102,100,101,104) +-- +ok +== +INSERT INTO t1(a,c,d,e,b) VALUES(107,106,108,109,105) +-- +ok +== +SELECT c-(SELECT sum(c) FROM t1) FROM t1 +-- +ok +== +SELECT CASE WHEN c>(SELECT sum(c)/count(*) FROM t1) THEN a*2 ELSE b*10 END FROM t1 +-- +ok +== +SELECT a, (SELECT SUM(b) FROM test tsub WHERE test.a=tsub.a) FROM test +-- +ok +== +SELECT a, (SELECT CASE WHEN test.a=11 THEN 22 ELSE NULL END) FROM test ORDER BY a +-- +ok +== +SELECT a, (SELECT CASE WHEN test.a=11 THEN b ELSE NULL END FROM test tsub) FROM test ORDER BY a +-- +ok +== +SELECT a, (SELECT CASE WHEN test.a=11 THEN b ELSE NULL END FROM test tsub LIMIT 1) FROM test ORDER BY a +-- +ok +== +SELECT * from test where a=(SELECT MIN(a) FROM test t WHERE t.b=test.b) ORDER BY a +-- +ok +== +SELECT * FROM test WHERE EXISTS (SELECT a FROM test ts WHERE ts.a = test.a AND b>21) +-- +ok +== +SELECT * FROM (SELECT 42 AS a, 44 AS a) tbl1 +-- +ok +== diff --git a/parser/testdata/corpus/sql/subquery/scalar/test_scalar_subquery_cte.test b/parser/testdata/corpus/sql/subquery/scalar/test_scalar_subquery_cte.test new file mode 100644 index 0000000..f357390 --- /dev/null +++ b/parser/testdata/corpus/sql/subquery/scalar/test_scalar_subquery_cte.test @@ -0,0 +1,91 @@ +# source: test/sql/subquery/scalar/test_scalar_subquery_cte.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +SELECT 1+(WITH cte AS (SELECT 1) SELECT * FROM cte) +-- +ok +== +SELECT 1=(WITH cte AS (SELECT 1) SELECT * FROM cte) +-- +ok +== +SELECT 1<>(WITH cte AS (SELECT 1) SELECT * FROM cte) +-- +ok +== +SELECT 1=(WITH cte AS (SELECT NULL) SELECT * FROM cte) +-- +ok +== +SELECT (WITH cte AS (SELECT 42) SELECT * FROM cte) +-- +ok +== +SELECT (WITH cte1 AS (WITH cte2 AS (SELECT 42) SELECT * FROM cte2) SELECT * FROM cte1) +-- +ok +== +SELECT * FROM (WITH cte(x) AS (SELECT 42) SELECT x FROM cte) v1(a); +-- +ok +== +SELECT * FROM (WITH cte AS (SELECT 42, 41 AS x) SELECT * FROM cte) v1(a); +-- +ok +== +SELECT * FROM (WITH cte AS (SELECT 42, 41 AS x) SELECT * FROM cte) v1(a, b, c); +-- +ok +== +SELECT (WITH cte AS (SELECT a * 42 FROM test) SELECT * FROM cte) +-- +ok +== +SELECT (WITH cte AS (SELECT a * 42 FROM test) SELECT * FROM cte) IN (462, 504, 546) +-- +ok +== +SELECT a*(WITH cte AS (SELECT 42) SELECT * FROM cte) FROM test +-- +ok +== +SELECT c-(WITH cte AS (SELECT sum(c) FROM t1) SELECT * FROM cte) FROM t1 +-- +ok +== +SELECT CASE WHEN c>(WITH cte AS (SELECT sum(c)/count(*) FROM t1) SELECT * FROM cte) THEN a*2 ELSE b*10 END FROM t1 +-- +ok +== +SELECT a, (WITH cte AS (SELECT SUM(b) FROM test tsub WHERE test.a=tsub.a) SELECT * FROM cte) FROM test +-- +ok +== +SELECT n, x, (WITH cte AS (SELECT n AS v) SELECT (SELECT v FROM cte WHERE x = 10 LIMIT 1)) AS z +FROM (VALUES (1,10),(1,20),(2,10),(2,20)) t(n,x) +ORDER BY n, x +-- +ok +== +SELECT a, (WITH cte AS (SELECT CASE WHEN test.a=11 THEN 22 ELSE NULL END) SELECT * FROM cte) FROM test ORDER BY a +-- +ok +== +SELECT a, (WITH cte AS (SELECT CASE WHEN test.a=11 THEN b ELSE NULL END FROM test tsub LIMIT 1) SELECT * FROM cte) FROM test ORDER BY a +-- +ok +== +SELECT * from test where a=(WITH cte AS (SELECT a FROM test t WHERE t.b=test.b) SELECT min(a) FROM cte) +-- +ok +== +SELECT * FROM test WHERE EXISTS (WITH cte AS (SELECT * FROM test ts WHERE ts.a = test.a AND b>21) SELECT a FROM cte) +-- +ok +== +SELECT * FROM (WITH cte AS (SELECT 42 AS a, 44 AS a) SELECT * FROM cte) tbl1 +-- +ok +== diff --git a/parser/testdata/corpus/sql/subquery/scalar/test_subquery_any_join.test b/parser/testdata/corpus/sql/subquery/scalar/test_subquery_any_join.test new file mode 100644 index 0000000..1848cb6 --- /dev/null +++ b/parser/testdata/corpus/sql/subquery/scalar/test_subquery_any_join.test @@ -0,0 +1,37 @@ +# source: test/sql/subquery/scalar/test_subquery_any_join.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +SELECT i IN (SELECT i1.i FROM (SELECT * FROM integers i1 WHERE i1.i=integers.i) i1 JOIN generate_series(1, 2, 1) tbl(i) ON i1.i=tbl.i) FROM integers ORDER BY i NULLS LAST; +-- +ok +== +SELECT i IN (SELECT i1.i FROM (SELECT * FROM integers i1 WHERE i1.i=integers.i) i1 LEFT JOIN generate_series(1, 2, 1) tbl(i) ON i1.i=tbl.i) FROM integers ORDER BY i NULLS LAST; +-- +ok +== +SELECT i IN (SELECT i1.i FROM (SELECT * FROM integers i1 WHERE i1.i=integers.i) i1 RIGHT JOIN generate_series(1, 2, 1) tbl(i) ON i1.i=tbl.i) FROM integers ORDER BY i NULLS LAST; +-- +ok +== +SELECT i IN (SELECT i1.i FROM generate_series(1, 2, 1) tbl(i) LEFT JOIN (SELECT * FROM integers i1 WHERE i1.i=integers.i) i1 ON i1.i=tbl.i) FROM integers ORDER BY i NULLS LAST; +-- +ok +== +SELECT i IN (SELECT i1.i FROM generate_series(1, 2, 1) tbl(i) RIGHT JOIN (SELECT * FROM integers i1 WHERE i1.i=integers.i) i1 ON i1.i=tbl.i) FROM integers ORDER BY i NULLS LAST; +-- +ok +== +SELECT i IN (SELECT i1.i FROM (SELECT * FROM integers i1 WHERE i1.i IS NOT DISTINCT FROM integers.i) i1 JOIN generate_series(1, 2, 1) tbl(i) ON i1.i=tbl.i OR (i1.i IS NULL AND tbl.i IS NULL)) FROM integers ORDER BY i NULLS LAST; +-- +ok +== +SELECT i IN (SELECT i1.i FROM (SELECT * FROM integers i1 WHERE i1.i IS NOT DISTINCT FROM integers.i) i1 LEFT JOIN generate_series(1, 2, 1) tbl(i) ON i1.i=tbl.i OR (i1.i IS NULL AND tbl.i IS NULL)) FROM integers ORDER BY i NULLS LAST; +-- +ok +== +SELECT i IN (SELECT i1.i FROM (SELECT * FROM integers i1 WHERE i1.i IS NOT DISTINCT FROM integers.i) i1 RIGHT JOIN generate_series(1, 2, 1) tbl(i) ON i1.i=tbl.i OR (i1.i IS NULL AND tbl.i IS NULL)) FROM integers ORDER BY i NULLS LAST; +-- +ok +== diff --git a/parser/testdata/corpus/sql/subquery/scalar/test_tpcds_correlated_subquery.test b/parser/testdata/corpus/sql/subquery/scalar/test_tpcds_correlated_subquery.test new file mode 100644 index 0000000..fb5864e --- /dev/null +++ b/parser/testdata/corpus/sql/subquery/scalar/test_tpcds_correlated_subquery.test @@ -0,0 +1,17 @@ +# source: test/sql/subquery/scalar/test_tpcds_correlated_subquery.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +CREATE TABLE item(i_manufact INTEGER) +-- +ok +== +SELECT * FROM item i1 WHERE (SELECT count(*) AS item_cnt FROM item WHERE (i_manufact = i1.i_manufact AND i_manufact=3) OR (i_manufact = i1.i_manufact AND i_manufact=3)) > 0 ORDER BY 1 LIMIT 100; +-- +ok +== +SELECT * FROM item i1 WHERE (SELECT count(*) AS item_cnt FROM item WHERE (i_manufact = i1.i_manufact AND i_manufact=3) OR (i_manufact = i1.i_manufact AND i_manufact=3)) ORDER BY 1 LIMIT 100; +-- +ok +== diff --git a/parser/testdata/corpus/sql/subquery/scalar/test_uncorrelated_scalar_subquery.test b/parser/testdata/corpus/sql/subquery/scalar/test_uncorrelated_scalar_subquery.test new file mode 100644 index 0000000..831c913 --- /dev/null +++ b/parser/testdata/corpus/sql/subquery/scalar/test_uncorrelated_scalar_subquery.test @@ -0,0 +1,73 @@ +# source: test/sql/subquery/scalar/test_uncorrelated_scalar_subquery.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +SELECT * FROM integers WHERE i=(SELECT 1) +-- +ok +== +SELECT * FROM integers WHERE i=(SELECT SUM(1)) +-- +ok +== +SELECT * FROM integers WHERE i=(SELECT MIN(i) FROM integers) +-- +ok +== +SELECT *, (SELECT MAX(i) FROM integers) FROM integers ORDER BY i +-- +ok +== +SELECT (SELECT 42) AS k, MAX(i) FROM integers GROUP BY k +-- +ok +== +SELECT i, MAX((SELECT 42)) FROM integers GROUP BY i ORDER BY i +-- +ok +== +SELECT (SELECT * FROM integers WHERE i>10) FROM integers +-- +ok +== +SELECT * FROM integers WHERE i=(SELECT i FROM integers WHERE i IS NOT NULL ORDER BY i) +-- +ok +== +SELECT * FROM integers WHERE i=(SELECT i FROM integers WHERE i IS NOT NULL ORDER BY i LIMIT 1) +-- +ok +== +SELECT * FROM integers WHERE i=(SELECT 1, 2) +-- +ok +== +SELECT * FROM integers WHERE i=(SELECT i, i + 2 FROM integers) +-- +ok +== +SELECT * FROM integers WHERE EXISTS (SELECT 1, 2) +-- +ok +== +SELECT * FROM integers WHERE EXISTS (SELECT i, i + 2 FROM integers) +-- +ok +== +SELECT (SELECT * FROM integers WHERE i=1) +-- +ok +== +SELECT (SELECT * FROM integers i1, integers i2) +-- +ok +== +SELECT (SELECT i FROM integers WHERE i=1) +-- +ok +== +SELECT * FROM integers WHERE i > (SELECT i FROM integers WHERE i=1) ORDER BY 1 +-- +ok +== diff --git a/parser/testdata/corpus/sql/subquery/scalar/test_uncorrelated_varchar_subquery.test b/parser/testdata/corpus/sql/subquery/scalar/test_uncorrelated_varchar_subquery.test new file mode 100644 index 0000000..688ddc3 --- /dev/null +++ b/parser/testdata/corpus/sql/subquery/scalar/test_uncorrelated_varchar_subquery.test @@ -0,0 +1,41 @@ +# source: test/sql/subquery/scalar/test_uncorrelated_varchar_subquery.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +CREATE TABLE strings(v VARCHAR) +-- +ok +== +SELECT NULL IN (SELECT * FROM strings) +-- +ok +== +SELECT 'hello' IN (SELECT * FROM strings) +-- +ok +== +SELECT 'bla' IN (SELECT * FROM strings) +-- +ok +== +SELECT 'bla' IN (SELECT * FROM strings WHERE v IS NOT NULL) +-- +ok +== +SELECT * FROM strings WHERE EXISTS(SELECT NULL) +-- +ok +== +SELECT * FROM strings WHERE EXISTS(SELECT v FROM strings WHERE v='bla') +-- +ok +== +SELECT (SELECT v FROM strings WHERE v='hello') FROM strings +-- +ok +== +SELECT (SELECT v FROM strings WHERE v='bla') FROM strings +-- +ok +== diff --git a/parser/testdata/corpus/sql/subquery/scalar/test_unnest_subquery.test b/parser/testdata/corpus/sql/subquery/scalar/test_unnest_subquery.test new file mode 100644 index 0000000..f2097ed --- /dev/null +++ b/parser/testdata/corpus/sql/subquery/scalar/test_unnest_subquery.test @@ -0,0 +1,73 @@ +# source: test/sql/subquery/scalar/test_unnest_subquery.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +SELECT (SELECT UNNEST([1])) +-- +ok +== +SELECT (SELECT UNNEST([NULL])) +-- +ok +== +SELECT (SELECT UNNEST([])) +-- +ok +== +SELECT (SELECT UNNEST(i)) FROM (VALUES ([1])) tbl(i); +-- +ok +== +SELECT (SELECT UNNEST(i)) FROM (VALUES ([NULL])) tbl(i); +-- +ok +== +SELECT (SELECT UNNEST(i)) FROM (VALUES ([])) tbl(i); +-- +ok +== +SELECT (SELECT SUM(k) FROM (SELECT UNNEST(i)) tbl(k)) FROM (VALUES ([1, 2, 3])) tbl(i); +-- +ok +== +SELECT (SELECT SUM(k)+SUM(l) FROM (SELECT UNNEST(i), UNNEST(j) FROM (VALUES ([1, 2, 3])) tbl(j)) tbl(k, l)) FROM (VALUES ([1, 2, 3])) tbl(i); +-- +ok +== +SELECT 1=ANY(SELECT UNNEST(i)) FROM (VALUES ([1, 2, 3])) tbl(i); +-- +ok +== +SELECT 4=ANY(SELECT UNNEST(i)) FROM (VALUES ([1, 2, 3])) tbl(i); +-- +ok +== +SELECT NULL=ANY(SELECT UNNEST(i)) FROM (VALUES ([1, 2, 3])) tbl(i); +-- +ok +== +SELECT 4=ANY(SELECT UNNEST(i)) FROM (VALUES ([1, 2, 3, NULL])) tbl(i); +-- +ok +== +SELECT 1 IN (SELECT UNNEST(i)) FROM (VALUES ([1, 2, 3])) tbl(i); +-- +ok +== +SELECT (SELECT 1=ANY(SELECT UNNEST(i))) FROM (VALUES ([1, 2, 3])) tbl(i); +-- +ok +== +SELECT (SELECT 4=ANY(SELECT UNNEST(i))) FROM (VALUES ([1, 2, 3])) tbl(i); +-- +ok +== +SELECT (SELECT 4=ANY(SELECT UNNEST(i))) FROM (VALUES ([1, 2, 3, NULL])) tbl(i); +-- +ok +== +SELECT (SELECT 1+i[1]=ANY(SELECT UNNEST(i))) FROM (VALUES ([1, 2, 3])) tbl(i); +-- +ok +== diff --git a/parser/testdata/corpus/sql/subquery/scalar/test_update_subquery.test b/parser/testdata/corpus/sql/subquery/scalar/test_update_subquery.test new file mode 100644 index 0000000..81d6861 --- /dev/null +++ b/parser/testdata/corpus/sql/subquery/scalar/test_update_subquery.test @@ -0,0 +1,25 @@ +# source: test/sql/subquery/scalar/test_update_subquery.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +UPDATE integers i1 SET i=(SELECT MAX(i) FROM integers WHERE i1.i<>i) +-- +ok +== +UPDATE integers i1 SET i=(SELECT MAX(i) FROM integers) WHERE i=(SELECT MIN(i) FROM integers) +-- +ok +== +UPDATE integers i1 SET i=(SELECT MAX(id) FROM integers WHERE id=e2.year)) ORDER BY name, course; +-- +ok +== +SELECT name, major FROM students s WHERE EXISTS(SELECT * FROM exams e WHERE e.sid=s.id AND grade=10) OR s.name='Dirk' ORDER BY name +-- +ok +== diff --git a/parser/testdata/corpus/sql/subquery/test_offset.test b/parser/testdata/corpus/sql/subquery/test_offset.test new file mode 100644 index 0000000..fad9194 --- /dev/null +++ b/parser/testdata/corpus/sql/subquery/test_offset.test @@ -0,0 +1,9 @@ +# source: test/sql/subquery/test_offset.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +SELECT (SELECT c0 OFFSET 1) FROM (VALUES(1)) c0; +-- +ok +== diff --git a/parser/testdata/corpus/sql/table_function/create_external_resource.test b/parser/testdata/corpus/sql/table_function/create_external_resource.test new file mode 100644 index 0000000..7e0c3bf --- /dev/null +++ b/parser/testdata/corpus/sql/table_function/create_external_resource.test @@ -0,0 +1,316 @@ +# source: test/sql/table_function/create_external_resource.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +CREATE MACRO mock_create(p) AS TABLE SELECT MAP {'id': 'r1'} AS handle; +-- +ok +== +CREATE MACRO mock_status(h) AS TABLE + SELECT 'ready' AS state, MAP {'uri': 'quack:localhost:9494', 'attached_db_type': 'quack', 'token': 't1'} AS result; +-- +ok +== +CREATE MACRO mock_destroy(h) AS TABLE SELECT 'ok' AS status; +-- +ok +== +CALL register_external_resource_type('mock@local', kind := 'catalog', create_function := 'mock_create', + status_function := 'mock_status', destroy_function := 'mock_destroy'); +-- +ok +== +SELECT uri, attached_db_type, deleter_function LIKE '%mock_destroy', handle +FROM create_external_resource('mock@local', params := MAP {'region': 'x'}); +-- +ok +== +SELECT result FROM create_external_resource('mock@local'); +-- +ok +== +SELECT handle, uri FROM create_external_resource('mock@local', handle := MAP {'id': 'adopted'}); +-- +ok +== +SET VARIABLE dfn = (SELECT deleter_function FROM create_external_resource('mock@local')); +-- +ok +== +SET VARIABLE dpl = (SELECT deleter_payload FROM create_external_resource('mock@local')); +-- +ok +== +CALL destroy_external_resource(getvariable('dfn'), getvariable('dpl')); +-- +ok +== +CREATE MACRO bad_status(h) AS TABLE SELECT 'ready' AS state, MAP {'foo': 'bar'} AS result; +-- +ok +== +CALL register_external_resource_type('badattach@local', kind := 'catalog', create_function := 'mock_create', status_function := 'bad_status'); +-- +ok +== +SELECT * FROM create_external_resource('badattach@local'); +-- +ok +== +CREATE MACRO fail_status(h) AS TABLE SELECT 'failed' AS state, MAP {'x': 'y'} AS result; +-- +ok +== +CALL register_external_resource_type('failing@local', kind := 'catalog', create_function := 'mock_create', status_function := 'fail_status'); +-- +ok +== +SELECT * FROM create_external_resource('failing@local'); +-- +ok +== +CALL register_external_resource_type('nostatus@local', kind := 'catalog', create_function := 'mock_create'); +-- +ok +== +SELECT * FROM create_external_resource('nostatus@local'); +-- +ok +== +SELECT * FROM create_external_resource('does_not_exist@local'); +-- +ok +== +CREATE MACRO "select"(p) AS TABLE SELECT MAP {'id':'r'} AS handle; +-- +ok +== +CREATE MACRO plain_status(h) AS TABLE SELECT 'ready' AS state, MAP {'uri':'kw', 'attached_db_type':'quack'} AS result; +-- +ok +== +CALL register_external_resource_type('kw@local', kind := 'catalog', create_function := 'select', status_function := 'plain_status'); +-- +ok +== +SELECT uri FROM create_external_resource('kw@local'); +-- +ok +== +CREATE MACRO nonmap_result_status(h) AS TABLE SELECT 'ready' AS state, 42 AS result; +-- +ok +== +CALL register_external_resource_type('nonmap_result@local', kind := 'compute', create_function := 'mock_create', status_function := 'nonmap_result_status'); +-- +ok +== +SELECT * FROM create_external_resource('nonmap_result@local'); +-- +ok +== +CREATE MACRO nonmap_handle_create(p) AS TABLE SELECT 99 AS handle; +-- +ok +== +CALL register_external_resource_type('nonmap_handle@local', kind := 'compute', create_function := 'nonmap_handle_create', status_function := 'mock_status'); +-- +ok +== +SELECT * FROM create_external_resource('nonmap_handle@local'); +-- +ok +== +CREATE MACRO stuck_status(h) AS TABLE SELECT 'pending' AS state, MAP {'uri':'u','attached_db_type':'quack'} AS result; +-- +ok +== +CALL register_external_resource_type('stuck@local', kind := 'catalog', create_function := 'mock_create', status_function := 'stuck_status'); +-- +ok +== +SET max_execution_time = 500; +-- +ok +== +SELECT * FROM create_external_resource('stuck@local'); +-- +ok +== +SET max_execution_time = 0; +-- +ok +== +SELECT * FROM create_external_resource('stuck@local', timeout_seconds := -1); +-- +ok +== +SELECT * FROM create_external_resource('stuck@local', timeout_seconds := 9223372036854775807); +-- +ok +== +SELECT * FROM create_external_resource('stuck@local', poll_interval_seconds := 0); +-- +ok +== +SELECT * FROM create_external_resource('stuck@local', poll_interval_seconds := 9223372036854775807); +-- +ok +== +CREATE MACRO compute_status(h) AS TABLE SELECT 'ready' AS state, MAP {'ip': '10.0.0.1'} AS result; +-- +ok +== +CALL register_external_resource_type('compute@local', kind := 'compute', create_function := 'mock_create', status_function := 'compute_status'); +-- +ok +== +SELECT result FROM create_external_resource('compute@local'); +-- +ok +== +CREATE SCHEMA app; +-- +ok +== +CREATE MACRO app.sp_create(p) AS TABLE SELECT MAP {'id':'r'} AS handle; +-- +ok +== +CREATE MACRO app.sp_status(h) AS TABLE SELECT 'ready' AS state, MAP {'uri':'quack:sp', 'attached_db_type':'quack'} AS result; +-- +ok +== +SET search_path = 'app'; +-- +ok +== +CALL register_external_resource_type('sp@local', kind := 'catalog', create_function := 'sp_create', status_function := 'sp_status'); +-- +ok +== +SELECT uri FROM create_external_resource('sp@local'); +-- +ok +== +CREATE SCHEMA q; +-- +ok +== +CREATE SEQUENCE q.qd_calls; +-- +ok +== +CREATE MACRO q.qd_create(p) AS TABLE SELECT MAP {'id':'r'} AS handle; +-- +ok +== +CREATE MACRO q.qd_status(h) AS TABLE SELECT 'ready' AS state, MAP {'uri':'qq','attached_db_type':'quack'} AS result; +-- +ok +== +CREATE MACRO q.qd_destroy(h) AS TABLE SELECT nextval('q.qd_calls') AS n; +-- +ok +== +SET search_path = 'q'; +-- +ok +== +CALL register_external_resource_type('qd@local', kind := 'catalog', create_function := 'qd_create', status_function := 'qd_status', destroy_function := 'qd_destroy'); +-- +ok +== +SELECT deleter_function LIKE '%.q.qd_destroy' FROM create_external_resource('qd@local'); +-- +ok +== +SET VARIABLE dfn = (SELECT deleter_function FROM create_external_resource('qd@local')); +-- +ok +== +SET VARIABLE dpl = (SELECT deleter_payload FROM create_external_resource('qd@local')); +-- +ok +== +CREATE SEQUENCE teardown_calls; +-- +ok +== +CREATE MACRO ok_handle(p) AS TABLE SELECT MAP {'id':'z'} AS handle; +-- +ok +== +CREATE MACRO fails(h) AS TABLE SELECT 'failed' AS state, MAP {'x':'y'} AS result; +-- +ok +== +CREATE MACRO record_teardown(h) AS TABLE SELECT nextval('teardown_calls') AS n; +-- +ok +== +CALL register_external_resource_type('leaky@local', kind := 'compute', create_function := 'ok_handle', status_function := 'fails', destroy_function := 'record_teardown'); +-- +ok +== +SELECT * FROM create_external_resource('leaky@local'); +-- +ok +== +SELECT nextval('teardown_calls'); +-- +ok +== +CREATE SEQUENCE teardown_calls_kept; +-- +ok +== +CREATE MACRO record_teardown_kept(h) AS TABLE SELECT nextval('teardown_calls_kept') AS n; +-- +ok +== +CALL register_external_resource_type('kept@local', kind := 'compute', create_function := 'ok_handle', status_function := 'fails', destroy_function := 'record_teardown_kept'); +-- +ok +== +SELECT * FROM create_external_resource('kept@local', teardown_on_failure := false); +-- +ok +== +SELECT nextval('teardown_calls_kept'); +-- +ok +== +CREATE SEQUENCE prov_count; +-- +ok +== +CREATE MACRO pc_create(p) AS TABLE SELECT MAP {'id': 'r' || nextval('prov_count')} AS handle; +-- +ok +== +CREATE MACRO pc_status(h) AS TABLE SELECT 'ready' AS state, MAP {'uri':'u','attached_db_type':'quack'} AS result; +-- +ok +== +CALL register_external_resource_type('pc@local', kind := 'catalog', create_function := 'pc_create', status_function := 'pc_status'); +-- +ok +== +SELECT * FROM create_external_resource('pc@local'); +-- +ok +== +SELECT nextval('prov_count'); +-- +ok +== +SELECT a.uri, b.uri FROM create_external_resource('pc@local') a, create_external_resource('pc@local') b; +-- +ok +== +SELECT * FROM create_external_resource('pc@local') LIMIT 0; +-- +ok +== diff --git a/parser/testdata/corpus/sql/table_function/database_oid.test b/parser/testdata/corpus/sql/table_function/database_oid.test new file mode 100644 index 0000000..15678d5 --- /dev/null +++ b/parser/testdata/corpus/sql/table_function/database_oid.test @@ -0,0 +1,17 @@ +# source: test/sql/table_function/database_oid.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +CREATE TEMP TABLE x (x INT); +-- +ok +== +CREATE TABLE x (x INT); +-- +ok +== +SELECT COUNT(DISTINCT database_oid) FROM duckdb_tables(); +-- +ok +== diff --git a/parser/testdata/corpus/sql/table_function/duckdb_available_metrics.test b/parser/testdata/corpus/sql/table_function/duckdb_available_metrics.test new file mode 100644 index 0000000..b138891 --- /dev/null +++ b/parser/testdata/corpus/sql/table_function/duckdb_available_metrics.test @@ -0,0 +1,11 @@ +# source: test/sql/table_function/duckdb_available_metrics.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +SELECT metric_name, metric_type, description, unit +FROM duckdb_available_metrics() +WHERE metric_name = 'query.cpu_time'; +-- +ok +== diff --git a/parser/testdata/corpus/sql/table_function/duckdb_columns.test b/parser/testdata/corpus/sql/table_function/duckdb_columns.test new file mode 100644 index 0000000..67cd590 --- /dev/null +++ b/parser/testdata/corpus/sql/table_function/duckdb_columns.test @@ -0,0 +1,51 @@ +# source: test/sql/table_function/duckdb_columns.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +SELECT * FROM duckdb_columns(); +-- +ok +== +SELECT * FROM duckdb_columns; +-- +ok +== +CREATE TABLE test(i INTEGER NOT NULL, j DECIMAL(18, 3), k VARCHAR DEFAULT 'hello') +-- +ok +== +SELECT tables.table_name, column_name, data_type, column_default, is_nullable, numeric_precision, numeric_precision_radix, numeric_scale +FROM duckdb_columns cols JOIN duckdb_tables tables USING (table_oid) ORDER BY 1, 2, 3; +-- +ok +== +SELECT DISTINCT(cols.database_name) = current_database() +FROM duckdb_columns cols JOIN duckdb_tables tables USING (table_oid); +-- +ok +== +create view v1 as select * from test +-- +ok +== +select table_name, column_name from duckdb_columns where table_name = 'v1' +-- +ok +== +alter table test rename column j to renamed +-- +ok +== +alter table test rename column renamed to j +-- +ok +== +create or replace view v1 (a, b) as select * from test; +-- +ok +== +alter table test rename column k to not_k +-- +ok +== diff --git a/parser/testdata/corpus/sql/table_function/duckdb_constraints.test b/parser/testdata/corpus/sql/table_function/duckdb_constraints.test new file mode 100644 index 0000000..9976c06 --- /dev/null +++ b/parser/testdata/corpus/sql/table_function/duckdb_constraints.test @@ -0,0 +1,45 @@ +# source: test/sql/table_function/duckdb_constraints.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +create table integers(i int primary key, check (i < 10)); +-- +ok +== +create table test(i varchar unique, k varchar, check(len(i || k) < 10)); +-- +ok +== +create table fk_integers(j int, foreign key (j) references integers(i)); +-- +ok +== +create table fk_integers_2(k int, foreign key (k) references integers(i)); +-- +ok +== +SELECT * FROM duckdb_constraints(); +-- +ok +== +SELECT * FROM duckdb_constraints; +-- +ok +== +SELECT table_name, constraint_index, constraint_type, UNNEST(constraint_column_names) col_name FROM duckdb_constraints ORDER BY table_name, constraint_index, col_name +-- +ok +== +SELECT constraint_name, unique_constraint_name FROM information_schema.referential_constraints ORDER BY constraint_name +-- +ok +== +SELECT column_name, constraint_name, table_name, position_in_unique_constraint FROM information_schema.key_column_usage ORDER BY constraint_name +-- +ok +== +SELECT constraint_name, table_name, constraint_type FROM information_schema.table_constraints ORDER BY constraint_name; +-- +ok +== diff --git a/parser/testdata/corpus/sql/table_function/duckdb_constraints_fk.test b/parser/testdata/corpus/sql/table_function/duckdb_constraints_fk.test new file mode 100644 index 0000000..2609529 --- /dev/null +++ b/parser/testdata/corpus/sql/table_function/duckdb_constraints_fk.test @@ -0,0 +1,44 @@ +# source: test/sql/table_function/duckdb_constraints_fk.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +CREATE TABLE tf_1 ( + a integer, "b c" integer, "d e" integer, + PRIMARY KEY (a), + UNIQUE ("b c"), + UNIQUE ("d e") +); +-- +ok +== +CREATE TABLE tf_3 ( + g integer, h integer, + PRIMARY KEY (g), + UNIQUE (h) +); +-- +ok +== +CREATE TABLE tf_2 ( + c integer, d integer, e integer, f integer, g integer, + PRIMARY KEY (c), + FOREIGN KEY (d) REFERENCES tf_1 (a), + FOREIGN KEY (e) REFERENCES tf_1 ("b c"), + FOREIGN KEY (f) REFERENCES tf_1 ("d e"), + FOREIGN KEY (g) REFERENCES tf_3 (g), +); +-- +ok +== +CREATE TABLE tf_4 ( + h integer, + FOREIGN KEY (h) REFERENCES tf_3 (h), +); +-- +ok +== +SELECT * EXCLUDE (database_name, schema_oid, table_oid, database_oid, constraint_name) FROM duckdb_constraints(); +-- +ok +== diff --git a/parser/testdata/corpus/sql/table_function/duckdb_constraints_issue11284.test b/parser/testdata/corpus/sql/table_function/duckdb_constraints_issue11284.test new file mode 100644 index 0000000..130de58 --- /dev/null +++ b/parser/testdata/corpus/sql/table_function/duckdb_constraints_issue11284.test @@ -0,0 +1,29 @@ +# source: test/sql/table_function/duckdb_constraints_issue11284.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +create table t (i int primary key); +-- +ok +== +select constraint_text from duckdb_constraints() where constraint_type = 'PRIMARY KEY'; +-- +ok +== +create table u (i int references t); +-- +ok +== +create table v (i int references t); +-- +ok +== +drop table v; +-- +ok +== +drop table u; +-- +ok +== diff --git a/parser/testdata/corpus/sql/table_function/duckdb_constraints_issue12863.test b/parser/testdata/corpus/sql/table_function/duckdb_constraints_issue12863.test new file mode 100644 index 0000000..1ec4bb6 --- /dev/null +++ b/parser/testdata/corpus/sql/table_function/duckdb_constraints_issue12863.test @@ -0,0 +1,29 @@ +# source: test/sql/table_function/duckdb_constraints_issue12863.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +CREATE TABLE a (ID int PRIMARY KEY); +-- +ok +== +CREATE TABLE b (id int REFERENCES A); +-- +ok +== +SELECT constraint_name, unique_constraint_name FROM information_schema.referential_constraints; +-- +ok +== +CREATE TABLE s1.a (ID int PRIMARY KEY); +-- +ok +== +CREATE TABLE s1.b (id int REFERENCES s1.A); +-- +ok +== +SELECT COUNT(*) FROM information_schema.referential_constraints; +-- +ok +== diff --git a/parser/testdata/corpus/sql/table_function/duckdb_databases.test b/parser/testdata/corpus/sql/table_function/duckdb_databases.test new file mode 100644 index 0000000..77376ab --- /dev/null +++ b/parser/testdata/corpus/sql/table_function/duckdb_databases.test @@ -0,0 +1,49 @@ +# source: test/sql/table_function/duckdb_databases.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +SELECT * FROM duckdb_databases(); +-- +ok +== +SELECT database_name, internal, readonly, path, type FROM duckdb_databases() ORDER BY database_name; +-- +ok +== +ATTACH '{TEST_DIR}/duckdb_databases.db' AS new_duckdb_database +-- +ok +== +SELECT database_name, internal, split(replace(path, '\', '/'), '/')[-1], type FROM duckdb_databases() WHERE path IS NOT NULL; +-- +ok +== +SELECT readonly FROM duckdb_databases WHERE database_name='new_duckdb_database'; +-- +ok +== +SELECT database_name FROM duckdb_databases ORDER BY database_name +-- +ok +== +SHOW databases +-- +ok +== +SELECT datname FROM pg_catalog.pg_database ORDER BY 1 +-- +ok +== +DETACH new_duckdb_database; +-- +ok +== +ATTACH '{TEST_DIR}/duckdb_databases.db' AS readonly_duckdb_database (READONLY 1); +-- +ok +== +SELECT readonly FROM duckdb_databases WHERE database_name='readonly_duckdb_database'; +-- +ok +== diff --git a/parser/testdata/corpus/sql/table_function/duckdb_dependencies.test b/parser/testdata/corpus/sql/table_function/duckdb_dependencies.test new file mode 100644 index 0000000..1eecf4a --- /dev/null +++ b/parser/testdata/corpus/sql/table_function/duckdb_dependencies.test @@ -0,0 +1,9 @@ +# source: test/sql/table_function/duckdb_dependencies.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +SELECT * FROM duckdb_dependencies(); +-- +ok +== diff --git a/parser/testdata/corpus/sql/table_function/duckdb_dialects.test b/parser/testdata/corpus/sql/table_function/duckdb_dialects.test new file mode 100644 index 0000000..c5005cc --- /dev/null +++ b/parser/testdata/corpus/sql/table_function/duckdb_dialects.test @@ -0,0 +1,25 @@ +# source: test/sql/table_function/duckdb_dialects.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +SELECT dialect_name FROM duckdb_dialects() ORDER BY dialect_name; +-- +ok +== +SELECT current_setting('current_dialect'); +-- +ok +== +SET current_dialect = 'duckdb'; +-- +ok +== +SET current_dialect = 'missing'; +-- +ok +== +RESET current_dialect; +-- +ok +== diff --git a/parser/testdata/corpus/sql/table_function/duckdb_eviction_queues.test b/parser/testdata/corpus/sql/table_function/duckdb_eviction_queues.test new file mode 100644 index 0000000..8a9d709 --- /dev/null +++ b/parser/testdata/corpus/sql/table_function/duckdb_eviction_queues.test @@ -0,0 +1,36 @@ +# source: test/sql/table_function/duckdb_eviction_queues.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +CREATE MACRO fudge() AS (20); +-- +ok +== +CREATE MACRO eviction_invariants_ok() AS ( + SELECT COUNT(*) = 0 FROM duckdb_eviction_queues() + WHERE dead_nodes < 0 + OR dead_nodes > approximate_size + fudge() + OR dead_nodes > total_insertions + OR total_insertions < approximate_size - fudge() +); +-- +ok +== +CREATE TABLE t AS SELECT range AS i, range::VARCHAR AS s +FROM range(2000000); +-- +ok +== +SELECT eviction_invariants_ok(); +-- +ok +== +SELECT SUM(length(s)) FROM t; +-- +ok +== +SET memory_limit='4MB'; +-- +ok +== diff --git a/parser/testdata/corpus/sql/table_function/duckdb_eviction_queues_transactions.test b/parser/testdata/corpus/sql/table_function/duckdb_eviction_queues_transactions.test new file mode 100644 index 0000000..ca3f2ac --- /dev/null +++ b/parser/testdata/corpus/sql/table_function/duckdb_eviction_queues_transactions.test @@ -0,0 +1,13 @@ +# source: test/sql/table_function/duckdb_eviction_queues_transactions.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +CREATE TABLE t(i BIGINT, s VARCHAR); +-- +ok +== +INSERT INTO t SELECT range AS i, range::VARCHAR AS s FROM range(200000); +-- +ok +== diff --git a/parser/testdata/corpus/sql/table_function/duckdb_extensions.test b/parser/testdata/corpus/sql/table_function/duckdb_extensions.test new file mode 100644 index 0000000..18fc7d3 --- /dev/null +++ b/parser/testdata/corpus/sql/table_function/duckdb_extensions.test @@ -0,0 +1,17 @@ +# source: test/sql/table_function/duckdb_extensions.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +SELECT aliases FROM duckdb_extensions() WHERE extension_name='postgres_scanner'; +-- +ok +== +LOAD tpch; +-- +ok +== +SELECT extension_name FROM duckdb_extensions() WHERE loaded AND extension_name='tpch'; +-- +ok +== diff --git a/parser/testdata/corpus/sql/table_function/duckdb_functions_window.test b/parser/testdata/corpus/sql/table_function/duckdb_functions_window.test new file mode 100644 index 0000000..6076a0c --- /dev/null +++ b/parser/testdata/corpus/sql/table_function/duckdb_functions_window.test @@ -0,0 +1,12 @@ +# source: test/sql/table_function/duckdb_functions_window.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +select function_name, parameters, parameter_types, function_type +from duckdb_functions() +where function_type = 'window' +order by all; +-- +ok +== diff --git a/parser/testdata/corpus/sql/table_function/duckdb_indexes.test b/parser/testdata/corpus/sql/table_function/duckdb_indexes.test new file mode 100644 index 0000000..de01b1a --- /dev/null +++ b/parser/testdata/corpus/sql/table_function/duckdb_indexes.test @@ -0,0 +1,17 @@ +# source: test/sql/table_function/duckdb_indexes.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +SELECT * FROM duckdb_indexes(); +-- +ok +== +SELECT * FROM duckdb_indexes; +-- +ok +== +select expressions from duckdb_indexes where table_name = 'integers'; +-- +ok +== diff --git a/parser/testdata/corpus/sql/table_function/duckdb_keywords.test b/parser/testdata/corpus/sql/table_function/duckdb_keywords.test new file mode 100644 index 0000000..acee742 --- /dev/null +++ b/parser/testdata/corpus/sql/table_function/duckdb_keywords.test @@ -0,0 +1,9 @@ +# source: test/sql/table_function/duckdb_keywords.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +SELECT * FROM duckdb_keywords(); +-- +ok +== diff --git a/parser/testdata/corpus/sql/table_function/duckdb_memory_convert_to_persistent.test b/parser/testdata/corpus/sql/table_function/duckdb_memory_convert_to_persistent.test new file mode 100644 index 0000000..92cd0ec --- /dev/null +++ b/parser/testdata/corpus/sql/table_function/duckdb_memory_convert_to_persistent.test @@ -0,0 +1,13 @@ +# source: test/sql/table_function/duckdb_memory_convert_to_persistent.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +create table test as select range i from range(1_000_000); +-- +ok +== +select memory_usage_bytes from duckdb_memory() where tag = 'IN_MEMORY_TABLE' +-- +ok +== diff --git a/parser/testdata/corpus/sql/table_function/duckdb_optimizers.test b/parser/testdata/corpus/sql/table_function/duckdb_optimizers.test new file mode 100644 index 0000000..f460710 --- /dev/null +++ b/parser/testdata/corpus/sql/table_function/duckdb_optimizers.test @@ -0,0 +1,13 @@ +# source: test/sql/table_function/duckdb_optimizers.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +SELECT * FROM duckdb_optimizers(); +-- +ok +== +SELECT name FROM duckdb_optimizers() WHERE name='join_order'; +-- +ok +== diff --git a/parser/testdata/corpus/sql/table_function/duckdb_prepared_statements.test b/parser/testdata/corpus/sql/table_function/duckdb_prepared_statements.test new file mode 100644 index 0000000..e6811db --- /dev/null +++ b/parser/testdata/corpus/sql/table_function/duckdb_prepared_statements.test @@ -0,0 +1,9 @@ +# source: test/sql/table_function/duckdb_prepared_statements.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +select * from duckdb_prepared_statements() order by name; +-- +ok +== diff --git a/parser/testdata/corpus/sql/table_function/duckdb_schemas.test b/parser/testdata/corpus/sql/table_function/duckdb_schemas.test new file mode 100644 index 0000000..89cc751 --- /dev/null +++ b/parser/testdata/corpus/sql/table_function/duckdb_schemas.test @@ -0,0 +1,21 @@ +# source: test/sql/table_function/duckdb_schemas.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +SELECT COUNT(*) FROM duckdb_schemas; +-- +ok +== +CREATE SCHEMA scheme; +-- +ok +== +SELECT COUNT(*) FROM duckdb_schemas() WHERE schema_name='scheme'; +-- +ok +== +SELECT COUNT(*) FROM duckdb_schemas WHERE schema_name='scheme'; +-- +ok +== diff --git a/parser/testdata/corpus/sql/table_function/duckdb_sequences.test b/parser/testdata/corpus/sql/table_function/duckdb_sequences.test new file mode 100644 index 0000000..2a4504b --- /dev/null +++ b/parser/testdata/corpus/sql/table_function/duckdb_sequences.test @@ -0,0 +1,23 @@ +# source: test/sql/table_function/duckdb_sequences.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +SELECT COUNT(*) FROM duckdb_sequences(); +-- +ok +== +CREATE TEMPORARY SEQUENCE seq2 MINVALUE 3 MAXVALUE 5 START WITH 4 CYCLE; +-- +ok +== +SELECT schema_name, sequence_name, temporary, start_value, min_value, max_value, increment_by, cycle +FROM duckdb_sequences() ORDER BY sequence_name; +-- +ok +== +SELECT database_name = current_database() OR database_name = 'temp' +FROM duckdb_sequences(); +-- +ok +== diff --git a/parser/testdata/corpus/sql/table_function/duckdb_settings.test b/parser/testdata/corpus/sql/table_function/duckdb_settings.test new file mode 100644 index 0000000..e8d29f7 --- /dev/null +++ b/parser/testdata/corpus/sql/table_function/duckdb_settings.test @@ -0,0 +1,31 @@ +# source: test/sql/table_function/duckdb_settings.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +SELECT name, value FROM duckdb_settings() WHERE name='default_null_order'; +-- +ok +== +SELECT COUNT(DISTINCT variant_typeof(typed_value)) > 1 FROM duckdb_settings(); +-- +ok +== +SELECT + typeof(value), + typeof(typed_value), + variant_typeof(typed_value) +FROM duckdb_settings() +WHERE name = 'standard_vector_size'; +-- +ok +== +SELECT + typeof(value), + typeof(typed_value), + variant_typeof(typed_value) +FROM duckdb_settings() +WHERE name = 'logging_level'; +-- +ok +== diff --git a/parser/testdata/corpus/sql/table_function/duckdb_tables.test b/parser/testdata/corpus/sql/table_function/duckdb_tables.test new file mode 100644 index 0000000..f541b25 --- /dev/null +++ b/parser/testdata/corpus/sql/table_function/duckdb_tables.test @@ -0,0 +1,35 @@ +# source: test/sql/table_function/duckdb_tables.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +SELECT COUNT(*) FROM duckdb_tables(); +-- +ok +== +CREATE TABLE pk(i INTEGER PRIMARY KEY, j VARCHAR, CHECK(i<100)) +-- +ok +== +CREATE TABLE myschema.mytable(k DOUBLE) +-- +ok +== +CREATE TEMPORARY TABLE mytemp(i INTEGER) +-- +ok +== +SELECT schema_name, table_name, temporary, has_primary_key, estimated_size, column_count, index_count, check_constraint_count +FROM duckdb_tables() ORDER BY table_name; +-- +ok +== +SELECT database_name = current_database() OR database_name = 'temp' +FROM duckdb_tables(); +-- +ok +== +SELECT * FROM temp.duckdb_tables +-- +ok +== diff --git a/parser/testdata/corpus/sql/table_function/duckdb_types.test b/parser/testdata/corpus/sql/table_function/duckdb_types.test new file mode 100644 index 0000000..617700f --- /dev/null +++ b/parser/testdata/corpus/sql/table_function/duckdb_types.test @@ -0,0 +1,13 @@ +# source: test/sql/table_function/duckdb_types.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +SELECT * FROM duckdb_types(); +-- +ok +== +SELECT * FROM duckdb_types; +-- +ok +== diff --git a/parser/testdata/corpus/sql/table_function/duckdb_views.test b/parser/testdata/corpus/sql/table_function/duckdb_views.test new file mode 100644 index 0000000..892b1fc --- /dev/null +++ b/parser/testdata/corpus/sql/table_function/duckdb_views.test @@ -0,0 +1,41 @@ +# source: test/sql/table_function/duckdb_views.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +SELECT COUNT(*) FROM duckdb_views; +-- +ok +== +CREATE VIEW v1 AS SELECT 42; +-- +ok +== +CREATE TEMPORARY VIEW v2 AS SELECT 42; +-- +ok +== +CREATE VIEW myschema.v2 AS SELECT 42; +-- +ok +== +SELECT schema_name, view_name, temporary +FROM duckdb_views() WHERE NOT internal ORDER BY ALL; +-- +ok +== +SELECT database_name = current_database() OR database_name = 'temp' +FROM duckdb_views() WHERE NOT internal ORDER BY view_name; +-- +ok +== +SELECT schema_name, view_name, temporary +FROM duckdb_views ORDER BY ALL; +-- +ok +== +SELECT database_name = current_database() OR database_name = 'temp' +FROM duckdb_views ORDER BY view_name; +-- +ok +== diff --git a/parser/testdata/corpus/sql/table_function/external_resource_discovery.test b/parser/testdata/corpus/sql/table_function/external_resource_discovery.test new file mode 100644 index 0000000..4e024d4 --- /dev/null +++ b/parser/testdata/corpus/sql/table_function/external_resource_discovery.test @@ -0,0 +1,70 @@ +# source: test/sql/table_function/external_resource_discovery.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +CREATE MACRO mock_list(opts) AS TABLE + SELECT * FROM (VALUES + (MAP {'id': 'd1'}, 'ext-1', 'running'), + (MAP {'id': 'd2'}, 'ext-2', 'stopped') + ) t(handle, reference, state); +-- +ok +== +CALL register_external_resource_type('mock@disc', kind := 'catalog', create_function := 'noop_create', list_function := 'mock_list'); +-- +ok +== +SELECT list_function FROM duckdb_external_resource_types() WHERE name = 'mock@disc'; +-- +ok +== +SELECT count(*) FROM duckdb_external_resources(); +-- +ok +== +SELECT name, type, managed, state, reference FROM duckdb_external_resources(discover := true) ORDER BY reference; +-- +ok +== +CALL register_external_resource('mock@disc', 'local_d1', MAP {'id': 'd1'}); +-- +ok +== +SELECT name, type, managed FROM duckdb_external_resources(); +-- +ok +== +SELECT name, type, managed, state, reference FROM duckdb_external_resources(discover := true) ORDER BY managed DESC; +-- +ok +== +CALL register_external_resource_type('nolist@disc', kind := 'catalog', create_function := 'noop_create'); +-- +ok +== +SELECT count(*) FROM duckdb_external_resources(discover := true); +-- +ok +== +CREATE MACRO other_list(opts) AS TABLE + SELECT * FROM (VALUES (MAP {'id': 'd1'}, 'other-1', 'running')) t(handle, reference, state); +-- +ok +== +CALL register_external_resource_type('other@disc', kind := 'catalog', create_function := 'noop_create', list_function := 'other_list'); +-- +ok +== +SELECT name, type, managed, state, reference FROM duckdb_external_resources(discover := true) ORDER BY type, reference; +-- +ok +== +CALL register_external_resource('other@disc', 'other_d1', MAP {'id': 'd1'}); +-- +ok +== +SELECT name, type, managed FROM duckdb_external_resources(discover := true) ORDER BY type, name; +-- +ok +== diff --git a/parser/testdata/corpus/sql/table_function/external_resource_discovery_error.test b/parser/testdata/corpus/sql/table_function/external_resource_discovery_error.test new file mode 100644 index 0000000..5157b73 --- /dev/null +++ b/parser/testdata/corpus/sql/table_function/external_resource_discovery_error.test @@ -0,0 +1,41 @@ +# source: test/sql/table_function/external_resource_discovery_error.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +CREATE MACRO nohandle_list(opts) AS TABLE SELECT 'ext-1' AS reference, 'running' AS state; +-- +ok +== +CALL register_external_resource_type('nohandle@disc', kind := 'catalog', create_function := 'noop_create', list_function := 'nohandle_list'); +-- +ok +== +SELECT * FROM duckdb_external_resources(discover := true); +-- +ok +== +CREATE OR REPLACE MACRO nohandle_list(opts) AS TABLE SELECT MAP {'id': 'a'} AS handle; +-- +ok +== +CREATE MACRO badtype_list(opts) AS TABLE SELECT 42 AS handle; +-- +ok +== +CALL register_external_resource_type('badtype@disc', kind := 'catalog', create_function := 'noop_create', list_function := 'badtype_list'); +-- +ok +== +CREATE OR REPLACE MACRO badtype_list(opts) AS TABLE SELECT MAP {'id': 'b'} AS handle; +-- +ok +== +CALL register_external_resource_type('broken@disc', kind := 'catalog', create_function := 'noop_create', list_function := 'no_such_list_fn'); +-- +ok +== +CREATE MACRO no_such_list_fn(opts) AS TABLE SELECT MAP {'id': 'c'} AS handle; +-- +ok +== diff --git a/parser/testdata/corpus/sql/table_function/external_resource_logging.test b/parser/testdata/corpus/sql/table_function/external_resource_logging.test new file mode 100644 index 0000000..32e2681 --- /dev/null +++ b/parser/testdata/corpus/sql/table_function/external_resource_logging.test @@ -0,0 +1,104 @@ +# source: test/sql/table_function/external_resource_logging.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +CREATE MACRO mock_status(h) AS TABLE + SELECT 'ready' AS state, MAP {'uri': 'quack:localhost:9494', 'attached_db_type': 'quack'} AS result; +-- +ok +== +CALL enable_logging('ExternalResource'); +-- +ok +== +SELECT * FROM create_external_resource('mock@local'); +-- +ok +== +SELECT operation, outcome, error IS NULL +FROM duckdb_logs_parsed('ExternalResource') WHERE resource_type = 'mock@local' ORDER BY operation; +-- +ok +== +SELECT extra_info['state'] +FROM duckdb_logs_parsed('ExternalResource') WHERE resource_type = 'mock@local' AND operation = 'status'; +-- +ok +== +CREATE MACRO scalar_create(p) AS TABLE SELECT 42 AS handle; +-- +ok +== +CALL register_external_resource_type('scalarcreate@local', kind := 'catalog', create_function := 'scalar_create', + status_function := 'mock_status', destroy_function := 'mock_destroy'); +-- +ok +== +SELECT * FROM create_external_resource('scalarcreate@local'); +-- +ok +== +SELECT operation, outcome +FROM duckdb_logs_parsed('ExternalResource') WHERE resource_type = 'scalarcreate@local'; +-- +ok +== +CREATE MACRO empty_create(p) AS TABLE SELECT MAP {'id': 'x'} AS handle WHERE false; +-- +ok +== +CALL register_external_resource_type('emptycreate@local', kind := 'catalog', create_function := 'empty_create', + status_function := 'mock_status', destroy_function := 'mock_destroy'); +-- +ok +== +SELECT * FROM create_external_resource('emptycreate@local'); +-- +ok +== +SELECT operation, outcome +FROM duckdb_logs_parsed('ExternalResource') WHERE resource_type = 'emptycreate@local'; +-- +ok +== +CREATE MACRO failed_status(h) AS TABLE SELECT 'failed' AS state, MAP {'id': 'r1'} AS result; +-- +ok +== +CALL register_external_resource_type('failed@local', kind := 'catalog', create_function := 'mock_create', + status_function := 'failed_status', destroy_function := 'mock_destroy'); +-- +ok +== +SELECT * FROM create_external_resource('failed@local'); +-- +ok +== +SELECT operation, outcome +FROM duckdb_logs_parsed('ExternalResource') WHERE resource_type = 'failed@local' ORDER BY operation; +-- +ok +== +SELECT * FROM create_external_resource('failed@local', teardown_on_failure := false); +-- +ok +== +SELECT count(*) +FROM duckdb_logs_parsed('ExternalResource') WHERE resource_type = 'failed@local' AND operation = 'destroy'; +-- +ok +== +SELECT DISTINCT type, log_level, scope FROM duckdb_logs_parsed('ExternalResource'); +-- +ok +== +CALL destroy_external_resource('mock_destroy', MAP {'id': 'r1'}); +-- +ok +== +SELECT operation, outcome, resource_name IS NULL +FROM duckdb_logs_parsed('ExternalResource') WHERE resource_type IS NULL; +-- +ok +== diff --git a/parser/testdata/corpus/sql/table_function/external_resource_types.test b/parser/testdata/corpus/sql/table_function/external_resource_types.test new file mode 100644 index 0000000..134484a --- /dev/null +++ b/parser/testdata/corpus/sql/table_function/external_resource_types.test @@ -0,0 +1,98 @@ +# source: test/sql/table_function/external_resource_types.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +SELECT count(*) FROM duckdb_external_resource_types(); +-- +ok +== +CALL register_external_resource_type('quack@aws:ec2', kind := 'catalog', create_function := 'quack_create'); +-- +ok +== +SELECT name, kind, create_function, status_function, destroy_function, resolve_function, origin FROM duckdb_external_resource_types(); +-- +ok +== +CALL register_external_resource_type('pg@aws:rds', kind := 'catalog', create_function := 'pg_create', + status_function := 'pg_status', destroy_function := 'pg_destroy', resolve_function := 'pg_resolve'); +-- +ok +== +SELECT status_function, destroy_function, resolve_function FROM duckdb_external_resource_types() WHERE name = 'pg@aws:rds'; +-- +ok +== +CALL register_external_resource_type('scratch_bucket', kind := 'storage', create_function := 's3_bucket_create', destroy_function := 's3_bucket_destroy'); +-- +ok +== +SELECT kind, destroy_function FROM duckdb_external_resource_types() WHERE name = 'scratch_bucket'; +-- +ok +== +CALL register_external_resource_type('quack@aws:ec2', kind := 'catalog', create_function := 'quack_create_v2'); +-- +ok +== +SELECT create_function, count(*) OVER () FROM duckdb_external_resource_types() WHERE name = 'quack@aws:ec2'; +-- +ok +== +CALL register_external_resource_type(NULL, kind := 'catalog', create_function := 'x'); +-- +ok +== +CALL register_external_resource_type('', kind := 'catalog', create_function := 'x'); +-- +ok +== +CALL register_external_resource_type('q@x', kind := 'catalog', create_function := '""', status_function := 'st'); +-- +ok +== +CALL register_external_resource_type('q@x', kind := 'catalog', create_function := '.'); +-- +ok +== +CALL register_external_resource_type('q@x', kind := 'catalog', create_function := 'a.b.c.d'); +-- +ok +== +CALL register_external_resource_type('q@x', kind := 'catalog', create_function := '"unterminated'); +-- +ok +== +CALL register_external_resource_type('q@x', kind := 'catalog', create_function := 'a..b'); +-- +ok +== +CALL register_external_resource_type('q@x', kind := 'catalog', create_function := '.foo'); +-- +ok +== +CALL register_external_resource_type('q@x', kind := 'catalog', create_function := 'c', status_function := '""'); +-- +ok +== +CALL register_external_resource_type('q@x', kind := 'catalog', create_function := 'c', destroy_function := 'a.b.c.d'); +-- +ok +== +CALL register_external_resource_type('q@x', kind := 'catalog', create_function := 'c', resolve_function := '.foo'); +-- +ok +== +SELECT count(*) FROM duckdb_external_resource_types() WHERE name = 'q@x'; +-- +ok +== +CALL register_external_resource_type('q@x', kind := 'catalog', create_function := 'my_catalog.my_schema."weird name"'); +-- +ok +== +SELECT create_function FROM duckdb_external_resource_types() WHERE name = 'q@x'; +-- +ok +== diff --git a/parser/testdata/corpus/sql/table_function/icu_range_timestamptz.test b/parser/testdata/corpus/sql/table_function/icu_range_timestamptz.test new file mode 100644 index 0000000..225537d --- /dev/null +++ b/parser/testdata/corpus/sql/table_function/icu_range_timestamptz.test @@ -0,0 +1,74 @@ +# source: test/sql/table_function/icu_range_timestamptz.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +SELECT d FROM range(TIMESTAMPTZ '1992-01-01 00:00:00-08', TIMESTAMPTZ '1992-01-01 12:00:00-08', INTERVAL (1) HOUR) tbl(d) +-- +ok +== +SELECT d FROM range(TIMESTAMPTZ '1992-01-01 00:00:00-08', TIMESTAMPTZ'1991-06-01 00:00:00-07', INTERVAL '1 MONTH ago') tbl(d) +-- +ok +== +SELECT d FROM generate_series(TIMESTAMPTZ '1992-01-01 00:00:00-08', TIMESTAMPTZ '1991-06-01 00:00:00-07', -INTERVAL '1 MONTH') tbl(d) +-- +ok +== +SELECT d FROM range(TIMESTAMPTZ '1992-01-01 00:00:00-08', TIMESTAMPTZ '1992-12-31 12:00:00-08', INTERVAL '1 MONTH 1 DAY 1 HOUR') tbl(d) +-- +ok +== +SELECT d FROM generate_series(TIMESTAMPTZ '1992-04-05 00:00:00-08', TIMESTAMPTZ '1992-04-05 12:00:00-07', INTERVAL '1 HOUR') tbl(d) +-- +ok +== +SELECT d FROM generate_series(TIMESTAMPTZ '1992-10-25 00:00:00-07', TIMESTAMPTZ '1992-10-25 12:00:00-08', INTERVAL '1 HOUR') tbl(d) +-- +ok +== +SELECT COUNT(*) FROM range(TIMESTAMPTZ '1992-01-01 00:00:00-08', TIMESTAMPTZ '2020-01-01 00:00:00-08', INTERVAL '1 DAY') tbl(d) +-- +ok +== +SELECT COUNT(*) FROM generate_series(TIMESTAMPTZ '1992-01-01 00:00:00-08', TIMESTAMPTZ '2020-01-01 00:00:00-08', INTERVAL '1 DAY') tbl(d) +-- +ok +== +explain +from range('290309-12-22 (BC) 00:00:00'::TIMESTAMPTZ, '294247-01-10 04:00:54.775806'::TIMESTAMPTZ, interval '1 hour'); +-- +ok +== +SELECT d FROM range(TIMESTAMPTZ '1992-01-01 00:00:00-08', TIMESTAMPTZ '1992-12-31 12:00:00-08', INTERVAL '0 MONTH') tbl(d) +-- +ok +== +SELECT d FROM range(TIMESTAMPTZ '1992-01-01 00:00:00-08', TIMESTAMPTZ '1992-12-31 12:00:00-08', INTERVAL '1 MONTH ago') tbl(d) +-- +ok +== +SELECT d FROM range(TIMESTAMPTZ '1993-01-01 00:00:00-08', TIMESTAMPTZ '1992-01-01 00:00:00-08', INTERVAL '1 MONTH') tbl(d) +-- +ok +== +SELECT d FROM range(TIMESTAMPTZ '1992-01-01 00:00:00-08', TIMESTAMPTZ '1992-12-31 12:00:00-08', INTERVAL '1 MONTH' - INTERVAL '1 HOUR') tbl(d) +-- +ok +== +SELECT COUNT(*) FROM generate_series('294247-01-09'::TIMESTAMPTZ, 'infinity'::TIMESTAMPTZ, INTERVAL '1 DAY'); +-- +ok +== +SELECT COUNT(*) FROM range('294247-01-09'::TIMESTAMPTZ, 'infinity'::TIMESTAMPTZ, INTERVAL '1 DAY'); +-- +ok +== +SELECT COUNT(*) FROM generate_series('-infinity'::TIMESTAMPTZ, '290303-12-11 (BC) 00:00:00'::TIMESTAMPTZ, INTERVAL '1 DAY'); +-- +ok +== +SELECT COUNT(*) FROM range('-infinity'::TIMESTAMPTZ, '290303-12-11 (BC) 00:00:00'::TIMESTAMPTZ, INTERVAL '1 DAY'); +-- +ok +== diff --git a/parser/testdata/corpus/sql/table_function/information_schema.test b/parser/testdata/corpus/sql/table_function/information_schema.test new file mode 100644 index 0000000..4db7d31 --- /dev/null +++ b/parser/testdata/corpus/sql/table_function/information_schema.test @@ -0,0 +1,145 @@ +# source: test/sql/table_function/information_schema.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +SELECT * FROM INFORMATION_SCHEMA.SCHEMATA; +-- +ok +== +SELECT * FROM information_schema.schemata; +-- +ok +== +SELECT COUNT(*) FROM information_schema.schemata WHERE schema_name='scheme' +-- +ok +== +CREATE TABLE scheme.integers (i INTEGER); +-- +ok +== +SELECT table_type FROM information_schema.tables WHERE table_schema='scheme' AND table_name='integers' AND table_catalog IS NOT NULL +-- +ok +== +SELECT ordinal_position, column_name, data_type FROM information_schema.columns WHERE table_name='integers' +-- +ok +== +CREATE TEMPORARY TABLE reals (f FLOAT PRIMARY KEY, dec DECIMAL(16, 4), h HUGEINT, b BIGINT, t TINYINT, d DOUBLE NOT NULL) +-- +ok +== +SELECT table_type FROM information_schema.tables WHERE table_catalog='temp' AND table_name='reals' +-- +ok +== +SELECT numeric_precision, numeric_scale, is_nullable FROM information_schema.columns WHERE table_name='reals' ORDER BY ordinal_position +-- +ok +== +CREATE VIEW scheme.vintegers AS SELECT * FROM scheme.integers; +-- +ok +== +SELECT table_type FROM information_schema.tables WHERE table_schema='scheme' AND table_name='vintegers' +-- +ok +== +SELECT ordinal_position, column_name, data_type FROM information_schema.columns WHERE table_schema='scheme' AND table_name='vintegers' AND table_catalog IS NOT NULL +-- +ok +== +SELECT character_set_name, character_repertoire, form_of_use, default_collate_name FROM information_schema.character_sets +-- +ok +== +SELECT * FROM information_schema.referential_constraints +-- +ok +== +SELECT * FROM information_schema.key_column_usage +-- +ok +== +SELECT * FROM information_schema.table_constraints +-- +ok +== +CREATE TABLE scheme.dept (dept_id INT PRIMARY KEY, dept_name VARCHAR(100) NOT NULL) +-- +ok +== +CREATE TABLE scheme.emp (emp_id INT PRIMARY KEY, first_name VARCHAR(100) NOT NULL, last_name VARCHAR(100) NOT NULL, ssn INT NOT NULL UNIQUE, salary DECIMAL(10, 2) NOT NULL CHECK (salary > 0), dept_id INT REFERENCES scheme.dept(dept_id)) +-- +ok +== +SELECT table_schema, table_name, column_name, constraint_schema, constraint_name +FROM information_schema.constraint_column_usage +WHERE table_schema = 'scheme' AND table_name = 'emp' +ORDER BY column_name ASC; +-- +ok +== +SELECT DISTINCT(table_catalog) = current_database() +FROM information_schema.constraint_column_usage +WHERE table_schema = 'scheme' AND table_name = 'emp' +ORDER BY column_name ASC; +-- +ok +== +SELECT DISTINCT(constraint_catalog) = current_database() +FROM information_schema.constraint_column_usage +WHERE table_schema = 'scheme' AND table_name = 'emp' +ORDER BY column_name ASC; +-- +ok +== +SELECT table_schema, table_name, constraint_schema, constraint_name +FROM information_schema.constraint_table_usage +WHERE table_schema = 'scheme' AND table_name = 'emp' +ORDER BY constraint_name ASC +-- +ok +== +SELECT constraint_schema, constraint_name, check_clause +FROM information_schema.check_constraints +WHERE constraint_schema = 'scheme' AND check_clause LIKE 'CHECK%' +-- +ok +== +SELECT DISTINCT(constraint_catalog) = current_database() +FROM information_schema.check_constraints +WHERE constraint_schema = 'scheme' AND check_clause LIKE 'CHECK%' +-- +ok +== +CREATE OR REPLACE VIEW scheme.emp_dept_view AS SELECT emp.*, dept.dept_name FROM scheme.emp JOIN scheme.dept ON emp.dept_id = dept.dept_id; +-- +ok +== +SELECT table_schema, table_name, SUBSTR (view_definition, 1, 32) AS view_definition_substr, check_option, is_updatable, is_insertable_into, is_trigger_updatable, is_trigger_deletable, is_trigger_insertable_into +FROM information_schema.views +WHERE table_schema = 'scheme' AND table_name = 'emp_dept_view'; +-- +ok +== +SELECT DISTINCT(table_catalog) = current_database() +FROM information_schema.views +WHERE table_schema = 'scheme' AND table_name = 'emp_dept_view'; +-- +ok +== +DROP SCHEMA scheme CASCADE; +-- +ok +== +SELECT COUNT(*) FROM information_schema.tables WHERE table_schema='scheme' +-- +ok +== +SELECT COUNT(*) FROM information_schema.columns WHERE table_schema='scheme' +-- +ok +== diff --git a/parser/testdata/corpus/sql/table_function/information_schema_fkey_constraint_names.test b/parser/testdata/corpus/sql/table_function/information_schema_fkey_constraint_names.test new file mode 100644 index 0000000..1edd46e --- /dev/null +++ b/parser/testdata/corpus/sql/table_function/information_schema_fkey_constraint_names.test @@ -0,0 +1,62 @@ +# source: test/sql/table_function/information_schema_fkey_constraint_names.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +select constraint_name +from information_schema.table_constraints +where constraint_type like '%KEY' +order by 1 +-- +ok +== +select constraint_name +from information_schema.key_column_usage +order by 1 +-- +ok +== +select constraint_name, unique_constraint_name +from information_schema.referential_constraints; +-- +ok +== +drop table u +-- +ok +== +create table target_tbl (target_col int primary key); +-- +ok +== +create table source_tbl(source_col int references target_tbl(target_col)); +-- +ok +== +DROP TABLE source_tbl; +-- +ok +== +DROP TABLE target_tbl; +-- +ok +== +CREATE TABLE a ( + a1 INT, a2 INT, a3 INT, + UNIQUE (a1, a2), UNIQUE (a2, a3) +); +-- +ok +== +CREATE TABLE b ( + a1 INT, a2 INT, a3 INT, + FOREIGN KEY (a1, a2) REFERENCES a (a1, a2), + FOREIGN KEY (a2, a3) REFERENCES a (a2, a3) +); +-- +ok +== +SELECT constraint_name, constraint_type FROM information_schema.table_constraints ORDER BY ALL +-- +ok +== diff --git a/parser/testdata/corpus/sql/table_function/information_schema_issue12867.test b/parser/testdata/corpus/sql/table_function/information_schema_issue12867.test new file mode 100644 index 0000000..7dad911 --- /dev/null +++ b/parser/testdata/corpus/sql/table_function/information_schema_issue12867.test @@ -0,0 +1,17 @@ +# source: test/sql/table_function/information_schema_issue12867.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +CREATE TABLE a (a1 int, a2 int, PRIMARY KEY (a1, a2)); +-- +ok +== +CREATE TABLE b (a1 int, a2 int, FOREIGN KEY (a1, a2) REFERENCES a); +-- +ok +== +SELECT table_name, column_name, ordinal_position, position_in_unique_constraint FROM information_schema.key_column_usage ORDER BY all; +-- +ok +== diff --git a/parser/testdata/corpus/sql/table_function/information_schema_types.test b/parser/testdata/corpus/sql/table_function/information_schema_types.test new file mode 100644 index 0000000..bc9e179 --- /dev/null +++ b/parser/testdata/corpus/sql/table_function/information_schema_types.test @@ -0,0 +1,13 @@ +# source: test/sql/table_function/information_schema_types.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +select table_name, column_name +from duckdb_columns() +where database_name = 'system' +and schema_name = 'information_schema' +and data_type = 'NULL' +-- +ok +== diff --git a/parser/testdata/corpus/sql/table_function/lateral_table_function.test b/parser/testdata/corpus/sql/table_function/lateral_table_function.test new file mode 100644 index 0000000..b42f2eb --- /dev/null +++ b/parser/testdata/corpus/sql/table_function/lateral_table_function.test @@ -0,0 +1,13 @@ +# source: test/sql/table_function/lateral_table_function.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +SELECT * FROM read_csv(thisishopefullyanonexistentfile) +-- +ok +== +SELECT * FROM (SELECT 'myfile.csv' AS thisishopefullyanonexistentfile), read_csv(thisishopefullyanonexistentfile) +-- +ok +== diff --git a/parser/testdata/corpus/sql/table_function/postgres_setof_compatibility.test b/parser/testdata/corpus/sql/table_function/postgres_setof_compatibility.test new file mode 100644 index 0000000..09792c6 --- /dev/null +++ b/parser/testdata/corpus/sql/table_function/postgres_setof_compatibility.test @@ -0,0 +1,97 @@ +# source: test/sql/table_function/postgres_setof_compatibility.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +select i from generate_series(1, 2) i; +-- +ok +== +select column_name, column_type from (describe select * from generate_series(1, 2) i); +-- +ok +== +select column_name, column_type from (describe select * from generate_series(1, 2) t(i)); +-- +ok +== +select r from range(1, 3) r; +-- +ok +== +select column_name, column_type from (describe select * from range(1, 3) r); +-- +ok +== +select r.range from range(1, 3) r; +-- +ok +== +select i from range(1, 3) r(i); +-- +ok +== +select i from unnest([1, 2]) i; +-- +ok +== +select column_name, column_type from (describe select * from unnest([1, 2]) i); +-- +ok +== +select column_name, column_type from (describe select * from unnest([1, 2]) t(i)); +-- +ok +== +select i.generate_series from generate_series(1, 2) i; +-- +ok +== +select i.unnest from unnest([1, 2]) i; +-- +ok +== +select r.unnest from unnest(range(0, 3)) as r; +-- +ok +== +select i.i from unnest([1, 2]) i; +-- +ok +== +select column_name, column_type from (describe select i from unnest([1, 2]) i); +-- +ok +== +select column_name, column_type from (describe select i.unnest from unnest([1, 2]) i); +-- +ok +== +select column_name, column_type from (describe select i.* from unnest([1, 2]) i); +-- +ok +== +select t.unnest from unnest([1, 2]) t(v); +-- +ok +== +select unnest.unnest from unnest([1, 2]) unnest; +-- +ok +== +create table lists as select * from (values (1, [10, 20]), (2, [30])) t(id, l); +-- +ok +== +select lst.id, x.unnest from lists lst, unnest(lst.l) as x order by 1, 2; +-- +ok +== +select g.generate_series, g.ordinality from generate_series(1, 3) with ordinality as g; +-- +ok +== +select g from generate_series(1, 3) with ordinality as g; +-- +ok +== diff --git a/parser/testdata/corpus/sql/table_function/range_function_different_iterators.test b/parser/testdata/corpus/sql/table_function/range_function_different_iterators.test new file mode 100644 index 0000000..1ab900b --- /dev/null +++ b/parser/testdata/corpus/sql/table_function/range_function_different_iterators.test @@ -0,0 +1,37 @@ +# source: test/sql/table_function/range_function_different_iterators.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +select * from range(4,15,6); +-- +ok +== +select * from range(-4,-15,-6); +-- +ok +== +select * from range(4,15); +-- +ok +== +select * from range(4,15,3)a; +-- +ok +== +select * from range(-4,-15,-3)a; +-- +ok +== +select * from range(4,15,5)a; +-- +ok +== +select * from range(4,19,5)a; +-- +ok +== +select * from generate_series(4,19,5)a; +-- +ok +== diff --git a/parser/testdata/corpus/sql/table_function/range_function_lateral.test b/parser/testdata/corpus/sql/table_function/range_function_lateral.test new file mode 100644 index 0000000..4a55225 --- /dev/null +++ b/parser/testdata/corpus/sql/table_function/range_function_lateral.test @@ -0,0 +1,77 @@ +# source: test/sql/table_function/range_function_lateral.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +SELECT * FROM range(1, NULL, 1); +-- +ok +== +SELECT * FROM (SELECT NULL a), range(a); +-- +ok +== +SELECT * FROM (SELECT NULL a), range(timestamp '2010-01-01', a, null); +-- +ok +== +SELECT * FROM range(3) t(i), range(i) t2(j) ORDER BY i, j; +-- +ok +== +SELECT * FROM range(4) t(i), range(i) t2(j), range(j) t3(k) ORDER BY i, j, k; +-- +ok +== +SELECT * FROM generate_series(0,2) t(i), generate_series(0,i) t2(j), generate_series(0,j) t3(k) ORDER BY i, j, k; +-- +ok +== +SELECT i, j, l, str FROM (SELECT ARRAY['null'], NULL, 'null' UNION ALL SELECT ARRAY['five'], 5, 'five' UNION ALL SELECT ARRAY['two'], 2, 'two') t(l, i, str), generate_series(0,i-1) t2(j) order by i, j +-- +ok +== +SELECT * FROM (SELECT 42 WHERE 42>84) t(i), range(i) t2(j) +-- +ok +== +SELECT * FROM (SELECT '5'::VARCHAR) t(str), range(str) t2(j) +-- +ok +== +PREPARE v1 AS SELECT * FROM range(?); +-- +ok +== +SELECT * FROM (SELECT 3, 1, -1 UNION ALL SELECT 1, 3, 2) t(s, e, increment), range(s, e, increment) t2(j) ORDER BY s, j +-- +ok +== +SELECT * FROM (SELECT DATE '2000-01-01', DATE '2000-10-1', INTERVAL '3' MONTHS) t(s, e, increment), range(s, e, increment) t2(j) ORDER BY s, j +-- +ok +== +SELECT * FROM (SELECT DATE '2000-01-01', DATE '2000-10-1', INTERVAL '3' MONTHS) t(s, e, increment), generate_series(s, e, increment) t2(j) ORDER BY s, j +-- +ok +== +SELECT * FROM (SELECT DATE '2000-01-01', DATE '2000-10-1', NULL) t(s, e, increment), generate_series(s, e, increment) t2(j) ORDER BY s, j +-- +ok +== +select count(*) from (values (1), (10), (100), (1000), (10000)) t(a), range(a); +-- +ok +== +SELECT * FROM (SELECT TIMESTAMPTZ '2000-01-01', TIMESTAMPTZ '2000-10-1', INTERVAL '3' MONTHS) t(s, e, increment), range(s, e, increment) t2(j) ORDER BY s, j +-- +ok +== +SELECT * FROM (SELECT TIMESTAMPTZ '2000-01-01', TIMESTAMPTZ '2000-10-1', NULL) t(s, e, increment), range(s, e, increment) t2(j) ORDER BY s, j +-- +ok +== +SELECT * FROM (SELECT TIMESTAMPTZ '2000-01-01', TIMESTAMPTZ '2000-10-1', NULL UNION ALL SELECT TIMESTAMPTZ '2000-10-01', TIMESTAMPTZ '2000-01-1', INTERVAL '-3 months') t(s, e, increment), range(s, e, increment) t2(j) ORDER BY s, j +-- +ok +== diff --git a/parser/testdata/corpus/sql/table_function/range_non_foldable.test b/parser/testdata/corpus/sql/table_function/range_non_foldable.test new file mode 100644 index 0000000..3796466 --- /dev/null +++ b/parser/testdata/corpus/sql/table_function/range_non_foldable.test @@ -0,0 +1,32 @@ +# source: test/sql/table_function/range_non_foldable.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +SELECT COUNT(*) +FROM range( + current_date, + current_date + interval '7' days, + interval '1 day' +) +-- +ok +== +SELECT to_timestamp(range) as entry + FROM range( + epoch(date_trunc('month', current_date))::BIGINT, + epoch(date_trunc('month', current_date) + interval '1 month' - interval '1 day')::BIGINT, + epoch(interval '1 day')::BIGINT + ) +-- +ok +== +SELECT to_timestamp(range) as entry +FROM range( + epoch(date_trunc('month', current_date))::BIGINT, + epoch(date_trunc('month', current_date) + interval '1 month' - interval '1 day')::BIGINT, + epoch(interval '1 day')::BIGINT +) +-- +ok +== diff --git a/parser/testdata/corpus/sql/table_function/range_timestamp.test b/parser/testdata/corpus/sql/table_function/range_timestamp.test new file mode 100644 index 0000000..cc657fb --- /dev/null +++ b/parser/testdata/corpus/sql/table_function/range_timestamp.test @@ -0,0 +1,94 @@ +# source: test/sql/table_function/range_timestamp.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +SELECT d::DATE FROM range(DATE '1992-01-01', DATE '1992-10-01', INTERVAL (1) MONTH) tbl(d) +-- +ok +== +SELECT * FROM range(date '1992-01-01', date '1992-01-01', interval '1' month); +-- +ok +== +SELECT d::DATE FROM generate_series(DATE '1992-01-01', DATE '1992-10-01', INTERVAL (1) MONTH) tbl(d) +-- +ok +== +SELECT d FROM range(TIMESTAMP '1992-01-01 00:00:00', TIMESTAMP '1992-01-01 12:00:00', INTERVAL (1) HOUR) tbl(d) +-- +ok +== +SELECT * FROM range(timestamp '1992-01-01 00:00:00', timestamp '1992-01-01 00:00:00', interval '1' month); +-- +ok +== +SELECT * FROM range(timestamp '1992-01-01 00:00:00', timestamp '1992-01-01 00:00:01', interval '1' month); +-- +ok +== +SELECT d FROM range(TIMESTAMP '1992-01-01 00:00:00', TIMESTAMP '1991-06-01 00:00:00', INTERVAL '1 MONTH ago') tbl(d) +-- +ok +== +SELECT d FROM generate_series(TIMESTAMP '1992-01-01 00:00:00', TIMESTAMP '1991-06-01 00:00:00', -INTERVAL '1 MONTH') tbl(d) +-- +ok +== +SELECT d FROM range(TIMESTAMP '1992-01-01 00:00:00', TIMESTAMP '1992-12-31 12:00:00', INTERVAL '1 MONTH 1 DAY 1 HOUR') tbl(d) +-- +ok +== +SELECT COUNT(*) FROM range(TIMESTAMP '1992-01-01 00:00:00', TIMESTAMP '2020-01-01 00:00:00', INTERVAL '1 DAY') tbl(d) +-- +ok +== +SELECT COUNT(*) FROM generate_series(TIMESTAMP '1992-01-01 00:00:00', TIMESTAMP '2020-01-01 00:00:00', INTERVAL '1 DAY') tbl(d) +-- +ok +== +SELECT COUNT(*) FROM range(NULL, TIMESTAMP '1992-12-31 12:00:00', INTERVAL '1 MONTH') tbl(d) +-- +ok +== +SELECT COUNT(*) FROM generate_series(NULL, TIMESTAMP '1992-12-31 12:00:00', INTERVAL '1 MONTH') tbl(d) +-- +ok +== +explain +from range('290309-12-22 (BC) 00:00:00'::TIMESTAMP, '294247-01-10 04:00:54.775806'::TIMESTAMP, interval '1 hour'); +-- +ok +== +SELECT d FROM range(TIMESTAMP '1992-01-01 00:00:00', TIMESTAMP '1992-12-31 12:00:00', INTERVAL '0 MONTH') tbl(d) +-- +ok +== +SELECT d FROM range(TIMESTAMP '1992-01-01 00:00:00', TIMESTAMP '1992-12-31 12:00:00', INTERVAL '1 MONTH ago') tbl(d) +-- +ok +== +SELECT d FROM range(TIMESTAMP '1993-01-01 00:00:00', TIMESTAMP '1992-01-01 00:00:00', INTERVAL '1 MONTH') tbl(d) +-- +ok +== +SELECT d FROM range(TIMESTAMP '1992-01-01 00:00:00', TIMESTAMP '1992-12-31 12:00:00', INTERVAL '1 MONTH' - INTERVAL '1 HOUR') tbl(d) +-- +ok +== +SELECT COUNT(*) FROM generate_series('294247-01-10'::TIMESTAMP, 'infinity'::TIMESTAMP, INTERVAL '1 DAY'); +-- +ok +== +SELECT COUNT(*) FROM range('294247-01-10'::TIMESTAMP, 'infinity'::TIMESTAMP, INTERVAL '1 DAY'); +-- +ok +== +SELECT COUNT(*) FROM generate_series('-infinity'::TIMESTAMP, '290309-12-22 (BC) 00:00:00'::TIMESTAMP, INTERVAL '1 DAY'); +-- +ok +== +SELECT COUNT(*) FROM range('-infinity'::TIMESTAMP, '290309-12-22 (BC) 00:00:00'::TIMESTAMP, INTERVAL '1 DAY'); +-- +ok +== diff --git a/parser/testdata/corpus/sql/table_function/range_timestamp_lateral_empty.test b/parser/testdata/corpus/sql/table_function/range_timestamp_lateral_empty.test new file mode 100644 index 0000000..3505661 --- /dev/null +++ b/parser/testdata/corpus/sql/table_function/range_timestamp_lateral_empty.test @@ -0,0 +1,65 @@ +# source: test/sql/table_function/range_timestamp_lateral_empty.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +CREATE TABLE t AS +SELECT i, TIMESTAMP '2024-01-01' + INTERVAL (i * 60) SECOND AS ts +FROM generate_series(0, 9) s(i); +-- +ok +== +SELECT COUNT(*) FROM t, LATERAL range(ts, ts + INTERVAL '5 minutes', INTERVAL '10 minutes'); +-- +ok +== +SELECT COUNT(*) FROM t, LATERAL range( + ts + (CASE WHEN i = 5 THEN INTERVAL '7 minutes' ELSE INTERVAL '0 minutes' END), + ts + INTERVAL '5 minutes', + INTERVAL '10 minutes'); +-- +ok +== +SELECT list(i ORDER BY i) FROM t, LATERAL range( + ts + (CASE WHEN i = 5 THEN INTERVAL '7 minutes' ELSE INTERVAL '0 minutes' END), + ts + INTERVAL '5 minutes', + INTERVAL '10 minutes'); +-- +ok +== +SELECT COUNT(*) FROM t, LATERAL range( + ts + (CASE WHEN i = 0 THEN INTERVAL '7 minutes' ELSE INTERVAL '0 minutes' END), + ts + INTERVAL '5 minutes', + INTERVAL '10 minutes'); +-- +ok +== +SELECT COUNT(*) FROM t, LATERAL range( + ts + (CASE WHEN i = 9 THEN INTERVAL '7 minutes' ELSE INTERVAL '0 minutes' END), + ts + INTERVAL '5 minutes', + INTERVAL '10 minutes'); +-- +ok +== +CREATE TABLE t2 AS +SELECT i, + TIMESTAMP '2024-01-01' + INTERVAL (i * 60) SECOND AS ts, + CASE WHEN i % 2 = 0 THEN 1 ELSE 7 END AS k +FROM generate_series(0, 64) s(i); +-- +ok +== +SELECT COUNT(*) FROM t2, LATERAL range(ts + to_minutes(k), ts + INTERVAL '5 minutes', INTERVAL '10 minutes'); +-- +ok +== +SELECT COUNT(*) FROM t2, LATERAL range(k::BIGINT, 5::BIGINT, 10::BIGINT); +-- +ok +== +SELECT COUNT(*) FROM t2, LATERAL ( + SELECT UNNEST(range(ts + to_minutes(k), ts + INTERVAL '5 minutes', INTERVAL '10 minutes')) AS r +) s; +-- +ok +== diff --git a/parser/testdata/corpus/sql/table_function/read_text_and_blob.test b/parser/testdata/corpus/sql/table_function/read_text_and_blob.test new file mode 100644 index 0000000..9464d12 --- /dev/null +++ b/parser/testdata/corpus/sql/table_function/read_text_and_blob.test @@ -0,0 +1,57 @@ +# source: test/sql/table_function/read_text_and_blob.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +SELECT COUNT(*) FROM read_text('test/sql/table_function/files/*.txt'); +-- +ok +== +SELECT COUNT(*) FROM read_blob('test/sql/table_function/files/*'); +-- +ok +== +SELECT * FROM read_text('test/sql/table_function/files/nonexistentfile.txt') ORDER BY ALL; +-- +ok +== +SELECT parse_path(filename) FROM read_text('test/sql/table_function/files/nonexistentfile.txt') ORDER BY ALL; +-- +ok +== +SELECT parse_path(filename) FROM read_text(['test/sql/table_function/files/one.txt', 'test/sql/table_function/files/two.txt']) ORDER BY ALL; +-- +ok +== +SELECT parse_path(filename), size, content FROM read_blob('test/sql/table_function/files/four.blob'); +-- +ok +== +SELECT parse_path(filename), size, content FROM read_text('test/sql/table_function/files/four.blob'); +-- +ok +== +SELECT size, parse_path(filename), content FROM read_text('test/sql/table_function/files/*.txt') ORDER BY filename, size; +-- +ok +== +SELECT last_modified > '2024-01-01' AND last_modified < '2500-01-01' FROM read_blob('test/sql/table_function/files/*'); +-- +ok +== +select parse_path(filename)[-6:], size, part, date from read_blob('{DATA_DIR}/parquet-testing/hive-partitioning/simple/*/*/test.parquet') order by filename +-- +ok +== +select parse_path(filename)[-6:], size, part, date from read_text('{DATA_DIR}/parquet-testing/hive-partitioning/simple/*/*/test.parquet') order by filename +-- +ok +== +select filename from read_blob('.*', union_by_name := true); +-- +ok +== +select filename from read_blob('s3://does-not-exist1144/date=2025-10-11/file.parquet'); +-- +ok +== diff --git a/parser/testdata/corpus/sql/table_function/register_external_resource.test b/parser/testdata/corpus/sql/table_function/register_external_resource.test new file mode 100644 index 0000000..e5a9f4a --- /dev/null +++ b/parser/testdata/corpus/sql/table_function/register_external_resource.test @@ -0,0 +1,70 @@ +# source: test/sql/table_function/register_external_resource.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +CALL register_external_resource('mock@local', 'r1', MAP {'id': 'abc'}, + uri := 'quack:localhost:9494', attached_db_type := 'quack', deleter_function := 'mock_destroy'); +-- +ok +== +SELECT name, type, managed, uri, attached_db_type, handle FROM duckdb_external_resources(); +-- +ok +== +CALL register_external_resource('mock@local', 'r2', MAP {'id': 'def'}); +-- +ok +== +SELECT name, uri, attached_db_type, handle FROM duckdb_external_resources() WHERE name = 'r2'; +-- +ok +== +CALL register_external_resource('mock@local', 'r1', MAP {'id': 'other'}); +-- +ok +== +CALL register_external_resource('mock@local', '', MAP {'id': 'x'}); +-- +ok +== +CALL register_external_resource('', 'r3', MAP {'id': 'x'}); +-- +ok +== +CALL register_external_resource(NULL, 'r3', MAP {'id': 'x'}); +-- +ok +== +CALL register_external_resource('mock@local', NULL, MAP {'id': 'x'}); +-- +ok +== +CALL register_external_resource('mock@local', 'r_txn', MAP {'id': 'txn'}); +-- +ok +== +SELECT count(*) FROM duckdb_external_resources() WHERE name = 'r_txn'; +-- +ok +== +CALL deregister_external_resource('r_txn'); +-- +ok +== +CALL deregister_external_resource('r1'); +-- +ok +== +CALL deregister_external_resource('nope'); +-- +ok +== +CALL deregister_external_resource('r2'); +-- +ok +== +CALL register_external_resource('mock@local', 'r1', MAP {'id': 'abc'}); +-- +ok +== diff --git a/parser/testdata/corpus/sql/table_function/sqlite_master.test b/parser/testdata/corpus/sql/table_function/sqlite_master.test new file mode 100644 index 0000000..2c289e0 --- /dev/null +++ b/parser/testdata/corpus/sql/table_function/sqlite_master.test @@ -0,0 +1,41 @@ +# source: test/sql/table_function/sqlite_master.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +SELECT * FROM sqlite_master; +-- +ok +== +SELECT EXISTS(SELECT * FROM sqlite_master) +-- +ok +== +SELECT EXISTS(SELECT * FROM sqlite_master OFFSET 1) +-- +ok +== +SELECT COUNT(*) FROM sqlite_master WHERE name='test' +-- +ok +== +SELECT COUNT(*) FROM sqlite_master WHERE name='integers' +-- +ok +== +SELECT * FROM sqlite_master WHERE name='tconstraint1'; +-- +ok +== +SELECT * FROM sqlite_master WHERE name='tconstraint2'; +-- +ok +== +SELECT * REPLACE (trim(sql, chr(10)) as sql) FROM sqlite_master WHERE name='i_index'; +-- +ok +== +SELECT "type", "name", "tbl_name", rootpage FROM sqlite_master WHERE name='v1'; +-- +ok +== diff --git a/parser/testdata/corpus/sql/table_function/sqlite_master_connections.test b/parser/testdata/corpus/sql/table_function/sqlite_master_connections.test new file mode 100644 index 0000000..a6b25f0 --- /dev/null +++ b/parser/testdata/corpus/sql/table_function/sqlite_master_connections.test @@ -0,0 +1,9 @@ +# source: test/sql/table_function/sqlite_master_connections.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +DROP VIEW sqlite_master +-- +ok +== diff --git a/parser/testdata/corpus/sql/table_function/sqlite_master_quotes.test b/parser/testdata/corpus/sql/table_function/sqlite_master_quotes.test new file mode 100644 index 0000000..06de817 --- /dev/null +++ b/parser/testdata/corpus/sql/table_function/sqlite_master_quotes.test @@ -0,0 +1,29 @@ +# source: test/sql/table_function/sqlite_master_quotes.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +CREATE TABLE "a b c"("d e" INTEGER, f INTEGER); +-- +ok +== +DROP TABLE "a b c"; +-- +ok +== +CREATE TABLE "inte""gers"(i INTEGER); +-- +ok +== +DROP TABLE "inte""gers" +-- +ok +== +CREATE TABLE integers("a b" INTEGER, "c d" INTEGER, PRIMARY KEY("a b", "c d")) +-- +ok +== +CREATE TABLE "1a"(a1 INTEGER, a2 INTEGER); +-- +ok +== diff --git a/parser/testdata/corpus/sql/table_function/test_information_schema_columns.test b/parser/testdata/corpus/sql/table_function/test_information_schema_columns.test new file mode 100644 index 0000000..4d3744a --- /dev/null +++ b/parser/testdata/corpus/sql/table_function/test_information_schema_columns.test @@ -0,0 +1,1050 @@ +# source: test/sql/table_function/test_information_schema_columns.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +CREATE TABLE wide ( + col0 varchar, + col1 int, + col2 time, + col3 time, + col4 bigint, + col5 bigint, + col6 varchar, + col7 time, + col8 varchar, + col9 int, + col10 bigint, + col11 time, + col12 time, + col13 varchar, + col14 time, + col15 varchar, + col16 varchar, + col17 int, + col18 time, + col19 int, + col20 bigint, + col21 time, + col22 int, + col23 bigint, + col24 varchar, + col25 varchar, + col26 bigint, + col27 time, + col28 bigint, + col29 time, + col30 varchar, + col31 int, + col32 int, + col33 varchar, + col34 bigint, + col35 varchar, + col36 bigint, + col37 varchar, + col38 int, + col39 time, + col40 time, + col41 time, + col42 bigint, + col43 varchar, + col44 bigint, + col45 int, + col46 time, + col47 int, + col48 int, + col49 varchar, + col50 varchar, + col51 int, + col52 time, + col53 varchar, + col54 varchar, + col55 varchar, + col56 bigint, + col57 time, + col58 bigint, + col59 time, + col60 time, + col61 varchar, + col62 varchar, + col63 time, + col64 varchar, + col65 varchar, + col66 bigint, + col67 int, + col68 bigint, + col69 varchar, + col70 int, + col71 varchar, + col72 bigint, + col73 bigint, + col74 varchar, + col75 time, + col76 varchar, + col77 int, + col78 time, + col79 varchar, + col80 bigint, + col81 int, + col82 bigint, + col83 bigint, + col84 bigint, + col85 time, + col86 bigint, + col87 time, + col88 time, + col89 int, + col90 bigint, + col91 bigint, + col92 int, + col93 int, + col94 time, + col95 varchar, + col96 varchar, + col97 varchar, + col98 varchar, + col99 int, + col100 varchar, + col101 int, + col102 time, + col103 varchar, + col104 bigint, + col105 varchar, + col106 int, + col107 varchar, + col108 time, + col109 time, + col110 bigint, + col111 int, + col112 time, + col113 int, + col114 time, + col115 int, + col116 int, + col117 time, + col118 varchar, + col119 bigint, + col120 time, + col121 int, + col122 int, + col123 varchar, + col124 varchar, + col125 bigint, + col126 varchar, + col127 varchar, + col128 bigint, + col129 time, + col130 time, + col131 int, + col132 varchar, + col133 varchar, + col134 bigint, + col135 int, + col136 int, + col137 bigint, + col138 time, + col139 time, + col140 varchar, + col141 varchar, + col142 time, + col143 varchar, + col144 bigint, + col145 bigint, + col146 time, + col147 varchar, + col148 bigint, + col149 bigint, + col150 time, + col151 varchar, + col152 varchar, + col153 time, + col154 time, + col155 varchar, + col156 time, + col157 varchar, + col158 bigint, + col159 time, + col160 time, + col161 varchar, + col162 int, + col163 time, + col164 bigint, + col165 time, + col166 int, + col167 int, + col168 int, + col169 bigint, + col170 int, + col171 varchar, + col172 varchar, + col173 int, + col174 time, + col175 int, + col176 bigint, + col177 time, + col178 int, + col179 int, + col180 int, + col181 bigint, + col182 varchar, + col183 int, + col184 time, + col185 time, + col186 bigint, + col187 bigint, + col188 varchar, + col189 varchar, + col190 bigint, + col191 int, + col192 int, + col193 int, + col194 int, + col195 varchar, + col196 varchar, + col197 time, + col198 varchar, + col199 bigint, + col200 varchar, + col201 time, + col202 varchar, + col203 bigint, + col204 bigint, + col205 int, + col206 varchar, + col207 bigint, + col208 bigint, + col209 time, + col210 varchar, + col211 int, + col212 varchar, + col213 int, + col214 bigint, + col215 int, + col216 int, + col217 bigint, + col218 int, + col219 int, + col220 int, + col221 int, + col222 varchar, + col223 varchar, + col224 bigint, + col225 bigint, + col226 int, + col227 varchar, + col228 int, + col229 varchar, + col230 bigint, + col231 varchar, + col232 time, + col233 bigint, + col234 bigint, + col235 time, + col236 int, + col237 time, + col238 int, + col239 bigint, + col240 bigint, + col241 int, + col242 time, + col243 int, + col244 time, + col245 bigint, + col246 time, + col247 varchar, + col248 varchar, + col249 int, + col250 bigint, + col251 varchar, + col252 varchar, + col253 bigint, + col254 varchar, + col255 varchar, + col256 varchar, + col257 bigint, + col258 time, + col259 time, + col260 varchar, + col261 int, + col262 varchar, + col263 int, + col264 bigint, + col265 varchar, + col266 int, + col267 varchar, + col268 varchar, + col269 time, + col270 bigint, + col271 bigint, + col272 bigint, + col273 varchar, + col274 varchar, + col275 time, + col276 time, + col277 int, + col278 bigint, + col279 int, + col280 bigint, + col281 int, + col282 varchar, + col283 varchar, + col284 varchar, + col285 time, + col286 bigint, + col287 bigint, + col288 int, + col289 varchar, + col290 bigint, + col291 varchar, + col292 time, + col293 varchar, + col294 time, + col295 time, + col296 bigint, + col297 int, + col298 bigint, + col299 int, + col300 time, + col301 time, + col302 varchar, + col303 int, + col304 bigint, + col305 bigint, + col306 int, + col307 bigint, + col308 bigint, + col309 bigint, + col310 bigint, + col311 varchar, + col312 time, + col313 bigint, + col314 time, + col315 int, + col316 varchar, + col317 bigint, + col318 time, + col319 int, + col320 int, + col321 bigint, + col322 int, + col323 time, + col324 time, + col325 int, + col326 time, + col327 bigint, + col328 int, + col329 bigint, + col330 int, + col331 int, + col332 int, + col333 varchar, + col334 bigint, + col335 time, + col336 int, + col337 bigint, + col338 time, + col339 bigint, + col340 time, + col341 bigint, + col342 varchar, + col343 bigint, + col344 time, + col345 bigint, + col346 time, + col347 bigint, + col348 int, + col349 varchar, + col350 varchar, + col351 int, + col352 varchar, + col353 bigint, + col354 int, + col355 varchar, + col356 int, + col357 int, + col358 varchar, + col359 varchar, + col360 time, + col361 bigint, + col362 varchar, + col363 bigint, + col364 varchar, + col365 time, + col366 varchar, + col367 varchar, + col368 varchar, + col369 varchar, + col370 bigint, + col371 bigint, + col372 time, + col373 time, + col374 varchar, + col375 bigint, + col376 varchar, + col377 int, + col378 bigint, + col379 varchar, + col380 int, + col381 int, + col382 varchar, + col383 varchar, + col384 time, + col385 time, + col386 varchar, + col387 varchar, + col388 varchar, + col389 bigint, + col390 varchar, + col391 int, + col392 varchar, + col393 bigint, + col394 time, + col395 time, + col396 int, + col397 bigint, + col398 varchar, + col399 time, + col400 varchar, + col401 varchar, + col402 time, + col403 bigint, + col404 varchar, + col405 time, + col406 time, + col407 varchar, + col408 time, + col409 time, + col410 varchar, + col411 time, + col412 bigint, + col413 varchar, + col414 time, + col415 bigint, + col416 time, + col417 varchar, + col418 varchar, + col419 int, + col420 bigint, + col421 bigint, + col422 time, + col423 varchar, + col424 time, + col425 int, + col426 time, + col427 time, + col428 varchar, + col429 bigint, + col430 time, + col431 varchar, + col432 varchar, + col433 int, + col434 int, + col435 varchar, + col436 time, + col437 time, + col438 time, + col439 int, + col440 varchar, + col441 int, + col442 bigint, + col443 int, + col444 bigint, + col445 bigint, + col446 time, + col447 varchar, + col448 int, + col449 time, + col450 varchar, + col451 int, + col452 varchar, + col453 int, + col454 varchar, + col455 varchar, + col456 bigint, + col457 time, + col458 bigint, + col459 int, + col460 bigint, + col461 int, + col462 varchar, + col463 time, + col464 varchar, + col465 int, + col466 bigint, + col467 varchar, + col468 int, + col469 bigint, + col470 time, + col471 int, + col472 varchar, + col473 bigint, + col474 bigint, + col475 bigint, + col476 varchar, + col477 time, + col478 bigint, + col479 time, + col480 int, + col481 int, + col482 bigint, + col483 int, + col484 varchar, + col485 int, + col486 int, + col487 bigint, + col488 bigint, + col489 varchar, + col490 int, + col491 int, + col492 bigint, + col493 varchar, + col494 time, + col495 int, + col496 bigint, + col497 varchar, + col498 varchar, + col499 varchar, + col500 time, + col501 int, + col502 varchar, + col503 int, + col504 time, + col505 bigint, + col506 bigint, + col507 int, + col508 bigint, + col509 bigint, + col510 bigint, + col511 time, + col512 varchar, + col513 time, + col514 int, + col515 time, + col516 time, + col517 bigint, + col518 int, + col519 time, + col520 varchar, + col521 int, + col522 int, + col523 int, + col524 bigint, + col525 time, + col526 time, + col527 varchar, + col528 time, + col529 time, + col530 varchar, + col531 int, + col532 bigint, + col533 bigint, + col534 int, + col535 bigint, + col536 varchar, + col537 int, + col538 time, + col539 varchar, + col540 bigint, + col541 time, + col542 bigint, + col543 int, + col544 time, + col545 int, + col546 bigint, + col547 bigint, + col548 int, + col549 int, + col550 time, + col551 int, + col552 time, + col553 bigint, + col554 int, + col555 time, + col556 bigint, + col557 time, + col558 bigint, + col559 time, + col560 varchar, + col561 bigint, + col562 int, + col563 int, + col564 bigint, + col565 time, + col566 bigint, + col567 int, + col568 bigint, + col569 bigint, + col570 int, + col571 int, + col572 bigint, + col573 time, + col574 varchar, + col575 int, + col576 int, + col577 time, + col578 time, + col579 time, + col580 varchar, + col581 bigint, + col582 varchar, + col583 time, + col584 varchar, + col585 time, + col586 bigint, + col587 int, + col588 time, + col589 int, + col590 bigint, + col591 time, + col592 varchar, + col593 time, + col594 bigint, + col595 time, + col596 time, + col597 varchar, + col598 time, + col599 bigint, + col600 int, + col601 bigint, + col602 int, + col603 bigint, + col604 int, + col605 varchar, + col606 varchar, + col607 int, + col608 bigint, + col609 bigint, + col610 time, + col611 bigint, + col612 time, + col613 time, + col614 int, + col615 varchar, + col616 bigint, + col617 time, + col618 time, + col619 time, + col620 time, + col621 varchar, + col622 bigint, + col623 bigint, + col624 varchar, + col625 int, + col626 varchar, + col627 varchar, + col628 time, + col629 time, + col630 bigint, + col631 bigint, + col632 int, + col633 int, + col634 varchar, + col635 int, + col636 bigint, + col637 bigint, + col638 int, + col639 time, + col640 time, + col641 bigint, + col642 varchar, + col643 int, + col644 time, + col645 varchar, + col646 time, + col647 int, + col648 int, + col649 varchar, + col650 time, + col651 bigint, + col652 bigint, + col653 int, + col654 time, + col655 int, + col656 int, + col657 int, + col658 bigint, + col659 bigint, + col660 time, + col661 bigint, + col662 int, + col663 bigint, + col664 bigint, + col665 varchar, + col666 varchar, + col667 varchar, + col668 time, + col669 time, + col670 varchar, + col671 bigint, + col672 int, + col673 int, + col674 bigint, + col675 bigint, + col676 bigint, + col677 int, + col678 varchar, + col679 varchar, + col680 varchar, + col681 bigint, + col682 varchar, + col683 bigint, + col684 int, + col685 time, + col686 int, + col687 time, + col688 varchar, + col689 time, + col690 varchar, + col691 varchar, + col692 varchar, + col693 bigint, + col694 varchar, + col695 varchar, + col696 time, + col697 time, + col698 bigint, + col699 varchar, + col700 bigint, + col701 int, + col702 int, + col703 time, + col704 bigint, + col705 time, + col706 bigint, + col707 int, + col708 bigint, + col709 int, + col710 varchar, + col711 time, + col712 varchar, + col713 bigint, + col714 int, + col715 time, + col716 bigint, + col717 time, + col718 bigint, + col719 varchar, + col720 bigint, + col721 time, + col722 bigint, + col723 int, + col724 varchar, + col725 time, + col726 time, + col727 int, + col728 bigint, + col729 int, + col730 int, + col731 time, + col732 int, + col733 int, + col734 bigint, + col735 varchar, + col736 varchar, + col737 varchar, + col738 time, + col739 bigint, + col740 varchar, + col741 int, + col742 int, + col743 bigint, + col744 time, + col745 bigint, + col746 bigint, + col747 time, + col748 time, + col749 time, + col750 varchar, + col751 int, + col752 time, + col753 int, + col754 time, + col755 int, + col756 int, + col757 bigint, + col758 int, + col759 time, + col760 time, + col761 time, + col762 int, + col763 bigint, + col764 int, + col765 bigint, + col766 time, + col767 int, + col768 time, + col769 time, + col770 int, + col771 varchar, + col772 int, + col773 bigint, + col774 varchar, + col775 time, + col776 time, + col777 bigint, + col778 varchar, + col779 int, + col780 int, + col781 int, + col782 bigint, + col783 int, + col784 time, + col785 time, + col786 varchar, + col787 int, + col788 time, + col789 int, + col790 varchar, + col791 varchar, + col792 time, + col793 bigint, + col794 int, + col795 int, + col796 varchar, + col797 time, + col798 time, + col799 bigint, + col800 time, + col801 time, + col802 bigint, + col803 time, + col804 bigint, + col805 bigint, + col806 varchar, + col807 time, + col808 int, + col809 int, + col810 bigint, + col811 varchar, + col812 int, + col813 time, + col814 time, + col815 int, + col816 time, + col817 varchar, + col818 int, + col819 int, + col820 int, + col821 int, + col822 varchar, + col823 int, + col824 bigint, + col825 int, + col826 int, + col827 bigint, + col828 bigint, + col829 varchar, + col830 int, + col831 varchar, + col832 int, + col833 varchar, + col834 bigint, + col835 bigint, + col836 time, + col837 time, + col838 varchar, + col839 int, + col840 varchar, + col841 int, + col842 bigint, + col843 time, + col844 varchar, + col845 varchar, + col846 int, + col847 int, + col848 varchar, + col849 time, + col850 int, + col851 int, + col852 time, + col853 time, + col854 bigint, + col855 time, + col856 time, + col857 time, + col858 time, + col859 varchar, + col860 time, + col861 time, + col862 int, + col863 int, + col864 varchar, + col865 bigint, + col866 bigint, + col867 time, + col868 time, + col869 varchar, + col870 time, + col871 time, + col872 bigint, + col873 time, + col874 bigint, + col875 bigint, + col876 varchar, + col877 bigint, + col878 varchar, + col879 time, + col880 varchar, + col881 bigint, + col882 int, + col883 varchar, + col884 time, + col885 time, + col886 time, + col887 varchar, + col888 time, + col889 time, + col890 varchar, + col891 varchar, + col892 varchar, + col893 time, + col894 bigint, + col895 varchar, + col896 int, + col897 bigint, + col898 time, + col899 time, + col900 time, + col901 varchar, + col902 varchar, + col903 int, + col904 varchar, + col905 time, + col906 bigint, + col907 time, + col908 varchar, + col909 time, + col910 bigint, + col911 varchar, + col912 time, + col913 int, + col914 bigint, + col915 varchar, + col916 varchar, + col917 bigint, + col918 varchar, + col919 time, + col920 int, + col921 bigint, + col922 time, + col923 bigint, + col924 time, + col925 varchar, + col926 varchar, + col927 varchar, + col928 varchar, + col929 bigint, + col930 varchar, + col931 int, + col932 bigint, + col933 int, + col934 bigint, + col935 bigint, + col936 int, + col937 bigint, + col938 varchar, + col939 time, + col940 int, + col941 time, + col942 int, + col943 varchar, + col944 bigint, + col945 time, + col946 bigint, + col947 varchar, + col948 time, + col949 time, + col950 time, + col951 int, + col952 varchar, + col953 bigint, + col954 time, + col955 varchar, + col956 int, + col957 bigint, + col958 bigint, + col959 bigint, + col960 bigint, + col961 int, + col962 time, + col963 varchar, + col964 bigint, + col965 varchar, + col966 bigint, + col967 time, + col968 varchar, + col969 time, + col970 time, + col971 time, + col972 int, + col973 int, + col974 bigint, + col975 bigint, + col976 bigint, + col977 time, + col978 bigint, + col979 varchar, + col980 varchar, + col981 bigint, + col982 int, + col983 bigint, + col984 time, + col985 bigint, + col986 int, + col987 bigint, + col988 int, + col989 bigint, + col990 bigint, + col991 time, + col992 bigint, + col993 bigint, + col994 bigint, + col995 int, + col996 int, + col997 int, + col998 int, + col999 varchar, + col1000 time, + col1001 bigint, + col1002 bigint, + col1003 bigint, + col1004 time, + col1005 varchar, + col1006 varchar, + col1007 varchar, + col1008 int, + col1009 bigint, + col1010 bigint, + col1011 time, + col1012 bigint, + col1013 time, + col1014 int, + col1015 varchar, + col1016 time, + col1017 time, + col1018 int, + col1019 varchar, + col1020 varchar, + col1021 int, + col1022 bigint, + col1023 time, + col1024 bigint); +-- +ok +== +SELECT COUNT(1) FROM information_schema.columns WHERE table_name='wide' +-- +ok +== +SELECT COUNT(1) FROM information_schema.columns WHERE table_name='wide' AND column_name='col1024' AND data_type='BIGINT' +-- +ok +== +CREATE VIEW vwide AS SELECT * FROM wide; +-- +ok +== +SELECT COUNT(1) FROM information_schema.columns WHERE table_name='wide' OR table_name='vwide' +-- +ok +== diff --git a/parser/testdata/corpus/sql/table_function/test_range_function.test b/parser/testdata/corpus/sql/table_function/test_range_function.test new file mode 100644 index 0000000..443abdf --- /dev/null +++ b/parser/testdata/corpus/sql/table_function/test_range_function.test @@ -0,0 +1,109 @@ +# source: test/sql/table_function/test_range_function.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +SELECT * FROM range(0, 10, 1) +-- +ok +== +CALL range(10) +-- +ok +== +SELECT * FROM generate_series(0, 10, 1) +-- +ok +== +SELECT * FROM range(10, 0, -1) ORDER BY 1 ASC +-- +ok +== +SELECT * FROM generate_series(10, 0, -1) ORDER BY 1 ASC +-- +ok +== +SELECT * FROM range(0, -5, -1) +-- +ok +== +SELECT * FROM range(0, 10, 0) +-- +ok +== +SELECT * FROM range(0, 10, -1) +-- +ok +== +SELECT * FROM range(10, 0, 1) +-- +ok +== +SELECT * FROM range(10) +-- +ok +== +SELECT * FROM range(0, 10) +-- +ok +== +SELECT EXISTS(SELECT * FROM range(10)) +-- +ok +== +SELECT EXISTS(SELECT * FROM range(0)) +-- +ok +== +SELECT * FROM range(10) t1(j) WHERE j=3 +-- +ok +== +SELECT * FROM range('hello') +-- +ok +== +SELECT * FROM range(10, 'hello') +-- +ok +== +SELECT * FROM range(10, 10, 'hello') +-- +ok +== +select * from generate_series(-2305843009213693951, 2305843009213693951, 2305843009213693951) +-- +ok +== +select * from generate_series(2305843009213693951, -2305843009213693951, -2305843009213693951) +-- +ok +== +select * from generate_series(0, 10, 9223372036854775807); +-- +ok +== +select * from generate_series(0, 9223372036854775807, 9223372036854775807); +-- +ok +== +select * from generate_series(0, -9223372036854775807, -9223372036854775807); +-- +ok +== +select * from generate_series(-9223372036854775808, 9223372036854775807, 9223372036854775807); +-- +ok +== +select * from generate_series(-9223372036854775807, -9223372036854775808, -1); +-- +ok +== +select * from generate_series(0, -9223372036854775808, -9223372036854775808); +-- +ok +== +select * FROM generate_series(1, 3, 1) AS _(x), generate_series(x, 2, 1) AS __(y); +-- +ok +== diff --git a/parser/testdata/corpus/sql/table_function/test_repeat_function.test b/parser/testdata/corpus/sql/table_function/test_repeat_function.test new file mode 100644 index 0000000..7af3994 --- /dev/null +++ b/parser/testdata/corpus/sql/table_function/test_repeat_function.test @@ -0,0 +1,41 @@ +# source: test/sql/table_function/test_repeat_function.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +SELECT * FROM repeat(0, 3) +-- +ok +== +SELECT * FROM repeat(NULL, 2) +-- +ok +== +SELECT * FROM repeat('hello', 2) +-- +ok +== +SELECT * FROM repeat('thisisalongstring', 2) +-- +ok +== +SELECT * FROM repeat(blob '\x00\x00hello', 2) +-- +ok +== +SELECT * FROM repeat(1, 10000) +-- +ok +== +SELECT * FROM repeat(DATE '1992-01-01', 2) +-- +ok +== +SELECT * FROM repeat(INTERVAL '30 days', 2) +-- +ok +== +SELECT * FROM repeat(INTERVAL '30 days', NULL) +-- +ok +== diff --git a/parser/testdata/corpus/sql/table_function/test_table_function.test b/parser/testdata/corpus/sql/table_function/test_table_function.test new file mode 100644 index 0000000..b2f91e0 --- /dev/null +++ b/parser/testdata/corpus/sql/table_function/test_table_function.test @@ -0,0 +1,33 @@ +# source: test/sql/table_function/test_table_function.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +SELECT * FROM pragma_table_info('integers'); +-- +ok +== +SELECT name FROM pragma_table_info('integers'); +-- +ok +== +SELECT blablabla FROM pragma_table_info('integers'); +-- +ok +== +CREATE TABLE join_table(name VARCHAR, value INTEGER); +-- +ok +== +INSERT INTO join_table VALUES ('i', 33), ('j', 44) +-- +ok +== +SELECT a.name, cid, value FROM pragma_table_info('integers') AS a INNER JOIN join_table ON a.name=join_table.name ORDER BY a.name; +-- +ok +== +SELECT cid, name FROM (SELECT * FROM pragma_table_info('integers')) AS a +-- +ok +== diff --git a/parser/testdata/corpus/sql/table_function/warn_deprecated_identifier_conversion.test b/parser/testdata/corpus/sql/table_function/warn_deprecated_identifier_conversion.test new file mode 100644 index 0000000..353489d --- /dev/null +++ b/parser/testdata/corpus/sql/table_function/warn_deprecated_identifier_conversion.test @@ -0,0 +1,25 @@ +# source: test/sql/table_function/warn_deprecated_identifier_conversion.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +SELECT count(*) FROM glob(no_such_file.csv); +-- +ok +== +SELECT count(*) FROM glob('no_such_file.csv'); +-- +ok +== +SET table_function_identifier_conversion='ENABLE_IMPLICIT_STRING'; +-- +ok +== +SET table_function_identifier_conversion='DISABLE_IMPLICIT_STRING'; +-- +ok +== +RESET table_function_identifier_conversion; +-- +ok +== diff --git a/parser/testdata/corpus/sql/timezone/disable_timestamptz_casts.test b/parser/testdata/corpus/sql/timezone/disable_timestamptz_casts.test new file mode 100644 index 0000000..02c9f69 --- /dev/null +++ b/parser/testdata/corpus/sql/timezone/disable_timestamptz_casts.test @@ -0,0 +1,33 @@ +# source: test/sql/timezone/disable_timestamptz_casts.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +set disable_timestamptz_casts=false; +-- +ok +== +select cast('2020-01-01T00:00:00'::timestamp as timestamptz) +-- +ok +== +select cast('2020-01-01T15:00:00+0000'::timestamptz as timestamp) +-- +ok +== +set disable_timestamptz_casts=true; +-- +ok +== +set calendar='gregorian'; +-- +ok +== +set TimeZone='America/Los_Angeles'; +-- +ok +== +select cast('2020-01-01T13:00:00+00'::timestamptz as date) +-- +ok +== diff --git a/parser/testdata/corpus/sql/timezone/icu_calendar_operations.test b/parser/testdata/corpus/sql/timezone/icu_calendar_operations.test new file mode 100644 index 0000000..a917ea4 --- /dev/null +++ b/parser/testdata/corpus/sql/timezone/icu_calendar_operations.test @@ -0,0 +1,28 @@ +# source: test/sql/timezone/icu_calendar_operations.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +SET Calendar = '{cal}'; +-- +ok +== +select age('2020-01-01'::timestamptz); +-- +ok +== +select '2020-01-01'::timestamptz + interval '380 days' +-- +ok +== +select '2021-01-01'::timestamptz - interval '380 days' +-- +ok +== +select + '2020-01-01'::timestamptz as start_date, + '2021-01-01'::timestamptz as end_date, + age(end_date, start_date) as delta; +-- +ok +== diff --git a/parser/testdata/corpus/sql/timezone/test_icu_calendar.test b/parser/testdata/corpus/sql/timezone/test_icu_calendar.test new file mode 100644 index 0000000..b1a370a --- /dev/null +++ b/parser/testdata/corpus/sql/timezone/test_icu_calendar.test @@ -0,0 +1,62 @@ +# source: test/sql/timezone/test_icu_calendar.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +SELECT name FROM icu_calendar_names() +GROUP BY 1 +ORDER BY 1; +-- +ok +== +SET Calendar = 'fnord'; +-- +ok +== +CREATE TABLE timestamps AS SELECT ts::TIMESTAMPTZ AS ts, era FROM (VALUES + ('0645-06-30 00:00:00+00', 'Taika'), + ('1867-01-01 00:00:00+00', 'Keiou'), + ('1868-09-07 00:00:00+00', 'Keiou'), + ('1868-09-08 00:00:00+00', 'Meiji'), + ('1912-07-29 00:00:00+00', 'Meiji'), + ('1912-07-30 00:00:00+00', 'Taisho'), + ('1926-12-24 00:00:00+00', 'Taisho'), + ('1926-12-25 00:00:00+00', 'Showa'), + ('1989-01-06 00:00:00+00', 'Showa'), + ('1989-01-08 00:00:00+00', 'Heisei'), + ('2019-05-01 00:00:00+00', 'Reiwa'), + ('2022-01-01 00:00:00+00', 'Reiwa') +) tbl(ts, era); +-- +ok +== +SELECT era, ts, DATE_PART(['era', 'year', 'month', 'day'], ts) +FROM timestamps +ORDER BY 2 +-- +ok +== +SET CALENDAR='islamic-umalqura'; +-- +ok +== +SELECT strftime(TIMESTAMPTZ '-260722-3-4 0:3:52',TIMESTAMP '-285441-5-3 8:3:4'::VARCHAR); +-- +ok +== +SET CALENDAR='indian'; +-- +ok +== +SELECT TIMESTAMPTZ '-276069-9-30 0:0:00 America/Whitehorse'; +-- +ok +== +PRAGMA CALENDAR='japanese'; +-- +ok +== +SELECT strftime(TIMESTAMPTZ '-23831-1-15 2:5:17 America/La_Paz',TIMETZ '0:8:29 America/Cayman'::VARCHAR); +-- +ok +== diff --git a/parser/testdata/corpus/sql/timezone/test_icu_calendar_chinese.test b/parser/testdata/corpus/sql/timezone/test_icu_calendar_chinese.test new file mode 100644 index 0000000..7fb47ba --- /dev/null +++ b/parser/testdata/corpus/sql/timezone/test_icu_calendar_chinese.test @@ -0,0 +1,101 @@ +# source: test/sql/timezone/test_icu_calendar_chinese.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +SET Calendar='chinese' +-- +ok +== +SELECT ts, era(ts), year(ts), month(ts), day(ts), dayofyear(ts) FROM (VALUES + ('2024-06-15 12:00:00+00'::TIMESTAMPTZ), ('2024-02-09 12:00:00+00'), ('2024-02-10 12:00:00+00'), + ('2023-01-21 12:00:00+00'), ('2023-01-22 12:00:00+00'), ('2023-03-21 12:00:00+00'), + ('2023-03-22 12:00:00+00'), ('1970-01-01 00:00:00+00'), ('1900-01-01 12:00:00+00'), + ('2033-11-01 12:00:00+00'), ('2033-12-01 12:00:00+00'), ('2034-01-01 12:00:00+00'), + ('1582-10-04 12:00:00+00'), ('1582-10-15 12:00:00+00'), ('0001-01-01 12:00:00+00')) t(ts) +-- +ok +== +SELECT make_timestamptz(78, 41, 5, 12, 0, 0.0, 'UTC') +-- +ok +== +SELECT make_timestamptz(78, 1, 1, 0, 0, 0.0, 'UTC') +-- +ok +== +SELECT make_timestamptz(1, 1, 1, 0, 0, 0.0, 'UTC') +-- +ok +== +SELECT date_trunc('year', '2024-06-15 12:00:00+00'::TIMESTAMPTZ) +-- +ok +== +SELECT date_trunc('month', '2024-06-15 12:00:00+00'::TIMESTAMPTZ) +-- +ok +== +SELECT date_trunc('day', '2024-06-15 12:00:00+00'::TIMESTAMPTZ) +-- +ok +== +SELECT date_trunc('week', '2024-06-15 12:00:00+00'::TIMESTAMPTZ) +-- +ok +== +SELECT last_day('2024-06-15 12:00:00+00'::TIMESTAMPTZ) +-- +ok +== +SELECT last_day('2024-02-15 12:00:00+00'::TIMESTAMPTZ) +-- +ok +== +SELECT date_diff('year', '1900-06-15 12:00:00+00'::TIMESTAMPTZ, '2024-06-15 12:00:00+00'::TIMESTAMPTZ) +-- +ok +== +SELECT date_diff('month', '2023-06-15 12:00:00+00'::TIMESTAMPTZ, '2024-06-15 12:00:00+00'::TIMESTAMPTZ) +-- +ok +== +SELECT date_diff('day', '2023-06-15 12:00:00+00'::TIMESTAMPTZ, '2024-06-15 12:00:00+00'::TIMESTAMPTZ) +-- +ok +== +SELECT age('2024-06-15 12:00:00+00'::TIMESTAMPTZ, '1900-06-15 12:00:00+00'::TIMESTAMPTZ) +-- +ok +== +SELECT date_part(['year','month','day','era','dayofyear','week','isoyear'], '2024-06-15 12:00:00+00'::TIMESTAMPTZ) +-- +ok +== +SELECT count(*), sum(hash(ts::VARCHAR)) FROM generate_series('1900-01-01 12:00:00+00'::TIMESTAMPTZ, '2100-01-01 12:00:00+00'::TIMESTAMPTZ, INTERVAL 5 DAY) t(ts) +-- +ok +== +SELECT y, count(distinct m) FROM (SELECT year(ts) y, month(ts) m FROM generate_series('2020-01-01 12:00:00+00'::TIMESTAMPTZ, '2030-01-01 12:00:00+00'::TIMESTAMPTZ, INTERVAL 1 DAY) t(ts)) GROUP BY ALL ORDER BY ALL +-- +ok +== +SET Calendar='dangi' +-- +ok +== +SELECT ts, era(ts), year(ts), month(ts), day(ts), dayofyear(ts) FROM (VALUES + ('2024-06-15 12:00:00+00'::TIMESTAMPTZ), ('1970-01-01 00:00:00+00'), ('1900-01-01 12:00:00+00'), + ('1896-06-15 12:00:00+00'), ('1897-06-15 12:00:00+00'), ('1898-06-15 12:00:00+00'), + ('1911-06-15 12:00:00+00'), ('1912-06-15 12:00:00+00'), ('0001-01-01 12:00:00+00')) t(ts) +-- +ok +== +SELECT count(*), sum(hash(ts::VARCHAR)) FROM generate_series('1880-01-01 12:00:00+00'::TIMESTAMPTZ, '1930-01-01 12:00:00+00'::TIMESTAMPTZ, INTERVAL 3 DAY) t(ts) +-- +ok +== +SELECT count(*), sum(hash(ts::VARCHAR)) FROM generate_series('1950-01-01 12:00:00+00'::TIMESTAMPTZ, '2050-01-01 12:00:00+00'::TIMESTAMPTZ, INTERVAL 5 DAY) t(ts) +-- +ok +== diff --git a/parser/testdata/corpus/sql/timezone/test_icu_calendar_coptic.test b/parser/testdata/corpus/sql/timezone/test_icu_calendar_coptic.test new file mode 100644 index 0000000..d8f23d6 --- /dev/null +++ b/parser/testdata/corpus/sql/timezone/test_icu_calendar_coptic.test @@ -0,0 +1,97 @@ +# source: test/sql/timezone/test_icu_calendar_coptic.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +SET Calendar='coptic' +-- +ok +== +SELECT ts, year(ts), month(ts), day(ts), era(ts), dayofyear(ts) FROM (VALUES + ('2024-06-15 12:00:00+00'::TIMESTAMPTZ), ('0284-08-29 12:00:00+00'), ('0283-08-29 12:00:00+00'), + ('1970-01-01 00:00:00+00'), ('2024-09-10 12:00:00+00'), ('2024-09-11 12:00:00+00'), + ('2023-09-11 12:00:00+00'), ('2027-09-11 12:00:00+00'), ('0001-01-01 12:00:00+00')) t(ts) +-- +ok +== +SELECT make_timestamptz(1740, 13, 5, 12, 0, 0.0, 'UTC') +-- +ok +== +SELECT make_timestamptz(1739, 13, 6, 12, 0, 0.0, 'UTC') +-- +ok +== +SELECT make_timestamptz(1740, 13, 6, 12, 0, 0.0, 'UTC') +-- +ok +== +SELECT make_timestamptz(1740, 1, 1, 0, 0, 0.0, 'UTC') +-- +ok +== +SELECT '2024-06-15 12:00:00+00'::TIMESTAMPTZ + INTERVAL 1 MONTH +-- +ok +== +SELECT '2024-06-15 12:00:00+00'::TIMESTAMPTZ + INTERVAL 13 MONTH +-- +ok +== +SELECT '2024-06-15 12:00:00+00'::TIMESTAMPTZ + INTERVAL 1 YEAR +-- +ok +== +SELECT date_trunc('quarter', '2024-06-15 12:00:00+00'::TIMESTAMPTZ) +-- +ok +== +SELECT date_trunc('decade', '2024-06-15 12:00:00+00'::TIMESTAMPTZ) +-- +ok +== +SELECT last_day('2024-09-05 12:00:00+00'::TIMESTAMPTZ) +-- +ok +== +SELECT * FROM generate_series('2024-09-05 12:00:00+00'::TIMESTAMPTZ, '2024-09-15 12:00:00+00'::TIMESTAMPTZ, INTERVAL 2 DAY) +-- +ok +== +SET Calendar='ethiopic' +-- +ok +== +SELECT ts, year(ts), month(ts), day(ts), era(ts), dayofyear(ts) FROM (VALUES + ('2024-06-15 12:00:00+00'::TIMESTAMPTZ), ('0008-08-29 12:00:00+00'), ('0007-08-29 12:00:00+00'), + ('1970-01-01 00:00:00+00'), ('2024-09-10 12:00:00+00'), ('2024-09-11 12:00:00+00'), + ('0001-01-01 12:00:00+00'), ('5500-01-01 (BC) 12:00:00+00')) t(ts) +-- +ok +== +SELECT make_timestamptz(2016, 13, 5, 12, 0, 0.0, 'UTC') +-- +ok +== +SELECT make_timestamptz(2016, 1, 1, 0, 0, 0.0, 'UTC') +-- +ok +== +SET Calendar='ethiopic-amete-alem' +-- +ok +== +SELECT ts, year(ts), month(ts), day(ts), era(ts), dayofyear(ts) FROM (VALUES + ('2024-06-15 12:00:00+00'::TIMESTAMPTZ), ('0008-08-29 12:00:00+00'), ('0007-08-29 12:00:00+00'), + ('1970-01-01 00:00:00+00'), ('0001-01-01 12:00:00+00'), ('5500-01-01 (BC) 12:00:00+00')) t(ts) +-- +ok +== +SELECT make_timestamptz(7516, 13, 5, 12, 0, 0.0, 'UTC') +-- +ok +== +SELECT make_timestamptz(7516, 1, 1, 0, 0, 0.0, 'UTC') +-- +ok +== diff --git a/parser/testdata/corpus/sql/timezone/test_icu_calendar_hebrew.test b/parser/testdata/corpus/sql/timezone/test_icu_calendar_hebrew.test new file mode 100644 index 0000000..e20f01f --- /dev/null +++ b/parser/testdata/corpus/sql/timezone/test_icu_calendar_hebrew.test @@ -0,0 +1,65 @@ +# source: test/sql/timezone/test_icu_calendar_hebrew.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +SET Calendar='hebrew' +-- +ok +== +SELECT ts, year(ts), month(ts), day(ts), era(ts), dayofyear(ts), monthname(ts) FROM (VALUES + ('2024-06-15 12:00:00+00'::TIMESTAMPTZ), ('1970-01-01 00:00:00+00'), ('2024-10-02 12:00:00+00'), + ('2024-10-03 12:00:00+00'), ('2023-09-15 12:00:00+00'), ('2023-09-16 12:00:00+00'), + ('2022-03-01 12:00:00+00'), ('2024-03-01 12:00:00+00'), ('0001-01-01 12:00:00+00'), + ('1000-01-01 12:00:00+00'), ('2100-01-01 12:00:00+00'), ('1900-01-01 12:00:00+00')) t(ts) +-- +ok +== +SELECT y, count(*) FROM (SELECT year(ts) y FROM generate_series('2015-01-01 12:00:00+00'::TIMESTAMPTZ, '2035-01-01 12:00:00+00'::TIMESTAMPTZ, INTERVAL 1 DAY) t(ts) GROUP BY ALL) GROUP BY ALL ORDER BY ALL +-- +ok +== +SELECT y, max(m) FROM (SELECT year(ts) y, month(ts) m FROM generate_series('2015-01-01 12:00:00+00'::TIMESTAMPTZ, '2035-01-01 12:00:00+00'::TIMESTAMPTZ, INTERVAL 1 DAY) t(ts)) GROUP BY ALL ORDER BY ALL +-- +ok +== +SELECT make_timestamptz(5784, 1, 1, 0, 0, 0.0, 'UTC') +-- +ok +== +SELECT make_timestamptz(5784, 6, 1, 0, 0, 0.0, 'UTC') +-- +ok +== +SELECT make_timestamptz(5784, 7, 1, 0, 0, 0.0, 'UTC') +-- +ok +== +SELECT make_timestamptz(5784, 13, 29, 0, 0, 0.0, 'UTC') +-- +ok +== +SELECT make_timestamptz(5783, 6, 1, 0, 0, 0.0, 'UTC') +-- +ok +== +SELECT make_timestamptz(5783, 13, 29, 0, 0, 0.0, 'UTC') +-- +ok +== +SELECT last_day('2023-11-15 12:00:00+00'::TIMESTAMPTZ) +-- +ok +== +SELECT date_diff('month', '2022-06-15 12:00:00+00'::TIMESTAMPTZ, '2024-06-15 12:00:00+00'::TIMESTAMPTZ) +-- +ok +== +SELECT age('2024-03-01 12:00:00+00'::TIMESTAMPTZ, '2022-03-01 12:00:00+00'::TIMESTAMPTZ) +-- +ok +== +SELECT count(*), sum(hash(ts::VARCHAR)) FROM generate_series('1900-01-01 12:00:00+00'::TIMESTAMPTZ, '2200-01-01 12:00:00+00'::TIMESTAMPTZ, INTERVAL 7 DAY) t(ts) +-- +ok +== diff --git a/parser/testdata/corpus/sql/timezone/test_icu_calendar_islamic.test b/parser/testdata/corpus/sql/timezone/test_icu_calendar_islamic.test new file mode 100644 index 0000000..dc0870d --- /dev/null +++ b/parser/testdata/corpus/sql/timezone/test_icu_calendar_islamic.test @@ -0,0 +1,86 @@ +# source: test/sql/timezone/test_icu_calendar_islamic.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +SET Calendar='islamic-civil' +-- +ok +== +SELECT ts, year(ts), month(ts), day(ts), era(ts), dayofyear(ts) FROM (VALUES + ('2024-06-15 12:00:00+00'::TIMESTAMPTZ), ('0622-07-19 12:00:00+00'), ('0622-07-18 12:00:00+00'), + ('1970-01-01 00:00:00+00'), ('2024-07-07 12:00:00+00'), ('2024-07-08 12:00:00+00'), + ('1882-11-12 12:00:00+00'), ('2100-01-01 12:00:00+00'), ('1000-01-01 12:00:00+00')) t(ts) +-- +ok +== +SELECT make_timestamptz(1445, 1, 1, 0, 0, 0.0, 'UTC') +-- +ok +== +SELECT make_timestamptz(1445, 12, 29, 0, 0, 0.0, 'UTC') +-- +ok +== +SELECT make_timestamptz(1445, 12, 30, 0, 0, 0.0, 'UTC') +-- +ok +== +SELECT make_timestamptz(1444, 12, 30, 0, 0, 0.0, 'UTC') +-- +ok +== +SELECT last_day('2024-07-20 12:00:00+00'::TIMESTAMPTZ) +-- +ok +== +SELECT * FROM generate_series('2024-07-01 12:00:00+00'::TIMESTAMPTZ, '2024-07-12 12:00:00+00'::TIMESTAMPTZ, INTERVAL 3 DAY) +-- +ok +== +SET Calendar='islamic-tbla' +-- +ok +== +SELECT ts, year(ts), month(ts), day(ts), era(ts), dayofyear(ts) FROM (VALUES + ('2024-06-15 12:00:00+00'::TIMESTAMPTZ), ('0622-07-19 12:00:00+00'), ('0622-07-18 12:00:00+00'), + ('1970-01-01 00:00:00+00'), ('2024-07-07 12:00:00+00'), ('1000-01-01 12:00:00+00')) t(ts) +-- +ok +== +SET Calendar='islamic-umalqura' +-- +ok +== +SELECT ts, year(ts), month(ts), day(ts), era(ts), dayofyear(ts) FROM (VALUES + ('2024-06-15 12:00:00+00'::TIMESTAMPTZ), ('1882-11-12 12:00:00+00'), ('1882-11-11 12:00:00+00'), + ('1970-01-01 00:00:00+00'), ('2024-07-07 12:00:00+00'), ('2024-07-08 12:00:00+00'), + ('2077-11-16 12:00:00+00'), ('2077-11-17 12:00:00+00'), ('2200-01-01 12:00:00+00'), + ('1000-01-01 12:00:00+00'), ('1900-01-01 12:00:00+00'), ('2000-01-01 12:00:00+00')) t(ts) +-- +ok +== +SELECT make_timestamptz(1300, 1, 1, 0, 0, 0.0, 'UTC') +-- +ok +== +SELECT make_timestamptz(1600, 12, 29, 0, 0, 0.0, 'UTC') +-- +ok +== +SELECT make_timestamptz(1601, 1, 1, 0, 0, 0.0, 'UTC') +-- +ok +== +SELECT make_timestamptz(1299, 1, 1, 0, 0, 0.0, 'UTC') +-- +ok +== +SELECT count(*), min(y), max(y) FROM (SELECT year(ts) y FROM generate_series('1880-01-01 12:00:00+00'::TIMESTAMPTZ, '2180-01-01 12:00:00+00'::TIMESTAMPTZ, INTERVAL 37 DAY) t(ts)) +-- +ok +== +SELECT sum(hash(ts::VARCHAR)) FROM generate_series('1880-01-01 12:00:00+00'::TIMESTAMPTZ, '2180-01-01 12:00:00+00'::TIMESTAMPTZ, INTERVAL 11 DAY) t(ts) +-- +ok +== diff --git a/parser/testdata/corpus/sql/timezone/test_icu_calendar_islamic_observed.test b/parser/testdata/corpus/sql/timezone/test_icu_calendar_islamic_observed.test new file mode 100644 index 0000000..a81c422 --- /dev/null +++ b/parser/testdata/corpus/sql/timezone/test_icu_calendar_islamic_observed.test @@ -0,0 +1,35 @@ +# source: test/sql/timezone/test_icu_calendar_islamic_observed.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +SET Calendar='islamic' +-- +ok +== +SELECT ts, year(ts), month(ts), day(ts), era(ts), dayofyear(ts) FROM (VALUES + ('2024-06-15 12:00:00+00'::TIMESTAMPTZ), ('0622-07-19 12:00:00+00'), ('0622-07-15 12:00:00+00'), + ('1970-01-01 00:00:00+00'), ('2024-07-07 12:00:00+00'), ('2024-07-08 12:00:00+00'), + ('2024-03-10 12:00:00+00'), ('2024-03-11 12:00:00+00'), ('2024-04-09 12:00:00+00'), + ('1900-01-01 12:00:00+00'), ('2100-01-01 12:00:00+00'), ('1500-01-01 12:00:00+00')) t(ts) +-- +ok +== +SELECT make_timestamptz(1445, 9, 1, 0, 0, 0.0, 'UTC') +-- +ok +== +SELECT last_day('2024-03-15 12:00:00+00'::TIMESTAMPTZ) +-- +ok +== +SET Calendar='islamic-rgsa' +-- +ok +== +SELECT ts, year(ts), month(ts), day(ts), era(ts), dayofyear(ts) FROM (VALUES + ('2024-06-15 12:00:00+00'::TIMESTAMPTZ), ('0622-07-19 12:00:00+00'), ('1970-01-01 00:00:00+00'), + ('2024-07-07 12:00:00+00'), ('1500-01-01 12:00:00+00')) t(ts) +-- +ok +== diff --git a/parser/testdata/corpus/sql/timezone/test_icu_calendar_japanese.test b/parser/testdata/corpus/sql/timezone/test_icu_calendar_japanese.test new file mode 100644 index 0000000..b06d189 --- /dev/null +++ b/parser/testdata/corpus/sql/timezone/test_icu_calendar_japanese.test @@ -0,0 +1,59 @@ +# source: test/sql/timezone/test_icu_calendar_japanese.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +SELECT ts, era(ts), year(ts), month(ts), day(ts) FROM (VALUES + ('2024-06-15 12:00:00+00'::TIMESTAMPTZ), ('2019-04-30 12:00:00+00'), ('2019-05-01 12:00:00+00'), + ('1989-01-07 12:00:00+00'), ('1989-01-08 12:00:00+00'), ('1926-12-24 12:00:00+00'), + ('1926-12-25 12:00:00+00'), ('1912-07-29 12:00:00+00'), ('1912-07-30 12:00:00+00'), + ('1868-10-22 12:00:00+00'), ('1868-10-23 12:00:00+00'), ('0645-06-18 12:00:00+00'), + ('0645-06-19 12:00:00+00'), ('0600-01-01 12:00:00+00'), ('1582-10-04 12:00:00+00'), + ('1582-10-15 12:00:00+00')) t(ts) +-- +ok +== +SELECT make_timestamptz(6, 6, 15, 12, 0, 0.0, 'UTC') +-- +ok +== +SELECT make_timestamptz(31, 4, 30, 12, 0, 0.0, 'UTC') +-- +ok +== +SELECT make_timestamptz(64, 1, 7, 12, 0, 0.0, 'UTC') +-- +ok +== +SELECT date_trunc('year', '2019-06-15 12:00:00+00'::TIMESTAMPTZ) +-- +ok +== +SELECT date_trunc('era', '2024-06-15 12:00:00+00'::TIMESTAMPTZ) +-- +ok +== +SELECT '2019-04-30 12:00:00+00'::TIMESTAMPTZ + INTERVAL 1 YEAR +-- +ok +== +SELECT '2019-04-30 12:00:00+00'::TIMESTAMPTZ + INTERVAL 1 MONTH +-- +ok +== +SELECT '2019-04-30 12:00:00+00'::TIMESTAMPTZ + INTERVAL 1 DAY +-- +ok +== +SELECT date_diff('year', '2019-01-01 12:00:00+00'::TIMESTAMPTZ, '2024-06-15 12:00:00+00'::TIMESTAMPTZ) +-- +ok +== +SELECT count(*), count(distinct era) FROM (SELECT era(ts) era FROM generate_series('0600-01-01 12:00:00+00'::TIMESTAMPTZ, '2100-01-01 12:00:00+00'::TIMESTAMPTZ, INTERVAL 31 DAY) t(ts)) +-- +ok +== +SELECT sum(hash(ts::VARCHAR)) FROM generate_series('0600-01-01 12:00:00+00'::TIMESTAMPTZ, '2100-01-01 12:00:00+00'::TIMESTAMPTZ, INTERVAL 13 DAY) t(ts) +-- +ok +== diff --git a/parser/testdata/corpus/sql/timezone/test_icu_calendar_persian.test b/parser/testdata/corpus/sql/timezone/test_icu_calendar_persian.test new file mode 100644 index 0000000..9d2d9e7 --- /dev/null +++ b/parser/testdata/corpus/sql/timezone/test_icu_calendar_persian.test @@ -0,0 +1,81 @@ +# source: test/sql/timezone/test_icu_calendar_persian.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +SET Calendar='persian' +-- +ok +== +SELECT ts, year(ts), month(ts), day(ts), era(ts), dayofyear(ts) FROM (VALUES + ('2024-06-15 12:00:00+00'::TIMESTAMPTZ), ('0622-03-21 12:00:00+00'), ('0622-03-22 12:00:00+00'), + ('1970-01-01 00:00:00+00'), ('2024-03-19 12:00:00+00'), ('2024-03-20 12:00:00+00'), + ('2025-03-20 12:00:00+00'), ('2025-03-21 12:00:00+00'), ('2123-03-20 12:00:00+00'), + ('2124-03-20 12:00:00+00'), ('1500-01-01 12:00:00+00'), ('0001-01-01 12:00:00+00')) t(ts) +-- +ok +== +SELECT make_timestamptz(1403, 1, 1, 0, 0, 0.0, 'UTC') +-- +ok +== +SELECT make_timestamptz(1403, 12, 29, 0, 0, 0.0, 'UTC') +-- +ok +== +SELECT make_timestamptz(1403, 12, 30, 0, 0, 0.0, 'UTC') +-- +ok +== +SELECT make_timestamptz(1402, 12, 30, 0, 0, 0.0, 'UTC') +-- +ok +== +SELECT '2024-03-20 12:00:00+00'::TIMESTAMPTZ - INTERVAL 1 DAY +-- +ok +== +SELECT last_day('2025-03-01 12:00:00+00'::TIMESTAMPTZ) +-- +ok +== +SELECT * FROM generate_series('2024-03-15 12:00:00+00'::TIMESTAMPTZ, '2024-03-25 12:00:00+00'::TIMESTAMPTZ, INTERVAL 2 DAY) +-- +ok +== +SET Calendar='indian' +-- +ok +== +SELECT ts, year(ts), month(ts), day(ts), era(ts), dayofyear(ts) FROM (VALUES + ('2024-06-15 12:00:00+00'::TIMESTAMPTZ), ('0079-03-22 12:00:00+00'), ('0078-03-22 12:00:00+00'), + ('1970-01-01 00:00:00+00'), ('2024-03-20 12:00:00+00'), ('2024-03-21 12:00:00+00'), + ('2023-03-21 12:00:00+00'), ('2023-03-22 12:00:00+00'), ('2024-12-31 12:00:00+00'), + ('2025-01-01 12:00:00+00'), ('0001-01-01 12:00:00+00')) t(ts) +-- +ok +== +SELECT make_timestamptz(1946, 1, 1, 0, 0, 0.0, 'UTC') +-- +ok +== +SELECT make_timestamptz(1946, 1, 31, 0, 0, 0.0, 'UTC') +-- +ok +== +SELECT make_timestamptz(1945, 1, 31, 0, 0, 0.0, 'UTC') +-- +ok +== +SELECT make_timestamptz(1946, 12, 30, 0, 0, 0.0, 'UTC') +-- +ok +== +SELECT last_day('2024-04-01 12:00:00+00'::TIMESTAMPTZ) +-- +ok +== +SELECT * FROM generate_series('2024-03-18 12:00:00+00'::TIMESTAMPTZ, '2024-03-26 12:00:00+00'::TIMESTAMPTZ, INTERVAL 2 DAY) +-- +ok +== diff --git a/parser/testdata/corpus/sql/timezone/test_icu_calendar_systems.test b/parser/testdata/corpus/sql/timezone/test_icu_calendar_systems.test new file mode 100644 index 0000000..b586d03 --- /dev/null +++ b/parser/testdata/corpus/sql/timezone/test_icu_calendar_systems.test @@ -0,0 +1,126 @@ +# source: test/sql/timezone/test_icu_calendar_systems.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +SET Calendar='buddhist' +-- +ok +== +SELECT ts, year(ts), month(ts), day(ts), era(ts) FROM (VALUES + ('2024-01-15 12:00:00-05'::TIMESTAMPTZ), ('1970-01-01 00:00:00-05'), ('0001-01-01 12:00:00-05'), + ('0544-01-01 (BC) 12:00:00-04:56'), ('1582-10-04 12:00:00-04:56'), ('1582-10-15 12:00:00-04:56'), + ('1000-06-15 12:00:00-04:56'), ('9999-12-31 12:00:00-05')) t(ts) +-- +ok +== +SELECT make_timestamptz(2567, 1, 15, 12, 0, 0.0, 'UTC') +-- +ok +== +SELECT '2024-01-15 12:00:00-05'::TIMESTAMPTZ + INTERVAL 1 YEAR +-- +ok +== +SELECT '2024-01-15 12:00:00-05'::TIMESTAMPTZ + INTERVAL 13 MONTH +-- +ok +== +SELECT date_trunc('year', '2024-06-15 12:00:00-04'::TIMESTAMPTZ) +-- +ok +== +SELECT date_trunc('decade', '2024-06-15 12:00:00-04'::TIMESTAMPTZ) +-- +ok +== +SELECT date_trunc('century', '2024-06-15 12:00:00-04'::TIMESTAMPTZ) +-- +ok +== +SELECT date_diff('year', '0001-01-01 12:00:00-04:56'::TIMESTAMPTZ, '2024-01-01 12:00:00-05'::TIMESTAMPTZ) +-- +ok +== +SELECT last_day('2024-02-15 12:00:00-05'::TIMESTAMPTZ) +-- +ok +== +SELECT date_part(['year','month','day','era','dayofyear','week','isoyear'], '2024-06-15 12:00:00-04'::TIMESTAMPTZ) +-- +ok +== +SET Calendar='roc' +-- +ok +== +SELECT ts, year(ts), month(ts), day(ts), era(ts) FROM (VALUES + ('2024-01-15 12:00:00-05'::TIMESTAMPTZ), ('1912-01-01 12:00:00-05'), ('1911-12-31 12:00:00-05'), + ('1911-01-01 12:00:00-05'), ('1800-01-01 12:00:00-04:56'), ('1582-10-04 12:00:00-04:56'), + ('1582-10-15 12:00:00-04:56'), ('0001-01-01 12:00:00-04:56')) t(ts) +-- +ok +== +SELECT make_timestamptz(113, 1, 15, 12, 0, 0.0, 'UTC') +-- +ok +== +SELECT '1912-01-01 12:00:00-05'::TIMESTAMPTZ - INTERVAL 1 YEAR +-- +ok +== +SELECT date_diff('year', '1900-01-01 12:00:00-04:56'::TIMESTAMPTZ, '2024-01-01 12:00:00-05'::TIMESTAMPTZ) +-- +ok +== +SET Calendar='iso8601' +-- +ok +== +SELECT ts, year(ts), week(ts), isoyear(ts), dayofweek(ts) FROM (VALUES + ('2024-01-01 12:00:00-05'::TIMESTAMPTZ), ('2023-01-01 12:00:00-05'), ('2021-01-01 12:00:00-05'), + ('2020-12-31 12:00:00-05'), ('2019-12-30 12:00:00-05'), ('2016-01-03 12:00:00-05'), + ('2016-01-04 12:00:00-05'), ('1000-06-15 12:00:00-04:56')) t(ts) +-- +ok +== +SELECT date_trunc('week', '2024-06-15 12:00:00-04'::TIMESTAMPTZ) +-- +ok +== +SELECT date_trunc('isoyear', '2024-01-01 12:00:00-05'::TIMESTAMPTZ) +-- +ok +== +SELECT date_diff('week', '2024-01-01 12:00:00-05'::TIMESTAMPTZ, '2024-12-31 12:00:00-05'::TIMESTAMPTZ) +-- +ok +== +SELECT make_timestamptz(2024, 6, 15, 12, 0, 0.0, 'UTC') +-- +ok +== +SELECT date_part(['year','month','day','era','dayofyear','week','isoyear','yearweek'], '2024-06-15 12:00:00-04'::TIMESTAMPTZ) +-- +ok +== +SELECT * FROM generate_series('2024-01-01 12:00:00-05'::TIMESTAMPTZ, '2024-02-01 12:00:00-05'::TIMESTAMPTZ, INTERVAL 1 WEEK) +-- +ok +== +SELECT ts, year(ts), month(ts), day(ts), dayofyear(ts) FROM (VALUES + ('1582-10-01 12:00:00+00'::TIMESTAMPTZ), ('1582-10-04 12:00:00+00'), ('1582-10-05 12:00:00+00'), + ('1582-10-14 12:00:00+00'), ('1582-10-15 12:00:00+00'), ('1582-12-31 12:00:00+00'), + ('1500-02-28 12:00:00+00'), ('1700-02-28 12:00:00+00')) t(ts) +-- +ok +== +SELECT ts, year(ts), month(ts), day(ts), dayofyear(ts) FROM (VALUES + ('1582-10-04 12:00:00+00'::TIMESTAMPTZ), ('1582-10-15 12:00:00+00'), ('1500-02-28 12:00:00+00')) t(ts) +-- +ok +== +SELECT name FROM icu_calendar_names() ORDER BY 1 +-- +ok +== diff --git a/parser/testdata/corpus/sql/timezone/test_icu_casts.test b/parser/testdata/corpus/sql/timezone/test_icu_casts.test new file mode 100644 index 0000000..a73363d --- /dev/null +++ b/parser/testdata/corpus/sql/timezone/test_icu_casts.test @@ -0,0 +1,63 @@ +# source: test/sql/timezone/test_icu_casts.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +CREATE TABLE tstzs AS + FROM VALUES ('2026-04-09 11:48:07.123456-07'::TIMESTAMPTZ) tbl(t); +-- +ok +== +CREATE TABLE tsns AS + FROM VALUES ('2021-01-01 00:00:00.000000123'::TIMESTAMP_NS) tbl(t); +-- +ok +== +select t::TIMESTAMP_NS from tstzs; +-- +ok +== +SELECT TIMESTAMPTZ_NS '2021-01-01 00:00:00.000000123+00'::TIMESTAMP_NS; +-- +ok +== +select t::TIMESTAMPTZ_NS from tsns; +-- +ok +== +select t::TIMESTAMP from tstzs; +-- +ok +== +select t::TIMESTAMP_MS from tstzs; +-- +ok +== +select t::TIMESTAMP_S from tstzs; +-- +ok +== +select t::DATE from tstzs; +-- +ok +== +SELECT TRY_CAST(TIMESTAMPTZ '2262-04-11 23:47:16.854776+00' AS TIMESTAMP_NS); +-- +ok +== +SELECT TRY_CAST(TIMESTAMPTZ '9999-01-01 00:00:00+00' AS TIMESTAMP_NS); +-- +ok +== +SELECT TRY_CAST(TIMESTAMPTZ '2026-04-09 11:48:07.123456-07' AS TIMESTAMP_NS); +-- +ok +== +SELECT TRY_CAST(DATE '5877642-06-25' AS TIMESTAMPTZ); +-- +ok +== +SELECT CAST(DATE '5877642-06-25' AS TIMESTAMPTZ); +-- +ok +== diff --git a/parser/testdata/corpus/sql/timezone/test_icu_datetime_overflow.test b/parser/testdata/corpus/sql/timezone/test_icu_datetime_overflow.test new file mode 100644 index 0000000..8426de9 --- /dev/null +++ b/parser/testdata/corpus/sql/timezone/test_icu_datetime_overflow.test @@ -0,0 +1,57 @@ +# source: test/sql/timezone/test_icu_datetime_overflow.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +SELECT '2000-01-01 00:00:00+00'::TIMESTAMPTZ - INTERVAL 2147483647 MONTH; +-- +ok +== +SELECT date_add('2000-01-01 00:00:00+00'::TIMESTAMPTZ, INTERVAL 2147483647 MONTH); +-- +ok +== +SELECT date_add('2000-01-01 00:00:00+00'::TIMESTAMPTZ, INTERVAL (-2147483648) MONTH); +-- +ok +== +SET Calendar='{cal}'; +-- +ok +== +SELECT date_add('1900-01-01 00:00:00+00'::TIMESTAMPTZ, INTERVAL 2147483647 MONTH); +-- +ok +== +SELECT date_add('1900-01-01 00:00:00+00'::TIMESTAMPTZ, INTERVAL (-2147483648) MONTH); +-- +ok +== +SET Calendar='chinese'; +-- +ok +== +SELECT date_part(['decade','timezone'], '294247-01-10 04:00:54.775806+00'::TIMESTAMPTZ); +-- +ok +== +SELECT date_add('2000-01-01 00:00:00+00'::TIMESTAMPTZ, INTERVAL 3 MONTH); +-- +ok +== +SELECT date_add('2000-01-31 00:00:00+00'::TIMESTAMPTZ, INTERVAL 1 MONTH); +-- +ok +== +SELECT '2000-01-01 00:00:00+00'::TIMESTAMPTZ - INTERVAL 1 MONTH; +-- +ok +== +SELECT date_add('1900-01-01 00:00:00+00'::TIMESTAMPTZ, INTERVAL '2147483647 months 5 days 3 hours'); +-- +ok +== +SELECT date_add('1900-01-01 00:00:00+00'::TIMESTAMPTZ, INTERVAL '-2147483648 months -5 days -3 hours'); +-- +ok +== diff --git a/parser/testdata/corpus/sql/timezone/test_icu_datetime_sweep.test b/parser/testdata/corpus/sql/timezone/test_icu_datetime_sweep.test new file mode 100644 index 0000000..6363a92 --- /dev/null +++ b/parser/testdata/corpus/sql/timezone/test_icu_datetime_sweep.test @@ -0,0 +1,32 @@ +# source: test/sql/timezone/test_icu_datetime_sweep.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +WITH instants(ts) AS (VALUES + ('1700-06-15 12:00:00+00'::TIMESTAMPTZ), ('1850-01-01 00:00:00+00'), ('1900-06-15 12:00:00+00'), + ('1918-03-31 12:00:00+00'), ('1942-06-15 12:00:00+00'), ('1970-01-01 00:00:00+00'), + ('1985-07-01 12:00:00+00'), ('2000-01-01 00:00:00+00'), ('2011-12-30 12:00:00+00'), + ('2020-03-29 01:30:00+00'), ('2024-06-15 12:00:00+00'), ('2038-01-19 03:14:07+00'), + ('2100-11-07 12:00:00+00'), ('2400-01-01 00:00:00+00')) +SELECT count(*), sum(hash(strftime(timezone(name, ts), '%Y-%m-%d %H:%M:%S'))) +FROM pg_timezone_names(), instants +-- +ok +== +WITH locals(ts) AS (VALUES + ('1900-01-01 00:00:00'::TIMESTAMP), ('1970-01-01 00:00:00'), ('2020-03-29 02:30:00'), + ('2020-10-25 02:30:00'), ('2024-06-15 12:00:00'), ('2100-01-01 00:00:00')) +SELECT count(*), sum(hash(timezone(name, ts)::VARCHAR)) +FROM pg_timezone_names(), locals +-- +ok +== +SELECT count(*), sum(hash(name)), sum(hash(abbrev)) FROM pg_timezone_names() +-- +ok +== +SELECT count(*), sum(hash(ts::VARCHAR)) FROM generate_series('1900-01-01 12:00:00+00'::TIMESTAMPTZ, '2100-01-01 12:00:00+00'::TIMESTAMPTZ, INTERVAL 11 DAY) t(ts) +-- +ok +== diff --git a/parser/testdata/corpus/sql/timezone/test_icu_timezone.test b/parser/testdata/corpus/sql/timezone/test_icu_timezone.test new file mode 100644 index 0000000..8212795 --- /dev/null +++ b/parser/testdata/corpus/sql/timezone/test_icu_timezone.test @@ -0,0 +1,295 @@ +# source: test/sql/timezone/test_icu_timezone.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +SET TimeZone = 'Europe/Duck'; +-- +ok +== +SELECT '2001-02-16 20:38:40'::TIMESTAMP AT TIME ZONE 'America/Denver'; +-- +ok +== +SELECT '2001-02-16 20:38:40'::TIMESTAMP AT TIME ZONE 'america/denver'; +-- +ok +== +SELECT '2001-02-16 20:38:40'::TIMESTAMP AT TIME ZONE 'America/Donver'; +-- +ok +== +SELECT '2001-02-16 20:38:40-05'::TIMESTAMPTZ AT TIME ZONE 'America/Denver'; +-- +ok +== +SELECT '2001-02-16 20:38:40'::TIMESTAMP AT TIME ZONE 'Europe/Duck'; +-- +ok +== +SELECT '2001-02-16 20:38:40-05'::TIMESTAMPTZ AT TIME ZONE 'Europe/Duck'; +-- +ok +== +SELECT 'infinity'::{datatype} AT TIME ZONE 'America/Denver'; +-- +error: Parser Error: syntax error at or near "{" +== +SELECT '-infinity'::{datatype} AT TIME ZONE 'America/Denver'; +-- +error: Parser Error: syntax error at or near "{" +== +SELECT 'infinity'::{datatype} AT TIME ZONE 'Europe/Duck'; +-- +error: Parser Error: syntax error at or near "{" +== +SELECT '-infinity'::{datatype} AT TIME ZONE 'Europe/Duck'; +-- +error: Parser Error: syntax error at or near "{" +== +SELECT NULL::TIMESTAMP AT TIME ZONE 'America/Denver'; +-- +ok +== +SELECT NULL::TIMESTAMPTZ AT TIME ZONE 'America/Denver'; +-- +ok +== +SELECT '2001-02-16 20:38:40'::TIMESTAMP AT TIME ZONE NULL; +-- +ok +== +SELECT '2001-02-16 20:38:40-05'::TIMESTAMPTZ AT TIME ZONE NULL; +-- +ok +== +select '12:15:37.123456-08'::TIMETZ AT TIME ZONE 'America/Phoenix'; +-- +ok +== +select timezone('America/Phoenix', '12:15:37.123456-08'::TIMETZ); +-- +ok +== +SELECT '2020-01-01'::DATE::TIMESTAMPTZ AS dttz; +-- +ok +== +SELECT 'infinity'::DATE::TIMESTAMPTZ AS dttz; +-- +ok +== +SELECT '-infinity'::DATE::TIMESTAMPTZ AS dttz; +-- +ok +== +select '5877642-06-25 (BC)'::DATE::TIMESTAMPTZ AS dttz; +-- +ok +== +select '5881580-07-10'::DATE::TIMESTAMPTZ AS dttz; +-- +ok +== +CREATE TABLE attimezone (ts TIMESTAMP, tstz TIMESTAMPTZ, ttz TIMETZ, tz VARCHAR); +-- +ok +== +INSERT INTO attimezone (VALUES + ('2001-02-16 20:38:40', '2001-02-16 19:38:40-08', '19:38:40-08', 'America/Phoenix'), + ('2001-02-16 18:38:40', '2001-02-16 20:38:40-05', '20:38:40-05', 'America/Phoenix'), + ('infinity', 'infinity', '19:38:40-08', 'America/Phoenix'), + ('-infinity', '-infinity', '20:38:40-05', 'America/Phoenix'), + (NULL, NULL, NULL, 'America/Phoenix'), + ('2001-02-16 20:38:40', '2001-02-16 19:38:40-08', '19:38:40+08', 'UTC'), + ('2001-02-16 18:38:40', '2001-02-16 20:38:40-05', '20:38:40+15:59', 'UTC'), + ('infinity', 'infinity', '12:15:37.123456-08', 'UTC'), + ('-infinity', '-infinity', '20:38:40-15:59', 'UTC'), + (NULL, NULL, NULL, 'UTC'), + ('2001-02-16 20:38:40', '2001-02-16 19:38:40-08', '19:38:40-08', NULL), + ('2001-02-16 18:38:40', '2001-02-16 20:38:40-05', '20:38:40-05', NULL), + ('infinity', 'infinity', '12:15:37.123456-08', NULL), + ('-infinity', '-infinity', '20:38:40-15:59', NULL), +); +-- +ok +== +SELECT ts AT TIME ZONE tz, tstz AT TIME ZONE tz, ttz AT TIME ZONE tz +FROM attimezone +-- +ok +== +SELECT ts AT TIME ZONE tz, tstz AT TIME ZONE tz, ttz AT TIME ZONE tz +FROM attimezone +WHERE ts > '2001-02-16 18:38:40'::TIMESTAMP +-- +ok +== +set TimeZone = '{utc}'; +-- +ok +== +select value from duckdb_settings() where name = 'TimeZone'; +-- +ok +== +SELECT '2026-04-23 19:26:40 {utc}'::TIMESTAMPTZ; +-- +ok +== +SELECT TIMESTAMP '2026-04-23 19:26:40' AT TIME ZONE '{utc}' +-- +ok +== +select localtimestamp; +-- +ok +== +select localtime; +-- +ok +== +select current_localtimestamp(); +-- +ok +== +select current_localtime(); +-- +ok +== +SELECT name, abbrev FROM pg_timezone_names() ORDER BY name; +-- +ok +== +SET TimeZone = 'Asia/Amman'; +-- +ok +== +SELECT '2022-10-29 00:00:00+00'::TIMESTAMPTZ; +-- +ok +== +SELECT '2022-11-01 00:00:00+00'::TIMESTAMPTZ; +-- +ok +== +SET TimeZone = 'America/Ciudad_Juarez'; +-- +ok +== +SELECT '2023-05-01 12:00:00+00'::TIMESTAMPTZ; +-- +ok +== +SET TimeZone = 'Egypt'; +-- +ok +== +SELECT '2023-05-15 12:00:00+00'::TIMESTAMPTZ; +-- +ok +== +SET TimeZone = 'Asia/Beirut'; +-- +ok +== +SELECT '2023-03-26 12:00:00+00'::TIMESTAMPTZ, '2023-04-21 12:00:00+00'::TIMESTAMPTZ; +-- +ok +== +SET TimeZone = 'America/Nuuk'; +-- +ok +== +SELECT '2022-10-30 03:00:00-07'::TIMESTAMPTZ, '2023-10-30 02:00:00-07'::TIMESTAMPTZ; +-- +ok +== +SET TimeZone = 'America/Scoresbysund'; +-- +ok +== +SELECT '2024-03-31 00:59:00-01'::TIMESTAMPTZ, '2024-03-31 01:00:00-01'::TIMESTAMPTZ; +-- +ok +== +SET TimeZone = 'Asia/Almaty'; +-- +ok +== +select '2024-02-29 00:00:00+06'::TIMESTAMPTZ, '2024-03-01 01:00:00+06'::TIMESTAMPTZ; +-- +ok +== +SET TimeZone = 'Atlantic/Azores'; +-- +ok +== +select '1981-09-27 01:00:00+00'::TIMESTAMPTZ; +-- +ok +== +set timezone='America/Asuncion'; +-- +ok +== +select '2025-03-23'::timestamptz; +-- +ok +== +select utc_offset, is_dst +from pg_timezone_names() +where name = 'America/Asuncion' +-- +ok +== +set timezone='America/Coyhaique'; +-- +ok +== +select '2025-04-05'::timestamptz; +-- +ok +== +select utc_offset, is_dst +from pg_timezone_names() +where name = 'America/Coyhaique' +-- +ok +== +set timezone='Mexico/BajaNorte'; +-- +ok +== +select '1962-07-31'::timestamptz; +-- +ok +== +set timezone='Europe/Chisinau'; +-- +ok +== +select + '2022-03-27 02:00:00+02'::timestamptz, + '2022-03-27 03:00:00+02'::timestamptz, + '2022-10-30 03:00:00+03'::timestamptz, + '2022-10-30 04:00:00+03'::timestamptz, +-- +ok +== +set timezone='America/Vancouver'; +-- +ok +== +select '2026-11-10'::timestamptz +-- +ok +== +set TimeZone = 'America/Edmonton'; +-- +ok +== +select '2026-12-01'::TIMESTAMPTZ; +-- +ok +== diff --git a/parser/testdata/corpus/sql/timezone/test_icu_timezone_edge_cases.test b/parser/testdata/corpus/sql/timezone/test_icu_timezone_edge_cases.test new file mode 100644 index 0000000..be66814 --- /dev/null +++ b/parser/testdata/corpus/sql/timezone/test_icu_timezone_edge_cases.test @@ -0,0 +1,230 @@ +# source: test/sql/timezone/test_icu_timezone_edge_cases.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +SELECT ts, ts::TIMESTAMPTZ FROM (VALUES + ('2024-03-10 01:59:59'::TIMESTAMP), ('2024-03-10 02:00:00'), ('2024-03-10 02:30:00'), + ('2024-03-10 02:59:59'), ('2024-03-10 03:00:00'), + ('2024-11-03 00:59:59'), ('2024-11-03 01:00:00'), ('2024-11-03 01:30:00'), + ('2024-11-03 01:59:59'), ('2024-11-03 02:00:00')) t(ts) +-- +ok +== +SET TimeZone='Australia/Lord_Howe' +-- +ok +== +SELECT ts, ts::TIMESTAMPTZ FROM (VALUES + ('2024-04-07 01:29:59'::TIMESTAMP), ('2024-04-07 01:30:00'), ('2024-04-07 01:45:00'), + ('2024-10-06 01:59:59'), ('2024-10-06 02:00:00'), ('2024-10-06 02:15:00')) t(ts) +-- +ok +== +SET TimeZone='Pacific/Apia' +-- +ok +== +SELECT ts, ts::TIMESTAMPTZ FROM (VALUES + ('2011-12-29 23:59:59'::TIMESTAMP), ('2011-12-30 00:00:00'), ('2011-12-30 12:00:00'), + ('2011-12-31 00:00:00'), ('2011-12-31 23:59:59')) t(ts) +-- +ok +== +SELECT '2011-12-29 23:59:59+13'::TIMESTAMPTZ + INTERVAL 1 DAY +-- +ok +== +SELECT '2011-12-29 23:59:59+13'::TIMESTAMPTZ + INTERVAL 1 MONTH +-- +ok +== +SET TimeZone='Europe/Dublin' +-- +ok +== +SELECT ts, ts::TIMESTAMPTZ, date_part('timezone', ts::TIMESTAMPTZ) FROM (VALUES + ('2024-01-15 12:00:00'::TIMESTAMP), ('2024-07-15 12:00:00'), + ('1970-01-15 12:00:00'), ('1970-07-15 12:00:00')) t(ts) +-- +ok +== +SET TimeZone='Europe/Amsterdam' +-- +ok +== +SELECT ts, ts::TIMESTAMPTZ FROM (VALUES + ('1800-01-01 00:00:00'::TIMESTAMP), ('1900-01-01 00:00:00'), + ('1937-06-30 23:59:59'), ('1937-07-01 00:00:00')) t(ts) +-- +ok +== +SET TimeZone='Asia/Kathmandu' +-- +ok +== +SELECT ts, ts::TIMESTAMPTZ FROM (VALUES + ('1500-01-01 00:00:00'::TIMESTAMP), ('1919-12-31 00:00:00'), + ('1986-01-01 00:00:00')) t(ts) +-- +ok +== +SET TimeZone='America/Los_Angeles' +-- +ok +== +SELECT ts, ts::TIMESTAMPTZ FROM (VALUES + ('4000-01-01 (BC) 00:00:00'::TIMESTAMP), ('0001-01-01 00:00:00'), + ('1582-10-04 00:00:00'), ('1582-10-15 00:00:00'), + ('9999-12-31 23:59:59'), ('99999-01-01 00:00:00')) t(ts) +-- +ok +== +SELECT part, date_trunc(part, '2024-03-10 03:30:00-04'::TIMESTAMPTZ) +FROM (VALUES ('millennium'),('century'),('decade'),('year'),('quarter'),('month'),('week'), + ('day'),('hour'),('minute'),('second'),('millisecond'),('microsecond')) t(part) +-- +ok +== +SELECT part, date_trunc(part, '2024-11-03 01:30:00-05'::TIMESTAMPTZ) +FROM (VALUES ('year'),('quarter'),('month'),('week'),('day'),('hour'),('minute')) t(part) +-- +ok +== +SELECT part, date_part(part, '2024-03-10 03:30:00-04'::TIMESTAMPTZ) +FROM (VALUES ('era'),('year'),('quarter'),('month'),('day'),('dayofweek'),('isodow'), + ('dayofyear'),('week'),('isoyear'),('yearweek'),('hour'),('minute'),('second'), + ('timezone'),('timezone_hour'),('timezone_minute')) t(part) +-- +ok +== +SELECT date_part('epoch', '2024-03-10 03:30:00-04'::TIMESTAMPTZ) +-- +ok +== +SELECT i, '2024-03-09 12:00:00-05'::TIMESTAMPTZ + i FROM (VALUES + (INTERVAL 1 DAY), (INTERVAL 24 HOUR), (INTERVAL 1 MONTH), (INTERVAL 1 YEAR), + (INTERVAL '1 day 2 hours'), (-INTERVAL 1 DAY), (-INTERVAL 24 HOUR)) t(i) +-- +ok +== +SELECT i, '2024-11-02 12:00:00-04'::TIMESTAMPTZ + i FROM (VALUES + (INTERVAL 1 DAY), (INTERVAL 24 HOUR), (INTERVAL 1 MONTH), (-INTERVAL 1 DAY)) t(i) +-- +ok +== +SELECT ts, ts + INTERVAL 1 MONTH, ts + INTERVAL 1 YEAR FROM (VALUES + ('2024-01-31 12:00:00-05'::TIMESTAMPTZ), ('2024-02-29 12:00:00-05'), + ('2023-03-31 12:00:00-04'), ('2024-05-31 12:00:00-04')) t(ts) +-- +ok +== +SELECT age('2024-03-11 12:00:00-04'::TIMESTAMPTZ, '2024-03-09 12:00:00-05'::TIMESTAMPTZ) +-- +ok +== +SELECT age('2025-03-09 12:00:00-05'::TIMESTAMPTZ, '2024-03-09 12:00:00-05'::TIMESTAMPTZ) +-- +ok +== +SELECT age('2024-02-29 12:00:00-05'::TIMESTAMPTZ, '2020-02-29 12:00:00-05'::TIMESTAMPTZ) +-- +ok +== +SELECT part, date_diff(part, '2024-03-09 12:00:00-05'::TIMESTAMPTZ, '2024-11-05 12:00:00-05'::TIMESTAMPTZ) +FROM (VALUES ('year'),('quarter'),('month'),('week'),('day'),('hour'),('minute')) t(part) +-- +ok +== +SELECT make_timestamptz(2024, 3, 10, 2, 30, 0.0, 'America/New_York') +-- +ok +== +SELECT make_timestamptz(2024, 13, 1, 0, 0, 0.0, 'UTC') +-- +ok +== +SELECT make_timestamptz(2024, 0, 1, 0, 0, 0.0, 'UTC') +-- +ok +== +SELECT make_timestamptz(2024, 2, 30, 0, 0, 0.0, 'UTC') +-- +ok +== +SELECT make_timestamptz(2024, 1, 1, 25, 70, 90.5, 'UTC') +-- +ok +== +SELECT make_timestamptz(0, 1, 1, 0, 0, 0.0, 'UTC') +-- +ok +== +SELECT make_timestamptz(-1, 1, 1, 0, 0, 0.0, 'UTC') +-- +ok +== +SELECT make_timestamptz(-4713, 11, 24, 12, 0, 0.0, 'UTC') +-- +ok +== +SELECT b, time_bucket(b, '2024-03-10 03:30:00-04'::TIMESTAMPTZ) FROM (VALUES + (INTERVAL 1 DAY), (INTERVAL 2 DAY), (INTERVAL 1 MONTH), (INTERVAL 1 HOUR), + (INTERVAL 30 MINUTE), (INTERVAL 1 YEAR)) t(b) +-- +ok +== +SELECT * FROM generate_series('2024-03-09 12:00:00-05'::TIMESTAMPTZ, '2024-03-12 12:00:00-04'::TIMESTAMPTZ, INTERVAL 1 DAY) +-- +ok +== +SELECT * FROM generate_series('2024-11-02 12:00:00-04'::TIMESTAMPTZ, '2024-11-05 12:00:00-05'::TIMESTAMPTZ, INTERVAL 1 DAY) +-- +ok +== +SELECT strptime('2024-03-10 02:30:00', '%Y-%m-%d %H:%M:%S')::TIMESTAMPTZ +-- +ok +== +SELECT strptime('2024-03-10 02:30:00 +0530', '%Y-%m-%d %H:%M:%S %z') +-- +ok +== +SELECT strptime('2024-11-03 01:30:00', '%Y-%m-%d %H:%M:%S')::TIMESTAMPTZ +-- +ok +== +SELECT strftime('2024-03-10 03:30:00-04'::TIMESTAMPTZ, '%Y-%m-%d %H:%M:%S %Z') +-- +ok +== +SELECT timezone('America/New_York', '2024-03-10 02:30:00'::TIMESTAMP) +-- +ok +== +SELECT timezone('America/New_York', '2024-11-03 01:30:00'::TIMESTAMP) +-- +ok +== +SELECT timezone('America/New_York', '2024-03-10 07:30:00+00'::TIMESTAMPTZ) +-- +ok +== +SELECT ts, last_day(ts), monthname(ts), dayname(ts) FROM (VALUES + ('2024-02-15 12:00:00+00'::TIMESTAMPTZ), ('2023-02-15 12:00:00+00'), + ('2024-12-31 23:59:59+00'), ('2024-01-01 00:00:00+00')) t(ts) +-- +ok +== +SELECT '2024-03-10 03:30:00-04'::TIMESTAMPTZ::TIMETZ +-- +ok +== +SELECT '2024-01-10 03:30:00-05'::TIMESTAMPTZ::TIMETZ +-- +ok +== +SELECT timezone('Asia/Kathmandu', '12:00:00+00'::TIMETZ) +-- +ok +== diff --git a/parser/testdata/corpus/sql/timezone/test_icu_timezone_far_future.test b/parser/testdata/corpus/sql/timezone/test_icu_timezone_far_future.test new file mode 100644 index 0000000..52583d2 --- /dev/null +++ b/parser/testdata/corpus/sql/timezone/test_icu_timezone_far_future.test @@ -0,0 +1,112 @@ +# source: test/sql/timezone/test_icu_timezone_far_future.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +SET TimeZone='America/New_York'; +-- +ok +== +SELECT '2038-01-19 03:14:07+00'::TIMESTAMPTZ; +-- +ok +== +SELECT '2038-01-19 03:14:08+00'::TIMESTAMPTZ; +-- +ok +== +SELECT '2038-01-15 12:00:00+00'::TIMESTAMPTZ, '2038-07-15 12:00:00+00'::TIMESTAMPTZ; +-- +ok +== +SELECT '2099-01-15 12:00:00+00'::TIMESTAMPTZ, '2099-07-15 12:00:00+00'::TIMESTAMPTZ; +-- +ok +== +SELECT '2500-07-15 12:00:00+00'::TIMESTAMPTZ; +-- +ok +== +SELECT '2045-03-12 06:59:59+00'::TIMESTAMPTZ, '2045-03-12 07:00:00+00'::TIMESTAMPTZ; +-- +ok +== +SELECT '2045-11-05 05:59:59+00'::TIMESTAMPTZ, '2045-11-05 06:00:00+00'::TIMESTAMPTZ; +-- +ok +== +CREATE MACRO transitions(zone) AS TABLE + WITH days(day) AS ( + SELECT '2038-01-01'::DATE + to_days(i::INTEGER) FROM range(23000) t(i) + ), offsets AS ( + SELECT day, + epoch(timezone(zone, day::TIMESTAMP + INTERVAL 12 HOUR)) - epoch(day::TIMESTAMP + INTERVAL 12 HOUR) + AS off + FROM days + ), changes AS ( + SELECT day, off, lag(off) OVER (ORDER BY day) AS previous FROM offsets + ) + SELECT day, previous > off AS starts_daylight_saving + FROM changes WHERE previous IS NOT NULL AND off <> previous; +-- +ok +== +SELECT count(*), + count(*) FILTER (WHERE dayname(day) <> 'Sunday'), + count(*) FILTER (WHERE starts_daylight_saving AND (month(day) <> 3 OR ((day(day) - 1) // 7) + 1 <> 2)), + count(*) FILTER (WHERE NOT starts_daylight_saving AND (month(day) <> 11 OR ((day(day) - 1) // 7) + 1 <> 1)) +FROM transitions('America/New_York'); +-- +ok +== +SELECT count(*), + count(*) FILTER (WHERE dayname(day) <> 'Sunday'), + count(*) FILTER (WHERE starts_daylight_saving AND (month(day) <> 3 OR day(day) + 7 <= 31)), + count(*) FILTER (WHERE NOT starts_daylight_saving AND (month(day) <> 10 OR day(day) + 7 <= 31)) +FROM transitions('Europe/Berlin'); +-- +ok +== +SELECT count(*), + count(*) FILTER (WHERE dayname(day) <> 'Sunday'), + count(DISTINCT month(day)) +FROM transitions('Australia/Sydney'); +-- +ok +== +SELECT count(*) FROM transitions('Asia/Tokyo'); +-- +ok +== +SELECT count(*) FROM transitions('Asia/Kolkata'); +-- +ok +== +SELECT year('2044-02-29 12:00:00+00'::TIMESTAMPTZ), dayofyear('2044-12-31 12:00:00+00'::TIMESTAMPTZ); +-- +ok +== +SELECT '2038-01-19 03:14:07+00'::TIMESTAMPTZ + INTERVAL 10 YEAR; +-- +ok +== +SELECT date_diff('day', '2037-01-01 00:00:00+00'::TIMESTAMPTZ, '2045-01-01 00:00:00+00'::TIMESTAMPTZ); +-- +ok +== +SELECT date_diff('year', '2000-01-01 00:00:00+00'::TIMESTAMPTZ, '2100-01-01 00:00:00+00'::TIMESTAMPTZ); +-- +ok +== +SELECT date_trunc('year', '2045-07-04 12:00:00+00'::TIMESTAMPTZ); +-- +ok +== +SELECT count(*) FROM ( + SELECT dayofweek(ts) AS dow, + lag(dayofweek(ts)) OVER (ORDER BY ts) AS previous + FROM (SELECT '2037-06-01 12:00:00+00'::TIMESTAMPTZ + to_days(i::INTEGER) AS ts FROM range(1000) t(i)) +) WHERE previous IS NOT NULL AND dow <> (previous + 1) % 7; +-- +ok +== diff --git a/parser/testdata/corpus/sql/timezone/test_icu_timezone_properties.test b/parser/testdata/corpus/sql/timezone/test_icu_timezone_properties.test new file mode 100644 index 0000000..096e92e --- /dev/null +++ b/parser/testdata/corpus/sql/timezone/test_icu_timezone_properties.test @@ -0,0 +1,50 @@ +# source: test/sql/timezone/test_icu_timezone_properties.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +CREATE TEMP TABLE windows AS +SELECT ('2015-01-01'::DATE + (y * INTERVAL 1 YEAR) + (d * INTERVAL 1 DAY))::TIMESTAMPTZ AS start, + y * 1000 + d AS id +FROM range(10) a(y), (VALUES (0),(59),(80),(100),(120),(170),(260),(280),(300),(310),(330),(364)) b(d); +-- +ok +== +CREATE TEMP TABLE instants AS +SELECT start + (h * INTERVAL 1 HOUR) AS ts, id FROM windows, range(48) c(h); +-- +ok +== +CREATE TEMP TABLE converted AS +SELECT name, id, ts, timezone(name, ts) AS local FROM pg_timezone_names(), instants; +-- +ok +== +SELECT count(*), count(DISTINCT name) FROM converted; +-- +ok +== +SELECT count(*) FILTER (WHERE timezone(name, local) <> ts), + count(*) FILTER (WHERE timezone(name, local) < ts), + max(epoch(timezone(name, local) - ts)) +FROM converted; +-- +ok +== +SELECT name, max(epoch(timezone(name, local) - ts)) shift FROM converted +WHERE timezone(name, local) <> ts GROUP BY name HAVING shift > 3600 ORDER BY 1; +-- +ok +== +SELECT count(*), min(step), max(step), count(*) FILTER (WHERE step <> 3600) +FROM (SELECT epoch(local - lag(local) OVER (PARTITION BY name, id ORDER BY ts)) AS step FROM converted) +WHERE step IS NOT NULL; +-- +ok +== +SELECT max(abs(epoch(local - ts::TIMESTAMP))), + count(*) FILTER (WHERE epoch(local - ts::TIMESTAMP) <> floor(epoch(local - ts::TIMESTAMP))) +FROM converted; +-- +ok +== diff --git a/parser/testdata/corpus/sql/topn/test_top_n.test b/parser/testdata/corpus/sql/topn/test_top_n.test new file mode 100644 index 0000000..8ac68c9 --- /dev/null +++ b/parser/testdata/corpus/sql/topn/test_top_n.test @@ -0,0 +1,37 @@ +# source: test/sql/topn/test_top_n.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +INSERT INTO test VALUES (22), (2), (7); +-- +ok +== +SELECT b FROM test ORDER BY b DESC LIMIT 2; +-- +ok +== +SELECT b FROM test ORDER BY b LIMIT 1 OFFSET 1; +-- +ok +== +SELECT b FROM test ORDER BY b LIMIT 10 +-- +ok +== +SELECT b FROM test ORDER BY b DESC LIMIT 10 +-- +ok +== +SELECT b FROM test ORDER BY b LIMIT 10 OFFSET 1; +-- +ok +== +SELECT b FROM test ORDER BY b LIMIT 10 OFFSET 10; +-- +ok +== +SELECT b FROM test ORDER BY b OFFSET 10; +-- +ok +== diff --git a/parser/testdata/corpus/sql/topn/test_top_n_distinct_row_group_pruner.test b/parser/testdata/corpus/sql/topn/test_top_n_distinct_row_group_pruner.test new file mode 100644 index 0000000..bbc1eb1 --- /dev/null +++ b/parser/testdata/corpus/sql/topn/test_top_n_distinct_row_group_pruner.test @@ -0,0 +1,29 @@ +# source: test/sql/topn/test_top_n_distinct_row_group_pruner.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +ATTACH '{TEST_DIR}/top_n_distinct_row_group_pruner_data.duckdb' AS db (ROW_GROUP_SIZE 2048) +-- +ok +== +CREATE TABLE db.t(i BIGINT) +-- +ok +== +INSERT INTO db.t SELECT 0 FROM range(2048) +-- +ok +== +INSERT INTO db.t SELECT 1 FROM range(2048) +-- +ok +== +ATTACH '{TEST_DIR}/top_n_distinct_row_group_pruner_data.duckdb' AS db +-- +ok +== +SELECT DISTINCT i FROM db.t ORDER BY 1 LIMIT 2 +-- +ok +== diff --git a/parser/testdata/corpus/sql/topn/test_top_n_lists.test b/parser/testdata/corpus/sql/topn/test_top_n_lists.test new file mode 100644 index 0000000..627ec97 --- /dev/null +++ b/parser/testdata/corpus/sql/topn/test_top_n_lists.test @@ -0,0 +1,45 @@ +# source: test/sql/topn/test_top_n_lists.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +CREATE TABLE tbl AS SELECT [i] l FROM range(1000) tbl(i) UNION ALL SELECT NULL l FROM range(3) +-- +ok +== +SELECT l FROM tbl ORDER BY l NULLS FIRST LIMIT 5 +-- +ok +== +SELECT l FROM tbl ORDER BY l NULLS LAST LIMIT 5 +-- +ok +== +SELECT l FROM tbl ORDER BY l DESC NULLS FIRST LIMIT 5 +-- +ok +== +SELECT l FROM tbl ORDER BY l DESC NULLS LAST LIMIT 5 +-- +ok +== +CREATE TABLE tbl AS SELECT NULL l FROM range(3) UNION ALL SELECT [i] l FROM range(1000) tbl(i) +-- +ok +== +CREATE TABLE tbl AS SELECT [i] l FROM range(1000) tbl(i) UNION ALL SELECT [NULL] l FROM range(3) +-- +ok +== +CREATE TABLE tbl AS SELECT [NULL] l FROM range(3) UNION ALL SELECT [i] l FROM range(1000) tbl(i) +-- +ok +== +SELECT range(i) l FROM range(10) tbl(i) ORDER BY l DESC LIMIT 3 +-- +ok +== +SELECT range(i) l FROM range(10) tbl(i) ORDER BY l ASC LIMIT 3 +-- +ok +== diff --git a/parser/testdata/corpus/sql/topn/test_top_n_medium.test b/parser/testdata/corpus/sql/topn/test_top_n_medium.test new file mode 100644 index 0000000..c8ce203 --- /dev/null +++ b/parser/testdata/corpus/sql/topn/test_top_n_medium.test @@ -0,0 +1,17 @@ +# source: test/sql/topn/test_top_n_medium.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +CREATE TABLE tbl AS SELECT i, i % 1000 j FROM range(1000000) tbl(i) +-- +ok +== +SELECT * FROM tbl ORDER BY j, i LIMIT 5 +-- +ok +== +SELECT * FROM tbl ORDER BY j DESC, i DESC LIMIT 5 +-- +ok +== diff --git a/parser/testdata/corpus/sql/topn/test_top_n_nested_struct.test b/parser/testdata/corpus/sql/topn/test_top_n_nested_struct.test new file mode 100644 index 0000000..c82adc3 --- /dev/null +++ b/parser/testdata/corpus/sql/topn/test_top_n_nested_struct.test @@ -0,0 +1,26 @@ +# source: test/sql/topn/test_top_n_nested_struct.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +CREATE TABLE nested_struct(cik BIGINT, entityName VARCHAR, a STRUCT(b STRUCT(c INT, d INT), c STRUCT(e INT, f INT))); +-- +ok +== +INSERT INTO nested_struct VALUES (42, 'entity', {'b': {'c': 42, 'd': 43}, 'c': {'e': 44, 'f': 45}}), + (142, 'entity2', {'b': {'c': 142, 'd': 143}, 'c': {'e': 144, 'f': 145}}); +-- +ok +== +select unnest(a, recursive:=true) from nested_struct limit 1 +-- +ok +== +SELECT unnest(a, recursive := true) FROM nested_struct ORDER BY a.b.c LIMIT 1 +-- +ok +== +SELECT unnest(a, recursive := true) FROM nested_struct ORDER BY a.b.c DESC LIMIT 1 +-- +ok +== diff --git a/parser/testdata/corpus/sql/topn/test_top_n_nulls_first.test b/parser/testdata/corpus/sql/topn/test_top_n_nulls_first.test new file mode 100644 index 0000000..6feb394 --- /dev/null +++ b/parser/testdata/corpus/sql/topn/test_top_n_nulls_first.test @@ -0,0 +1,21 @@ +# source: test/sql/topn/test_top_n_nulls_first.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +SELECT * FROM integers ORDER BY i NULLS FIRST LIMIT 2 +-- +ok +== +SELECT * FROM integers ORDER BY i NULLS LAST LIMIT 2 +-- +ok +== +SELECT * FROM integers ORDER BY i DESC NULLS FIRST LIMIT 2 +-- +ok +== +SELECT * FROM integers ORDER BY i DESC NULLS LAST LIMIT 2 +-- +ok +== diff --git a/parser/testdata/corpus/sql/topn/test_top_n_nulls_first_row_group_reorderer_edge_cases.test b/parser/testdata/corpus/sql/topn/test_top_n_nulls_first_row_group_reorderer_edge_cases.test new file mode 100644 index 0000000..d7e81b9 --- /dev/null +++ b/parser/testdata/corpus/sql/topn/test_top_n_nulls_first_row_group_reorderer_edge_cases.test @@ -0,0 +1,71 @@ +# source: test/sql/topn/test_top_n_nulls_first_row_group_reorderer_edge_cases.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +SET threads TO 1 +-- +ok +== +ATTACH '{TEST_DIR}/top_n_nulls_first_row_group_reorderer_edge_cases_data.duckdb' AS db (ROW_GROUP_SIZE 2048) +-- +ok +== +CREATE TABLE db.null_only_ints AS SELECT NULL::BIGINT AS i FROM range(2048) +-- +ok +== +CREATE TABLE db.mixed_ints AS +SELECT i FROM repeat(NULL::BIGINT, 1023) t(i) +UNION ALL +SELECT i FROM repeat(1::BIGINT, 1025) t(i) +-- +ok +== +CREATE TABLE db.null_only_strings AS SELECT NULL::VARCHAR AS s FROM range(2048) +-- +ok +== +CREATE TABLE db.mixed_strings AS +SELECT s FROM repeat(NULL::VARCHAR, 1023) t(s) +UNION ALL +SELECT s FROM repeat('a', 1025) t(s) +-- +ok +== +ATTACH '{TEST_DIR}/top_n_nulls_first_row_group_reorderer_edge_cases_data.duckdb' AS db +-- +ok +== +EXPLAIN ANALYZE SELECT i FROM db.null_only_ints ORDER BY i NULLS FIRST LIMIT 1 +-- +ok +== +SELECT i FROM db.null_only_ints ORDER BY i NULLS FIRST LIMIT 1 +-- +ok +== +EXPLAIN ANALYZE SELECT i FROM db.mixed_ints ORDER BY i NULLS FIRST LIMIT 1 +-- +ok +== +SELECT i FROM db.mixed_ints ORDER BY i NULLS FIRST LIMIT 1 OFFSET 1023 +-- +ok +== +EXPLAIN ANALYZE SELECT s FROM db.null_only_strings ORDER BY s NULLS FIRST LIMIT 1 +-- +ok +== +SELECT s FROM db.null_only_strings ORDER BY s NULLS FIRST LIMIT 1 +-- +ok +== +EXPLAIN ANALYZE SELECT s FROM db.mixed_strings ORDER BY s NULLS FIRST LIMIT 1 +-- +ok +== +SELECT s FROM db.mixed_strings ORDER BY s NULLS FIRST LIMIT 1 OFFSET 1023 +-- +ok +== diff --git a/parser/testdata/corpus/sql/topn/test_top_n_nulls_row_group_pruner.test b/parser/testdata/corpus/sql/topn/test_top_n_nulls_row_group_pruner.test new file mode 100644 index 0000000..f719e26 --- /dev/null +++ b/parser/testdata/corpus/sql/topn/test_top_n_nulls_row_group_pruner.test @@ -0,0 +1,16 @@ +# source: test/sql/topn/test_top_n_nulls_row_group_pruner.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +CREATE TABLE integers AS +SELECT NULL::BIGINT AS i FROM range(122881) +UNION ALL +SELECT range::BIGINT AS i FROM range(122880) +-- +ok +== +SELECT i FROM integers ORDER BY i NULLS LAST LIMIT 1 OFFSET 122880; +-- +ok +== diff --git a/parser/testdata/corpus/sql/topn/test_top_n_nulls_row_group_pruner_extensive.test b/parser/testdata/corpus/sql/topn/test_top_n_nulls_row_group_pruner_extensive.test new file mode 100644 index 0000000..a8324c9 --- /dev/null +++ b/parser/testdata/corpus/sql/topn/test_top_n_nulls_row_group_pruner_extensive.test @@ -0,0 +1,363 @@ +# source: test/sql/topn/test_top_n_nulls_row_group_pruner_extensive.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +ATTACH '{TEST_DIR}/top_n_nulls_row_group_pruner_extensive_data.duckdb' AS db (ROW_GROUP_SIZE 2048) +-- +ok +== +CREATE TABLE db.ints AS SELECT CASE WHEN i = 0 THEN 0 ELSE 3 END AS i FROM range(2048) tbl(i) +-- +ok +== +INSERT INTO db.ints SELECT CASE WHEN i = 0 THEN 0 ELSE 3 END AS i FROM range(2048) tbl(i) +-- +ok +== +INSERT INTO db.ints SELECT CASE WHEN i = 0 THEN 1 ELSE 5 END AS i FROM range(2048) tbl(i) +-- +ok +== +INSERT INTO db.ints SELECT CASE WHEN i = 2047 THEN 6 ELSE 4 END AS i FROM range(2048) tbl(i) +-- +ok +== +INSERT INTO db.ints SELECT CASE WHEN i = 0 THEN 7 ELSE 8 END AS i FROM range(2048) tbl(i) +-- +ok +== +INSERT INTO db.ints SELECT i FROM repeat(NULL, 2048) t1(i) +-- +ok +== +INSERT INTO db.ints +SELECT CASE WHEN i = 0 THEN 9 WHEN i = 2047 THEN 10 ELSE NULL END AS i FROM range(2048) tbl(i) +-- +ok +== +CREATE TABLE db.strings AS SELECT CASE WHEN i = 0 THEN 'a' ELSE 'd' END AS s FROM range(2048) tbl(i) +-- +ok +== +INSERT INTO db.strings SELECT CASE WHEN i = 0 THEN 'a' ELSE 'd' END AS s FROM range(2048) tbl(i) +-- +ok +== +INSERT INTO db.strings SELECT CASE WHEN i = 0 THEN 'b' ELSE 'f' END AS s FROM range(2048) tbl(i) +-- +ok +== +INSERT INTO db.strings SELECT CASE WHEN i = 2047 THEN 'g' ELSE 'e' END AS s FROM range(2048) tbl(i) +-- +ok +== +INSERT INTO db.strings SELECT CASE WHEN i = 0 THEN 'h' ELSE 'i' END AS s FROM range(2048) tbl(i) +-- +ok +== +INSERT INTO db.strings SELECT s FROM repeat(NULL, 2048) t1(s) +-- +ok +== +INSERT INTO db.strings +SELECT CASE WHEN i = 0 THEN 'j' WHEN i = 2047 THEN 'k' ELSE NULL END AS s FROM range(2048) tbl(i) +-- +ok +== +CREATE TABLE db.offset_boundary AS SELECT 0 AS i FROM range(2048) +-- +ok +== +INSERT INTO db.offset_boundary SELECT 1 AS i FROM range(2048) +-- +ok +== +INSERT INTO db.offset_boundary SELECT 2 AS i FROM range(2048) +-- +ok +== +INSERT INTO db.offset_boundary SELECT NULL::BIGINT FROM range(2048) +-- +ok +== +CREATE TABLE db.null_prefix_{type} AS SELECT NULL::{type} AS v FROM range(2048) +-- +error: Parser Error: syntax error at or near "{" +== +INSERT INTO db.null_prefix_{type} SELECT NULL::{type} AS v FROM range(2048) +-- +error: Parser Error: syntax error at or near "{" +== +INSERT INTO db.null_prefix_{type} SELECT CAST('1' AS {type}) AS v FROM range(2048) +-- +error: Parser Error: syntax error at or near "{" +== +INSERT INTO db.null_prefix_{type} SELECT CAST('2' AS {type}) AS v FROM range(2048) +-- +error: Parser Error: syntax error at or near "{" +== +CREATE TABLE db.null_then_values_{type} AS SELECT NULL::{type} AS v FROM range(2048) +-- +error: Parser Error: syntax error at or near "{" +== +INSERT INTO db.null_then_values_{type} SELECT NULL::{type} AS v FROM range(2048) +-- +error: Parser Error: syntax error at or near "{" +== +INSERT INTO db.null_then_values_{type} SELECT CAST('1' AS {type}) AS v FROM range(2048) +-- +error: Parser Error: syntax error at or near "{" +== +INSERT INTO db.null_then_values_{type} SELECT CAST('2' AS {type}) AS v FROM range(2048) +-- +error: Parser Error: syntax error at or near "{" +== +CREATE TABLE db.null_mixed_value_{type} AS SELECT NULL::{type} AS v FROM range(2048) +-- +error: Parser Error: syntax error at or near "{" +== +INSERT INTO db.null_mixed_value_{type} +SELECT CASE WHEN i < 1023 THEN NULL ELSE CAST('1' AS {type}) END AS v FROM range(2048) tbl(i) +-- +error: Parser Error: syntax error at or near "{" +== +INSERT INTO db.null_mixed_value_{type} SELECT CAST('2' AS {type}) AS v FROM range(2048) +-- +error: Parser Error: syntax error at or near "{" +== +CREATE TABLE db.scattered_nulls_{type} AS SELECT NULL::{type} AS v FROM range(2048) +-- +error: Parser Error: syntax error at or near "{" +== +INSERT INTO db.scattered_nulls_{type} +SELECT CASE WHEN i < 1023 THEN NULL ELSE CAST('1' AS {type}) END AS v FROM range(2048) tbl(i) +-- +error: Parser Error: syntax error at or near "{" +== +INSERT INTO db.scattered_nulls_{type} SELECT NULL::{type} AS v FROM range(2048) +-- +error: Parser Error: syntax error at or near "{" +== +INSERT INTO db.scattered_nulls_{type} SELECT CAST('2' AS {type}) AS v FROM range(2048) +-- +error: Parser Error: syntax error at or near "{" +== +CREATE TABLE db.all_null_offset_{type} AS +SELECT i FROM repeat(NULL::{type}, 2048) t(i); +-- +error: Parser Error: syntax error at or near "{" +== +INSERT INTO db.all_null_offset_{type} +SELECT i FROM repeat(NULL::{type}, 2048) t(i); +-- +error: Parser Error: syntax error at or near "{" +== +ATTACH '{TEST_DIR}/top_n_nulls_row_group_pruner_extensive_data.duckdb' AS db +-- +ok +== +EXPLAIN ANALYZE SELECT i FROM db.ints ORDER BY i NULLS LAST LIMIT 2 +-- +ok +== +SELECT i FROM db.ints ORDER BY i NULLS LAST LIMIT 2 +-- +ok +== +EXPLAIN ANALYZE SELECT i FROM db.ints ORDER BY i DESC NULLS LAST LIMIT 3 +-- +ok +== +SELECT i FROM db.ints ORDER BY i DESC NULLS LAST LIMIT 3 +-- +ok +== +EXPLAIN ANALYZE SELECT i FROM db.ints ORDER BY i NULLS FIRST LIMIT 1 +-- +ok +== +SELECT i FROM db.ints ORDER BY i NULLS FIRST LIMIT 1 +-- +ok +== +SELECT i FROM db.ints ORDER BY i NULLS LAST LIMIT 1 OFFSET 10242 +-- +ok +== +EXPLAIN ANALYZE SELECT s FROM db.strings ORDER BY s NULLS LAST LIMIT 2 +-- +ok +== +SELECT s FROM db.strings ORDER BY s NULLS LAST LIMIT 2 +-- +ok +== +EXPLAIN ANALYZE SELECT s FROM db.strings ORDER BY s DESC NULLS LAST LIMIT 3 +-- +ok +== +SELECT s FROM db.strings ORDER BY s DESC NULLS LAST LIMIT 3 +-- +ok +== +EXPLAIN ANALYZE SELECT s FROM db.strings ORDER BY s NULLS FIRST LIMIT 1 +-- +ok +== +SELECT s FROM db.strings ORDER BY s NULLS FIRST LIMIT 1 +-- +ok +== +SELECT s FROM db.strings ORDER BY s NULLS LAST LIMIT 1 OFFSET 10242 +-- +ok +== +EXPLAIN ANALYZE SELECT i FROM db.offset_boundary ORDER BY i NULLS LAST LIMIT 1 OFFSET 6144 +-- +ok +== +SELECT i FROM db.offset_boundary ORDER BY i NULLS LAST LIMIT 1 OFFSET 6144 +-- +ok +== +EXPLAIN ANALYZE SELECT v FROM db.null_prefix_BIGINT ORDER BY v NULLS FIRST LIMIT 1 OFFSET 4096 +-- +ok +== +SELECT v FROM db.null_prefix_BIGINT ORDER BY v NULLS FIRST LIMIT 1 OFFSET 4096 +-- +ok +== +EXPLAIN ANALYZE SELECT v FROM db.null_prefix_VARCHAR ORDER BY v NULLS FIRST LIMIT 1 OFFSET 4096 +-- +ok +== +SELECT v FROM db.null_prefix_VARCHAR ORDER BY v NULLS FIRST LIMIT 1 OFFSET 4096 +-- +ok +== +EXPLAIN ANALYZE SELECT v FROM db.null_then_values_BIGINT ORDER BY v NULLS FIRST LIMIT 1 OFFSET 4096 +-- +ok +== +SELECT v FROM db.null_then_values_BIGINT ORDER BY v NULLS FIRST LIMIT 1 OFFSET 4096 +-- +ok +== +EXPLAIN ANALYZE SELECT v FROM db.null_then_values_BIGINT ORDER BY v NULLS FIRST LIMIT 1 OFFSET 6144 +-- +ok +== +SELECT v FROM db.null_then_values_BIGINT ORDER BY v NULLS FIRST LIMIT 1 OFFSET 6144 +-- +ok +== +EXPLAIN ANALYZE SELECT v FROM db.null_then_values_VARCHAR ORDER BY v NULLS FIRST LIMIT 1 OFFSET 4096 +-- +ok +== +SELECT v FROM db.null_then_values_VARCHAR ORDER BY v NULLS FIRST LIMIT 1 OFFSET 4096 +-- +ok +== +EXPLAIN ANALYZE SELECT v FROM db.null_then_values_VARCHAR ORDER BY v NULLS FIRST LIMIT 1 OFFSET 6144 +-- +ok +== +SELECT v FROM db.null_then_values_VARCHAR ORDER BY v NULLS FIRST LIMIT 1 OFFSET 6144 +-- +ok +== +EXPLAIN ANALYZE SELECT v FROM db.null_mixed_value_BIGINT ORDER BY v NULLS FIRST LIMIT 1 OFFSET 2048 +-- +ok +== +SELECT v FROM db.null_mixed_value_BIGINT ORDER BY v NULLS FIRST LIMIT 1 OFFSET 2048 +-- +ok +== +EXPLAIN ANALYZE SELECT v FROM db.null_mixed_value_VARCHAR ORDER BY v NULLS FIRST LIMIT 1 OFFSET 2048 +-- +ok +== +SELECT v FROM db.null_mixed_value_VARCHAR ORDER BY v NULLS FIRST LIMIT 1 OFFSET 2048 +-- +ok +== +EXPLAIN ANALYZE SELECT v FROM db.scattered_nulls_BIGINT ORDER BY v NULLS FIRST LIMIT 1 OFFSET 4096 +-- +ok +== +SELECT v FROM db.scattered_nulls_BIGINT ORDER BY v NULLS FIRST LIMIT 1 OFFSET 4096 +-- +ok +== +EXPLAIN ANALYZE SELECT v FROM db.scattered_nulls_VARCHAR ORDER BY v NULLS FIRST LIMIT 1 OFFSET 4096 +-- +ok +== +SELECT v FROM db.scattered_nulls_VARCHAR ORDER BY v NULLS FIRST LIMIT 1 OFFSET 4096 +-- +ok +== +EXPLAIN ANALYZE +SELECT i +FROM db.all_null_offset_BIGINT +ORDER BY i NULLS FIRST +LIMIT 1 OFFSET 4096; +-- +ok +== +SELECT i +FROM db.all_null_offset_BIGINT +ORDER BY i NULLS FIRST +LIMIT 1 OFFSET 4096; +-- +ok +== +EXPLAIN ANALYZE +SELECT i +FROM db.all_null_offset_BIGINT +ORDER BY i NULLS FIRST +LIMIT 1 OFFSET 4095; +-- +ok +== +SELECT i +FROM db.all_null_offset_BIGINT +ORDER BY i NULLS FIRST +LIMIT 1 OFFSET 4095; +-- +ok +== +EXPLAIN ANALYZE +SELECT i +FROM db.all_null_offset_VARCHAR +ORDER BY i NULLS FIRST +LIMIT 1 OFFSET 4096; +-- +ok +== +SELECT i +FROM db.all_null_offset_VARCHAR +ORDER BY i NULLS FIRST +LIMIT 1 OFFSET 4096; +-- +ok +== +EXPLAIN ANALYZE +SELECT i +FROM db.all_null_offset_VARCHAR +ORDER BY i NULLS FIRST +LIMIT 1 OFFSET 4095; +-- +ok +== +SELECT i +FROM db.all_null_offset_VARCHAR +ORDER BY i NULLS FIRST +LIMIT 1 OFFSET 4095; +-- +ok +== diff --git a/parser/testdata/corpus/sql/topn/test_top_n_nulls_small.test b/parser/testdata/corpus/sql/topn/test_top_n_nulls_small.test new file mode 100644 index 0000000..772f649 --- /dev/null +++ b/parser/testdata/corpus/sql/topn/test_top_n_nulls_small.test @@ -0,0 +1,65 @@ +# source: test/sql/topn/test_top_n_nulls_small.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +CREATE TABLE integers AS SELECT i, i j FROM range(1000) tbl(i) UNION ALL SELECT NULL i, range j FROM range(1000) +-- +ok +== +SELECT i FROM integers ORDER BY i ASC NULLS FIRST LIMIT 5; +-- +ok +== +SELECT i FROM integers ORDER BY i ASC NULLS LAST LIMIT 5; +-- +ok +== +SELECT i FROM integers ORDER BY i DESC NULLS FIRST LIMIT 5; +-- +ok +== +SELECT i FROM integers ORDER BY i DESC NULLS LAST LIMIT 5; +-- +ok +== +SELECT i FROM integers ORDER BY i NULLS FIRST LIMIT 5 OFFSET 1000; +-- +ok +== +SELECT i FROM integers ORDER BY i DESC NULLS FIRST LIMIT 5 OFFSET 1000; +-- +ok +== +SELECT i FROM integers ORDER BY i NULLS LAST LIMIT 5 OFFSET 1000; +-- +ok +== +SELECT j, i FROM integers ORDER BY j, i NULLS FIRST LIMIT 5; +-- +ok +== +SELECT j, i FROM integers ORDER BY j, i NULLS LAST LIMIT 5; +-- +ok +== +SELECT j, i FROM integers ORDER BY j DESC, i DESC NULLS FIRST LIMIT 5; +-- +ok +== +SELECT j, i FROM integers ORDER BY j DESC, i DESC NULLS LAST LIMIT 5; +-- +ok +== +SELECT i, j FROM integers ORDER BY i DESC NULLS FIRST, j DESC LIMIT 5; +-- +ok +== +SELECT i, j FROM integers ORDER BY i DESC NULLS LAST, j ASC LIMIT 5; +-- +ok +== +CREATE TABLE integers AS SELECT NULL i, i j FROM range(1000) tbl(i) UNION ALL SELECT range i, range j FROM range(1000) +-- +ok +== diff --git a/parser/testdata/corpus/sql/topn/test_top_n_offset_no_limit_pruner.test b/parser/testdata/corpus/sql/topn/test_top_n_offset_no_limit_pruner.test new file mode 100644 index 0000000..bf0c990 --- /dev/null +++ b/parser/testdata/corpus/sql/topn/test_top_n_offset_no_limit_pruner.test @@ -0,0 +1,25 @@ +# source: test/sql/topn/test_top_n_offset_no_limit_pruner.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +CREATE TABLE t AS SELECT range AS id FROM range(300000) +-- +ok +== +SELECT COUNT(*) FROM (SELECT id FROM t ORDER BY id OFFSET 0) +-- +ok +== +SELECT COUNT(*) FROM (SELECT id FROM t ORDER BY id OFFSET 200000) +-- +ok +== +SELECT MAX(id) FROM (SELECT id FROM t ORDER BY id OFFSET 200000) +-- +ok +== +SELECT COUNT(*) FROM (SELECT id FROM t ORDER BY id LIMIT 100000000 OFFSET 200000) +-- +ok +== diff --git a/parser/testdata/corpus/sql/topn/test_top_n_structs.test b/parser/testdata/corpus/sql/topn/test_top_n_structs.test new file mode 100644 index 0000000..7e10e93 --- /dev/null +++ b/parser/testdata/corpus/sql/topn/test_top_n_structs.test @@ -0,0 +1,13 @@ +# source: test/sql/topn/test_top_n_structs.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +CREATE TABLE tbl AS SELECT {'i': i} l FROM range(1000) tbl(i) UNION ALL SELECT NULL l FROM range(3) +-- +ok +== +CREATE TABLE tbl AS SELECT NULL l FROM range(3) UNION ALL SELECT {'i': i} l FROM range(1000) tbl(i) +-- +ok +== diff --git a/parser/testdata/corpus/sql/topn/top_n_materialization.test b/parser/testdata/corpus/sql/topn/top_n_materialization.test new file mode 100644 index 0000000..5acc0f1 --- /dev/null +++ b/parser/testdata/corpus/sql/topn/top_n_materialization.test @@ -0,0 +1,21 @@ +# source: test/sql/topn/top_n_materialization.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +CREATE TABLE test AS SELECT i, i + 1 AS j, i + 2 AS k, -i AS l FROM range(10) t(i); +-- +ok +== +CREATE OR REPLACE TABLE test AS SELECT i, printf('%02d', i + 1) AS j, printf('%02d', i + 2) AS k, -i AS l FROM range(10) t(i); +-- +ok +== +SET late_materialization_max_rows=0 +-- +ok +== +RESET late_materialization_max_rows +-- +ok +== diff --git a/parser/testdata/corpus/sql/topn/top_n_pruning.test b/parser/testdata/corpus/sql/topn/top_n_pruning.test new file mode 100644 index 0000000..088ba86 --- /dev/null +++ b/parser/testdata/corpus/sql/topn/top_n_pruning.test @@ -0,0 +1,128 @@ +# source: test/sql/topn/top_n_pruning.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +ATTACH '{TEST_DIR}/top_n_hard_limit.duckdb' AS db (ROW_GROUP_SIZE 2048) +-- +ok +== +CREATE TABLE t( + generated_col AS (i + 1), + i BIGINT +); +-- +ok +== +INSERT INTO t SELECT 0 i UNION ALL SELECT i FROM repeat(3, 2047) t1(i) +-- +ok +== +INSERT INTO t SELECT 1 i UNION ALL SELECT i FROM repeat(5, 2047) t1(i) +-- +ok +== +INSERT INTO t SELECT i FROM repeat(4, 2047) t1(i) UNION ALL SELECT 6 i +-- +ok +== +INSERT INTO t SELECT 7 i UNION ALL SELECT i FROM repeat(8, 2047) t1(i) +-- +ok +== +INSERT INTO t SELECT i FROM repeat(NULL, 2000000) t1(i) +-- +ok +== +ATTACH '{TEST_DIR}/tmp.duckdb' AS tmp +-- +ok +== +USE tmp +-- +ok +== +DETACH tmp +-- +ok +== +EXPLAIN ANALYZE SELECT * FROM t ORDER BY i LIMIT 2 +-- +ok +== +EXPLAIN ANALYZE SELECT * FROM t ORDER BY i LIMIT 3 +-- +ok +== +EXPLAIN ANALYZE SELECT * FROM t ORDER BY i LIMIT 4097 +-- +ok +== +EXPLAIN ANALYZE SELECT * FROM t ORDER BY i LIMIT 4098 +-- +ok +== +EXPLAIN ANALYZE SELECT * FROM t ORDER BY i LIMIT 8192 +-- +ok +== +EXPLAIN ANALYZE SELECT * FROM t ORDER BY i LIMIT 8193 +-- +ok +== +EXPLAIN ANALYZE SELECT * FROM t ORDER BY i DESC LIMIT 2048 +-- +ok +== +EXPLAIN ANALYZE SELECT * FROM t ORDER BY i DESC LIMIT 2049 +-- +ok +== +EXPLAIN ANALYZE SELECT * FROM t ORDER BY i DESC LIMIT 2050 +-- +ok +== +EXPLAIN ANALYZE SELECT * FROM t ORDER BY i DESC LIMIT 4096 +-- +ok +== +EXPLAIN ANALYZE SELECT * FROM t ORDER BY i DESC LIMIT 4097 +-- +ok +== +EXPLAIN ANALYZE SELECT * FROM t ORDER BY i DESC LIMIT 6143 +-- +ok +== +EXPLAIN ANALYZE SELECT * FROM t ORDER BY i DESC LIMIT 6144 +-- +ok +== +EXPLAIN ANALYZE SELECT * FROM t ORDER BY i DESC LIMIT 8190 +-- +ok +== +EXPLAIN ANALYZE SELECT * FROM t ORDER BY i DESC LIMIT 8191 +-- +ok +== +EXPLAIN ANALYZE SELECT * FROM t ORDER BY i LIMIT 1 OFFSET 1 +-- +ok +== +EXPLAIN ANALYZE SELECT * FROM t ORDER BY i LIMIT 1 OFFSET 2 +-- +ok +== +INSERT INTO t SELECT 9 i UNION ALL SELECT i FROM repeat(NULL, 2046) t1(i) UNION ALL SELECT 10 i +-- +ok +== +EXPLAIN ANALYZE SELECT i FROM t ORDER by i DESC LIMIT 3 +-- +ok +== +SELECT i FROM t ORDER BY i DESC LIMIT 3 +-- +ok +== diff --git a/parser/testdata/corpus/sql/topn/topn_nulls_first.test b/parser/testdata/corpus/sql/topn/topn_nulls_first.test new file mode 100644 index 0000000..8e04313 --- /dev/null +++ b/parser/testdata/corpus/sql/topn/topn_nulls_first.test @@ -0,0 +1,23 @@ +# source: test/sql/topn/topn_nulls_first.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +CREATE TABLE topn_nulls(v INTEGER) +-- +ok +== +INSERT INTO topn_nulls +SELECT CASE WHEN i % 3 = 0 THEN NULL ELSE i END +FROM range(12) tbl(i) +-- +ok +== +EXPLAIN SELECT v FROM topn_nulls ORDER BY v NULLS FIRST LIMIT 6; +-- +ok +== +SELECT v FROM topn_nulls ORDER BY v NULLS FIRST LIMIT 6; +-- +ok +== diff --git a/parser/testdata/corpus/sql/topn/tpcds_q14_topn.test b/parser/testdata/corpus/sql/topn/tpcds_q14_topn.test new file mode 100644 index 0000000..801cfda --- /dev/null +++ b/parser/testdata/corpus/sql/topn/tpcds_q14_topn.test @@ -0,0 +1,49 @@ +# source: test/sql/topn/tpcds_q14_topn.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +CREATE TABLE final(channel VARCHAR, i_brand_id INTEGER, i_class_id INTEGER, i_category_id INTEGER, sum_sales DECIMAL(38,2), number_sales HUGEINT); +-- +ok +== +COPY final FROM '{DATA_DIR}/csv/tpcds_14.csv' (FORMAT CSV, DELIMITER '|', HEADER); +-- +ok +== +SELECT * FROM final +ORDER BY channel NULLS FIRST, + i_brand_id NULLS FIRST, + i_class_id NULLS FIRST, + i_category_id NULLS FIRST +LIMIT 100; +-- +ok +== +SELECT * FROM final +ORDER BY channel DESC NULLS FIRST, + i_brand_id DESC NULLS FIRST, + i_class_id DESC NULLS FIRST, + i_category_id DESC NULLS FIRST +LIMIT 100; +-- +ok +== +SELECT * FROM final +ORDER BY channel NULLS LAST, + i_brand_id NULLS LAST, + i_class_id NULLS LAST, + i_category_id NULLS LAST +LIMIT 100; +-- +ok +== +SELECT * FROM final +ORDER BY channel DESC NULLS LAST, + i_brand_id DESC NULLS LAST, + i_class_id DESC NULLS LAST, + i_category_id DESC NULLS LAST +LIMIT 100; +-- +ok +== diff --git a/parser/testdata/corpus/sql/topn/tpcds_q59_topn.test b/parser/testdata/corpus/sql/topn/tpcds_q59_topn.test new file mode 100644 index 0000000..f82b9b6 --- /dev/null +++ b/parser/testdata/corpus/sql/topn/tpcds_q59_topn.test @@ -0,0 +1,22 @@ +# source: test/sql/topn/tpcds_q59_topn.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +CREATE TABLE final(s_store_name1 VARCHAR, s_store_id1 VARCHAR, d_week_seq1 INTEGER, "sun_sales1 / sun_sales2" DOUBLE, "mon_sales1 / mon_sales2" DOUBLE, "tue_sales1 / tue_sales2" DOUBLE, "wed_sales1 / wed_sales2" DOUBLE, "thu_sales1 / thu_sales2" DOUBLE, "fri_sales1 / fri_sales2" DOUBLE, "sat_sales1 / sat_sales2" DOUBLE); +-- +ok +== +COPY final FROM '{DATA_DIR}/csv/tpcds_59.csv' (FORMAT CSV, DELIMITER '|', HEADER); +-- +ok +== +SELECT * +FROM final +ORDER BY s_store_name1 NULLS FIRST, + s_store_id1 NULLS FIRST, + d_week_seq1 NULLS FIRST +LIMIT 100; +-- +ok +== diff --git a/parser/testdata/corpus/sql/tpcds/dsdgen_readonly.test b/parser/testdata/corpus/sql/tpcds/dsdgen_readonly.test new file mode 100644 index 0000000..12db7f4 --- /dev/null +++ b/parser/testdata/corpus/sql/tpcds/dsdgen_readonly.test @@ -0,0 +1,17 @@ +# source: test/sql/tpcds/dsdgen_readonly.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +CALL dsdgen(sf=0); +-- +ok +== +ATTACH '{TEST_DIR}/test_dsdgen_ro.db' AS dsdgentest (READ_ONLY) +-- +ok +== +CALL dsdgen(sf=0, catalog='dsdgentest'); +-- +ok +== diff --git a/parser/testdata/corpus/sql/tpcds/dsdgen_sync_scan.test b/parser/testdata/corpus/sql/tpcds/dsdgen_sync_scan.test new file mode 100644 index 0000000..b1074dc --- /dev/null +++ b/parser/testdata/corpus/sql/tpcds/dsdgen_sync_scan.test @@ -0,0 +1,17 @@ +# source: test/sql/tpcds/dsdgen_sync_scan.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +SET debug_physical_table_scan_execution_strategy=SYNCHRONOUS; +-- +ok +== +CALL dsdgen(sf=0.01, suffix='_sync_scan'); +-- +ok +== +SET debug_physical_table_scan_execution_strategy=DEFAULT; +-- +ok +== diff --git a/parser/testdata/corpus/sql/tpcds/tpcds_sf0.test b/parser/testdata/corpus/sql/tpcds/tpcds_sf0.test new file mode 100644 index 0000000..050def5 --- /dev/null +++ b/parser/testdata/corpus/sql/tpcds/tpcds_sf0.test @@ -0,0 +1,37 @@ +# source: test/sql/tpcds/tpcds_sf0.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +CALL dsdgen(sf=0) +-- +ok +== +PRAGMA tpcds({i}) +-- +error: Parser Error: syntax error at or near "}" +== +PRAGMA tpcds(-1) +-- +ok +== +PRAGMA tpcds(3290819023812038903) +-- +ok +== +PRAGMA tpcds(32908301298) +-- +ok +== +PRAGMA tpcds(1.1) +-- +ok +== +PRAGMA tpcds(NULL) +-- +ok +== +SELECT * FROM tpcds_queries() +-- +ok +== diff --git a/parser/testdata/corpus/sql/tpch/dbgen_readonly.test b/parser/testdata/corpus/sql/tpch/dbgen_readonly.test new file mode 100644 index 0000000..d9eae44 --- /dev/null +++ b/parser/testdata/corpus/sql/tpch/dbgen_readonly.test @@ -0,0 +1,17 @@ +# source: test/sql/tpch/dbgen_readonly.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +CALL dbgen(sf=0); +-- +ok +== +ATTACH '{TEST_DIR}/test_dbgen_ro.db' AS dbgentest (READ_ONLY) +-- +ok +== +CALL dbgen(sf=0, catalog='dbgentest'); +-- +ok +== diff --git a/parser/testdata/corpus/sql/tpch/tpch_sf0.test b/parser/testdata/corpus/sql/tpch/tpch_sf0.test new file mode 100644 index 0000000..4dcdd86 --- /dev/null +++ b/parser/testdata/corpus/sql/tpch/tpch_sf0.test @@ -0,0 +1,29 @@ +# source: test/sql/tpch/tpch_sf0.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +PRAGMA tpch({i}) +-- +error: Parser Error: syntax error at or near "}" +== +PRAGMA tpch(-1) +-- +ok +== +PRAGMA tpch(3290819023812038903) +-- +ok +== +PRAGMA tpch(32908301298) +-- +ok +== +PRAGMA tpch(1.1) +-- +ok +== +PRAGMA tpch(NULL) +-- +ok +== diff --git a/parser/testdata/corpus/sql/transactions/aborted_transaction_commit.test b/parser/testdata/corpus/sql/transactions/aborted_transaction_commit.test new file mode 100644 index 0000000..cea9218 --- /dev/null +++ b/parser/testdata/corpus/sql/transactions/aborted_transaction_commit.test @@ -0,0 +1,17 @@ +# source: test/sql/transactions/aborted_transaction_commit.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +CREATE TABLE keys(i INTEGER PRIMARY KEY); +-- +ok +== +INSERT INTO keys VALUES (1); +-- +ok +== +SELECT COUNT(*) FROM keys +-- +ok +== diff --git a/parser/testdata/corpus/sql/transactions/commit_revert_failure.test b/parser/testdata/corpus/sql/transactions/commit_revert_failure.test new file mode 100644 index 0000000..8f0d3eb --- /dev/null +++ b/parser/testdata/corpus/sql/transactions/commit_revert_failure.test @@ -0,0 +1,41 @@ +# source: test/sql/transactions/commit_revert_failure.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +SET debug_force_commit_failure=true; +-- +ok +== +INSERT INTO t VALUES (4); +-- +ok +== +UPDATE t SET i = i + 100 WHERE i = 1; +-- +ok +== +DELETE FROM t WHERE i = 2; +-- +ok +== +SET debug_force_commit_failure=false; +-- +ok +== +SELECT i FROM t ORDER BY i +-- +ok +== +INSERT INTO t VALUES (5); +-- +ok +== +SET debug_force_commit_revert_failure=true; +-- +ok +== +INSERT INTO t VALUES (6); +-- +ok +== diff --git a/parser/testdata/corpus/sql/transactions/concurrent_drop_index.test b/parser/testdata/corpus/sql/transactions/concurrent_drop_index.test new file mode 100644 index 0000000..562b3a9 --- /dev/null +++ b/parser/testdata/corpus/sql/transactions/concurrent_drop_index.test @@ -0,0 +1,33 @@ +# source: test/sql/transactions/concurrent_drop_index.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +CREATE TABLE t1 (id INTEGER, val INTEGER) +-- +ok +== +INSERT INTO t1 SELECT i, i * 10 FROM range(10) tbl(i) +-- +ok +== +CREATE INDEX idx1 ON t1(id) +-- +ok +== +SELECT id FROM t1 WHERE id = 5 +-- +ok +== +EXPLAIN ANALYZE SELECT id FROM t1 WHERE id = 5 +-- +ok +== +DROP INDEX idx1 +-- +ok +== +SELECT COUNT(*) FROM duckdb_indexes WHERE index_name = 'idx1' +-- +ok +== diff --git a/parser/testdata/corpus/sql/transactions/concurrent_drop_table.test b/parser/testdata/corpus/sql/transactions/concurrent_drop_table.test new file mode 100644 index 0000000..ea3fcab --- /dev/null +++ b/parser/testdata/corpus/sql/transactions/concurrent_drop_table.test @@ -0,0 +1,41 @@ +# source: test/sql/transactions/concurrent_drop_table.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +CREATE TABLE t (id INTEGER PRIMARY KEY) +-- +ok +== +INSERT INTO t SELECT range FROM range(10) +-- +ok +== +SELECT id FROM t WHERE id = 5 +-- +ok +== +SELECT memory_usage_bytes > 0 FROM duckdb_memory() WHERE tag = 'ART_INDEX' +-- +ok +== +SELECT used_blocks > 1 FROM pragma_database_size() +-- +ok +== +DROP TABLE t +-- +ok +== +EXPLAIN ANALYZE SELECT id FROM t WHERE id = 5 +-- +ok +== +SELECT memory_usage_bytes FROM duckdb_memory() WHERE tag = 'ART_INDEX' +-- +ok +== +SELECT used_blocks FROM pragma_database_size() +-- +ok +== diff --git a/parser/testdata/corpus/sql/transactions/conflict_drop_then_delete.test b/parser/testdata/corpus/sql/transactions/conflict_drop_then_delete.test new file mode 100644 index 0000000..9baff94 --- /dev/null +++ b/parser/testdata/corpus/sql/transactions/conflict_drop_then_delete.test @@ -0,0 +1,23 @@ +# source: test/sql/transactions/conflict_drop_then_delete.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +create or replace table original_table as from range(10) select 1 as col +-- +ok +== +create table new_incremental as + from range(10000) + select 42 as col +-- +ok +== +drop table original_table +-- +ok +== +delete from original_table where rowid % 2 = 0 +-- +ok +== diff --git a/parser/testdata/corpus/sql/transactions/conflict_rename_append.test b/parser/testdata/corpus/sql/transactions/conflict_rename_append.test new file mode 100644 index 0000000..efa9368 --- /dev/null +++ b/parser/testdata/corpus/sql/transactions/conflict_rename_append.test @@ -0,0 +1,31 @@ +# source: test/sql/transactions/conflict_rename_append.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +insert into original_table + from new_incremental +-- +ok +== +drop table new_incremental +-- +ok +== +alter table original_table rename to backup_table +-- +ok +== +create table temp_table as + from range(100) select 2 as col +-- +ok +== +alter table temp_table rename to original_table +-- +ok +== +drop table backup_table +-- +ok +== diff --git a/parser/testdata/corpus/sql/transactions/count_star_transactions.test b/parser/testdata/corpus/sql/transactions/count_star_transactions.test new file mode 100644 index 0000000..da78bf2 --- /dev/null +++ b/parser/testdata/corpus/sql/transactions/count_star_transactions.test @@ -0,0 +1,25 @@ +# source: test/sql/transactions/count_star_transactions.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +CREATE TABLE tbl (id INT); +-- +ok +== +INSERT INTO tbl FROM range(10000); +-- +ok +== +DELETE FROM tbl WHERE id%2=0 +-- +ok +== +SELECT COUNT(*), COUNT(*) + 1 FROM tbl +-- +ok +== +INSERT INTO tbl FROM range(10000, 15000) +-- +ok +== diff --git a/parser/testdata/corpus/sql/transactions/delete_and_drop_in_same_transaction.test b/parser/testdata/corpus/sql/transactions/delete_and_drop_in_same_transaction.test new file mode 100644 index 0000000..d2e73ff --- /dev/null +++ b/parser/testdata/corpus/sql/transactions/delete_and_drop_in_same_transaction.test @@ -0,0 +1,23 @@ +# source: test/sql/transactions/delete_and_drop_in_same_transaction.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +CREATE OR REPLACE TABLE SampleTable AS +SELECT DISTINCT id +FROM (VALUES + ('one'), + ('two'), + ('three') +) AS t(id); +-- +ok +== +DELETE FROM sampletable; +-- +ok +== +DROP TABLE SampleTable; +-- +ok +== diff --git a/parser/testdata/corpus/sql/transactions/delete_index_lookup_transactions.test b/parser/testdata/corpus/sql/transactions/delete_index_lookup_transactions.test new file mode 100644 index 0000000..0b4ff38 --- /dev/null +++ b/parser/testdata/corpus/sql/transactions/delete_index_lookup_transactions.test @@ -0,0 +1,21 @@ +# source: test/sql/transactions/delete_index_lookup_transactions.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +INSERT INTO tbl VALUES (5, 'con2 payload'); +-- +ok +== +SELECT id, payload FROM tbl WHERE id = 1 ORDER BY ALL; +-- +ok +== +SELECT id, payload FROM tbl WHERE id = 5 ORDER BY ALL; +-- +ok +== +SELECT id, payload, rowid FROM tbl WHERE id = 1 ORDER BY ALL; +-- +ok +== diff --git a/parser/testdata/corpus/sql/transactions/min_max_deletes.test b/parser/testdata/corpus/sql/transactions/min_max_deletes.test new file mode 100644 index 0000000..9307b22 --- /dev/null +++ b/parser/testdata/corpus/sql/transactions/min_max_deletes.test @@ -0,0 +1,9 @@ +# source: test/sql/transactions/min_max_deletes.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +SELECT min(id), max(id) FROM tbl +-- +ok +== diff --git a/parser/testdata/corpus/sql/transactions/min_max_updates.test b/parser/testdata/corpus/sql/transactions/min_max_updates.test new file mode 100644 index 0000000..b01a08a --- /dev/null +++ b/parser/testdata/corpus/sql/transactions/min_max_updates.test @@ -0,0 +1,17 @@ +# source: test/sql/transactions/min_max_updates.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +INSERT INTO tbl FROM range(10); +-- +ok +== +UPDATE tbl SET i=i+100 +-- +ok +== +SELECT MIN(i), MAX(i) FROM tbl +-- +ok +== diff --git a/parser/testdata/corpus/sql/transactions/revert_commit_index_corruption_drop_table.test b/parser/testdata/corpus/sql/transactions/revert_commit_index_corruption_drop_table.test new file mode 100644 index 0000000..ad7c987 --- /dev/null +++ b/parser/testdata/corpus/sql/transactions/revert_commit_index_corruption_drop_table.test @@ -0,0 +1,41 @@ +# source: test/sql/transactions/revert_commit_index_corruption_drop_table.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +CREATE TABLE t1 (id INTEGER PRIMARY KEY, val INTEGER) +-- +ok +== +INSERT INTO t1 SELECT i, i * 10 FROM range(1000) tbl(i) +-- +ok +== +CREATE TABLE t2 (id INTEGER PRIMARY KEY, val INTEGER) +-- +ok +== +INSERT INTO t2 SELECT i, i * 10 FROM range(1000) tbl(i) +-- +ok +== +DELETE FROM t2 WHERE id < 500 +-- +ok +== +SELECT id, val FROM t1 WHERE id = 42 +-- +ok +== +INSERT INTO t1 VALUES (42, 999) +-- +ok +== +SELECT id, val FROM t1 WHERE val = 7000 +-- +ok +== +SELECT id, val FROM t1 WHERE id = 700 +-- +ok +== diff --git a/parser/testdata/corpus/sql/transactions/rollback_drop.test b/parser/testdata/corpus/sql/transactions/rollback_drop.test new file mode 100644 index 0000000..68c89c7 --- /dev/null +++ b/parser/testdata/corpus/sql/transactions/rollback_drop.test @@ -0,0 +1,13 @@ +# source: test/sql/transactions/rollback_drop.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +DROP TABLE original_table +-- +ok +== +SELECT COUNT(*) FROM original_table; +-- +ok +== diff --git a/parser/testdata/corpus/sql/transactions/rollback_drop_column.test b/parser/testdata/corpus/sql/transactions/rollback_drop_column.test new file mode 100644 index 0000000..ec762fd --- /dev/null +++ b/parser/testdata/corpus/sql/transactions/rollback_drop_column.test @@ -0,0 +1,29 @@ +# source: test/sql/transactions/rollback_drop_column.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +CREATE TABLE t1 (id INTEGER, val INTEGER, extra VARCHAR) +-- +ok +== +INSERT INTO t1 SELECT i, i, repeat(md5(i::VARCHAR), 200) FROM range(100) tbl(i) +-- +ok +== +CREATE TABLE t2 (id INTEGER) +-- +ok +== +INSERT INTO t2 SELECT i FROM range(10) tbl(i) +-- +ok +== +DELETE FROM t2 WHERE id < 5 +-- +ok +== +ALTER TABLE t2 ADD COLUMN x INTEGER +-- +ok +== diff --git a/parser/testdata/corpus/sql/transactions/rollback_drop_index.test b/parser/testdata/corpus/sql/transactions/rollback_drop_index.test new file mode 100644 index 0000000..e242e30 --- /dev/null +++ b/parser/testdata/corpus/sql/transactions/rollback_drop_index.test @@ -0,0 +1,9 @@ +# source: test/sql/transactions/rollback_drop_index.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +SELECT index_name FROM duckdb_indexes WHERE index_name = 'idx1' +-- +ok +== diff --git a/parser/testdata/corpus/sql/transactions/rollback_drop_table.test b/parser/testdata/corpus/sql/transactions/rollback_drop_table.test new file mode 100644 index 0000000..b12dae5 --- /dev/null +++ b/parser/testdata/corpus/sql/transactions/rollback_drop_table.test @@ -0,0 +1,13 @@ +# source: test/sql/transactions/rollback_drop_table.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +CREATE TABLE t1 (id INTEGER) +-- +ok +== +INSERT INTO t1 SELECT i FROM range(10) tbl(i) +-- +ok +== diff --git a/parser/testdata/corpus/sql/transactions/rollback_drop_table_with_delete.test b/parser/testdata/corpus/sql/transactions/rollback_drop_table_with_delete.test new file mode 100644 index 0000000..c16a9c8 --- /dev/null +++ b/parser/testdata/corpus/sql/transactions/rollback_drop_table_with_delete.test @@ -0,0 +1,21 @@ +# source: test/sql/transactions/rollback_drop_table_with_delete.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +CREATE TABLE t1 (id INTEGER PRIMARY KEY) +-- +ok +== +DELETE FROM t1 WHERE id < 5 +-- +ok +== +SELECT * from t1 LIMIT 1 +-- +ok +== +INSERT INTO t1 VALUES (5) +-- +ok +== diff --git a/parser/testdata/corpus/sql/transactions/statement-preprocessor/invalidation_policy_is_respected_by_preprocessor.test b/parser/testdata/corpus/sql/transactions/statement-preprocessor/invalidation_policy_is_respected_by_preprocessor.test new file mode 100644 index 0000000..1966ef0 --- /dev/null +++ b/parser/testdata/corpus/sql/transactions/statement-preprocessor/invalidation_policy_is_respected_by_preprocessor.test @@ -0,0 +1,17 @@ +# source: test/sql/transactions/statement-preprocessor/invalidation_policy_is_respected_by_preprocessor.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +CREATE OR REPLACE TABLE t AS SELECT range::INT AS id FROM range(10); +-- +ok +== +SELECT nonexistent_column FROM t; +-- +ok +== +from t; +-- +ok +== diff --git a/parser/testdata/corpus/sql/transactions/statement-preprocessor/multistatement_is_transactional.test b/parser/testdata/corpus/sql/transactions/statement-preprocessor/multistatement_is_transactional.test new file mode 100644 index 0000000..1119b63 --- /dev/null +++ b/parser/testdata/corpus/sql/transactions/statement-preprocessor/multistatement_is_transactional.test @@ -0,0 +1,9 @@ +# source: test/sql/transactions/statement-preprocessor/multistatement_is_transactional.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +ALTER TABLE t ADD COLUMN d TIMESTAMP WITH TIME ZONE DEFAULT non_existent_function(); +-- +ok +== diff --git a/parser/testdata/corpus/sql/transactions/statement-preprocessor/multistatement_is_transactional_after_BEGIN_chained_COMMIT.test b/parser/testdata/corpus/sql/transactions/statement-preprocessor/multistatement_is_transactional_after_BEGIN_chained_COMMIT.test new file mode 100644 index 0000000..4383a27 --- /dev/null +++ b/parser/testdata/corpus/sql/transactions/statement-preprocessor/multistatement_is_transactional_after_BEGIN_chained_COMMIT.test @@ -0,0 +1,9 @@ +# source: test/sql/transactions/statement-preprocessor/multistatement_is_transactional_after_BEGIN_chained_COMMIT.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +ALTER TABLE t ADD COLUMN d TIMESTAMP WITH TIME ZONE DEFAULT non_existent_function(); COMMIT; +-- +ok +== diff --git a/parser/testdata/corpus/sql/transactions/statement-preprocessor/multistatement_is_transactional_chained_BEGIN.test b/parser/testdata/corpus/sql/transactions/statement-preprocessor/multistatement_is_transactional_chained_BEGIN.test new file mode 100644 index 0000000..6ede296 --- /dev/null +++ b/parser/testdata/corpus/sql/transactions/statement-preprocessor/multistatement_is_transactional_chained_BEGIN.test @@ -0,0 +1,9 @@ +# source: test/sql/transactions/statement-preprocessor/multistatement_is_transactional_chained_BEGIN.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +BEGIN TRANSACTION; ALTER TABLE t ADD COLUMN d TIMESTAMP WITH TIME ZONE DEFAULT non_existent_function(); +-- +ok +== diff --git a/parser/testdata/corpus/sql/transactions/statement-preprocessor/multistatement_is_transactional_chained_BEGIN_body_COMMIT.test b/parser/testdata/corpus/sql/transactions/statement-preprocessor/multistatement_is_transactional_chained_BEGIN_body_COMMIT.test new file mode 100644 index 0000000..dde8b85 --- /dev/null +++ b/parser/testdata/corpus/sql/transactions/statement-preprocessor/multistatement_is_transactional_chained_BEGIN_body_COMMIT.test @@ -0,0 +1,9 @@ +# source: test/sql/transactions/statement-preprocessor/multistatement_is_transactional_chained_BEGIN_body_COMMIT.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +BEGIN TRANSACTION; ALTER TABLE t ADD COLUMN d TIMESTAMP WITH TIME ZONE DEFAULT non_existent_function(); COMMIT; +-- +ok +== diff --git a/parser/testdata/corpus/sql/transactions/statement-preprocessor/multistatement_is_transactional_chained_PRAGMA.test b/parser/testdata/corpus/sql/transactions/statement-preprocessor/multistatement_is_transactional_chained_PRAGMA.test new file mode 100644 index 0000000..b6b27c0 --- /dev/null +++ b/parser/testdata/corpus/sql/transactions/statement-preprocessor/multistatement_is_transactional_chained_PRAGMA.test @@ -0,0 +1,9 @@ +# source: test/sql/transactions/statement-preprocessor/multistatement_is_transactional_chained_PRAGMA.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +PRAGMA disable_checkpoint_on_shutdown; ALTER TABLE t ADD COLUMN d TIMESTAMP WITH TIME ZONE DEFAULT non_existent_function(); +-- +ok +== diff --git a/parser/testdata/corpus/sql/transactions/statement-preprocessor/multistatement_is_transactional_chained_PRAGMA_BEGIN.test b/parser/testdata/corpus/sql/transactions/statement-preprocessor/multistatement_is_transactional_chained_PRAGMA_BEGIN.test new file mode 100644 index 0000000..1704c84 --- /dev/null +++ b/parser/testdata/corpus/sql/transactions/statement-preprocessor/multistatement_is_transactional_chained_PRAGMA_BEGIN.test @@ -0,0 +1,9 @@ +# source: test/sql/transactions/statement-preprocessor/multistatement_is_transactional_chained_PRAGMA_BEGIN.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +PRAGMA disable_checkpoint_on_shutdown; BEGIN TRANSACTION; ALTER TABLE t ADD COLUMN d TIMESTAMP WITH TIME ZONE DEFAULT non_existent_function(); +-- +ok +== diff --git a/parser/testdata/corpus/sql/transactions/statement-preprocessor/pivot_is_handled_correctly.test b/parser/testdata/corpus/sql/transactions/statement-preprocessor/pivot_is_handled_correctly.test new file mode 100644 index 0000000..e745dd4 --- /dev/null +++ b/parser/testdata/corpus/sql/transactions/statement-preprocessor/pivot_is_handled_correctly.test @@ -0,0 +1,9 @@ +# source: test/sql/transactions/statement-preprocessor/pivot_is_handled_correctly.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +PIVOT VALUES(1,2),(1,3) x(y,z) ON x USING FIRST(y) ORDER BY 1; +-- +ok +== diff --git a/parser/testdata/corpus/sql/transactions/test_alter_sequence_ownership_conflict.test b/parser/testdata/corpus/sql/transactions/test_alter_sequence_ownership_conflict.test new file mode 100644 index 0000000..043c398 --- /dev/null +++ b/parser/testdata/corpus/sql/transactions/test_alter_sequence_ownership_conflict.test @@ -0,0 +1,23 @@ +# source: test/sql/transactions/test_alter_sequence_ownership_conflict.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +CREATE TABLE tbl1 (id INT); +-- +ok +== +CREATE TABLE tbl2 ( + id INT DEFAULT nextval('seq') +); +-- +ok +== +DROP TABLE tbl1 CASCADE; +-- +ok +== +ALTER SEQUENCE seq OWNED BY tbl2; +-- +ok +== diff --git a/parser/testdata/corpus/sql/transactions/test_alter_sequence_ownership_conflict2.test b/parser/testdata/corpus/sql/transactions/test_alter_sequence_ownership_conflict2.test new file mode 100644 index 0000000..83099dd --- /dev/null +++ b/parser/testdata/corpus/sql/transactions/test_alter_sequence_ownership_conflict2.test @@ -0,0 +1,19 @@ +# source: test/sql/transactions/test_alter_sequence_ownership_conflict2.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +CREATE TABLE tbl1 ( + id INT +); +-- +ok +== +drop table tbl1 +-- +ok +== +drop sequence seq +-- +ok +== diff --git a/parser/testdata/corpus/sql/transactions/test_basic_transactions.test b/parser/testdata/corpus/sql/transactions/test_basic_transactions.test new file mode 100644 index 0000000..e0abb1a --- /dev/null +++ b/parser/testdata/corpus/sql/transactions/test_basic_transactions.test @@ -0,0 +1,9 @@ +# source: test/sql/transactions/test_basic_transactions.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +CREATE TABLE integers2(i INTEGER) +-- +ok +== diff --git a/parser/testdata/corpus/sql/transactions/test_cardinality_estimation_uncommitted.test b/parser/testdata/corpus/sql/transactions/test_cardinality_estimation_uncommitted.test new file mode 100644 index 0000000..712eaf9 --- /dev/null +++ b/parser/testdata/corpus/sql/transactions/test_cardinality_estimation_uncommitted.test @@ -0,0 +1,13 @@ +# source: test/sql/transactions/test_cardinality_estimation_uncommitted.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +INSERT INTO t1 SELECT range, range FROM range(10000) +-- +ok +== +EXPLAIN SELECT * FROM t1 +-- +ok +== diff --git a/parser/testdata/corpus/sql/transactions/test_create_drop_conflict.test b/parser/testdata/corpus/sql/transactions/test_create_drop_conflict.test new file mode 100644 index 0000000..c7aa2aa --- /dev/null +++ b/parser/testdata/corpus/sql/transactions/test_create_drop_conflict.test @@ -0,0 +1,21 @@ +# source: test/sql/transactions/test_create_drop_conflict.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +CREATE SCHEMA foo; +-- +ok +== +DROP SCHEMA IF EXISTS foo CASCADE; +-- +ok +== +create table foo.bar as select 42; +-- +ok +== +DROP SCHEMA foo CASCADE; +-- +ok +== diff --git a/parser/testdata/corpus/sql/transactions/test_create_drop_conflict_variation1.test b/parser/testdata/corpus/sql/transactions/test_create_drop_conflict_variation1.test new file mode 100644 index 0000000..b4911bd --- /dev/null +++ b/parser/testdata/corpus/sql/transactions/test_create_drop_conflict_variation1.test @@ -0,0 +1,13 @@ +# source: test/sql/transactions/test_create_drop_conflict_variation1.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +select * from foo.bar; +-- +ok +== +select schema_name from duckdb_schemas() where schema_name = 'foo'; +-- +ok +== diff --git a/parser/testdata/corpus/sql/transactions/test_ddl_after_dml.test b/parser/testdata/corpus/sql/transactions/test_ddl_after_dml.test new file mode 100644 index 0000000..311d3bd --- /dev/null +++ b/parser/testdata/corpus/sql/transactions/test_ddl_after_dml.test @@ -0,0 +1,57 @@ +# source: test/sql/transactions/test_ddl_after_dml.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +CREATE TABLE t1 (id INT) +-- +ok +== +INSERT INTO t1 (id) VALUES (1) +-- +ok +== +UPDATE t1 SET id = 2 WHERE id = 1 +-- +ok +== +ALTER TABLE t1 ADD COLUMN c0 INT DEFAULT 0 +-- +ok +== +select * from t1 +-- +ok +== +ALTER TABLE t1 ADD COLUMN c1 VARCHAR DEFAULT repeat('a', 5) +-- +ok +== +ALTER TABLE t1 DROP COLUMN c0 +-- +ok +== +select * from t1; +-- +ok +== +PRAGMA wal_autocheckpoint='1TB' +-- +ok +== +CREATE TABLE t2 (id INT) +-- +ok +== +INSERT INTO t2 (id) VALUES (10), (20), (30) +-- +ok +== +ALTER TABLE t2 ADD COLUMN c0 INT DEFAULT 7 +-- +ok +== +SELECT * FROM t3 ORDER BY id +-- +ok +== diff --git a/parser/testdata/corpus/sql/transactions/test_from_update_conflict.test b/parser/testdata/corpus/sql/transactions/test_from_update_conflict.test new file mode 100644 index 0000000..e898053 --- /dev/null +++ b/parser/testdata/corpus/sql/transactions/test_from_update_conflict.test @@ -0,0 +1,37 @@ +# source: test/sql/transactions/test_from_update_conflict.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +CREATE TABLE test AS SELECT i AS a FROM range (2048, 5000, 1) t1(i) +-- +ok +== +INSERT INTO test VALUES (1), (2), (3) +-- +ok +== +CREATE TABLE src(b INTEGER) +-- +ok +== +INSERT INTO src VALUES (3), (2), (1), (4) +-- +ok +== +SELECT src.rowid sr, b, test.rowid tr, a FROM src, test WHERE src.b = test.a ORDER BY a; +-- +ok +== +UPDATE src SET b = 10000 WHERE src.rowid = 0 OR src.rowid = 1 OR src.rowid = 3 +-- +ok +== +SELECT b FROM src +-- +ok +== +UPDATE src SET b = 20000 FROM test WHERE src.b = test.a; +-- +ok +== diff --git a/parser/testdata/corpus/sql/transactions/test_index_abort.test b/parser/testdata/corpus/sql/transactions/test_index_abort.test new file mode 100644 index 0000000..201c27c --- /dev/null +++ b/parser/testdata/corpus/sql/transactions/test_index_abort.test @@ -0,0 +1,17 @@ +# source: test/sql/transactions/test_index_abort.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +INSERT INTO integers VALUES (1, 1), (2, 2), (3, 3) +-- +ok +== +INSERT INTO integers VALUES (4, 4) +-- +ok +== +UPDATE integers SET j=j+1 +-- +ok +== diff --git a/parser/testdata/corpus/sql/transactions/test_index_delete_cleanup_non_main_storage.test b/parser/testdata/corpus/sql/transactions/test_index_delete_cleanup_non_main_storage.test new file mode 100644 index 0000000..f07df38 --- /dev/null +++ b/parser/testdata/corpus/sql/transactions/test_index_delete_cleanup_non_main_storage.test @@ -0,0 +1,145 @@ +# source: test/sql/transactions/test_index_delete_cleanup_non_main_storage.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +SET index_scan_percentage=1.0 +-- +ok +== +SET index_scan_max_count=1 +-- +ok +== +CREATE TABLE t_drop (id INTEGER PRIMARY KEY, val INTEGER) +-- +ok +== +INSERT INTO t_drop SELECT i, i * 10 FROM range(1000) tbl(i) +-- +ok +== +SELECT COUNT(*) FROM t_drop +-- +ok +== +DELETE FROM t_drop WHERE id < 500 +-- +ok +== +DROP TABLE t_drop +-- +ok +== +EXPLAIN ANALYZE SELECT val FROM t_drop WHERE id = 42 +-- +ok +== +SELECT val FROM t_drop WHERE id = 42 +-- +ok +== +CREATE TABLE t_replace (id INTEGER PRIMARY KEY, val INTEGER) +-- +ok +== +INSERT INTO t_replace SELECT i, i * 10 FROM range(1000) tbl(i) +-- +ok +== +SELECT COUNT(*) FROM t_replace +-- +ok +== +DELETE FROM t_replace WHERE id < 500 +-- +ok +== +CREATE OR REPLACE TABLE t_replace (id INTEGER PRIMARY KEY, val INTEGER) +-- +ok +== +EXPLAIN ANALYZE SELECT val FROM t_replace WHERE id = 42 +-- +ok +== +SELECT val FROM t_replace WHERE id = 42 +-- +ok +== +CREATE TABLE t_alter (id INTEGER PRIMARY KEY, val INTEGER) +-- +ok +== +INSERT INTO t_alter SELECT i, i * 10 FROM range(1000) tbl(i) +-- +ok +== +SELECT COUNT(*) FROM t_alter +-- +ok +== +DELETE FROM t_alter WHERE id < 500 +-- +ok +== +ALTER TABLE t_alter ADD COLUMN extra INTEGER DEFAULT 0 +-- +ok +== +EXPLAIN ANALYZE SELECT val FROM t_alter WHERE id = 42 +-- +ok +== +SELECT val FROM t_alter WHERE id = 42 +-- +ok +== +SELECT COUNT(*), MIN(id), MAX(id), MIN(extra), MAX(extra) FROM t_alter +-- +ok +== +EXPLAIN ANALYZE SELECT val FROM t_alter WHERE id = 700 +-- +ok +== +SELECT val FROM t_alter WHERE id = 700 +-- +ok +== +SELECT COUNT(*) FROM t_alter WHERE id = 42 +-- +ok +== +CREATE TABLE t_same_tx (id INTEGER PRIMARY KEY, val INTEGER) +-- +ok +== +INSERT INTO t_same_tx SELECT i, i * 10 FROM range(1000) tbl(i) +-- +ok +== +DELETE FROM t_same_tx WHERE id < 500 +-- +ok +== +ALTER TABLE t_same_tx ADD COLUMN extra INTEGER DEFAULT 0 +-- +ok +== +SELECT COUNT(*), MIN(id), MAX(id), MIN(extra), MAX(extra) FROM t_same_tx +-- +ok +== +EXPLAIN ANALYZE SELECT val FROM t_same_tx WHERE id = 700 +-- +ok +== +SELECT val FROM t_same_tx WHERE id = 700 +-- +ok +== +SELECT COUNT(*) FROM t_same_tx WHERE id = 42 +-- +ok +== diff --git a/parser/testdata/corpus/sql/transactions/test_index_huge_aborted_append.test b/parser/testdata/corpus/sql/transactions/test_index_huge_aborted_append.test new file mode 100644 index 0000000..dc09d7a --- /dev/null +++ b/parser/testdata/corpus/sql/transactions/test_index_huge_aborted_append.test @@ -0,0 +1,21 @@ +# source: test/sql/transactions/test_index_huge_aborted_append.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +CREATE TABLE integers(i INTEGER PRIMARY KEY); +-- +ok +== +INSERT INTO integers SELECT i FROM range(2, 131068, 1) t1(i) +-- +ok +== +INSERT INTO integers VALUES (3); +-- +ok +== +INSERT INTO integers VALUES (4); +-- +ok +== diff --git a/parser/testdata/corpus/sql/transactions/test_index_large_aborted_append.test b/parser/testdata/corpus/sql/transactions/test_index_large_aborted_append.test new file mode 100644 index 0000000..170051d --- /dev/null +++ b/parser/testdata/corpus/sql/transactions/test_index_large_aborted_append.test @@ -0,0 +1,33 @@ +# source: test/sql/transactions/test_index_large_aborted_append.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +CREATE TABLE integers(i INTEGER UNIQUE); +-- +ok +== +INSERT INTO integers SELECT -10 + i FROM RANGE({i}) tbl(i); +-- +error: Parser Error: syntax error at or near "}" +== +INSERT INTO integers SELECT case when i%2=0 then null else i end FROM range(2, 2049, 1) t1(i) +-- +ok +== +INSERT INTO integers VALUES (-10); +-- +ok +== +SELECT COUNT(*)={i} FROM integers +-- +error: Parser Error: syntax error at or near "}" +== +INSERT INTO integers SELECT i FROM range(2, 2049, 1) t1(i) +-- +ok +== +SELECT (COUNT(*)-2047)={i}, MIN(i), MAX(i), (COUNT(i)-2047)={i} FROM integers ORDER BY 1 +-- +error: Parser Error: syntax error at or near "}" +== diff --git a/parser/testdata/corpus/sql/transactions/test_index_local_update.test b/parser/testdata/corpus/sql/transactions/test_index_local_update.test new file mode 100644 index 0000000..6cf7afc --- /dev/null +++ b/parser/testdata/corpus/sql/transactions/test_index_local_update.test @@ -0,0 +1,29 @@ +# source: test/sql/transactions/test_index_local_update.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +INSERT INTO integers VALUES (4) +-- +ok +== +UPDATE integers SET i = 3 WHERE i = 4 +-- +ok +== +UPDATE integers SET i = 5 WHERE i = 4 +-- +ok +== +SELECT i FROM integers WHERE i = 5 +-- +ok +== +SELECT i FROM integers WHERE i = 4 +-- +ok +== +SELECT i FROM integers ORDER BY i +-- +ok +== diff --git a/parser/testdata/corpus/sql/transactions/test_index_pending_delete.test b/parser/testdata/corpus/sql/transactions/test_index_pending_delete.test new file mode 100644 index 0000000..41a5ee4 --- /dev/null +++ b/parser/testdata/corpus/sql/transactions/test_index_pending_delete.test @@ -0,0 +1,9 @@ +# source: test/sql/transactions/test_index_pending_delete.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +DELETE FROM integers WHERE i=1 +-- +ok +== diff --git a/parser/testdata/corpus/sql/transactions/test_index_pending_update.test b/parser/testdata/corpus/sql/transactions/test_index_pending_update.test new file mode 100644 index 0000000..11bb410 --- /dev/null +++ b/parser/testdata/corpus/sql/transactions/test_index_pending_update.test @@ -0,0 +1,13 @@ +# source: test/sql/transactions/test_index_pending_update.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +UPDATE integers SET i=4 WHERE i=1 +-- +ok +== +SELECT COUNT(*) FROM integers WHERE i=4 +-- +ok +== diff --git a/parser/testdata/corpus/sql/transactions/test_index_rollback_flushed_data.test b/parser/testdata/corpus/sql/transactions/test_index_rollback_flushed_data.test new file mode 100644 index 0000000..0aaacfa --- /dev/null +++ b/parser/testdata/corpus/sql/transactions/test_index_rollback_flushed_data.test @@ -0,0 +1,17 @@ +# source: test/sql/transactions/test_index_rollback_flushed_data.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +INSERT INTO integers SELECT range FROM range(2, 4097, 1); +-- +ok +== +INSERT INTO integers SELECT i FROM range(2, 4097, 1) t1(i) +-- +ok +== +SELECT MAX(i) FROM integers +-- +ok +== diff --git a/parser/testdata/corpus/sql/transactions/test_index_transaction_local.test b/parser/testdata/corpus/sql/transactions/test_index_transaction_local.test new file mode 100644 index 0000000..700512e --- /dev/null +++ b/parser/testdata/corpus/sql/transactions/test_index_transaction_local.test @@ -0,0 +1,33 @@ +# source: test/sql/transactions/test_index_transaction_local.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +UPDATE integers SET i=1 WHERE i=4 +-- +ok +== +UPDATE integers SET i=5 WHERE i=4 +-- +ok +== +DELETE FROM integers WHERE i >= 4 +-- +ok +== +CREATE TABLE issue2241 (id text primary key); +-- +ok +== +INSERT INTO issue2241 VALUES ('Alice'); +-- +ok +== +INSERT INTO issue2241 VALUES ('Bob'); +-- +ok +== +DELETE FROM issue2241 WHERE id = 'Bob'; +-- +ok +== diff --git a/parser/testdata/corpus/sql/transactions/test_index_versioned_deletes.test b/parser/testdata/corpus/sql/transactions/test_index_versioned_deletes.test new file mode 100644 index 0000000..2a1cf42 --- /dev/null +++ b/parser/testdata/corpus/sql/transactions/test_index_versioned_deletes.test @@ -0,0 +1,17 @@ +# source: test/sql/transactions/test_index_versioned_deletes.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +SELECT i FROM integers WHERE i=1 +-- +ok +== +SELECT i FROM integers WHERE i=4 +-- +ok +== +DELETE FROM integers WHERE i=4 +-- +ok +== diff --git a/parser/testdata/corpus/sql/transactions/test_index_versioned_updates.test b/parser/testdata/corpus/sql/transactions/test_index_versioned_updates.test new file mode 100644 index 0000000..6f16291 --- /dev/null +++ b/parser/testdata/corpus/sql/transactions/test_index_versioned_updates.test @@ -0,0 +1,13 @@ +# source: test/sql/transactions/test_index_versioned_updates.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +UPDATE integers SET j=4 WHERE i=1 +-- +ok +== +SELECT j FROM integers WHERE i=1 +-- +ok +== diff --git a/parser/testdata/corpus/sql/transactions/test_multi_transaction_append.test b/parser/testdata/corpus/sql/transactions/test_multi_transaction_append.test new file mode 100644 index 0000000..2e08efd --- /dev/null +++ b/parser/testdata/corpus/sql/transactions/test_multi_transaction_append.test @@ -0,0 +1,9 @@ +# source: test/sql/transactions/test_multi_transaction_append.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +INSERT INTO integers VALUES (1, 3) +-- +ok +== diff --git a/parser/testdata/corpus/sql/transactions/test_multi_version.test b/parser/testdata/corpus/sql/transactions/test_multi_version.test new file mode 100644 index 0000000..e6b5824 --- /dev/null +++ b/parser/testdata/corpus/sql/transactions/test_multi_version.test @@ -0,0 +1,21 @@ +# source: test/sql/transactions/test_multi_version.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +UPDATE integers SET i=5 WHERE i=1; +-- +ok +== +UPDATE integers SET i=10 WHERE i=5; +-- +ok +== +DELETE FROM integers WHERE i>5; +-- +ok +== +INSERT INTO integers VALUES (1), (2) +-- +ok +== diff --git a/parser/testdata/corpus/sql/transactions/test_multi_version_large.test b/parser/testdata/corpus/sql/transactions/test_multi_version_large.test new file mode 100644 index 0000000..6bc0225 --- /dev/null +++ b/parser/testdata/corpus/sql/transactions/test_multi_version_large.test @@ -0,0 +1,29 @@ +# source: test/sql/transactions/test_multi_version_large.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +INSERT INTO integers VALUES (1), (2), (3), (4); +-- +ok +== +INSERT INTO integers SELECT * FROM integers +-- +ok +== +SELECT COUNT(*), COUNT(DISTINCT ROWID) FROM integers WHERE i=1 +-- +ok +== +SELECT COUNT(*) FROM integers WHERE i=2 +-- +ok +== +SELECT COUNT(*) FROM integers WHERE i=3 +-- +ok +== +DELETE FROM integers WHERE i=3 +-- +ok +== diff --git a/parser/testdata/corpus/sql/transactions/test_null_version.test b/parser/testdata/corpus/sql/transactions/test_null_version.test new file mode 100644 index 0000000..4d2c9bb --- /dev/null +++ b/parser/testdata/corpus/sql/transactions/test_null_version.test @@ -0,0 +1,13 @@ +# source: test/sql/transactions/test_null_version.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +INSERT INTO integers VALUES (NULL, 3) +-- +ok +== +UPDATE integers SET i=1,j=1 +-- +ok +== diff --git a/parser/testdata/corpus/sql/transactions/test_read_only_transactions.test b/parser/testdata/corpus/sql/transactions/test_read_only_transactions.test new file mode 100644 index 0000000..698a7e3 --- /dev/null +++ b/parser/testdata/corpus/sql/transactions/test_read_only_transactions.test @@ -0,0 +1,9 @@ +# source: test/sql/transactions/test_read_only_transactions.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +INSERT INTO a VALUES (48) +-- +ok +== diff --git a/parser/testdata/corpus/sql/transactions/test_stacked_schema_change.test b/parser/testdata/corpus/sql/transactions/test_stacked_schema_change.test new file mode 100644 index 0000000..dbc1cc2 --- /dev/null +++ b/parser/testdata/corpus/sql/transactions/test_stacked_schema_change.test @@ -0,0 +1,21 @@ +# source: test/sql/transactions/test_stacked_schema_change.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +INSERT INTO a VALUES (44) +-- +ok +== +SELECT i FROM a +-- +ok +== +INSERT INTO a VALUES (45) +-- +ok +== +INSERT INTO a VALUES (46) +-- +ok +== diff --git a/parser/testdata/corpus/sql/transactions/test_transaction_abort.test b/parser/testdata/corpus/sql/transactions/test_transaction_abort.test new file mode 100644 index 0000000..2abcf31 --- /dev/null +++ b/parser/testdata/corpus/sql/transactions/test_transaction_abort.test @@ -0,0 +1,17 @@ +# source: test/sql/transactions/test_transaction_abort.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +SELEC 42 +-- +error: Parser Error: syntax error at or near "42" +== +SELECT * FROM nonexistanttable +-- +ok +== +UPDATE integers SET i=2 +-- +ok +== diff --git a/parser/testdata/corpus/sql/transactions/test_transaction_local_add.test b/parser/testdata/corpus/sql/transactions/test_transaction_local_add.test new file mode 100644 index 0000000..4002957 --- /dev/null +++ b/parser/testdata/corpus/sql/transactions/test_transaction_local_add.test @@ -0,0 +1,9 @@ +# source: test/sql/transactions/test_transaction_local_add.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +ALTER TABLE integers ADD COLUMN k INTEGER DEFAULT 4 +-- +ok +== diff --git a/parser/testdata/corpus/sql/transactions/test_transaction_local_alter_type.test b/parser/testdata/corpus/sql/transactions/test_transaction_local_alter_type.test new file mode 100644 index 0000000..3dcf211 --- /dev/null +++ b/parser/testdata/corpus/sql/transactions/test_transaction_local_alter_type.test @@ -0,0 +1,9 @@ +# source: test/sql/transactions/test_transaction_local_alter_type.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +ALTER TABLE integers ALTER j TYPE BIGINT +-- +ok +== diff --git a/parser/testdata/corpus/sql/transactions/test_transaction_local_data.test b/parser/testdata/corpus/sql/transactions/test_transaction_local_data.test new file mode 100644 index 0000000..91f0ebd --- /dev/null +++ b/parser/testdata/corpus/sql/transactions/test_transaction_local_data.test @@ -0,0 +1,13 @@ +# source: test/sql/transactions/test_transaction_local_data.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +INSERT INTO integers VALUES (1, 3), (2, 3) +-- +ok +== +UPDATE integers SET j=5 WHERE i=2 +-- +ok +== diff --git a/parser/testdata/corpus/sql/transactions/test_transaction_local_drop.test b/parser/testdata/corpus/sql/transactions/test_transaction_local_drop.test new file mode 100644 index 0000000..1d04207 --- /dev/null +++ b/parser/testdata/corpus/sql/transactions/test_transaction_local_drop.test @@ -0,0 +1,9 @@ +# source: test/sql/transactions/test_transaction_local_drop.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +ALTER TABLE integers DROP COLUMN j +-- +ok +== diff --git a/parser/testdata/corpus/sql/transactions/test_transaction_local_unique_ops.test b/parser/testdata/corpus/sql/transactions/test_transaction_local_unique_ops.test new file mode 100644 index 0000000..e9098c7 --- /dev/null +++ b/parser/testdata/corpus/sql/transactions/test_transaction_local_unique_ops.test @@ -0,0 +1,13 @@ +# source: test/sql/transactions/test_transaction_local_unique_ops.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +UPDATE integers SET i=1 WHERE i=2 +-- +ok +== +UPDATE integers SET i=3 WHERE i=2 +-- +ok +== diff --git a/parser/testdata/corpus/sql/transactions/transaction_insert_delete_chunks.test b/parser/testdata/corpus/sql/transactions/transaction_insert_delete_chunks.test new file mode 100644 index 0000000..d83e575 --- /dev/null +++ b/parser/testdata/corpus/sql/transactions/transaction_insert_delete_chunks.test @@ -0,0 +1,21 @@ +# source: test/sql/transactions/transaction_insert_delete_chunks.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +INSERT INTO integers FROM range(1000); +-- +ok +== +INSERT INTO integers FROM range(1000, 3000); +-- +ok +== +INSERT INTO integers FROM range(10000); +-- +ok +== +INSERT INTO integers FROM range(10000, 30000); +-- +ok +== diff --git a/parser/testdata/corpus/sql/transactions/transaction_insert_mixed_deletes.test b/parser/testdata/corpus/sql/transactions/transaction_insert_mixed_deletes.test new file mode 100644 index 0000000..da4bbd6 --- /dev/null +++ b/parser/testdata/corpus/sql/transactions/transaction_insert_mixed_deletes.test @@ -0,0 +1,9 @@ +# source: test/sql/transactions/transaction_insert_mixed_deletes.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +INSERT INTO integers FROM range(1000,3000); +-- +ok +== diff --git a/parser/testdata/corpus/sql/transactions/types/test_hugeint_transactions.test b/parser/testdata/corpus/sql/transactions/types/test_hugeint_transactions.test new file mode 100644 index 0000000..eb1a881 --- /dev/null +++ b/parser/testdata/corpus/sql/transactions/types/test_hugeint_transactions.test @@ -0,0 +1,29 @@ +# source: test/sql/transactions/types/test_hugeint_transactions.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +INSERT INTO hugeints VALUES (100::HUGEINT), (1023819078293589341789412412), (42); +-- +ok +== +UPDATE hugeints SET h=100 WHERE h=42; +-- +ok +== +SELECT * FROM hugeints ORDER BY 1 +-- +ok +== +SELECT COUNT(DISTINCT h) FROM hugeints +-- +ok +== +SELECT h, COUNT(*) FROM hugeints GROUP BY h ORDER BY 2 DESC +-- +ok +== +UPDATE hugeints SET h=h+1 WHERE h=100; +-- +ok +== diff --git a/parser/testdata/corpus/sql/transactions/types/test_interval_transactions.test b/parser/testdata/corpus/sql/transactions/types/test_interval_transactions.test new file mode 100644 index 0000000..8a36377 --- /dev/null +++ b/parser/testdata/corpus/sql/transactions/types/test_interval_transactions.test @@ -0,0 +1,25 @@ +# source: test/sql/transactions/types/test_interval_transactions.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +INSERT INTO interval VALUES (INTERVAL '20' DAY), (INTERVAL '1' YEAR), (INTERVAL '1' MONTH); +-- +ok +== +UPDATE interval SET t=INTERVAL '1' MONTH WHERE t=INTERVAL '20' DAY; +-- +ok +== +SELECT * FROM interval ORDER BY 1 +-- +ok +== +SELECT COUNT(DISTINCT t) FROM interval +-- +ok +== +SELECT t, COUNT(*) FROM interval GROUP BY t ORDER BY 2 DESC +-- +ok +== diff --git a/parser/testdata/corpus/sql/transactions/types/test_uhugeint_transactions.test b/parser/testdata/corpus/sql/transactions/types/test_uhugeint_transactions.test new file mode 100644 index 0000000..de9698f --- /dev/null +++ b/parser/testdata/corpus/sql/transactions/types/test_uhugeint_transactions.test @@ -0,0 +1,29 @@ +# source: test/sql/transactions/types/test_uhugeint_transactions.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +INSERT INTO uhugeints VALUES (100::UHUGEINT), (1023819078293589341789412412), (42); +-- +ok +== +UPDATE uhugeints SET h=100 WHERE h=42; +-- +ok +== +SELECT * FROM uhugeints ORDER BY 1 +-- +ok +== +SELECT COUNT(DISTINCT h) FROM uhugeints +-- +ok +== +SELECT h, COUNT(*) FROM uhugeints GROUP BY h ORDER BY 2 DESC +-- +ok +== +UPDATE uhugeints SET h=h+1 WHERE h=100; +-- +ok +== diff --git a/parser/testdata/corpus/sql/trigger/create_trigger_catalog.test b/parser/testdata/corpus/sql/trigger/create_trigger_catalog.test new file mode 100644 index 0000000..edd9c4c --- /dev/null +++ b/parser/testdata/corpus/sql/trigger/create_trigger_catalog.test @@ -0,0 +1,214 @@ +# source: test/sql/trigger/create_trigger_catalog.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +CREATE TABLE t1 (id INTEGER, data VARCHAR); +-- +ok +== +CREATE TABLE log_table (id INTEGER); +-- +ok +== +CREATE TRIGGER my_trigger AFTER INSERT ON t1 INSERT INTO log_table VALUES (1); +-- +ok +== +SELECT trigger_name, table_name, action_timing, event_manipulation FROM duckdb_triggers() WHERE trigger_name = 'my_trigger'; +-- +ok +== +CREATE TRIGGER del_trigger BEFORE DELETE ON t1 INSERT INTO log_table VALUES (2); +-- +ok +== +SELECT COUNT(*) FROM duckdb_triggers() WHERE table_name = 't1'; +-- +ok +== +CREATE TRIGGER upd_trigger AFTER UPDATE ON t1 INSERT INTO log_table VALUES (3); +-- +ok +== +CREATE TABLE t_upd_of (id INTEGER, data VARCHAR); +-- +ok +== +CREATE TRIGGER upd_col_trigger AFTER UPDATE OF id ON t_upd_of INSERT INTO log_table VALUES (4); +-- +ok +== +SELECT trigger_name, columns FROM duckdb_triggers() WHERE trigger_name = 'upd_col_trigger'; +-- +ok +== +CREATE TABLE t_ifne (id INTEGER); +-- +ok +== +CREATE TRIGGER ifne_trigger AFTER INSERT ON t_ifne INSERT INTO log_table VALUES (1); +-- +ok +== +CREATE TRIGGER IF NOT EXISTS ifne_trigger AFTER INSERT ON t_ifne INSERT INTO log_table VALUES (1); +-- +ok +== +SELECT COUNT(*) FROM duckdb_triggers() WHERE trigger_name = 'ifne_trigger'; +-- +ok +== +CREATE TABLE t_upd_body (id INTEGER); +-- +ok +== +CREATE TRIGGER update_body_trigger AFTER INSERT ON t_upd_body UPDATE log_table SET id = 99 WHERE log_table.id = 1; +-- +ok +== +SELECT trigger_name, sql FROM duckdb_triggers() WHERE trigger_name = 'update_body_trigger'; +-- +ok +== +CREATE TABLE t_del_body (id INTEGER); +-- +ok +== +CREATE TRIGGER delete_body_trigger BEFORE DELETE ON t_del_body DELETE FROM log_table WHERE log_table.id = 1; +-- +ok +== +SELECT trigger_name, sql FROM duckdb_triggers() WHERE trigger_name = 'delete_body_trigger'; +-- +ok +== +CREATE TABLE t_ins_sel (id INTEGER); +-- +ok +== +CREATE TRIGGER insert_select_trigger AFTER UPDATE ON t_ins_sel INSERT INTO log_table SELECT id FROM t_ins_sel; +-- +ok +== +SELECT trigger_name, sql FROM duckdb_triggers() WHERE trigger_name = 'insert_select_trigger'; +-- +ok +== +DROP TABLE log_table; +-- +ok +== +CREATE TABLE my_schema.t2 (id INTEGER); +-- +ok +== +CREATE TABLE my_schema.log2 (id INTEGER); +-- +ok +== +CREATE TRIGGER schema_trigger AFTER INSERT ON my_schema.t2 INSERT INTO my_schema.log2 VALUES (1); +-- +ok +== +SELECT schema_name, trigger_name, table_name FROM duckdb_triggers() WHERE trigger_name = 'schema_trigger'; +-- +ok +== +DROP TABLE my_schema.t2 CASCADE; +-- +ok +== +DROP TABLE my_schema.log2; +-- +ok +== +DROP SCHEMA my_schema CASCADE; +-- +ok +== +CREATE TABLE a (id INTEGER); +-- +ok +== +CREATE TABLE b (id INTEGER); +-- +ok +== +CREATE TABLE log_ab (id INTEGER); +-- +ok +== +CREATE TRIGGER same_name AFTER INSERT ON a INSERT INTO log_ab VALUES (1); +-- +ok +== +CREATE TRIGGER same_name AFTER INSERT ON b INSERT INTO log_ab VALUES (2); +-- +ok +== +SELECT trigger_name, table_name FROM duckdb_triggers() WHERE trigger_name = 'same_name' ORDER BY table_name; +-- +ok +== +CREATE TRIGGER same_name AFTER DELETE ON a INSERT INTO log_ab VALUES (3); +-- +ok +== +CREATE TRIGGER IF NOT EXISTS same_name AFTER DELETE ON a INSERT INTO log_ab VALUES (3); +-- +ok +== +DROP TABLE a CASCADE; +-- +ok +== +DROP TABLE b CASCADE; +-- +ok +== +DROP TABLE log_ab; +-- +ok +== +ATTACH ':memory:' AS trig_cat; +-- +ok +== +CREATE TABLE trig_cat.t_base (id INTEGER); +-- +ok +== +CREATE TABLE trig_cat.t_audit (msg VARCHAR); +-- +ok +== +CREATE TRIGGER cat_qualified_trigger AFTER INSERT ON trig_cat.t_base FOR EACH STATEMENT + INSERT INTO trig_cat.t_audit VALUES ('fired'); +-- +ok +== +SELECT trigger_name, sql FROM duckdb_triggers() WHERE trigger_name = 'cat_qualified_trigger'; +-- +ok +== +INSERT INTO trig_cat.t_base VALUES (1); +-- +ok +== +SELECT msg FROM trig_cat.t_audit; +-- +ok +== +DROP TABLE trig_cat.t_base CASCADE; +-- +ok +== +DROP TABLE trig_cat.t_audit; +-- +ok +== +DETACH trig_cat; +-- +ok +== diff --git a/parser/testdata/corpus/sql/trigger/create_trigger_parse.test b/parser/testdata/corpus/sql/trigger/create_trigger_parse.test new file mode 100644 index 0000000..01ed772 --- /dev/null +++ b/parser/testdata/corpus/sql/trigger/create_trigger_parse.test @@ -0,0 +1,100 @@ +# source: test/sql/trigger/create_trigger_parse.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +CREATE TRIGGER my_trigger AFTER INSERT ON my_table INSERT INTO log_table VALUES (1); +-- +ok +== +CREATE TRIGGER my_trigger BEFORE DELETE ON my_table INSERT INTO log_table VALUES (1); +-- +ok +== +CREATE TRIGGER my_trigger INSTEAD OF INSERT ON my_table INSERT INTO log_table VALUES (1); +-- +ok +== +CREATE TRIGGER my_trigger AFTER UPDATE ON my_table INSERT INTO log_table VALUES (1); +-- +ok +== +CREATE TRIGGER my_trigger AFTER UPDATE OF col1, col2 ON my_table INSERT INTO log_table VALUES (1); +-- +ok +== +CREATE TRIGGER my_trigger AFTER INSERT ON my_table FOR EACH ROW INSERT INTO log_table VALUES (1); +-- +ok +== +CREATE TRIGGER my_trigger AFTER INSERT ON my_table FOR EACH STATEMENT INSERT INTO log_table VALUES (1); +-- +ok +== +CREATE TRIGGER IF NOT EXISTS my_trigger AFTER INSERT ON my_table INSERT INTO log_table VALUES (1); +-- +ok +== +CREATE TRIGGER my_schema.my_trigger AFTER INSERT ON my_table INSERT INTO log_table VALUES (1); +-- +error: Parser Error: syntax error at or near "." +== +CREATE TRIGGER my_trigger AFTER INSERT ON my_schema.my_table INSERT INTO log_table VALUES (1); +-- +ok +== +CREATE TRIGGER my_trigger AFTER INSERT ON my_table DELETE FROM other_table WHERE id = 1; +-- +ok +== +CREATE TRIGGER my_trigger AFTER INSERT ON my_table UPDATE other_table SET col = 1; +-- +ok +== +CREATE TRIGGER my_trigger AFTER INSERT my_table INSERT INTO log_table VALUES (1); +-- +error: Parser Error: syntax error at or near "my_table" +== +CREATE TRIGGER my_trigger INSERT ON my_table INSERT INTO log_table VALUES (1); +-- +error: Parser Error: syntax error at or near "INSERT" +== +CREATE TABLE base_tbl (id INTEGER); +-- +ok +== +CREATE VIEW base_view AS SELECT * FROM base_tbl; +-- +ok +== +CREATE TRIGGER trg_on_view AFTER INSERT ON base_view FOR EACH STATEMENT + INSERT INTO base_tbl VALUES (1); +-- +ok +== +CREATE TRIGGER trg_instead_of INSTEAD OF INSERT ON base_tbl FOR EACH STATEMENT + INSERT INTO base_tbl VALUES (1); +-- +ok +== +LOAD sqlite_scanner; +-- +ok +== +ATTACH ':memory:' AS sqlite_db (TYPE SQLITE); +-- +ok +== +CREATE TABLE sqlite_db.my_ext_table (id INTEGER); +-- +ok +== +CREATE TABLE sqlite_db.my_ext_audit (msg VARCHAR); +-- +ok +== +CREATE TRIGGER trg_on_sqlite AFTER INSERT ON sqlite_db.my_ext_table FOR EACH STATEMENT + INSERT INTO sqlite_db.my_ext_audit VALUES ('inserted'); +-- +ok +== diff --git a/parser/testdata/corpus/sql/trigger/create_trigger_wal.test b/parser/testdata/corpus/sql/trigger/create_trigger_wal.test new file mode 100644 index 0000000..fee70d5 --- /dev/null +++ b/parser/testdata/corpus/sql/trigger/create_trigger_wal.test @@ -0,0 +1,37 @@ +# source: test/sql/trigger/create_trigger_wal.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +ATTACH '{TEST_DIR}/create_trigger_wal.db' AS triggerdb (STORAGE_VERSION 'v2.0.0'); +-- +ok +== +USE triggerdb; +-- +ok +== +CREATE TRIGGER del_trigger BEFORE DELETE ON t1 DELETE FROM log_table WHERE log_table.id = 1; +-- +ok +== +CREATE TRIGGER upd_trigger AFTER UPDATE OF id ON t1 UPDATE log_table SET id = 99 WHERE log_table.id = 1; +-- +ok +== +DETACH triggerdb; +-- +ok +== +ATTACH '{TEST_DIR}/create_trigger_wal.db' AS triggerdb; +-- +ok +== +SELECT trigger_name, table_name, action_timing, event_manipulation FROM duckdb_triggers() WHERE database_name = 'triggerdb' ORDER BY trigger_name; +-- +ok +== +SELECT trigger_name, for_each, columns FROM duckdb_triggers() WHERE trigger_name = 'upd_trigger'; +-- +ok +== diff --git a/parser/testdata/corpus/sql/trigger/drop_trigger.test b/parser/testdata/corpus/sql/trigger/drop_trigger.test new file mode 100644 index 0000000..1a899c3 --- /dev/null +++ b/parser/testdata/corpus/sql/trigger/drop_trigger.test @@ -0,0 +1,113 @@ +# source: test/sql/trigger/drop_trigger.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +SELECT COUNT(*) FROM duckdb_triggers() WHERE trigger_name = 'my_trigger' AND table_name = 't1'; +-- +ok +== +DROP TRIGGER my_trigger ON t1; +-- +ok +== +DROP TRIGGER IF EXISTS my_trigger ON t1; +-- +ok +== +CREATE TRIGGER keep_trigger BEFORE DELETE ON t1 INSERT INTO log_table VALUES (2); +-- +ok +== +CREATE TRIGGER drop_me AFTER UPDATE ON t1 INSERT INTO log_table VALUES (3); +-- +ok +== +DROP TRIGGER drop_me ON t1; +-- +ok +== +SELECT trigger_name, table_name FROM duckdb_triggers() WHERE table_name = 't1'; +-- +ok +== +CREATE TRIGGER schema_trigger AFTER INSERT ON my_schema.t2 INSERT INTO log_table VALUES (10); +-- +ok +== +SELECT COUNT(*) FROM duckdb_triggers() WHERE trigger_name = 'schema_trigger'; +-- +ok +== +DROP TRIGGER schema_trigger ON my_schema.t2; +-- +ok +== +CREATE TABLE a (x INTEGER); +-- +ok +== +CREATE TABLE b (x INTEGER); +-- +ok +== +CREATE TRIGGER same_name AFTER INSERT ON a INSERT INTO log_table VALUES (1); +-- +ok +== +CREATE TRIGGER same_name AFTER INSERT ON b INSERT INTO log_table VALUES (2); +-- +ok +== +DROP TRIGGER same_name ON a; +-- +ok +== +SELECT trigger_name, table_name FROM duckdb_triggers() WHERE trigger_name = 'same_name'; +-- +ok +== +DROP TRIGGER same_name ON b; +-- +ok +== +SELECT COUNT(*) FROM duckdb_triggers() WHERE trigger_name = 'same_name'; +-- +ok +== +ATTACH ':memory:' AS mydb; +-- +ok +== +CREATE TABLE mydb.main.cat_table (id INTEGER); +-- +ok +== +CREATE TABLE mydb.main.cat_log (id INTEGER); +-- +ok +== +CREATE TRIGGER cat_trigger AFTER INSERT ON mydb.main.cat_table INSERT INTO mydb.main.cat_log VALUES (1); +-- +ok +== +SELECT COUNT(*) FROM duckdb_triggers() WHERE trigger_name = 'cat_trigger' AND database_name = 'mydb'; +-- +ok +== +DROP TRIGGER cat_trigger ON mydb.main.cat_table; +-- +ok +== +DROP TABLE mydb.main.cat_table; +-- +ok +== +DROP TABLE mydb.main.cat_log; +-- +ok +== +DROP TABLE b; +-- +ok +== diff --git a/parser/testdata/corpus/sql/trigger/drop_trigger_parse.test b/parser/testdata/corpus/sql/trigger/drop_trigger_parse.test new file mode 100644 index 0000000..fb2050a --- /dev/null +++ b/parser/testdata/corpus/sql/trigger/drop_trigger_parse.test @@ -0,0 +1,57 @@ +# source: test/sql/trigger/drop_trigger_parse.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +DROP TRIGGER my_trigger ON my_table; +-- +ok +== +DROP TRIGGER IF EXISTS my_trigger ON my_table; +-- +ok +== +DROP TRIGGER my_schema.my_trigger ON my_table; +-- +error: Parser Error: syntax error at or near "." +== +DROP TRIGGER my_trigger ON my_schema.my_table; +-- +ok +== +DROP TRIGGER my_schema.my_trigger ON my_schema.my_table; +-- +error: Parser Error: syntax error at or near "." +== +DROP TRIGGER IF EXISTS my_schema.my_trigger ON my_schema.my_table; +-- +error: Parser Error: syntax error at or near "." +== +DROP TRIGGER my_trigger ON my_table CASCADE; +-- +ok +== +DROP TRIGGER my_trigger ON my_table RESTRICT; +-- +ok +== +DROP TRIGGER IF EXISTS my_trigger ON my_table CASCADE; +-- +ok +== +DROP TRIGGER IF EXISTS my_trigger ON my_table RESTRICT; +-- +ok +== +DROP TRIGGER my_trigger my_table; +-- +error: Parser Error: syntax error at or near "my_table" +== +DROP TRIGGER my_trigger ON; +-- +error: Parser Error: syntax error at or near ";" +== +DROP TRIGGER ON my_table; +-- +error: Parser Error: syntax error at or near "ON" +== diff --git a/parser/testdata/corpus/sql/trigger/drop_trigger_wal.test b/parser/testdata/corpus/sql/trigger/drop_trigger_wal.test new file mode 100644 index 0000000..d4a9a19 --- /dev/null +++ b/parser/testdata/corpus/sql/trigger/drop_trigger_wal.test @@ -0,0 +1,37 @@ +# source: test/sql/trigger/drop_trigger_wal.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +ATTACH '{TEST_DIR}/drop_trigger_wal.db' AS triggerdb (STORAGE_VERSION 'v2.0.0'); +-- +ok +== +CREATE TABLE t1 (id INTEGER); +-- +ok +== +CREATE TRIGGER keep_trigger AFTER INSERT ON t1 INSERT INTO log_table VALUES (1); +-- +ok +== +CREATE TRIGGER drop_trigger BEFORE DELETE ON t1 DELETE FROM log_table WHERE log_table.id = 1; +-- +ok +== +DROP TRIGGER drop_trigger ON t1; +-- +ok +== +ATTACH '{TEST_DIR}/drop_trigger_wal.db' AS triggerdb; +-- +ok +== +SELECT trigger_name, table_name FROM duckdb_triggers() WHERE database_name = 'triggerdb' ORDER BY trigger_name; +-- +ok +== +SELECT COUNT(*) FROM duckdb_triggers() WHERE trigger_name = 'drop_trigger'; +-- +ok +== diff --git a/parser/testdata/corpus/sql/trigger/trigger_after_delete.test b/parser/testdata/corpus/sql/trigger/trigger_after_delete.test new file mode 100644 index 0000000..62ed3c3 --- /dev/null +++ b/parser/testdata/corpus/sql/trigger/trigger_after_delete.test @@ -0,0 +1,184 @@ +# source: test/sql/trigger/trigger_after_delete.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +CREATE TABLE target (id INTEGER); +-- +ok +== +INSERT INTO target VALUES (1), (2), (3); +-- +ok +== +CREATE TABLE audit (msg VARCHAR); +-- +ok +== +CREATE TRIGGER trg_basic AFTER DELETE ON target FOR EACH STATEMENT + INSERT INTO audit VALUES ('deleted'); +-- +ok +== +DELETE FROM target WHERE id = 1; +-- +ok +== +SELECT COUNT(*) FROM audit; +-- +ok +== +DELETE FROM target WHERE id = 2; +-- +ok +== +DELETE FROM target; +-- +ok +== +CREATE TABLE row_audit (deleted_id INTEGER); +-- +ok +== +CREATE TRIGGER trg_row AFTER DELETE ON row_target FOR EACH ROW + INSERT INTO row_audit VALUES (OLD.id); +-- +ok +== +INSERT INTO row_target VALUES (10), (20), (30); +-- +ok +== +DELETE FROM row_target WHERE id IN (10, 20); +-- +ok +== +SELECT deleted_id FROM row_audit ORDER BY deleted_id; +-- +ok +== +CREATE TABLE strict_target (id INTEGER); +-- +ok +== +INSERT INTO strict_target VALUES (1); +-- +ok +== +CREATE TABLE strict_log (id INTEGER UNIQUE); +-- +ok +== +INSERT INTO strict_log VALUES (999); +-- +ok +== +CREATE TRIGGER trg_fail AFTER DELETE ON strict_target FOR EACH STATEMENT + INSERT INTO strict_log VALUES (999); +-- +ok +== +DELETE FROM strict_target; +-- +ok +== +SELECT COUNT(*) FROM strict_target; +-- +ok +== +SELECT COUNT(*) FROM strict_log; +-- +ok +== +CREATE TABLE t_multi (id INTEGER); +-- +ok +== +CREATE TABLE t_multi_audit (msg VARCHAR); +-- +ok +== +CREATE TRIGGER trg_multi_a AFTER DELETE ON t_multi FOR EACH STATEMENT + INSERT INTO t_multi_audit VALUES ('a'); +-- +ok +== +CREATE TRIGGER trg_multi_b AFTER DELETE ON t_multi FOR EACH STATEMENT + INSERT INTO t_multi_audit VALUES ('b'); +-- +ok +== +INSERT INTO t_multi VALUES (1); +-- +ok +== +DELETE FROM t_multi; +-- +ok +== +SELECT COUNT(*) FROM t_multi_audit; +-- +ok +== +CREATE TABLE t_del_target (id INTEGER); +-- +ok +== +INSERT INTO t_del_target VALUES (1), (2), (3); +-- +ok +== +CREATE TABLE t_counter (n INTEGER); +-- +ok +== +INSERT INTO t_counter VALUES (0); +-- +ok +== +CREATE TRIGGER trg_upd_body AFTER DELETE ON t_del_target FOR EACH STATEMENT + UPDATE t_counter SET n = n + 1; +-- +ok +== +DELETE FROM t_del_target WHERE id = 1; +-- +ok +== +SELECT n FROM t_counter; +-- +ok +== +DELETE FROM t_del_target WHERE id = 2; +-- +ok +== +CREATE TABLE t_del2_target (id INTEGER); +-- +ok +== +INSERT INTO t_del2_target VALUES (1); +-- +ok +== +CREATE TABLE t_scratch (id INTEGER); +-- +ok +== +INSERT INTO t_scratch VALUES (1), (2), (3); +-- +ok +== +CREATE TRIGGER trg_del_body AFTER DELETE ON t_del2_target FOR EACH STATEMENT + DELETE FROM t_scratch; +-- +ok +== +DELETE FROM t_del2_target; +-- +ok +== +SELECT COUNT(*) FROM t_scratch; +-- +ok +== diff --git a/parser/testdata/corpus/sql/trigger/trigger_after_delete_referencing.test b/parser/testdata/corpus/sql/trigger/trigger_after_delete_referencing.test new file mode 100644 index 0000000..fd6e24b --- /dev/null +++ b/parser/testdata/corpus/sql/trigger/trigger_after_delete_referencing.test @@ -0,0 +1,137 @@ +# source: test/sql/trigger/trigger_after_delete_referencing.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +CREATE TABLE target (id INTEGER, val VARCHAR); +-- +ok +== +CREATE TABLE audit (id INTEGER, val VARCHAR); +-- +ok +== +CREATE TRIGGER trg_ref AFTER DELETE ON target +REFERENCING OLD TABLE AS deleted +FOR EACH STATEMENT + INSERT INTO audit SELECT id, val FROM deleted; +-- +ok +== +INSERT INTO target VALUES (1, 'a'), (2, 'b'), (3, 'c'); +-- +ok +== +SELECT id, val FROM audit; +-- +ok +== +DELETE FROM target WHERE id IN (2, 3); +-- +ok +== +CREATE TABLE t_rows (id INTEGER); +-- +ok +== +CREATE TABLE t_rows_log (n INTEGER); +-- +ok +== +CREATE TRIGGER trg_rows AFTER DELETE ON t_rows +REFERENCING OLD TABLE AS old_rows +FOR EACH STATEMENT + INSERT INTO t_rows_log SELECT COUNT(*) FROM old_rows; +-- +ok +== +INSERT INTO t_rows VALUES (1), (2), (3), (4), (5); +-- +ok +== +DELETE FROM t_rows WHERE id <= 3; +-- +ok +== +SELECT n FROM t_rows_log; +-- +ok +== +DELETE FROM t_rows WHERE id > 3; +-- +ok +== +CREATE TABLE t_agg (val INTEGER); +-- +ok +== +CREATE TABLE t_agg_log (total INTEGER, cnt INTEGER); +-- +ok +== +CREATE TRIGGER trg_agg AFTER DELETE ON t_agg +REFERENCING OLD TABLE AS old_vals +FOR EACH STATEMENT + INSERT INTO t_agg_log SELECT SUM(val), COUNT(*) FROM old_vals; +-- +ok +== +INSERT INTO t_agg VALUES (10), (20), (30); +-- +ok +== +DELETE FROM t_agg WHERE val <= 20; +-- +ok +== +SELECT total, cnt FROM t_agg_log; +-- +ok +== +CREATE TABLE t_tosql (id INTEGER); +-- +ok +== +CREATE TABLE t_tosql_log (id INTEGER); +-- +ok +== +CREATE TRIGGER trg_tosql AFTER DELETE ON t_tosql +REFERENCING OLD TABLE AS del +FOR EACH STATEMENT + INSERT INTO t_tosql_log SELECT id FROM del; +-- +ok +== +SELECT sql LIKE '%REFERENCING OLD TABLE AS del%' FROM duckdb_triggers() WHERE trigger_name = 'trg_tosql'; +-- +ok +== +CREATE TABLE t_old_alias_shadow (i INTEGER); +-- +ok +== +CREATE TABLE log_old_alias_shadow (s VARCHAR); +-- +ok +== +CREATE TRIGGER tr_old_alias_shadow AFTER DELETE ON t_old_alias_shadow +REFERENCING OLD TABLE AS o +FOR EACH STATEMENT + WITH o AS (SELECT 'local' AS s) + INSERT INTO log_old_alias_shadow SELECT s FROM o; +-- +ok +== +INSERT INTO t_old_alias_shadow VALUES (1); +-- +ok +== +DELETE FROM t_old_alias_shadow; +-- +ok +== +SELECT s FROM log_old_alias_shadow; +-- +ok +== diff --git a/parser/testdata/corpus/sql/trigger/trigger_after_insert.test b/parser/testdata/corpus/sql/trigger/trigger_after_insert.test new file mode 100644 index 0000000..59a04f4 --- /dev/null +++ b/parser/testdata/corpus/sql/trigger/trigger_after_insert.test @@ -0,0 +1,359 @@ +# source: test/sql/trigger/trigger_after_insert.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +CREATE TRIGGER trg_basic AFTER INSERT ON target FOR EACH STATEMENT + INSERT INTO audit VALUES ('inserted'); +-- +ok +== +INSERT INTO target VALUES (1); +-- +ok +== +INSERT INTO target VALUES (2); +-- +ok +== +INSERT INTO target VALUES (10), (11), (12); +-- +ok +== +CREATE TABLE multi_target (id INTEGER); +-- +ok +== +CREATE TABLE multi_audit (fired_id INTEGER); +-- +ok +== +CREATE TRIGGER trg_multi AFTER INSERT ON multi_target FOR EACH ROW + INSERT INTO multi_audit VALUES (NEW.id); +-- +ok +== +INSERT INTO multi_target VALUES (1), (2), (3); +-- +ok +== +SELECT COUNT(*) FROM multi_audit; +-- +ok +== +CREATE TRIGGER trg_fail AFTER INSERT ON strict_target FOR EACH STATEMENT + INSERT INTO strict_log VALUES (999); +-- +ok +== +CREATE TRIGGER trg_multi_a AFTER INSERT ON t_multi FOR EACH STATEMENT + INSERT INTO t_multi_audit VALUES ('a'); +-- +ok +== +CREATE TRIGGER trg_multi_b AFTER INSERT ON t_multi FOR EACH STATEMENT + INSERT INTO t_multi_audit VALUES ('b'); +-- +ok +== +CREATE TABLE t_validate (id INTEGER); +-- +ok +== +CREATE TRIGGER trg_bad_table AFTER INSERT ON t_validate FOR EACH STATEMENT + INSERT INTO nonexistent_table VALUES (1); +-- +ok +== +CREATE TABLE t_no_fire (id INTEGER UNIQUE); +-- +ok +== +CREATE TABLE t_no_fire_log (msg VARCHAR); +-- +ok +== +INSERT INTO t_no_fire VALUES (1); +-- +ok +== +CREATE TRIGGER trg_no_fire AFTER INSERT ON t_no_fire FOR EACH STATEMENT + INSERT INTO t_no_fire_log VALUES ('fired'); +-- +ok +== +SELECT COUNT(*) FROM t_no_fire_log; +-- +ok +== +CREATE TABLE t_zero (id INTEGER); +-- +ok +== +CREATE TABLE t_zero_log (msg VARCHAR); +-- +ok +== +CREATE TRIGGER trg_zero AFTER INSERT ON t_zero FOR EACH STATEMENT + INSERT INTO t_zero_log VALUES ('fired'); +-- +ok +== +INSERT INTO t_zero SELECT * FROM t_zero; +-- +ok +== +SELECT COUNT(*) FROM t_zero_log; +-- +ok +== +CREATE TABLE t_upd_target (id INTEGER); +-- +ok +== +CREATE TABLE t_upd_counter (n INTEGER); +-- +ok +== +INSERT INTO t_upd_counter VALUES (0); +-- +ok +== +CREATE TRIGGER trg_upd_body AFTER INSERT ON t_upd_target FOR EACH STATEMENT + UPDATE t_upd_counter SET n = n + 1; +-- +ok +== +INSERT INTO t_upd_target VALUES (1); +-- +ok +== +SELECT n FROM t_upd_counter; +-- +ok +== +INSERT INTO t_upd_target VALUES (2); +-- +ok +== +CREATE TABLE t_del_scratch (id INTEGER); +-- +ok +== +INSERT INTO t_del_scratch VALUES (1), (2), (3); +-- +ok +== +CREATE TRIGGER trg_del_body AFTER INSERT ON t_del_target FOR EACH STATEMENT + DELETE FROM t_del_scratch; +-- +ok +== +INSERT INTO t_del_target VALUES (99); +-- +ok +== +SELECT COUNT(*) FROM t_del_scratch; +-- +ok +== +CREATE TABLE other_schema.cross_log (msg VARCHAR); +-- +ok +== +CREATE TABLE t_cross (id INTEGER); +-- +ok +== +CREATE TRIGGER trg_cross AFTER INSERT ON t_cross FOR EACH STATEMENT + INSERT INTO other_schema.cross_log VALUES ('cross'); +-- +ok +== +INSERT INTO t_cross VALUES (1); +-- +ok +== +SELECT COUNT(*) FROM other_schema.cross_log; +-- +ok +== +CREATE TABLE t_conflict (id INTEGER PRIMARY KEY); +-- +ok +== +CREATE TABLE t_conflict_log (msg VARCHAR); +-- +ok +== +CREATE TRIGGER trg_conflict AFTER INSERT ON t_conflict FOR EACH STATEMENT + INSERT INTO t_conflict_log VALUES ('fired'); +-- +ok +== +INSERT INTO t_conflict VALUES (1); +-- +ok +== +SELECT COUNT(*) FROM t_conflict_log; +-- +ok +== +INSERT INTO t_conflict VALUES (1) ON CONFLICT DO NOTHING; +-- +ok +== +CREATE TABLE t_upsert (id INTEGER PRIMARY KEY, val INTEGER); +-- +ok +== +CREATE TABLE t_upsert_log (msg VARCHAR); +-- +ok +== +CREATE TRIGGER trg_upsert AFTER INSERT ON t_upsert FOR EACH STATEMENT + INSERT INTO t_upsert_log VALUES ('fired'); +-- +ok +== +INSERT INTO t_upsert VALUES (1, 10); +-- +ok +== +INSERT INTO t_upsert VALUES (1, 99) ON CONFLICT (id) DO UPDATE SET val = excluded.val; +-- +ok +== +SELECT val FROM t_upsert WHERE id = 1; +-- +ok +== +SELECT COUNT(*) FROM t_upsert_log; +-- +ok +== +CREATE TABLE t_chain_a (id INTEGER); +-- +ok +== +CREATE TABLE t_chain_b (msg VARCHAR); +-- +ok +== +CREATE TABLE t_chain_c (msg VARCHAR); +-- +ok +== +CREATE TRIGGER trg_chain_b AFTER INSERT ON t_chain_b FOR EACH STATEMENT + INSERT INTO t_chain_c VALUES ('fired from b'); +-- +ok +== +CREATE TRIGGER trg_chain_a AFTER INSERT ON t_chain_a FOR EACH STATEMENT + INSERT INTO t_chain_b VALUES ('fired from a'); +-- +ok +== +INSERT INTO t_chain_a VALUES (1); +-- +ok +== +SELECT COUNT(*) FROM t_chain_b; +-- +ok +== +SELECT COUNT(*) FROM t_chain_c; +-- +ok +== +CREATE TABLE t_mutual_a (id INTEGER); +-- +ok +== +CREATE TABLE t_mutual_b (id INTEGER); +-- +ok +== +CREATE TRIGGER trg_mutual_a AFTER INSERT ON t_mutual_a FOR EACH STATEMENT + INSERT INTO t_mutual_b VALUES (1); +-- +ok +== +CREATE TRIGGER trg_mutual_b AFTER INSERT ON t_mutual_b FOR EACH STATEMENT + INSERT INTO t_mutual_a VALUES (1); +-- +ok +== +CREATE TABLE t_recursive (id INTEGER); +-- +ok +== +CREATE TRIGGER trg_recursive AFTER INSERT ON t_recursive FOR EACH STATEMENT + INSERT INTO t_recursive VALUES (1); +-- +ok +== +CREATE TABLE t_nn (id INTEGER NOT NULL); +-- +ok +== +CREATE TABLE t_nn_log (msg VARCHAR); +-- +ok +== +CREATE TRIGGER trg_nn AFTER INSERT ON t_nn FOR EACH STATEMENT + INSERT INTO t_nn_log VALUES ('fired'); +-- +ok +== +INSERT INTO t_nn VALUES (NULL); +-- +ok +== +SELECT COUNT(*) FROM t_nn_log; +-- +ok +== +CREATE TABLE t_returning (id INTEGER); +-- +ok +== +CREATE TABLE t_returning_log (msg VARCHAR); +-- +ok +== +CREATE TRIGGER trg_returning AFTER INSERT ON t_returning FOR EACH STATEMENT + INSERT INTO t_returning_log VALUES ('fired'); +-- +ok +== +INSERT INTO t_returning VALUES (1) RETURNING id; +-- +ok +== +CREATE TABLE t_merge_target (id INTEGER PRIMARY KEY, val INTEGER); +-- +ok +== +CREATE TABLE t_merge_source (id INTEGER, val INTEGER); +-- +ok +== +INSERT INTO t_merge_source VALUES (1, 100); +-- +ok +== +CREATE TABLE t_merge_log (msg VARCHAR); +-- +ok +== +CREATE TRIGGER trg_merge AFTER INSERT ON t_merge_target FOR EACH STATEMENT + INSERT INTO t_merge_log VALUES ('fired'); +-- +ok +== +MERGE INTO t_merge_target t USING t_merge_source s ON t.id = s.id + WHEN NOT MATCHED THEN INSERT VALUES (s.id, s.val); +-- +ok +== diff --git a/parser/testdata/corpus/sql/trigger/trigger_after_insert_referencing.test b/parser/testdata/corpus/sql/trigger/trigger_after_insert_referencing.test new file mode 100644 index 0000000..99591d3 --- /dev/null +++ b/parser/testdata/corpus/sql/trigger/trigger_after_insert_referencing.test @@ -0,0 +1,243 @@ +# source: test/sql/trigger/trigger_after_insert_referencing.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +CREATE TRIGGER trg_ref AFTER INSERT ON target +REFERENCING NEW TABLE AS inserted +FOR EACH STATEMENT + INSERT INTO audit SELECT id, val FROM inserted; +-- +ok +== +INSERT INTO target VALUES (1, 'a'); +-- +ok +== +SELECT id, val FROM target; +-- +ok +== +INSERT INTO target VALUES (2, 'b'), (3, 'c'), (4, 'd'); +-- +ok +== +CREATE TRIGGER trg_rows AFTER INSERT ON t_rows +REFERENCING NEW TABLE AS new_rows +FOR EACH STATEMENT + INSERT INTO t_rows_log SELECT COUNT(*) FROM new_rows; +-- +ok +== +INSERT INTO t_rows VALUES (1), (2), (3); +-- +ok +== +INSERT INTO t_rows VALUES (10), (20); +-- +ok +== +CREATE TABLE t_plain (id INTEGER); +-- +ok +== +CREATE TABLE t_plain_log (msg VARCHAR); +-- +ok +== +CREATE TRIGGER trg_plain AFTER INSERT ON t_plain FOR EACH STATEMENT + INSERT INTO t_plain_log VALUES ('fired'); +-- +ok +== +INSERT INTO t_plain VALUES (1); +-- +ok +== +SELECT COUNT(*) FROM t_plain_log; +-- +ok +== +CREATE TRIGGER trg_tosql AFTER INSERT ON t_tosql +REFERENCING NEW TABLE AS ins +FOR EACH STATEMENT + INSERT INTO t_tosql_log SELECT id FROM ins; +-- +ok +== +SELECT sql LIKE '%REFERENCING NEW TABLE AS ins%' FROM duckdb_triggers() WHERE trigger_name = 'trg_tosql'; +-- +ok +== +CREATE TRIGGER trg_agg AFTER INSERT ON t_agg +REFERENCING NEW TABLE AS new_vals +FOR EACH STATEMENT + INSERT INTO t_agg_log SELECT SUM(val), COUNT(*) FROM new_vals; +-- +ok +== +CREATE TABLE t_conflict_log (id INTEGER); +-- +ok +== +CREATE TRIGGER trg_conflict AFTER INSERT ON t_conflict +REFERENCING NEW TABLE AS ins +FOR EACH STATEMENT + INSERT INTO t_conflict_log SELECT id FROM ins; +-- +ok +== +INSERT INTO t_conflict VALUES (1), (2), (3) ON CONFLICT DO NOTHING; +-- +ok +== +SELECT id FROM t_conflict_log; +-- +ok +== +CREATE TABLE t_upsert_log (id INTEGER, val INTEGER); +-- +ok +== +INSERT INTO t_upsert VALUES (1, 100); +-- +ok +== +CREATE TRIGGER trg_upsert AFTER INSERT ON t_upsert +REFERENCING NEW TABLE AS ins +FOR EACH STATEMENT + INSERT INTO t_upsert_log SELECT id, val FROM ins; +-- +ok +== +INSERT INTO t_upsert VALUES (1, 999), (2, 200) ON CONFLICT (id) DO UPDATE SET val = excluded.val; +-- +ok +== +CREATE TABLE t_rollback (id INTEGER); +-- +ok +== +CREATE TABLE t_rollback_log (id INTEGER UNIQUE); +-- +ok +== +INSERT INTO t_rollback_log VALUES (999); +-- +ok +== +CREATE TRIGGER trg_rollback AFTER INSERT ON t_rollback +REFERENCING NEW TABLE AS ins +FOR EACH STATEMENT + INSERT INTO t_rollback_log SELECT id FROM ins; +-- +ok +== +INSERT INTO t_rollback VALUES (999); +-- +ok +== +SELECT COUNT(*) FROM t_rollback; +-- +ok +== +CREATE TABLE t_naming (id INTEGER); +-- +ok +== +CREATE TABLE t_naming_log (id INTEGER); +-- +ok +== +CREATE TRIGGER trg_naming AFTER INSERT ON t_naming +REFERENCING NEW TABLE AS __duckdb_trigger_base +FOR EACH STATEMENT + INSERT INTO t_naming_log SELECT id FROM __duckdb_trigger_base; +-- +ok +== +INSERT INTO t_naming VALUES (42); +-- +ok +== +SELECT id FROM t_naming_log; +-- +ok +== +CREATE TABLE __duckdb_trigger_base (id INTEGER); +-- +ok +== +INSERT INTO __duckdb_trigger_base VALUES (999); +-- +ok +== +CREATE TABLE t_real_ref (id INTEGER); +-- +ok +== +CREATE TABLE t_real_ref_log (id INTEGER); +-- +ok +== +CREATE TRIGGER trg_real_ref AFTER INSERT ON t_real_ref FOR EACH STATEMENT + INSERT INTO t_real_ref_log SELECT id FROM __duckdb_trigger_base; +-- +ok +== +INSERT INTO t_real_ref VALUES (1); +-- +ok +== +SELECT id FROM t_real_ref_log; +-- +ok +== +CREATE TABLE t_cte_scope (id INTEGER); +-- +ok +== +CREATE TABLE t_cte_scope_log (id INTEGER); +-- +ok +== +CREATE TRIGGER trg_cte_scope AFTER INSERT ON t_cte_scope +REFERENCING NEW TABLE AS ins +FOR EACH STATEMENT + INSERT INTO t_cte_scope_log SELECT id FROM ins; +-- +ok +== +WITH __duckdb_trigger_base AS (SELECT 7 as id) +INSERT INTO t_cte_scope SELECT id FROM __duckdb_trigger_base; +-- +ok +== +SELECT id FROM t_cte_scope_log; +-- +ok +== +CREATE TABLE t_alias_shadow (i INTEGER); +-- +ok +== +CREATE TABLE log_alias_shadow (s VARCHAR); +-- +ok +== +CREATE TRIGGER tr_alias_shadow AFTER INSERT ON t_alias_shadow +REFERENCING NEW TABLE AS n +FOR EACH STATEMENT + WITH n AS (SELECT 'local' AS s) + INSERT INTO log_alias_shadow SELECT s FROM n; +-- +ok +== +INSERT INTO t_alias_shadow VALUES (1); +-- +ok +== +SELECT s FROM log_alias_shadow; +-- +ok +== diff --git a/parser/testdata/corpus/sql/trigger/trigger_after_update.test b/parser/testdata/corpus/sql/trigger/trigger_after_update.test new file mode 100644 index 0000000..6113532 --- /dev/null +++ b/parser/testdata/corpus/sql/trigger/trigger_after_update.test @@ -0,0 +1,212 @@ +# source: test/sql/trigger/trigger_after_update.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +CREATE TABLE target (id INTEGER, val INTEGER); +-- +ok +== +INSERT INTO target VALUES (1, 10), (2, 20), (3, 30); +-- +ok +== +CREATE TRIGGER trg_basic AFTER UPDATE ON target FOR EACH STATEMENT + INSERT INTO audit VALUES ('updated'); +-- +ok +== +UPDATE target SET val = 99 WHERE id = 1; +-- +ok +== +UPDATE target SET val = 100 WHERE id = 2; +-- +ok +== +UPDATE target SET val = 0; +-- +ok +== +CREATE TRIGGER trg_row AFTER UPDATE ON target FOR EACH ROW + INSERT INTO audit VALUES ('row'); +-- +ok +== +CREATE TABLE strict_target (id INTEGER, val INTEGER); +-- +ok +== +INSERT INTO strict_target VALUES (1, 0); +-- +ok +== +CREATE TRIGGER trg_fail AFTER UPDATE ON strict_target FOR EACH STATEMENT + INSERT INTO strict_log VALUES (999); +-- +ok +== +UPDATE strict_target SET val = 1; +-- +ok +== +SELECT val FROM strict_target; +-- +ok +== +CREATE TRIGGER trg_multi_a AFTER UPDATE ON t_multi FOR EACH STATEMENT + INSERT INTO t_multi_audit VALUES ('a'); +-- +ok +== +CREATE TRIGGER trg_multi_b AFTER UPDATE ON t_multi FOR EACH STATEMENT + INSERT INTO t_multi_audit VALUES ('b'); +-- +ok +== +UPDATE t_multi SET id = 2; +-- +ok +== +CREATE TABLE t_upd_target (id INTEGER, val INTEGER); +-- +ok +== +INSERT INTO t_upd_target VALUES (1, 0); +-- +ok +== +CREATE TRIGGER trg_del_body AFTER UPDATE ON t_upd_target FOR EACH STATEMENT + DELETE FROM t_scratch; +-- +ok +== +UPDATE t_upd_target SET val = 1; +-- +ok +== +CREATE TABLE t_upd2_target (id INTEGER, val INTEGER); +-- +ok +== +INSERT INTO t_upd2_target VALUES (1, 0); +-- +ok +== +CREATE TRIGGER trg_upd_body AFTER UPDATE ON t_upd2_target FOR EACH STATEMENT + UPDATE t_counter SET n = n + 1; +-- +ok +== +UPDATE t_upd2_target SET val = 1; +-- +ok +== +UPDATE t_upd2_target SET val = 2; +-- +ok +== +CREATE TABLE t_col (id INTEGER, val INTEGER, other INTEGER); +-- +ok +== +INSERT INTO t_col VALUES (1, 10, 100); +-- +ok +== +CREATE TABLE t_col_audit (msg VARCHAR); +-- +ok +== +CREATE TRIGGER trg_col AFTER UPDATE OF val ON t_col FOR EACH STATEMENT + INSERT INTO t_col_audit VALUES ('val_changed'); +-- +ok +== +UPDATE t_col SET val = 20 WHERE id = 1; +-- +ok +== +SELECT COUNT(*) FROM t_col_audit; +-- +ok +== +UPDATE t_col SET other = 200 WHERE id = 1; +-- +ok +== +UPDATE t_col SET val = 30, other = 300 WHERE id = 1; +-- +ok +== +CREATE TABLE t_multi_col (a INTEGER, b INTEGER, c INTEGER); +-- +ok +== +INSERT INTO t_multi_col VALUES (1, 2, 3); +-- +ok +== +CREATE TABLE t_multi_col_audit (msg VARCHAR); +-- +ok +== +CREATE TRIGGER trg_multi_col AFTER UPDATE OF a, b ON t_multi_col FOR EACH STATEMENT + INSERT INTO t_multi_col_audit VALUES ('ab_changed'); +-- +ok +== +UPDATE t_multi_col SET a = 10; +-- +ok +== +SELECT COUNT(*) FROM t_multi_col_audit; +-- +ok +== +UPDATE t_multi_col SET b = 20; +-- +ok +== +UPDATE t_multi_col SET c = 30; +-- +ok +== +UPDATE t_multi_col SET a = 100, c = 300; +-- +ok +== +CREATE TABLE t_mix (a INTEGER, b INTEGER); +-- +ok +== +INSERT INTO t_mix VALUES (1, 2); +-- +ok +== +CREATE TABLE t_mix_audit (phase VARCHAR); +-- +ok +== +CREATE TRIGGER trg_mix_before BEFORE UPDATE OF a ON t_mix FOR EACH STATEMENT + INSERT INTO t_mix_audit VALUES ('before'); +-- +ok +== +CREATE TRIGGER trg_mix_after AFTER UPDATE OF a ON t_mix FOR EACH STATEMENT + INSERT INTO t_mix_audit VALUES ('after'); +-- +ok +== +UPDATE t_mix SET a = 10; +-- +ok +== +SELECT COUNT(*) FROM t_mix_audit; +-- +ok +== +UPDATE t_mix SET b = 20; +-- +ok +== diff --git a/parser/testdata/corpus/sql/trigger/trigger_after_update_old_new.test b/parser/testdata/corpus/sql/trigger/trigger_after_update_old_new.test new file mode 100644 index 0000000..f0d45f6 --- /dev/null +++ b/parser/testdata/corpus/sql/trigger/trigger_after_update_old_new.test @@ -0,0 +1,445 @@ +# source: test/sql/trigger/trigger_after_update_old_new.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +CREATE TABLE old_audit (id INTEGER, val INTEGER); +-- +ok +== +CREATE TRIGGER trg_old AFTER UPDATE ON target +REFERENCING OLD TABLE AS o +FOR EACH STATEMENT + INSERT INTO old_audit SELECT id, val FROM o; +-- +ok +== +UPDATE target SET val = val + 5 WHERE id = 1; +-- +ok +== +SELECT id, val FROM old_audit; +-- +ok +== +CREATE TABLE both_audit (id INTEGER, old_val INTEGER, new_val INTEGER); +-- +ok +== +CREATE TRIGGER trg_both AFTER UPDATE ON target +REFERENCING OLD TABLE AS o NEW TABLE AS n +FOR EACH STATEMENT + INSERT INTO both_audit SELECT n.id, o.val, n.val FROM o JOIN n ON o.id = n.id; +-- +ok +== +UPDATE target SET val = val * 10 WHERE id <= 2; +-- +ok +== +SELECT id, old_val, new_val FROM both_audit; +-- +ok +== +CREATE TABLE t2 (id INTEGER, val INTEGER); +-- +ok +== +CREATE TABLE t2_audit (id INTEGER, old_val INTEGER, new_val INTEGER); +-- +ok +== +INSERT INTO t2 VALUES (1, 100), (2, 200); +-- +ok +== +CREATE TRIGGER trg_no AFTER UPDATE ON t2 +REFERENCING NEW TABLE AS n OLD TABLE AS o +FOR EACH STATEMENT + INSERT INTO t2_audit SELECT o.id, o.val, n.val FROM o JOIN n ON o.id = n.id; +-- +ok +== +UPDATE t2 SET val = val + 1; +-- +ok +== +SELECT id, old_val, new_val FROM t2_audit; +-- +ok +== +CREATE TABLE t_zero (id INTEGER, val INTEGER); +-- +ok +== +CREATE TABLE t_zero_log (old_cnt INTEGER, new_cnt INTEGER); +-- +ok +== +INSERT INTO t_zero VALUES (1, 10); +-- +ok +== +CREATE TRIGGER trg_zero AFTER UPDATE ON t_zero +REFERENCING OLD TABLE AS o NEW TABLE AS n +FOR EACH STATEMENT + INSERT INTO t_zero_log SELECT (SELECT COUNT(*) FROM o), (SELECT COUNT(*) FROM n); +-- +ok +== +UPDATE t_zero SET val = 99 WHERE id = 999; +-- +ok +== +SELECT old_cnt, new_cnt FROM t_zero_log; +-- +ok +== +CREATE TABLE t_noop (id INTEGER, val INTEGER); +-- +ok +== +CREATE TABLE t_noop_log (id INTEGER, old_val INTEGER, new_val INTEGER); +-- +ok +== +INSERT INTO t_noop VALUES (1, 7), (2, 8); +-- +ok +== +CREATE TRIGGER trg_noop AFTER UPDATE ON t_noop +REFERENCING OLD TABLE AS o NEW TABLE AS n +FOR EACH STATEMENT + INSERT INTO t_noop_log SELECT o.id, o.val, n.val FROM o JOIN n ON o.id = n.id; +-- +ok +== +UPDATE t_noop SET val = val; +-- +ok +== +SELECT id, old_val, new_val FROM t_noop_log; +-- +ok +== +CREATE TABLE t_from (id INTEGER, val INTEGER); +-- +ok +== +CREATE TABLE t_src (id INTEGER, v INTEGER); +-- +ok +== +CREATE TABLE t_from_log (id INTEGER, old_val INTEGER, new_val INTEGER); +-- +ok +== +INSERT INTO t_from VALUES (1, 1), (2, 2), (3, 3); +-- +ok +== +INSERT INTO t_src VALUES (1, 111), (2, 222); +-- +ok +== +CREATE TRIGGER trg_from AFTER UPDATE ON t_from +REFERENCING OLD TABLE AS o NEW TABLE AS n +FOR EACH STATEMENT + INSERT INTO t_from_log SELECT o.id, o.val, n.val FROM o JOIN n ON o.id = n.id; +-- +ok +== +UPDATE t_from SET val = t_src.v FROM t_src WHERE t_from.id = t_src.id; +-- +ok +== +SELECT id, old_val, new_val FROM t_from_log; +-- +ok +== +CREATE TABLE t_vol (id INTEGER, val INTEGER); +-- +ok +== +CREATE SEQUENCE seq_vol START 1; +-- +ok +== +CREATE TABLE t_vol_log (id INTEGER, new_val INTEGER); +-- +ok +== +INSERT INTO t_vol VALUES (1, 0), (2, 0), (3, 0); +-- +ok +== +CREATE TRIGGER trg_vol AFTER UPDATE ON t_vol +REFERENCING NEW TABLE AS n +FOR EACH STATEMENT + INSERT INTO t_vol_log SELECT id, val FROM n; +-- +ok +== +UPDATE t_vol SET val = nextval('seq_vol'); +-- +ok +== +SELECT COUNT(*) FROM t_vol_log l JOIN t_vol t ON l.id = t.id AND l.new_val = t.val; +-- +ok +== +SELECT MAX(new_val) - MIN(new_val) FROM t_vol_log; +-- +ok +== +CREATE TABLE t_di (id INTEGER, val INTEGER); +-- +ok +== +CREATE TABLE t_di_log (id INTEGER, old_val INTEGER, new_val INTEGER); +-- +ok +== +INSERT INTO t_di VALUES (1, 10), (2, 20), (3, 30); +-- +ok +== +CREATE TRIGGER trg_di AFTER UPDATE ON t_di +REFERENCING OLD TABLE AS o NEW TABLE AS n +FOR EACH STATEMENT + INSERT INTO t_di_log SELECT o.id, o.val, n.val FROM o JOIN n ON o.id = n.id; +-- +ok +== +SET force_update_to_del_and_insert = true; +-- +ok +== +UPDATE t_di SET val = val + 1 WHERE id >= 2; +-- +ok +== +SET force_update_to_del_and_insert = false; +-- +ok +== +SELECT id, old_val, new_val FROM t_di_log; +-- +ok +== +CREATE TABLE t_list (id INTEGER, vals INTEGER[]); +-- +ok +== +CREATE TABLE t_list_log (id INTEGER, old_len INTEGER, new_len INTEGER); +-- +ok +== +INSERT INTO t_list VALUES (1, [1, 2]), (2, [3, 4, 5]); +-- +ok +== +CREATE TRIGGER trg_list AFTER UPDATE ON t_list +REFERENCING OLD TABLE AS o NEW TABLE AS n +FOR EACH STATEMENT + INSERT INTO t_list_log SELECT o.id, len(o.vals), len(n.vals) FROM o JOIN n ON o.id = n.id; +-- +ok +== +UPDATE t_list SET vals = [9, 9, 9, 9] WHERE id = 1; +-- +ok +== +SELECT id, old_len, new_len FROM t_list_log; +-- +ok +== +CREATE TABLE t_gen (id INTEGER, a INTEGER, total INTEGER GENERATED ALWAYS AS (a * 2)); +-- +ok +== +CREATE TABLE t_gen_log (id INTEGER, old_a INTEGER, old_total INTEGER, new_a INTEGER, new_total INTEGER); +-- +ok +== +INSERT INTO t_gen (id, a) VALUES (1, 5), (2, 6); +-- +ok +== +CREATE TRIGGER trg_gen AFTER UPDATE ON t_gen +REFERENCING OLD TABLE AS o NEW TABLE AS n +FOR EACH STATEMENT + INSERT INTO t_gen_log SELECT o.id, o.a, o.total, n.a, n.total FROM o JOIN n ON o.id = n.id; +-- +ok +== +UPDATE t_gen SET a = 7 WHERE id = 1; +-- +ok +== +SELECT id, old_a, old_total, new_a, new_total FROM t_gen_log; +-- +ok +== +CREATE TABLE t_gen_order ( + x INTEGER, + g2 INTEGER GENERATED ALWAYS AS (g1 + 1), + g1 INTEGER GENERATED ALWAYS AS (x + 1) +); +-- +ok +== +CREATE TABLE t_gen_order_log (x INTEGER, g2 INTEGER, g1 INTEGER); +-- +ok +== +INSERT INTO t_gen_order (x) VALUES (1); +-- +ok +== +CREATE TRIGGER trg_gen_order AFTER UPDATE ON t_gen_order +REFERENCING OLD TABLE AS o +FOR EACH STATEMENT + INSERT INTO t_gen_order_log SELECT * FROM o; +-- +ok +== +UPDATE t_gen_order SET x = 10; +-- +ok +== +SELECT x, g2, g1 FROM t_gen_order_log; +-- +ok +== +CREATE TABLE t_ret (id INTEGER, val INTEGER); +-- +ok +== +CREATE TABLE t_ret_log (id INTEGER, old_val INTEGER, new_val INTEGER); +-- +ok +== +INSERT INTO t_ret VALUES (1, 10), (2, 20); +-- +ok +== +CREATE TRIGGER trg_ret AFTER UPDATE ON t_ret +REFERENCING OLD TABLE AS o NEW TABLE AS n +FOR EACH STATEMENT + INSERT INTO t_ret_log SELECT o.id, o.val, n.val FROM o JOIN n ON o.id = n.id; +-- +ok +== +UPDATE t_ret SET val = val + 100 RETURNING id, val; +-- +ok +== +SELECT id, old_val, new_val FROM t_ret_log; +-- +ok +== +CREATE TABLE t_shape (id INTEGER, val INTEGER); +-- +ok +== +CREATE TABLE t_shape_old (id INTEGER, val INTEGER); +-- +ok +== +CREATE TABLE t_shape_new (id INTEGER, val INTEGER); +-- +ok +== +INSERT INTO t_shape VALUES (1, 10); +-- +ok +== +CREATE TRIGGER trg_shape AFTER UPDATE ON t_shape +REFERENCING OLD TABLE AS o NEW TABLE AS n +FOR EACH STATEMENT + INSERT INTO t_shape_old SELECT * FROM o; +-- +ok +== +CREATE TRIGGER trg_shape_new AFTER UPDATE ON t_shape +REFERENCING NEW TABLE AS n +FOR EACH STATEMENT + INSERT INTO t_shape_new SELECT * FROM n; +-- +ok +== +UPDATE t_shape SET val = 20; +-- +ok +== +SELECT id, val FROM t_shape_old; +-- +ok +== +SELECT id, val FROM t_shape_new; +-- +ok +== +CREATE TABLE t_name (__duckdb_old_col_0 INTEGER, id INTEGER); +-- +ok +== +CREATE TABLE t_name_log (captured_old INTEGER, captured_id INTEGER); +-- +ok +== +INSERT INTO t_name VALUES (10, 1); +-- +ok +== +CREATE TRIGGER trg_name AFTER UPDATE ON t_name +REFERENCING OLD TABLE AS o +FOR EACH STATEMENT + INSERT INTO t_name_log SELECT o.__duckdb_old_col_0, o.id FROM o; +-- +ok +== +UPDATE t_name SET __duckdb_old_col_0 = 999 WHERE id = 1; +-- +ok +== +SELECT captured_old, captured_id FROM t_name_log; +-- +ok +== +SELECT __duckdb_old_col_0, id FROM t_name; +-- +ok +== +CREATE TABLE t_rb (id INTEGER, val INTEGER); +-- +ok +== +INSERT INTO t_rb VALUES (1, 10), (2, 20); +-- +ok +== +CREATE TABLE t_rb_unique (v INTEGER UNIQUE); +-- +ok +== +INSERT INTO t_rb_unique VALUES (999); +-- +ok +== +CREATE TRIGGER trg_rb AFTER UPDATE ON t_rb +REFERENCING OLD TABLE AS o NEW TABLE AS n +FOR EACH STATEMENT + INSERT INTO t_rb_unique SELECT 999 FROM o JOIN n ON o.id = n.id LIMIT 1; +-- +ok +== +UPDATE t_rb SET val = val + 1; +-- +ok +== +SELECT id, val FROM t_rb; +-- +ok +== diff --git a/parser/testdata/corpus/sql/trigger/trigger_after_update_old_new_wal.test b/parser/testdata/corpus/sql/trigger/trigger_after_update_old_new_wal.test new file mode 100644 index 0000000..f89e9b0 --- /dev/null +++ b/parser/testdata/corpus/sql/trigger/trigger_after_update_old_new_wal.test @@ -0,0 +1,36 @@ +# source: test/sql/trigger/trigger_after_update_old_new_wal.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +ATTACH '{TEST_DIR}/trigger_upd_old_new_wal.db' AS triggerdb (STORAGE_VERSION 'v2.0.0'); +-- +ok +== +CREATE TABLE audit (id INTEGER, old_val INTEGER, new_val INTEGER); +-- +ok +== +CREATE TRIGGER trg AFTER UPDATE ON target +REFERENCING OLD TABLE AS o NEW TABLE AS n +FOR EACH STATEMENT + INSERT INTO audit SELECT n.id, o.val, n.val FROM o JOIN n ON o.id = n.id; +-- +ok +== +ATTACH '{TEST_DIR}/trigger_upd_old_new_wal.db' AS triggerdb; +-- +ok +== +SELECT trigger_name, table_name, action_timing, event_manipulation FROM duckdb_triggers() WHERE database_name = 'triggerdb'; +-- +ok +== +UPDATE target SET val = val + 100 WHERE id = 1; +-- +ok +== +SELECT id, old_val, new_val FROM audit; +-- +ok +== diff --git a/parser/testdata/corpus/sql/trigger/trigger_after_update_referencing.test b/parser/testdata/corpus/sql/trigger/trigger_after_update_referencing.test new file mode 100644 index 0000000..09f22f2 --- /dev/null +++ b/parser/testdata/corpus/sql/trigger/trigger_after_update_referencing.test @@ -0,0 +1,93 @@ +# source: test/sql/trigger/trigger_after_update_referencing.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +CREATE TABLE audit (id INTEGER, val INTEGER); +-- +ok +== +INSERT INTO target VALUES (1, 100), (2, 200), (3, 300); +-- +ok +== +CREATE TRIGGER trg_ref AFTER UPDATE ON target +REFERENCING NEW TABLE AS updated +FOR EACH STATEMENT + INSERT INTO audit SELECT id, val FROM updated; +-- +ok +== +UPDATE target SET val = val + 1 WHERE id = 1; +-- +ok +== +SELECT id, val FROM target WHERE id = 1; +-- +ok +== +UPDATE target SET val = val * 10; +-- +ok +== +CREATE TABLE t_partial (id INTEGER, val INTEGER); +-- +ok +== +CREATE TABLE t_partial_log (n INTEGER); +-- +ok +== +INSERT INTO t_partial VALUES (1, 10), (2, 20), (3, 30); +-- +ok +== +CREATE TRIGGER trg_partial AFTER UPDATE ON t_partial +REFERENCING NEW TABLE AS changed +FOR EACH STATEMENT + INSERT INTO t_partial_log SELECT COUNT(*) FROM changed; +-- +ok +== +UPDATE t_partial SET val = val + 1 WHERE id <= 2; +-- +ok +== +SELECT n FROM t_partial_log; +-- +ok +== +CREATE TABLE t_agg (id INTEGER, val INTEGER); +-- +ok +== +INSERT INTO t_agg VALUES (1, 10), (2, 20), (3, 30); +-- +ok +== +CREATE TRIGGER trg_agg AFTER UPDATE ON t_agg +REFERENCING NEW TABLE AS new_vals +FOR EACH STATEMENT + INSERT INTO t_agg_log SELECT SUM(val), COUNT(*) FROM new_vals; +-- +ok +== +UPDATE t_agg SET val = val + 100 WHERE id >= 2; +-- +ok +== +CREATE TABLE t_zero_log (n INTEGER); +-- +ok +== +CREATE TRIGGER trg_zero AFTER UPDATE ON t_zero +REFERENCING NEW TABLE AS changed +FOR EACH STATEMENT + INSERT INTO t_zero_log SELECT COUNT(*) FROM changed; +-- +ok +== +SELECT n FROM t_zero_log; +-- +ok +== diff --git a/parser/testdata/corpus/sql/trigger/trigger_alter_table.test b/parser/testdata/corpus/sql/trigger/trigger_alter_table.test new file mode 100644 index 0000000..791c3f6 --- /dev/null +++ b/parser/testdata/corpus/sql/trigger/trigger_alter_table.test @@ -0,0 +1,33 @@ +# source: test/sql/trigger/trigger_alter_table.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +CREATE TABLE audit(x INTEGER); +-- +ok +== +CREATE TRIGGER tr AFTER INSERT ON t INSERT INTO audit VALUES (1); +-- +ok +== +SELECT COUNT(*) FROM duckdb_triggers(); +-- +ok +== +ALTER TABLE t DROP COLUMN j; +-- +ok +== +ALTER TABLE t ALTER COLUMN i SET NOT NULL; +-- +ok +== +ALTER TABLE t ALTER COLUMN i TYPE BIGINT; +-- +ok +== +ALTER TABLE t ADD PRIMARY KEY(i); +-- +ok +== diff --git a/parser/testdata/corpus/sql/trigger/trigger_before_after_mixed.test b/parser/testdata/corpus/sql/trigger/trigger_before_after_mixed.test new file mode 100644 index 0000000..176a69a --- /dev/null +++ b/parser/testdata/corpus/sql/trigger/trigger_before_after_mixed.test @@ -0,0 +1,191 @@ +# source: test/sql/trigger/trigger_before_after_mixed.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +CREATE TABLE log (seq INTEGER, label VARCHAR); +-- +ok +== +CREATE SEQUENCE log_seq; +-- +ok +== +CREATE TRIGGER trg_before BEFORE INSERT ON target FOR EACH STATEMENT + INSERT INTO log VALUES (nextval('log_seq'), 'before'); +-- +ok +== +CREATE TRIGGER trg_after AFTER INSERT ON target FOR EACH STATEMENT + INSERT INTO log VALUES (nextval('log_seq'), 'after'); +-- +ok +== +SELECT label, seq FROM log ORDER BY seq; +-- +ok +== +CREATE TABLE state_target (id INTEGER); +-- +ok +== +INSERT INTO state_target VALUES (1); +-- +ok +== +CREATE TABLE state_log (phase VARCHAR, observed_count INTEGER); +-- +ok +== +CREATE TRIGGER state_before BEFORE INSERT ON state_target FOR EACH STATEMENT + INSERT INTO state_log SELECT 'before', COUNT(*) FROM state_target; +-- +ok +== +CREATE TRIGGER state_after AFTER INSERT ON state_target FOR EACH STATEMENT + INSERT INTO state_log SELECT 'after', COUNT(*) FROM state_target; +-- +ok +== +INSERT INTO state_target VALUES (2); +-- +ok +== +SELECT phase, observed_count FROM state_log ORDER BY phase; +-- +ok +== +CREATE TABLE upd_target (id INTEGER, val INTEGER); +-- +ok +== +INSERT INTO upd_target VALUES (1, 10); +-- +ok +== +CREATE TABLE upd_log (phase VARCHAR, observed_val INTEGER); +-- +ok +== +CREATE TRIGGER upd_before BEFORE UPDATE ON upd_target FOR EACH STATEMENT + INSERT INTO upd_log SELECT 'before', val FROM upd_target WHERE id = 1; +-- +ok +== +CREATE TRIGGER upd_after AFTER UPDATE ON upd_target FOR EACH STATEMENT + INSERT INTO upd_log SELECT 'after', val FROM upd_target WHERE id = 1; +-- +ok +== +UPDATE upd_target SET val = 99 WHERE id = 1; +-- +ok +== +SELECT phase, observed_val FROM upd_log ORDER BY phase; +-- +ok +== +CREATE TABLE del_target (id INTEGER); +-- +ok +== +INSERT INTO del_target VALUES (1), (2), (3); +-- +ok +== +CREATE TABLE del_log (phase VARCHAR, observed_count INTEGER); +-- +ok +== +CREATE TRIGGER del_before BEFORE DELETE ON del_target FOR EACH STATEMENT + INSERT INTO del_log SELECT 'before', COUNT(*) FROM del_target; +-- +ok +== +CREATE TRIGGER del_after AFTER DELETE ON del_target FOR EACH STATEMENT + INSERT INTO del_log SELECT 'after', COUNT(*) FROM del_target; +-- +ok +== +DELETE FROM del_target WHERE id = 1; +-- +ok +== +SELECT phase, observed_count FROM del_log ORDER BY phase; +-- +ok +== +CREATE TABLE fail_target (id INTEGER); +-- +ok +== +CREATE TABLE fail_log (msg VARCHAR); +-- +ok +== +CREATE TABLE fail_unique (id INTEGER UNIQUE); +-- +ok +== +INSERT INTO fail_unique VALUES (777); +-- +ok +== +CREATE TRIGGER fail_before BEFORE INSERT ON fail_target FOR EACH STATEMENT + INSERT INTO fail_unique VALUES (777); +-- +ok +== +CREATE TRIGGER fail_after AFTER INSERT ON fail_target FOR EACH STATEMENT + INSERT INTO fail_log VALUES ('after_fired'); +-- +ok +== +INSERT INTO fail_target VALUES (1); +-- +ok +== +SELECT COUNT(*) FROM fail_target; +-- +ok +== +SELECT COUNT(*) FROM fail_log; +-- +ok +== +CREATE TABLE cyc_ba_a (id INTEGER); +-- +ok +== +CREATE TABLE cyc_ba_b (id INTEGER); +-- +ok +== +CREATE TRIGGER cyc_ba_before BEFORE INSERT ON cyc_ba_a FOR EACH STATEMENT + INSERT INTO cyc_ba_b VALUES (1); +-- +ok +== +CREATE TRIGGER cyc_ba_after AFTER INSERT ON cyc_ba_b FOR EACH STATEMENT + INSERT INTO cyc_ba_a VALUES (1); +-- +ok +== +CREATE TABLE cyc_ab_a (id INTEGER); +-- +ok +== +CREATE TABLE cyc_ab_b (id INTEGER); +-- +ok +== +CREATE TRIGGER cyc_ab_after AFTER INSERT ON cyc_ab_a FOR EACH STATEMENT + INSERT INTO cyc_ab_b VALUES (1); +-- +ok +== +CREATE TRIGGER cyc_ab_before BEFORE INSERT ON cyc_ab_b FOR EACH STATEMENT + INSERT INTO cyc_ab_a VALUES (1); +-- +ok +== diff --git a/parser/testdata/corpus/sql/trigger/trigger_before_delete.test b/parser/testdata/corpus/sql/trigger/trigger_before_delete.test new file mode 100644 index 0000000..f2a65b7 --- /dev/null +++ b/parser/testdata/corpus/sql/trigger/trigger_before_delete.test @@ -0,0 +1,76 @@ +# source: test/sql/trigger/trigger_before_delete.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +CREATE TRIGGER trg_basic BEFORE DELETE ON target FOR EACH STATEMENT + INSERT INTO audit VALUES ('deleting'); +-- +ok +== +SELECT COUNT(*) FROM target; +-- +ok +== +CREATE TABLE pre_target (id INTEGER); +-- +ok +== +INSERT INTO pre_target VALUES (1), (2), (3); +-- +ok +== +CREATE TABLE pre_audit (count_before INTEGER); +-- +ok +== +CREATE TRIGGER trg_pre BEFORE DELETE ON pre_target FOR EACH STATEMENT + INSERT INTO pre_audit SELECT COUNT(*) FROM pre_target; +-- +ok +== +DELETE FROM pre_target WHERE id = 1; +-- +ok +== +SELECT count_before FROM pre_audit; +-- +ok +== +SELECT COUNT(*) FROM pre_target; +-- +ok +== +CREATE TRIGGER trg_row BEFORE DELETE ON target FOR EACH ROW + INSERT INTO audit VALUES ('row'); +-- +ok +== +CREATE TRIGGER trg_ref BEFORE DELETE ON target REFERENCING OLD TABLE AS old_rows FOR EACH STATEMENT + INSERT INTO audit SELECT 'ref' FROM old_rows; +-- +ok +== +CREATE TRIGGER trg_fail BEFORE DELETE ON strict_target FOR EACH STATEMENT + INSERT INTO strict_log VALUES (999); +-- +ok +== +CREATE TRIGGER trg_multi_a BEFORE DELETE ON t_multi FOR EACH STATEMENT + INSERT INTO t_multi_audit VALUES ('a'); +-- +ok +== +CREATE TRIGGER trg_multi_b BEFORE DELETE ON t_multi FOR EACH STATEMENT + INSERT INTO t_multi_audit VALUES ('b'); +-- +ok +== +DELETE FROM target RETURNING id; +-- +ok +== +DROP TRIGGER trg_basic ON target; +-- +ok +== diff --git a/parser/testdata/corpus/sql/trigger/trigger_before_insert.test b/parser/testdata/corpus/sql/trigger/trigger_before_insert.test new file mode 100644 index 0000000..ab1a121 --- /dev/null +++ b/parser/testdata/corpus/sql/trigger/trigger_before_insert.test @@ -0,0 +1,87 @@ +# source: test/sql/trigger/trigger_before_insert.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +CREATE TRIGGER trg_basic BEFORE INSERT ON target FOR EACH STATEMENT + INSERT INTO audit VALUES ('inserting'); +-- +ok +== +INSERT INTO target VALUES (2, 20); +-- +ok +== +INSERT INTO target VALUES (3, 30), (4, 40), (5, 50); +-- +ok +== +CREATE TRIGGER trg_pre BEFORE INSERT ON pre_target FOR EACH STATEMENT + INSERT INTO pre_audit SELECT COUNT(*) FROM pre_target; +-- +ok +== +INSERT INTO pre_target VALUES (4); +-- +ok +== +CREATE TRIGGER trg_row BEFORE INSERT ON target FOR EACH ROW + INSERT INTO audit VALUES ('row'); +-- +ok +== +CREATE TRIGGER trg_ref BEFORE INSERT ON target REFERENCING NEW TABLE AS new_rows FOR EACH STATEMENT + INSERT INTO audit SELECT 'ref' FROM new_rows; +-- +ok +== +CREATE TRIGGER trg_fail BEFORE INSERT ON strict_target FOR EACH STATEMENT + INSERT INTO strict_log VALUES (999); +-- +ok +== +CREATE TRIGGER trg_multi_a BEFORE INSERT ON t_multi FOR EACH STATEMENT + INSERT INTO t_multi_audit VALUES ('a'); +-- +ok +== +CREATE TRIGGER trg_multi_b BEFORE INSERT ON t_multi FOR EACH STATEMENT + INSERT INTO t_multi_audit VALUES ('b'); +-- +ok +== +CREATE TRIGGER trg_del_body BEFORE INSERT ON t_del_target FOR EACH STATEMENT + DELETE FROM t_scratch; +-- +ok +== +INSERT INTO t_del_target VALUES (1); +-- +ok +== +CREATE TRIGGER trg_upd_body BEFORE INSERT ON t_upd_target FOR EACH STATEMENT + UPDATE t_counter SET n = n + 1; +-- +ok +== +INSERT INTO target VALUES (99, 99) RETURNING id; +-- +ok +== +CREATE TABLE rec_a (id INTEGER); +-- +ok +== +CREATE TABLE rec_b (id INTEGER); +-- +ok +== +CREATE TRIGGER trg_cycle BEFORE INSERT ON rec_a FOR EACH STATEMENT + INSERT INTO rec_a VALUES (1); +-- +ok +== +INSERT INTO target VALUES (100, 100); +-- +ok +== diff --git a/parser/testdata/corpus/sql/trigger/trigger_before_update.test b/parser/testdata/corpus/sql/trigger/trigger_before_update.test new file mode 100644 index 0000000..8815e0d --- /dev/null +++ b/parser/testdata/corpus/sql/trigger/trigger_before_update.test @@ -0,0 +1,111 @@ +# source: test/sql/trigger/trigger_before_update.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +CREATE TRIGGER trg_basic BEFORE UPDATE ON target FOR EACH STATEMENT + INSERT INTO audit VALUES ('updating'); +-- +ok +== +SELECT val FROM target WHERE id = 1; +-- +ok +== +CREATE TABLE pre_target (id INTEGER, val INTEGER); +-- +ok +== +INSERT INTO pre_target VALUES (1, 10); +-- +ok +== +CREATE TABLE pre_audit (val_before INTEGER); +-- +ok +== +CREATE TRIGGER trg_pre BEFORE UPDATE ON pre_target FOR EACH STATEMENT + INSERT INTO pre_audit SELECT val FROM pre_target WHERE id = 1; +-- +ok +== +UPDATE pre_target SET val = 999 WHERE id = 1; +-- +ok +== +SELECT val_before FROM pre_audit; +-- +ok +== +SELECT val FROM pre_target WHERE id = 1; +-- +ok +== +CREATE TRIGGER trg_row BEFORE UPDATE ON target FOR EACH ROW + INSERT INTO audit VALUES ('row'); +-- +ok +== +CREATE TRIGGER trg_ref BEFORE UPDATE ON target REFERENCING OLD TABLE AS old_rows FOR EACH STATEMENT + INSERT INTO audit SELECT 'ref' FROM old_rows; +-- +ok +== +CREATE TRIGGER trg_fail BEFORE UPDATE ON strict_target FOR EACH STATEMENT + INSERT INTO strict_log VALUES (999); +-- +ok +== +CREATE TRIGGER trg_multi_a BEFORE UPDATE ON t_multi FOR EACH STATEMENT + INSERT INTO t_multi_audit VALUES ('a'); +-- +ok +== +CREATE TRIGGER trg_multi_b BEFORE UPDATE ON t_multi FOR EACH STATEMENT + INSERT INTO t_multi_audit VALUES ('b'); +-- +ok +== +CREATE TRIGGER trg_col BEFORE UPDATE OF val ON t_col FOR EACH STATEMENT + INSERT INTO t_col_audit VALUES ('val_changed'); +-- +ok +== +CREATE TRIGGER trg_multi_col BEFORE UPDATE OF a, b ON t_multi_col FOR EACH STATEMENT + INSERT INTO t_multi_col_audit VALUES ('ab_changed'); +-- +ok +== +CREATE TABLE t_case (val INTEGER); +-- +ok +== +INSERT INTO t_case VALUES (1); +-- +ok +== +CREATE TABLE t_case_audit (msg VARCHAR); +-- +ok +== +CREATE TRIGGER trg_case BEFORE UPDATE OF VAL ON t_case FOR EACH STATEMENT + INSERT INTO t_case_audit VALUES ('case'); +-- +ok +== +UPDATE t_case SET val = 2; +-- +ok +== +SELECT COUNT(*) FROM t_case_audit; +-- +ok +== +UPDATE target SET val = 1 RETURNING id; +-- +ok +== +UPDATE target SET val = 7 WHERE id = 1; +-- +ok +== diff --git a/parser/testdata/corpus/sql/trigger/trigger_for_each_row.test b/parser/testdata/corpus/sql/trigger/trigger_for_each_row.test new file mode 100644 index 0000000..3e27976 --- /dev/null +++ b/parser/testdata/corpus/sql/trigger/trigger_for_each_row.test @@ -0,0 +1,883 @@ +# source: test/sql/trigger/trigger_for_each_row.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +CREATE TABLE t (id INTEGER, val VARCHAR); +-- +ok +== +CREATE TABLE audit (row_id INTEGER, row_val VARCHAR); +-- +ok +== +CREATE TRIGGER trg_basic AFTER INSERT ON t FOR EACH ROW + INSERT INTO audit VALUES (NEW.id, NEW.val); +-- +ok +== +INSERT INTO t VALUES (1, 'a'); +-- +ok +== +SELECT row_id, row_val FROM audit ORDER BY row_id; +-- +ok +== +INSERT INTO t VALUES (2, 'b'), (3, 'c'), (4, 'd'); +-- +ok +== +INSERT INTO t VALUES (5, 'e'); +-- +ok +== +CREATE TABLE t_dup (id INTEGER, val VARCHAR); +-- +ok +== +CREATE TABLE audit_dup (row_id INTEGER); +-- +ok +== +CREATE TRIGGER trg_dup AFTER INSERT ON t_dup FOR EACH ROW + INSERT INTO audit_dup VALUES (NEW.id); +-- +ok +== +INSERT INTO t_dup VALUES (5, 'a'), (5, 'b'), (5, 'c'), (5, 'd'); +-- +ok +== +SELECT COUNT(*) FROM audit_dup; +-- +ok +== +SELECT row_id, COUNT(*) FROM audit_dup GROUP BY row_id; +-- +ok +== +INSERT INTO t_dup VALUES (7, 'x'), (7, 'y'), (8, 'z'); +-- +ok +== +CREATE TABLE t_dup_all (id INTEGER, val VARCHAR); +-- +ok +== +CREATE TABLE audit_dup_all (row_id INTEGER, row_val VARCHAR); +-- +ok +== +CREATE TRIGGER trg_dup_all AFTER INSERT ON t_dup_all FOR EACH ROW + INSERT INTO audit_dup_all VALUES (NEW.id, NEW.val); +-- +ok +== +INSERT INTO t_dup_all VALUES (1, 'same'), (1, 'same'), (1, 'same'); +-- +ok +== +SELECT COUNT(*) FROM audit_dup_all; +-- +ok +== +CREATE TABLE t2 (id INTEGER); +-- +ok +== +CREATE TABLE audit2 (msg VARCHAR); +-- +ok +== +CREATE TRIGGER trg_noref AFTER INSERT ON t2 FOR EACH ROW + INSERT INTO audit2 VALUES ('row'); +-- +ok +== +CREATE TABLE src (id INTEGER); +-- +ok +== +INSERT INTO t SELECT id, 'from_src' FROM src; +-- +ok +== +SELECT COUNT(*) FROM audit WHERE row_id >= 100; +-- +ok +== +CREATE TABLE t_unique (id INTEGER UNIQUE); +-- +ok +== +CREATE TABLE audit_unique (fired_id INTEGER); +-- +ok +== +CREATE TRIGGER trg_unique AFTER INSERT ON t_unique FOR EACH ROW + INSERT INTO audit_unique VALUES (NEW.id); +-- +ok +== +SELECT COUNT(*) FROM audit_unique; +-- +ok +== +CREATE TABLE t_snap (id INTEGER); +-- +ok +== +CREATE TABLE snap_result (snap_id INTEGER, cnt INTEGER); +-- +ok +== +CREATE TRIGGER trg_snap AFTER INSERT ON t_snap FOR EACH ROW + INSERT INTO snap_result SELECT NEW.id, COUNT(*) FROM t_snap; +-- +ok +== +INSERT INTO t_snap VALUES (1), (2), (3); +-- +ok +== +SELECT DISTINCT cnt FROM snap_result; +-- +ok +== +CREATE TABLE audit_multi (n INTEGER); +-- +ok +== +CREATE TRIGGER trg_m1 AFTER INSERT ON t_multi FOR EACH ROW + INSERT INTO audit_multi VALUES (NEW.id * 10); +-- +ok +== +CREATE TRIGGER trg_m2 AFTER INSERT ON t_multi FOR EACH ROW + INSERT INTO audit_multi VALUES (NEW.id * 100); +-- +ok +== +INSERT INTO t_multi VALUES (1), (2); +-- +ok +== +SELECT COUNT(*) FROM audit_multi; +-- +ok +== +SELECT SUM(n) FROM audit_multi; +-- +ok +== +CREATE TABLE t_upd_src (id INTEGER, amount INTEGER); +-- +ok +== +CREATE TABLE t_upd_totals (total INTEGER); +-- +ok +== +INSERT INTO t_upd_totals VALUES (0); +-- +ok +== +CREATE TRIGGER trg_upd AFTER INSERT ON t_upd_src FOR EACH ROW + UPDATE t_upd_totals SET total = total + NEW.amount; +-- +ok +== +INSERT INTO t_upd_src VALUES (1, 5), (2, 10), (3, 3); +-- +ok +== +SELECT total FROM t_upd_totals; +-- +ok +== +CREATE TABLE t_upd1 (id INTEGER); +-- +ok +== +CREATE TABLE target_upd1 (id INTEGER, val INTEGER); +-- +ok +== +CREATE TRIGGER trg_upd1 AFTER INSERT ON t_upd1 FOR EACH ROW + UPDATE target_upd1 SET val = val + 1 WHERE id = NEW.id; +-- +ok +== +INSERT INTO target_upd1 VALUES (1, 0), (2, 0), (3, 0); +-- +ok +== +CREATE TRIGGER trg_upd1_corr AFTER INSERT ON t_upd1 FOR EACH ROW + UPDATE target_upd1 SET val = val + 1 WHERE id = NEW.id; +-- +ok +== +INSERT INTO t_upd1 VALUES (1), (2); +-- +ok +== +SELECT id, val FROM target_upd1 WHERE val = 1 ORDER BY id; +-- +ok +== +CREATE TABLE t_before (id INTEGER); +-- +ok +== +CREATE TRIGGER trg_before BEFORE INSERT ON t_before FOR EACH ROW + INSERT INTO t_before VALUES (NEW.id); +-- +ok +== +CREATE TABLE t_upd_ev (id INTEGER); +-- +ok +== +CREATE TRIGGER trg_upd_ev AFTER UPDATE ON t_upd_ev FOR EACH ROW + INSERT INTO t_upd_ev VALUES (NEW.id); +-- +ok +== +CREATE TABLE t_del_ev (id INTEGER, v INTEGER); +-- +ok +== +CREATE TABLE t_del_ev_audit (old_id INTEGER, old_v INTEGER); +-- +ok +== +CREATE TRIGGER trg_del_ev AFTER DELETE ON t_del_ev FOR EACH ROW + INSERT INTO t_del_ev_audit VALUES (OLD.id, OLD.v); +-- +ok +== +INSERT INTO t_del_ev VALUES (1, 10), (2, 20), (3, 30); +-- +ok +== +DELETE FROM t_del_ev WHERE id <= 2; +-- +ok +== +SELECT old_id, old_v FROM t_del_ev_audit ORDER BY old_id; +-- +ok +== +DELETE FROM t_del_ev; +-- +ok +== +CREATE TABLE t_del_noref (id INTEGER); +-- +ok +== +CREATE TABLE t_del_noref_audit (msg VARCHAR); +-- +ok +== +CREATE TRIGGER trg_del_noref AFTER DELETE ON t_del_noref FOR EACH ROW + INSERT INTO t_del_noref_audit VALUES ('deleted'); +-- +ok +== +CREATE TABLE t_ref (id INTEGER); +-- +ok +== +CREATE TABLE t_ref_new (id INTEGER); +-- +ok +== +CREATE TRIGGER trg_ref AFTER INSERT ON t_ref REFERENCING NEW TABLE AS new_t FOR EACH ROW + INSERT INTO t_ref_new VALUES (1); +-- +ok +== +CREATE TABLE t_from_new (id INTEGER); +-- +ok +== +CREATE TABLE t_from_new_log (id INTEGER); +-- +ok +== +CREATE TRIGGER trg_from_new AFTER INSERT ON t_from_new FOR EACH ROW + INSERT INTO t_from_new_log SELECT id FROM new; +-- +ok +== +CREATE TABLE t_self (id INTEGER); +-- +ok +== +CREATE TRIGGER trg_self AFTER INSERT ON t_self FOR EACH ROW + INSERT INTO t_self VALUES (NEW.id + 1); +-- +ok +== +CREATE TABLE t_mix (id INTEGER); +-- +ok +== +CREATE TABLE t_mix_log (msg VARCHAR); +-- +ok +== +CREATE TRIGGER trg_mix_stmt AFTER INSERT ON t_mix FOR EACH STATEMENT + INSERT INTO t_mix_log VALUES ('stmt'); +-- +ok +== +CREATE TRIGGER trg_mix_row AFTER INSERT ON t_mix FOR EACH ROW + INSERT INTO t_mix_log VALUES (CAST(NEW.id AS VARCHAR)); +-- +ok +== +CREATE TABLE t_mix2 (id INTEGER); +-- +ok +== +CREATE TABLE t_mix2_log (msg VARCHAR); +-- +ok +== +CREATE TRIGGER trg_mix2_row AFTER INSERT ON t_mix2 FOR EACH ROW + INSERT INTO t_mix2_log VALUES (CAST(NEW.id AS VARCHAR)); +-- +ok +== +CREATE TRIGGER trg_mix2_stmt AFTER INSERT ON t_mix2 FOR EACH STATEMENT + INSERT INTO t_mix2_log VALUES ('stmt'); +-- +ok +== +CREATE TABLE t_mix3 (id INTEGER); +-- +ok +== +CREATE TABLE t_mix3_log (msg VARCHAR); +-- +ok +== +CREATE TRIGGER trg_mix3_before_stmt BEFORE INSERT ON t_mix3 FOR EACH STATEMENT + INSERT INTO t_mix3_log VALUES ('stmt'); +-- +ok +== +CREATE TRIGGER trg_mix3_after_row AFTER INSERT ON t_mix3 FOR EACH ROW + INSERT INTO t_mix3_log VALUES (CAST(NEW.id AS VARCHAR)); +-- +ok +== +CREATE TABLE t_mix4 (id INTEGER); +-- +ok +== +CREATE TABLE t_mix4_log (msg VARCHAR); +-- +ok +== +CREATE TRIGGER trg_mix4_after_row AFTER INSERT ON t_mix4 FOR EACH ROW + INSERT INTO t_mix4_log VALUES (CAST(NEW.id AS VARCHAR)); +-- +ok +== +CREATE TRIGGER trg_mix4_before_stmt BEFORE INSERT ON t_mix4 FOR EACH STATEMENT + INSERT INTO t_mix4_log VALUES ('stmt'); +-- +ok +== +CREATE TABLE t_ret (id INTEGER); +-- +ok +== +CREATE TABLE t_ret_log (id INTEGER); +-- +ok +== +CREATE TRIGGER trg_ret AFTER INSERT ON t_ret FOR EACH ROW + INSERT INTO t_ret_log VALUES (NEW.id); +-- +ok +== +INSERT INTO t_ret VALUES (1) RETURNING id; +-- +ok +== +CREATE TABLE t_conflict (id INTEGER PRIMARY KEY, val VARCHAR); +-- +ok +== +CREATE TRIGGER trg_conflict AFTER INSERT ON t_conflict FOR EACH ROW + INSERT INTO t_conflict_log VALUES (NEW.id); +-- +ok +== +INSERT INTO t_conflict VALUES (1, 'a'); +-- +ok +== +INSERT INTO t_conflict VALUES (1, 'b') ON CONFLICT DO UPDATE SET val = excluded.val; +-- +ok +== +INSERT INTO t_conflict VALUES (1, 'b') ON CONFLICT DO NOTHING; +-- +ok +== +CREATE TABLE casc_a (id INTEGER); +-- +ok +== +CREATE TABLE casc_b (id INTEGER); +-- +ok +== +CREATE TABLE casc_c (id INTEGER); +-- +ok +== +CREATE TRIGGER trg_casc_a AFTER INSERT ON casc_a FOR EACH ROW + INSERT INTO casc_b VALUES (NEW.id + 100); +-- +ok +== +CREATE TRIGGER trg_casc_b AFTER INSERT ON casc_b FOR EACH ROW + INSERT INTO casc_c VALUES (NEW.id + 1000); +-- +ok +== +INSERT INTO casc_a VALUES (1), (2), (3); +-- +ok +== +INSERT INTO casc_a VALUES (1); +-- +ok +== +CREATE TABLE casc2_a (id INTEGER); +-- +ok +== +CREATE TABLE casc2_b (id INTEGER); +-- +ok +== +CREATE TABLE casc2_c (id INTEGER); +-- +ok +== +CREATE TRIGGER trg_casc2_b AFTER INSERT ON casc2_b FOR EACH ROW + INSERT INTO casc2_c VALUES (NEW.id); +-- +ok +== +CREATE TRIGGER trg_casc2_a AFTER INSERT ON casc2_a FOR EACH ROW + INSERT INTO casc2_b VALUES (NEW.id); +-- +ok +== +CREATE TABLE casc3_a (id INTEGER); +-- +ok +== +CREATE TABLE casc3_b (id INTEGER); +-- +ok +== +CREATE TABLE casc3_c (id INTEGER); +-- +ok +== +CREATE TRIGGER trg_casc3_a AFTER INSERT ON casc3_a FOR EACH ROW + INSERT INTO casc3_b VALUES (NEW.id); +-- +ok +== +CREATE TRIGGER trg_casc3_b AFTER INSERT ON casc3_b FOR EACH ROW + INSERT INTO casc3_c VALUES (NEW.id); +-- +ok +== +CREATE TABLE t_ins2 (id INTEGER); +-- +ok +== +CREATE TABLE source_ins2 (id INTEGER); +-- +ok +== +CREATE TABLE audit_ins2 (id INTEGER); +-- +ok +== +INSERT INTO source_ins2 VALUES (10), (20); +-- +ok +== +CREATE TRIGGER trg_ins2 AFTER INSERT ON t_ins2 FOR EACH ROW + INSERT INTO audit_ins2 SELECT NEW.id; +-- +ok +== +INSERT INTO t_ins2 VALUES (1), (2); +-- +ok +== +SELECT COUNT(*) FROM audit_ins2; +-- +ok +== +CREATE TABLE t_del1 (id INTEGER); +-- +ok +== +CREATE TABLE other_del1 (id INTEGER); +-- +ok +== +INSERT INTO other_del1 VALUES (1), (2), (3); +-- +ok +== +CREATE TRIGGER trg_del1 AFTER INSERT ON t_del1 FOR EACH ROW + DELETE FROM other_del1 WHERE id = NEW.id; +-- +ok +== +INSERT INTO t_del1 VALUES (1), (3); +-- +ok +== +SELECT COUNT(*) FROM other_del1; +-- +ok +== +CREATE TABLE t_gen (a INTEGER, b INTEGER GENERATED ALWAYS AS (a + 1)); +-- +ok +== +CREATE TABLE t_gen_log (a INTEGER); +-- +ok +== +CREATE TRIGGER trg_gen AFTER INSERT ON t_gen FOR EACH ROW + INSERT INTO t_gen_log VALUES (NEW.a); +-- +ok +== +CREATE TABLE replace_t (id INTEGER); +-- +ok +== +CREATE TABLE replace_log (id INTEGER); +-- +ok +== +CREATE TRIGGER replace_trg AFTER INSERT ON replace_t FOR EACH STATEMENT + INSERT INTO replace_log VALUES (0); +-- +ok +== +CREATE OR REPLACE TRIGGER replace_trg AFTER INSERT ON replace_t FOR EACH ROW + INSERT INTO replace_log VALUES (NEW.id); +-- +ok +== +INSERT INTO replace_t VALUES (1); +-- +ok +== +SELECT id FROM replace_log ORDER BY id; +-- +ok +== +CREATE TABLE del_t (id INTEGER, val VARCHAR); +-- +ok +== +CREATE TABLE del_audit (row_id INTEGER, row_val VARCHAR); +-- +ok +== +CREATE TRIGGER del_trg_basic AFTER DELETE ON del_t FOR EACH ROW + INSERT INTO del_audit VALUES (OLD.id, OLD.val); +-- +ok +== +INSERT INTO del_t VALUES (1, 'a'), (2, 'b'), (3, 'c'); +-- +ok +== +DELETE FROM del_t WHERE id = 2; +-- +ok +== +SELECT row_id, row_val FROM del_audit ORDER BY row_id; +-- +ok +== +DELETE FROM del_t; +-- +ok +== +DELETE FROM del_t WHERE id = 999; +-- +ok +== +SELECT COUNT(*) FROM del_audit; +-- +ok +== +CREATE TABLE del_dup (id INTEGER, val VARCHAR); +-- +ok +== +CREATE TABLE del_dup_audit (row_id INTEGER); +-- +ok +== +CREATE TRIGGER del_trg_dup AFTER DELETE ON del_dup FOR EACH ROW + INSERT INTO del_dup_audit VALUES (OLD.id); +-- +ok +== +INSERT INTO del_dup VALUES (5, 'a'), (5, 'b'), (5, 'c'), (5, 'd'); +-- +ok +== +DELETE FROM del_dup; +-- +ok +== +SELECT COUNT(*) FROM del_dup_audit; +-- +ok +== +SELECT row_id, COUNT(*) FROM del_dup_audit GROUP BY row_id; +-- +ok +== +CREATE TABLE del_dup_all (id INTEGER, val VARCHAR); +-- +ok +== +CREATE TABLE del_dup_all_audit (row_id INTEGER, row_val VARCHAR); +-- +ok +== +CREATE TRIGGER del_trg_dup_all AFTER DELETE ON del_dup_all FOR EACH ROW + INSERT INTO del_dup_all_audit VALUES (OLD.id, OLD.val); +-- +ok +== +INSERT INTO del_dup_all VALUES (1, 'same'), (1, 'same'), (1, 'same'); +-- +ok +== +DELETE FROM del_dup_all; +-- +ok +== +SELECT COUNT(*) FROM del_dup_all_audit; +-- +ok +== +CREATE TABLE del_fk (id INTEGER PRIMARY KEY); +-- +ok +== +CREATE TABLE del_fk_audit (fired_id INTEGER); +-- +ok +== +CREATE TRIGGER del_trg_fk AFTER DELETE ON del_fk FOR EACH ROW + INSERT INTO del_fk_audit VALUES (OLD.id); +-- +ok +== +INSERT INTO del_fk VALUES (1); +-- +ok +== +DELETE FROM del_fk WHERE id = 999; +-- +ok +== +SELECT COUNT(*) FROM del_fk_audit; +-- +ok +== +CREATE TABLE del_src (id INTEGER); +-- +ok +== +CREATE TABLE del_ref (id INTEGER); +-- +ok +== +INSERT INTO del_src VALUES (10), (20), (30); +INSERT INTO del_ref VALUES (10), (20), (30), (40); +-- +ok +== +CREATE TRIGGER del_trg_corr AFTER DELETE ON del_src FOR EACH ROW + DELETE FROM del_ref WHERE id = OLD.id; +-- +ok +== +DELETE FROM del_src WHERE id IN (10, 30); +-- +ok +== +SELECT id FROM del_ref ORDER BY id; +-- +ok +== +CREATE TABLE del_multi (id INTEGER); +-- +ok +== +CREATE TABLE del_multi_audit (n INTEGER); +-- +ok +== +CREATE TRIGGER del_trg_m1 AFTER DELETE ON del_multi FOR EACH ROW + INSERT INTO del_multi_audit VALUES (OLD.id * 10); +-- +ok +== +CREATE TRIGGER del_trg_m2 AFTER DELETE ON del_multi FOR EACH ROW + INSERT INTO del_multi_audit VALUES (OLD.id * 100); +-- +ok +== +INSERT INTO del_multi VALUES (1), (2); +-- +ok +== +DELETE FROM del_multi; +-- +ok +== +SELECT COUNT(*) FROM del_multi_audit; +-- +ok +== +SELECT SUM(n) FROM del_multi_audit; +-- +ok +== +CREATE TABLE del_sel (id INTEGER); +-- +ok +== +CREATE TABLE del_sel_audit (id INTEGER); +-- +ok +== +CREATE TRIGGER del_trg_sel AFTER DELETE ON del_sel FOR EACH ROW + INSERT INTO del_sel_audit SELECT OLD.id; +-- +ok +== +INSERT INTO del_sel VALUES (1), (2); +-- +ok +== +DELETE FROM del_sel; +-- +ok +== +SELECT COUNT(*) FROM del_sel_audit; +-- +ok +== +CREATE TABLE del_ret (id INTEGER); +-- +ok +== +CREATE TABLE del_ret_log (id INTEGER); +-- +ok +== +CREATE TRIGGER del_trg_ret AFTER DELETE ON del_ret FOR EACH ROW + INSERT INTO del_ret_log VALUES (OLD.id); +-- +ok +== +INSERT INTO del_ret VALUES (1); +-- +ok +== +DELETE FROM del_ret WHERE id = 1 RETURNING id; +-- +ok +== +CREATE TABLE del_self (id INTEGER); +-- +ok +== +CREATE TRIGGER del_trg_self AFTER DELETE ON del_self FOR EACH ROW + DELETE FROM del_self WHERE id = OLD.id + 1; +-- +ok +== +CREATE TABLE del_casc_a (id INTEGER); +-- +ok +== +CREATE TABLE del_casc_b (id INTEGER); +-- +ok +== +CREATE TABLE del_casc_c (id INTEGER); +-- +ok +== +CREATE TRIGGER del_trg_casc_b AFTER DELETE ON del_casc_b FOR EACH ROW + INSERT INTO del_casc_c VALUES (OLD.id); +-- +ok +== +CREATE TRIGGER del_trg_casc_a AFTER DELETE ON del_casc_a FOR EACH ROW + DELETE FROM del_casc_b WHERE id = OLD.id; +-- +ok +== +CREATE TABLE del_replace_t (id INTEGER); +-- +ok +== +CREATE TABLE del_replace_log (id INTEGER); +-- +ok +== +CREATE TRIGGER del_replace_trg AFTER DELETE ON del_replace_t FOR EACH STATEMENT + INSERT INTO del_replace_log VALUES (0); +-- +ok +== +CREATE OR REPLACE TRIGGER del_replace_trg AFTER DELETE ON del_replace_t FOR EACH ROW + INSERT INTO del_replace_log VALUES (OLD.id); +-- +ok +== +INSERT INTO del_replace_t VALUES (7); +-- +ok +== +DELETE FROM del_replace_t; +-- +ok +== +SELECT id FROM del_replace_log ORDER BY id; +-- +ok +== diff --git a/parser/testdata/corpus/sql/trigger/trigger_multiple_per_event.test b/parser/testdata/corpus/sql/trigger/trigger_multiple_per_event.test new file mode 100644 index 0000000..f2d4eb0 --- /dev/null +++ b/parser/testdata/corpus/sql/trigger/trigger_multiple_per_event.test @@ -0,0 +1,541 @@ +# source: test/sql/trigger/trigger_multiple_per_event.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +CREATE TABLE audit1 (msg VARCHAR); +-- +ok +== +CREATE TRIGGER trg1 AFTER INSERT ON t1 FOR EACH STATEMENT + INSERT INTO audit1 VALUES ('trg1 fired'); +-- +ok +== +CREATE TRIGGER trg2 AFTER INSERT ON t1 FOR EACH STATEMENT + INSERT INTO audit2 VALUES ('trg2 fired'); +-- +ok +== +SELECT COUNT(*) FROM audit1; +-- +ok +== +SELECT COUNT(*) FROM audit2; +-- +ok +== +CREATE SEQUENCE order_seq START 1; +-- +ok +== +CREATE TABLE order_audit (seq_val INTEGER, name VARCHAR); +-- +ok +== +CREATE TRIGGER b_trg AFTER INSERT ON t2 FOR EACH STATEMENT + INSERT INTO order_audit VALUES (nextval('order_seq'), 'b_trg'); +-- +ok +== +CREATE TRIGGER a_trg AFTER INSERT ON t2 FOR EACH STATEMENT + INSERT INTO order_audit VALUES (nextval('order_seq'), 'a_trg'); +-- +ok +== +INSERT INTO t2 VALUES (1); +-- +ok +== +SELECT seq_val, name FROM order_audit ORDER BY seq_val; +-- +ok +== +CREATE TABLE t2b (id INTEGER); +-- +ok +== +CREATE SEQUENCE order_seq2 START 1; +-- +ok +== +CREATE TABLE order_audit2 (seq_val INTEGER, name VARCHAR); +-- +ok +== +CREATE TRIGGER a_trg2 AFTER INSERT ON t2b FOR EACH STATEMENT + INSERT INTO order_audit2 VALUES (nextval('order_seq2'), 'a_trg2'); +-- +ok +== +CREATE TRIGGER b_trg2 AFTER INSERT ON t2b FOR EACH STATEMENT + INSERT INTO order_audit2 VALUES (nextval('order_seq2'), 'b_trg2'); +-- +ok +== +INSERT INTO t2b VALUES (1); +-- +ok +== +SELECT seq_val, name FROM order_audit2 ORDER BY seq_val; +-- +ok +== +CREATE TABLE t3 (id INTEGER); +-- +ok +== +CREATE TABLE count3 (n INTEGER); +-- +ok +== +INSERT INTO count3 VALUES (0); +-- +ok +== +CREATE TRIGGER trg3_a AFTER INSERT ON t3 FOR EACH STATEMENT + UPDATE count3 SET n = n + 1; +-- +ok +== +CREATE TRIGGER trg3_b AFTER INSERT ON t3 FOR EACH STATEMENT + UPDATE count3 SET n = n + 1; +-- +ok +== +CREATE TRIGGER trg3_c AFTER INSERT ON t3 FOR EACH STATEMENT + UPDATE count3 SET n = n + 1; +-- +ok +== +INSERT INTO t3 VALUES (1); +-- +ok +== +SELECT n FROM count3; +-- +ok +== +CREATE TABLE t4 (id INTEGER); +-- +ok +== +CREATE TABLE mixed_audit (event VARCHAR); +-- +ok +== +CREATE TRIGGER t4_ins1 AFTER INSERT ON t4 FOR EACH STATEMENT + INSERT INTO mixed_audit VALUES ('insert1'); +-- +ok +== +CREATE TRIGGER t4_ins2 AFTER INSERT ON t4 FOR EACH STATEMENT + INSERT INTO mixed_audit VALUES ('insert2'); +-- +ok +== +CREATE TRIGGER t4_del AFTER DELETE ON t4 FOR EACH STATEMENT + INSERT INTO mixed_audit VALUES ('delete'); +-- +ok +== +INSERT INTO t4 VALUES (1), (2); +-- +ok +== +SELECT COUNT(*) FROM mixed_audit WHERE event LIKE 'insert%'; +-- +ok +== +SELECT COUNT(*) FROM mixed_audit WHERE event = 'delete'; +-- +ok +== +DELETE FROM t4; +-- +ok +== +CREATE TABLE t5 (id INTEGER); +-- +ok +== +CREATE TABLE ref_audit (val INTEGER); +-- +ok +== +CREATE TRIGGER t5_ref1 AFTER INSERT ON t5 + REFERENCING NEW TABLE AS new_rows1 + FOR EACH STATEMENT + INSERT INTO ref_audit SELECT id FROM new_rows1; +-- +ok +== +CREATE TRIGGER t5_ref2 AFTER INSERT ON t5 + REFERENCING NEW TABLE AS new_rows2 + FOR EACH STATEMENT + INSERT INTO ref_audit SELECT id * 10 FROM new_rows2; +-- +ok +== +INSERT INTO t5 VALUES (1), (2); +-- +ok +== +SELECT COUNT(*) FROM ref_audit; +-- +ok +== +SELECT SUM(val) FROM ref_audit; +-- +ok +== +CREATE TABLE t6 (id INTEGER); +-- +ok +== +CREATE TABLE same_alias_audit (val INTEGER); +-- +ok +== +CREATE TRIGGER t6_a AFTER INSERT ON t6 + REFERENCING NEW TABLE AS inserted + FOR EACH STATEMENT + INSERT INTO same_alias_audit SELECT id FROM inserted; +-- +ok +== +CREATE TRIGGER t6_b AFTER INSERT ON t6 + REFERENCING NEW TABLE AS inserted + FOR EACH STATEMENT + INSERT INTO same_alias_audit SELECT id * 100 FROM inserted; +-- +ok +== +INSERT INTO t6 VALUES (3); +-- +ok +== +SELECT COUNT(*) FROM same_alias_audit; +-- +ok +== +SELECT SUM(val) FROM same_alias_audit; +-- +ok +== +CREATE TABLE t6b (id INTEGER); +-- +ok +== +CREATE TABLE t6b_audit (msg VARCHAR); +-- +ok +== +CREATE TRIGGER t6b_with_ref AFTER INSERT ON t6b + REFERENCING NEW TABLE AS new_rows + FOR EACH STATEMENT + INSERT INTO t6b_audit VALUES ('fired'); +-- +ok +== +CREATE TRIGGER t6b_no_ref AFTER INSERT ON t6b FOR EACH STATEMENT + INSERT INTO t6b_audit SELECT id FROM new_rows; +-- +ok +== +CREATE TABLE alias_parent (id INTEGER); +-- +ok +== +CREATE TABLE shadow_alias (id INTEGER); +-- +ok +== +CREATE TABLE alias_audit (id INTEGER); +-- +ok +== +INSERT INTO shadow_alias VALUES (1000); +-- +ok +== +CREATE TRIGGER a_alias AFTER INSERT ON alias_parent + REFERENCING NEW TABLE AS shadow_alias + FOR EACH STATEMENT + INSERT INTO alias_audit SELECT id FROM shadow_alias; +-- +ok +== +CREATE TRIGGER b_plain AFTER INSERT ON alias_parent FOR EACH STATEMENT + INSERT INTO alias_audit SELECT id FROM shadow_alias; +-- +ok +== +INSERT INTO alias_parent VALUES (7); +-- +ok +== +SELECT COUNT(*) FROM alias_audit WHERE id = 7; +-- +ok +== +SELECT COUNT(*) FROM alias_audit WHERE id = 1000; +-- +ok +== +CREATE TABLE t_chain2_parent (id INTEGER); +-- +ok +== +CREATE TABLE t_chain2_child (id INTEGER); +-- +ok +== +CREATE TABLE t_chain2_audit (msg VARCHAR); +-- +ok +== +CREATE TRIGGER t_chain2_child_trg AFTER INSERT ON t_chain2_child FOR EACH STATEMENT + INSERT INTO t_chain2_audit VALUES ('child fired'); +-- +ok +== +CREATE TRIGGER t_chain2_parent_a AFTER INSERT ON t_chain2_parent FOR EACH STATEMENT + INSERT INTO t_chain2_child VALUES (1); +-- +ok +== +CREATE TRIGGER t_chain2_parent_b AFTER INSERT ON t_chain2_parent FOR EACH STATEMENT + INSERT INTO t_chain2_child VALUES (2); +-- +ok +== +INSERT INTO t_chain2_parent VALUES (99); +-- +ok +== +SELECT COUNT(*) FROM t_chain2_child; +-- +ok +== +SELECT COUNT(*) FROM t_chain2_audit; +-- +ok +== +CREATE TABLE t7 (id INTEGER); +-- +ok +== +CREATE TABLE t7b (id INTEGER); +-- +ok +== +CREATE TABLE chain_audit (msg VARCHAR); +-- +ok +== +CREATE TRIGGER t7b_trg AFTER INSERT ON t7b FOR EACH STATEMENT + INSERT INTO chain_audit VALUES ('t7b fired'); +-- +ok +== +CREATE TRIGGER t7_direct AFTER INSERT ON t7 FOR EACH STATEMENT + INSERT INTO chain_audit VALUES ('t7 direct'); +-- +ok +== +CREATE TRIGGER t7_chain AFTER INSERT ON t7 FOR EACH STATEMENT + INSERT INTO t7b VALUES (99); +-- +ok +== +INSERT INTO t7 VALUES (1); +-- +ok +== +SELECT COUNT(*) FROM chain_audit; +-- +ok +== +SELECT COUNT(*) FROM t7b; +-- +ok +== +CREATE TABLE ta (id INTEGER); +-- +ok +== +CREATE TABLE tb (id INTEGER); +-- +ok +== +CREATE TABLE ta_audit (msg VARCHAR); +-- +ok +== +CREATE TABLE tb_audit (msg VARCHAR); +-- +ok +== +CREATE TRIGGER ta_trg AFTER INSERT ON ta FOR EACH STATEMENT + INSERT INTO ta_audit VALUES ('ta fired'); +-- +ok +== +CREATE TRIGGER tb_trg AFTER INSERT ON tb FOR EACH STATEMENT + INSERT INTO tb_audit VALUES ('tb fired'); +-- +ok +== +INSERT INTO ta VALUES (1); +-- +ok +== +INSERT INTO tb VALUES (2); +-- +ok +== +SELECT COUNT(*) FROM ta_audit; +-- +ok +== +SELECT COUNT(*) FROM tb_audit; +-- +ok +== +CREATE TABLE t8 (id INTEGER); +-- +ok +== +CREATE TRIGGER t8_recursive AFTER INSERT ON t8 FOR EACH STATEMENT + INSERT INTO t8 VALUES (1); +-- +ok +== +CREATE TABLE t_cycle_a (id INTEGER); +-- +ok +== +CREATE TABLE t_cycle_b (id INTEGER); +-- +ok +== +CREATE TABLE t_cycle_audit (msg VARCHAR); +-- +ok +== +CREATE TRIGGER t_cycle_a_harmless AFTER INSERT ON t_cycle_a FOR EACH STATEMENT + INSERT INTO t_cycle_audit VALUES ('harmless'); +-- +ok +== +CREATE TRIGGER t_cycle_a_to_b AFTER INSERT ON t_cycle_a FOR EACH STATEMENT + INSERT INTO t_cycle_b VALUES (1); +-- +ok +== +CREATE TRIGGER t_cycle_b_to_a AFTER INSERT ON t_cycle_b FOR EACH STATEMENT + INSERT INTO t_cycle_a VALUES (1); +-- +ok +== +CREATE TABLE t_cycle2_a (id INTEGER); +-- +ok +== +CREATE TABLE t_cycle2_b (id INTEGER); +-- +ok +== +CREATE TABLE t_cycle2_c (id INTEGER); +-- +ok +== +CREATE TRIGGER t_cycle2_a_to_b AFTER INSERT ON t_cycle2_a FOR EACH STATEMENT + INSERT INTO t_cycle2_b VALUES (1); +-- +ok +== +CREATE TRIGGER t_cycle2_a_to_c AFTER INSERT ON t_cycle2_a FOR EACH STATEMENT + INSERT INTO t_cycle2_c VALUES (1); +-- +ok +== +CREATE TRIGGER t_cycle2_c_to_a AFTER INSERT ON t_cycle2_c FOR EACH STATEMENT + INSERT INTO t_cycle2_a VALUES (1); +-- +ok +== +CREATE TABLE t9 (id INTEGER); +-- +ok +== +CREATE TABLE drop_audit (msg VARCHAR); +-- +ok +== +CREATE TRIGGER t9_keep AFTER INSERT ON t9 FOR EACH STATEMENT + INSERT INTO drop_audit VALUES ('keep'); +-- +ok +== +CREATE TRIGGER t9_drop AFTER INSERT ON t9 FOR EACH STATEMENT + INSERT INTO drop_audit VALUES ('drop'); +-- +ok +== +DROP TRIGGER t9_drop ON t9; +-- +ok +== +INSERT INTO t9 VALUES (1); +-- +ok +== +SELECT COUNT(*) FROM drop_audit WHERE msg = 'keep'; +-- +ok +== +SELECT COUNT(*) FROM drop_audit WHERE msg = 'drop'; +-- +ok +== +CREATE TABLE t10 (id INTEGER); +-- +ok +== +CREATE TABLE replace_audit (msg VARCHAR); +-- +ok +== +CREATE TRIGGER t10_a AFTER INSERT ON t10 FOR EACH STATEMENT + INSERT INTO replace_audit VALUES ('original_a'); +-- +ok +== +CREATE TRIGGER t10_b AFTER INSERT ON t10 FOR EACH STATEMENT + INSERT INTO replace_audit VALUES ('b'); +-- +ok +== +CREATE OR REPLACE TRIGGER t10_a AFTER INSERT ON t10 FOR EACH STATEMENT + INSERT INTO replace_audit VALUES ('replaced_a'); +-- +ok +== +INSERT INTO t10 VALUES (1); +-- +ok +== +SELECT COUNT(*) FROM replace_audit WHERE msg = 'original_a'; +-- +ok +== +SELECT COUNT(*) FROM replace_audit WHERE msg = 'replaced_a'; +-- +ok +== +SELECT COUNT(*) FROM replace_audit WHERE msg = 'b'; +-- +ok +== diff --git a/parser/testdata/corpus/sql/trigger/trigger_referencing_validation.test b/parser/testdata/corpus/sql/trigger/trigger_referencing_validation.test new file mode 100644 index 0000000..d32775d --- /dev/null +++ b/parser/testdata/corpus/sql/trigger/trigger_referencing_validation.test @@ -0,0 +1,172 @@ +# source: test/sql/trigger/trigger_referencing_validation.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +CREATE TABLE t (id INTEGER); +-- +ok +== +CREATE TRIGGER trg_old_on_insert AFTER INSERT ON t +REFERENCING OLD TABLE AS old_rows +FOR EACH STATEMENT + INSERT INTO t VALUES (1); +-- +ok +== +CREATE TRIGGER trg_new_on_delete AFTER DELETE ON t +REFERENCING NEW TABLE AS new_rows +FOR EACH STATEMENT + INSERT INTO t VALUES (1); +-- +ok +== +CREATE TABLE t_old_upd_log (id INTEGER); +-- +ok +== +CREATE TRIGGER trg_old_on_update AFTER UPDATE ON t +REFERENCING OLD TABLE AS old_rows +FOR EACH STATEMENT + INSERT INTO t_old_upd_log SELECT id FROM old_rows; +-- +ok +== +CREATE TABLE t_before (i INTEGER); +-- +ok +== +CREATE TRIGGER trg_before_ins BEFORE INSERT ON t_before +REFERENCING NEW TABLE AS inserted_rows +FOR EACH STATEMENT + INSERT INTO t VALUES (1); +-- +ok +== +CREATE TRIGGER trg_before_del BEFORE DELETE ON t_before +REFERENCING OLD TABLE AS deleted_rows +FOR EACH STATEMENT + INSERT INTO t VALUES (1); +-- +ok +== +CREATE TABLE t_update_of (i INTEGER, j INTEGER); +-- +ok +== +CREATE TRIGGER trg_update_of AFTER UPDATE OF i ON t_update_of +REFERENCING NEW TABLE AS updated_rows +FOR EACH STATEMENT + INSERT INTO t VALUES (1); +-- +ok +== +CREATE TRIGGER trg_update_of_old AFTER UPDATE OF i ON t_update_of +REFERENCING OLD TABLE AS old_rows +FOR EACH STATEMENT + INSERT INTO t VALUES (1); +-- +ok +== +CREATE TRIGGER trg_both_del AFTER DELETE ON t +REFERENCING OLD TABLE AS old_rows NEW TABLE AS new_rows +FOR EACH STATEMENT + INSERT INTO t VALUES (1); +-- +ok +== +CREATE TRIGGER trg_both_del2 AFTER DELETE ON t +REFERENCING NEW TABLE AS new_rows OLD TABLE AS old_rows +FOR EACH STATEMENT + INSERT INTO t VALUES (1); +-- +ok +== +CREATE TRIGGER trg_both_ins AFTER INSERT ON t +REFERENCING NEW TABLE AS new_rows OLD TABLE AS old_rows +FOR EACH STATEMENT + INSERT INTO t VALUES (1); +-- +ok +== +CREATE TRIGGER trg_both_ins2 AFTER INSERT ON t +REFERENCING OLD TABLE AS old_rows NEW TABLE AS new_rows +FOR EACH STATEMENT + INSERT INTO t VALUES (1); +-- +ok +== +CREATE TABLE t_both_upd_log (id INTEGER); +-- +ok +== +CREATE TRIGGER trg_both_upd AFTER UPDATE ON t +REFERENCING NEW TABLE AS new_rows OLD TABLE AS old_rows +FOR EACH STATEMENT + INSERT INTO t_both_upd_log SELECT n.id FROM old_rows o JOIN new_rows n ON o.id = n.id; +-- +ok +== +CREATE TRIGGER trg_both_upd2 AFTER UPDATE ON t +REFERENCING OLD TABLE AS old_rows NEW TABLE AS new_rows +FOR EACH STATEMENT + INSERT INTO t_both_upd_log SELECT o.id FROM old_rows o JOIN new_rows n ON o.id = n.id; +-- +ok +== +CREATE TRIGGER trg_dup_old AFTER DELETE ON t +REFERENCING OLD TABLE AS x OLD TABLE AS y +FOR EACH STATEMENT + INSERT INTO t VALUES (1); +-- +error: Parser Error: OLD TABLE cannot be specified multiple times in REFERENCING clause +== +CREATE TRIGGER trg_dup_new AFTER INSERT ON t +REFERENCING NEW TABLE AS x NEW TABLE AS y +FOR EACH STATEMENT + INSERT INTO t VALUES (1); +-- +error: Parser Error: NEW TABLE cannot be specified multiple times in REFERENCING clause +== +CREATE TRIGGER trg_same_alias AFTER UPDATE ON t +REFERENCING NEW TABLE AS x OLD TABLE AS x +FOR EACH STATEMENT + INSERT INTO t VALUES (1); +-- +error: Parser Error: REFERENCING aliases must be distinct +== +CREATE TABLE t_log (id INTEGER); +-- +ok +== +CREATE TRIGGER trg_bad AFTER INSERT ON t FOR EACH STATEMENT + INSERT INTO t_log SELECT id FROM nonexistent_alias; +-- +ok +== +CREATE TRIGGER trg_alias_mismatch AFTER INSERT ON t +REFERENCING NEW TABLE AS new_rows +FOR EACH STATEMENT + INSERT INTO t_log SELECT id FROM wrong_alias; +-- +ok +== +CREATE TABLE t_reserved_log (id INTEGER); +-- +ok +== +CREATE TRIGGER trg_reserved_base AFTER INSERT ON t +REFERENCING NEW TABLE AS __duckdb_trigger_base +FOR EACH STATEMENT + INSERT INTO t_reserved_log SELECT id FROM __duckdb_trigger_base; +-- +ok +== +INSERT INTO t VALUES (77); +-- +ok +== +SELECT id FROM t_reserved_log; +-- +ok +== diff --git a/parser/testdata/corpus/sql/trigger/trigger_referencing_validation.test.metadata.json b/parser/testdata/corpus/sql/trigger/trigger_referencing_validation.test.metadata.json new file mode 100644 index 0000000..2f2bb0e --- /dev/null +++ b/parser/testdata/corpus/sql/trigger/trigger_referencing_validation.test.metadata.json @@ -0,0 +1,7 @@ +{ + "todo": { + "64879408d841181f": "transformer-raised parser error: upstream rejects in the transformer, not the grammar; expected to clear as transformers land (milestones 3-5)", + "8e41ddf0dc8ffc0f": "transformer-raised parser error: upstream rejects in the transformer, not the grammar; expected to clear as transformers land (milestones 3-5)", + "f06f8b423baeecb6": "transformer-raised parser error: upstream rejects in the transformer, not the grammar; expected to clear as transformers land (milestones 3-5)" + } +} diff --git a/parser/testdata/corpus/sql/trigger/trigger_returning.test b/parser/testdata/corpus/sql/trigger/trigger_returning.test new file mode 100644 index 0000000..5cd1939 --- /dev/null +++ b/parser/testdata/corpus/sql/trigger/trigger_returning.test @@ -0,0 +1,737 @@ +# source: test/sql/trigger/trigger_returning.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +CREATE TABLE t (a INTEGER, b INTEGER GENERATED ALWAYS AS (a + 1)); +-- +ok +== +CREATE TABLE log (msg VARCHAR); +-- +ok +== +CREATE TABLE other (x INTEGER); +-- +ok +== +INSERT INTO other VALUES (42); +-- +ok +== +CREATE TABLE g (a INTEGER, gen INTEGER GENERATED ALWAYS AS (a * 2), b INTEGER); +-- +ok +== +CREATE TABLE glog (msg VARCHAR); +-- +ok +== +CREATE TRIGGER tr_g AFTER INSERT ON g FOR EACH STATEMENT + INSERT INTO glog VALUES ('g'); +-- +ok +== +INSERT INTO g(a, b) VALUES (5, 7) RETURNING a, gen, b; +-- +ok +== +INSERT INTO g(a, b) VALUES (3, 4) RETURNING *; +-- +ok +== +SELECT COUNT(*) FROM glog; +-- +ok +== +CREATE TRIGGER tr_after_ins AFTER INSERT ON t FOR EACH STATEMENT + INSERT INTO log VALUES ('after_ins'); +-- +ok +== +INSERT INTO t VALUES (10) RETURNING *; +-- +ok +== +INSERT INTO t VALUES (20) RETURNING a * 2 AS double_a; +-- +ok +== +INSERT INTO t VALUES (30) RETURNING a + 0; +-- +ok +== +INSERT INTO t VALUES (40) RETURNING t.a; +-- +ok +== +INSERT INTO t VALUES (50) RETURNING b; +-- +ok +== +INSERT INTO t VALUES (70) RETURNING * EXCLUDE (b); +-- +ok +== +INSERT INTO t VALUES (80) RETURNING * REPLACE (a * 10 AS a); +-- +ok +== +SELECT COUNT(*) FROM log WHERE msg = 'after_ins'; +-- +ok +== +CREATE TABLE t2 (a INTEGER); +-- +ok +== +CREATE TABLE log2 (msg VARCHAR); +-- +ok +== +CREATE TRIGGER tr_before_ins BEFORE INSERT ON t2 FOR EACH STATEMENT + INSERT INTO log2 VALUES ('before_ins'); +-- +ok +== +INSERT INTO t2 VALUES (5) RETURNING a; +-- +ok +== +SELECT COUNT(*) FROM log2; +-- +ok +== +CREATE TABLE t3 (a INTEGER); +-- +ok +== +CREATE TABLE log3 (msg VARCHAR); +-- +ok +== +CREATE TRIGGER tr3_before BEFORE INSERT ON t3 FOR EACH STATEMENT + INSERT INTO log3 VALUES ('before'); +-- +ok +== +CREATE TRIGGER tr3_after AFTER INSERT ON t3 FOR EACH STATEMENT + INSERT INTO log3 VALUES ('after'); +-- +ok +== +INSERT INTO t3 VALUES (7) RETURNING a; +-- +ok +== +SELECT msg, COUNT(*) FROM log3 GROUP BY msg ORDER BY msg; +-- +ok +== +CREATE TABLE upd (id INTEGER, val INTEGER); +-- +ok +== +INSERT INTO upd VALUES (1, 10), (2, 20); +-- +ok +== +CREATE TABLE ulog (msg VARCHAR); +-- +ok +== +CREATE TRIGGER tr_upd AFTER UPDATE ON upd FOR EACH STATEMENT + INSERT INTO ulog VALUES ('updated'); +-- +ok +== +UPDATE upd SET val = val + 1 RETURNING id, val; +-- +ok +== +SELECT COUNT(*) FROM ulog; +-- +ok +== +UPDATE upd AS u SET val = 0 RETURNING u.id; +-- +ok +== +CREATE TABLE del (id INTEGER); +-- +ok +== +INSERT INTO del VALUES (10), (20), (30); +-- +ok +== +CREATE TABLE dlog (msg VARCHAR); +-- +ok +== +CREATE TRIGGER tr_del AFTER DELETE ON del FOR EACH STATEMENT + INSERT INTO dlog VALUES ('deleted'); +-- +ok +== +DELETE FROM del RETURNING id; +-- +ok +== +SELECT COUNT(*) FROM dlog; +-- +ok +== +CREATE TABLE ref_t (id INTEGER, val INTEGER); +-- +ok +== +INSERT INTO ref_t VALUES (1, 100); +-- +ok +== +CREATE TABLE ref_log (captured INTEGER); +-- +ok +== +CREATE TRIGGER tr_ref AFTER INSERT ON ref_t + REFERENCING NEW TABLE AS new_rows + FOR EACH STATEMENT + INSERT INTO ref_log SELECT id FROM new_rows; +-- +ok +== +INSERT INTO ref_t VALUES (2, 200) RETURNING id; +-- +ok +== +SELECT captured FROM ref_log ORDER BY captured; +-- +ok +== +CREATE TABLE zero (id INTEGER); +-- +ok +== +CREATE TABLE zerolog (msg VARCHAR); +-- +ok +== +CREATE TRIGGER tr_zero AFTER INSERT ON zero FOR EACH STATEMENT + INSERT INTO zerolog VALUES ('fired'); +-- +ok +== +INSERT INTO zero SELECT id FROM zero RETURNING id; +-- +ok +== +SELECT COUNT(*) FROM zerolog; +-- +ok +== +CREATE TABLE of_t (a INTEGER, b INTEGER); +-- +ok +== +INSERT INTO of_t VALUES (1, 2); +-- +ok +== +CREATE TABLE of_log (msg VARCHAR); +-- +ok +== +CREATE TRIGGER tr_of BEFORE UPDATE OF b ON of_t FOR EACH STATEMENT + INSERT INTO of_log VALUES ('fired'); +-- +ok +== +UPDATE of_t SET a = 99 RETURNING a; +-- +ok +== +SELECT COUNT(*) FROM of_log; +-- +ok +== +CREATE TABLE oc (id INTEGER PRIMARY KEY, v INTEGER); +-- +ok +== +INSERT INTO oc VALUES (1, 10); +-- +ok +== +CREATE TRIGGER tr_oc AFTER INSERT ON oc FOR EACH STATEMENT + INSERT INTO log VALUES ('oc'); +-- +ok +== +INSERT INTO oc VALUES (1, 99), (2, 20) ON CONFLICT DO NOTHING RETURNING id, v; +-- +ok +== +CREATE TABLE wcte (id INTEGER); +-- +ok +== +CREATE TRIGGER tr_wcte AFTER INSERT ON wcte FOR EACH STATEMENT + INSERT INTO log VALUES ('wcte'); +-- +ok +== +WITH ins AS (INSERT INTO wcte VALUES (5) RETURNING id) SELECT id FROM ins; +-- +ok +== +CREATE TABLE rowid_del (id INTEGER); +-- +ok +== +INSERT INTO rowid_del VALUES (10), (20); +-- +ok +== +CREATE TABLE rowid_dlog (msg VARCHAR); +-- +ok +== +CREATE TRIGGER tr_rowid_del AFTER DELETE ON rowid_del FOR EACH STATEMENT + INSERT INTO rowid_dlog VALUES ('deleted'); +-- +ok +== +WITH d AS (DELETE FROM rowid_del WHERE id = 10 RETURNING rowid) +SELECT typeof(rowid) FROM d; +-- +ok +== +CREATE TABLE leak_d (id INTEGER); +-- +ok +== +INSERT INTO leak_d VALUES (10), (20); +-- +ok +== +CREATE TABLE leak_cap (c INTEGER); +-- +ok +== +CREATE TRIGGER tr_leak_old AFTER DELETE ON leak_d REFERENCING OLD TABLE AS oldr + FOR EACH STATEMENT INSERT INTO leak_cap SELECT * FROM oldr; +-- +ok +== +WITH d AS (DELETE FROM leak_d WHERE id = 10 RETURNING rowid) +SELECT typeof(rowid) FROM d; +-- +ok +== +SELECT c FROM leak_cap; +-- +ok +== +CREATE TABLE leak_u (id INTEGER, v INTEGER); +-- +ok +== +INSERT INTO leak_u VALUES (1, 100); +-- +ok +== +CREATE TABLE leak_ucap (id INTEGER, v INTEGER); +-- +ok +== +CREATE TRIGGER tr_leak_new AFTER UPDATE ON leak_u REFERENCING NEW TABLE AS newr + FOR EACH STATEMENT INSERT INTO leak_ucap SELECT * FROM newr; +-- +ok +== +UPDATE leak_u SET v = v + 1 WHERE id = 1 RETURNING id, v; +-- +ok +== +SELECT id, v FROM leak_ucap; +-- +ok +== +CREATE TABLE dupe_d (id INTEGER); +-- +ok +== +INSERT INTO dupe_d VALUES (10), (20); +-- +ok +== +CREATE TABLE dupe_log (msg VARCHAR); +-- +ok +== +CREATE TRIGGER tr_dupe AFTER DELETE ON dupe_d FOR EACH STATEMENT + INSERT INTO dupe_log VALUES ('d'); +-- +ok +== +WITH d AS (DELETE FROM dupe_d WHERE id = 10 RETURNING *, rowid) +SELECT id, typeof(rowid) FROM d; +-- +ok +== +CREATE TABLE dupe_d2 (id INTEGER); +-- +ok +== +INSERT INTO dupe_d2 VALUES (10); +-- +ok +== +CREATE TABLE dupe_cap (c INTEGER); +-- +ok +== +CREATE TRIGGER tr_dupe2 AFTER DELETE ON dupe_d2 REFERENCING OLD TABLE AS oldr + FOR EACH STATEMENT INSERT INTO dupe_cap SELECT * FROM oldr; +-- +ok +== +WITH d AS (DELETE FROM dupe_d2 WHERE id = 10 RETURNING *, rowid) +SELECT id, typeof(rowid) FROM d; +-- +ok +== +SELECT c FROM dupe_cap; +-- +ok +== +CREATE TABLE dupe_d3 (id INTEGER); +-- +ok +== +INSERT INTO dupe_d3 VALUES (1); +-- +ok +== +CREATE TRIGGER tr_dupe3 AFTER DELETE ON dupe_d3 FOR EACH STATEMENT + INSERT INTO dupe_log VALUES ('d'); +-- +ok +== +WITH d AS (DELETE FROM dupe_d3 RETURNING rowid AS my_rid) +SELECT typeof(my_rid) FROM d; +-- +ok +== +CREATE TABLE dupe_d4 (id INTEGER); +-- +ok +== +INSERT INTO dupe_d4 VALUES (1); +-- +ok +== +CREATE TRIGGER tr_dupe4 AFTER DELETE ON dupe_d4 FOR EACH STATEMENT + INSERT INTO dupe_log VALUES ('d'); +-- +ok +== +WITH d AS (DELETE FROM dupe_d4 RETURNING rowid, rowid + 1 AS rid_plus_one) +SELECT typeof(rowid), typeof(rid_plus_one) FROM d; +-- +ok +== +CREATE TABLE rowid_del2 (id INTEGER); +-- +ok +== +INSERT INTO rowid_del2 VALUES (99); +-- +ok +== +CREATE TABLE rowid_dlog2 (msg VARCHAR); +-- +ok +== +CREATE TRIGGER tr_rowid_del2 AFTER DELETE ON rowid_del2 FOR EACH STATEMENT + INSERT INTO rowid_dlog2 VALUES ('d'); +-- +ok +== +WITH d AS (DELETE FROM rowid_del2 RETURNING rowid_del2.rowid) +SELECT typeof(rowid) FROM d; +-- +ok +== +CREATE TABLE rowid_alias (id INTEGER); +-- +ok +== +INSERT INTO rowid_alias VALUES (1); +-- +ok +== +CREATE TABLE rowid_alias_log (msg VARCHAR); +-- +ok +== +CREATE TRIGGER tr_rowid_alias AFTER DELETE ON rowid_alias FOR EACH STATEMENT + INSERT INTO rowid_alias_log VALUES ('d'); +-- +ok +== +DELETE FROM rowid_alias AS x RETURNING rowid_alias.rowid; +-- +ok +== +WITH d AS (DELETE FROM rowid_alias AS x RETURNING x.rowid) +SELECT typeof(rowid) FROM d; +-- +ok +== +CREATE TABLE rowid_schemaref (id INTEGER); +-- +ok +== +INSERT INTO rowid_schemaref VALUES (1); +-- +ok +== +CREATE TABLE rowid_schemaref_log (msg VARCHAR); +-- +ok +== +CREATE TRIGGER tr_rowid_schemaref AFTER DELETE ON rowid_schemaref FOR EACH STATEMENT + INSERT INTO rowid_schemaref_log VALUES ('d'); +-- +ok +== +WITH d AS (DELETE FROM rowid_schemaref RETURNING main.rowid_schemaref.rowid) +SELECT typeof(rowid) FROM d; +-- +ok +== +CREATE TABLE rowid_noalias (id INTEGER); +-- +ok +== +INSERT INTO rowid_noalias VALUES (1); +-- +ok +== +CREATE TABLE rowid_noalias_log (msg VARCHAR); +-- +ok +== +CREATE TRIGGER tr_rowid_noalias AFTER DELETE ON rowid_noalias FOR EACH STATEMENT + INSERT INTO rowid_noalias_log VALUES ('d'); +-- +ok +== +WITH d AS (DELETE FROM rowid_noalias RETURNING rowid_noalias.rowid) +SELECT typeof(rowid) FROM d; +-- +ok +== +CREATE TABLE rowid_expr (id INTEGER); +-- +ok +== +INSERT INTO rowid_expr VALUES (1); +-- +ok +== +CREATE TABLE rowid_expr_log (msg VARCHAR); +-- +ok +== +CREATE TRIGGER tr_rowid_expr AFTER DELETE ON rowid_expr FOR EACH STATEMENT + INSERT INTO rowid_expr_log VALUES ('d'); +-- +ok +== +WITH d AS (DELETE FROM rowid_expr RETURNING rowid + 1) +SELECT "(rowid + CAST(1 AS BIGINT))" FROM d; +-- +ok +== +CREATE TABLE rowid_expr2 (id INTEGER); +-- +ok +== +INSERT INTO rowid_expr2 VALUES (1); +-- +ok +== +CREATE TABLE rowid_expr2_log (msg VARCHAR); +-- +ok +== +CREATE TRIGGER tr_rowid_expr2 AFTER DELETE ON rowid_expr2 FOR EACH STATEMENT + INSERT INTO rowid_expr2_log VALUES ('d'); +-- +ok +== +WITH d AS (DELETE FROM rowid_expr2 RETURNING rowid + 1 AS rid_plus_one) +SELECT rid_plus_one FROM d; +-- +ok +== +CREATE TABLE rowid_ins (id INTEGER); +-- +ok +== +CREATE TRIGGER tr_rowid_ins AFTER INSERT ON rowid_ins FOR EACH STATEMENT + INSERT INTO rowid_dlog VALUES ('ins'); +-- +ok +== +INSERT INTO rowid_ins VALUES (1) RETURNING rowid; +-- +ok +== +CREATE TABLE rowid_upd (id INTEGER); +-- +ok +== +INSERT INTO rowid_upd VALUES (1); +-- +ok +== +CREATE TRIGGER tr_rowid_upd AFTER UPDATE ON rowid_upd FOR EACH STATEMENT + INSERT INTO rowid_dlog VALUES ('upd'); +-- +ok +== +UPDATE rowid_upd SET id = 2 RETURNING rowid; +-- +ok +== +CREATE TABLE neg (id INTEGER PRIMARY KEY, v INTEGER); +-- +ok +== +INSERT INTO neg VALUES (1, 10); +-- +ok +== +CREATE TRIGGER tr_neg AFTER INSERT ON neg FOR EACH STATEMENT + INSERT INTO log VALUES ('neg'); +-- +ok +== +INSERT INTO neg VALUES (1, 99) ON CONFLICT DO UPDATE SET v = EXCLUDED.v + RETURNING id, v, EXCLUDED.v; +-- +ok +== +CREATE TABLE neg_src (x INTEGER); +-- +ok +== +INSERT INTO neg_src VALUES (99); +-- +ok +== +CREATE TRIGGER tr_neg_upd AFTER UPDATE ON neg FOR EACH STATEMENT + INSERT INTO log VALUES ('neg_upd'); +-- +ok +== +UPDATE neg SET v = neg_src.x FROM neg_src RETURNING neg_src.x; +-- +ok +== +CREATE TABLE neg_del (id INTEGER); +-- +ok +== +INSERT INTO neg_del VALUES (1); +-- +ok +== +CREATE TABLE neg_using (x INTEGER); +-- +ok +== +INSERT INTO neg_using VALUES (1); +-- +ok +== +CREATE TRIGGER tr_neg_del AFTER DELETE ON neg_del FOR EACH STATEMENT + INSERT INTO log VALUES ('neg_del'); +-- +ok +== +DELETE FROM neg_del USING neg_using WHERE neg_del.id = neg_using.x RETURNING neg_using.x; +-- +ok +== +CREATE TABLE cv ("RowID" INTEGER, v INTEGER); +-- +ok +== +INSERT INTO cv VALUES (7, 70); +-- +ok +== +CREATE TABLE cv_log (msg VARCHAR); +-- +ok +== +CREATE TRIGGER cv_trg AFTER DELETE ON cv FOR EACH STATEMENT + INSERT INTO cv_log VALUES ('d'); +-- +ok +== +DELETE FROM cv RETURNING *; +-- +ok +== +INSERT INTO cv VALUES (8, 80); +-- +ok +== +DELETE FROM cv RETURNING "RowID"; +-- +ok +== +CREATE TABLE df (id INTEGER, n INTEGER DEFAULT 42, m INTEGER); +-- +ok +== +CREATE TABLE df_log (msg VARCHAR); +-- +ok +== +CREATE TRIGGER df_trg AFTER INSERT ON df FOR EACH STATEMENT + INSERT INTO df_log VALUES ('d'); +-- +ok +== +INSERT INTO df (id) VALUES (1) RETURNING *; +-- +ok +== +INSERT INTO df VALUES (2, DEFAULT, NULL) RETURNING id, n, m; +-- +ok +== +CREATE TABLE nst (id INTEGER, l INTEGER[], mp MAP(VARCHAR, INTEGER)); +-- +ok +== +CREATE TABLE nst_log (msg VARCHAR); +-- +ok +== +CREATE TRIGGER nst_trg AFTER INSERT ON nst FOR EACH STATEMENT + INSERT INTO nst_log VALUES ('d'); +-- +ok +== +INSERT INTO nst VALUES (1, [1, 2, 3], MAP(['a', 'b'], [10, 20])) RETURNING id, l, mp; +-- +ok +== diff --git a/parser/testdata/corpus/sql/trigger/trigger_returning_binder_parity.test b/parser/testdata/corpus/sql/trigger/trigger_returning_binder_parity.test new file mode 100644 index 0000000..485d045 --- /dev/null +++ b/parser/testdata/corpus/sql/trigger/trigger_returning_binder_parity.test @@ -0,0 +1,171 @@ +# source: test/sql/trigger/trigger_returning_binder_parity.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +CREATE TABLE returning_agg_target (a INTEGER); +-- +ok +== +CREATE TABLE returning_agg_log (x INTEGER); +-- +ok +== +CREATE TRIGGER returning_agg_trg +AFTER INSERT ON returning_agg_target +FOR EACH STATEMENT + INSERT INTO returning_agg_log VALUES (1); +-- +ok +== +INSERT INTO returning_agg_target VALUES (1), (2) RETURNING sum(a); +-- +ok +== +CREATE TABLE returning_subquery_target (a INTEGER); +-- +ok +== +CREATE TABLE returning_subquery_log (x INTEGER); +-- +ok +== +CREATE TRIGGER returning_subquery_trg +AFTER INSERT ON returning_subquery_target +FOR EACH STATEMENT + INSERT INTO returning_subquery_log VALUES (1); +-- +ok +== +INSERT INTO returning_subquery_target VALUES (1), (2) +RETURNING a IN (SELECT a FROM returning_subquery_target); +-- +ok +== +CREATE TABLE returning_window_target (a INTEGER); +-- +ok +== +CREATE TABLE returning_window_log (x INTEGER); +-- +ok +== +CREATE TRIGGER returning_window_trg +AFTER INSERT ON returning_window_target +FOR EACH STATEMENT + INSERT INTO returning_window_log VALUES (1); +-- +ok +== +INSERT INTO returning_window_target VALUES (1), (2) +RETURNING row_number() OVER (ORDER BY a), a; +-- +ok +== +CREATE SCHEMA returning_schema_qual; +-- +ok +== +CREATE TABLE returning_schema_qual.target (a INTEGER); +-- +ok +== +INSERT INTO returning_schema_qual.target VALUES (7); +-- +ok +== +CREATE TABLE returning_schema_qual.log (x INTEGER); +-- +ok +== +CREATE TRIGGER returning_schema_qual_trg +AFTER DELETE ON returning_schema_qual.target +FOR EACH STATEMENT + INSERT INTO returning_schema_qual.log VALUES (1); +-- +ok +== +DELETE FROM returning_schema_qual.target +RETURNING returning_schema_qual.target.a; +-- +ok +== +CREATE SCHEMA returning_wrong_schema; +-- +ok +== +CREATE TABLE returning_wrong_schema.target (a INTEGER); +-- +ok +== +INSERT INTO returning_wrong_schema.target VALUES (7); +-- +ok +== +CREATE TABLE returning_wrong_schema.log (x INTEGER); +-- +ok +== +CREATE TRIGGER returning_wrong_schema_trg +AFTER DELETE ON returning_wrong_schema.target +FOR EACH STATEMENT + INSERT INTO returning_wrong_schema.log VALUES (1); +-- +ok +== +DELETE FROM returning_wrong_schema.target +RETURNING not_returning_wrong_schema.target.rowid; +-- +ok +== +CREATE TABLE returning_physical_rowid_target (rowid INTEGER, id VARCHAR); +-- +ok +== +INSERT INTO returning_physical_rowid_target VALUES (42, 'x'); +-- +ok +== +CREATE TABLE returning_physical_rowid_log (x INTEGER); +-- +ok +== +CREATE TRIGGER returning_physical_rowid_trg +AFTER DELETE ON returning_physical_rowid_target +FOR EACH STATEMENT + INSERT INTO returning_physical_rowid_log VALUES (1); +-- +ok +== +DELETE FROM returning_physical_rowid_target RETURNING *, rowid; +-- +ok +== +CREATE TABLE returning_physical_rowid_ref_target (rowid INTEGER, id VARCHAR); +-- +ok +== +INSERT INTO returning_physical_rowid_ref_target VALUES (42, 'x'); +-- +ok +== +CREATE TABLE returning_physical_rowid_ref_cap (rowid INTEGER, id VARCHAR); +-- +ok +== +CREATE TRIGGER returning_physical_rowid_ref_trg +AFTER DELETE ON returning_physical_rowid_ref_target +REFERENCING OLD TABLE AS old_rows +FOR EACH STATEMENT + INSERT INTO returning_physical_rowid_ref_cap SELECT * FROM old_rows; +-- +ok +== +DELETE FROM returning_physical_rowid_ref_target RETURNING rowid; +-- +ok +== +SELECT * FROM returning_physical_rowid_ref_cap; +-- +ok +== diff --git a/parser/testdata/corpus/sql/trigger/trigger_update_from_multi_match.test b/parser/testdata/corpus/sql/trigger/trigger_update_from_multi_match.test new file mode 100644 index 0000000..3d31b51 --- /dev/null +++ b/parser/testdata/corpus/sql/trigger/trigger_update_from_multi_match.test @@ -0,0 +1,87 @@ +# source: test/sql/trigger/trigger_update_from_multi_match.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +CREATE TABLE t (id INTEGER, v INTEGER); +-- +ok +== +INSERT INTO t VALUES (1, 0), (2, 0); +-- +ok +== +CREATE TABLE audit (id INTEGER, old_v INTEGER, new_v INTEGER); +-- +ok +== +CREATE TRIGGER trg AFTER UPDATE ON t +REFERENCING OLD TABLE AS o NEW TABLE AS n +FOR EACH STATEMENT + INSERT INTO audit SELECT o.id, o.v, n.v FROM o JOIN n ON o.id = n.id; +-- +ok +== +CREATE TABLE src (id INTEGER, v INTEGER); +-- +ok +== +INSERT INTO src VALUES (1, 10), (1, 20), (2, 30), (2, 40); +-- +ok +== +UPDATE t SET v = src.v FROM src WHERE t.id = src.id; +-- +ok +== +SELECT count(*) FROM audit; +-- +ok +== +SELECT count(*) FROM audit WHERE old_v = 0 AND (new_v IN (10, 20) AND id = 1 OR new_v IN (30, 40) AND id = 2); +-- +ok +== +SELECT count(*) FROM t WHERE (id = 1 AND v IN (10, 20)) OR (id = 2 AND v IN (30, 40)); +-- +ok +== +CREATE TABLE tl (id INTEGER, vals INTEGER[]); +-- +ok +== +INSERT INTO tl VALUES (1, [0]), (2, [0]); +-- +ok +== +CREATE TABLE tl_audit (id INTEGER, old_len INTEGER, new_len INTEGER); +-- +ok +== +CREATE TRIGGER trg_l AFTER UPDATE ON tl +REFERENCING OLD TABLE AS o NEW TABLE AS n +FOR EACH STATEMENT + INSERT INTO tl_audit SELECT o.id, len(o.vals), len(n.vals) FROM o JOIN n ON o.id = n.id; +-- +ok +== +CREATE TABLE sl (id INTEGER, vals INTEGER[]); +-- +ok +== +INSERT INTO sl VALUES (1, [9, 9]), (1, [1, 1]), (2, [8, 8, 8]), (2, [7, 7, 7]); +-- +ok +== +UPDATE tl SET vals = sl.vals FROM sl WHERE tl.id = sl.id; +-- +ok +== +SELECT id, old_len, new_len FROM tl_audit; +-- +ok +== +SELECT id, len(vals) FROM tl; +-- +ok +== diff --git a/parser/testdata/corpus/sql/types/alias/nested_alias.test b/parser/testdata/corpus/sql/types/alias/nested_alias.test new file mode 100644 index 0000000..030f4de --- /dev/null +++ b/parser/testdata/corpus/sql/types/alias/nested_alias.test @@ -0,0 +1,17 @@ +# source: test/sql/types/alias/nested_alias.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +CREATE TYPE my_int AS INT +-- +ok +== +CREATE TYPE my_int_list AS my_int[] +-- +ok +== +SELECT [42]::my_int_list +-- +ok +== diff --git a/parser/testdata/corpus/sql/types/alias/recursive_alias.test b/parser/testdata/corpus/sql/types/alias/recursive_alias.test new file mode 100644 index 0000000..28e83f0 --- /dev/null +++ b/parser/testdata/corpus/sql/types/alias/recursive_alias.test @@ -0,0 +1,17 @@ +# source: test/sql/types/alias/recursive_alias.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +CREATE TYPE t4 AS UNION ( v0 SETOF t4 ); +-- +ok +== +CREATE TYPE t4 AS t4[] +-- +ok +== +CREATE TYPE t4 AS STRUCT(a t4) +-- +ok +== diff --git a/parser/testdata/corpus/sql/types/alias/test_alias.test b/parser/testdata/corpus/sql/types/alias/test_alias.test new file mode 100644 index 0000000..7e5c9ea --- /dev/null +++ b/parser/testdata/corpus/sql/types/alias/test_alias.test @@ -0,0 +1,25 @@ +# source: test/sql/types/alias/test_alias.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +CREATE TYPE alias AS VARCHAR; +-- +ok +== +CREATE TYPE alias AS INTEGER; +-- +ok +== +DROP TYPE alias; +-- +ok +== +DROP TYPE IF EXISTS alias; +-- +ok +== +CREATE TYPE alias as BLOBL; +-- +ok +== diff --git a/parser/testdata/corpus/sql/types/alias/test_alias_functions.test b/parser/testdata/corpus/sql/types/alias/test_alias_functions.test new file mode 100644 index 0000000..288c718 --- /dev/null +++ b/parser/testdata/corpus/sql/types/alias/test_alias_functions.test @@ -0,0 +1,13 @@ +# source: test/sql/types/alias/test_alias_functions.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +CREATE TYPE str_alias as VARCHAR; +-- +ok +== +SELECT upper('hello'::str_alias) +-- +ok +== diff --git a/parser/testdata/corpus/sql/types/alias/test_alias_map.test b/parser/testdata/corpus/sql/types/alias/test_alias_map.test new file mode 100644 index 0000000..c98fd6d --- /dev/null +++ b/parser/testdata/corpus/sql/types/alias/test_alias_map.test @@ -0,0 +1,13 @@ +# source: test/sql/types/alias/test_alias_map.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +CREATE TYPE MAPPOINT AS MAP(INTEGER,INTEGER); +-- +ok +== +CREATE TABLE a(b MAPPOINT); +-- +ok +== diff --git a/parser/testdata/corpus/sql/types/alias/test_alias_struct.test b/parser/testdata/corpus/sql/types/alias/test_alias_struct.test new file mode 100644 index 0000000..9b849ec --- /dev/null +++ b/parser/testdata/corpus/sql/types/alias/test_alias_struct.test @@ -0,0 +1,49 @@ +# source: test/sql/types/alias/test_alias_struct.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +CREATE TYPE POINT AS STRUCT(i INTEGER, j INTEGER); +-- +ok +== +CREATE TABLE a(b POINT); +-- +ok +== +INSERT INTO a VALUES ({'i': 3, 'j': 4}); +-- +ok +== +INSERT INTO a VALUES (NULL); +-- +ok +== +INSERT INTO a VALUES (ROW(2, 3)); +-- +ok +== +INSERT INTO a VALUES (ROW(3, NULL)), (ROW(NULL, 4)); +-- +ok +== +INSERT INTO a VALUES (ROW(1, 2, 3)) +-- +ok +== +INSERT INTO a VALUES (ROW(1)) +-- +ok +== +INSERT INTO a VALUES (ROW('hello', 1)) +-- +ok +== +INSERT INTO a VALUES (ROW('hello', [1, 2])) +-- +ok +== +INSERT INTO a VALUES (ROW(1, ROW(1, 7))) +-- +ok +== diff --git a/parser/testdata/corpus/sql/types/alias/test_alias_struct_nested_alias.test b/parser/testdata/corpus/sql/types/alias/test_alias_struct_nested_alias.test new file mode 100644 index 0000000..a7efd84 --- /dev/null +++ b/parser/testdata/corpus/sql/types/alias/test_alias_struct_nested_alias.test @@ -0,0 +1,34 @@ +# source: test/sql/types/alias/test_alias_struct_nested_alias.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +CREATE TYPE foobar AS ENUM( + 'Foo', + 'Bar' +); +-- +ok +== +CREATE TYPE top_nest AS STRUCT( + foobar FOOBAR +); +-- +ok +== +CREATE TABLE failing ( + top_nest TOP_NEST +); +-- +ok +== +insert into failing VALUES ( + {'foobar': 'Foo'} +) +-- +ok +== +SELECT top_nest FROM failing; +-- +ok +== diff --git a/parser/testdata/corpus/sql/types/alias/test_alias_table.test b/parser/testdata/corpus/sql/types/alias/test_alias_table.test new file mode 100644 index 0000000..c8d0b9a --- /dev/null +++ b/parser/testdata/corpus/sql/types/alias/test_alias_table.test @@ -0,0 +1,138 @@ +# source: test/sql/types/alias/test_alias_table.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +CREATE TABLE person ( + name text, + current_car car +); +-- +ok +== +CREATE TABLE person ( + name text, + current_alias alias +); +-- +ok +== +INSERT INTO person VALUES ('Pedro', 'ok'); +-- +ok +== +INSERT INTO person VALUES ('Mark', 'sad'); +-- +ok +== +select * from person where current_alias = 'sad' +-- +ok +== +select * from person where current_alias > 'ok' +-- +ok +== +CREATE TABLE pets ( + name text, + current_alias alias +); +-- +ok +== +INSERT INTO pets VALUES ('Anne', 'happy'); +-- +ok +== +INSERT INTO pets VALUES ('Oogie Boogie', 'ok'); +-- +ok +== +INSERT INTO pets VALUES ('Mr. Fluffles McFluffingstein', NULL); +-- +ok +== +select * from pets; +-- +ok +== +select person.name, pets.name from person inner join pets on (person.current_alias = pets.current_alias) +-- +ok +== +DROP TABLE person; +-- +ok +== +DROP TABLE pets; +-- +ok +== +CREATE TABLE aliens ( + name text, + current_alias alias +); +-- +ok +== +CREATE TYPE intelligence AS VARCHAR; +-- +ok +== +INSERT INTO aliens VALUES ('Alf o Eteimoso', 'happy'), ('Dr Zoidberg', 'sad') +-- +ok +== +ALTER TABLE aliens ADD COLUMN iq_level intelligence +-- +ok +== +select * from aliens +-- +ok +== +INSERT INTO aliens VALUES ('The Borg', 'ok', 'ehh') +-- +ok +== +ALTER TABLE aliens ALTER current_alias SET DATA TYPE VARCHAR +-- +ok +== +CREATE TYPE car_brand AS VARCHAR; +-- +ok +== +CREATE TABLE person ( + name text, + current_alias alias, + last_year_alias alias, + car car_brand +); +-- +ok +== +INSERT INTO person VALUES ('Pedro', 'ok', 'ok','Seat'), ('Mark', 'sad', 'happy','Fiets'); +-- +ok +== +select * from person where current_alias = last_year_alias +-- +ok +== +select * from person where current_alias = 'ok' +-- +ok +== +INSERT INTO person VALUES ('Diego', 'sad', 'happy','Seat'), ('Tim', 'happy', 'sad','Fiets'); +-- +ok +== +select count(*), current_alias from person group by current_alias order by all +-- +ok +== +select name, current_alias from person order by current_alias +-- +ok +== diff --git a/parser/testdata/corpus/sql/types/alias/type_with_schema.test b/parser/testdata/corpus/sql/types/alias/type_with_schema.test new file mode 100644 index 0000000..5f8a391 --- /dev/null +++ b/parser/testdata/corpus/sql/types/alias/type_with_schema.test @@ -0,0 +1,23 @@ +# source: test/sql/types/alias/type_with_schema.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +CREATE TYPE my_schema.my_type AS STRUCT ( + a int, b int +); +-- +ok +== +CREATE TABLE my_schema.tbl ( + c0 my_schema.my_type +); +-- +ok +== +CREATE TABLE main.tbl ( + c0 my_schema.my_type +); +-- +ok +== diff --git a/parser/testdata/corpus/sql/types/bignum/test_big_bignum.test b/parser/testdata/corpus/sql/types/bignum/test_big_bignum.test new file mode 100644 index 0000000..c268cab --- /dev/null +++ b/parser/testdata/corpus/sql/types/bignum/test_big_bignum.test @@ -0,0 +1,17 @@ +# source: test/sql/types/bignum/test_big_bignum.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +create table t as select concat('1', repeat('0', i))::bignum as a from range(0,100) tbl(i) +-- +ok +== +select sum(a) from t +-- +ok +== +select sum(a) from t where a < 10000000 +-- +ok +== diff --git a/parser/testdata/corpus/sql/types/bignum/test_bignum_boundaries.test b/parser/testdata/corpus/sql/types/bignum/test_bignum_boundaries.test new file mode 100644 index 0000000..3a82234 --- /dev/null +++ b/parser/testdata/corpus/sql/types/bignum/test_bignum_boundaries.test @@ -0,0 +1,59 @@ +# source: test/sql/types/bignum/test_bignum_boundaries.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +select tinyint::varchar::bignum = tinyint::bignum, +smallint::varchar::bignum = smallint::bignum, +int::varchar::bignum = int::bignum, +bigint::varchar::bignum = bigint::bignum, +hugeint::varchar::bignum = hugeint::bignum, +uhugeint::varchar::bignum = uhugeint::bignum, +utinyint::varchar::bignum = utinyint::bignum, +usmallint::varchar::bignum = usmallint::bignum, +uint::varchar::bignum = uint::bignum, +ubigint::varchar::bignum = ubigint::bignum +FROM test_all_types() +where tinyint is not null; +-- +ok +== +select tinyint::varchar = tinyint::bignum::varchar , +smallint::varchar = smallint::bignum::varchar , +int::varchar = int::bignum::varchar , +bigint::varchar = bigint::bignum::varchar , +hugeint::varchar = hugeint::bignum::varchar , +uhugeint::varchar = uhugeint::bignum::varchar , +utinyint::varchar = utinyint::bignum::varchar , +usmallint::varchar = usmallint::bignum::varchar , +uint::varchar = uint::bignum::varchar , +ubigint::varchar::bignum = ubigint::bignum::varchar +FROM test_all_types() +where tinyint is not null; +-- +ok +== +select 1.7976931348623157E+308::double::bignum = '179769313486231570814527423731704356798070567525844996598917476803157260780028538760589558632766878171540458953514382464234321326889464182768467546703537516986049910576551282076245490090389328944075868508455133942304583236903222948165808559332123348274797826204144723168738177180919299881250404026184124858368'::bignum +-- +ok +== +select (-1.7976931348623157E+308)::double::bignum = '-179769313486231570814527423731704356798070567525844996598917476803157260780028538760589558632766878171540458953514382464234321326889464182768467546703537516986049910576551282076245490090389328944075868508455133942304583236903222948165808559332123348274797826204144723168738177180919299881250404026184124858368'::bignum +-- +ok +== +select '179769313486231570814527423731704356798070567525844996598917476803157260780028538760589558632766878171540458953514382464234321326889464182768467546703537516986049910576551282076245490090389328944075868508455133942304583236903222948165808559332123348274797826204144723168738177180919299881250404026184124858368'::bignum::double = '1.7976931348623157E+308'::double +-- +ok +== +select '-179769313486231570814527423731704356798070567525844996598917476803157260780028538760589558632766878171540458953514382464234321326889464182768467546703537516986049910576551282076245490090389328944075868508455133942304583236903222948165808559332123348274797826204144723168738177180919299881250404026184124858368'::bignum::double = '-1.7976931348623157E+308'::double +-- +ok +== +select 3.4028235E+38::float::bignum = '340282346638528859811704183484516925440'::bignum +-- +ok +== +select (-3.4028235E+38)::float::bignum = '-340282346638528859811704183484516925440'::bignum +-- +ok +== diff --git a/parser/testdata/corpus/sql/types/bignum/test_bignum_comparisons.test b/parser/testdata/corpus/sql/types/bignum/test_bignum_comparisons.test new file mode 100644 index 0000000..8fc29ad --- /dev/null +++ b/parser/testdata/corpus/sql/types/bignum/test_bignum_comparisons.test @@ -0,0 +1,72 @@ +# source: test/sql/types/bignum/test_bignum_comparisons.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +CREATE TABLE bignum_comparisons(a bignum); +-- +ok +== +insert into bignum_comparisons values +('9223372036854775807'::bignum), +('-9223372036854775808'::bignum), +('2147483647'::bignum), +('-2147483648'::bignum), +('32767'::bignum), +('-32768'::bignum), +('255'::bignum), +('0'::bignum), +('-1'::bignum), +('1'::bignum), +('340282366920938463463374607431768211455'::bignum), +('-170141183460469231731687303715884105727'::bignum), +('170141183460469231731687303715884105727'::bignum), +('340282366920938463463374607431768211455987'::bignum), +('-340282366920938463463374607431768211455987'::bignum); +-- +ok +== +select a, a < '9223372036854775807'::bignum from bignum_comparisons +-- +ok +== +select a, a <= '9223372036854775807'::bignum from bignum_comparisons +-- +ok +== +select a, a = '9223372036854775807'::bignum from bignum_comparisons +-- +ok +== +select a, a > '9223372036854775807'::bignum from bignum_comparisons +-- +ok +== +select a, a >= '9223372036854775807'::bignum from bignum_comparisons +-- +ok +== +select a, a != '9223372036854775807'::bignum from bignum_comparisons +-- +ok +== +select a, a < '2147483647'::bignum from bignum_comparisons +-- +ok +== +select a, a <= '2147483647'::bignum from bignum_comparisons +-- +ok +== +select a, a = '2147483647'::bignum from bignum_comparisons +-- +ok +== +select a, a > '2147483647'::bignum from bignum_comparisons +-- +ok +== +select a, a >= '2147483647'::bignum from bignum_comparisons +-- +ok +== diff --git a/parser/testdata/corpus/sql/types/bignum/test_bignum_double.test b/parser/testdata/corpus/sql/types/bignum/test_bignum_double.test new file mode 100644 index 0000000..b1d2136 --- /dev/null +++ b/parser/testdata/corpus/sql/types/bignum/test_bignum_double.test @@ -0,0 +1,49 @@ +# source: test/sql/types/bignum/test_bignum_double.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +select '100'::bignum::double +-- +ok +== +select '100000'::bignum::double +-- +ok +== +select '1000000000000000'::bignum::double +-- +ok +== +select '340282366920938463463374607431768211455'::bignum::double +-- +ok +== +select '-100'::bignum::double +-- +ok +== +select '-100000'::bignum::double +-- +ok +== +select '-1000000000000000'::bignum::double +-- +ok +== +select '-340282366920938463463374607431768211455'::bignum::double +-- +ok +== +select 179769313486231570814527423731704356798070567525844996598917476803157260780028538760589558632766878171540458953514382464234321326889464182768467546703537516986049910576551282076245490090389328944075868508455133942304583236903222948165808559332123348274797826204144723168738177180919299881250404026184124858368::bignum::double +-- +ok +== +select 1797693134862315708145274237317043567980705675258449965989174768031572607800285387605895586327668781715404589535143824642343213268894641827684675467035375169860499105765512820762454900903893289440758685084551339423045832369032229481658085593321233482747978262041447231687381771809192998812504040261841248583700::bignum::double +-- +ok +== +select '1797693134862315708145274237317043567980705675258449965989174768031572607800285387605895586327668781715404589535143824642343213268894641827684675467035375169860499105765512820762454900903893289440758685084551339423045832369032229481658085593321233482747978262041447231687381771809192998812504040261841248583700'::bignum::double +-- +ok +== diff --git a/parser/testdata/corpus/sql/types/bignum/test_bignum_float_string_cast.test b/parser/testdata/corpus/sql/types/bignum/test_bignum_float_string_cast.test new file mode 100644 index 0000000..55d84d3 --- /dev/null +++ b/parser/testdata/corpus/sql/types/bignum/test_bignum_float_string_cast.test @@ -0,0 +1,33 @@ +# source: test/sql/types/bignum/test_bignum_float_string_cast.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +SELECT CAST('1.5' AS INTEGER) AS i1, CAST('1.5' AS HUGEINT) AS i2, CAST('1.5' AS BIGNUM) AS i3; +-- +ok +== +SELECT CAST('1.4' AS BIGNUM); +-- +ok +== +SELECT CAST('2.5' AS BIGNUM); +-- +ok +== +SELECT CAST('0.4' AS BIGNUM), CAST('-0.4' AS BIGNUM), CAST('.4' AS BIGNUM), CAST('-.4' AS BIGNUM); +-- +ok +== +SELECT CAST('0.5' AS BIGNUM), CAST('-0.5' AS BIGNUM), CAST('.5' AS BIGNUM), CAST('-.5' AS BIGNUM); +-- +ok +== +SELECT CAST('-1.5' AS BIGNUM); +-- +ok +== +SELECT CAST('-1.4' AS BIGNUM); +-- +ok +== diff --git a/parser/testdata/corpus/sql/types/bignum/test_bignum_hugeint.test b/parser/testdata/corpus/sql/types/bignum/test_bignum_hugeint.test new file mode 100644 index 0000000..39674ef --- /dev/null +++ b/parser/testdata/corpus/sql/types/bignum/test_bignum_hugeint.test @@ -0,0 +1,29 @@ +# source: test/sql/types/bignum/test_bignum_hugeint.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +Select 85070591730234614260976917445211069672::BIGNUM ; +-- +ok +== +Select (-85070591730234614260976917445211069672)::BIGNUM ; +-- +ok +== +create table t as select (10 * power(10,i))::hugeint as i from range (0,38) t(i) +-- +ok +== +select distinct i::varchar == i::bignum::varchar FROM t; +-- +ok +== +select distinct (-i)::varchar == (-i)::bignum::varchar FROM t; +-- +ok +== +select distinct i::uhugeint::varchar == i::uhugeint::bignum::varchar FROM t; +-- +ok +== diff --git a/parser/testdata/corpus/sql/types/bignum/test_bignum_implicit_cast.test b/parser/testdata/corpus/sql/types/bignum/test_bignum_implicit_cast.test new file mode 100644 index 0000000..42e19ff --- /dev/null +++ b/parser/testdata/corpus/sql/types/bignum/test_bignum_implicit_cast.test @@ -0,0 +1,25 @@ +# source: test/sql/types/bignum/test_bignum_implicit_cast.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +create table t (a bignum) +-- +ok +== +insert into t values (1), (10), (1000) , (33999999014383402399481480781255147520::DOUBLE), (17976931348623157081452742373170435679807056752584499659891747); +-- +ok +== +select sum(a) from t; +-- +ok +== +insert into t values (-17976931348623157081452742373170435679807056752584499659891747680315726078002853876058); +-- +ok +== +insert into t values (1000000000000000000000000000000000000000000000000000000000000000000000000), (100000000000000000000000000000000000000000000000000000000000000000000000), (10000000000000000000000000000000000000000000000000000000000000000000000), (1000000000000000000000000000000000000000000000000000000000000000000000), (100000000000000000000000000000000000000000000000000000000000000000000); +-- +ok +== diff --git a/parser/testdata/corpus/sql/types/bignum/test_bignum_not_cast.test b/parser/testdata/corpus/sql/types/bignum/test_bignum_not_cast.test new file mode 100644 index 0000000..f89d63e --- /dev/null +++ b/parser/testdata/corpus/sql/types/bignum/test_bignum_not_cast.test @@ -0,0 +1,9 @@ +# source: test/sql/types/bignum/test_bignum_not_cast.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +select {type}::bignum FROM test_all_types() limit 1; +-- +error: Parser Error: syntax error at or near "}" +== diff --git a/parser/testdata/corpus/sql/types/bignum/test_bignum_subtract.test b/parser/testdata/corpus/sql/types/bignum/test_bignum_subtract.test new file mode 100644 index 0000000..926d060 --- /dev/null +++ b/parser/testdata/corpus/sql/types/bignum/test_bignum_subtract.test @@ -0,0 +1,53 @@ +# source: test/sql/types/bignum/test_bignum_subtract.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +SELECT -(1::BIGNUM) +-- +ok +== +SELECT -(0::BIGNUM) +-- +ok +== +SELECT -(-0::BIGNUM) +-- +ok +== +SELECT -(NULL::BIGNUM) +-- +ok +== +SELECT -('99999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999'::BIGNUM) +-- +ok +== +SELECT 10::bignum - 7::bignum +-- +ok +== +create table T (a bignum, b bignum); +-- +ok +== +insert into T values (0,0), (NULL, 10), (10, NULL), (100, -10), (-10, 100), (888, 271); +-- +ok +== +SELECT a-b,a,b FROM T +-- +ok +== +SELECT ('99999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999'::BIGNUM) - ('1'::BIGNUM) +-- +ok +== +SELECT ('1'::BIGNUM) - (-'9999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999'::BIGNUM) +-- +ok +== +SELECT "-"(c1, c2) FROM test_vector_types(CAST(NULL AS BIGNUM), CAST(NULL AS BIGNUM)) AS test_vector_types(c1, c2) +-- +ok +== diff --git a/parser/testdata/corpus/sql/types/bignum/test_bignum_sum.test b/parser/testdata/corpus/sql/types/bignum/test_bignum_sum.test new file mode 100644 index 0000000..730120f --- /dev/null +++ b/parser/testdata/corpus/sql/types/bignum/test_bignum_sum.test @@ -0,0 +1,232 @@ +# source: test/sql/types/bignum/test_bignum_sum.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +CREATE TABLE numbers ( x bignum ); +-- +ok +== +select sum(x) from (values ('1'::bignum), ('-2'::bignum)) t(x), range(100000) t(y); +-- +ok +== +INSERT INTO numbers (x) VALUES (9223372036854775808::BIGNUM), (1::BIGNUM); +-- +ok +== +select (-1)::BIGNUM + 9223372036854775807::BIGNUM +-- +ok +== +select 9223372036854775808::BIGNUM + 1::BIGNUM +-- +ok +== +select (-10)::BIGNUM + (-1)::BIGNUM +-- +ok +== +select (-999999999)::BIGNUM + (-1)::BIGNUM +-- +ok +== +select 9223372036854775808::BIGNUM + (-1)::BIGNUM +-- +ok +== +select (-1000)::BIGNUM + (-1000)::BIGNUM +-- +ok +== +SELECT sum(x)::bignum FROM numbers; +-- +ok +== +DROP TABLE numbers; +-- +ok +== +INSERT INTO numbers (x) VALUES (255::BIGNUM), (255::BIGNUM); +-- +ok +== +INSERT INTO numbers (x) VALUES (1::BIGNUM), (99999999::BIGNUM); +-- +ok +== +CREATE TABLE bignum_nulls (a BIGNUM, b BIGNUM); +-- +ok +== +INSERT INTO bignum_nulls VALUES (NULL, 1::BIGNUM), (2::BIGNUM, NULL), (NULL, NULL); +-- +ok +== +SELECT a + b FROM bignum_nulls; +-- +ok +== +SELECT sum(a)::BIGNUM FROM bignum_nulls; +-- +ok +== +SELECT sum(b)::BIGNUM FROM bignum_nulls; +-- +ok +== +DROP TABLE bignum_nulls; +-- +ok +== +CREATE TABLE bignum_zero (x BIGNUM); +-- +ok +== +INSERT INTO bignum_zero VALUES (0::BIGNUM), (0::BIGNUM), ((-0)::BIGNUM); +-- +ok +== +SELECT sum(x)::BIGNUM FROM bignum_zero; +-- +ok +== +SELECT 0::BIGNUM + 0::BIGNUM; +-- +ok +== +SELECT (-0)::BIGNUM + 0::BIGNUM; +-- +ok +== +DROP TABLE bignum_zero; +-- +ok +== +SELECT 10000000000000000000::BIGNUM + (-5)::BIGNUM; +-- +ok +== +SELECT (-5)::BIGNUM + 10000000000000000000::BIGNUM; +-- +ok +== +SELECT (-10000000000000000000)::BIGNUM + 5::BIGNUM; +-- +ok +== +SELECT 18446744073709551615::BIGNUM + 1::BIGNUM; +-- +ok +== +SELECT (-18446744073709551615)::BIGNUM + (-1)::BIGNUM; +-- +ok +== +CREATE TABLE mixed_values(x BIGNUM); +-- +ok +== +INSERT INTO mixed_values VALUES + (0::BIGNUM), + (1::BIGNUM), + ((-1)::BIGNUM); +-- +ok +== +SELECT sum(x)::BIGNUM FROM mixed_values; +-- +ok +== +INSERT INTO mixed_values VALUES (9223372036854775808::BIGNUM) +-- +ok +== +INSERT INTO mixed_values VALUES ((-9223372036854775808)::BIGNUM) +-- +ok +== +INSERT INTO mixed_values VALUES ((100)::BIGNUM) +-- +ok +== +INSERT INTO mixed_values VALUES ((-100)::BIGNUM) +-- +ok +== +INSERT INTO mixed_values VALUES (NULL) +-- +ok +== +DROP TABLE mixed_values; +-- +ok +== +select (-500)::BIGNUM + 1000::BIGNUM +-- +ok +== +SELECT ((-500)::BIGNUM + 1000::BIGNUM) + ((-250)::BIGNUM); +-- +ok +== +SELECT (-500)::BIGNUM + (1000::BIGNUM + ((-250)::BIGNUM)); +-- +ok +== +SELECT 170141183460469231731687303715884105728::BIGNUM + 1::BIGNUM; +-- +ok +== +select (170141183460469231731687::BIGNUM - 170141183460469231731686::BIGNUM) + 1::BIGNUM +-- +ok +== +SELECT 340282366920938463463374607431768211456::BIGNUM + 340282366920938463463374607431768211456::BIGNUM; +-- +ok +== +select '-21474836460000000000958214748364600000000009582147483646000000000095821474836460000000000958'::bignum + '1000'::bignum; +-- +ok +== +select '-21474836460000000000958214748364600000000009582147483646000000000095821474836459999999999958'::bignum + '-1000'::bignum; +-- +ok +== +select '1'::bignum + '-2'::bignum +-- +ok +== +select bignum + '-1'::bignum from test_all_types(use_large_bignum = true) limit 1 +-- +ok +== +select bignum + '1'::bignum from test_all_types(use_large_bignum = true) limit 1 offset 1 +-- +ok +== +create table bignum_underflow as select bignum from test_all_types(use_large_bignum = true) limit 1 +-- +ok +== +insert into bignum_underflow values (-1); +-- +ok +== +select sum(bignum) from bignum_underflow +-- +ok +== +create table bignum_overflow as select bignum from test_all_types(use_large_bignum = true) limit 1 offset 1 +-- +ok +== +insert into bignum_overflow values (1); +-- +ok +== +select sum(bignum) from bignum_overflow +-- +ok +== diff --git a/parser/testdata/corpus/sql/types/bignum/test_bignum_try_cast.test b/parser/testdata/corpus/sql/types/bignum/test_bignum_try_cast.test new file mode 100644 index 0000000..8478145 --- /dev/null +++ b/parser/testdata/corpus/sql/types/bignum/test_bignum_try_cast.test @@ -0,0 +1,45 @@ +# source: test/sql/types/bignum/test_bignum_try_cast.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +SELECT TRY_CAST('hello' AS BIGNUM) +-- +ok +== +SELECT TRY_CAST('1e+24' AS BIGNUM) +-- +ok +== +SELECT TRY_CAST('123456789012345678901234567890' AS BIGNUM)::VARCHAR +-- +ok +== +SELECT TRY_CAST('0.5' AS BIGNUM)::VARCHAR +-- +ok +== +SELECT TRY_CAST('-0.5' AS BIGNUM)::VARCHAR +-- +ok +== +SELECT TRY_CAST('+0.5' AS BIGNUM)::VARCHAR +-- +ok +== +SELECT TRY_CAST('.5' AS BIGNUM)::VARCHAR +-- +ok +== +SELECT TRY_CAST('-.5' AS BIGNUM)::VARCHAR +-- +ok +== +SELECT TRY_CAST('.' AS BIGNUM) +-- +ok +== +SELECT CAST('hello' AS BIGNUM) +-- +ok +== diff --git a/parser/testdata/corpus/sql/types/bignum/test_bignum_varchar_invalid.test b/parser/testdata/corpus/sql/types/bignum/test_bignum_varchar_invalid.test new file mode 100644 index 0000000..2cb4d22 --- /dev/null +++ b/parser/testdata/corpus/sql/types/bignum/test_bignum_varchar_invalid.test @@ -0,0 +1,21 @@ +# source: test/sql/types/bignum/test_bignum_varchar_invalid.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +SELECT 'ä'::BIGNUM +-- +ok +== +SELECT '12ä34'::BIGNUM +-- +ok +== +SELECT '€'::BIGNUM +-- +ok +== +SELECT '12345'::BIGNUM +-- +ok +== diff --git a/parser/testdata/corpus/sql/types/bignum/test_double_bignum.test b/parser/testdata/corpus/sql/types/bignum/test_double_bignum.test new file mode 100644 index 0000000..866fe5f --- /dev/null +++ b/parser/testdata/corpus/sql/types/bignum/test_double_bignum.test @@ -0,0 +1,41 @@ +# source: test/sql/types/bignum/test_double_bignum.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +select 179769313486231570814527423731704356798070567525844996598917476803157260780028538760589558632766878171540458953514382464234321326889464182768467546703537516986049910576551282076245490090389328944075868508455133942304583236903222948165808559332123348274797826204144723168738177180919299881250404026184124858368::double::bignum +-- +ok +== +select (-179769313486231570814527423731704356798070567525844996598917476803157260780028538760589558632766878171540458953514382464234321326889464182768467546703537516986049910576551282076245490090389328944075868508455133942304583236903222948165808559332123348274797826204144723168738177180919299881250404026184124858368)::double::bignum +-- +ok +== +select 33999999014383402399481480781255147520::float::bignum +-- +ok +== +select 33999999014383402399481480781255147520::double::bignum +-- +ok +== +select 0::double::bignum +-- +ok +== +select (-0)::double::bignum +-- +ok +== +select 1::double::bignum +-- +ok +== +select 100000::double::bignum +-- +ok +== +select 100000.595::double::bignum +-- +ok +== diff --git a/parser/testdata/corpus/sql/types/bignum/test_int_bignum_conversion.test b/parser/testdata/corpus/sql/types/bignum/test_int_bignum_conversion.test new file mode 100644 index 0000000..6320fc8 --- /dev/null +++ b/parser/testdata/corpus/sql/types/bignum/test_int_bignum_conversion.test @@ -0,0 +1,81 @@ +# source: test/sql/types/bignum/test_int_bignum_conversion.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +select distinct i::{int_type}::bignum = i::bignum from range(0, 100) t(i); +-- +error: Parser Error: syntax error at or near "{" +== +select distinct i::{int_type}::bignum = i::bignum from range(-100, 0) t(i); +-- +error: Parser Error: syntax error at or near "{" +== +select (-1)::bignum +-- +ok +== +select 0::bignum +-- +ok +== +select 1::bignum +-- +ok +== +CREATE TABLE integers(a bignum); +-- +ok +== +insert into integers values (0), (1), (-1); +-- +ok +== +SELECT * FROM integers; +-- +ok +== +select * from integers where a >= 0::BIGNUM +-- +ok +== +select * from integers where a < 0::BIGNUM +-- +ok +== +insert into integers values (300), (-300), (-10); +-- +ok +== +select (300)::BIGNUM +-- +ok +== +select (-300)::BIGNUM +-- +ok +== +select * from integers where a >= (-10)::BIGNUM +-- +ok +== +select * from integers where a = 1::BIGNUM +-- +ok +== +select count(*) from integers where a = 0::BIGNUM +-- +ok +== +select count(*) from integers where a < 0::BIGNUM +-- +ok +== +select 2147483647::bignum +-- +ok +== +select (-2147483647)::bignum +-- +ok +== diff --git a/parser/testdata/corpus/sql/types/bignum/test_varchar_bignum_conversion.test b/parser/testdata/corpus/sql/types/bignum/test_varchar_bignum_conversion.test new file mode 100644 index 0000000..66267fa --- /dev/null +++ b/parser/testdata/corpus/sql/types/bignum/test_varchar_bignum_conversion.test @@ -0,0 +1,57 @@ +# source: test/sql/types/bignum/test_varchar_bignum_conversion.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +select '340282366920938463463374607431768211455'::UHUGEINT::bignum +-- +ok +== +select distinct i::varchar::bignum = i::bignum from range(-1000, 1000) t(i); +-- +ok +== +select '2147483646'::bignum = 2147483646::bignum +-- +ok +== +select '340282366920938463463374607431768211455'::UHUGEINT::bignum = '340282366920938463463374607431768211455'::bignum +-- +ok +== +select '-2147483646'::bignum = (-2147483646)::bignum +-- +ok +== +select '100'::bignum = 100::bignum; +-- +ok +== +select '256'::bignum = 256::bignum; +-- +ok +== +select '256'::bignum; +-- +ok +== +select '2147483646'::bignum; +-- +ok +== +select '21474836460000000000958'::bignum; +-- +ok +== +select '-21474836460000000000958'::bignum; +-- +ok +== +select '-21474836460000000000958214748364600000000009582147483646000000000095821474836460000000000958'::bignum; +-- +ok +== +select '-21474836460000000000958214748364600000000009582147483646000000000095821474836460000000000958'::bignum < '-21474836460000000000958214748364600000000009582147483646000000000095821474836460000000000957'::bignum; +-- +ok +== diff --git a/parser/testdata/corpus/sql/types/bignum/test_varchar_bignum_unhappy.test b/parser/testdata/corpus/sql/types/bignum/test_varchar_bignum_unhappy.test new file mode 100644 index 0000000..d12b1b4 --- /dev/null +++ b/parser/testdata/corpus/sql/types/bignum/test_varchar_bignum_unhappy.test @@ -0,0 +1,129 @@ +# source: test/sql/types/bignum/test_varchar_bignum_unhappy.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +select '-0'::BIGNUM +-- +ok +== +select '+0'::BIGNUM +-- +ok +== +select '+0'::VARINT +-- +ok +== +select '+-0'::BIGNUM +-- +ok +== +select '-+0'::BIGNUM +-- +ok +== +select '-'::BIGNUM +-- +ok +== +select '-0010'::BIGNUM +-- +ok +== +select '-0010.'::BIGNUM +-- +ok +== +select '-0010.5'::BIGNUM +-- +ok +== +select '-0010.4999'::BIGNUM +-- +ok +== +select '0010.5'::BIGNUM +-- +ok +== +select '0010.4999'::BIGNUM +-- +ok +== +select '0.5'::BIGNUM +-- +ok +== +select '-0.5'::BIGNUM +-- +ok +== +select '+0.5'::BIGNUM +-- +ok +== +select '0.'::BIGNUM +-- +ok +== +select '.5'::BIGNUM +-- +ok +== +select '-.5'::BIGNUM +-- +ok +== +select '.'::BIGNUM +-- +ok +== +select '00-0010'::BIGNUM +-- +ok +== +select '-0010.2'::BIGNUM +-- +ok +== +select '-0010.9'::BIGNUM +-- +ok +== +select '0010.2'::BIGNUM +-- +ok +== +select '0010.9'::BIGNUM +-- +ok +== +select ''::BIGNUM +-- +ok +== +select (-0)::BIGNUM +-- +ok +== +select 'bla'::BIGNUM +-- +ok +== +select '1000bla'::BIGNUM +-- +ok +== +select '1000.bla'::BIGNUM +-- +ok +== +select '1000...'::BIGNUM +-- +ok +== +select '1000.0.0'::BIGNUM +-- +ok +== diff --git a/parser/testdata/corpus/sql/types/bit/bit_issue_11211.test b/parser/testdata/corpus/sql/types/bit/bit_issue_11211.test new file mode 100644 index 0000000..9d559b1 --- /dev/null +++ b/parser/testdata/corpus/sql/types/bit/bit_issue_11211.test @@ -0,0 +1,20 @@ +# source: test/sql/types/bit/bit_issue_11211.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +select ( 2::bit & 2::bit ) = 2::bit as b; +-- +ok +== +FROM +( + SELECT + ( 2::bit & 2::bit ) AS a, + 2::bit AS b, + (a = b) AS '(a = b)', +) +SELECT a, b, a = b, "(a = b)"; +-- +ok +== diff --git a/parser/testdata/corpus/sql/types/bit/bit_issue_22527.test b/parser/testdata/corpus/sql/types/bit/bit_issue_22527.test new file mode 100644 index 0000000..da2212a --- /dev/null +++ b/parser/testdata/corpus/sql/types/bit/bit_issue_22527.test @@ -0,0 +1,121 @@ +# source: test/sql/types/bit/bit_issue_22527.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +SELECT + '0'::BIT < '10101010'::BIT, + '0'::BIT > '10101010'::BIT, + '0'::BIT <= '10101010'::BIT, + '0'::BIT >= '10101010'::BIT, + '0'::BIT < '00'::BIT, + '00'::BIT > '0'::BIT, + '01'::BIT < '1'::BIT, + '1'::BIT > '01'::BIT; +-- +ok +== +SELECT + bitstring_byte_comparable('0'::BIT) < bitstring_byte_comparable('00'::BIT), + bitstring_byte_comparable('01'::BIT) < bitstring_byte_comparable('1'::BIT), + bitstring_byte_comparable('10101010'::BIT) > bitstring_byte_comparable('1'::BIT); +-- +ok +== +CREATE TABLE bit_comparison_values(v BIT); +-- +ok +== +INSERT INTO bit_comparison_values VALUES ('0'), ('10101010'), ('00'), ('01'), ('1'); +-- +ok +== +SELECT v::VARCHAR FROM bit_comparison_values ORDER BY v; +-- +ok +== +SELECT v::VARCHAR FROM bit_comparison_values WHERE v < '10101010'::BIT ORDER BY v; +-- +ok +== +SELECT + '0'::BIT IS DISTINCT FROM '10101010'::BIT, + '0'::BIT IS NOT DISTINCT FROM '0'::BIT, + '0'::BIT IS DISTINCT FROM '0'::BIT, + NULL::BIT IS DISTINCT FROM '0'::BIT, + NULL::BIT IS NOT DISTINCT FROM NULL::BIT; +-- +ok +== +SELECT min(v)::VARCHAR, max(v)::VARCHAR FROM bit_comparison_values; +-- +ok +== +CREATE TABLE bit_join_l(v BIT); +-- +ok +== +CREATE TABLE bit_join_r(v BIT); +-- +ok +== +INSERT INTO bit_join_l VALUES ('0'), ('10101010'), ('1'); +-- +ok +== +INSERT INTO bit_join_r VALUES ('00'), ('10101010'), ('1'); +-- +ok +== +SELECT l.v::VARCHAR, r.v::VARCHAR +FROM bit_join_l l, bit_join_r r +WHERE l.v = r.v +ORDER BY 1, 2; +-- +ok +== +SELECT l.v::VARCHAR, r.v::VARCHAR +FROM bit_join_l l, bit_join_r r +WHERE l.v < r.v +ORDER BY 1, 2; +-- +ok +== +CREATE TABLE bit_zonemap_values(v BIT); +-- +ok +== +INSERT INTO bit_zonemap_values VALUES ('11111111'), ('0'); +-- +ok +== +SELECT v::VARCHAR FROM bit_zonemap_values WHERE v < '10101010'::BIT ORDER BY v; +-- +ok +== +SELECT v::VARCHAR FROM bit_zonemap_values WHERE v > '10101010'::BIT ORDER BY v; +-- +ok +== +CREATE TABLE bit_long_zonemap_values(v BIT); +-- +ok +== +INSERT INTO bit_long_zonemap_values VALUES (repeat('0', 100)::BIT), (repeat('1', 100)::BIT); +-- +ok +== +SELECT length(v::VARCHAR), substr(v::VARCHAR, 1, 1) +FROM bit_long_zonemap_values +WHERE v < repeat('1', 100)::BIT +ORDER BY v; +-- +ok +== +SELECT length(v::VARCHAR), substr(v::VARCHAR, 1, 1) +FROM bit_long_zonemap_values +WHERE v > repeat('0', 100)::BIT +ORDER BY v; +-- +ok +== diff --git a/parser/testdata/corpus/sql/types/bit/bit_try_cast.test b/parser/testdata/corpus/sql/types/bit/bit_try_cast.test new file mode 100644 index 0000000..ea17d5c --- /dev/null +++ b/parser/testdata/corpus/sql/types/bit/bit_try_cast.test @@ -0,0 +1,101 @@ +# source: test/sql/types/bit/bit_try_cast.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +SELECT try_cast(1::BIT as TINYINT); +-- +ok +== +SELECT try_cast(1::BIT as SMALLINT); +-- +ok +== +SELECT try_cast(1::BIT as UTINYINT); +-- +ok +== +SELECT try_cast(1::BIT as USMALLINT); +-- +ok +== +SELECT try_cast(bitstring('1', 9) as TINYINT); +-- +ok +== +SELECT try_cast(bitstring('1', 17) as SMALLINT); +-- +ok +== +SELECT try_cast(bitstring('1', 33) as INT); +-- +ok +== +SELECT try_cast(bitstring('1', 65) as BIGINT); +-- +ok +== +SELECT try_cast(bitstring('1', 33) as FLOAT); +-- +ok +== +SELECT try_cast(bitstring('1', 65) as DOUBLE); +-- +ok +== +SELECT try_cast(bitstring('1', 129) as HUGEINT); +-- +ok +== +SELECT try_cast(bitstring('1', 129) as UHUGEINT); +-- +ok +== +SELECT try_cast('00001111'::BIT as TINYINT); +-- +ok +== +SELECT try_cast('00001111'::BIT as SMALLINT); +-- +ok +== +SELECT try_cast('00001111'::BIT as INTEGER); +-- +ok +== +SELECT try_cast('00001111'::BIT as BIGINT); +-- +ok +== +SELECT try_cast('00001111'::BIT as UTINYINT); +-- +ok +== +SELECT try_cast('00001111'::BIT as USMALLINT); +-- +ok +== +SELECT try_cast('00001111'::BIT as UINTEGER); +-- +ok +== +SELECT try_cast('00001111'::BIT as UBIGINT); +-- +ok +== +SELECT try_cast('00001111'::BIT as HUGEINT); +-- +ok +== +SELECT try_cast('00001111'::BIT as UHUGEINT); +-- +ok +== +SELECT try_cast('00001111'::BIT as FLOAT); +-- +ok +== +SELECT try_cast('00001111'::BIT as DOUBLE); +-- +ok +== diff --git a/parser/testdata/corpus/sql/types/bit/test_bit.test b/parser/testdata/corpus/sql/types/bit/test_bit.test new file mode 100644 index 0000000..b0ea5dc --- /dev/null +++ b/parser/testdata/corpus/sql/types/bit/test_bit.test @@ -0,0 +1,137 @@ +# source: test/sql/types/bit/test_bit.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +SELECT ('0101011'::BIT) +-- +ok +== +SELECT ('0101011'::BITSTRING) +-- +ok +== +SELECT bitstring('0101011'::{cast}, 15); +-- +error: Parser Error: syntax error at or near "{" +== +SELECT bitstring('1'::{cast}, 6); +-- +error: Parser Error: syntax error at or near "{" +== +SELECT bitstring('1'::{cast}, 1); +-- +error: Parser Error: syntax error at or near "{" +== +SELECT bitstring('0101011'::{cast}, 203); +-- +error: Parser Error: syntax error at or near "{" +== +SELECT bitstring('111100001111000010101010'::{cast}, 36); +-- +error: Parser Error: syntax error at or near "{" +== +SELECT bitstring('0101011'::{cast}, 3); +-- +error: Parser Error: syntax error at or near "{" +== +SELECT bitstring('', 0); +-- +ok +== +SELECT bitstring('5', 10); +-- +ok +== +SELECT bitstring('0101011'); +-- +ok +== +INSERT INTO bits VALUES('101011010'), ('111'), ('1010010101111111001101') +-- +ok +== +INSERT INTO bits VALUES('0'), ('1'), ('0000000000000000000111') +-- +ok +== +SELECT * FROM bits WHERE b = '111'; +-- +ok +== +INSERT INTO bits VALUES('101211010') +-- +ok +== +INSERT INTO bits VALUES('1A10') +-- +ok +== +SELECT ('0101011'::BIT(10)) +-- +ok +== +SELECT NULL::BIT +-- +ok +== +SELECT ''::BIT +-- +ok +== +DELETE FROM bits +-- +ok +== +INSERT INTO bits VALUES (NULL) +-- +ok +== +INSERT INTO bits VALUES ('') +-- +ok +== +SELECT TRY_CAST('101' AS BIT) +-- +ok +== +SELECT TRY_CAST('102' AS BIT) +-- +ok +== +CREATE TABLE varchars (col VARCHAR); +-- +ok +== +INSERT INTO varchars VALUES('1010010101010101100001111111001101'), ('0') +-- +ok +== +SELECT col::BIT FROM varchars +-- +ok +== +INSERT INTO varchars VALUES('1011010'), ('0🦆1'), ('1'), ('3') +-- +ok +== +SELECT TRY_CAST(col AS BIT) FROM varchars +-- +ok +== +CREATE TABLE huge_bits (big bit); +-- +ok +== +INSERT INTO huge_bits VALUES('101011010010010100111000010101010100001001010010010100010101000001010010000010101010010101001010010010100100000010010010010010101010100010101001001001010010101101011010010010100111000010101010100001001010010010100010101000001010010000010101010010101001010010010100100000010010010010010101010100010101001001001010010101101011010010010100111000010101010100001001010010010100010101000001010010000010101010010101001010010010100100000010010010010010101010100010101001001001010010101101011010010010100111000010101010100001001010010010100010101000001010010000010101010010101001010010010100100000010010010010010101010100010101001001001010010101101011010010010100111000010101010100001001010010010100010101000001010010000010101010010101001010010010100100000010010010010010101010100010101001001001010010101101011010010010100111000010101010100001001010010010100010101000001010010000010101010010101001010010010100100000010010010010010101010100010101001001001010010101101011010010010100111000010101010100001001010010010100010101000001010010000010101010010101001010010010100100000010010010010010101010100010101001001001010010101101011010010010100111000010101010100001001010010010100010101000001010010000010101010010101001010010010100100000010010010010010101010100010101001001001010010101101011010010010100111000010101010100001001010010010100010101000001010010000010101010010101001010010010100100000010010010010010101010100010101001001001010010101101011010010010100111000010101010100001001010010010100010101000001010010000010101010010101001010010010100100000010010010010010101010100010101001001001010010101101011010010010100111000010101010100001001010010010100010101000001010010000010101010010101001010010010100100000010010010010010101010100010101001001001010010101101011010010010100111000010101010100001001010010010100010101000001010010000010101010010101001010010010100100000010010010010010101010100010101001001001010010101101011010010010100111000010101010100001001010010010100010101000001010010000010101010010101001010010010100100000010010010010010101010100010101001001001010010101101011010010010100111000010101010100001001010010010100010101000001010010000010101010010101001010010010100100000010010010010010101010100010101001001001010010101101011010010010100111000010101010100001001010010010100010101000001010010000010101010010101001010010010100100000010010010010010101010100010101001001001010010101101011010010010100111000010101010100001001010010010100010101000001010010000010101010010101001010010010100100000010010010010010101010100010101001001001010010101101011010010010100111000010101010100001001010010010100010101000001010010000010101010010101001010010010100100000010010010010010101010100010101001001001010010101101011010010010100111000010101010100001001010010010100010101000001010010000010101010010101001010010010100100000010010010010010101010100010101001001001010010101101011010010010100111000010101010100001001010010010100010101000001010010000010101010010101001010010010100100000010010010010010101010100010101001001001010010101101011010010010100111000010101010100001001010010010100010101000001010010000010101010010101001010010010100100000010010010010010101010100010101001001001010010101101011010010010100111000010101010100001001010010010100010101000001010010000010101010010101001010010010100100000010010010010010101010100010101001001001010010101101011010010010100111000010101010100001001010010010100010101000001010010000010101010010101001010010010100100000010010010010010101010100010101001001001010010101101011010010010100111000010101010100001001010010010100010101000001010010000010101010010101001010010010100100000010010010010010101010100010101001001001010010101101011010010010100111000010101010100001001010010010100010101000001010010000010101010010101001010010010100100000010010010010010101010100010101001001001010010101101011010010010100111000010101010100001001010010010100010101000001010010000010101010010101001010010010100100000010010010010010101010100010101001001001010010101101011010010010100111000010101010100001001010010010100010101000001010010000010101010010101001010010010100100000010010010010010101010100010101001001001010010101101011010010010100111000010101010100001001010010010100010101000001010010000010101010010101001010010010100100000010010010010010101010100010101001001001010010101101011010010010100111000010101010100001001010010010100010101000001010010000010101010010101001010010010100100000010010010010010101010100010101001001001010010101101011010010010100111000010101010100001001010010010100010101000001010010000010101010010101001010010010100100000010010010010010101010100010101001001001010010101101011010010010100111000010101010100001001010010010100010101000001010010000010101010010101001010010010100100000010010010010010101010100010101001001001010010101101011010010010100111000010101010100001001010010010100010101000001010010000010101010010101001010010010100100000010010010010010101010100010101001001001010010101101011010010010100111000010101010100001001010010010100010101000001010010000010101010010101001010010010100100000010010010010010101010100010101001001001010010101101011010010010100111000010101010100001001010010010100010101000001010010000010101010010101001010010010100100000010010010010010101010100010101001001001010010101101011010010010100111000010101010100001001010010010100010101000001010010000010101010010101001010010010100100000010010010010010101010100010101001001001010010101101011010010010100111000010101010100001001010010010100010101000001010010000010101010010101001010010010100100000010010010010010101010100010101001001001010010101101011010010010100111000010101010100001001010010010100010101000001010010000010101010010101001010010010100100000010010010010010101010100010101001001001010010101101011010010010100111000010101010100001001010010010100010101000001010010000010101010010101001010010010100100000010010010010010101010100010101001001001010010101101011010010010100111000010101010100001001010010010100010101000001010010000010101010010101001010010010100100000010010010010010101010100010101001001001010010101101011010010010100111000010101010100001001010010010100010101000001010010000010101010010101001010010010100100000010010010010010101010100010101001001001010010101101011010010010100111000010101010100001001010010010100010101000001010010000010101010010101001010010010100100000010010010010010101010100010101001001001010010101101011010010010100111000010101010100001001010010010100010101000001010010000010101010010101001010010010100100000010010010010010101010100010101001001001010010101101011010010010100111000010101010100001001010010010100010101000001010010000010101010010101001010010010100100000010010010010010101010100010101001001001010010101010110100100101001110000101010101000010010100100101000101010000010100100000101010100101010010100100101001000000100100100100101010101000101010010010010100101011010110100100101001110000101010101000010010100100101000101010000010100100000101010100101010010100100101001000000100100100100101010101000101010010010010100101011010110100100101001110000101010101000010010100100101000101010000010100100000101010100101010010100100101001000000100100100100101010101000101010010010010100101011010110100100101001110000101010101000010010100100101000101010000010100100000101010100101010010100100101001000000100100100100101010101000101010010010010100101011010110100100101001110000101010101000010010100100101000101010000010100100000101010100101010010100100101001000000100100100100101010101000101010010010010100101011010110100100101001110000101010101000010010100100101000101010000010100100000101010100101010010100100101001000000100100100100101010101000101010010010010100101011010110100100101001110000101010101000010010100100101000101010000010100100000101010100101010010100100101001000000100100100100101010101000101010010010010100101011010110100100101001110000101010101000010010100100101000101010000010100100000101010100101010010100100101001000000100100100100101010101000101010010010010100101011010110100100101001110000101010101000010010100100101000101010000010100100000101010100101010010100100101001000000100100100100101010101000101010010010010100101011010110100100101001110000101010101000010010100100101000101010000010100100000101010100101010010100100101001000000100100100100101010101000101010010010010100101011010110100100101001110000101010101000010010100100101000101010000010100100000101010100101010010100100101001000000100100100100101010101000101010010010010100101011010110100100101001110000101010101000010010100100101000101010000010100100000101010100101010010100100101001000000100100100100101010101000101010010010010100101011010110100100101001110000101010101000010010100100101000101010000010100100000101010100101010010100100101001000000100100100100101010101000101010010010010100101011010110100100101001110000101010101000010010100100101000101010000010100100000101010100101010010100100101001000000100100100100101010101000101010010010010100101011010110100100101001110000101010101000010010100100101000101010000010100100000101010100101010010100100101001000000100100100100101010101000101010010010010100101011010110100100101001110000101010101000010010100100101000101010000010100100000101010100101010010100100101001000000100100100100101010101000101010010010010100101011010110100100101001110000101010101000010010100100101000101010000010100100000101010100101010010100100101001000000100100100100101010101000101010010010010100101011010110100100101001110000101010101000010010100100101000101010000010100100000101010100101010010100100101001000000100100100100101010101000101010010010010100101011010110100100101001110000101010101000010010100100101000101010000010100100000101010100101010010100100101001000000100100100100101010101000101010010010010100101011010110100100101001110000101010101000010010100100101000101010000010100100000101010100101010010100100101001000000100100100100101010101000101010010010010100101011010110100100101001110000101010101000010010100100101000101010000010100100000101010100101010010100100101001000000100100100100101010101000101010010010010100101011') +-- +ok +== +SELECT bit_length(big) FROM huge_bits +-- +ok +== +select( 'ab'::blob::bit<<2)::blob; +-- +ok +== diff --git a/parser/testdata/corpus/sql/types/bit/test_bit_bitwise_operations.test b/parser/testdata/corpus/sql/types/bit/test_bit_bitwise_operations.test new file mode 100644 index 0000000..4497dc5 --- /dev/null +++ b/parser/testdata/corpus/sql/types/bit/test_bit_bitwise_operations.test @@ -0,0 +1,113 @@ +# source: test/sql/types/bit/test_bit_bitwise_operations.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +INSERT INTO bits VALUES('101111011010'), ('110001100100'), ('101001000110') +-- +ok +== +SELECT '10101'::BIT & '10001'::BIT +-- +ok +== +SELECT '1000001101011111'::BIT & '1100101101000011'::BIT +-- +ok +== +SELECT '01011'::BIT & '11000'::BIT +-- +ok +== +SELECT b & '011100011011'::BIT FROM bits +-- +ok +== +SELECT '010110'::BIT & '11000'::BIT +-- +ok +== +SELECT '10001111'::BIT | '00011011'::BIT +-- +ok +== +SELECT '1011'::BIT | '0001'::BIT +-- +ok +== +SELECT '10000010011101011111'::BIT | '11001011010011100011'::BIT +-- +ok +== +SELECT b | '011100011011'::BIT FROM bits +-- +ok +== +SELECT '0110'::BIT | '11000'::BIT +-- +ok +== +SELECT xor('101'::BIT, '001'::BIT) +-- +ok +== +SELECT xor('10000010011101011111'::BIT, '11001011010111000011'::BIT) +-- +ok +== +SELECT xor(b, '011100011011'::BIT) FROM bits +-- +ok +== +SELECT xor('011010110'::BIT, '11000'::BIT) +-- +ok +== +SELECT ~('101'::BIT) +-- +ok +== +SELECT ~('1001010101111111000111'::BIT) +-- +ok +== +SELECT ~(b) FROM bits +-- +ok +== +SELECT '1001010101111111000111'::BIT << 4 +-- +ok +== +SELECT '010101'::BIT << 50 +-- +ok +== +SELECT '101'::BIT << 0 +-- +ok +== +SELECT '010101'::BIT << -2 +-- +ok +== +SELECT b << 3 FROM bits +-- +ok +== +SELECT '1001010101111111000111'::BIT >> 10 +-- +ok +== +SELECT '010101'::BIT >> 50 +-- +ok +== +SELECT '101'::BIT >> 0 +-- +ok +== +SELECT b >> 5 FROM bits +-- +ok +== diff --git a/parser/testdata/corpus/sql/types/bit/test_bit_equality.test b/parser/testdata/corpus/sql/types/bit/test_bit_equality.test new file mode 100644 index 0000000..1b7daa2 --- /dev/null +++ b/parser/testdata/corpus/sql/types/bit/test_bit_equality.test @@ -0,0 +1,9 @@ +# source: test/sql/types/bit/test_bit_equality.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +select bitstring('1', 6) from range(100000) group by 1; +-- +ok +== diff --git a/parser/testdata/corpus/sql/types/bit/test_bit_functions.test b/parser/testdata/corpus/sql/types/bit/test_bit_functions.test new file mode 100644 index 0000000..d971856 --- /dev/null +++ b/parser/testdata/corpus/sql/types/bit/test_bit_functions.test @@ -0,0 +1,121 @@ +# source: test/sql/types/bit/test_bit_functions.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +INSERT INTO bits VALUES('101001111'), ('00111'), ('100101010110000000000001'), ('111111010100') +-- +ok +== +INSERT INTO bits VALUES('0110108'); +-- +ok +== +SELECT bit_length('1010111111101010011101011'::BIT) +-- +ok +== +SELECT bit_length('0'::BIT) +-- +ok +== +SELECT bit_length(b) FROM bits; +-- +ok +== +SELECT octet_length('10101111111010100111010'::BIT) +-- +ok +== +SELECT octet_length('0'::BIT) +-- +ok +== +SELECT octet_length(b) FROM bits; +-- +ok +== +SELECT get_bit('101010101010101010'::BIT, 6) +-- +ok +== +SELECT get_bit('110'::BIT, 2) +-- +ok +== +SELECT get_bit('1010000'::BIT, 0) +-- +ok +== +SELECT get_bit(b, 4) FROM bits; +-- +ok +== +SELECT get_bit('10101'::BIT, 6) +-- +ok +== +SELECT get_bit('001'::BIT, -1) +-- +ok +== +SELECT set_bit('0101010101010101010'::BIT, 2, 1) +-- +ok +== +SELECT set_bit('1111111'::BIT, 5, 0) +-- +ok +== +SELECT set_bit('11111'::BIT, 0, 0) +-- +ok +== +SELECT set_bit(b, 3, 0) FROM bits +-- +ok +== +SELECT set_bit('11111'::BIT, 2, 7) +-- +ok +== +SELECT set_bit('10101'::BIT, 6, 1) +-- +ok +== +SELECT set_bit('011'::BIT, -1, 0) +-- +ok +== +SELECT bit_count('10101'::BIT) +-- +ok +== +SELECT bit_count('0000000'::BIT) +-- +ok +== +SELECT bit_count('1101111111111101111111111111111101111'::BIT) +-- +ok +== +SELECT bit_count(b) FROM bits +-- +ok +== +SELECT bit_position('010'::BIT, '010111'::BIT) +-- +ok +== +SELECT bit_position('010'::BIT, '1110101'::BIT) +-- +ok +== +SELECT bit_position('010'::BIT, '11110011011011101011'::BIT) +-- +ok +== +SELECT bit_position('010'::BIT, '1101110101011101'::BIT) +-- +ok +== diff --git a/parser/testdata/corpus/sql/types/bit/test_hex_to_bit.test b/parser/testdata/corpus/sql/types/bit/test_hex_to_bit.test new file mode 100644 index 0000000..a2d965f --- /dev/null +++ b/parser/testdata/corpus/sql/types/bit/test_hex_to_bit.test @@ -0,0 +1,49 @@ +# source: test/sql/types/bit/test_hex_to_bit.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +CREATE TABLE valid (v VARCHAR); +-- +ok +== +INSERT INTO valid VALUES ('x0'), ('x04'), ('x0F0'), ('xFFFF'), ('xABCDE'), ('xabcdef'); +-- +ok +== +SELECT v::BIT FROM valid; +-- +ok +== +CREATE TABLE invalid (v VARCHAR); +-- +ok +== +INSERT INTO invalid VALUES ('x0/'), ('x0:4'), ('x@0F0'), ('xFFGF'), ('xAB`DE'), ('xabcdgf'); +-- +ok +== +SELECT TRY_CAST(v AS BIT) FROM invalid; +-- +ok +== +SELECT bitstring('x1'::BIT, 4) +-- +ok +== +SELECT bitstring('x1'::BIT, 5) +-- +ok +== +SELECT bitstring('x1'::BIT, 3) +-- +ok +== +SELECT 'x01g'::BIT +-- +ok +== +SELECT 'x'::BIT +-- +ok +== diff --git a/parser/testdata/corpus/sql/types/blob/test_blob.test b/parser/testdata/corpus/sql/types/blob/test_blob.test new file mode 100644 index 0000000..4e3f754 --- /dev/null +++ b/parser/testdata/corpus/sql/types/blob/test_blob.test @@ -0,0 +1,25 @@ +# source: test/sql/types/blob/test_blob.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +SELECT 'abc �'::BYTEA; +-- +ok +== +SELECT ''::BLOB +-- +ok +== +SELECT NULL::BLOB +-- +ok +== +select 'ü'::blob; +-- +ok +== +SELECT '\x7F'::BLOB; +-- +ok +== diff --git a/parser/testdata/corpus/sql/types/blob/test_blob_cast.test b/parser/testdata/corpus/sql/types/blob/test_blob_cast.test new file mode 100644 index 0000000..1564ad9 --- /dev/null +++ b/parser/testdata/corpus/sql/types/blob/test_blob_cast.test @@ -0,0 +1,61 @@ +# source: test/sql/types/blob/test_blob_cast.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +SELECT 'a'::BYTEA::VARCHAR +-- +ok +== +SELECT 'a'::VARCHAR::BYTEA +-- +ok +== +SELECT '\x20\x00\xFF'::BYTEA +-- +ok +== +SELECT '\x20\x00\xFF'::BLOB::VARCHAR +-- +ok +== +SELECT '\x20\x00\xFF'::BLOB::VARCHAR::BLOB +-- +ok +== +SELECT '\x20\x00\xFF'::BLOB::VARCHAR::BLOB::VARCHAR +-- +ok +== +SELECT '\x20\x00\xFF'::VARCHAR::BLOB::VARCHAR::BLOB +-- +ok +== +SELECT 1::BYTEA +-- +ok +== +SELECT 1.0::BYTEA +-- +ok +== +SELECT 1::tinyint::BYTEA +-- +ok +== +SELECT 1::smallint::BYTEA +-- +ok +== +SELECT 1::integer::BYTEA +-- +ok +== +SELECT 1::bigint::BYTEA +-- +ok +== +SELECT 1::decimal::BYTEA +-- +ok +== diff --git a/parser/testdata/corpus/sql/types/blob/test_blob_function.test b/parser/testdata/corpus/sql/types/blob/test_blob_function.test new file mode 100644 index 0000000..4da2e7a --- /dev/null +++ b/parser/testdata/corpus/sql/types/blob/test_blob_function.test @@ -0,0 +1,53 @@ +# source: test/sql/types/blob/test_blob_function.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +INSERT INTO blobs VALUES ('a'::BYTEA) +-- +ok +== +SELECT b || 'ZZ'::BYTEA FROM blobs +-- +ok +== +SELECT 'abc '::BYTEA || 'klm *\xEF\xBF\xBDT'::BYTEA +-- +ok +== +INSERT INTO blobs VALUES ('abc klm *\xEF\xBF\xBDT'::BYTEA) +-- +ok +== +SELECT COUNT(*) FROM blobs +-- +ok +== +SELECT OCTET_LENGTH(b) FROM blobs +-- +ok +== +INSERT INTO blobs VALUES ('\xFF'::BYTEA) +-- +ok +== +SELECT b || '\x5A\x5A'::BYTEA FROM blobs +-- +ok +== +SELECT b || '5A5A'::VARCHAR FROM blobs +-- +ok +== +INSERT INTO blobs VALUES ('FF'::BYTEA) +-- +ok +== +INSERT INTO blobs VALUES ('\x55\xAA\xFF\x55\xAA\xFF\x55\xAA\xFF\x01'::BYTEA) +-- +ok +== +INSERT INTO blobs VALUES ('55AAFF55AAFF55AAFF01'::BYTEA) +-- +ok +== diff --git a/parser/testdata/corpus/sql/types/blob/test_blob_invalid_utf8.test b/parser/testdata/corpus/sql/types/blob/test_blob_invalid_utf8.test new file mode 100644 index 0000000..fd7c857 --- /dev/null +++ b/parser/testdata/corpus/sql/types/blob/test_blob_invalid_utf8.test @@ -0,0 +1,17 @@ +# source: test/sql/types/blob/test_blob_invalid_utf8.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +CREATE TABLE b(b blob); +-- +ok +== +INSERT INTO b VALUES (NULL); +-- +ok +== +UPDATE b SET b=blob'\x80abcdefghjijklmnopqrstuvwxyz'; +-- +ok +== diff --git a/parser/testdata/corpus/sql/types/blob/test_blob_operator.test b/parser/testdata/corpus/sql/types/blob/test_blob_operator.test new file mode 100644 index 0000000..0020812 --- /dev/null +++ b/parser/testdata/corpus/sql/types/blob/test_blob_operator.test @@ -0,0 +1,45 @@ +# source: test/sql/types/blob/test_blob_operator.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +CREATE TABLE blobs (b BYTEA, g INTEGER); +-- +ok +== +INSERT INTO blobs VALUES ('hello', 0), ('\x00whatisgoingon', 1), (NULL, 0), ('\xFF\xFE\xFB', 1) +-- +ok +== +SELECT COUNT(*), COUNT(b), MIN(b), MAX(b) FROM blobs +-- +ok +== +SELECT * FROM blobs ORDER BY b +-- +ok +== +INSERT INTO blobs VALUES ('hello', 3), ('\x00whatisgoingon', 9), (NULL, 0), ('\xFF\xFE\xFB', 19) +-- +ok +== +SELECT b, SUM(g) FROM blobs GROUP BY b ORDER BY b +-- +ok +== +CREATE TABLE blobs2 (b BYTEA, g INTEGER); +-- +ok +== +INSERT INTO blobs2 VALUES ('hello', 0), ('\x00whatisgoingon', 100), (NULL, 0), ('\xFF\xFE\xFB', 200) +-- +ok +== +SELECT L.b, SUM(L.g) FROM blobs as L JOIN blobs2 AS R ON L.b=R.b GROUP BY L.b ORDER BY L.b +-- +ok +== +SELECT R.b, SUM(R.g) FROM blobs as L, blobs2 AS R WHERE L.b=R.b GROUP BY R.b ORDER BY R.b +-- +ok +== diff --git a/parser/testdata/corpus/sql/types/blob/test_blob_string.test b/parser/testdata/corpus/sql/types/blob/test_blob_string.test new file mode 100644 index 0000000..fa7cae1 --- /dev/null +++ b/parser/testdata/corpus/sql/types/blob/test_blob_string.test @@ -0,0 +1,17 @@ +# source: test/sql/types/blob/test_blob_string.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +INSERT INTO blobs VALUES ('aaaaaaaaaa') +-- +ok +== +INSERT INTO blobs SELECT b||b||b||b||b||b||b||b||b||b FROM blobs WHERE OCTET_LENGTH(b)=(SELECT MAX(OCTET_LENGTH(b)) FROM blobs) +-- +ok +== +SELECT OCTET_LENGTH(b) FROM blobs ORDER BY 1 +-- +ok +== diff --git a/parser/testdata/corpus/sql/types/blob/test_blob_try_cast.test b/parser/testdata/corpus/sql/types/blob/test_blob_try_cast.test new file mode 100644 index 0000000..aafa108 --- /dev/null +++ b/parser/testdata/corpus/sql/types/blob/test_blob_try_cast.test @@ -0,0 +1,61 @@ +# source: test/sql/types/blob/test_blob_try_cast.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +SELECT TRY_CAST('\\' AS BLOB) +-- +ok +== +SELECT TRY_CAST('\\x3' AS BLOB) +-- +ok +== +SELECT TRY_CAST('\\b12' AS BLOB) +-- +ok +== +SELECT TRY_CAST('\\xx2' AS BLOB) +-- +ok +== +SELECT TRY_CAST('\\x2x' AS BLOB) +-- +ok +== +SELECT TRY_CAST('ü' AS BLOB) +-- +ok +== +SELECT TRY_CAST('\x12' AS BLOB) +-- +ok +== +SELECT '\\'::BLOB +-- +ok +== +SELECT '\\x3'::BLOB +-- +ok +== +SELECT '\\b12'::BLOB +-- +ok +== +SELECT '\\xx2'::BLOB +-- +ok +== +SELECT '\\x2x'::BLOB +-- +ok +== +SELECT 'ü'::BLOB +-- +ok +== +SELECT CAST('\x12' AS BLOB) +-- +ok +== diff --git a/parser/testdata/corpus/sql/types/date/date_implicit_cast.test b/parser/testdata/corpus/sql/types/date/date_implicit_cast.test new file mode 100644 index 0000000..c33f078 --- /dev/null +++ b/parser/testdata/corpus/sql/types/date/date_implicit_cast.test @@ -0,0 +1,21 @@ +# source: test/sql/types/date/date_implicit_cast.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +CREATE TABLE timestamps(ts {type}) +-- +error: Parser Error: syntax error at or near "{" +== +INSERT INTO timestamps VALUES ('1993-08-14 00:00:00'), ('1993-08-15 01:01:02'), ('1993-08-16 00:00:00') +-- +ok +== +SELECT * FROM timestamps WHERE ts >= date '1993-08-15' +-- +ok +== +DROP TABLE timestamps +-- +ok +== diff --git a/parser/testdata/corpus/sql/types/date/date_limits.test b/parser/testdata/corpus/sql/types/date/date_limits.test new file mode 100644 index 0000000..3c1345e --- /dev/null +++ b/parser/testdata/corpus/sql/types/date/date_limits.test @@ -0,0 +1,197 @@ +# source: test/sql/types/date/date_limits.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +select '1969-01-01'::date +-- +ok +== +select '2370-01-01'::date +-- +ok +== +select '5877642-06-25 (BC)'::date +-- +ok +== +select '5877642-06-24 (BC)'::date +-- +ok +== +select '5877680-06-23 (BC)'::date +-- +ok +== +select '99999999-06-23 (BC)'::date +-- +ok +== +select '290308-01-01 (BC)'::date::timestamp +-- +ok +== +select '290309-01-01 (BC)'::date::timestamp +-- +ok +== +select '5877642-06-23 (BC)'::date::timestamp +-- +ok +== +select '5877642-06-25 (BC)'::date + 1 +-- +ok +== +select '5877642-06-24 (BC)'::date - 1 +-- +ok +== +select '5877642-06-24 (BC)'::date - 365 +-- +ok +== +select '5877642-06-24 (BC)'::date - 2147483647 +-- +ok +== +select '290309-12-22 (BC)'::date + interval (1) day +-- +ok +== +select '290309-12-22 (BC)'::date - interval (1) day +-- +ok +== +select '290309-12-22 (BC)'::date - interval (365) day +-- +ok +== +select '290309-12-22 (BC)'::date - interval (2147483647) day +-- +ok +== +select '290309-12-22 (BC)'::date - interval (9999999999999) second +-- +ok +== +select '290309-12-22 (BC)'::date - interval (9223372036854775807) microsecond +-- +ok +== +select '290309-12-22 (BC)'::date - interval '1147483647 days 9223372036854775807 microseconds' +-- +ok +== +select '290309-12-22 (BC)'::date - interval '2147483647 days 9223372036854775807 microseconds' +-- +ok +== +select '290309-12-22 (BC)'::date - interval '2007483647 days 9223372036854775807 microseconds' +-- +ok +== +select '290309-12-22 (BC)'::date + interval (1) month +-- +ok +== +select '5877642-06-23 (BC)'::date - interval (1) month +-- +ok +== +select '5877642-06-23 (BC)'::date - interval (2147483647) month +-- +ok +== +select '5881580-07-10'::date +-- +ok +== +select '5881580-07-11'::date +-- +ok +== +select '5881580-08-11'::date +-- +ok +== +select '99999999-01-01'::date +-- +ok +== +select '294247-01-10'::date::timestamp +-- +ok +== +select '294247-01-11'::date::timestamp +-- +ok +== +select '5881580-07-10'::date - 1 +-- +ok +== +select '5881580-07-10'::date + 1 +-- +ok +== +select '5881580-07-10'::date + 365 +-- +ok +== +select '5881580-07-10'::date + 2147483647 +-- +ok +== +SELECT '5877642-06-25 (BC)'::DATE - 1; +-- +ok +== +select '294247-01-10'::date - interval (1) day +-- +ok +== +select '294247-01-10'::date + interval (1) day +-- +ok +== +select '294247-01-10'::date + interval (365) day +-- +ok +== +select '294247-01-10'::date + interval (2147483647) day +-- +ok +== +select '294247-01-10'::date + interval (9999999999999) second +-- +ok +== +select '294247-01-10'::date + interval (9223372036854775807) microsecond +-- +ok +== +select '294247-01-10'::date + interval '1147483647 days 9223372036854775807 microseconds' +-- +ok +== +select '294247-01-10'::date + interval '2147483647 days 9223372036854775807 microseconds' +-- +ok +== +select '294247-01-10'::date + interval '2007483647 days 9223372036854775807 microseconds' +-- +ok +== +select '294247-01-10'::date + interval (1) month +-- +ok +== +select '294247-01-10'::date - interval (1) month +-- +ok +== +select '5881580-07-10'::date - '5877642-06-25 (BC)'::date +-- +ok +== diff --git a/parser/testdata/corpus/sql/types/date/date_parsing.test b/parser/testdata/corpus/sql/types/date/date_parsing.test new file mode 100644 index 0000000..2258a4a --- /dev/null +++ b/parser/testdata/corpus/sql/types/date/date_parsing.test @@ -0,0 +1,406 @@ +# source: test/sql/types/date/date_parsing.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +SELECT '1992-01-01'::DATE::VARCHAR == '1992-01-01' +-- +ok +== +SELECT '1992-09-20'::DATE::VARCHAR == '1992-09-20' +-- +ok +== +SELECT '1992-02-29'::DATE::VARCHAR == '1992-02-29' +-- +ok +== +SELECT '3600-02-29'::DATE::VARCHAR == '3600-02-29' +-- +ok +== +SELECT '0030-01-01'::DATE::VARCHAR == '0030-01-01' +-- +ok +== +SELECT '30000-01-01'::DATE::VARCHAR == '30000-01-01' +-- +ok +== +SELECT '1969-01-01'::DATE::VARCHAR == '1969-01-01' +-- +ok +== +SELECT '1970-01-01'::DATE::VARCHAR == '1970-01-01' +-- +ok +== +SELECT '2369-01-01'::DATE::VARCHAR == '2369-01-01' +-- +ok +== +SELECT '2370-01-01'::DATE::VARCHAR == '2370-01-01' +-- +ok +== +SELECT '2371-01-01'::DATE::VARCHAR == '2371-01-01' +-- +ok +== +SELECT '-1000-01-01'::DATE::VARCHAR == '1001-01-01 (BC)' +-- +ok +== +SELECT '1992/09/20'::DATE::VARCHAR == '1992-09-20' +-- +ok +== +SELECT '1992 09 20'::DATE::VARCHAR == '1992-09-20' +-- +ok +== +SELECT '1992\09\20'::DATE::VARCHAR == '1992-09-20' +-- +ok +== +SELECT CAST('2020-01-01 garbage' AS DATE) +-- +ok +== +SELECT CAST('2020-01-01 garbage' AS DATE) +-- +ok +== +SELECT CAST('2020-01-01abc' AS DATE) +-- +ok +== +SELECT TRY_CAST('2020-01-01 garbage' AS DATE) IS NULL +-- +ok +== +SELECT CAST('2020-01-01 12:34:56' AS DATE) +-- +ok +== +SELECT CAST('2020-01-01 ' AS DATE) +-- +ok +== +SELECT CAST(CAST('2020-01-01 24:00:00' AS DATE) AS VARCHAR), + COALESCE(CAST(TRY_CAST('294247-01-11 00:00:00' AS DATE) AS VARCHAR), 'NULL'); +-- +ok +== +SELECT '1993-01-31'::DATE::VARCHAR +-- +ok +== +SELECT '1993-01-32'::DATE::VARCHAR +-- +ok +== +SELECT '1993-02-28'::DATE::VARCHAR +-- +ok +== +SELECT '1993-02-29'::DATE::VARCHAR +-- +ok +== +SELECT '1993-03-31'::DATE::VARCHAR +-- +ok +== +SELECT '1993-03-32'::DATE::VARCHAR +-- +ok +== +SELECT '1993-04-30'::DATE::VARCHAR +-- +ok +== +SELECT '1993-04-31'::DATE::VARCHAR +-- +ok +== +SELECT '1993-05-31'::DATE::VARCHAR +-- +ok +== +SELECT '1993-05-32'::DATE::VARCHAR +-- +ok +== +SELECT '1993-06-30'::DATE::VARCHAR +-- +ok +== +SELECT '1993-06-31'::DATE::VARCHAR +-- +ok +== +SELECT '1993-07-31'::DATE::VARCHAR +-- +ok +== +SELECT '1993-07-32'::DATE::VARCHAR +-- +ok +== +SELECT '1993-08-31'::DATE::VARCHAR +-- +ok +== +SELECT '1993-08-32'::DATE::VARCHAR +-- +ok +== +SELECT '1993-09-30'::DATE::VARCHAR +-- +ok +== +SELECT '1993-09-31'::DATE::VARCHAR +-- +ok +== +SELECT '1993-10-31'::DATE::VARCHAR +-- +ok +== +SELECT '1993-10-32'::DATE::VARCHAR +-- +ok +== +SELECT '1993-11-30'::DATE::VARCHAR +-- +ok +== +SELECT '1993-11-31'::DATE::VARCHAR +-- +ok +== +SELECT '1993-12-31'::DATE::VARCHAR +-- +ok +== +SELECT '1993-12-32'::DATE::VARCHAR +-- +ok +== +SELECT '1992-01-31'::DATE::VARCHAR +-- +ok +== +SELECT '1992-01-32'::DATE::VARCHAR +-- +ok +== +SELECT '1992-02-29'::DATE::VARCHAR +-- +ok +== +SELECT '1992-02-30'::DATE::VARCHAR +-- +ok +== +SELECT '1992-03-31'::DATE::VARCHAR +-- +ok +== +SELECT '1992-03-32'::DATE::VARCHAR +-- +ok +== +SELECT '1992-04-30'::DATE::VARCHAR +-- +ok +== +SELECT '1992-04-31'::DATE::VARCHAR +-- +ok +== +SELECT '1992-05-31'::DATE::VARCHAR +-- +ok +== +SELECT '1992-05-32'::DATE::VARCHAR +-- +ok +== +SELECT '1992-06-30'::DATE::VARCHAR +-- +ok +== +SELECT '1992-06-31'::DATE::VARCHAR +-- +ok +== +SELECT '1992-07-31'::DATE::VARCHAR +-- +ok +== +SELECT '1992-07-32'::DATE::VARCHAR +-- +ok +== +SELECT '1992-08-31'::DATE::VARCHAR +-- +ok +== +SELECT '1992-08-32'::DATE::VARCHAR +-- +ok +== +SELECT '1992-09-30'::DATE::VARCHAR +-- +ok +== +SELECT '1992-09-31'::DATE::VARCHAR +-- +ok +== +SELECT '1992-10-31'::DATE::VARCHAR +-- +ok +== +SELECT '1992-10-32'::DATE::VARCHAR +-- +ok +== +SELECT '1992-11-30'::DATE::VARCHAR +-- +ok +== +SELECT '1992-11-31'::DATE::VARCHAR +-- +ok +== +SELECT '1992-12-31'::DATE::VARCHAR +-- +ok +== +SELECT '1992-12-32'::DATE::VARCHAR +-- +ok +== +SELECT '1900-02-29'::DATE::VARCHAR +-- +ok +== +SELECT '2000-02-29'::DATE::VARCHAR == '2000-02-29' +-- +ok +== +SELECT '0-01-01'::DATE::VARCHAR +-- +ok +== +SELECT '1-01-01'::DATE::VARCHAR +-- +ok +== +SELECT '-1-01-01'::DATE::VARCHAR +-- +ok +== +SELECT '100000'::DATE::VARCHAR +-- +ok +== +SELECT '1992-10/10'::DATE::VARCHAR +-- +ok +== +SELECT '1992a10a10'::DATE::VARCHAR +-- +ok +== +SELECT '1992/10-10'::DATE::VARCHAR +-- +ok +== +SELECT 'hello'::DATE::VARCHAR +-- +ok +== +SELECT 'aa-10-10'::DATE::VARCHAR +-- +ok +== +SELECT '1992-aa-10'::DATE::VARCHAR +-- +ok +== +SELECT '1992-10-aa'::DATE::VARCHAR +-- +ok +== +SELECT ''::DATE::VARCHAR +-- +ok +== +SELECT '-'::DATE::VARCHAR +-- +ok +== +SELECT '-/10/10'::DATE::VARCHAR +-- +ok +== +SELECT '-291000-01-01'::DATE:VARCHAR; +-- +error: Parser Error: syntax error at or near ":" +== +SELECT '291000-01-01'::DATE::VARCHAR; +-- +ok +== +SELECT '291000-01-01 (BC)'::DATE:VARCHAR; +-- +error: Parser Error: syntax error at or near ":" +== +SELECT '-a'::DATE::VARCHAR +-- +ok +== +SELECT '1992-'::DATE::VARCHAR +-- +ok +== +SELECT '1992-10'::DATE::VARCHAR +-- +ok +== +SELECT '1992-10-'::DATE::VARCHAR +-- +ok +== +SELECT '10000000000-01-01'::DATE::VARCHAR +-- +ok +== +SELECT '-10000000000-01-01'::DATE::VARCHAR +-- +ok +== +SELECT '1992-30-30'::DATE::VARCHAR +-- +ok +== +SELECT '1992-00-50'::DATE::VARCHAR +-- +ok +== +SELECT '1992-01-00'::DATE::VARCHAR +-- +ok +== +SELECT '1992-10-50'::DATE::VARCHAR +-- +ok +== +SELECT '1992-10-100'::DATE::VARCHAR +-- +ok +== diff --git a/parser/testdata/corpus/sql/types/date/date_try_cast.test b/parser/testdata/corpus/sql/types/date/date_try_cast.test new file mode 100644 index 0000000..54e80b0 --- /dev/null +++ b/parser/testdata/corpus/sql/types/date/date_try_cast.test @@ -0,0 +1,121 @@ +# source: test/sql/types/date/date_try_cast.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +select try_cast('' as date) +-- +ok +== +select try_cast(' ' as date) +-- +ok +== +select try_cast('1111' as date) +-- +ok +== +select try_cast(' 1111 ' as date) +-- +ok +== +select try_cast('1111-' as date) +-- +ok +== +select try_cast('1111-11' as date) +-- +ok +== +select try_cast('1111-11-' as date) +-- +ok +== +select try_cast('1111-111-1' as date) +-- +ok +== +select try_cast('1111-11-111' as date) +-- +ok +== +select try_cast('1111-11-11' as date) +-- +ok +== +select try_cast('1111-11-11 (bc)' as date) +-- +ok +== +select try_cast('2001-02-29' as date) +-- +ok +== +select try_cast('2004-02-29' as date) +-- +ok +== +select try_cast('2004/02/29' as date) +-- +ok +== +select try_cast('2004/02-29' as date) +-- +ok +== +select try_cast('5877642-06-25 (BC)' as date) +-- +ok +== +select try_cast('5877642-06-24 (BC)' as date) +-- +ok +== +select try_cast('-infinity' as date); +-- +ok +== +select try_cast('99999999-06-22 (BC)' as date); +-- +ok +== +select try_cast('290308-01-01 (BC)'::date as timestamp) +-- +ok +== +select try_cast('290309-01-01 (BC)'::date as timestamp) +-- +ok +== +select try_cast('5877642-06-25 (BC)'::date as timestamp) +-- +ok +== +select try_cast('5881580-07-10' as date) +-- +ok +== +select try_cast('5881580-07-11' as date) +-- +ok +== +select try_cast('infinity' as date) +-- +ok +== +select try_cast('5881580-08-11' as date) +-- +ok +== +select try_cast('99999999-01-01' as date) +-- +ok +== +select try_cast('294246-12-31'::date as timestamp) +-- +ok +== +select try_cast('294247-12-31'::date as timestamp) +-- +ok +== diff --git a/parser/testdata/corpus/sql/types/date/test_bc_dates.test b/parser/testdata/corpus/sql/types/date/test_bc_dates.test new file mode 100644 index 0000000..cc3fbef --- /dev/null +++ b/parser/testdata/corpus/sql/types/date/test_bc_dates.test @@ -0,0 +1,45 @@ +# source: test/sql/types/date/test_bc_dates.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +INSERT INTO dates VALUES ('-1993-08-14'), (NULL) +-- +ok +== +SELECT year(i) FROM dates +-- +ok +== +SELECT cast(i AS VARCHAR) FROM dates +-- +ok +== +SELECT DATE '0000-01-01' +-- +ok +== +SELECT DATE '0000-01-01 (BC)' +-- +ok +== +SELECT DATE '-0030-01-01 (BC)' +-- +ok +== +SELECT DATE '1992-01-01 (BC)' +-- +ok +== +SELECT DATE '-1992-01-01' +-- +ok +== +CREATE TABLE bc_dates AS SELECT date '0020-01-01' - interval (i) years AS d from range(0, 40) tbl(i); +-- +ok +== +SELECT d, d::VARCHAR FROM bc_dates ORDER BY 1 +-- +ok +== diff --git a/parser/testdata/corpus/sql/types/date/test_date.test b/parser/testdata/corpus/sql/types/date/test_date.test new file mode 100644 index 0000000..f923acd --- /dev/null +++ b/parser/testdata/corpus/sql/types/date/test_date.test @@ -0,0 +1,65 @@ +# source: test/sql/types/date/test_date.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +SELECT i + 5 FROM dates +-- +ok +== +SELECT i - 5 FROM dates +-- +ok +== +SELECT i * 3 FROM dates +-- +ok +== +SELECT i / 3 FROM dates +-- +ok +== +SELECT i % 3 FROM dates +-- +ok +== +SELECT i + i FROM dates +-- +ok +== +SELECT (i + 5) - i FROM dates +-- +ok +== +SELECT ''::DATE +-- +ok +== +SELECT ' '::DATE +-- +ok +== +SELECT '1992'::DATE +-- +ok +== +SELECT '1992-'::DATE +-- +ok +== +SELECT '1992-01'::DATE +-- +ok +== +SELECT '1992-01-'::DATE +-- +ok +== +SELECT '30000307-01-01 (BC)'::DATE +-- +ok +== +SELECT '2021-03-01'::DATE, DATE '2021-03-01', DATE('2021-03-01') +-- +ok +== diff --git a/parser/testdata/corpus/sql/types/date/test_date_2411.test b/parser/testdata/corpus/sql/types/date/test_date_2411.test new file mode 100644 index 0000000..63f6ee9 --- /dev/null +++ b/parser/testdata/corpus/sql/types/date/test_date_2411.test @@ -0,0 +1,21 @@ +# source: test/sql/types/date/test_date_2411.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +CREATE TABLE timestamp(i TIMESTAMP) +-- +ok +== +INSERT INTO dates VALUES ('1993-08-14') +-- +ok +== +INSERT INTO timestamp VALUES ('1993-08-14 00:00:01') +-- +ok +== +select count(*) from dates inner join timestamp on (timestamp.i::DATE = dates.i) +-- +ok +== diff --git a/parser/testdata/corpus/sql/types/date/test_incorrect_dates.test b/parser/testdata/corpus/sql/types/date/test_incorrect_dates.test new file mode 100644 index 0000000..0e2bee6 --- /dev/null +++ b/parser/testdata/corpus/sql/types/date/test_incorrect_dates.test @@ -0,0 +1,53 @@ +# source: test/sql/types/date/test_incorrect_dates.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +INSERT INTO dates VALUES ('blabla') +-- +ok +== +INSERT INTO dates VALUES ('1993-20-14') +-- +ok +== +INSERT INTO dates VALUES ('1993-08-99') +-- +ok +== +INSERT INTO dates VALUES ('1993-02-29') +-- +ok +== +INSERT INTO dates VALUES ('1900-02-29') +-- +ok +== +INSERT INTO dates VALUES ('1992-02-29') +-- +ok +== +INSERT INTO dates VALUES ('2000-02-29') +-- +ok +== +INSERT INTO dates VALUES ('02-02-1992') +-- +ok +== +INSERT INTO dates VALUES ('1900a01a01') +-- +ok +== +INSERT INTO dates VALUES ('1900-1-1') +-- +ok +== +INSERT INTO dates VALUES ('-100000000-01-01') +-- +ok +== +INSERT INTO dates VALUES ('1000000000-01-01') +-- +ok +== diff --git a/parser/testdata/corpus/sql/types/decimal/cast_from_decimal.test b/parser/testdata/corpus/sql/types/decimal/cast_from_decimal.test new file mode 100644 index 0000000..6091c92 --- /dev/null +++ b/parser/testdata/corpus/sql/types/decimal/cast_from_decimal.test @@ -0,0 +1,73 @@ +# source: test/sql/types/decimal/cast_from_decimal.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +SELECT 127::DECIMAL(3,0)::TINYINT, -127::DECIMAL(3,0)::TINYINT, -7::DECIMAL(9,1)::TINYINT, 27::DECIMAL(18,1)::TINYINT, 33::DECIMAL(38,1)::TINYINT +-- +ok +== +SELECT 128::DECIMAL(3,0)::TINYINT +-- +ok +== +SELECT -128::DECIMAL(9,0)::TINYINT +-- +ok +== +SELECT 128::DECIMAL(18,0)::TINYINT +-- +ok +== +SELECT 14751947891758972421513::DECIMAL(38,0)::TINYINT +-- +ok +== +SELECT 127::DECIMAL(3,0)::SMALLINT, -32767::DECIMAL(5,0)::SMALLINT, -7::DECIMAL(9,1)::SMALLINT, 27::DECIMAL(18,1)::SMALLINT, 33::DECIMAL(38,1)::SMALLINT +-- +ok +== +SELECT -32768::DECIMAL(9,0)::SMALLINT +-- +ok +== +SELECT 32768::DECIMAL(18,0)::SMALLINT +-- +ok +== +SELECT 14751947891758972421513::DECIMAL(38,0)::SMALLINT +-- +ok +== +SELECT 127::DECIMAL(3,0)::INTEGER, -2147483647::DECIMAL(10,0)::INTEGER, -7::DECIMAL(9,1)::INTEGER, 27::DECIMAL(18,1)::INTEGER, 33::DECIMAL(38,1)::INTEGER +-- +ok +== +SELECT 2147483648::DECIMAL(18,0)::INTEGER +-- +ok +== +SELECT 14751947891758972421513::DECIMAL(38,0)::INTEGER +-- +ok +== +SELECT 127::DECIMAL(3,0)::BIGINT, -9223372036854775807::DECIMAL(19,0)::BIGINT, -7::DECIMAL(9,1)::BIGINT, 27::DECIMAL(18,1)::BIGINT, 33::DECIMAL(38,1)::BIGINT +-- +ok +== +SELECT 14751947891758972421513::DECIMAL(38,0)::BIGINT +-- +ok +== +SELECT 127::DECIMAL(3,0)::HUGEINT, -17014118346046923173168730371588410572::DECIMAL(38,0)::HUGEINT, -7::DECIMAL(9,1)::HUGEINT, 27::DECIMAL(18,1)::HUGEINT, 33::DECIMAL(38,1)::HUGEINT +-- +ok +== +SELECT 127::DECIMAL(3,0)::FLOAT, -17014118346046923173168730371588410572::DECIMAL(38,0)::FLOAT, -7::DECIMAL(9,1)::FLOAT, 27::DECIMAL(18,1)::FLOAT, 33::DECIMAL(38,1)::FLOAT +-- +ok +== +SELECT 127::DECIMAL(3,0)::DOUBLE, -17014118346046923173168730371588410572::DECIMAL(38,0)::DOUBLE, -7::DECIMAL(9,1)::DOUBLE, 27::DECIMAL(18,1)::DOUBLE, 33::DECIMAL(38,1)::DOUBLE +-- +ok +== diff --git a/parser/testdata/corpus/sql/types/decimal/cast_to_decimal.test b/parser/testdata/corpus/sql/types/decimal/cast_to_decimal.test new file mode 100644 index 0000000..de3e4e7 --- /dev/null +++ b/parser/testdata/corpus/sql/types/decimal/cast_to_decimal.test @@ -0,0 +1,317 @@ +# source: test/sql/types/decimal/cast_to_decimal.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +SELECT 100::TINYINT::DECIMAL(18,3), 100::TINYINT::DECIMAL(3,0), (-100)::TINYINT::DECIMAL(3,0), 0::TINYINT::DECIMAL(3,3) +-- +ok +== +SELECT 100::TINYINT::DECIMAL(38,35), 100::TINYINT::DECIMAL(9,6) +-- +ok +== +SELECT 100::TINYINT::DECIMAL(3,1) +-- +ok +== +SELECT 1::TINYINT::DECIMAL(3,3) +-- +ok +== +SELECT 100::TINYINT::DECIMAL(18,17) +-- +ok +== +SELECT 100::TINYINT::DECIMAL(9,7) +-- +ok +== +SELECT 100::TINYINT::DECIMAL(38,37) +-- +ok +== +SELECT 100::SMALLINT::DECIMAL(18,3), 100::SMALLINT::DECIMAL(3,0), (-100)::SMALLINT::DECIMAL(3,0), 0::SMALLINT::DECIMAL(3,3) +-- +ok +== +SELECT 100::SMALLINT::DECIMAL(38,35), 100::SMALLINT::DECIMAL(9,6) +-- +ok +== +SELECT 100::SMALLINT::DECIMAL(3,1) +-- +ok +== +SELECT 1::SMALLINT::DECIMAL(3,3) +-- +ok +== +SELECT 100::SMALLINT::DECIMAL(18,17) +-- +ok +== +SELECT 100::SMALLINT::DECIMAL(9,7) +-- +ok +== +SELECT 100::SMALLINT::DECIMAL(38,37) +-- +ok +== +SELECT 100::INTEGER::DECIMAL(18,3), 100::INTEGER::DECIMAL(3,0), (-100)::INTEGER::DECIMAL(3,0), 0::INTEGER::DECIMAL(3,3) +-- +ok +== +SELECT 100::INTEGER::DECIMAL(38,35), 100::INTEGER::DECIMAL(9,6), 2147483647::INTEGER::DECIMAL(10,0), (-2147483647)::INTEGER::DECIMAL(10,0) +-- +ok +== +SELECT 100::INTEGER::DECIMAL(3,1) +-- +ok +== +SELECT 10000000::INTEGER::DECIMAL(3,1) +-- +ok +== +SELECT -10000000::INTEGER::DECIMAL(3,1) +-- +ok +== +SELECT 1::INTEGER::DECIMAL(3,3) +-- +ok +== +SELECT 100::INTEGER::DECIMAL(18,17) +-- +ok +== +SELECT 100::INTEGER::DECIMAL(9,7) +-- +ok +== +SELECT 100::INTEGER::DECIMAL(38,37) +-- +ok +== +SELECT 100::BIGINT::DECIMAL(18,3), 100::BIGINT::DECIMAL(3,0), (-100)::BIGINT::DECIMAL(3,0), 0::BIGINT::DECIMAL(3,3) +-- +ok +== +SELECT 100::BIGINT::DECIMAL(38,35), 100::BIGINT::DECIMAL(9,6), 9223372036854775807::BIGINT::DECIMAL(19,0), (-9223372036854775807)::BIGINT::DECIMAL(19,0) +-- +ok +== +SELECT 922337203685477580::BIGINT::DECIMAL(18,0), (-922337203685477580)::BIGINT::DECIMAL(18,0) +-- +ok +== +SELECT 100::BIGINT::DECIMAL(3,1) +-- +ok +== +SELECT 10000000::BIGINT::DECIMAL(3,1) +-- +ok +== +SELECT -10000000::BIGINT::DECIMAL(3,1) +-- +ok +== +SELECT 1::BIGINT::DECIMAL(3,3) +-- +ok +== +SELECT 100::BIGINT::DECIMAL(18,17) +-- +ok +== +SELECT 100::BIGINT::DECIMAL(9,7) +-- +ok +== +SELECT 100::BIGINT::DECIMAL(38,37) +-- +ok +== +SELECT 100::HUGEINT::DECIMAL(18,3), 100::HUGEINT::DECIMAL(3,0), (-100)::HUGEINT::DECIMAL(3,0), 0::HUGEINT::DECIMAL(3,3) +-- +ok +== +SELECT 100::HUGEINT::DECIMAL(38,35), 100::HUGEINT::DECIMAL(9,6), 17014118346046923173168730371588410572::HUGEINT::DECIMAL(38,0), (-17014118346046923173168730371588410572)::HUGEINT::DECIMAL(38,0) +-- +ok +== +SELECT 100::HUGEINT::DECIMAL(3,1) +-- +ok +== +SELECT 10000000::HUGEINT::DECIMAL(3,1) +-- +ok +== +SELECT -10000000::HUGEINT::DECIMAL(3,1) +-- +ok +== +SELECT 1::HUGEINT::DECIMAL(3,3) +-- +ok +== +SELECT 100::HUGEINT::DECIMAL(18,17) +-- +ok +== +SELECT 100::HUGEINT::DECIMAL(9,7) +-- +ok +== +SELECT 100::HUGEINT::DECIMAL(38,37) +-- +ok +== +SELECT 17014118346046923173168730371588410572::HUGEINT::DECIMAL(38,1) +-- +ok +== +SELECT 17014118346046923173168730371588410572::HUGEINT::DECIMAL(37,0) +-- +ok +== +SELECT 17014118346046923173168730371588410572::HUGEINT::DECIMAL(18,0) +-- +ok +== +SELECT 17014118346046923173168730371588410572::HUGEINT::DECIMAL(9,0) +-- +ok +== +SELECT 17014118346046923173168730371588410572::HUGEINT::DECIMAL(4,0) +-- +ok +== +SELECT 100::FLOAT::DECIMAL(18,3), 100::FLOAT::DECIMAL(3,0), (-100)::FLOAT::DECIMAL(3,0), 0::FLOAT::DECIMAL(3,3) +-- +ok +== +SELECT 12345678::FLOAT::DECIMAL(18,2) +-- +ok +== +SELECT 100::FLOAT::DECIMAL(38,35)::FLOAT, 100::FLOAT::DECIMAL(9,6)::FLOAT, 17014118346046923173168730371588410572::FLOAT::DECIMAL(38,0)::FLOAT, (-17014118346046923173168730371588410572)::FLOAT::DECIMAL(38,0)::FLOAT +-- +ok +== +SELECT 1.25::FLOAT::DECIMAL(3,2) +-- +ok +== +SELECT 100::FLOAT::DECIMAL(3,1) +-- +ok +== +SELECT 10000000::FLOAT::DECIMAL(3,1) +-- +ok +== +SELECT -10000000::FLOAT::DECIMAL(3,1) +-- +ok +== +SELECT 1::FLOAT::DECIMAL(3,3) +-- +ok +== +SELECT 100::FLOAT::DECIMAL(18,17) +-- +ok +== +SELECT 100::FLOAT::DECIMAL(9,7) +-- +ok +== +SELECT 100::FLOAT::DECIMAL(38,37) +-- +ok +== +SELECT 17014118346046923173168730371588410572::FLOAT::DECIMAL(38,1) +-- +ok +== +SELECT 17014118346046923173168730371588410572::FLOAT::DECIMAL(37,0) +-- +ok +== +SELECT 17014118346046923173168730371588410572::FLOAT::DECIMAL(18,0) +-- +ok +== +SELECT 17014118346046923173168730371588410572::FLOAT::DECIMAL(9,0) +-- +ok +== +SELECT 17014118346046923173168730371588410572::FLOAT::DECIMAL(4,0) +-- +ok +== +SELECT 100::DOUBLE::DECIMAL(18,3), 100::DOUBLE::DECIMAL(3,0), (-100)::DOUBLE::DECIMAL(3,0), 0::DOUBLE::DECIMAL(3,3) +-- +ok +== +SELECT 100::DOUBLE::DECIMAL(38,35)::DOUBLE, 100::DOUBLE::DECIMAL(9,6)::DOUBLE, 17014118346046923173168730371588410572::DOUBLE::DECIMAL(38,0)::DOUBLE, (-17014118346046923173168730371588410572)::DOUBLE::DECIMAL(38,0)::DOUBLE +-- +ok +== +SELECT 1.25::DOUBLE::DECIMAL(3,2) +-- +ok +== +SELECT 100::DOUBLE::DECIMAL(3,1) +-- +ok +== +SELECT 10000000::DOUBLE::DECIMAL(3,1) +-- +ok +== +SELECT -10000000::DOUBLE::DECIMAL(3,1) +-- +ok +== +SELECT 1::DOUBLE::DECIMAL(3,3) +-- +ok +== +SELECT 100::DOUBLE::DECIMAL(18,17) +-- +ok +== +SELECT 100::DOUBLE::DECIMAL(9,7) +-- +ok +== +SELECT 100::DOUBLE::DECIMAL(38,37) +-- +ok +== +SELECT 17014118346046923173168730371588410572::DOUBLE::DECIMAL(38,1) +-- +ok +== +SELECT 17014118346046923173168730371588410572::DOUBLE::DECIMAL(37,0) +-- +ok +== +SELECT 17014118346046923173168730371588410572::DOUBLE::DECIMAL(18,0) +-- +ok +== +SELECT 17014118346046923173168730371588410572::DOUBLE::DECIMAL(9,0) +-- +ok +== +SELECT 17014118346046923173168730371588410572::DOUBLE::DECIMAL(4,0) +-- +ok +== diff --git a/parser/testdata/corpus/sql/types/decimal/decimal_aggregates.test b/parser/testdata/corpus/sql/types/decimal/decimal_aggregates.test new file mode 100644 index 0000000..f76cba7 --- /dev/null +++ b/parser/testdata/corpus/sql/types/decimal/decimal_aggregates.test @@ -0,0 +1,53 @@ +# source: test/sql/types/decimal/decimal_aggregates.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +SELECT typeof(FIRST('0.1'::DECIMAL(4,1))) +-- +ok +== +SELECT FIRST(NULL::DECIMAL), + FIRST('0.1'::DECIMAL(4,1))::VARCHAR, + FIRST('4938245.1'::DECIMAL(9,1))::VARCHAR, + FIRST('45672564564938245.1'::DECIMAL(18,1))::VARCHAR, + FIRST('4567645908450368043562342564564938245.1'::DECIMAL(38,1))::VARCHAR +-- +ok +== +SELECT MIN(NULL::DECIMAL), + MIN('0.1'::DECIMAL(4,1))::VARCHAR, + MIN('4938245.1'::DECIMAL(9,1))::VARCHAR, + MIN('45672564564938245.1'::DECIMAL(18,1))::VARCHAR, + MIN('4567645908450368043562342564564938245.1'::DECIMAL(38,1))::VARCHAR +-- +ok +== +SELECT MAX(NULL::DECIMAL), + MAX('0.1'::DECIMAL(4,1))::VARCHAR, + MAX('4938245.1'::DECIMAL(9,1))::VARCHAR, + MAX('45672564564938245.1'::DECIMAL(18,1))::VARCHAR, + MAX('4567645908450368043562342564564938245.1'::DECIMAL(38,1))::VARCHAR +-- +ok +== +SELECT SUM(NULL::DECIMAL), + SUM('0.1'::DECIMAL(4,1))::VARCHAR, + SUM('4938245.1'::DECIMAL(9,1))::VARCHAR, + SUM('45672564564938245.1'::DECIMAL(18,1))::VARCHAR, + SUM('4567645908450368043562342564564938245.1'::DECIMAL(38,1))::VARCHAR +-- +ok +== +CREATE TABLE decimals AS SELECT i::DECIMAL(4,1) AS d1, (i * i)::DECIMAL(9,1) AS d2, (i * i * i)::DECIMAL(18,1) AS d3, (i * i * i * i)::DECIMAL(38,1) AS d4 FROM range(1000) tbl(i); +-- +ok +== +SELECT SUM(d1)::VARCHAR, SUM(d2)::VARCHAR, SUM(d3)::VARCHAR, SUM(d4)::VARCHAR FROM decimals; +-- +ok +== +INSERT INTO decimals VALUES ('0.1', '0.1', '0.1', '0.1'), ('0.2', '0.2', '0.2', '0.2') +-- +ok +== diff --git a/parser/testdata/corpus/sql/types/decimal/decimal_arithmetic.test b/parser/testdata/corpus/sql/types/decimal/decimal_arithmetic.test new file mode 100644 index 0000000..6bcd354 --- /dev/null +++ b/parser/testdata/corpus/sql/types/decimal/decimal_arithmetic.test @@ -0,0 +1,149 @@ +# source: test/sql/types/decimal/decimal_arithmetic.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +SELECT -('0.1'::DECIMAL), -('-0.1'::DECIMAL) +-- +ok +== +SELECT +('0.1'::DECIMAL), +('-0.1'::DECIMAL) +-- +ok +== +SELECT '0.1'::DECIMAL + '0.1'::DECIMAL +-- +ok +== +SELECT '0.1'::DECIMAL + 1::INTEGER +-- +ok +== +SELECT '0.5'::DECIMAL(4,4) + '0.5'::DECIMAL(4,4) +-- +ok +== +SELECT '0.5'::DECIMAL(1,1) + '100.0'::DECIMAL(3,0) +-- +ok +== +SELECT ('0.5'::DECIMAL(1,1) + 10000)::VARCHAR, + ('0.54321'::DECIMAL(5,5) + 10000)::VARCHAR, + ('0.5432154321'::DECIMAL(10,10) + 10000)::VARCHAR, + ('0.543215432154321'::DECIMAL(15,15) + 10000::DECIMAL(20,15))::VARCHAR, + ('0.54321543215432154321'::DECIMAL(20,20) + 10000)::VARCHAR, + ('0.5432154321543215432154321'::DECIMAL(25,25) + 10000)::VARCHAR +-- +ok +== +SELECT ('0.54321543215432154321543215432154321'::DECIMAL(35,35) + 10000)::VARCHAR +-- +ok +== +SELECT '0.5'::DECIMAL(1,1) + 1::TINYINT, + '0.5'::DECIMAL(1,1) + 1::SMALLINT, + '0.5'::DECIMAL(1,1) + 1::INTEGER, + '0.5'::DECIMAL(1,1) + 1::BIGINT, + '0.5'::DECIMAL(1,1) + 1::HUGEINT +-- +ok +== +SELECT '0.5'::DECIMAL(1,1) + -1::TINYINT, + '0.5'::DECIMAL(1,1) + -1::SMALLINT, + '0.5'::DECIMAL(1,1) + -1::INTEGER, + '0.5'::DECIMAL(1,1) + -1::BIGINT, + '0.5'::DECIMAL(1,1) + -1::HUGEINT +-- +ok +== +SELECT '0.5'::DECIMAL(1,1) - 1::TINYINT, + '0.5'::DECIMAL(1,1) - 1::SMALLINT, + '0.5'::DECIMAL(1,1) - 1::INTEGER, + '0.5'::DECIMAL(1,1) - 1::BIGINT, + '0.5'::DECIMAL(1,1) - 1::HUGEINT +-- +ok +== +SELECT '0.5'::DECIMAL(1,1) - -1::TINYINT, + '0.5'::DECIMAL(1,1) - -1::SMALLINT, + '0.5'::DECIMAL(1,1) - -1::INTEGER, + '0.5'::DECIMAL(1,1) - -1::BIGINT, + '0.5'::DECIMAL(1,1) - -1::HUGEINT +-- +ok +== +CREATE TABLE decimals(d DECIMAL(3, 2)); +-- +ok +== +INSERT INTO decimals VALUES ('0.1'), ('0.2'); +-- +ok +== +SELECT d + 10000 FROM decimals; +-- +ok +== +SELECT d + '0.1'::DECIMAL, d + 10000 FROM decimals; +-- +ok +== +SELECT '0.1'::DECIMAL * '10.0'::DECIMAL +-- +ok +== +SELECT typeof('0.1'::DECIMAL(2,1) * '10.0'::DECIMAL(3,1)) +-- +ok +== +SELECT '0.1'::DECIMAL * '0.1'::DECIMAL +-- +ok +== +SELECT '0.1'::DECIMAL * 10::INTEGER +-- +ok +== +SELECT '5.0'::DECIMAL(4,3) * '5.0'::DECIMAL(4,3) +-- +ok +== +SELECT '-5.0'::DECIMAL(4,3) * '5.0'::DECIMAL(4,3) +-- +ok +== +SELECT ('18.25'::DECIMAL(4,2) * '17.25'::DECIMAL(4,2))::VARCHAR +-- +ok +== +SELECT '0.001'::DECIMAL * 100::TINYINT, + '0.001'::DECIMAL * 10000::SMALLINT, + '0.001'::DECIMAL * 1000000::INTEGER, + '0.001'::DECIMAL * 100000000::BIGINT, + '0.001'::DECIMAL * 10000000000::HUGEINT +-- +ok +== +SELECT '0.000000000000000000000000000001'::DECIMAL(38,30) * '0.000000000000000000000000000001'::DECIMAL(38,30) +-- +ok +== +SELECT 2.0 + 1.0, + 2.0000 + 1.0000, + 2.000000000000 + 1.000000000000, + 2.00000000000000000000 + 1.00000000000000000000 +-- +ok +== +SELECT 2.0 - 1.0, + 2.0000 - 1.0000, + 2.000000000000 - 1.000000000000, + 2.00000000000000000000 - 1.00000000000000000000 +-- +ok +== +SELECT 2.0 * 1.0, + 2.0000 * 1.0000 +-- +ok +== diff --git a/parser/testdata/corpus/sql/types/decimal/decimal_automatic_cast.test b/parser/testdata/corpus/sql/types/decimal/decimal_automatic_cast.test new file mode 100644 index 0000000..b25333a --- /dev/null +++ b/parser/testdata/corpus/sql/types/decimal/decimal_automatic_cast.test @@ -0,0 +1,28 @@ +# source: test/sql/types/decimal/decimal_automatic_cast.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +SELECT [1.33, 10.0] +-- +ok +== +SELECT [0.1, 1.33, 10.0, 9999999.999999999] +-- +ok +== +SELECT [99999999999999999999999999999999999.9, 9.99999999999999999999999999999999999] +-- +ok +== +CREATE TABLE foo + (my_struct STRUCT(my_double DOUBLE)[]); +-- +ok +== +INSERT INTO foo VALUES + ([{'my_double': 1.33}, + {'my_double': 10.0}]); +-- +ok +== diff --git a/parser/testdata/corpus/sql/types/decimal/decimal_average.test b/parser/testdata/corpus/sql/types/decimal/decimal_average.test new file mode 100644 index 0000000..8d464b9 --- /dev/null +++ b/parser/testdata/corpus/sql/types/decimal/decimal_average.test @@ -0,0 +1,186 @@ +# source: test/sql/types/decimal/decimal_average.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +CREATE TABLE prices (v DECIMAL(10,2)); +-- +ok +== +INSERT INTO prices VALUES (10.00), (20.00); +-- +ok +== +SELECT decimal_average(v) FROM prices; +-- +ok +== +SELECT typeof(decimal_average(v)) FROM prices; +-- +ok +== +CREATE TABLE prices_with_null (v DECIMAL(10,2)); +-- +ok +== +INSERT INTO prices_with_null VALUES (10.00), (NULL), (20.00); +-- +ok +== +SELECT decimal_average(v) FROM prices_with_null; +-- +ok +== +CREATE TABLE all_null (v DECIMAL(10,2)); +-- +ok +== +INSERT INTO all_null VALUES (NULL); +-- +ok +== +SELECT decimal_average(v) FROM all_null; +-- +ok +== +SELECT decimal_average(v) FROM prices WHERE v > 1000.00; +-- +ok +== +CREATE TABLE mixed (v DECIMAL(10,2)); +-- +ok +== +INSERT INTO mixed VALUES (-10.00), (-20.00); +-- +ok +== +SELECT decimal_average(v) FROM mixed; +-- +ok +== +CREATE TABLE zero_avg (v DECIMAL(10,2)); +-- +ok +== +INSERT INTO zero_avg VALUES (-5.00), (5.00); +-- +ok +== +SELECT decimal_average(v) FROM zero_avg; +-- +ok +== +CREATE TABLE odd_avg (v DECIMAL(5,0)); +-- +ok +== +INSERT INTO odd_avg VALUES (3), (4); +-- +ok +== +SELECT decimal_average(v) FROM odd_avg; +-- +ok +== +CREATE TABLE even_avg (v DECIMAL(5,0)); +-- +ok +== +INSERT INTO even_avg VALUES (2), (3); +-- +ok +== +SELECT decimal_average(v) FROM even_avg; +-- +ok +== +CREATE TABLE int16_dec (v DECIMAL(4,2)); +-- +ok +== +INSERT INTO int16_dec VALUES (1.23), (4.56); +-- +ok +== +SELECT typeof(decimal_average(v)) FROM int16_dec; +-- +ok +== +CREATE TABLE int32_dec (v DECIMAL(9,2)); +-- +ok +== +INSERT INTO int32_dec VALUES (1.23), (4.56); +-- +ok +== +SELECT typeof(decimal_average(v)) FROM int32_dec; +-- +ok +== +CREATE TABLE int128_dec (v DECIMAL(38,2)); +-- +ok +== +INSERT INTO int128_dec VALUES (1.23), (4.56); +-- +ok +== +SELECT typeof(decimal_average(v)) FROM int128_dec; +-- +ok +== +CREATE TABLE high_scale_int64 (v DECIMAL(18,17)); +-- +ok +== +INSERT INTO high_scale_int64 VALUES (0.10000000000000000), (0.20000000000000000), (0.30000000000000000); +-- +ok +== +SELECT typeof(decimal_average(v)) FROM high_scale_int64; +-- +ok +== +SELECT decimal_average(v) FROM high_scale_int64; +-- +ok +== +CREATE TABLE high_scale_int128 (v DECIMAL(38,20)); +-- +ok +== +INSERT INTO high_scale_int128 VALUES (1.00000000000000000001), (2.00000000000000000001), (3.00000000000000000001); +-- +ok +== +SELECT typeof(decimal_average(v)) FROM high_scale_int128; +-- +ok +== +SELECT decimal_average(v) FROM high_scale_int128; +-- +ok +== +CREATE TABLE overflow_big (v DECIMAL(38,0)); +-- +ok +== +INSERT INTO overflow_big VALUES (99999999999999999999999999999999999999); +-- +ok +== +SELECT decimal_average(v) FROM overflow_big; +-- +ok +== +SELECT decimal_average(x) +FROM ( + VALUES + (-85070591730234615865843651857942052864::DECIMAL(38,0)), + (-85070591730234615865843651857942052864::DECIMAL(38,0)) +) t(x); +-- +ok +== diff --git a/parser/testdata/corpus/sql/types/decimal/decimal_decimal_overflow_cast.test b/parser/testdata/corpus/sql/types/decimal/decimal_decimal_overflow_cast.test new file mode 100644 index 0000000..55c2a3b --- /dev/null +++ b/parser/testdata/corpus/sql/types/decimal/decimal_decimal_overflow_cast.test @@ -0,0 +1,89 @@ +# source: test/sql/types/decimal/decimal_decimal_overflow_cast.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +SELECT 1.0::DECIMAL(4,3)::DECIMAL(2,1), 1.0::DECIMAL(4,3)::DECIMAL(9,1), 1.0::DECIMAL(4,3)::DECIMAL(18,1), 1.0::DECIMAL(4,3)::DECIMAL(38,1) +-- +ok +== +SELECT 1.0::DECIMAL(9,8)::DECIMAL(2,1), 1.0::DECIMAL(9,8)::DECIMAL(9,1), 1.0::DECIMAL(9,8)::DECIMAL(18,1), 1.0::DECIMAL(9,8)::DECIMAL(38,1) +-- +ok +== +SELECT 1.0::DECIMAL(18,17)::DECIMAL(2,1), 1.0::DECIMAL(18,17)::DECIMAL(9,1), 1.0::DECIMAL(18,17)::DECIMAL(18,1), 1.0::DECIMAL(18,17)::DECIMAL(38,1) +-- +ok +== +SELECT 1.0::DECIMAL(38,37)::DECIMAL(2,1), 1.0::DECIMAL(38,37)::DECIMAL(9,1), 1.0::DECIMAL(38,37)::DECIMAL(18,1), 1.0::DECIMAL(38,37)::DECIMAL(38,1) +-- +ok +== +SELECT 10.00::DECIMAL(4,2)::DECIMAL(4,3); +-- +ok +== +SELECT 10.00::DECIMAL(4,2)::DECIMAL(9,8); +-- +ok +== +SELECT 10.00::DECIMAL(4,2)::DECIMAL(18,17); +-- +ok +== +SELECT 10.00::DECIMAL(4,2)::DECIMAL(38,37); +-- +ok +== +SELECT 10.00::DECIMAL(4,2)::DECIMAL(2,1); +-- +ok +== +SELECT 10.00::DECIMAL(9,7)::DECIMAL(7,6); +-- +ok +== +SELECT 10.00::DECIMAL(18,16)::DECIMAL(16,15); +-- +ok +== +SELECT 10.00::DECIMAL(38,36)::DECIMAL(36,35); +-- +ok +== +SELECT 1.0::DECIMAL(3,1)::DECIMAL(18,2), 1.0::DECIMAL(3,1)::DECIMAL(38,2) +-- +ok +== +SELECT 1.0::DECIMAL(3,1)::DECIMAL(2,1), 1.0::DECIMAL(3,1)::DECIMAL(9,1), 1.0::DECIMAL(3,1)::DECIMAL(18,1), 1.0::DECIMAL(3,1)::DECIMAL(38,1) +-- +ok +== +SELECT 1.0::DECIMAL(9,1)::DECIMAL(2,1), 1.0::DECIMAL(9,1)::DECIMAL(8,1), 1.0::DECIMAL(9,1)::DECIMAL(18,1), 1.0::DECIMAL(9,1)::DECIMAL(38,1) +-- +ok +== +SELECT 1.0::DECIMAL(18,1)::DECIMAL(2,1), 1.0::DECIMAL(18,1)::DECIMAL(8,1), 1.0::DECIMAL(18,1)::DECIMAL(17,1), 1.0::DECIMAL(18,1)::DECIMAL(38,1) +-- +ok +== +SELECT 1.0::DECIMAL(38,1)::DECIMAL(2,1), 1.0::DECIMAL(38,1)::DECIMAL(8,1), 1.0::DECIMAL(38,1)::DECIMAL(17,1), 1.0::DECIMAL(38,1)::DECIMAL(37,1) +-- +ok +== +SELECT 1.0::DECIMAL(3,1)::DECIMAL(1,1) +-- +ok +== +SELECT 1.0::DECIMAL(9,1)::DECIMAL(1,1) +-- +ok +== +SELECT 1.0::DECIMAL(18,1)::DECIMAL(1,1) +-- +ok +== +SELECT 1.0::DECIMAL(38,1)::DECIMAL(1,1) +-- +ok +== diff --git a/parser/testdata/corpus/sql/types/decimal/decimal_division.test b/parser/testdata/corpus/sql/types/decimal/decimal_division.test new file mode 100644 index 0000000..9589d5d --- /dev/null +++ b/parser/testdata/corpus/sql/types/decimal/decimal_division.test @@ -0,0 +1,105 @@ +# source: test/sql/types/decimal/decimal_division.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +SELECT decimal_division(10.00, 4.00); +-- +ok +== +SELECT decimal_division(DECIMAL '1.00', DECIMAL '3.000'); +-- +ok +== +SELECT decimal_division(1.00::DECIMAL(5,2), 3.000::DECIMAL(5,3)); +-- +ok +== +SELECT decimal_division(-7.00, 2.00); +-- +ok +== +SELECT decimal_division(1.00, 0.25); +-- +ok +== +SELECT decimal_division(1.00, 0.00); +-- +ok +== +SELECT typeof(decimal_division(12.34::DECIMAL(4,2), 3.5::DECIMAL(4,1))); +-- +ok +== +SELECT decimal_division(12.34::DECIMAL(4,2), 3.5::DECIMAL(4,1)); +-- +ok +== +SELECT typeof(decimal_division(1000.000::DECIMAL(9,3), 4.00::DECIMAL(6,2))); +-- +ok +== +SELECT decimal_division(1000.000::DECIMAL(9,3), 4.00::DECIMAL(6,2)); +-- +ok +== +SELECT typeof(decimal_division(100000.00000::DECIMAL(15,5), 8.000::DECIMAL(12,3))); +-- +ok +== +SELECT decimal_division(100000.00000::DECIMAL(15,5), 8.000::DECIMAL(12,3)); +-- +ok +== +SELECT decimal_division(10000000000.00000000::DECIMAL(28,8), 4.00000::DECIMAL(20,5)); +-- +ok +== +SELECT decimal_division(3::decimal(38,2), 16384::decimal(37,2)); +-- +ok +== +SELECT typeof(decimal_division(12.34::DECIMAL(4,2), 3.5::DECIMAL(4,1), 2)); +-- +ok +== +SELECT decimal_division(12.34::DECIMAL(4,2), 3.5::DECIMAL(4,1), 2); +-- +ok +== +SELECT typeof(decimal_division(12.34::DECIMAL(4,2), 3.5::DECIMAL(4,1), 0)); +-- +ok +== +SELECT decimal_division(12.34::DECIMAL(4,2), 3.5::DECIMAL(4,1), 0); +-- +ok +== +SELECT decimal_division(12.34::DECIMAL(4,2), 3.5::DECIMAL(4,1), 1); +-- +ok +== +SELECT typeof(decimal_division(12.34::DECIMAL(4,2), 3.5::DECIMAL(4,1), 10)); +-- +ok +== +SELECT decimal_division(12.34::DECIMAL(4,2), 3.5::DECIMAL(4,1), 10); +-- +ok +== +SELECT decimal_division(1.00::DECIMAL(3,2), 3.00::DECIMAL(3,2), 17); +-- +ok +== +SELECT decimal_division(1.00::DECIMAL(3,2), 3.00::DECIMAL(3,2), 35); +-- +ok +== +SELECT decimal_division(1.0::DECIMAL(4,1), 3.0::DECIMAL(4,1), -1); +-- +ok +== +SELECT decimal_division(1.0::DECIMAL(4,1), 3.0::DECIMAL(4,1), 39); +-- +ok +== diff --git a/parser/testdata/corpus/sql/types/decimal/decimal_exception.test b/parser/testdata/corpus/sql/types/decimal/decimal_exception.test new file mode 100644 index 0000000..eb80397 --- /dev/null +++ b/parser/testdata/corpus/sql/types/decimal/decimal_exception.test @@ -0,0 +1,53 @@ +# source: test/sql/types/decimal/decimal_exception.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +select cast('9.99' as decimal(1,0)); +-- +ok +== +select cast(9.99::float as decimal(1,0)); +-- +ok +== +select cast(9.99::double as decimal(1,0)); +-- +ok +== +select cast(9.99 as decimal(1,0)); +-- +ok +== +select cast(9.49 as decimal(1,0)); +-- +ok +== +select cast(9.5 as decimal(1,0)); +-- +ok +== +select cast(-9.99 as decimal(1,0)); +-- +ok +== +select cast(-9.5 as decimal(1,0)); +-- +ok +== +select cast(-9.01 as decimal(1,0)); +-- +ok +== +select cast(-9.999999999 as decimal(1,0)); +-- +ok +== +select cast(9.9999999999999999999999999999999 as decimal(1,0)); +-- +ok +== +select cast(-9.9999999999999999999999999999999 as decimal(1,0)); +-- +ok +== diff --git a/parser/testdata/corpus/sql/types/decimal/decimal_exponent.test b/parser/testdata/corpus/sql/types/decimal/decimal_exponent.test new file mode 100644 index 0000000..0eaac37 --- /dev/null +++ b/parser/testdata/corpus/sql/types/decimal/decimal_exponent.test @@ -0,0 +1,173 @@ +# source: test/sql/types/decimal/decimal_exponent.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +SELECT '1e3'::DECIMAL, '1e-1'::DECIMAL, '.1e3'::DECIMAL, '0.1e3'::DECIMAL +-- +ok +== +SELECT '-1e3'::DECIMAL, '-0.1e3'::DECIMAL, '-.1e-1'::DECIMAL, '-0.1e-1'::DECIMAL +-- +ok +== +SELECT '0e1'::DECIMAL, '-0e1'::DECIMAL, '00000e1'::DECIMAL, '-00000e1'::DECIMAL +-- +ok +== +SELECT '1e-100'::DECIMAL +-- +ok +== +SELECT '1e-9999'::DECIMAL +-- +ok +== +SELECT '1E3'::DECIMAL(4,0) +-- +ok +== +SELECT '1e8'::DECIMAL(9,0) +-- +ok +== +SELECT '1e17'::DECIMAL(18,0) +-- +ok +== +SELECT '1e37'::DECIMAL(38,0) +-- +ok +== +SELECT '1e4'::DECIMAL(4,0) +-- +ok +== +SELECT '1e9'::DECIMAL(9,0) +-- +ok +== +SELECT '1e18'::DECIMAL(18,0) +-- +ok +== +SELECT '1e38'::DECIMAL(38,0) +-- +ok +== +SELECT '1e100'::DECIMAL +-- +ok +== +SELECT '1e100e100'::DECIMAL +-- +ok +== +SELECT '1e100.2'::DECIMAL +-- +ok +== +SELECT '1e9999999999'::DECIMAL +-- +ok +== +SELECT '1e-9999999999'::DECIMAL +-- +ok +== +SELECT '1e-99999999999999999999999999999999'::DECIMAL +-- +ok +== +SELECT '.1f3'::DECIMAL +-- +ok +== +SELECT '1f3'::DECIMAL +-- +ok +== +SELECT '5.8207660913467407e-11'::DECIMAL(18,4) +-- +ok +== +SELECT '5.5e-11'::DECIMAL(18,4) +-- +ok +== +SELECT '4.9e-11'::DECIMAL(18,4) +-- +ok +== +SELECT '9.9e-11'::DECIMAL(18,4) +-- +ok +== +SELECT '5e-11'::DECIMAL(18,4) +-- +ok +== +SELECT '1e-10'::DECIMAL(18,4) +-- +ok +== +SELECT '-5.5e-11'::DECIMAL(18,4) +-- +ok +== +SELECT '-9.9e-11'::DECIMAL(18,4) +-- +ok +== +SELECT '-5e-11'::DECIMAL(18,4) +-- +ok +== +SELECT '5.5e-11'::DECIMAL(18,10) +-- +ok +== +SELECT '4.9e-11'::DECIMAL(18,10) +-- +ok +== +SELECT '5.5e-12'::DECIMAL(18,10) +-- +ok +== +SELECT '5e-4'::DECIMAL(18,4) +-- +ok +== +SELECT '5e-5'::DECIMAL(18,4) +-- +ok +== +SELECT '4.9e-5'::DECIMAL(18,4) +-- +ok +== +SELECT '5.5e-5'::DECIMAL(18,4) +-- +ok +== +SELECT '5.5e-10'::DECIMAL +-- +ok +== +SELECT '9.9e-10'::DECIMAL +-- +ok +== +SELECT '5.5e-6'::DECIMAL(18,6) +-- +ok +== +SELECT '5.5e-7'::DECIMAL(18,6) +-- +ok +== +SELECT '5.5e-8'::DECIMAL(18,6) +-- +ok +== diff --git a/parser/testdata/corpus/sql/types/decimal/decimal_overflow.test b/parser/testdata/corpus/sql/types/decimal/decimal_overflow.test new file mode 100644 index 0000000..66a5fff --- /dev/null +++ b/parser/testdata/corpus/sql/types/decimal/decimal_overflow.test @@ -0,0 +1,57 @@ +# source: test/sql/types/decimal/decimal_overflow.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +select (99000000000000000.0::DECIMAL(18,1)+99000000000000000.0::DECIMAL(18,1)); +-- +ok +== +select (99000000000000000.0::DECIMAL(18,1)+99000000000000000.0::DECIMAL(18,1))::VARCHAR::DECIMAL(18,1); +-- +ok +== +select (50000000000000000.0::DECIMAL(18,1)+50000000000000000.0::DECIMAL(18,1)); +-- +ok +== +select (-99000000000000000.0::DECIMAL(18,1)-99000000000000000.0::DECIMAL(18,1)); +-- +ok +== +select (-50000000000000000.0::DECIMAL(18,1)-50000000000000000.0::DECIMAL(18,1)); +-- +ok +== +select (9900000000000000000000000000000000000.0::DECIMAL(38,1)+9900000000000000000000000000000000000.0::DECIMAL(38,1)); +-- +ok +== +select (5000000000000000000000000000000000000.0::DECIMAL(38,1)+5000000000000000000000000000000000000.0::DECIMAL(38,1)); +-- +ok +== +select '10000000000000000000000000000000000000.0'::DECIMAL(38,1); +-- +ok +== +select (-5000000000000000000000000000000000000.0::DECIMAL(38,1)-5000000000000000000000000000000000000.0::DECIMAL(38,1)); +-- +ok +== +select 90000000000000000.0::DECIMAL(18,1) * 10::DECIMAL(2,0); +-- +ok +== +select 90000000000000000.0::DECIMAL(18,1) * 1000::DECIMAL(4,0); +-- +ok +== +select 5000000000000000000000000000000000000.0::DECIMAL(38,1) * 2::DECIMAL(1,0); +-- +ok +== +select 9900000000000000000000000000000000000.0::DECIMAL(38,1) * 1.0; +-- +ok +== diff --git a/parser/testdata/corpus/sql/types/decimal/decimal_overflow_table.test b/parser/testdata/corpus/sql/types/decimal/decimal_overflow_table.test new file mode 100644 index 0000000..40f9c12 --- /dev/null +++ b/parser/testdata/corpus/sql/types/decimal/decimal_overflow_table.test @@ -0,0 +1,41 @@ +# source: test/sql/types/decimal/decimal_overflow_table.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +CREATE TABLE decimals(d DECIMAL(18,1)) +-- +ok +== +INSERT INTO decimals VALUES (99000000000000000.0) +-- +ok +== +SELECT d+1 FROM decimals +-- +ok +== +SELECT d+1000000000000000.0 FROM decimals +-- +ok +== +SELECT -1-d FROM decimals +-- +ok +== +SELECT -1000000000000000.0-d FROM decimals +-- +ok +== +SELECT 1*d FROM decimals +-- +ok +== +SELECT 2*d FROM decimals +-- +ok +== +SELECT typeof(d+1000000000000000.0), typeof(-1000000000000000.0-d) FROM decimals +-- +ok +== diff --git a/parser/testdata/corpus/sql/types/decimal/decimal_promotion.test b/parser/testdata/corpus/sql/types/decimal/decimal_promotion.test new file mode 100644 index 0000000..ca15ec6 --- /dev/null +++ b/parser/testdata/corpus/sql/types/decimal/decimal_promotion.test @@ -0,0 +1,57 @@ +# source: test/sql/types/decimal/decimal_promotion.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +SELECT typeof(1::DECIMAL(4,0) + 1::DECIMAL(4,0)), + typeof(1::DECIMAL(9,0) + 1::DECIMAL(9,0)), + typeof(1::DECIMAL(18,0) + 1::DECIMAL(18,0)) +-- +ok +== +SELECT typeof(99999999999999.9999::DECIMAL(18,4) + 0.0001::DECIMAL(5,4)), + 99999999999999.9999::DECIMAL(18,4) + 0.0001::DECIMAL(5,4) +-- +ok +== +SELECT typeof(1::DECIMAL(18,0) + 0.1::DECIMAL(18,18)), + 1::DECIMAL(18,0) + 0.1::DECIMAL(18,18), + typeof(0.1::DECIMAL(18,18) - 1::DECIMAL(18,0)), + 0.1::DECIMAL(18,18) - 1::DECIMAL(18,0) +-- +ok +== +CREATE TABLE decimal_stats_overflow( + add_left DECIMAL(38,0), + add_right DECIMAL(38,0), + subtract_left DECIMAL(38,0), + subtract_right DECIMAL(38,0), + multiply_left DECIMAL(38,0), + multiply_right DECIMAL(38,0) +); +-- +ok +== +INSERT INTO decimal_stats_overflow VALUES ( + 99999999999999999999999999999999999999, + 1, + -99999999999999999999999999999999999999, + 1, + 99999999999999999999999999999999999999, + 2 +); +-- +ok +== +SELECT add_left + add_right FROM decimal_stats_overflow +-- +ok +== +SELECT subtract_left - subtract_right FROM decimal_stats_overflow +-- +ok +== +SELECT multiply_left * multiply_right FROM decimal_stats_overflow +-- +ok +== diff --git a/parser/testdata/corpus/sql/types/decimal/decimal_try_cast.test b/parser/testdata/corpus/sql/types/decimal/decimal_try_cast.test new file mode 100644 index 0000000..bac788b --- /dev/null +++ b/parser/testdata/corpus/sql/types/decimal/decimal_try_cast.test @@ -0,0 +1,181 @@ +# source: test/sql/types/decimal/decimal_try_cast.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +SELECT CAST(1000 AS DECIMAL(3,0)) +-- +ok +== +SELECT CAST(100 AS DECIMAL(2,0)) +-- +ok +== +SELECT CAST('100' AS DECIMAL(2,0)) +-- +ok +== +SELECT CAST('100'::DOUBLE AS DECIMAL(2,0)) +-- +ok +== +SELECT CAST(100::DECIMAL(3,0) AS DECIMAL(2,0)) +-- +ok +== +SELECT CAST(10000::DECIMAL(5,0) AS DECIMAL(2,0)) +-- +ok +== +SELECT CAST(1000000000::DECIMAL(10,0) AS DECIMAL(2,0)) +-- +ok +== +SELECT CAST(1000000000::DECIMAL(20,0) AS DECIMAL(2,0)) +-- +ok +== +SELECT TRY_CAST(1000 AS DECIMAL(3,0)) +-- +ok +== +SELECT TRY_CAST(100 AS DECIMAL(2,0)) +-- +ok +== +SELECT TRY_CAST('100' AS DECIMAL(2,0)) +-- +ok +== +SELECT TRY_CAST('100'::DOUBLE AS DECIMAL(2,0)) +-- +ok +== +SELECT TRY_CAST(100::DECIMAL(3,0) AS DECIMAL(2,0)) +-- +ok +== +SELECT TRY_CAST(10000::DECIMAL(5,0) AS DECIMAL(2,0)) +-- +ok +== +SELECT TRY_CAST(1000000000::DECIMAL(10,0) AS DECIMAL(2,0)) +-- +ok +== +SELECT TRY_CAST(1000000000::DECIMAL(20,0) AS DECIMAL(2,0)) +-- +ok +== +SELECT CAST(1000000 AS DECIMAL(5,0)) +-- +ok +== +SELECT CAST('100000' AS DECIMAL(5,0)) +-- +ok +== +SELECT CAST('100000'::DOUBLE AS DECIMAL(5,0)) +-- +ok +== +SELECT CAST(100000::DECIMAL(6,0) AS DECIMAL(5,0)) +-- +ok +== +SELECT CAST(1000000000::DECIMAL(20,0) AS DECIMAL(5,0)) +-- +ok +== +SELECT TRY_CAST(1000000 AS DECIMAL(5,0)) +-- +ok +== +SELECT TRY_CAST('100000' AS DECIMAL(5,0)) +-- +ok +== +SELECT TRY_CAST('100000'::DOUBLE AS DECIMAL(5,0)) +-- +ok +== +SELECT TRY_CAST(100000::DECIMAL(6,0) AS DECIMAL(5,0)) +-- +ok +== +SELECT TRY_CAST(1000000000::DECIMAL(20,0) AS DECIMAL(5,0)) +-- +ok +== +SELECT CAST(10000000000 AS DECIMAL(10,0)) +-- +ok +== +SELECT CAST('10000000000' AS DECIMAL(10,0)) +-- +ok +== +SELECT CAST('10000000000'::DOUBLE AS DECIMAL(10,0)) +-- +ok +== +SELECT CAST(10000000000::DECIMAL(11,0) AS DECIMAL(10,0)) +-- +ok +== +SELECT CAST(10000000000::DECIMAL(20,0) AS DECIMAL(10,0)) +-- +ok +== +SELECT TRY_CAST(10000000000 AS DECIMAL(10,0)) +-- +ok +== +SELECT TRY_CAST('10000000000' AS DECIMAL(10,0)) +-- +ok +== +SELECT TRY_CAST('10000000000'::DOUBLE AS DECIMAL(10,0)) +-- +ok +== +SELECT TRY_CAST(10000000000::DECIMAL(11,0) AS DECIMAL(10,0)) +-- +ok +== +SELECT TRY_CAST(10000000000::DECIMAL(20,0) AS DECIMAL(10,0)) +-- +ok +== +SELECT CAST(100000000000000000000 AS DECIMAL(20,0)) +-- +ok +== +SELECT CAST('100000000000000000000' AS DECIMAL(20,0)) +-- +ok +== +SELECT CAST('100000000000000000000'::DOUBLE AS DECIMAL(20,0)) +-- +ok +== +SELECT CAST(100000000000000000000::DECIMAL(20,0) AS DECIMAL(20,0)) +-- +ok +== +SELECT TRY_CAST(100000000000000000000 AS DECIMAL(20,0)) +-- +ok +== +SELECT TRY_CAST('100000000000000000000' AS DECIMAL(20,0)) +-- +ok +== +SELECT TRY_CAST('100000000000000000000'::DOUBLE AS DECIMAL(20,0)) +-- +ok +== +SELECT TRY_CAST(100000000000000000000::DECIMAL(25,0) AS DECIMAL(20,0)) +-- +ok +== diff --git a/parser/testdata/corpus/sql/types/decimal/large_decimal_constants.test b/parser/testdata/corpus/sql/types/decimal/large_decimal_constants.test new file mode 100644 index 0000000..8fbeef1 --- /dev/null +++ b/parser/testdata/corpus/sql/types/decimal/large_decimal_constants.test @@ -0,0 +1,21 @@ +# source: test/sql/types/decimal/large_decimal_constants.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +SELECT 42.1, -10239814.1, 1049185157.12345, 102398294123451814.12345, -49238409238403918140294812084.12490812490 +-- +ok +== +SELECT typeof(42.1), typeof(-10239814.1), typeof(1049185157.12345), typeof(102398294123451814.12345), typeof(-49238409238403918140294812084.12490812490) +-- +ok +== +SELECT 42., 42e3, 4.23e1, 10e20, .34, - 2.3 +-- +ok +== +SELECT typeof(42.), typeof(42e3), typeof(4.23e1), typeof(10e20), typeof(.34), typeof(-2.3), typeof(10e100) +-- +ok +== diff --git a/parser/testdata/corpus/sql/types/decimal/test_decimal.test b/parser/testdata/corpus/sql/types/decimal/test_decimal.test new file mode 100644 index 0000000..542d580 --- /dev/null +++ b/parser/testdata/corpus/sql/types/decimal/test_decimal.test @@ -0,0 +1,145 @@ +# source: test/sql/types/decimal/test_decimal.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +SELECT typeof('0.1'::DECIMAL); +-- +ok +== +SELECT '0.1'::DECIMAL::VARCHAR, '922337203685478.758'::DECIMAL::VARCHAR; +-- +ok +== +SELECT '-0.1'::DECIMAL::VARCHAR, '-922337203685478.758'::DECIMAL::VARCHAR; +-- +ok +== +SELECT ' 7 '::DECIMAL::VARCHAR, '9.'::DECIMAL::VARCHAR, '.1'::DECIMAL::VARCHAR; +-- +ok +== +SELECT '0.123456789'::DECIMAL::VARCHAR, '-0.123456789'::DECIMAL::VARCHAR; +-- +ok +== +SELECT '9223372036854788.758'::DECIMAL; +-- +ok +== +SELECT '0.1'::DECIMAL(3, 0)::VARCHAR; +-- +ok +== +SELECT '123.4'::DECIMAL(9)::VARCHAR; +-- +ok +== +SELECT '0.1'::DECIMAL(3, 3)::VARCHAR, '-0.1'::DECIMAL(3, 3)::VARCHAR; +-- +ok +== +SELECT '1'::DECIMAL(3, 3)::VARCHAR; +-- +ok +== +SELECT '-1'::DECIMAL(3, 3)::VARCHAR; +-- +ok +== +select '0.1'::decimal::decimal::decimal; +-- +ok +== +select '123.4'::DECIMAL(4,1)::VARCHAR +-- +ok +== +select '2.001'::DECIMAL(4,3)::VARCHAR +-- +ok +== +select '123456.789'::DECIMAL(9,3)::VARCHAR +-- +ok +== +select '123456789'::DECIMAL(9,0)::VARCHAR +-- +ok +== +select '123456789'::DECIMAL(18,3)::VARCHAR +-- +ok +== +select '1701411834604692317316873037.1588410572'::DECIMAL(38,10)::VARCHAR +-- +ok +== +select '0'::DECIMAL(38,10)::VARCHAR +-- +ok +== +select '0.00003'::DECIMAL(38,10)::VARCHAR +-- +ok +== +select CAST(33.846 AS DECIMAL(5,0)) d0; +-- +ok +== +select CAST(-33.846 AS DECIMAL(5,0)) d0; +-- +ok +== +SELECT CAST(1234567890.1235 AS DECIMAL (13, 3)); +-- +ok +== +SELECT '0.1'::DECIMAL(3, 4); +-- +ok +== +SELECT '0.1'::DECIMAL('hello'); +-- +ok +== +SELECT '0.1'::DECIMAL((-17)); +-- +ok +== +SELECT '0.1'::DECIMAL(40); +-- +ok +== +SELECT '0.1'::DECIMAL(1, 2, 3); +-- +ok +== +SELECT '1'::INTEGER(1000); +-- +error: Parser Error: syntax error at or near "(" +== +SELECT 1::DECIMAL(3.2); +-- +ok +== +SELECT 1::DECIMAL(3.0); +-- +ok +== +SELECT 1::DECIMAL('32'); +-- +ok +== +SELECT 1::DECIMAL(18, 2.5); +-- +ok +== +SELECT 1::DECIMAL(18, '2'); +-- +ok +== +SELECT 1::DECIMAL(TRUE); +-- +ok +== diff --git a/parser/testdata/corpus/sql/types/decimal/test_decimal_2411.test b/parser/testdata/corpus/sql/types/decimal/test_decimal_2411.test new file mode 100644 index 0000000..4736fb7 --- /dev/null +++ b/parser/testdata/corpus/sql/types/decimal/test_decimal_2411.test @@ -0,0 +1,25 @@ +# source: test/sql/types/decimal/test_decimal_2411.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +CREATE TABLE decimals(i DECIMAL(38,1)) +-- +ok +== +CREATE TABLE decimals2(i DECIMAL(38,1)) +-- +ok +== +INSERT INTO decimals VALUES (4642275147320176030871715840) +-- +ok +== +INSERT INTO decimals2 VALUES (4642275147320176030871715840) +-- +ok +== +select count(*) from decimals inner join decimals2 on (decimals.i = decimals2.i) +-- +ok +== diff --git a/parser/testdata/corpus/sql/types/decimal/test_decimal_2975.test b/parser/testdata/corpus/sql/types/decimal/test_decimal_2975.test new file mode 100644 index 0000000..062be41 --- /dev/null +++ b/parser/testdata/corpus/sql/types/decimal/test_decimal_2975.test @@ -0,0 +1,21 @@ +# source: test/sql/types/decimal/test_decimal_2975.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +create table q (big decimal (38,10)) +-- +ok +== +insert into q (big ) values (9999999999999999899999999999.9999999999); +-- +ok +== +insert into q (big ) values (-9999999999999999899999999999.9999999999); +-- +ok +== +SELECT * FROM q +-- +ok +== diff --git a/parser/testdata/corpus/sql/types/decimal/test_decimal_4106.test b/parser/testdata/corpus/sql/types/decimal/test_decimal_4106.test new file mode 100644 index 0000000..1e5b14b --- /dev/null +++ b/parser/testdata/corpus/sql/types/decimal/test_decimal_4106.test @@ -0,0 +1,21 @@ +# source: test/sql/types/decimal/test_decimal_4106.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +CREATE TABLE from_values AS VALUES (1000000), (10.0000000005); +-- +ok +== +SELECT * FROM from_values; +-- +ok +== +CREATE TABLE from_list AS SELECT [1000000, 10.0000000005]; +-- +ok +== +SELECT * FROM from_list; +-- +ok +== diff --git a/parser/testdata/corpus/sql/types/decimal/test_decimal_from_string.test b/parser/testdata/corpus/sql/types/decimal/test_decimal_from_string.test new file mode 100644 index 0000000..c04fa67 --- /dev/null +++ b/parser/testdata/corpus/sql/types/decimal/test_decimal_from_string.test @@ -0,0 +1,33 @@ +# source: test/sql/types/decimal/test_decimal_from_string.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +select '+1e-1'::DECIMAL(38,3) +-- +ok +== +select '+1234.56789e-1'::DECIMAL(38,0) +-- +ok +== +select '+1234.56789e-1'::DECIMAL(38,5) +-- +ok +== +select +1234.56789e-1::DECIMAL(38,5) +-- +ok +== +select '{base_sign}{num}e{exp_sign}{exponent}'::DECIMAL(38,{scale}) == {base_sign}{num}e{exp_sign}{exponent}::DECIMAL(38,{scale}); +-- +error: Parser Error: syntax error at or near "}" +== +select decimal 'a'; +-- +ok +== +select map { 1: decimal 'b' }; +-- +ok +== diff --git a/parser/testdata/corpus/sql/types/decimal/test_decimal_ops.test b/parser/testdata/corpus/sql/types/decimal/test_decimal_ops.test new file mode 100644 index 0000000..88bb296 --- /dev/null +++ b/parser/testdata/corpus/sql/types/decimal/test_decimal_ops.test @@ -0,0 +1,276 @@ +# source: test/sql/types/decimal/test_decimal_ops.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +SELECT * FROM decimals +-- +ok +== +SELECT * FROM decimals ORDER BY d DESC +-- +ok +== +SELECT * FROM decimals WHERE d='0.1'::DECIMAL(3,2) +-- +ok +== +SELECT * FROM decimals WHERE d>='0.1'::DECIMAL(3,2) +-- +ok +== +SELECT * FROM decimals WHERE d='0.1'::DECIMAL(9,5) +-- +ok +== +SELECT * FROM decimals WHERE d >= '0.1'::DECIMAL(9,5) ORDER BY 1 +-- +ok +== +INSERT INTO decimals VALUES ('0.11'), ('0.21'); +-- +ok +== +SELECT * FROM decimals WHERE d = '0.1'::DECIMAL(9,1) +-- +ok +== +SELECT * FROM decimals WHERE d > '0.1'::DECIMAL(9,1) ORDER BY 1 +-- +ok +== +DELETE FROM decimals WHERE d <> d::DECIMAL(9,1) +-- +ok +== +SELECT ABS('-0.1'::DECIMAL), ABS('0.1'::DECIMAL), ABS(NULL::DECIMAL) +-- +ok +== +SELECT ABS('-0.1'::DECIMAL(4,3)), ABS('-0.1'::DECIMAL(9,3)), ABS('-0.1'::DECIMAL(18,3)), ABS('-0.1'::DECIMAL(38,3)) +-- +ok +== +SELECT CEIL('0.0'::DECIMAL), CEIL('0.1'::DECIMAL), CEIL('-0.1'::DECIMAL), CEIL(NULL::DECIMAL) +-- +ok +== +SELECT CEIL('100.3'::DECIMAL), CEIL('-127012.3'::DECIMAL) +-- +ok +== +SELECT CEIL('10.5'::DECIMAL), CEIL('-10.5'::DECIMAL) +-- +ok +== +SELECT CEIL('999.9'::DECIMAL(4,1)), CEIL('99999999.9'::DECIMAL(9,1)), CEIL('99999999999999999.9'::DECIMAL(18,1)), CEIL('9999999999999999999999999999999999999.9'::DECIMAL(38,1)) +-- +ok +== +SELECT CEIL('-999.9'::DECIMAL(4,1)), CEIL('-99999999.9'::DECIMAL(9,1)), CEIL('-99999999999999999.9'::DECIMAL(18,1)), CEIL('-9999999999999999999999999999999999999.9'::DECIMAL(38,1)) +-- +ok +== +SELECT FLOOR('0.1'::DECIMAL), FLOOR('-0.1'::DECIMAL), FLOOR(NULL::DECIMAL) +-- +ok +== +SELECT FLOOR('100.3'::DECIMAL), FLOOR('-127012.3'::DECIMAL) +-- +ok +== +SELECT FLOOR('10.5'::DECIMAL), FLOOR('-10.5'::DECIMAL) +-- +ok +== +SELECT FLOOR('999.9'::DECIMAL(4,1)), FLOOR('99999999.9'::DECIMAL(9,1)), FLOOR('99999999999999999.9'::DECIMAL(18,1)), FLOOR('9999999999999999999999999999999999999.9'::DECIMAL(38,1)) +-- +ok +== +SELECT FLOOR('-999.9'::DECIMAL(4,1)), FLOOR('-99999999.9'::DECIMAL(9,1)), FLOOR('-99999999999999999.9'::DECIMAL(18,1)), FLOOR('-9999999999999999999999999999999999999.9'::DECIMAL(38,1)) +-- +ok +== +SELECT ROUND('0.1'::DECIMAL), ROUND('-0.1'::DECIMAL), ROUND(NULL::DECIMAL) +-- +ok +== +SELECT ROUND('100.3'::DECIMAL), ROUND('-127012.3'::DECIMAL) +-- +ok +== +SELECT ROUND('10.5'::DECIMAL), ROUND('-10.5'::DECIMAL) +-- +ok +== +SELECT ROUND('999.9'::DECIMAL(4,1)), ROUND('99999999.9'::DECIMAL(9,1)), ROUND('99999999999999999.9'::DECIMAL(18,1)), ROUND('9999999999999999999999999999999999999.9'::DECIMAL(38,1)) +-- +ok +== +SELECT ROUND('-999.9'::DECIMAL(4,1)), ROUND('-99999999.9'::DECIMAL(9,1)), ROUND('-99999999999999999.9'::DECIMAL(18,1)), ROUND('-9999999999999999999999999999999999999.9'::DECIMAL(38,1)) +-- +ok +== +SELECT ROUND('100.3908147521'::DECIMAL(18,10), 0)::VARCHAR, + ROUND('100.3908147521'::DECIMAL(18,10), 1)::VARCHAR, + ROUND('100.3908147521'::DECIMAL(18,10), 2)::VARCHAR, + ROUND('100.3908147521'::DECIMAL(18,10), 3)::VARCHAR, + ROUND('100.3908147521'::DECIMAL(18,10), 4)::VARCHAR, + ROUND('100.3908147521'::DECIMAL(18,10), 5)::VARCHAR, + ROUND('100.3908147521'::DECIMAL(18,10), 6)::VARCHAR, + ROUND('100.3908147521'::DECIMAL(18,10), 7)::VARCHAR, + ROUND('100.3908147521'::DECIMAL(18,10), 8)::VARCHAR, + ROUND('100.3908147521'::DECIMAL(18,10), 9)::VARCHAR, + ROUND('100.3908147521'::DECIMAL(18,10), 10)::VARCHAR, + ROUND('100.3908147521'::DECIMAL(18,10), 100000)::VARCHAR, + ROUND(NULL::DECIMAL, 0) +-- +ok +== +SELECT ROUND('1049578239572094512.32415'::DECIMAL(30,10), 0)::VARCHAR, + ROUND('1049578239572094512.32415'::DECIMAL(30,10), -1)::VARCHAR, + ROUND('1049578239572094512.32415'::DECIMAL(30,10), -2)::VARCHAR, + ROUND('1049578239572094512.32415'::DECIMAL(30,10), -3)::VARCHAR, + ROUND('1049578239572094512.32415'::DECIMAL(30,10), -4)::VARCHAR, + ROUND('1049578239572094512.32415'::DECIMAL(30,10), -5)::VARCHAR, + ROUND('1049578239572094512.32415'::DECIMAL(30,10), -6)::VARCHAR, + ROUND('1049578239572094512.32415'::DECIMAL(30,10), -7)::VARCHAR, + ROUND('1049578239572094512.32415'::DECIMAL(30,10), -8)::VARCHAR, + ROUND('1049578239572094512.32415'::DECIMAL(30,10), -9)::VARCHAR, + ROUND('1049578239572094512.32415'::DECIMAL(30,10), -10)::VARCHAR, + ROUND('1049578239572094512.32415'::DECIMAL(30,10), -11)::VARCHAR, + ROUND('1049578239572094512.32415'::DECIMAL(30,10), -12)::VARCHAR, + ROUND('1049578239572094512.32415'::DECIMAL(30,10), -13)::VARCHAR, + ROUND('1049578239572094512.32415'::DECIMAL(30,10), -14)::VARCHAR, + ROUND('1049578239572094512.32415'::DECIMAL(30,10), -15)::VARCHAR, + ROUND('1049578239572094512.32415'::DECIMAL(30,10), -16)::VARCHAR, + ROUND('1049578239572094512.32415'::DECIMAL(30,10), -18)::VARCHAR, + ROUND('1049578239572094512.32415'::DECIMAL(30,10), -19)::VARCHAR, + ROUND('1049578239572094512.32415'::DECIMAL(30,10), -20)::VARCHAR, + ROUND('1049578239572094512.32415'::DECIMAL(30,10), -19842)::VARCHAR +-- +ok +== +SELECT ROUND('-100.3908147521'::DECIMAL(18,10), 0)::VARCHAR, + ROUND('-100.3908147521'::DECIMAL(18,10), 1)::VARCHAR, + ROUND('-100.3908147521'::DECIMAL(18,10), 2)::VARCHAR, + ROUND('-100.3908147521'::DECIMAL(18,10), 3)::VARCHAR, + ROUND('-100.3908147521'::DECIMAL(18,10), 4)::VARCHAR, + ROUND('-100.3908147521'::DECIMAL(18,10), 5)::VARCHAR, + ROUND('-100.3908147521'::DECIMAL(18,10), 6)::VARCHAR, + ROUND('-100.3908147521'::DECIMAL(18,10), 7)::VARCHAR, + ROUND('-100.3908147521'::DECIMAL(18,10), 8)::VARCHAR, + ROUND('-100.3908147521'::DECIMAL(18,10), 9)::VARCHAR, + ROUND('-100.3908147521'::DECIMAL(18,10), 10)::VARCHAR, + ROUND('-100.3908147521'::DECIMAL(18,10), 100000)::VARCHAR, + ROUND(NULL::DECIMAL, 0) +-- +ok +== +SELECT ROUND('-1049578239572094512.32415'::DECIMAL(30,10), 0)::VARCHAR, + ROUND('-1049578239572094512.32415'::DECIMAL(30,10), -1)::VARCHAR, + ROUND('-1049578239572094512.32415'::DECIMAL(30,10), -2)::VARCHAR, + ROUND('-1049578239572094512.32415'::DECIMAL(30,10), -3)::VARCHAR, + ROUND('-1049578239572094512.32415'::DECIMAL(30,10), -4)::VARCHAR, + ROUND('-1049578239572094512.32415'::DECIMAL(30,10), -5)::VARCHAR, + ROUND('-1049578239572094512.32415'::DECIMAL(30,10), -6)::VARCHAR, + ROUND('-1049578239572094512.32415'::DECIMAL(30,10), -7)::VARCHAR, + ROUND('-1049578239572094512.32415'::DECIMAL(30,10), -8)::VARCHAR, + ROUND('-1049578239572094512.32415'::DECIMAL(30,10), -9)::VARCHAR, + ROUND('-1049578239572094512.32415'::DECIMAL(30,10), -10)::VARCHAR, + ROUND('-1049578239572094512.32415'::DECIMAL(30,10), -11)::VARCHAR, + ROUND('-1049578239572094512.32415'::DECIMAL(30,10), -12)::VARCHAR, + ROUND('-1049578239572094512.32415'::DECIMAL(30,10), -13)::VARCHAR, + ROUND('-1049578239572094512.32415'::DECIMAL(30,10), -14)::VARCHAR, + ROUND('-1049578239572094512.32415'::DECIMAL(30,10), -15)::VARCHAR, + ROUND('-1049578239572094512.32415'::DECIMAL(30,10), -16)::VARCHAR, + ROUND('-1049578239572094512.32415'::DECIMAL(30,10), -18)::VARCHAR, + ROUND('-1049578239572094512.32415'::DECIMAL(30,10), -19)::VARCHAR, + ROUND('-1049578239572094512.32415'::DECIMAL(30,10), -20)::VARCHAR, + ROUND('-1049578239572094512.32415'::DECIMAL(30,10), -19842)::VARCHAR +-- +ok +== +SELECT typeof(ROUND(9999::DECIMAL(4,0), -1)), + ROUND(9999::DECIMAL(4,0), -1), + typeof(ROUND(999999999::DECIMAL(9,0), -1)), + ROUND(999999999::DECIMAL(9,0), -1), + typeof(ROUND(999999999999999999::DECIMAL(18,0), -1)), + ROUND(999999999999999999::DECIMAL(18,0), -1), + typeof(ROUND(9999999999999999999999999999999999999::DECIMAL(37,0), -1)), + ROUND(9999999999999999999999999999999999999::DECIMAL(37,0), -1) +-- +ok +== +SELECT ROUND(4999::DECIMAL(4,0), -4), + ROUND(5000::DECIMAL(4,0), -4), + ROUND(-5000::DECIMAL(4,0), -4), + ROUND(9999::DECIMAL(4,0), -5) +-- +ok +== +SELECT typeof(ROUND(999.9::DECIMAL(4,1), -3)), + ROUND(999.9::DECIMAL(4,1), -3), + ROUND(499.9::DECIMAL(4,1), -3) +-- +ok +== +SELECT typeof(ROUND(123::DECIMAL(38,0), -1)), + ROUND(123::DECIMAL(38,0), -1) +-- +ok +== +SELECT ROUND(99999999999999999999999999999999999999::DECIMAL(38,0), -39) +-- +ok +== +SELECT ROUND(99999999999999999999999999999999999999::DECIMAL(38,0), -1) +-- +ok +== +SELECT ROUND(-99999999999999999999999999999999999999::DECIMAL(38,0), -1) +-- +ok +== +SELECT ROUND(12::DECIMAL(3,0)) +-- +ok +== +SELECT ROUND(12::DECIMAL(3,0), i) FROM range(1) tbl(i) +-- +ok +== +SELECT ROUND(12::DECIMAL(3,0), NULL) +-- +ok +== +SELECT ROUND('-100.3'::DECIMAL(4,1), 1)::VARCHAR, + ROUND('104.3'::DECIMAL(4,1), 0)::VARCHAR, + ROUND('104.3'::DECIMAL(4,1), -1)::VARCHAR +-- +ok +== +SELECT ROUND('-100.3'::DECIMAL(9,1), 1)::VARCHAR, + ROUND('104.3'::DECIMAL(9,1), 0)::VARCHAR, + ROUND('104.3'::DECIMAL(9,1), -1)::VARCHAR +-- +ok +== +SELECT ROUND('-100.3'::DECIMAL(18,1), 1)::VARCHAR, + ROUND('104.3'::DECIMAL(18,1), 0)::VARCHAR, + ROUND('104.3'::DECIMAL(18,1), -1)::VARCHAR +-- +ok +== +SELECT printf('%.2f', '0.12345'::DECIMAL(30,10)) +-- +ok +== +SELECT (SELECT '1.0'::DECIMAL(2,1)); +-- +ok +== +SELECT ROUND(CAST(CAST('-100.3' AS DECIMAL(18, 1)) AS REAL), 1); +-- +ok +== diff --git a/parser/testdata/corpus/sql/types/decimal/test_decimal_small_precision_behavior.test b/parser/testdata/corpus/sql/types/decimal/test_decimal_small_precision_behavior.test new file mode 100644 index 0000000..8a1b8fb --- /dev/null +++ b/parser/testdata/corpus/sql/types/decimal/test_decimal_small_precision_behavior.test @@ -0,0 +1,37 @@ +# source: test/sql/types/decimal/test_decimal_small_precision_behavior.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +select '1.023450000001'::DECIMAL(5,4) +-- +ok +== +select '1.234499999'::DECIMAL(4,3) +-- +ok +== +select '1.23499999'::DECIMAL(4,3) +-- +ok +== +select '1.234499999'::DECIMAL(5,4) +-- +ok +== +select '-1.023450000001'::DECIMAL(5,4) +-- +ok +== +select '-1.234499999'::DECIMAL(4,3) +-- +ok +== +select '-1.23499999'::DECIMAL(4,3) +-- +ok +== +select '-1.234499999'::DECIMAL(5,4) +-- +ok +== diff --git a/parser/testdata/corpus/sql/types/decimal/test_empty_dec.test b/parser/testdata/corpus/sql/types/decimal/test_empty_dec.test new file mode 100644 index 0000000..7f9ccb0 --- /dev/null +++ b/parser/testdata/corpus/sql/types/decimal/test_empty_dec.test @@ -0,0 +1,21 @@ +# source: test/sql/types/decimal/test_empty_dec.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +CREATE TABLE decs(i DEC(), j DEC) +-- +ok +== +INSERT INTO decs VALUES (0176030871715840, 2.2) +-- +ok +== +SELECT * FROM decs +-- +ok +== +SELECT 1.25::FLOAT::DEC, 1.25::FLOAT::DEC() +-- +ok +== diff --git a/parser/testdata/corpus/sql/types/decimal/test_empty_decimal.test b/parser/testdata/corpus/sql/types/decimal/test_empty_decimal.test new file mode 100644 index 0000000..777a9da --- /dev/null +++ b/parser/testdata/corpus/sql/types/decimal/test_empty_decimal.test @@ -0,0 +1,17 @@ +# source: test/sql/types/decimal/test_empty_decimal.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +CREATE TABLE decimals(i DECIMAL(), j DECIMAL) +-- +ok +== +INSERT INTO decimals VALUES (0176030871715840, 2.2) +-- +ok +== +SELECT 1.25::FLOAT::DECIMAL, 1.25::FLOAT::DECIMAL() +-- +ok +== diff --git a/parser/testdata/corpus/sql/types/enum/standalone_enum.test b/parser/testdata/corpus/sql/types/enum/standalone_enum.test new file mode 100644 index 0000000..d95cddb --- /dev/null +++ b/parser/testdata/corpus/sql/types/enum/standalone_enum.test @@ -0,0 +1,33 @@ +# source: test/sql/types/enum/standalone_enum.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +SELECT 'hello'::ENUM('world', 'hello'); +-- +ok +== +CREATE TABLE test AS SELECT 'hello'::ENUM('world', 'hello') AS h; +-- +ok +== +SELECT 'hello'::ENUM; +-- +ok +== +SELECT ENUM 'a'; +-- +ok +== +SELECT 'hello'::ENUM(42); +-- +ok +== +SELECT 'hello'::ENUM('zzz', 42); +-- +ok +== +SELECT 'hello'::ENUM(foobar 42); +-- +error: Parser Error: syntax error at or near "42" +== diff --git a/parser/testdata/corpus/sql/types/enum/test_3479.test b/parser/testdata/corpus/sql/types/enum/test_3479.test new file mode 100644 index 0000000..6471c9a --- /dev/null +++ b/parser/testdata/corpus/sql/types/enum/test_3479.test @@ -0,0 +1,29 @@ +# source: test/sql/types/enum/test_3479.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +CREATE TYPE mood_2 AS ENUM ('1', '2', '3'); +-- +ok +== +CREATE TABLE m ( + m mood +); +-- +ok +== +CREATE TABLE m_2 ( + m mood_2 +); +-- +ok +== +insert into m_2 values ('1') +-- +ok +== +insert into m SELECT * FROM m_2 +-- +ok +== diff --git a/parser/testdata/corpus/sql/types/enum/test_3641.test b/parser/testdata/corpus/sql/types/enum/test_3641.test new file mode 100644 index 0000000..b2c1d76 --- /dev/null +++ b/parser/testdata/corpus/sql/types/enum/test_3641.test @@ -0,0 +1,44 @@ +# source: test/sql/types/enum/test_3641.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +CREATE TYPE mood_2 AS ENUM ('very sad', 'very ok', 'very happy'); +-- +ok +== +CREATE TABLE m ( + m mood, + m_2 mood_2 +); +-- +ok +== +insert into m values ('sad', 'very sad') +-- +ok +== +select * from m where m = ''::VARCHAR +-- +ok +== +SELECT m='' FROM m +-- +ok +== +PREPARE v1 AS SELECT m=? FROM m; +-- +ok +== +EXECUTE v1('') +-- +ok +== +SELECT * FROM m WHERE m=m_2 +-- +ok +== +SELECT * FROM m WHERE m::mood_2=m_2 +-- +ok +== diff --git a/parser/testdata/corpus/sql/types/enum/test_5983.test b/parser/testdata/corpus/sql/types/enum/test_5983.test new file mode 100644 index 0000000..59dab06 --- /dev/null +++ b/parser/testdata/corpus/sql/types/enum/test_5983.test @@ -0,0 +1,29 @@ +# source: test/sql/types/enum/test_5983.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +CALL DBGEN(sf=0.01); +-- +ok +== +create type orderkey_enum as enum (Select (l_orderkey/4)::VARCHAR from lineitem); +-- +ok +== +create table t2 (c1 orderkey_enum); +-- +ok +== +insert into t2 (select (l_orderkey/4)::VARCHAR from lineitem); +-- +ok +== +CREATE TYPE l_comment_enum as ENUM(select l_comment from lineitem); +-- +ok +== +CREATE TABLE lineitem2 (comment l_comment_enum); +-- +ok +== diff --git a/parser/testdata/corpus/sql/types/enum/test_6356.test b/parser/testdata/corpus/sql/types/enum/test_6356.test new file mode 100644 index 0000000..2ec7b89 --- /dev/null +++ b/parser/testdata/corpus/sql/types/enum/test_6356.test @@ -0,0 +1,69 @@ +# source: test/sql/types/enum/test_6356.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +create table a (a string, b mood); +-- +ok +== +insert into a values (NULL, 'happy'); +-- +ok +== +insert into a values ('woof', NULL); +-- +ok +== +insert into a values (NULL, NULL); +-- +ok +== +insert into a values ('quack', 'ok'); +-- +ok +== +insert into a values ('moo', 'sad'); +-- +ok +== +select coalesce(a, b) from a; +-- +ok +== +CREATE TYPE onomatopoeia AS ENUM ('woof', 'quack', 'moo'); +-- +ok +== +create table b (a onomatopoeia, b mood); +-- +ok +== +insert into b values (NULL, 'happy'); +-- +ok +== +insert into b values ('woof', NULL); +-- +ok +== +insert into b values (NULL, NULL); +-- +ok +== +insert into b values ('quack', 'ok'); +-- +ok +== +insert into b values ('moo', 'sad'); +-- +ok +== +select coalesce(a, b) from b; +-- +ok +== +select * from a where b in ('sad','woof', NULL) +-- +ok +== diff --git a/parser/testdata/corpus/sql/types/enum/test_alter_enum.test b/parser/testdata/corpus/sql/types/enum/test_alter_enum.test new file mode 100644 index 0000000..05aa7ed --- /dev/null +++ b/parser/testdata/corpus/sql/types/enum/test_alter_enum.test @@ -0,0 +1,43 @@ +# source: test/sql/types/enum/test_alter_enum.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +CREATE TABLE person ( + name text +); +-- +ok +== +insert into person values ('Pedro'), ('Mark'), ('Hannes'), ('Pedro'), ('Pedro'), ('Mark') +-- +ok +== +CREATE TYPE name_enum AS ENUM ('Pedro', 'Mark'); +-- +ok +== +ALTER TABLE person ALTER name TYPE name_enum +-- +ok +== +DROP TYPE name_enum +-- +ok +== +CREATE TYPE name_enum AS ENUM ('Pedro', 'Mark', 'Hannes'); +-- +ok +== +select typeof(name) from person limit 1 +-- +ok +== +ALTER TABLE person ALTER name TYPE text +-- +ok +== +ALTER TABLE person ALTER name TYPE bogus_name +-- +ok +== diff --git a/parser/testdata/corpus/sql/types/enum/test_enum.test b/parser/testdata/corpus/sql/types/enum/test_enum.test new file mode 100644 index 0000000..7ac8125 --- /dev/null +++ b/parser/testdata/corpus/sql/types/enum/test_enum.test @@ -0,0 +1,145 @@ +# source: test/sql/types/enum/test_enum.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +CREATE TYPE IF NOT EXISTS mood AS ENUM ('sad', 'ok', 'happy'); +-- +ok +== +select 'happy'::mood; +-- +ok +== +select 'awesome-bro'::mood; +-- +ok +== +select 0::mood; +-- +ok +== +CREATE TYPE bla AS ENUM (); +-- +ok +== +DROP TYPE bla; +-- +ok +== +CREATE TYPE bla AS ENUM (1,2,3); +-- +ok +== +CREATE TYPE bla AS ENUM ('sad',NULL); +-- +ok +== +CREATE TYPE bla AS ENUM ('sad','sad'); +-- +ok +== +CREATE TYPE mood_2 AS ENUM ('sad','Sad','SAD'); +-- +ok +== +ALTER TYPE mood ADD VALUE 'depressive'; +-- +error: Parser Error: syntax error at or near "TYPE" +== +ALTER TYPE mood REMOVE VALUE 'depressive'; +-- +error: Parser Error: syntax error at or near "TYPE" +== +DROP TYPE mood; +-- +ok +== +DROP TYPE mood_2; +-- +ok +== +DROP TYPE IF EXISTS mood; +-- +ok +== +CREATE TYPE mood AS ENUM ('sad', 'ok', 'happy', NULL); +-- +ok +== +select ['happy']::mood[] +-- +ok +== +select [NULL,'happy',NULL]::mood[] +-- +ok +== +select ['happy','ok','ok']::mood[] +-- +ok +== +select ['bla']::mood[] +-- +ok +== +select [1]::mood[] +-- +ok +== +select []::mood[] +-- +ok +== +select [NULL]::mood[] +-- +ok +== +select {'a': 'happy'::mood}; +-- +ok +== +select {'a': 'happy'::mood, 'b': 'ok'::mood}; +-- +ok +== +select {'a': 'happy'::mood, 'b': 1, 'c': 'ok'::mood}; +-- +ok +== +select {'a': 'happy'::mood, 'b': 'bla'::mood}; +-- +ok +== +select {'a': 'bla'::mood}; +-- +ok +== +select MAP([1,2,3,4],['happy','ok','ok','sad']::mood[]) +-- +ok +== +select MAP([1,2,3,4],['bla','ok','ok','sad']::mood[]) +-- +ok +== +CREATE OR REPLACE TYPE mood AS ENUM (); +-- +ok +== +SELECT enum_range(NULL::mood) AS my_enum_range; +-- +ok +== +SELECT enum_first(NULL::mood), enum_last(NULL::mood); +-- +ok +== +CREATE TEMPORARY TYPE mood AS ENUM ('sad', 'ok', 'happy'); +-- +ok +== +DROP TYPE mood +-- +ok +== diff --git a/parser/testdata/corpus/sql/types/enum/test_enum_case.test b/parser/testdata/corpus/sql/types/enum/test_enum_case.test new file mode 100644 index 0000000..e17afd5 --- /dev/null +++ b/parser/testdata/corpus/sql/types/enum/test_enum_case.test @@ -0,0 +1,21 @@ +# source: test/sql/types/enum/test_enum_case.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +CREATE TYPE E1 AS ENUM ('v1', 'v2'); +-- +ok +== +CREATE TABLE t1 (v E1); +-- +ok +== +INSERT INTO t1 VALUES ('v1'); +-- +ok +== +SELECT typeof(CASE WHEN 1 THEN v END) FROM t1; +-- +ok +== diff --git a/parser/testdata/corpus/sql/types/enum/test_enum_cast.test b/parser/testdata/corpus/sql/types/enum/test_enum_cast.test new file mode 100644 index 0000000..ebd93cc --- /dev/null +++ b/parser/testdata/corpus/sql/types/enum/test_enum_cast.test @@ -0,0 +1,89 @@ +# source: test/sql/types/enum/test_enum_cast.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +INSERT INTO person VALUES ('Pedro', 'ok'), ('Mark', 'sad'),('Moe', 'happy'), ('Diego', NULL); +-- +ok +== +select current_mood::varchar from person +-- +ok +== +CREATE TYPE years AS ENUM ('2001', '2006', '2012', '2018'); +-- +ok +== +CREATE TABLE albums ( + name text, + year_release years +); +-- +ok +== +INSERT INTO albums VALUES ('Tenacious D', '2001'), ('The Pick of Destiny', '2006'),('Rize of the Fenix', '2012'), ('Post-Apocalypto', '2018'), ('Something Random', NULL); +-- +ok +== +select name, year_release::INT from albums +-- +ok +== +select name from albums where year_release::INT > 2010 +-- +ok +== +CREATE TYPE years_error AS ENUM ('2001', '2006', '2012', 'bla'); +-- +ok +== +CREATE TABLE albums_error ( + name text, + year_release years_error +); +-- +ok +== +INSERT INTO albums_error VALUES ('Tenacious D', '2001'), ('The Pick of Destiny', 'bla') +-- +ok +== +select name, year_release::INT from albums_error +-- +ok +== +select name, year_release::INT from albums_error where year_release = '2001' +-- +ok +== +select name, TRY_CAST(year_release AS INT) from albums_error +-- +ok +== +select name, year_release::DOUBLE from albums +-- +ok +== +CREATE TYPE dates AS ENUM ('2001-01-01'); +-- +ok +== +CREATE TABLE dates_table ( + year_release dates +); +-- +ok +== +INSERT INTO dates_table VALUES ('2001-01-01') +-- +ok +== +select year_release::DATE from dates_table +-- +ok +== +select year_release::TIMESTAMP from dates_table +-- +ok +== diff --git a/parser/testdata/corpus/sql/types/enum/test_enum_comparisons.test b/parser/testdata/corpus/sql/types/enum/test_enum_comparisons.test new file mode 100644 index 0000000..45dc2e6 --- /dev/null +++ b/parser/testdata/corpus/sql/types/enum/test_enum_comparisons.test @@ -0,0 +1,169 @@ +# source: test/sql/types/enum/test_enum_comparisons.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +CREATE TYPE mood AS ENUM ('sad', 'quackity-quack', 'happy', 'ok'); +-- +ok +== +insert into person values ('Pedro','happy'), ('Mark', NULL), ('Hannes', 'quackity-quack'), ('Tim', 'ok'), ('Diego', 'sad') +-- +ok +== +CREATE TABLE robots ( + name text, + current_mood mood +); +-- +ok +== +insert into robots values ('Timmynator','sad'), ('Tars', 'ok'), ('Diggernaut', NULL) +-- +ok +== +select person.name, robots.name from person inner join robots on (person.current_mood = robots.current_mood) +-- +ok +== +CREATE TYPE pet_mood AS ENUM ( 'happy','beaming', 'quackity-quack'); +-- +ok +== +CREATE TABLE pet ( + name text, + current_mood pet_mood +); +-- +ok +== +insert into pet values ('Oogie','happy'), ('Wilbur', 'quackity-quack'), ('Chorizo', NULL), ('Vacilo', 'beaming') +-- +ok +== +select person.name, pet.name from person inner join pet on (person.current_mood > pet.current_mood) where person.name = 'Pedro' +-- +ok +== +select person.name, pet.name from person inner join pet on (person.current_mood = pet.current_mood) +-- +ok +== +select person_name,pet_name from +(select person.name as person_name, pet.name as pet_name, person.current_mood as person_mood, pet.current_mood as pet_mood +from person,pet) as t +where person_mood = pet_mood +-- +ok +== +select person_name,pet_name from +(select person.name as person_name, pet.name as pet_name, person.current_mood as person_mood, pet.current_mood as pet_mood +from person,pet) as t +where pet_mood = person_mood +-- +ok +== +SELECT person.current_mood +FROM person +UNION ALL +SELECT pet.current_mood +FROM pet +-- +ok +== +CREATE TABLE person_pet ( + person_name text, + pet_name text +); +-- +ok +== +insert into person_pet values ('Pedro','Oogie'), ('Hannes', 'Wilbur'), ('Tim', 'Chorizo'), ('Diego', 'Vacilo') +-- +ok +== +CREATE TABLE person_pet_den as select person_name,pet_name, person_mood, pet_mood from +(select person.name as person_name, pet.name as pet_name, person.current_mood as person_mood, pet.current_mood as pet_mood +from person inner join person_pet on (person.name = person_pet.person_name) inner join pet on (pet.name = person_pet.pet_name)) +-- +ok +== +SELECT * FROM person_pet_den +-- +ok +== +SELECT CASE WHEN person_name = 'Tim' THEN person_mood ELSE pet_mood END FROM person_pet_den +-- +ok +== +SELECT person_mood in ('sad') FROM person_pet_den +-- +ok +== +SELECT person_mood in ('beaming'::pet_mood) FROM person_pet_den +-- +ok +== +SELECT [person_mood, pet_mood] FROM person_pet_den +-- +ok +== +SELECT person_mood == pet_mood FROM person_pet_den +-- +ok +== +SELECT * FROM person_pet_den WHERE (person_mood == pet_mood) IS NULL +-- +ok +== +SELECT person_mood::pet_mood FROM person_pet_den +-- +ok +== +SELECT substring(person_mood from 1 for 2) FROM person_pet_den +-- +ok +== +SELECT substring(pet_mood from 1 for 2) FROM person_pet_den +-- +ok +== +SELECT person_mood FROM person_pet_den where person_mood like '%a%' +-- +ok +== +SELECT regexp_matches(person_mood, '.*a.*') FROM person_pet_den +-- +ok +== +CREATE TYPE wealth AS ENUM ('poor', 'medium-class', 'rich', 'very super rich'); +-- +ok +== +CREATE TABLE test ( + a mood, + b wealth +); +-- +ok +== +insert into test values ('happy', 'rich'), ('ok', 'poor') +-- +ok +== +SELECT a = b FROM test +-- +ok +== +SELECT * FROM test where a = b +-- +ok +== +insert into test values (NULL, 'very super rich') +-- +ok +== +SELECT * FROM test where (a = b) is NULL +-- +ok +== diff --git a/parser/testdata/corpus/sql/types/enum/test_enum_constraints.test b/parser/testdata/corpus/sql/types/enum/test_enum_constraints.test new file mode 100644 index 0000000..9528b18 --- /dev/null +++ b/parser/testdata/corpus/sql/types/enum/test_enum_constraints.test @@ -0,0 +1,65 @@ +# source: test/sql/types/enum/test_enum_constraints.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +drop type mood +-- +ok +== +drop table person +-- +ok +== +DROP TYPE mood CASCADE +-- +ok +== +ALTER TABLE person ALTER current_mood SET DATA TYPE VARCHAR +-- +ok +== +DROP TABLE person +-- +ok +== +ALTER TABLE person DROP COLUMN current_mood +-- +ok +== +ALTER TABLE person ADD COLUMN current_mood mood +-- +ok +== +CREATE TABLE person ( + past_mood mood, + current_mood mood +); +-- +ok +== +ALTER TABLE person ALTER past_mood SET DATA TYPE VARCHAR +-- +ok +== +ALTER TABLE person ALTER current_mood SET DATA TYPE VARCHAR; +-- +ok +== +CREATE TABLE person ( + name text ); +-- +ok +== +ALTER TABLE person RENAME COLUMN current_mood TO past_mood +-- +ok +== +CREATE TABLE person ( + name text, + current_mood mood, + past_mood mood +); +-- +ok +== diff --git a/parser/testdata/corpus/sql/types/enum/test_enum_duckdb_types.test b/parser/testdata/corpus/sql/types/enum/test_enum_duckdb_types.test new file mode 100644 index 0000000..9c7e5e9 --- /dev/null +++ b/parser/testdata/corpus/sql/types/enum/test_enum_duckdb_types.test @@ -0,0 +1,9 @@ +# source: test/sql/types/enum/test_enum_duckdb_types.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +SELECT type_name, logical_type FROM duckdb_types() WHERE NOT internal +-- +ok +== diff --git a/parser/testdata/corpus/sql/types/enum/test_enum_schema.test b/parser/testdata/corpus/sql/types/enum/test_enum_schema.test new file mode 100644 index 0000000..e6ee3d4 --- /dev/null +++ b/parser/testdata/corpus/sql/types/enum/test_enum_schema.test @@ -0,0 +1,93 @@ +# source: test/sql/types/enum/test_enum_schema.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +CREATE TYPE s1.mood AS ENUM ('sad', 'ok', 'happy'); +-- +ok +== +select 'happy'::s1.mood; +-- +ok +== +DROP TYPE s1.mood +-- +ok +== +CREATE TYPE foo.bar AS ENUM ('a', 'b'); +-- +ok +== +CREATE TABLE foo.baz ( + bar_col foo.bar NOT NULL +); +-- +ok +== +drop schema foo cascade; +-- +ok +== +CREATE SCHEMA "foo"; +-- +ok +== +CREATE TYPE "foo.bar" AS ENUM ('a', 'b'); +-- +ok +== +CREATE TABLE foo.baz ( + bar_col "foo.bar" NOT NULL +); +-- +ok +== +drop type "foo.bar" cascade; +-- +ok +== +drop schema "foo" cascade; +-- +ok +== +drop type foo.bar; +-- +ok +== +drop schema "foo" +-- +ok +== +drop type "foo.bar"; +-- +ok +== +CREATE TYPE "foo".bar AS ENUM ('a', 'b'); +-- +ok +== +CREATE TABLE foo.baz ( + bar_col "foo".bar NOT NULL +); +-- +ok +== +CREATE TYPE foo.bar AS ENUM ('a', 'b', 'c'); +-- +ok +== +CREATE TABLE foo.test ( + qualified_array foo.bar[] +); +-- +ok +== +INSERT INTO foo.test VALUES (['a', 'b']); +-- +ok +== +SELECT * FROM foo.test; +-- +ok +== diff --git a/parser/testdata/corpus/sql/types/enum/test_enum_structs.test b/parser/testdata/corpus/sql/types/enum/test_enum_structs.test new file mode 100644 index 0000000..2c9d310 --- /dev/null +++ b/parser/testdata/corpus/sql/types/enum/test_enum_structs.test @@ -0,0 +1,46 @@ +# source: test/sql/types/enum/test_enum_structs.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +SET storage_compatibility_version='v0.10.2'; +-- +ok +== +INSERT INTO person VALUES ( + 1, + ROW('Mark', 'happy') +); +-- +ok +== +FROM person +-- +ok +== +ALTER TABLE person DROP COLUMN c +-- +ok +== +ALTER TABLE person ADD COLUMN c STRUCT( + name text, + current_mood mood + ) +-- +ok +== +ALTER TABLE person ADD COLUMN c INT +-- +ok +== +ALTER TABLE person ALTER c SET DATA TYPE STRUCT( + name text, + current_mood mood + ) +-- +ok +== +UPDATE person SET c=ROW('Mark', 'happy') +-- +ok +== diff --git a/parser/testdata/corpus/sql/types/enum/test_enum_table.test b/parser/testdata/corpus/sql/types/enum/test_enum_table.test new file mode 100644 index 0000000..99d044c --- /dev/null +++ b/parser/testdata/corpus/sql/types/enum/test_enum_table.test @@ -0,0 +1,158 @@ +# source: test/sql/types/enum/test_enum_table.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +INSERT INTO person VALUES ('Moe', 'diego'); +-- +ok +== +select * from person where current_mood = 'sad' +-- +ok +== +select * from person where current_mood > 'sad' +-- +ok +== +select * from person where current_mood < 'sad' +-- +ok +== +CREATE TABLE pets ( + name text, + current_mood mood +); +-- +ok +== +select person.name, pets.name from person inner join pets on (person.current_mood = pets.current_mood) +-- +ok +== +CREATE TYPE intelligence AS ENUM ('dumb', 'smart', 'ehh'); +-- +ok +== +ALTER TABLE aliens ALTER current_mood SET DATA TYPE VARCHAR +-- +ok +== +CREATE TYPE car_brand AS ENUM ('Tesla', 'VW', 'Seat', 'Fiets'); +-- +ok +== +CREATE TABLE person ( + name text, + current_mood mood, + last_year_mood mood, + car car_brand +); +-- +ok +== +select * from person where current_mood = last_year_mood +-- +ok +== +select * from person where current_mood = 'ok' +-- +ok +== +select count(*), current_mood from person group by current_mood order by all +-- +ok +== +select name, current_mood from person order by current_mood +-- +ok +== +SELECT CAST (current_mood as STRING) from person +-- +ok +== +SELECT TRY_CAST (current_mood as STRING) from person +-- +ok +== +SELECT CAST ('ok' as mood) +-- +ok +== +SELECT TRY_CAST ('ok' as mood) +-- +ok +== +SELECT CAST ('bla' as mood) +-- +ok +== +SELECT TRY_CAST ('bla' as mood) +-- +ok +== +create type breed AS ENUM ('Maltese', 'Shi-tzu', 'Samoyed', 'Robot'); +-- +ok +== +CREATE TABLE person_string ( + name text, + current_mood text +); +-- +ok +== +INSERT INTO person_string VALUES ('Pedro', 'ok'), ('Mark', 'sad'); +-- +ok +== +select name,current_mood::mood from person_string where current_mood = 'sad' +-- +ok +== +create type midenum as enum ('0','1','2','3','4','5','6','7','8','9','10','11','12','13','14','15','16','17','18','19','20','21','22','23','24','25','26','27','28','29','30','31','32','33','34','35','36','37','38','39','40','41','42','43','44','45','46','47','48','49','50','51','52','53','54','55','56','57','58','59','60','61','62','63','64','65','66','67','68','69','70','71','72','73','74','75','76','77','78','79','80','81','82','83','84','85','86','87','88','89','90','91','92','93','94','95','96','97','98','99','100','101','102','103','104','105','106','107','108','109','110','111','112','113','114','115','116','117','118','119','120','121','122','123','124','125','126','127','128','129','130','131','132','133','134','135','136','137','138','139','140','141','142','143','144','145','146','147','148','149','150','151','152','153','154','155','156','157','158','159','160','161','162','163','164','165','166','167','168','169','170','171','172','173','174','175','176','177','178','179','180','181','182','183','184','185','186','187','188','189','190','191','192','193','194','195','196','197','198','199','200','201','202','203','204','205','206','207','208','209','210','211','212','213','214','215','216','217','218','219','220','221','222','223','224','225','226','227','228','229','230','231','232','233','234','235','236','237','238','239','240','241','242','243','244','245','246','247','248','249','250','251','252','253','254','255') +-- +ok +== +CREATE TABLE midenum_t ( + test midenum +); +-- +ok +== +INSERT INTO midenum_t VALUES ('0') +-- +ok +== +create type midenum_2 as enum ('0','1','2','3','4','5','6','7','8','9','10','11','12','13','14','15','16','17','18','19','20','21','22','23','24','25','26','27','28','29','30','31','32','33','34','35','36','37','38','39','40','41','42','43','44','45','46','47','48','49','50','51','52','53','54','55','56','57','58','59','60','61','62','63','64','65','66','67','68','69','70','71','72','73','74','75','76','77','78','79','80','81','82','83','84','85','86','87','88','89','90','91','92','93','94','95','96','97','98','99','100','101','102','103','104','105','106','107','108','109','110','111','112','113','114','115','116','117','118','119','120','121','122','123','124','125','126','127','128','129','130','131','132','133','134','135','136','137','138','139','140','141','142','143','144','145','146','147','148','149','150','151','152','153','154','155','156','157','158','159','160','161','162','163','164','165','166','167','168','169','170','171','172','173','174','175','176','177','178','179','180','181','182','183','184','185','186','187','188','189','190','191','192','193','194','195','196','197','198','199','200','201','202','203','204','205','206','207','208','209','210','211','212','213','214','215','216','217','218','219','220','221','222','223','224','225','226','227','228','229','230','231','232','233','234','235','236','237','238','239','240','241','242','243','244','245','246','247','248','249','250','251','252','253','254','255') +-- +ok +== +CREATE TABLE midenum_t2 ( + test_2 midenum_2 +); +-- +ok +== +INSERT INTO midenum_t2 VALUES ('0') +-- +ok +== +CREATE TYPE large_enum AS ENUM ('Floccinaucinihilipilification', 'Antidisestablishmentarianism', 'Honorificabilitudinitatibus'); +-- +ok +== +CREATE TABLE large_enum_tbl ( + big_word large_enum +); +-- +ok +== +INSERT INTO large_enum_tbl values ('Floccinaucinihilipilification'), ('Floccinaucinihilipilification'), ('Honorificabilitudinitatibus'), ('Floccinaucinihilipilification'), ('Antidisestablishmentarianism') +-- +ok +== +select * from large_enum_tbl +-- +ok +== diff --git a/parser/testdata/corpus/sql/types/enum/test_enum_temp_tbl.test b/parser/testdata/corpus/sql/types/enum/test_enum_temp_tbl.test new file mode 100644 index 0000000..afa4a39 --- /dev/null +++ b/parser/testdata/corpus/sql/types/enum/test_enum_temp_tbl.test @@ -0,0 +1,21 @@ +# source: test/sql/types/enum/test_enum_temp_tbl.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +CREATE TEMP TABLE tbl_temp (name varchar , cur_mood mood); +-- +ok +== +insert into tbl_temp values ('bla', 'sad'), ('bla_2', 'happy') +-- +ok +== +select count(*) from tbl_temp; +-- +ok +== +insert into tbl_temp values ('bla', 'invalid') +-- +ok +== diff --git a/parser/testdata/corpus/sql/types/enum/test_enum_to_numbers.test b/parser/testdata/corpus/sql/types/enum/test_enum_to_numbers.test new file mode 100644 index 0000000..98edac5 --- /dev/null +++ b/parser/testdata/corpus/sql/types/enum/test_enum_to_numbers.test @@ -0,0 +1,201 @@ +# source: test/sql/types/enum/test_enum_to_numbers.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +create type enum_numstrings as enum ('1', '2', '3', '4'); +-- +ok +== +create table t1 as select range as a from range(10); +-- +ok +== +create table t2 (a enum_numstrings); +-- +ok +== +insert into t2 values ('1'), ('2'), ('3'); +-- +ok +== +select t1.a, count(*) as num_matches from t1, t2 where t1.a != t2.a group by t1.a order by t1.a; +-- +ok +== +insert into t2 values ('1'), ('2'); +-- +ok +== +select * from t1, t2 where t1.a = t2.a order by t1.a; +-- +ok +== +delete from t2 where 1=1; +-- +ok +== +insert into t2 values (NULL), ('1'); +-- +ok +== +select * from t1, t2 order by t1.a, t2.a NULLS FIRST; +-- +ok +== +insert into t2 values ('2'), ('3'), ('4'); +-- +ok +== +select * from t1, t2 where t2.a NOT IN ('2', '3', '4') order by t1.a, t2.a NULLS FIRST; +-- +ok +== +EXPLAIN select * from t1, t2 where t2.a = '2' order by t1.a; +-- +ok +== +drop table t1 +-- +ok +== +drop table t2 +-- +ok +== +create type enum_strings as enum ('hello', 'goodbye', 'mr duck'); +-- +ok +== +create table t1 as select range as a from range(500); +-- +ok +== +create table t2 (a enum_strings); +-- +ok +== +insert into t2 values ('hello'), ('goodbye'), ('mr duck'), ('mr duck'), ('hello'), ('goodbye'); +-- +ok +== +Select * from t1, t2 where t1.a = t2.a; +-- +ok +== +Select * from t1, t2 where t1.a::VARCHAR = t2.a; +-- +ok +== +drop table t1; +-- +ok +== +drop table t2; +-- +ok +== +create type new_type as enum ('1', '2', '3', '4', '5'); +-- +ok +== +create table t1 as select range::{type} as a from range(8); +-- +error: Parser Error: syntax error at or near "{" +== +create table t2 as select (range%4+1)::VARCHAR::new_type as b from range(8); +-- +ok +== +select a from t1, t2 where t1.a = t2.b; +-- +ok +== +select count(*) from t1, t2 where t1.a::VARCHAR < t2.b; +-- +ok +== +select count(*) from t1, t2 where t1.a::VARCHAR <= t2.b; +-- +ok +== +select count(*) from t1, t2 where t1.a::VARCHAR > t2.b; +-- +ok +== +select count(*) from t1, t2 where t1.a::VARCHAR >= t2.b; +-- +ok +== +drop type new_type; +-- +ok +== +create type new_type as enum ('294247-01-10 04:00:54.775806', '83 years 3 months 999 days 00:16:39.999999', '1677-09-21 00:12:43.145225', 'other enum type', 'another 1', '~~~'); +-- +ok +== +create table t1 as select date, time, timestamp, timestamp_s, timestamp_ms, timestamp_ns, time_tz, timestamp_tz, interval, blob, bool from test_all_types(); +-- +ok +== +create table t2 as select * from VALUES ('294247-01-10 04:00:54.775806'::new_type), ('83 years 3 months 999 days 00:16:39.999999'::new_type), ('1677-09-21 00:12:43.145225'::new_type), ('other enum type'::new_type), ('another 1'::new_type), ('~~~'::new_type) t(b); +-- +ok +== +select count(*) from t1, t2 where t1.date = t2.b; +-- +ok +== +select count(*) from t1, t2 where t1.time = t2.b; +-- +ok +== +select count(*) from t1, t2 where t1.timestamp = t2.b; +-- +ok +== +select count(*) from t1, t2 where t1.timestamp_s = t2.b; +-- +ok +== +select count(*) from t1, t2 where t1.timestamp_ms = t2.b; +-- +ok +== +select count(*) from t1, t2 where t1.timestamp_ns = t2.b; +-- +ok +== +select count(*) from t1, t2 where t1.time_tz = t2.b; +-- +ok +== +select count(*) from t1, t2 where t1.timestamp_tz = t2.b; +-- +ok +== +select count(*) from t1, t2 where t1.interval = t2.b; +-- +ok +== +select count(*) from t1, t2 where t1.blob = t2.b; +-- +ok +== +create type enum_bits as enum ('11001010110', '110', '0101001010101', 'some enum val that cannot be cast to bit'); +-- +ok +== +create table t1 as select * from values ('110010'::BIT), ('110'::BIT), ('110110110011'::BIT) t(a); +-- +ok +== +create table t2 as select * from values ('11001010110'::enum_bits), ('110'::enum_bits), ('0101001010101'::enum_bits), ('some enum val that cannot be cast to bit'::enum_bits) t(b); +-- +ok +== +select count(*) from t1, t2 where t1.a = t2.b; +-- +ok +== diff --git a/parser/testdata/corpus/sql/types/enum/test_enums_and_built_in_types.test b/parser/testdata/corpus/sql/types/enum/test_enums_and_built_in_types.test new file mode 100644 index 0000000..7145349 --- /dev/null +++ b/parser/testdata/corpus/sql/types/enum/test_enums_and_built_in_types.test @@ -0,0 +1,25 @@ +# source: test/sql/types/enum/test_enums_and_built_in_types.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +CREATE TYPE "integer" AS ENUM ('1', '2', '3'); +-- +ok +== +SELECT 4::INTEGEE +-- +ok +== +DROP TYPE "INTEGER" +-- +ok +== +DROP TYPE "INTEGEE" +-- +ok +== +CREATE TYPE integer AS ENUM ('1', '2', '3'); +-- +ok +== diff --git a/parser/testdata/corpus/sql/types/float/ieee_floating_points.test b/parser/testdata/corpus/sql/types/float/ieee_floating_points.test new file mode 100644 index 0000000..7a94aa9 --- /dev/null +++ b/parser/testdata/corpus/sql/types/float/ieee_floating_points.test @@ -0,0 +1,93 @@ +# source: test/sql/types/float/ieee_floating_points.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +CREATE OR REPLACE TABLE tbl(val {type}) +-- +error: Parser Error: syntax error at or near "{" +== +INSERT INTO tbl VALUES (1), (-1), (0), ('nan'), ('inf') +-- +ok +== +SELECT val, val / 0::{type} FROM tbl +-- +error: Parser Error: syntax error at or near "{" +== +SELECT val, val % 0::{type} FROM tbl +-- +error: Parser Error: syntax error at or near "{" +== +SELECT sqrt(-1::{type}); +-- +error: Parser Error: syntax error at or near "{" +== +SELECT ln(-1::{type}); +-- +error: Parser Error: syntax error at or near "{" +== +SELECT asin(2::{type}); +-- +error: Parser Error: syntax error at or near "{" +== +SELECT acos(2::{type}); +-- +error: Parser Error: syntax error at or near "{" +== +SELECT atanh(2::{type}); +-- +error: Parser Error: syntax error at or near "{" +== +SELECT sin('inf'::{type}); +-- +error: Parser Error: syntax error at or near "{" +== +SELECT cos('inf'::{type}); +-- +error: Parser Error: syntax error at or near "{" +== +SELECT tan('inf'::{type}); +-- +error: Parser Error: syntax error at or near "{" +== +SELECT cot('inf'::{type}); +-- +error: Parser Error: syntax error at or near "{" +== +SELECT cot(0::{type}); +-- +error: Parser Error: syntax error at or near "{" +== +SELECT gamma(0::{type}); +-- +error: Parser Error: syntax error at or near "{" +== +SELECT lgamma(0::{type}); +-- +error: Parser Error: syntax error at or near "{" +== +SELECT sqrt(-1::{type}), ln(-1::{type}), log10(-1::{type}), log2(-1::{type}); +-- +error: Parser Error: syntax error at or near "{" +== +SELECT ln(0::{type}), log10(0::{type}), log2(0::{type}), log(1::{type}, 64::{type}); +-- +error: Parser Error: syntax error at or near "{" +== +SELECT asin(2::{type}), acos(2::{type}), atanh(2::{type}), atanh(1::{type}), atanh(-1::{type}); +-- +error: Parser Error: syntax error at or near "{" +== +SELECT sin('inf'::{type}), cos('inf'::{type}), tan('inf'::{type}), cot('inf'::{type}); +-- +error: Parser Error: syntax error at or near "{" +== +SELECT cot(0::{type}), cot(-0::{type}); +-- +error: Parser Error: syntax error at or near "{" +== +SELECT gamma(0::{type}), gamma(-1::{type}), lgamma(0::{type}), lgamma(-1::{type}); +-- +error: Parser Error: syntax error at or near "{" +== diff --git a/parser/testdata/corpus/sql/types/float/infinity_test.test b/parser/testdata/corpus/sql/types/float/infinity_test.test new file mode 100644 index 0000000..cccb36c --- /dev/null +++ b/parser/testdata/corpus/sql/types/float/infinity_test.test @@ -0,0 +1,105 @@ +# source: test/sql/types/float/infinity_test.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +SELECT 'INF'::{type}, '-INF'::{type} +-- +error: Parser Error: syntax error at or near "{" +== +select 'inf'::{type} == 'inf'::{type} +-- +error: Parser Error: syntax error at or near "{" +== +select 'inf'::{type} <> 'inf'::{type} +-- +error: Parser Error: syntax error at or near "{" +== +select 'inf'::{type} <> 3.0::{type} +-- +error: Parser Error: syntax error at or near "{" +== +CREATE TABLE floats(f {type} {key}); +-- +error: Parser Error: syntax error at or near "{" +== +INSERT INTO floats VALUES ('INF'), (1), ('-INF') +-- +ok +== +SELECT * FROM floats +-- +ok +== +SELECT f FROM floats WHERE f=1 +-- +ok +== +SELECT f FROM floats WHERE f='inf'::{type} +-- +error: Parser Error: syntax error at or near "{" +== +SELECT f FROM floats WHERE f='-inf'::{type} +-- +error: Parser Error: syntax error at or near "{" +== +SELECT f FROM floats WHERE f<>1 ORDER BY 1 +-- +ok +== +SELECT f FROM floats WHERE f<>'inf'::{type} ORDER BY 1 +-- +error: Parser Error: syntax error at or near "{" +== +SELECT f FROM floats WHERE f<>'-inf'::{type} ORDER BY 1 +-- +error: Parser Error: syntax error at or near "{" +== +SELECT f FROM floats WHERE f>1 ORDER BY 1 +-- +ok +== +SELECT f FROM floats WHERE f>'-inf'::{type} ORDER BY 1 +-- +error: Parser Error: syntax error at or near "{" +== +SELECT f FROM floats WHERE f>'inf'::{type} +-- +error: Parser Error: syntax error at or near "{" +== +SELECT f FROM floats WHERE f>=1 ORDER BY ALL +-- +ok +== +SELECT f FROM floats WHERE f>='-inf'::{type} ORDER BY ALL +-- +error: Parser Error: syntax error at or near "{" +== +SELECT f FROM floats WHERE f>='inf'::{type} ORDER BY ALL +-- +error: Parser Error: syntax error at or near "{" +== +SELECT f FROM floats WHERE f<1 +-- +ok +== +SELECT f FROM floats WHERE f<'inf'::{type} ORDER BY ALL +-- +error: Parser Error: syntax error at or near "{" +== +SELECT f FROM floats WHERE f<'-inf'::{type} ORDER BY ALL +-- +error: Parser Error: syntax error at or near "{" +== +SELECT f FROM floats WHERE f<=1 ORDER BY ALL +-- +ok +== +SELECT f FROM floats WHERE f<='inf'::{type} ORDER BY ALL +-- +error: Parser Error: syntax error at or near "{" +== +SELECT f FROM floats WHERE f<='-inf'::{type} ORDER BY ALL +-- +error: Parser Error: syntax error at or near "{" +== diff --git a/parser/testdata/corpus/sql/types/float/nan_aggregate.test b/parser/testdata/corpus/sql/types/float/nan_aggregate.test new file mode 100644 index 0000000..8063f70 --- /dev/null +++ b/parser/testdata/corpus/sql/types/float/nan_aggregate.test @@ -0,0 +1,45 @@ +# source: test/sql/types/float/nan_aggregate.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +create table floats(f {type}, i int); +-- +error: Parser Error: syntax error at or near "{" +== +insert into floats values ('inf', 1), ('inf', 7), ('-inf', 3), ('nan', 7), ('nan', 19), ('-inf', 2) +-- +ok +== +SELECT f, SUM(i) FROM floats GROUP BY f ORDER BY f; +-- +ok +== +select sum(f) from floats where 0 < f and f != 'nan'::DOUBLE; +-- +ok +== +select sum(f) from floats where 0 > f; +-- +ok +== +select sum(f) from floats +-- +ok +== +create table floats_doubles (f FLOAT, d DOUBLE); +-- +ok +== +insert into floats_doubles VALUES (2e38, 1e308), (2e38, 1e308), (-1e38, 0), (-1e38, 0); +-- +ok +== +select sum(f) from floats_doubles where f > 0 +-- +ok +== +select sum(d) from floats_doubles where d > 0 +-- +ok +== diff --git a/parser/testdata/corpus/sql/types/float/nan_aggregates.test b/parser/testdata/corpus/sql/types/float/nan_aggregates.test new file mode 100644 index 0000000..c38c2f5 --- /dev/null +++ b/parser/testdata/corpus/sql/types/float/nan_aggregates.test @@ -0,0 +1,29 @@ +# source: test/sql/types/float/nan_aggregates.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +SELECT SUM('inf'::{type}), SUM('-inf'::{type}), SUM('nan'::{type}) +-- +error: Parser Error: syntax error at or near "{" +== +SELECT MIN('inf'::{type}), MIN('-inf'::{type}), MIN('nan'::{type}) +-- +error: Parser Error: syntax error at or near "{" +== +SELECT MAX('inf'::{type}), MAX('-inf'::{type}), MAX('nan'::{type}) +-- +error: Parser Error: syntax error at or near "{" +== +create table floats(f {type}); +-- +error: Parser Error: syntax error at or near "{" +== +insert into floats values ('inf'), ('-inf'), ('nan'); +-- +ok +== +SELECT MIN(f), MAX(f) FROM floats +-- +ok +== diff --git a/parser/testdata/corpus/sql/types/float/nan_arithmetic.test b/parser/testdata/corpus/sql/types/float/nan_arithmetic.test new file mode 100644 index 0000000..4cd3cec --- /dev/null +++ b/parser/testdata/corpus/sql/types/float/nan_arithmetic.test @@ -0,0 +1,121 @@ +# source: test/sql/types/float/nan_arithmetic.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +SELECT '{val}'::{type} + 1 +-- +error: Parser Error: syntax error at or near "{" +== +SELECT '{val}'::{type} + 'inf'::{type} +-- +error: Parser Error: syntax error at or near "{" +== +SELECT '{val}'::{type} - 1 +-- +error: Parser Error: syntax error at or near "{" +== +SELECT '{val}'::{type} - 'inf'::{type} +-- +error: Parser Error: syntax error at or near "{" +== +SELECT '{val}'::{type} * 1 +-- +error: Parser Error: syntax error at or near "{" +== +SELECT '{val}'::{type} * 'inf'::{type} +-- +error: Parser Error: syntax error at or near "{" +== +SELECT '{val}'::{type} / 1 +-- +error: Parser Error: syntax error at or near "{" +== +SELECT '{val}'::{type} / 'inf'::{type} +-- +error: Parser Error: syntax error at or near "{" +== +SELECT '{val}'::{type} % 1 +-- +error: Parser Error: syntax error at or near "{" +== +SELECT '{val}'::{type} % 'inf'::{type} +-- +error: Parser Error: syntax error at or near "{" +== +SELECT -('{val}'::{type}) +-- +error: Parser Error: syntax error at or near "{" +== +SELECT 'inf'::{type} + 1 +-- +error: Parser Error: syntax error at or near "{" +== +SELECT 'inf'::{type} + 'inf'::{type} +-- +error: Parser Error: syntax error at or near "{" +== +SELECT 'inf'::{type} - 1 +-- +error: Parser Error: syntax error at or near "{" +== +SELECT 'inf'::{type} - 'inf'::{type} +-- +error: Parser Error: syntax error at or near "{" +== +SELECT 'inf'::{type} * 1 +-- +error: Parser Error: syntax error at or near "{" +== +SELECT 'inf'::{type} * 'inf'::{type} +-- +error: Parser Error: syntax error at or near "{" +== +SELECT 'inf'::{type} * '-inf'::{type} +-- +error: Parser Error: syntax error at or near "{" +== +SELECT 'inf'::{type} / 1 +-- +error: Parser Error: syntax error at or near "{" +== +SELECT 1 / 'inf'::{type} +-- +error: Parser Error: syntax error at or near "{" +== +SELECT 'inf'::{type} % 1 +-- +error: Parser Error: syntax error at or near "{" +== +SELECT 1 % 'inf'::{type} +-- +error: Parser Error: syntax error at or near "{" +== +SELECT -('inf'::{type}) +-- +error: Parser Error: syntax error at or near "{" +== +SELECT '-inf'::{type} + 1 +-- +error: Parser Error: syntax error at or near "{" +== +SELECT '-inf'::{type} - 1 +-- +error: Parser Error: syntax error at or near "{" +== +SELECT '-inf'::{type} * 1 +-- +error: Parser Error: syntax error at or near "{" +== +SELECT '-inf'::{type} / 1 +-- +error: Parser Error: syntax error at or near "{" +== +SELECT '-inf'::{type} % 1 +-- +error: Parser Error: syntax error at or near "{" +== +SELECT -('-inf'::{type}) +-- +error: Parser Error: syntax error at or near "{" +== diff --git a/parser/testdata/corpus/sql/types/float/nan_cast.test b/parser/testdata/corpus/sql/types/float/nan_cast.test new file mode 100644 index 0000000..84dcbaa --- /dev/null +++ b/parser/testdata/corpus/sql/types/float/nan_cast.test @@ -0,0 +1,25 @@ +# source: test/sql/types/float/nan_cast.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +SELECT '{val}'::{source_type} +-- +error: Parser Error: syntax error at or near "{" +== +SELECT '{val}'::{source_type}::{target_type} +-- +error: Parser Error: syntax error at or near "{" +== +SELECT 'nan'::{source_type}::{target_type} +-- +error: Parser Error: syntax error at or near "{" +== +SELECT 'inf'::{source_type}::{target_type} +-- +error: Parser Error: syntax error at or near "{" +== +SELECT '-inf'::{source_type}::{target_type} +-- +error: Parser Error: syntax error at or near "{" +== diff --git a/parser/testdata/corpus/sql/types/float/nan_functions.test b/parser/testdata/corpus/sql/types/float/nan_functions.test new file mode 100644 index 0000000..c7b6ce1 --- /dev/null +++ b/parser/testdata/corpus/sql/types/float/nan_functions.test @@ -0,0 +1,90 @@ +# source: test/sql/types/float/nan_functions.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +SELECT nextafter(3, '-inf'::{type}) +-- +error: Parser Error: syntax error at or near "{" +== +SELECT nextafter(3, 'inf'::{type}) +-- +error: Parser Error: syntax error at or near "{" +== +SELECT nextafter('inf'::{type}, 'inf'::{type}) +-- +error: Parser Error: syntax error at or near "{" +== +SELECT nextafter('-inf'::{type}, '-inf'::{type}) +-- +error: Parser Error: syntax error at or near "{" +== +SELECT nextafter('nan'::{type}, '-inf'::{type}) +-- +error: Parser Error: syntax error at or near "{" +== +SELECT nextafter(0, 'nan'::{type}) +-- +error: Parser Error: syntax error at or near "{" +== +SELECT sign('-inf'::{type}) +-- +error: Parser Error: syntax error at or near "{" +== +SELECT sign('inf'::{type}) +-- +error: Parser Error: syntax error at or near "{" +== +SELECT sign('nan'::{type}) +-- +error: Parser Error: syntax error at or near "{" +== +SELECT {unary_func}('-inf'::{type}) +-- +error: Parser Error: syntax error at or near "}" +== +SELECT {unary_func}('inf'::{type}) +-- +error: Parser Error: syntax error at or near "}" +== +SELECT {unary_func}('nan'::{type}) +-- +error: Parser Error: syntax error at or near "}" +== +select f, abs(f), exp(f), pow(f, 2), sqrt(case when f < 0 then NULL else f end), cbrt(f), ln(case when f < 0 then NULL else f end), degrees(f), radians(f), gamma(f), lgamma(f), atan(f), atan2(f, 0) +from floats; +-- +ok +== +select {unary_func}('inf'::{type}) +-- +error: Parser Error: syntax error at or near "}" +== +select {unary_func}('-inf'::{type}) +-- +error: Parser Error: syntax error at or near "}" +== +select {unary_func}('nan'::{type}) +-- +error: Parser Error: syntax error at or near "}" +== +drop table floats +-- +ok +== +SELECT nextafter('inf'::float, '-inf'::float) +-- +ok +== +SELECT nextafter('-inf'::float, 'inf'::float) +-- +ok +== +SELECT nextafter('inf'::double, '-inf'::double) +-- +ok +== +SELECT nextafter('-inf'::double, 'inf'::double) +-- +ok +== diff --git a/parser/testdata/corpus/sql/types/float/nan_join.test b/parser/testdata/corpus/sql/types/float/nan_join.test new file mode 100644 index 0000000..2b0f5c3 --- /dev/null +++ b/parser/testdata/corpus/sql/types/float/nan_join.test @@ -0,0 +1,25 @@ +# source: test/sql/types/float/nan_join.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +SELECT * FROM floats JOIN (SELECT 'inf'::{type}) tbl(f) USING (f) +-- +error: Parser Error: syntax error at or near "{" +== +SELECT * FROM floats JOIN (SELECT '-inf'::{type}) tbl(f) USING (f) +-- +error: Parser Error: syntax error at or near "{" +== +SELECT * FROM floats JOIN (SELECT 'inf'::{type}) tbl(f) ON (floats.f >= tbl.f) ORDER BY 1 +-- +error: Parser Error: syntax error at or near "{" +== +SELECT * FROM floats JOIN (SELECT 'inf'::{type}) tbl(f) ON (floats.f <= tbl.f) ORDER BY 1 +-- +error: Parser Error: syntax error at or near "{" +== +SELECT * FROM floats JOIN (SELECT '-inf'::{type}, 'inf'::{type}) tbl(f,g ) ON (floats.f >= tbl.f AND floats.f <= tbl.g) ORDER BY 1 +-- +error: Parser Error: syntax error at or near "{" +== diff --git a/parser/testdata/corpus/sql/types/float/nan_ordering.test b/parser/testdata/corpus/sql/types/float/nan_ordering.test new file mode 100644 index 0000000..e01d32a --- /dev/null +++ b/parser/testdata/corpus/sql/types/float/nan_ordering.test @@ -0,0 +1,57 @@ +# source: test/sql/types/float/nan_ordering.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +CREATE TABLE floats(f {type}); +-- +error: Parser Error: syntax error at or near "{" +== +INSERT INTO floats VALUES ('NAN'), (1), ('infinity'), ('-infinity'), (-1), (NULL) +-- +ok +== +SELECT f FROM floats ORDER BY f +-- +ok +== +SELECT f FROM floats ORDER BY f DESC +-- +ok +== +SELECT f FROM floats ORDER BY f DESC NULLS LAST LIMIT 2 +-- +ok +== +SELECT f FROM floats ORDER BY f NULLS LAST LIMIT 2 +-- +ok +== +INSERT INTO floats SELECT '0'::{type} FROM range(10000) +-- +error: Parser Error: syntax error at or near "{" +== +INSERT INTO floats VALUES ('nan'::{type}) +-- +error: Parser Error: syntax error at or near "{" +== +INSERT INTO floats VALUES ('-inf'::{type}) +-- +error: Parser Error: syntax error at or near "{" +== +SELECT f FROM floats ORDER BY f DESC NULLS LAST LIMIT 4 +-- +ok +== +SELECT f FROM floats ORDER BY f NULLS LAST LIMIT 4 +-- +ok +== +SELECT COUNT(*) FROM floats WHERE f > 0 +-- +ok +== +SELECT COUNT(*) FROM floats WHERE f < 0 +-- +ok +== diff --git a/parser/testdata/corpus/sql/types/float/nan_test.test b/parser/testdata/corpus/sql/types/float/nan_test.test new file mode 100644 index 0000000..a899e31 --- /dev/null +++ b/parser/testdata/corpus/sql/types/float/nan_test.test @@ -0,0 +1,65 @@ +# source: test/sql/types/float/nan_test.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +SELECT 'NAN'::{type} +-- +error: Parser Error: syntax error at or near "{" +== +INSERT INTO floats VALUES ('NAN'), (1) +-- +ok +== +select 'nan'::{type} == 'nan'::{type} +-- +error: Parser Error: syntax error at or near "{" +== +select 'nan'::{type} <> 'nan'::{type} +-- +error: Parser Error: syntax error at or near "{" +== +select 'nan'::{type} <> 3.0::{type} +-- +error: Parser Error: syntax error at or near "{" +== +SELECT f FROM floats WHERE f='nan'::{type} +-- +error: Parser Error: syntax error at or near "{" +== +SELECT f FROM floats WHERE f<>1 +-- +ok +== +SELECT f FROM floats WHERE f<>'nan'::{type} +-- +error: Parser Error: syntax error at or near "{" +== +SELECT f FROM floats WHERE f > 0 ORDER BY ALL; +-- +ok +== +SELECT f FROM floats WHERE f>'nan'::{type} +-- +error: Parser Error: syntax error at or near "{" +== +SELECT f FROM floats WHERE f >= 1 ORDER BY ALL; +-- +ok +== +SELECT f FROM floats WHERE f>='nan'::{type} +-- +error: Parser Error: syntax error at or near "{" +== +SELECT f FROM floats WHERE f<'nan'::{type} +-- +error: Parser Error: syntax error at or near "{" +== +SELECT f FROM floats WHERE f<=1 +-- +ok +== +SELECT f FROM floats WHERE f <= 'nan'::{type} ORDER BY ALL; +-- +error: Parser Error: syntax error at or near "{" +== diff --git a/parser/testdata/corpus/sql/types/float/nan_window.test b/parser/testdata/corpus/sql/types/float/nan_window.test new file mode 100644 index 0000000..f4485b7 --- /dev/null +++ b/parser/testdata/corpus/sql/types/float/nan_window.test @@ -0,0 +1,21 @@ +# source: test/sql/types/float/nan_window.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +SELECT f, SUM(i) OVER (PARTITION BY f) FROM floats ORDER BY f +-- +ok +== +SELECT f, i, SUM(i) OVER (ORDER BY f, i) FROM floats ORDER BY f, i +-- +ok +== +SELECT f, i, SUM(i) OVER (PARTITION BY f ORDER BY f, i) FROM floats ORDER BY f, i +-- +ok +== +SELECT i, f, SUM(i) OVER (ORDER BY i, f) FROM floats ORDER BY i, f +-- +ok +== diff --git a/parser/testdata/corpus/sql/types/float/nested_nan.test b/parser/testdata/corpus/sql/types/float/nested_nan.test new file mode 100644 index 0000000..2aa6925 --- /dev/null +++ b/parser/testdata/corpus/sql/types/float/nested_nan.test @@ -0,0 +1,21 @@ +# source: test/sql/types/float/nested_nan.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +SELECT ['nan'::double] +-- +ok +== +SELECT UNNEST(['nan'::double]) +-- +ok +== +SELECT {'a': 'nan'::double} +-- +ok +== +SELECT ({'a': 'nan'::double}).a +-- +ok +== diff --git a/parser/testdata/corpus/sql/types/geo/geometry.test b/parser/testdata/corpus/sql/types/geo/geometry.test new file mode 100644 index 0000000..114cfef --- /dev/null +++ b/parser/testdata/corpus/sql/types/geo/geometry.test @@ -0,0 +1,134 @@ +# source: test/sql/types/geo/geometry.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +create table t1(id INT, g GEOMETRY); +-- +ok +== +insert into t1 values + (1, 'POINT(0 1)'), + (2, 'LINESTRING(0 0, 1 1, 2 2)'), + (3, 'POLYGON((0 0, 4 0, 4 4, 0 4, 0 0))'), + (4, 'MULTIPOINT((1 1), (2 2), (3 3))'), + (5, 'MULTIPOINT(1 1, 2 2, 3 3)'), --alternative syntax + (6, 'MULTILINESTRING((0 0, 1 1), (2 2, 3 3))'), + (7, 'MULTIPOLYGON(((0 0, 4 0, 4 4, 0 4, 0 0)), ((5 5, 7 5, 7 7, 5 7, 5 5)))'), + (8, 'GEOMETRYCOLLECTION(POINT(1 1), LINESTRING(0 0, 1 1))'), + (9, NULL); +-- +ok +== +select id, g::VARCHAR from t1 order by id; +-- +ok +== +create table t2(id INT, g GEOMETRY); +-- +ok +== +insert into t2 values + (1, 'POINT EMPTY'), + (2, 'LINESTRING EMPTY'), + (3, 'POLYGON EMPTY'), + (4, 'MULTIPOINT EMPTY'), + (5, 'MULTILINESTRING EMPTY'), + (6, 'MULTIPOLYGON EMPTY'), + (7, 'GEOMETRYCOLLECTION EMPTY'), +-- +ok +== +select id, g::VARCHAR from t2 order by id; +-- +ok +== +SELECT 'MULTIPOINT(EMPTY, 2 2, EMPTY)'::GEOMETRY::VARCHAR; +-- +ok +== +create table t3(id INT, g GEOMETRY); +-- +ok +== +insert into t3 values + (1, 'POINT Z (1 2 3)'), + (2, 'POINT M (1 2 3)'), + (3, 'POINT ZM (1 2 3 4)'), + (4, 'LINESTRING Z (0 0 0, 1 1 1, 2 2 2)'), + (5, 'LINESTRING M (0 0 0, 1 1 1, 2 2 2)'), + (6, 'LINESTRING ZM (0 0 0 0, 1 1 1 1, 2 2 2 2)'), + (7, 'POLYGON Z ((0 0 0, 4 0 0, 4 4 0, 0 4 0, 0 0 0))'), + (8, 'POLYGON M ((0 0 0, 4 0 0, 4 4 0, 0 4 0, 0 0 0))'), + (9, 'POLYGON ZM ((0 0 0 0, 4 0 0 0, 4 4 0 0, 0 4 0 0, 0 0 0 0))'), + (10, 'MULTIPOINT Z ((1 1 1), (2 2 2), (3 3 3))'), + (11, 'MULTIPOINT M ((1 1 1), (2 2 2), (3 3 3))'), + (12, 'MULTIPOINT ZM ((1 1 1 1), (2 2 2 2), (3 3 3 3))'), + (13, 'MULTILINESTRING Z ((0 0 0, 1 1 1), (2 2 2, 3 3 3))'), + (14, 'MULTILINESTRING M ((0 0 0, 1 1 1), (2 2 2, 3 3 3))'), + (15, 'MULTILINESTRING ZM ((0 0 0 0, 1 1 1 1), (2 2 2 2, 3 3 3 3))'), + (16, 'MULTIPOLYGON Z (((0 0 0,4 0 0,4 4 0,0 4 0,0 0 0)),((5 5 5,7 5 5,7 7 5,5 7 5,5 5 5)))'), + (17, 'MULTIPOLYGON M (((0 0 0,4 0 0,4 4 0,0 4 0,0 0 0)),((5 5 5,7 5 5,7 7 5,5 7 5,5 5 5)))'), + (18, 'MULTIPOLYGON ZM (((0 0 0 0,4 0 0 0,4 4 0 0,0 4 0 0,0 0 0 0)),((5 5 5 5,7 5 5 5,7 7 5 5,5 7 5 5,5 5 5 5)))'), + (19, 'GEOMETRYCOLLECTION Z (POINT Z (1 1 1), LINESTRING Z (0 0 0, 1 1 1))'), + (20, 'GEOMETRYCOLLECTION M (POINT M (1 1 1), LINESTRING M (0 0 0, 1 1 1))'), + (21, 'GEOMETRYCOLLECTION ZM (POINT ZM (1 1 1 1), LINESTRING ZM (0 0 0 0, 1 1 1 1))'); +-- +ok +== +select id, g::VARCHAR from t3 order by id; +-- +ok +== +select 'GEOMETRYCOLLECTION Z (POINT Z (1 1 2), LINESTRING (0 0, 1 1))'::GEOMETRY; +-- +ok +== +SELECT 'POINT(1e20 1e-10)'::GEOMETRY::VARCHAR; +-- +ok +== +SELECT 'POINT(5e30 3e-20)'::GEOMETRY::VARCHAR; +-- +ok +== +SELECT 'POINT(4.56e20 1.23e-10)'::GEOMETRY::VARCHAR; +-- +ok +== +SELECT ('POINT(1e20 1e-10)'::GEOMETRY::VARCHAR)::GEOMETRY::VARCHAR; +-- +ok +== +SELECT ' POINT(1 2)'::GEOMETRY::VARCHAR; +-- +ok +== +SELECT 'POINT(1 2) '::GEOMETRY::VARCHAR; +-- +ok +== +SELECT 'POINT(1 2) garbage'::GEOMETRY::VARCHAR; +-- +ok +== +SELECT TRY_CAST('POINT(1 2) garbage' AS GEOMETRY); +-- +ok +== +SELECT 'SRID=4326;POINT(1 2)'::GEOMETRY::VARCHAR; +-- +ok +== +SELECT 'MULTIPOINT((1 2), EMPTY, (3 4))'::GEOMETRY::VARCHAR; +-- +ok +== +SELECT 'MULTILINESTRING((0 0, 1 1), EMPTY, (2 2, 3 3))'::GEOMETRY::VARCHAR; +-- +ok +== +SELECT 'MULTIPOLYGON(((0 0, 4 0, 4 4, 0 4, 0 0)), EMPTY, ((5 5, 7 5, 7 7, 5 7, 5 5)))'::GEOMETRY::VARCHAR; +-- +ok +== diff --git a/parser/testdata/corpus/sql/types/geo/geometry_compatability.test b/parser/testdata/corpus/sql/types/geo/geometry_compatability.test new file mode 100644 index 0000000..c35a4ce --- /dev/null +++ b/parser/testdata/corpus/sql/types/geo/geometry_compatability.test @@ -0,0 +1,61 @@ +# source: test/sql/types/geo/geometry_compatability.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +copy (select content from read_blob('{DATA_DIR}/storage/spatial_geo.db')) to '{TEST_DIR}/geo.db' (format BLOB); +-- +ok +== +ATTACH '{TEST_DIR}/geo.db' +-- +ok +== +USE geo; +-- +ok +== +select tags.storage_version from duckdb_databases() where database_name = 'geo'; +-- +ok +== +select * from t_all_types order by id; +-- +ok +== +select stats(g) from t_all_types limit 1 +-- +ok +== +EXPLAIN ANALYZE SELECT id from t_all_types where g = 'MULTIPOINT Z (1 2 3, 3 4 5, 5 6 7)'; +-- +ok +== +SELECT id from t_all_types where g = 'MULTIPOINT Z (1 2 3, 3 4 5, 5 6 7)'; +-- +ok +== +INSERT INTO t_all_types VALUES (29, 'POINT (1 2)'); +-- +ok +== +INSERT INTO t_all_types VALUES (29, 'POINT (2 3)'); +-- +ok +== +select id, g from t_all_types where id = 29; +-- +ok +== +DETACH geo; +-- +ok +== +ATTACH '{TEST_DIR}/geo.db' (STORAGE_VERSION 'v1.5.0'); +-- +ok +== +INSERT INTO t_all_types VALUES (30, 'POINT (4 4)'); +-- +ok +== diff --git a/parser/testdata/corpus/sql/types/geo/geometry_crs.test b/parser/testdata/corpus/sql/types/geo/geometry_crs.test new file mode 100644 index 0000000..43f1edb --- /dev/null +++ b/parser/testdata/corpus/sql/types/geo/geometry_crs.test @@ -0,0 +1,69 @@ +# source: test/sql/types/geo/geometry_crs.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +select st_crs(NULL); +-- +ok +== +select st_crs('foobar'); +-- +ok +== +select st_crs(1); +-- +ok +== +select st_crs(st_setcrs('POINT(0 1)', 'OGC:CRS84')); +-- +ok +== +create table t1 (g GEOMETRY('OGC:CRS84')); +-- +ok +== +create table t2 (g GEOMETRY('OGC:CRS83')); +-- +ok +== +insert into t2 values ('POINT(0 1)'); +-- +ok +== +insert into t1 select * from t2; +-- +ok +== +insert into t2 select st_setcrs(g, '') from t1; +-- +ok +== +select * from t2; +-- +ok +== +select st_crs(g) from t2; +-- +ok +== +select 'POINT(0 1)'::GEOMETRY((['abc'])); +-- +error: Parser Error: Expected a constant as type modifier +== +select 'POINT(0 1)'::GEOMETRY(4326); +-- +ok +== +create table t3 (srid VARCHAR, g GEOMETRY); +-- +ok +== +insert into t3 values ('EPSG:4326', 'POINT(0 1)'); +-- +ok +== +select st_setcrs(g, srid) from t3; +-- +ok +== diff --git a/parser/testdata/corpus/sql/types/geo/geometry_crs.test.metadata.json b/parser/testdata/corpus/sql/types/geo/geometry_crs.test.metadata.json new file mode 100644 index 0000000..7f718c4 --- /dev/null +++ b/parser/testdata/corpus/sql/types/geo/geometry_crs.test.metadata.json @@ -0,0 +1,5 @@ +{ + "todo": { + "38b254ab655e2b4d": "transformer-raised parser error: upstream rejects in the transformer, not the grammar; expected to clear as transformers land (milestones 3-5)" + } +} diff --git a/parser/testdata/corpus/sql/types/geo/geometry_crs_projjson.test b/parser/testdata/corpus/sql/types/geo/geometry_crs_projjson.test new file mode 100644 index 0000000..24c3171 --- /dev/null +++ b/parser/testdata/corpus/sql/types/geo/geometry_crs_projjson.test @@ -0,0 +1,115 @@ +# source: test/sql/types/geo/geometry_crs_projjson.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +select typeof('POINT(0 1)'::GEOMETRY(' +{ + "$schema": "https://proj.org/schemas/v0.7/projjson.schema.json", + "type": "GeographicCRS", + "name": "WGS 84 (CRS84)", + "datum_ensemble": { + "name": "World Geodetic System 1984 ensemble", + "members": [ + { + "name": "World Geodetic System 1984 (Transit)", + "id": { + "authority": "EPSG", + "code": 1166 + } + }, + { + "name": "World Geodetic System 1984 (G730)", + "id": { + "authority": "EPSG", + "code": 1152 + } + }, + { + "name": "World Geodetic System 1984 (G873)", + "id": { + "authority": "EPSG", + "code": 1153 + } + }, + { + "name": "World Geodetic System 1984 (G1150)", + "id": { + "authority": "EPSG", + "code": 1154 + } + }, + { + "name": "World Geodetic System 1984 (G1674)", + "id": { + "authority": "EPSG", + "code": 1155 + } + }, + { + "name": "World Geodetic System 1984 (G1762)", + "id": { + "authority": "EPSG", + "code": 1156 + } + }, + { + "name": "World Geodetic System 1984 (G2139)", + "id": { + "authority": "EPSG", + "code": 1309 + } + }, + { + "name": "World Geodetic System 1984 (G2296)", + "id": { + "authority": "EPSG", + "code": 1383 + } + } + ], + "ellipsoid": { + "name": "WGS 84", + "semi_major_axis": 6378137, + "inverse_flattening": 298.257223563 + }, + "accuracy": "2.0", + "id": { + "authority": "EPSG", + "code": 6326 + } + }, + "coordinate_system": { + "subtype": "ellipsoidal", + "axis": [ + { + "name": "Geodetic longitude", + "abbreviation": "Lon", + "direction": "east", + "unit": "degree" + }, + { + "name": "Geodetic latitude", + "abbreviation": "Lat", + "direction": "north", + "unit": "degree" + } + ] + }, + "scope": "Not known.", + "area": "World.", + "bbox": { + "south_latitude": -90, + "west_longitude": -180, + "north_latitude": 90, + "east_longitude": 180 + }, + "id": { + "authority": "OGC", + "code": "CRS84" + } +} +')); +-- +ok +== diff --git a/parser/testdata/corpus/sql/types/geo/geometry_crs_wkt2.test b/parser/testdata/corpus/sql/types/geo/geometry_crs_wkt2.test new file mode 100644 index 0000000..52ccc94 --- /dev/null +++ b/parser/testdata/corpus/sql/types/geo/geometry_crs_wkt2.test @@ -0,0 +1,40 @@ +# source: test/sql/types/geo/geometry_crs_wkt2.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +select typeof('POINT(0 1)'::GEOMETRY('GEOGCRS["WGS 84 (CRS84)", + ENSEMBLE["World Geodetic System 1984 ensemble", + MEMBER["World Geodetic System 1984 (Transit)"], + MEMBER["World Geodetic System 1984 (G730)"], + MEMBER["World Geodetic System 1984 (G873)"], + MEMBER["World Geodetic System 1984 (G1150)"], + MEMBER["World Geodetic System 1984 (G1674)"], + MEMBER["World Geodetic System 1984 (G1762)"], + MEMBER["World Geodetic System 1984 (G2139)"], + MEMBER["World Geodetic System 1984 (G2296)"], + ELLIPSOID["WGS 84",6378137,298.257223563, + LENGTHUNIT["metre",1]], + ENSEMBLEACCURACY[2.0]], + PRIMEM["Greenwich",0, + ANGLEUNIT["degree",0.0174532925199433]], + CS[ellipsoidal,2], + AXIS["geodetic longitude (Lon)",east, + ORDER[1], + ANGLEUNIT["degree",0.0174532925199433]], + AXIS["geodetic latitude (Lat)",north, + ORDER[2], + ANGLEUNIT["degree",0.0174532925199433]], + USAGE[ + SCOPE["Not known."], + AREA["World."], + BBOX[-90,-180,90,180]], + ID["OGC","CRS84"]] +')); +-- +ok +== +select typeof('POINT(0 1)'::GEOMETRY('GEOGCRS["WGS 84",foo[]')); +-- +ok +== diff --git a/parser/testdata/corpus/sql/types/geo/geometry_from_wkb_stats.test b/parser/testdata/corpus/sql/types/geo/geometry_from_wkb_stats.test new file mode 100644 index 0000000..87c4c22 --- /dev/null +++ b/parser/testdata/corpus/sql/types/geo/geometry_from_wkb_stats.test @@ -0,0 +1,168 @@ +# source: test/sql/types/geo/geometry_from_wkb_stats.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +CREATE TABLE lines_wkb(wkb BLOB); +-- +ok +== +INSERT INTO lines_wkb SELECT ST_AsWKB(g) +FROM (VALUES ('LINESTRING(0 0, 1 1)'::GEOMETRY), ('LINESTRING(2 2, 3 3)'::GEOMETRY)) t(g); +-- +ok +== +SELECT stats(vertex_extract(ST_GeomFromWKB(wkb), 'x')) FROM lines_wkb LIMIT 1; +-- +ok +== +CREATE TABLE poly_wkb(wkb BLOB); +-- +ok +== +INSERT INTO poly_wkb SELECT ST_AsWKB('POLYGON((0 0, 1 0, 1 1, 0 0))'::GEOMETRY); +-- +ok +== +SELECT stats(vertex_extract(ST_GeomFromWKB(wkb), 'x')) FROM poly_wkb LIMIT 1; +-- +ok +== +CREATE TABLE pts_wkb(wkb BLOB); +-- +ok +== +INSERT INTO pts_wkb SELECT ST_AsWKB(g) +FROM (VALUES ('POINT(1 2)'::GEOMETRY), ('POINT(5 8)'::GEOMETRY)) t(g); +-- +ok +== +SELECT stats(vertex_extract(ST_GeomFromWKB(wkb), 'x')) FROM pts_wkb LIMIT 1; +-- +ok +== +SELECT stats(vertex_extract(ST_GeomFromWKB(wkb), 'z')) FROM pts_wkb LIMIT 1; +-- +ok +== +CREATE TABLE pts_z_wkb(wkb BLOB); +-- +ok +== +INSERT INTO pts_z_wkb SELECT ST_AsWKB(g) +FROM (VALUES ('POINT Z (1 2 3)'::GEOMETRY), ('POINT Z (5 8 9)'::GEOMETRY)) t(g); +-- +ok +== +SELECT stats(vertex_extract(ST_GeomFromWKB(wkb), 'z')) FROM pts_z_wkb LIMIT 1; +-- +ok +== +CREATE TABLE mixed_wkb(wkb BLOB); +-- +ok +== +INSERT INTO mixed_wkb SELECT ST_AsWKB(g) +FROM (VALUES ('POINT(1 2)'::GEOMETRY), ('LINESTRING(0 0, 1 1)'::GEOMETRY)) t(g); +-- +ok +== +SELECT stats(vertex_extract(ST_GeomFromWKB(wkb), 'x')) FROM mixed_wkb LIMIT 1; +-- +ok +== +CREATE TABLE be_lines_wkb(wkb BLOB); +-- +ok +== +INSERT INTO be_lines_wkb VALUES + ('\x00\x00\x00\x00\x02\x00\x00\x00\x02\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x3F\xF0\x00\x00\x00\x00\x00\x00\x3F\xF0\x00\x00\x00\x00\x00\x00'::BLOB); +-- +ok +== +SELECT ST_AsText(ST_GeomFromWKB(wkb)) FROM be_lines_wkb; +-- +ok +== +SELECT stats(vertex_extract(ST_GeomFromWKB(wkb), 'x')) FROM be_lines_wkb LIMIT 1; +-- +ok +== +CREATE TABLE bad_wkb(wkb BLOB); +-- +ok +== +INSERT INTO bad_wkb VALUES ('\x01\x02\x00\x00\x00'::BLOB); +-- +ok +== +SELECT vertex_extract(ST_GeomFromWKB(wkb), 'x') FROM bad_wkb; +-- +ok +== +CREATE TABLE empty_ls_wkb(wkb BLOB); +-- +ok +== +INSERT INTO empty_ls_wkb VALUES ('\x01\x02\x00\x00\x00\x00\x00\x00\x00'::BLOB); +-- +ok +== +SELECT stats(vertex_extract(ST_GeomFromWKB(wkb), 'x')) FROM empty_ls_wkb LIMIT 1; +-- +ok +== +CREATE TABLE interior_trunc_wkb(wkb BLOB); +-- +ok +== +INSERT INTO interior_trunc_wkb SELECT ST_AsWKB('LINESTRING(0 0, 1 1)'::GEOMETRY); +-- +ok +== +INSERT INTO interior_trunc_wkb VALUES ('\x01\x02\x00\x00\x00\x05'::BLOB); +-- +ok +== +SELECT vertex_extract(ST_GeomFromWKB(wkb), 'x') FROM interior_trunc_wkb; +-- +ok +== +CREATE TABLE ewkb_point_z(wkb BLOB); +-- +ok +== +INSERT INTO ewkb_point_z VALUES + ('\x01\x01\x00\x00\x80\x00\x00\x00\x00\x00\x00\xF0\x3F\x00\x00\x00\x00\x00\x00\x00\x40\x00\x00\x00\x00\x00\x00\x08\x40'::BLOB); +-- +ok +== +SELECT ST_AsText(ST_GeomFromWKB(wkb)) FROM ewkb_point_z; +-- +ok +== +SELECT vertex_extract(ST_GeomFromWKB(wkb), 'z') FROM ewkb_point_z; +-- +ok +== +CREATE TABLE ewkb_point_m(wkb BLOB); +-- +ok +== +INSERT INTO ewkb_point_m VALUES + ('\x01\x01\x00\x00\x40\x00\x00\x00\x00\x00\x00\xF0\x3F\x00\x00\x00\x00\x00\x00\x00\x40\x00\x00\x00\x00\x00\x00\x10\x40'::BLOB); +-- +ok +== +SELECT ST_AsText(ST_GeomFromWKB(wkb)) FROM ewkb_point_m; +-- +ok +== +SELECT vertex_extract(ST_GeomFromWKB(wkb), 'm') FROM ewkb_point_m; +-- +ok +== +SELECT stats(vertex_extract(ST_GeomFromWKB(wkb), 'z')) FROM ewkb_point_m LIMIT 1; +-- +ok +== diff --git a/parser/testdata/corpus/sql/types/geo/geometry_intersection_filter_parquet.test b/parser/testdata/corpus/sql/types/geo/geometry_intersection_filter_parquet.test new file mode 100644 index 0000000..863c25a --- /dev/null +++ b/parser/testdata/corpus/sql/types/geo/geometry_intersection_filter_parquet.test @@ -0,0 +1,38 @@ +# source: test/sql/types/geo/geometry_intersection_filter_parquet.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +COPY ( + select + (x + y * 1000) as id, + printf('POINT(%d %d)', x, y)::GEOMETRY as g + from range(1000) xx(x), range(10) yy(y) +) TO '{TEST_DIR}/points.parquet' (FORMAT 'parquet', GEOPARQUET_VERSION 'NONE', ROW_GROUP_SIZE 1000); +-- +ok +== +explain select * from '{TEST_DIR}/points.parquet' where g && 'POLYGON((0 0, 100 0, 100 100, 0 100, 0 0))'; +-- +ok +== +select * from '{TEST_DIR}/points.parquet' where g && 'POLYGON((0 0, 100 0, 100 100, 0 100, 0 0))' order by id; +-- +ok +== +set disabled_optimizers = 'filter_pushdown'; +-- +ok +== +set disabled_optimizers = ''; +-- +ok +== +explain select * from '{TEST_DIR}/points.parquet' where g && 'POLYGON((0 0, 2000 0, 2000 2000, 0 2000, 0 0))'; +-- +ok +== +explain select * from '{TEST_DIR}/points.parquet' where g && 'POLYGON((5000 5000, 10000 5000, 10000 10000, 5000 10000, 5000 5000))'; +-- +ok +== diff --git a/parser/testdata/corpus/sql/types/geo/geometry_intersects.test b/parser/testdata/corpus/sql/types/geo/geometry_intersects.test new file mode 100644 index 0000000..16f827b --- /dev/null +++ b/parser/testdata/corpus/sql/types/geo/geometry_intersects.test @@ -0,0 +1,21 @@ +# source: test/sql/types/geo/geometry_intersects.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +select 'POINT(0 1)'::GEOMETRY && 'POINT(0 0)'::GEOMETRY; +-- +ok +== +select 'POINT(0 1)'::GEOMETRY && 'POINT(0 1)'::GEOMETRY; +-- +ok +== +select 'POINT Z(0 1 2)'::GEOMETRY && 'POINT Z(0 1 3)'::GEOMETRY; +-- +ok +== +select 'POINT(0 1)'::GEOMETRY && 'LINESTRING Z(0 0 1, 0 2 2, 2 2 3)'::GEOMETRY; +-- +ok +== diff --git a/parser/testdata/corpus/sql/types/geo/geometry_legacy_recheckpoint.test b/parser/testdata/corpus/sql/types/geo/geometry_legacy_recheckpoint.test new file mode 100644 index 0000000..9911b5a --- /dev/null +++ b/parser/testdata/corpus/sql/types/geo/geometry_legacy_recheckpoint.test @@ -0,0 +1,29 @@ +# source: test/sql/types/geo/geometry_legacy_recheckpoint.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +attach '{TEST_DIR}/geometry_legacy_recheckpoint.db' AS db (STORAGE_VERSION 'v1.4.4'); +-- +ok +== +CREATE TABLE db.t1 AS SELECT i, ('POINT(' || i || ' ' || i || ')')::GEOMETRY AS geom FROM range(1000) tbl(i); +-- +ok +== +DELETE FROM db.t1 WHERE i = 5; +-- +ok +== +SELECT count(*), count(geom) FROM db.t1; +-- +ok +== +ATTACH '{TEST_DIR}/geometry_legacy_recheckpoint.db' AS db; +-- +ok +== +SELECT geom FROM db.t1 WHERE i = 4; +-- +ok +== diff --git a/parser/testdata/corpus/sql/types/geo/geometry_nonascii_cast.test b/parser/testdata/corpus/sql/types/geo/geometry_nonascii_cast.test new file mode 100644 index 0000000..48720a6 --- /dev/null +++ b/parser/testdata/corpus/sql/types/geo/geometry_nonascii_cast.test @@ -0,0 +1,21 @@ +# source: test/sql/types/geo/geometry_nonascii_cast.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +select 'pä int(0 1)'::GEOMETRY +-- +ok +== +select 'ä POINT(0 1)'::GEOMETRY +-- +ok +== +select 'POINT(0 1)'::GEOMETRY::VARCHAR +-- +ok +== +select ST_SetCRS('POINT(0 1)'::GEOMETRY, 'GEäDCRS') +-- +ok +== diff --git a/parser/testdata/corpus/sql/types/geo/geometry_parquet_pushdown.test b/parser/testdata/corpus/sql/types/geo/geometry_parquet_pushdown.test new file mode 100644 index 0000000..b5eeee9 --- /dev/null +++ b/parser/testdata/corpus/sql/types/geo/geometry_parquet_pushdown.test @@ -0,0 +1,35 @@ +# source: test/sql/types/geo/geometry_parquet_pushdown.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +COPY ( + select + (x + y) as id, + printf('POINT(%d %d)', x, y)::GEOMETRY('OGC:CRS84') as g + from range(100) xx(x), range(100) yy(y) +) TO '{TEST_DIR}/points.parquet' (FORMAT 'parquet', GEOPARQUET_VERSION 'V2', ROW_GROUP_SIZE 1000); +-- +ok +== +PRAGMA profiling_output = '{TEST_DIR}/output.json'; +-- +error: Parser Error: Profiler file type ({TEST_DIR}/output.json) must either have the same file extension as the profiling output type (query_tree), or be a '.txt' file. Set "enable_profiling = 'json'" first. +== +SET tracked_metrics = ['operator.type', 'operator.row_groups_scanned', 'operator.total_row_groups_to_scan']; +-- +ok +== +select * from '{TEST_DIR}/points.parquet' where g && 'POLYGON((10 10, 20 10, 20 20, 10 20, 10 10))'::GEOMETRY; +-- +ok +== +SELECT t.row_groups_scanned +FROM '{TEST_DIR}/output.json' prof, + LATERAL unnest(prof.operator) t0(op0), + LATERAL unnest(op0.children) t1(op1), + LATERAL unnest(op1.children) t2(t) +WHERE t.type = 'TABLE_SCAN'; +-- +ok +== diff --git a/parser/testdata/corpus/sql/types/geo/geometry_parquet_pushdown.test.metadata.json b/parser/testdata/corpus/sql/types/geo/geometry_parquet_pushdown.test.metadata.json new file mode 100644 index 0000000..08129c1 --- /dev/null +++ b/parser/testdata/corpus/sql/types/geo/geometry_parquet_pushdown.test.metadata.json @@ -0,0 +1,5 @@ +{ + "todo": { + "6d655e14266461ae": "transformer-raised parser error: upstream rejects in the transformer, not the grammar; expected to clear as transformers land (milestones 3-5)" + } +} diff --git a/parser/testdata/corpus/sql/types/geo/geometry_persist.test b/parser/testdata/corpus/sql/types/geo/geometry_persist.test new file mode 100644 index 0000000..bd28f9b --- /dev/null +++ b/parser/testdata/corpus/sql/types/geo/geometry_persist.test @@ -0,0 +1,13 @@ +# source: test/sql/types/geo/geometry_persist.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +create table t1(g GEOMETRY); +-- +ok +== +INSERT INTO t1 VALUES ('POINT(1 2)'::GEOMETRY); +-- +ok +== diff --git a/parser/testdata/corpus/sql/types/geo/geometry_persist_wal.test b/parser/testdata/corpus/sql/types/geo/geometry_persist_wal.test new file mode 100644 index 0000000..36ec320 --- /dev/null +++ b/parser/testdata/corpus/sql/types/geo/geometry_persist_wal.test @@ -0,0 +1,29 @@ +# source: test/sql/types/geo/geometry_persist_wal.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +ATTACH '{TEST_DIR}/geometry_wal.db' AS geo_wal (STORAGE_VERSION 'v1.5.0') +-- +ok +== +create table geo_wal.t1(g GEOMETRY); +-- +ok +== +INSERT INTO geo_wal.t1 VALUES ('POINT(1 2)'::GEOMETRY); +-- +ok +== +select * from geo_wal.t1; +-- +ok +== +DETACH geo_wal +-- +ok +== +ATTACH '{TEST_DIR}/geometry_wal.db' AS geo_wal +-- +ok +== diff --git a/parser/testdata/corpus/sql/types/geo/geometry_shred.test b/parser/testdata/corpus/sql/types/geo/geometry_shred.test new file mode 100644 index 0000000..14f66ad --- /dev/null +++ b/parser/testdata/corpus/sql/types/geo/geometry_shred.test @@ -0,0 +1,25 @@ +# source: test/sql/types/geo/geometry_shred.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +SET geometry_minimum_shredding_size = 0; +-- +ok +== +select distinct segment_type from pragma_storage_info('t1') order by all; +-- +ok +== +select stats(g) from t1; +-- +ok +== +SELECT ST_AsText(g) FROM t1; +-- +ok +== +INSERT INTO t1 VALUES ('LINESTRING(0 0, 1 1)'::GEOMETRY); +-- +ok +== diff --git a/parser/testdata/corpus/sql/types/geo/geometry_shred_deletes.test b/parser/testdata/corpus/sql/types/geo/geometry_shred_deletes.test new file mode 100644 index 0000000..29e66a1 --- /dev/null +++ b/parser/testdata/corpus/sql/types/geo/geometry_shred_deletes.test @@ -0,0 +1,21 @@ +# source: test/sql/types/geo/geometry_shred_deletes.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +set checkpoint_threshold='10gb' +-- +ok +== +CREATE TABLE t1(geom GEOMETRY); +-- +ok +== +INSERT INTO t1 SELECT 'POINT(1 2)'::GEOMETRY FROM range(3); +-- +ok +== +DELETE FROM t1 WHERE rowid = 0; +-- +ok +== diff --git a/parser/testdata/corpus/sql/types/geo/geometry_shred_empty.test b/parser/testdata/corpus/sql/types/geo/geometry_shred_empty.test new file mode 100644 index 0000000..fdb61b7 --- /dev/null +++ b/parser/testdata/corpus/sql/types/geo/geometry_shred_empty.test @@ -0,0 +1,52 @@ +# source: test/sql/types/geo/geometry_shred_empty.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +CREATE TABLE t1(type VARCHAR, has_z BOOLEAN, has_m BOOLEAN, g GEOMETRY); +-- +ok +== +insert into t1 values + ('POINT', FALSE, FALSE, 'POINT EMPTY'::GEOMETRY), + ('POINT', TRUE, FALSE, 'POINT Z EMPTY'::GEOMETRY), + ('POINT', FALSE, TRUE, 'POINT M EMPTY'::GEOMETRY), + ('POINT', TRUE, TRUE, 'POINT ZM EMPTY'::GEOMETRY), + ('LINESTRING', FALSE, FALSE, 'LINESTRING EMPTY'::GEOMETRY), + ('LINESTRING', TRUE, FALSE, 'LINESTRING Z EMPTY'::GEOMETRY), + ('LINESTRING', FALSE, TRUE, 'LINESTRING M EMPTY'::GEOMETRY), + ('LINESTRING', TRUE, TRUE, 'LINESTRING ZM EMPTY'::GEOMETRY), + ('POLYGON', FALSE, FALSE, 'POLYGON EMPTY'::GEOMETRY), + ('POLYGON', TRUE, FALSE, 'POLYGON Z EMPTY'::GEOMETRY), + ('POLYGON', FALSE, TRUE, 'POLYGON M EMPTY'::GEOMETRY), + ('POLYGON', TRUE, TRUE, 'POLYGON ZM EMPTY'::GEOMETRY), + ('MULTIPOINT', TRUE, FALSE, 'MULTIPOINT Z EMPTY'::GEOMETRY), + ('MULTIPOINT', FALSE, TRUE, 'MULTIPOINT M EMPTY'::GEOMETRY), + ('MULTIPOINT', TRUE, TRUE, 'MULTIPOINT ZM EMPTY'::GEOMETRY), + ('MULTIPOINT', FALSE, FALSE, 'MULTIPOINT ((1 2), (EMPTY))'::GEOMETRY), + ('MULTIPOINT', TRUE, FALSE, 'MULTIPOINT Z ((1 2 3), (EMPTY))'::GEOMETRY), + ('MULTIPOINT', FALSE, TRUE, 'MULTIPOINT M ((1 2 3), (EMPTY))'::GEOMETRY), + ('MULTIPOINT', TRUE, TRUE, 'MULTIPOINT ZM ((1 2 3 4), (EMPTY))'::GEOMETRY), + ('MULTILINESTRING', FALSE, FALSE, 'MULTILINESTRING EMPTY'::GEOMETRY), + ('MULTILINESTRING', TRUE, FALSE, 'MULTILINESTRING Z EMPTY'::GEOMETRY), + ('MULTILINESTRING', FALSE, TRUE, 'MULTILINESTRING M EMPTY'::GEOMETRY), + ('MULTILINESTRING', TRUE, TRUE, 'MULTILINESTRING ZM EMPTY'::GEOMETRY), + ('MULTIPOLYGON', FALSE, FALSE, 'MULTIPOLYGON EMPTY'::GEOMETRY), + ('MULTIPOLYGON', TRUE, FALSE, 'MULTIPOLYGON Z EMPTY'::GEOMETRY), + ('MULTIPOLYGON', FALSE, TRUE, 'MULTIPOLYGON M EMPTY'::GEOMETRY), + ('MULTIPOLYGON', TRUE, TRUE, 'MULTIPOLYGON ZM EMPTY'::GEOMETRY); +-- +ok +== +create table t2 as select g from t1 where type='{type}' and has_z={has_z} and has_m={has_m}; +-- +error: Parser Error: syntax error at or near "}" +== +select segment_type from pragma_storage_info('t2') order by all; +-- +ok +== +select stats(g) from t2; +-- +ok +== diff --git a/parser/testdata/corpus/sql/types/geo/geometry_shred_fetch.test b/parser/testdata/corpus/sql/types/geo/geometry_shred_fetch.test new file mode 100644 index 0000000..0b5d76a --- /dev/null +++ b/parser/testdata/corpus/sql/types/geo/geometry_shred_fetch.test @@ -0,0 +1,25 @@ +# source: test/sql/types/geo/geometry_shred_fetch.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +create table t1(g geometry, id integer); +-- +ok +== +insert into t1 select printf('POINT(%d %d)', i, i)::geometry, i from range(0,3000) as r(i); +-- +ok +== +create index idx_id on t1(id); +-- +ok +== +select g, id from t1 where id = 1500; +-- +ok +== +select g, id from t1 where id < 10 order by id; +-- +ok +== diff --git a/parser/testdata/corpus/sql/types/geo/geometry_shred_limit.test b/parser/testdata/corpus/sql/types/geo/geometry_shred_limit.test new file mode 100644 index 0000000..738d770 --- /dev/null +++ b/parser/testdata/corpus/sql/types/geo/geometry_shred_limit.test @@ -0,0 +1,25 @@ +# source: test/sql/types/geo/geometry_shred_limit.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +SET geometry_minimum_shredding_size = 3; +-- +ok +== +CREATE TABLE t1(g GEOMETRY); +-- +ok +== +INSERT INTO t1 VALUES ('POINT(0 0)'::GEOMETRY); +-- +ok +== +INSERT INTO t1 VALUES ('POINT(1 1)'::GEOMETRY); +-- +ok +== +INSERT INTO t1 VALUES ('POINT(2 2)'::GEOMETRY); +-- +ok +== diff --git a/parser/testdata/corpus/sql/types/geo/geometry_shred_list.test b/parser/testdata/corpus/sql/types/geo/geometry_shred_list.test new file mode 100644 index 0000000..bade743 --- /dev/null +++ b/parser/testdata/corpus/sql/types/geo/geometry_shred_list.test @@ -0,0 +1,21 @@ +# source: test/sql/types/geo/geometry_shred_list.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +create table t1(g geometry[], id integer); +-- +ok +== +insert into t1 select [printf('POINT(%d %d)', i, i)::geometry], i from range(0,3000) as r(i); +-- +ok +== +select g, id from t1 order by id limit 1; +-- +ok +== +select g, id from t1 where id > 200 and id < 2500 order by id desc limit 1 +-- +ok +== diff --git a/parser/testdata/corpus/sql/types/geo/geometry_shred_more.test b/parser/testdata/corpus/sql/types/geo/geometry_shred_more.test new file mode 100644 index 0000000..5b28453 --- /dev/null +++ b/parser/testdata/corpus/sql/types/geo/geometry_shred_more.test @@ -0,0 +1,97 @@ +# source: test/sql/types/geo/geometry_shred_more.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +SET checkpoint_threshold='10gb'; +-- +ok +== +ATTACH '{TEST_DIR}/geocp_{storage_version}_{rgsize}.db' AS db (ROW_GROUP_SIZE {rgsize}, STORAGE_VERSION '{storage_version}'); +-- +error: Parser Error: syntax error at or near "}" +== +SET geometry_minimum_shredding_size=30000; +-- +ok +== +CREATE TABLE pts AS SELECT printf('POINT(%f %f)', a::DOUBLE, a::DOUBLE)::GEOMETRY AS g FROM range(10000) t(a); +-- +ok +== +SELECT count(*) FROM pts; +-- +ok +== +SELECT count(*) FROM pts WHERE g && 'POLYGON((10 10, 10 50, 50 50, 50 10, 10 10))'::GEOMETRY; +-- +ok +== +SELECT count(*) FROM pts WHERE g::VARCHAR = 'POINT (5 5)'; +-- +ok +== +CREATE TABLE mixed AS + SELECT printf('POINT(%f %f)', a::DOUBLE, a::DOUBLE)::GEOMETRY AS g FROM range(5000) t(a) + UNION ALL + SELECT printf('LINESTRING(%f %f, %f %f)', a::DOUBLE, a::DOUBLE, (a + 1)::DOUBLE, (a + 1)::DOUBLE)::GEOMETRY + FROM range(5000) t(a); +-- +ok +== +SELECT count(*) FROM mixed; +-- +ok +== +SELECT count(*) FROM mixed WHERE g && 'POLYGON((10 10, 10 50, 50 50, 50 10, 10 10))'::GEOMETRY; +-- +ok +== +CREATE TABLE withnull AS + SELECT CASE WHEN a % 3 = 0 THEN NULL + WHEN a % 3 = 1 THEN 'POINT EMPTY'::GEOMETRY + ELSE printf('POINT(%f %f)', a::DOUBLE, a::DOUBLE)::GEOMETRY END AS g + FROM range(10000) t(a); +-- +ok +== +SELECT count(g) FROM withnull; +-- +ok +== +INSERT INTO pts SELECT printf('POINT(%f %f)', a::DOUBLE, a::DOUBLE)::GEOMETRY FROM range(10000, 20000) t(a); +-- +ok +== +SET geometry_minimum_shredding_size=512; +-- +ok +== +CREATE TABLE pts_shred AS SELECT printf('POINT(%f %f)', a::DOUBLE, a::DOUBLE)::GEOMETRY AS g FROM range(10000) t(a); +-- +ok +== +SELECT count(*) FROM pts_shred WHERE g && 'POLYGON((10 10, 10 50, 50 50, 50 10, 10 10))'::GEOMETRY; +-- +ok +== +SELECT count(*) FROM pts_shred WHERE g::VARCHAR = 'POINT (5 5)'; +-- +ok +== +SET geometry_minimum_shredding_size=-1; +-- +ok +== +CREATE TABLE pts_noshred AS SELECT printf('POINT(%f %f)', a::DOUBLE, a::DOUBLE)::GEOMETRY AS g FROM range(10000) t(a); +-- +ok +== +SELECT count(*) FROM pts_noshred WHERE g && 'POLYGON((10 10, 10 50, 50 50, 50 10, 10 10))'::GEOMETRY; +-- +ok +== +ATTACH '{TEST_DIR}/geocp_{storage_version}_{rgsize}.db' AS db; +-- +ok +== diff --git a/parser/testdata/corpus/sql/types/geo/geometry_shred_pk_append.test b/parser/testdata/corpus/sql/types/geo/geometry_shred_pk_append.test new file mode 100644 index 0000000..c8f8ff6 --- /dev/null +++ b/parser/testdata/corpus/sql/types/geo/geometry_shred_pk_append.test @@ -0,0 +1,17 @@ +# source: test/sql/types/geo/geometry_shred_pk_append.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +CREATE TABLE t(id UUID PRIMARY KEY, g GEOMETRY); +-- +ok +== +INSERT INTO t VALUES (uuidv7(), 'POINT (0 1)'::GEOMETRY); +-- +ok +== +SELECT COUNT(*) FROM t WHERE g::VARCHAR = 'POINT (0 1)'; +-- +ok +== diff --git a/parser/testdata/corpus/sql/types/geo/geometry_stats.test b/parser/testdata/corpus/sql/types/geo/geometry_stats.test new file mode 100644 index 0000000..7951ec4 --- /dev/null +++ b/parser/testdata/corpus/sql/types/geo/geometry_stats.test @@ -0,0 +1,33 @@ +# source: test/sql/types/geo/geometry_stats.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +insert into t1 values (0, 'POINT(0 0)'::GEOMETRY); +-- +ok +== +select s.extent.x_min, s.extent.x_max, s.extent.y_min, s.extent.y_max, s.has_empty_geom, s.has_non_empty_geom, s.has_empty_part, s.has_non_empty_part, s.has_null, s.has_no_null from (select stats(g) s from t1 limit 1); +-- +ok +== +insert into t1 values (1, 'POINT(-2 2)'::GEOMETRY); +-- +ok +== +insert into t1 values (3, 'POINT(2 -2)'::GEOMETRY); +-- +ok +== +insert into t1 values (4, 'LINESTRING Z (0 0 0, 1 1 1, 2 2 2)'::GEOMETRY); +-- +ok +== +insert into t1 values (5, 'POLYGON M ((0 0 2, 4 0 2, 4 4 2, 0 4 2, 0 0 2))'::GEOMETRY); +-- +ok +== +insert into t1 values (6, 'MULTILINESTRING ZM ((0 0 -10 10, 1 1 -10 10), (2 2 2 1, 3 3 3 1))'::GEOMETRY); +-- +ok +== diff --git a/parser/testdata/corpus/sql/types/geo/geometry_stats_prune.test b/parser/testdata/corpus/sql/types/geo/geometry_stats_prune.test new file mode 100644 index 0000000..d3440b2 --- /dev/null +++ b/parser/testdata/corpus/sql/types/geo/geometry_stats_prune.test @@ -0,0 +1,43 @@ +# source: test/sql/types/geo/geometry_stats_prune.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +ATTACH '{TEST_DIR}/repro_geo_rowgroup.db' AS geoms (ROW_GROUP_SIZE 2048, STORAGE_VERSION 'v1.5.0'); +-- +ok +== +USE geoms; +-- +ok +== +CREATE TABLE geoms AS +SELECT +printf('POLYGON((%f %f, %f %f, %f %f, %f %f, %f %f))', + x, y, + x, y + 0.005, + x + 0.005, y + 0.005, + x + 0.005, y, + x, y +)::GEOMETRY AS geom +FROM ( + SELECT + ((i % 10)::DOUBLE * 0.01) AS x, + (floor(i / 10)::DOUBLE * 0.01) AS y + FROM range(2048) AS t(i) +); +-- +ok +== +SELECT count(*) AS count FROM geoms WHERE geom && 'POLYGON ((0.02 0.02, 0.02 0.05, 0.05 0.05, 0.05 0.02, 0.02 0.02))'::GEOMETRY; +-- +ok +== +DETACH geoms; +-- +ok +== +ATTACH '{TEST_DIR}/repro_geo_rowgroup.db' AS geoms (STORAGE_VERSION 'v1.5.0'); +-- +ok +== diff --git a/parser/testdata/corpus/sql/types/geo/geometry_stats_prune_shredded.test b/parser/testdata/corpus/sql/types/geo/geometry_stats_prune_shredded.test new file mode 100644 index 0000000..d2aa8fd --- /dev/null +++ b/parser/testdata/corpus/sql/types/geo/geometry_stats_prune_shredded.test @@ -0,0 +1,9 @@ +# source: test/sql/types/geo/geometry_stats_prune_shredded.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +set geometry_minimum_shredding_size=0; +-- +ok +== diff --git a/parser/testdata/corpus/sql/types/geo/geometry_storage_version.test b/parser/testdata/corpus/sql/types/geo/geometry_storage_version.test new file mode 100644 index 0000000..a6d1d24 --- /dev/null +++ b/parser/testdata/corpus/sql/types/geo/geometry_storage_version.test @@ -0,0 +1,17 @@ +# source: test/sql/types/geo/geometry_storage_version.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +attach '{TEST_DIR}/geometry.db' (STORAGE_VERSION 'v1.4.4'); +-- +ok +== +use geometry; +-- +ok +== +create table t1 (g STRUCT(a GEOMETRY[])); +-- +ok +== diff --git a/parser/testdata/corpus/sql/types/geo/geometry_update.test b/parser/testdata/corpus/sql/types/geo/geometry_update.test new file mode 100644 index 0000000..a689605 --- /dev/null +++ b/parser/testdata/corpus/sql/types/geo/geometry_update.test @@ -0,0 +1,21 @@ +# source: test/sql/types/geo/geometry_update.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +CREATE TABLE t (id INT, geo GEOMETRY) +-- +ok +== +INSERT INTO t VALUES (1, NULL), (2, 'POINT(1.0 2.0)') +-- +ok +== +UPDATE t SET geo = 'POINT(0 1)' WHERE id = 1; +-- +ok +== +SELECT id, ST_AsText(geo) FROM t ORDER BY id; +-- +ok +== diff --git a/parser/testdata/corpus/sql/types/geo/geometry_vertex_extract.test b/parser/testdata/corpus/sql/types/geo/geometry_vertex_extract.test new file mode 100644 index 0000000..8a2f041 --- /dev/null +++ b/parser/testdata/corpus/sql/types/geo/geometry_vertex_extract.test @@ -0,0 +1,196 @@ +# source: test/sql/types/geo/geometry_vertex_extract.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +SELECT vertex_extract('POINT(1 2)'::GEOMETRY, 'x'); +-- +ok +== +SELECT vertex_extract('POINT(1 2)'::GEOMETRY, 'y'); +-- +ok +== +SELECT vertex_extract('POINT(1 2)'::GEOMETRY, 'X'), vertex_extract('POINT(1 2)'::GEOMETRY, 'Y'); +-- +ok +== +SELECT ('POINT(1 2)'::GEOMETRY).x, ('POINT(1 2)'::GEOMETRY).y +-- +ok +== +SELECT ('POINT(-1.5 2.25)'::GEOMETRY).x, ('POINT(-1.5 2.25)'::GEOMETRY).y +-- +ok +== +SELECT ('POINT Z (1 2 3)'::GEOMETRY).x, ('POINT Z (1 2 3)'::GEOMETRY).y, + ('POINT Z (1 2 3)'::GEOMETRY).z, ('POINT Z (1 2 3)'::GEOMETRY).m +-- +ok +== +SELECT ('POINT M (1 2 4)'::GEOMETRY).x, ('POINT M (1 2 4)'::GEOMETRY).y, + ('POINT M (1 2 4)'::GEOMETRY).z, ('POINT M (1 2 4)'::GEOMETRY).m +-- +ok +== +SELECT ('POINT ZM (1 2 3 4)'::GEOMETRY).x, ('POINT ZM (1 2 3 4)'::GEOMETRY).y, + ('POINT ZM (1 2 3 4)'::GEOMETRY).z, ('POINT ZM (1 2 3 4)'::GEOMETRY).m +-- +ok +== +SELECT ('POINT(1 2)'::GEOMETRY).z, ('POINT(1 2)'::GEOMETRY).m +-- +ok +== +SELECT ('LINESTRING(0 0, 1 1)'::GEOMETRY).x +-- +ok +== +SELECT ('POLYGON((0 0, 1 0, 1 1, 0 0))'::GEOMETRY).x +-- +ok +== +SELECT ('MULTIPOINT(1 2, 3 4)'::GEOMETRY).x +-- +ok +== +SELECT ('GEOMETRYCOLLECTION(POINT(1 2))'::GEOMETRY).x +-- +ok +== +SELECT ('POINT EMPTY'::GEOMETRY).x, ('POINT EMPTY'::GEOMETRY).y, + ('POINT EMPTY'::GEOMETRY).z, ('POINT EMPTY'::GEOMETRY).m +-- +ok +== +SELECT (NULL::GEOMETRY).x +-- +ok +== +CREATE TABLE geometries(id INTEGER, geom GEOMETRY); +-- +ok +== +INSERT INTO geometries VALUES + (1, 'POINT(1 2)'), + (2, 'POINT Z (3 4 5)'), + (3, 'POINT M (6 7 8)'), + (4, 'POINT ZM (9 10 11 12)'), + (5, 'POINT EMPTY'), + (6, 'LINESTRING(0 0, 1 1)'), + (7, NULL); +-- +ok +== +SELECT id, geom.x, geom.y, geom.z, geom.m FROM geometries ORDER BY id; +-- +ok +== +SELECT vertex_extract('POINT(1 2)'::GEOMETRY, 'w'); +-- +ok +== +SELECT vertex_extract('POINT(1 2)'::GEOMETRY, NULL::VARCHAR); +-- +ok +== +SELECT geom.x, vertex_extract(geom, ord) FROM (SELECT 'POINT(1 2)'::GEOMETRY AS geom, 'x' AS ord); +-- +ok +== +CREATE TABLE pts(geom GEOMETRY); +-- +ok +== +INSERT INTO pts VALUES ('POINT(1 2)'), ('POINT(5 8)'), ('POINT(-3 4)'); +-- +ok +== +SELECT stats(geom.x) FROM pts LIMIT 1; +-- +ok +== +SELECT stats(geom.y) FROM pts LIMIT 1; +-- +ok +== +SELECT stats(geom.z) FROM pts LIMIT 1; +-- +ok +== +CREATE TABLE pts_zm(geom GEOMETRY); +-- +ok +== +INSERT INTO pts_zm VALUES ('POINT ZM (1 2 3 4)'), ('POINT ZM (5 6 7 8)'); +-- +ok +== +SELECT stats(geom.z) FROM pts_zm LIMIT 1; +-- +ok +== +SELECT stats(geom.m) FROM pts_zm LIMIT 1; +-- +ok +== +CREATE TABLE pts_mixed_dim(geom GEOMETRY); +-- +ok +== +INSERT INTO pts_mixed_dim VALUES ('POINT(1 2)'), ('POINT M (3 4 9)'); +-- +ok +== +SELECT stats(geom.m) FROM pts_mixed_dim LIMIT 1; +-- +ok +== +CREATE TABLE pts_and_lines(geom GEOMETRY); +-- +ok +== +INSERT INTO pts_and_lines VALUES ('POINT(1 2)'), ('LINESTRING(0 0, 10 10)'); +-- +ok +== +SELECT stats(geom.x) FROM pts_and_lines LIMIT 1; +-- +ok +== +CREATE TABLE pts_2d_only(geom GEOMETRY); +-- +ok +== +INSERT INTO pts_2d_only VALUES ('POINT(1 2)'), ('POINT(5 8)'); +-- +ok +== +SELECT stats(geom.x) FROM pts_2d_only LIMIT 1; +-- +ok +== +CREATE TABLE lines_only(geom GEOMETRY); +-- +ok +== +INSERT INTO lines_only VALUES ('LINESTRING(0 0, 1 1)'), ('LINESTRING(2 2, 3 3)'); +-- +ok +== +SELECT stats(geom.x) FROM lines_only LIMIT 1; +-- +ok +== +CREATE TABLE empty_pts(geom GEOMETRY); +-- +ok +== +INSERT INTO empty_pts VALUES ('POINT EMPTY'), ('POINT EMPTY'); +-- +ok +== +SELECT stats(geom.x) FROM empty_pts LIMIT 1; +-- +ok +== diff --git a/parser/testdata/corpus/sql/types/geo/geometry_wkb.test b/parser/testdata/corpus/sql/types/geo/geometry_wkb.test new file mode 100644 index 0000000..c8330e9 --- /dev/null +++ b/parser/testdata/corpus/sql/types/geo/geometry_wkb.test @@ -0,0 +1,197 @@ +# source: test/sql/types/geo/geometry_wkb.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +insert into t1 values + (1, 'POINT(0 1)'), + (2, 'LINESTRING(0 0, 1 1, 2 2)'), + (3, 'POLYGON((0 0, 4 0, 4 4, 0 4, 0 0))'), + (4, 'MULTIPOINT((1 1), (2 2), (3 3))'), + (5, 'MULTILINESTRING((0 0, 1 1), (2 2, 3 3))'), + (6, 'MULTIPOLYGON(((0 0, 4 0, 4 4, 0 4, 0 0)), ((5 5, 7 5, 7 7, 5 7, 5 5)))'), + (7, 'GEOMETRYCOLLECTION(POINT(1 1), LINESTRING(0 0, 1 1))'), + (8, NULL); +-- +ok +== +select id, ST_AsText(ST_GeomFromWKB(ST_AsWKB(g))) from t1 order by id; +-- +ok +== +create table t_all_types(id INT, g GEOMETRY); +-- +ok +== +insert into t_all_types values + (1, 'POINT (1 2)'), + (2, 'POINT Z (1 2 3)'), + (3, 'POINT M (1 2 4)'), + (4, 'POINT ZM (1 2 3 4)'), + (5, 'LINESTRING (1 2, 3 4)'), + (6, 'LINESTRING Z (1 2 3, 4 5 6)'), + (7, 'LINESTRING M (1 2 4, 4 5 7)'), + (8, 'LINESTRING ZM (1 2 3 4, 4 5 6 7)'), + (9, 'POLYGON ((1 2, 3 4, 5 6, 1 2))'), + (10, 'POLYGON Z ((1 2 3, 3 4 5, 5 6 7, 1 2 3))'), + (11, 'POLYGON M ((1 2 4, 3 4 6, 5 6 8, 1 2 4))'), + (12, 'POLYGON ZM ((1 2 3 4, 3 4 5 6, 5 6 7 8, 1 2 3 4))'), + (13, 'MULTIPOINT (1 2, 3 4, 5 6)'), + (14, 'MULTIPOINT Z (1 2 3, 3 4 5, 5 6 7)'), + (15, 'MULTIPOINT M (1 2 4, 3 4 6, 5 6 8)'), + (16, 'MULTIPOINT ZM (1 2 3 4, 3 4 5 6, 5 6 7 8)'), + (17, 'MULTILINESTRING ((1 2, 3 4), (5 6, 7 8))'), + (18, 'MULTILINESTRING Z ((1 2 3, 3 4 5), (5 6 7, 7 8 9))'), + (19, 'MULTILINESTRING M ((1 2 4, 3 4 6), (5 6 8, 7 8 10))'), + (20, 'MULTILINESTRING ZM ((1 2 3 4, 3 4 5 6), (5 6 7 8, 7 8 9 10))'), + (21, 'MULTIPOLYGON (((1 2, 3 4, 5 6, 1 2)), ((7 8, 9 10, 11 12, 7 8)))'), + (22, 'MULTIPOLYGON Z (((1 2 3, 3 4 5, 5 6 7, 1 2 3)), ((7 8 9, 9 10 11, 11 12 13, 7 8 9)))'), + (23, 'MULTIPOLYGON M (((1 2 4, 3 4 6, 5 6 8, 1 2 4)), ((7 8 10, 9 10 12, 11 12 14, 7 8 10)))'), + (24, 'MULTIPOLYGON ZM (((1 2 3 4, 3 4 5 6, 5 6 7 8, 1 2 3 4)), ((7 8 9 10, 9 10 11 12, 11 12 13 14, 7 8 9 10)))'), + (25, 'GEOMETRYCOLLECTION (POINT (1 2), LINESTRING (3 4, 5 6))'), + (26, 'GEOMETRYCOLLECTION Z (POINT Z (1 2 3), LINESTRING Z (3 4 5, 5 6 7))'), + (27, 'GEOMETRYCOLLECTION M (POINT M (1 2 4), LINESTRING M (3 4 6, 5 6 8))'), + (28, 'GEOMETRYCOLLECTION ZM (POINT ZM (1 2 3 4), LINESTRING ZM (3 4 5 6, 5 6 7 8))'); +-- +ok +== +select id, g::VARCHAR from t_all_types order by id; +-- +ok +== +select id, ST_AsText(ST_GeomFromWKB(ST_AsWKB(g))) from t_all_types order by id; +-- +ok +== +select id, st_geomfromwkb(('\x' || regexp_replace(g, '(.{2})', '\1\\x', 'g')[:-3])::BLOB) FROM values +(1, '0101000000000000000000f03f0000000000000040'), +(2, '01e9030000000000000000f03f00000000000000400000000000000840'), +(3, '01d1070000000000000000f03f00000000000000400000000000001040'), +(4, '01b90b0000000000000000f03f000000000000004000000000000008400000000000001040'), +(5, '010200000002000000000000000000f03f000000000000004000000000000008400000000000001040'), +(6, '01ea03000002000000000000000000f03f00000000000000400000000000000840000000000000104000000000000014400000000000001840'), +(7, '01d207000002000000000000000000f03f00000000000000400000000000001040000000000000104000000000000014400000000000001c40'), +(8, '01ba0b000002000000000000000000f03f0000000000000040000000000000084000000000000010400000000000001040000000000000144000000000000018400000000000001c40'), +(9, '01030000000100000004000000000000000000f03f00000000000000400000000000000840000000000000104000000000000014400000000000001840000000000000f03f0000000000000040'), +(10,'01eb0300000100000004000000000000000000f03f00000000000000400000000000000840000000000000084000000000000010400000000000001440000000000000144000000000000018400000000000001c40000000000000f03f00000000000000400000000000000840'), +(11,'01d30700000100000004000000000000000000f03f00000000000000400000000000001040000000000000084000000000000010400000000000001840000000000000144000000000000018400000000000002040000000000000f03f00000000000000400000000000001040'), +(12,'01bb0b00000100000004000000000000000000f03f0000000000000040000000000000084000000000000010400000000000000840000000000000104000000000000014400000000000001840000000000000144000000000000018400000000000001c400000000000002040000000000000f03f000000000000004000000000000008400000000000001040'), +(13,'0104000000030000000101000000000000000000f03f0000000000000040010100000000000000000008400000000000001040010100000000000000000014400000000000001840'), +(14,'01ec0300000300000001e9030000000000000000f03f0000000000000040000000000000084001e903000000000000000008400000000000001040000000000000144001e9030000000000000000144000000000000018400000000000001c40'), +(15,'01d40700000300000001d1070000000000000000f03f0000000000000040000000000000104001d107000000000000000008400000000000001040000000000000184001d1070000000000000000144000000000000018400000000000002040'), +(16,'01bc0b00000300000001b90b0000000000000000f03f00000000000000400000000000000840000000000000104001b90b0000000000000000084000000000000010400000000000001440000000000000184001b90b0000000000000000144000000000000018400000000000001c400000000000002040'), +(17,'010500000002000000010200000002000000000000000000f03f000000000000004000000000000008400000000000001040010200000002000000000000000000144000000000000018400000000000001c400000000000002040'), +(18,'01ed0300000200000001ea03000002000000000000000000f03f0000000000000040000000000000084000000000000008400000000000001040000000000000144001ea03000002000000000000000000144000000000000018400000000000001c400000000000001c4000000000000020400000000000002240'), +(19,'01d50700000200000001d207000002000000000000000000f03f0000000000000040000000000000104000000000000008400000000000001040000000000000184001d2070000020000000000000000001440000000000000184000000000000020400000000000001c4000000000000020400000000000002440'), +(20,'01bd0b00000200000001ba0b000002000000000000000000f03f000000000000004000000000000008400000000000001040000000000000084000000000000010400000000000001440000000000000184001ba0b000002000000000000000000144000000000000018400000000000001c4000000000000020400000000000001c40000000000000204000000000000022400000000000002440'), +(21,'01060000000200000001030000000100000004000000000000000000f03f00000000000000400000000000000840000000000000104000000000000014400000000000001840000000000000f03f0000000000000040010300000001000000040000000000000000001c40000000000000204000000000000022400000000000002440000000000000264000000000000028400000000000001c400000000000002040'), +(22,'01ee0300000200000001eb0300000100000004000000000000000000f03f00000000000000400000000000000840000000000000084000000000000010400000000000001440000000000000144000000000000018400000000000001c40000000000000f03f0000000000000040000000000000084001eb03000001000000040000000000000000001c4000000000000020400000000000002240000000000000224000000000000024400000000000002640000000000000264000000000000028400000000000002a400000000000001c4000000000000020400000000000002240'), +(23,'01d60700000200000001d30700000100000004000000000000000000f03f00000000000000400000000000001040000000000000084000000000000010400000000000001840000000000000144000000000000018400000000000002040000000000000f03f0000000000000040000000000000104001d307000001000000040000000000000000001c4000000000000020400000000000002440000000000000224000000000000024400000000000002840000000000000264000000000000028400000000000002c400000000000001c4000000000000020400000000000002440'), +(24,'01be0b00000200000001bb0b00000100000004000000000000000000f03f0000000000000040000000000000084000000000000010400000000000000840000000000000104000000000000014400000000000001840000000000000144000000000000018400000000000001c400000000000002040000000000000f03f00000000000000400000000000000840000000000000104001bb0b000001000000040000000000000000001c400000000000002040000000000000224000000000000024400000000000002240000000000000244000000000000026400000000000002840000000000000264000000000000028400000000000002a400000000000002c400000000000001c40000000000000204000000000000022400000000000002440'), +(25,'0107000000020000000101000000000000000000f03f00000000000000400102000000020000000000000000000840000000000000104000000000000014400000000000001840'), +(26,'01ef0300000200000001e9030000000000000000f03f0000000000000040000000000000084001ea03000002000000000000000000084000000000000010400000000000001440000000000000144000000000000018400000000000001c40'), +(27,'01d70700000200000001d1070000000000000000f03f0000000000000040000000000000104001d207000002000000000000000000084000000000000010400000000000001840000000000000144000000000000018400000000000002040'), +(28,'01bf0b00000200000001b90b0000000000000000f03f00000000000000400000000000000840000000000000104001ba0b0000020000000000000000000840000000000000104000000000000014400000000000001840000000000000144000000000000018400000000000001c400000000000002040') + as t(id, g) order by id; +-- +ok +== +select id, st_geomfromwkb(('\x' || regexp_replace(g, '(.{2})', '\1\\x', 'g')[:-3])::BLOB) FROM values +(1, '00000000013ff00000000000004000000000000000'), +(2, '00000003e93ff000000000000040000000000000004008000000000000'), +(3, '00000007d13ff000000000000040000000000000004010000000000000'), +(4, '0000000bb93ff0000000000000400000000000000040080000000000004010000000000000'), +(5, '0000000002000000023ff0000000000000400000000000000040080000000000004010000000000000'), +(6, '00000003ea000000023ff000000000000040000000000000004008000000000000401000000000000040140000000000004018000000000000'), +(7, '00000007d2000000023ff00000000000004000000000000000401000000000000040100000000000004014000000000000401c000000000000'), +(8, '0000000bba000000023ff0000000000000400000000000000040080000000000004010000000000000401000000000000040140000000000004018000000000000401c000000000000'), +(9, '000000000300000001000000043ff0000000000000400000000000000040080000000000004010000000000000401400000000000040180000000000003ff00000000000004000000000000000'), +(10,'00000003eb00000001000000043ff00000000000004000000000000000400800000000000040080000000000004010000000000000401400000000000040140000000000004018000000000000401c0000000000003ff000000000000040000000000000004008000000000000'), +(11,'00000007d300000001000000043ff0000000000000400000000000000040100000000000004008000000000000401000000000000040180000000000004014000000000000401800000000000040200000000000003ff000000000000040000000000000004010000000000000'), +(12,'0000000bbb00000001000000043ff0000000000000400000000000000040080000000000004010000000000000400800000000000040100000000000004014000000000000401800000000000040140000000000004018000000000000401c00000000000040200000000000003ff0000000000000400000000000000040080000000000004010000000000000'), +(13,'00000000040000000300000000013ff00000000000004000000000000000000000000140080000000000004010000000000000000000000140140000000000004018000000000000'), +(14,'00000003ec0000000300000003e93ff00000000000004000000000000000400800000000000000000003e940080000000000004010000000000000401400000000000000000003e940140000000000004018000000000000401c000000000000'), +(15,'00000007d40000000300000007d13ff00000000000004000000000000000401000000000000000000007d140080000000000004010000000000000401800000000000000000007d1401400000000000040180000000000004020000000000000'), +(16,'0000000bbc000000030000000bb93ff00000000000004000000000000000400800000000000040100000000000000000000bb940080000000000004010000000000000401400000000000040180000000000000000000bb940140000000000004018000000000000401c0000000000004020000000000000'), +(17,'0000000005000000020000000002000000023ff000000000000040000000000000004008000000000000401000000000000000000000020000000240140000000000004018000000000000401c0000000000004020000000000000'), +(18,'00000003ed0000000200000003ea000000023ff00000000000004000000000000000400800000000000040080000000000004010000000000000401400000000000000000003ea0000000240140000000000004018000000000000401c000000000000401c00000000000040200000000000004022000000000000'), +(19,'00000007d50000000200000007d2000000023ff00000000000004000000000000000401000000000000040080000000000004010000000000000401800000000000000000007d200000002401400000000000040180000000000004020000000000000401c00000000000040200000000000004024000000000000'), +(20,'0000000bbd000000020000000bba000000023ff000000000000040000000000000004008000000000000401000000000000040080000000000004010000000000000401400000000000040180000000000000000000bba0000000240140000000000004018000000000000401c0000000000004020000000000000401c000000000000402000000000000040220000000000004024000000000000'), +(21,'000000000600000002000000000300000001000000043ff0000000000000400000000000000040080000000000004010000000000000401400000000000040180000000000003ff0000000000000400000000000000000000000030000000100000004401c00000000000040200000000000004022000000000000402400000000000040260000000000004028000000000000401c0000000000004020000000000000'), +(22,'00000003ee0000000200000003eb00000001000000043ff00000000000004000000000000000400800000000000040080000000000004010000000000000401400000000000040140000000000004018000000000000401c0000000000003ff00000000000004000000000000000400800000000000000000003eb0000000100000004401c0000000000004020000000000000402200000000000040220000000000004024000000000000402600000000000040260000000000004028000000000000402a000000000000401c00000000000040200000000000004022000000000000'), +(23,'00000007d60000000200000007d300000001000000043ff0000000000000400000000000000040100000000000004008000000000000401000000000000040180000000000004014000000000000401800000000000040200000000000003ff00000000000004000000000000000401000000000000000000007d30000000100000004401c0000000000004020000000000000402400000000000040220000000000004024000000000000402800000000000040260000000000004028000000000000402c000000000000401c00000000000040200000000000004024000000000000'), +(24,'0000000bbe000000020000000bbb00000001000000043ff0000000000000400000000000000040080000000000004010000000000000400800000000000040100000000000004014000000000000401800000000000040140000000000004018000000000000401c00000000000040200000000000003ff00000000000004000000000000000400800000000000040100000000000000000000bbb0000000100000004401c000000000000402000000000000040220000000000004024000000000000402200000000000040240000000000004026000000000000402800000000000040260000000000004028000000000000402a000000000000402c000000000000401c000000000000402000000000000040220000000000004024000000000000'), +(25,'00000000070000000200000000013ff000000000000040000000000000000000000002000000024008000000000000401000000000000040140000000000004018000000000000'), +(26,'00000003ef0000000200000003e93ff00000000000004000000000000000400800000000000000000003ea0000000240080000000000004010000000000000401400000000000040140000000000004018000000000000401c000000000000'), +(27,'00000007d70000000200000007d13ff00000000000004000000000000000401000000000000000000007d200000002400800000000000040100000000000004018000000000000401400000000000040180000000000004020000000000000'), +(28,'0000000bbf000000020000000bb93ff00000000000004000000000000000400800000000000040100000000000000000000bba00000002400800000000000040100000000000004014000000000000401800000000000040140000000000004018000000000000401c0000000000004020000000000000'), + as t(id, g) order by id; +-- +ok +== +select id, st_geomfromwkb(('\x' || regexp_replace(g, '(.{2})', '\1\\x', 'g')[:-3])::BLOB) FROM values + (1, '0101000000000000000000F03F0000000000000040'), + (2, '0101000080000000000000F03F00000000000000400000000000000840'), + (3, '0101000040000000000000F03F00000000000000400000000000001040'), + (4, '01010000C0000000000000F03F000000000000004000000000000008400000000000001040'), + (5, '010200000002000000000000000000F03F000000000000004000000000000008400000000000001040'), + (6, '010200008002000000000000000000F03F00000000000000400000000000000840000000000000104000000000000014400000000000001840'), + (7, '010200004002000000000000000000F03F00000000000000400000000000001040000000000000104000000000000014400000000000001C40'), + (8, '01020000C002000000000000000000F03F0000000000000040000000000000084000000000000010400000000000001040000000000000144000000000000018400000000000001C40'), + (9, '01030000000100000004000000000000000000F03F00000000000000400000000000000840000000000000104000000000000014400000000000001840000000000000F03F0000000000000040'), + (10, '01030000800100000004000000000000000000F03F00000000000000400000000000000840000000000000084000000000000010400000000000001440000000000000144000000000000018400000000000001C40000000000000F03F00000000000000400000000000000840'), + (11, '01030000400100000004000000000000000000F03F00000000000000400000000000001040000000000000084000000000000010400000000000001840000000000000144000000000000018400000000000002040000000000000F03F00000000000000400000000000001040'), + (12, '01030000C00100000004000000000000000000F03F0000000000000040000000000000084000000000000010400000000000000840000000000000104000000000000014400000000000001840000000000000144000000000000018400000000000001C400000000000002040000000000000F03F000000000000004000000000000008400000000000001040'), + (13, '0104000000030000000101000000000000000000F03F0000000000000040010100000000000000000008400000000000001040010100000000000000000014400000000000001840'), + (14, '0104000080030000000101000080000000000000F03F0000000000000040000000000000084001010000800000000000000840000000000000104000000000000014400101000080000000000000144000000000000018400000000000001C40'), + (15, '0104000040030000000101000040000000000000F03F0000000000000040000000000000104001010000400000000000000840000000000000104000000000000018400101000040000000000000144000000000000018400000000000002040'), + (16, '01040000C00300000001010000C0000000000000F03F00000000000000400000000000000840000000000000104001010000C0000000000000084000000000000010400000000000001440000000000000184001010000C0000000000000144000000000000018400000000000001C400000000000002040'), + (17, '010500000002000000010200000002000000000000000000F03F000000000000004000000000000008400000000000001040010200000002000000000000000000144000000000000018400000000000001C400000000000002040'), + (18, '010500008002000000010200008002000000000000000000F03F00000000000000400000000000000840000000000000084000000000000010400000000000001440010200008002000000000000000000144000000000000018400000000000001C400000000000001C4000000000000020400000000000002240'), + (19, '010500004002000000010200004002000000000000000000F03F000000000000004000000000000010400000000000000840000000000000104000000000000018400102000040020000000000000000001440000000000000184000000000000020400000000000001C4000000000000020400000000000002440'), + (20, '01050000C00200000001020000C002000000000000000000F03F000000000000004000000000000008400000000000001040000000000000084000000000000010400000000000001440000000000000184001020000C002000000000000000000144000000000000018400000000000001C4000000000000020400000000000001C40000000000000204000000000000022400000000000002440'), + (21, '01060000000200000001030000000100000004000000000000000000F03F00000000000000400000000000000840000000000000104000000000000014400000000000001840000000000000F03F0000000000000040010300000001000000040000000000000000001C40000000000000204000000000000022400000000000002440000000000000264000000000000028400000000000001C400000000000002040'), + (22, '01060000800200000001030000800100000004000000000000000000F03F00000000000000400000000000000840000000000000084000000000000010400000000000001440000000000000144000000000000018400000000000001C40000000000000F03F00000000000000400000000000000840010300008001000000040000000000000000001C4000000000000020400000000000002240000000000000224000000000000024400000000000002640000000000000264000000000000028400000000000002A400000000000001C4000000000000020400000000000002240'), + (23, '01060000400200000001030000400100000004000000000000000000F03F00000000000000400000000000001040000000000000084000000000000010400000000000001840000000000000144000000000000018400000000000002040000000000000F03F00000000000000400000000000001040010300004001000000040000000000000000001C4000000000000020400000000000002440000000000000224000000000000024400000000000002840000000000000264000000000000028400000000000002C400000000000001C4000000000000020400000000000002440'), + (24, '01060000C00200000001030000C00100000004000000000000000000F03F0000000000000040000000000000084000000000000010400000000000000840000000000000104000000000000014400000000000001840000000000000144000000000000018400000000000001C400000000000002040000000000000F03F00000000000000400000000000000840000000000000104001030000C001000000040000000000000000001C400000000000002040000000000000224000000000000024400000000000002240000000000000244000000000000026400000000000002840000000000000264000000000000028400000000000002A400000000000002C400000000000001C40000000000000204000000000000022400000000000002440'), + (25, '0107000000020000000101000000000000000000F03F00000000000000400102000000020000000000000000000840000000000000104000000000000014400000000000001840'), + (26, '0107000080020000000101000080000000000000F03F00000000000000400000000000000840010200008002000000000000000000084000000000000010400000000000001440000000000000144000000000000018400000000000001C40'), + (27, '0107000040020000000101000040000000000000F03F00000000000000400000000000001040010200004002000000000000000000084000000000000010400000000000001840000000000000144000000000000018400000000000002040'), + (28, '01070000C00200000001010000C0000000000000F03F00000000000000400000000000000840000000000000104001020000C0020000000000000000000840000000000000104000000000000014400000000000001840000000000000144000000000000018400000000000001C400000000000002040') + as t(id, g) order by id; +-- +ok +== +select id, st_geomfromwkb(('\x' || regexp_replace(g, '(.{2})', '\1\\x', 'g')[:-3])::BLOB) FROM values + (1, '00000000013FF00000000000004000000000000000'), + (2, '00800000013FF000000000000040000000000000004008000000000000'), + (3, '00400000013FF000000000000040000000000000004010000000000000'), + (4, '00C00000013FF0000000000000400000000000000040080000000000004010000000000000'), + (5, '0000000002000000023FF0000000000000400000000000000040080000000000004010000000000000'), + (6, '0080000002000000023FF000000000000040000000000000004008000000000000401000000000000040140000000000004018000000000000'), + (7, '0040000002000000023FF00000000000004000000000000000401000000000000040100000000000004014000000000000401C000000000000'), + (8, '00C0000002000000023FF0000000000000400000000000000040080000000000004010000000000000401000000000000040140000000000004018000000000000401C000000000000'), + (9, '000000000300000001000000043FF0000000000000400000000000000040080000000000004010000000000000401400000000000040180000000000003FF00000000000004000000000000000'), + (10, '008000000300000001000000043FF00000000000004000000000000000400800000000000040080000000000004010000000000000401400000000000040140000000000004018000000000000401C0000000000003FF000000000000040000000000000004008000000000000'), + (11, '004000000300000001000000043FF0000000000000400000000000000040100000000000004008000000000000401000000000000040180000000000004014000000000000401800000000000040200000000000003FF000000000000040000000000000004010000000000000'), + (12, '00C000000300000001000000043FF0000000000000400000000000000040080000000000004010000000000000400800000000000040100000000000004014000000000000401800000000000040140000000000004018000000000000401C00000000000040200000000000003FF0000000000000400000000000000040080000000000004010000000000000'), + (13, '00000000040000000300000000013FF00000000000004000000000000000000000000140080000000000004010000000000000000000000140140000000000004018000000000000'), + (14, '00800000040000000300800000013FF0000000000000400000000000000040080000000000000080000001400800000000000040100000000000004014000000000000008000000140140000000000004018000000000000401C000000000000'), + (15, '00400000040000000300400000013FF00000000000004000000000000000401000000000000000400000014008000000000000401000000000000040180000000000000040000001401400000000000040180000000000004020000000000000'), + (16, '00C00000040000000300C00000013FF000000000000040000000000000004008000000000000401000000000000000C0000001400800000000000040100000000000004014000000000000401800000000000000C000000140140000000000004018000000000000401C0000000000004020000000000000'), + (17, '0000000005000000020000000002000000023FF000000000000040000000000000004008000000000000401000000000000000000000020000000240140000000000004018000000000000401C0000000000004020000000000000'), + (18, '0080000005000000020080000002000000023FF00000000000004000000000000000400800000000000040080000000000004010000000000000401400000000000000800000020000000240140000000000004018000000000000401C000000000000401C00000000000040200000000000004022000000000000'), + (19, '0040000005000000020040000002000000023FF000000000000040000000000000004010000000000000400800000000000040100000000000004018000000000000004000000200000002401400000000000040180000000000004020000000000000401C00000000000040200000000000004024000000000000'), + (20, '00C00000050000000200C0000002000000023FF0000000000000400000000000000040080000000000004010000000000000400800000000000040100000000000004014000000000000401800000000000000C00000020000000240140000000000004018000000000000401C0000000000004020000000000000401C000000000000402000000000000040220000000000004024000000000000'), + (21, '000000000600000002000000000300000001000000043FF0000000000000400000000000000040080000000000004010000000000000401400000000000040180000000000003FF0000000000000400000000000000000000000030000000100000004401C00000000000040200000000000004022000000000000402400000000000040260000000000004028000000000000401C0000000000004020000000000000'), + (22, '008000000600000002008000000300000001000000043FF00000000000004000000000000000400800000000000040080000000000004010000000000000401400000000000040140000000000004018000000000000401C0000000000003FF00000000000004000000000000000400800000000000000800000030000000100000004401C0000000000004020000000000000402200000000000040220000000000004024000000000000402600000000000040260000000000004028000000000000402A000000000000401C00000000000040200000000000004022000000000000'), + (23, '004000000600000002004000000300000001000000043FF0000000000000400000000000000040100000000000004008000000000000401000000000000040180000000000004014000000000000401800000000000040200000000000003FF00000000000004000000000000000401000000000000000400000030000000100000004401C0000000000004020000000000000402400000000000040220000000000004024000000000000402800000000000040260000000000004028000000000000402C000000000000401C00000000000040200000000000004024000000000000'), + (24, '00C00000060000000200C000000300000001000000043FF0000000000000400000000000000040080000000000004010000000000000400800000000000040100000000000004014000000000000401800000000000040140000000000004018000000000000401C00000000000040200000000000003FF000000000000040000000000000004008000000000000401000000000000000C00000030000000100000004401C000000000000402000000000000040220000000000004024000000000000402200000000000040240000000000004026000000000000402800000000000040260000000000004028000000000000402A000000000000402C000000000000401C000000000000402000000000000040220000000000004024000000000000'), + (25, '00000000070000000200000000013FF000000000000040000000000000000000000002000000024008000000000000401000000000000040140000000000004018000000000000'), + (26, '00800000070000000200800000013FF00000000000004000000000000000400800000000000000800000020000000240080000000000004010000000000000401400000000000040140000000000004018000000000000401C000000000000'), + (27, '00400000070000000200400000013FF000000000000040000000000000004010000000000000004000000200000002400800000000000040100000000000004018000000000000401400000000000040180000000000004020000000000000'), + (28, '00C00000070000000200C00000013FF000000000000040000000000000004008000000000000401000000000000000C000000200000002400800000000000040100000000000004014000000000000401800000000000040140000000000004018000000000000401C0000000000004020000000000000') + as t(id, g) order by id; +-- +ok +== diff --git a/parser/testdata/corpus/sql/types/hugeint/hugeint_multiply.test b/parser/testdata/corpus/sql/types/hugeint/hugeint_multiply.test new file mode 100644 index 0000000..ee477b0 --- /dev/null +++ b/parser/testdata/corpus/sql/types/hugeint/hugeint_multiply.test @@ -0,0 +1,133 @@ +# source: test/sql/types/hugeint/hugeint_multiply.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +SELECT 251658240::HUGEINT * 251658240::HUGEINT +-- +ok +== +SELECT 251658240::HUGEINT * 1080863910568919040::HUGEINT +-- +ok +== +SELECT 251658240::HUGEINT * 4642275147320176030871715840::HUGEINT +-- +ok +== +SELECT 251658240::HUGEINT * 19938419936773738093557105904205168640::HUGEINT +-- +ok +== +SELECT 1080863910568919040::HUGEINT * 251658240::HUGEINT +-- +ok +== +SELECT 1080863910568919040::HUGEINT * 1080863910568919040::HUGEINT +-- +ok +== +SELECT 1080863910568919040::HUGEINT * 4642275147320176030871715840::HUGEINT +-- +ok +== +SELECT 1080863910568919040::HUGEINT * 19938419936773738093557105904205168640::HUGEINT +-- +ok +== +SELECT 4642275147320176030871715840::HUGEINT * 251658240::HUGEINT +-- +ok +== +SELECT 4642275147320176030871715840::HUGEINT * 1080863910568919040::HUGEINT +-- +ok +== +SELECT 4642275147320176030871715840::HUGEINT * 4642275147320176030871715840::HUGEINT +-- +ok +== +SELECT 4642275147320176030871715840::HUGEINT * 19938419936773738093557105904205168640::HUGEINT +-- +ok +== +SELECT 19938419936773738093557105904205168640::HUGEINT * 251658240::HUGEINT +-- +ok +== +SELECT 19938419936773738093557105904205168640::HUGEINT * 1080863910568919040::HUGEINT +-- +ok +== +SELECT 19938419936773738093557105904205168640::HUGEINT * 4642275147320176030871715840::HUGEINT +-- +ok +== +SELECT 19938419936773738093557105904205168640::HUGEINT * 19938419936773738093557105904205168640::HUGEINT +-- +ok +== +SELECT 85070591730234615865843651857942052863::HUGEINT * 2::HUGEINT +-- +ok +== +SELECT 85070591730234615865843651857942052864::HUGEINT * 2::HUGEINT +-- +ok +== +SELECT 85070591730234615865843651857942052865::HUGEINT * 2::HUGEINT +-- +ok +== +SELECT 19807040628566084398385987583::HUGEINT * 8589934592::HUGEINT +-- +ok +== +SELECT 19807040628566084398385987584::HUGEINT*8589934592::HUGEINT; +-- +ok +== +SELECT 36893488147419103231::HUGEINT * 4611686018427387904::HUGEINT +-- +ok +== +SELECT 36893488147419103232::HUGEINT * 4611686018427387904::HUGEINT +-- +ok +== +SELECT 2::HUGEINT * 85070591730234615865843651857942052863::HUGEINT +-- +ok +== +SELECT 2::HUGEINT * 85070591730234615865843651857942052864::HUGEINT +-- +ok +== +SELECT 2::HUGEINT * 85070591730234615865843651857942052865::HUGEINT +-- +ok +== +SELECT 8589934592::HUGEINT * 19807040628566084398385987583::HUGEINT +-- +ok +== +SELECT 8589934592::HUGEINT * 19807040628566084398385987584::HUGEINT +-- +ok +== +SELECT 4611686018427387904::HUGEINT * 36893488147419103231::HUGEINT +-- +ok +== +SELECT 4611686018427387904::HUGEINT * 36893488147419103232::HUGEINT +-- +ok +== +SELECT 10376293541461622783::HUGEINT * 10376293541461622783::HUGEINT +-- +ok +== +SELECT 17293822569102704639::HUGEINT * 10376293541461622783::HUGEINT +-- +ok +== diff --git a/parser/testdata/corpus/sql/types/hugeint/hugeint_sum_overflow.test b/parser/testdata/corpus/sql/types/hugeint/hugeint_sum_overflow.test new file mode 100644 index 0000000..9ddcf8b --- /dev/null +++ b/parser/testdata/corpus/sql/types/hugeint/hugeint_sum_overflow.test @@ -0,0 +1,45 @@ +# source: test/sql/types/hugeint/hugeint_sum_overflow.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +SELECT SUM(170141183460469231731687303715884105727) FROM range(10); +-- +ok +== +SELECT SUM(x) FROM (VALUES (170141183460469231731687303715884105727), (170141183460469231731687303715884105727)) t(x) +-- +ok +== +SELECT AVG(170141183460469231731687303715884105727) FROM range(10); +-- +ok +== +SELECT AVG(x) FROM (VALUES (170141183460469231731687303715884105727), (170141183460469231731687303715884105727)) t(x) +-- +ok +== +SELECT SUM(x) FROM ( + SELECT 100000000000000000000000000000000000000::HUGEINT AS x + UNION ALL + SELECT 100000000000000000000000000000000000000::HUGEINT +) t; +-- +ok +== +SELECT AVG(x) FROM ( + SELECT 100000000000000000000000000000000000000::HUGEINT AS x + UNION ALL + SELECT 100000000000000000000000000000000000000::HUGEINT +) t; +-- +ok +== +SELECT SUM(x) FROM ( + SELECT 50000000000000000000000000000000000000::HUGEINT AS x + UNION ALL + SELECT 50000000000000000000000000000000000000::HUGEINT +) t; +-- +ok +== diff --git a/parser/testdata/corpus/sql/types/hugeint/hugeint_try_cast.test b/parser/testdata/corpus/sql/types/hugeint/hugeint_try_cast.test new file mode 100644 index 0000000..e1ea233 --- /dev/null +++ b/parser/testdata/corpus/sql/types/hugeint/hugeint_try_cast.test @@ -0,0 +1,37 @@ +# source: test/sql/types/hugeint/hugeint_try_cast.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +SELECT CAST('170141183460469231731687303715884105728' AS HUGEINT) +-- +ok +== +SELECT CAST('170141183460469231731687303715884105728'::DOUBLE AS HUGEINT) +-- +ok +== +SELECT CAST('-170141183460469231731687303715884105729' AS HUGEINT) +-- +ok +== +SELECT CAST('-170141183460469231731687303715884105729'::DOUBLE AS HUGEINT) +-- +ok +== +SELECT TRY_CAST('170141183460469231731687303715884105728' AS HUGEINT) +-- +ok +== +SELECT TRY_CAST('170141183460469231731687303715884105728'::DOUBLE AS HUGEINT) +-- +ok +== +SELECT TRY_CAST('-170141183460469231731687303715884105729' AS HUGEINT) +-- +ok +== +SELECT TRY_CAST('-170141183460469231731687303715884105729'::DOUBLE AS HUGEINT) +-- +ok +== diff --git a/parser/testdata/corpus/sql/types/hugeint/test_hugeint_aggregates.test b/parser/testdata/corpus/sql/types/hugeint/test_hugeint_aggregates.test new file mode 100644 index 0000000..720b449 --- /dev/null +++ b/parser/testdata/corpus/sql/types/hugeint/test_hugeint_aggregates.test @@ -0,0 +1,29 @@ +# source: test/sql/types/hugeint/test_hugeint_aggregates.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +CREATE TABLE hugeints(g INTEGER, h HUGEINT); +-- +ok +== +INSERT INTO hugeints VALUES (1, 42.0), (2, 1267650600228229401496703205376), (2, -439847238974238975238975), (1, '-12'); +-- +ok +== +SELECT MIN(h), MAX(h), SUM(h), FIRST(h), LAST(h) FROM hugeints; +-- +ok +== +SELECT g, MIN(h), MAX(h), SUM(h), FIRST(h), LAST(h) FROM hugeints GROUP BY g ORDER BY 1; +-- +ok +== +SELECT FIRST(h), LAST(h) FROM hugeints; +-- +ok +== +SELECT g, FIRST(h), LAST(h) FROM hugeints GROUP BY g ORDER BY 1; +-- +ok +== diff --git a/parser/testdata/corpus/sql/types/hugeint/test_hugeint_arithmetic.test b/parser/testdata/corpus/sql/types/hugeint/test_hugeint_arithmetic.test new file mode 100644 index 0000000..84b218f --- /dev/null +++ b/parser/testdata/corpus/sql/types/hugeint/test_hugeint_arithmetic.test @@ -0,0 +1,389 @@ +# source: test/sql/types/hugeint/test_hugeint_arithmetic.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +SELECT -(100::HUGEINT), -(-(50::HUGEINT)); +-- +ok +== +SELECT -(0::HUGEINT) +-- +ok +== +SELECT -(100000000000000000000::HUGEINT), -(-(100000000000000000000::HUGEINT)); +-- +ok +== +SELECT 42::HUGEINT + 42::HUGEINT; +-- +ok +== +SELECT 42::HUGEINT + -42::HUGEINT, -42::HUGEINT + 100::HUGEINT, -42::HUGEINT+-42::HUGEINT; +-- +ok +== +SELECT '100000000000000000000'::HUGEINT + '100000000000000000000'::HUGEINT; +-- +ok +== +SELECT '100000000000000000000'::HUGEINT + '-1000000000000000000000'::HUGEINT; +-- +ok +== +SELECT '5'::HUGEINT + '-10000000000000000002'::HUGEINT; +-- +ok +== +SELECT '170141183460469231731687303715884105727'::HUGEINT + '170141183460469231731687303715884105727'::HUGEINT; +-- +ok +== +SELECT '170141183460469231731687303715884105727'::HUGEINT + '10'::HUGEINT; +-- +ok +== +SELECT '170141183460469231731687303715884105727'::HUGEINT - 10::HUGEINT + 10::HUGEINT +-- +ok +== +SELECT '-170141183460469231731687303715884105728'::HUGEINT + 10::HUGEINT - 10::HUGEINT +-- +ok +== +SELECT '170141183460469231731687303715884105727'::HUGEINT - 10::HUGEINT + 11::HUGEINT +-- +ok +== +SELECT '-170141183460469231731687303715884105728'::HUGEINT + 10::HUGEINT - 11::HUGEINT +-- +ok +== +SELECT 100::HUGEINT - 42::HUGEINT, 3::HUGEINT - 5::HUGEINT; +-- +ok +== +SELECT -100::HUGEINT - 42::HUGEINT, -3::HUGEINT - 5::HUGEINT, 12::HUGEINT-(-12::HUGEINT); +-- +ok +== +SELECT '-10000000000000000002'::HUGEINT - '-10000000000000000002'::HUGEINT; +-- +ok +== +SELECT '-170141183460469231731687303715884105728'::HUGEINT - '170141183460469231731687303715884105727'::HUGEINT; +-- +ok +== +SELECT '170141183460469231731687303715884105727'::HUGEINT - '-170141183460469231731687303715884105728'::HUGEINT; +-- +ok +== +SELECT 100::HUGEINT * 50::HUGEINT; +-- +ok +== +SELECT 100::HUGEINT * -50::HUGEINT, -100::HUGEINT * 50::HUGEINT, -100::HUGEINT * -50::HUGEINT; +-- +ok +== +SELECT '1701411834604692317'::HUGEINT * '2'::HUGEINT, '100000000000000000000'::HUGEINT * '1000000000000000000'::HUGEINT +-- +ok +== +SELECT '170141183460469231731687303715884105727'::HUGEINT * 1::HUGEINT +-- +ok +== +SELECT '170141183460469231731687303715884105727'::HUGEINT * 2::HUGEINT +-- +ok +== +SELECT '1701411834604692317'::HUGEINT * '131687303715884105727'::HUGEINT +-- +ok +== +SELECT 100::HUGEINT // 20::HUGEINT, 90::HUGEINT // 20::HUGEINT +-- +ok +== +SELECT -100::HUGEINT // 20::HUGEINT, 100::HUGEINT // -20::HUGEINT, -100::HUGEINT // -20::HUGEINT +-- +ok +== +SELECT 100::HUGEINT // 0::HUGEINT +-- +ok +== +SELECT '100000000000000000000000000000000000000'::HUGEINT // '10000000000000'::HUGEINT, '100000000000000000000000000000000000000'::HUGEINT // '2'::HUGEINT +-- +ok +== +SELECT 100::HUGEINT % 20::HUGEINT, 90::HUGEINT % 20::HUGEINT +-- +ok +== +SELECT -90 % 20, 90 % -20, -90 % -20 +-- +ok +== +SELECT -90::HUGEINT % 20::HUGEINT, 90::HUGEINT % -20::HUGEINT, -90::HUGEINT % -20::HUGEINT +-- +ok +== +SELECT 100::HUGEINT % 0::HUGEINT +-- +ok +== +SELECT '100000000000000000000000000000000000000'::HUGEINT % '6587689457689375689735'::HUGEINT, '100000000000000000000000000000000000000'::HUGEINT % '3'::HUGEINT +-- +ok +== +SELECT ABS('100'::HUGEINT), ABS('-100'::HUGEINT);; +-- +ok +== +SELECT '-170141183460469231731687303715884105727'::HUGEINT + -1; +-- +ok +== +SELECT '170141183460469231731687303715884105726'::HUGEINT + 1; +-- +ok +== +SELECT -170141183460469231731687303715884105728 + -1; +-- +ok +== +SELECT 170141183460469231731687303715884105727 + 1; +-- +ok +== +SELECT '170141183460469231731687303715884105727'::HUGEINT + -1; +-- +ok +== +SELECT '-170141183460469231731687303715884105728'::HUGEINT + 1; +-- +ok +== +SELECT -1 + '-170141183460469231731687303715884105727'::HUGEINT; +-- +ok +== +SELECT 1 + '170141183460469231731687303715884105726'::HUGEINT; +-- +ok +== +SELECT -1 + -170141183460469231731687303715884105728; +-- +ok +== +SELECT 1 + 170141183460469231731687303715884105727; +-- +ok +== +SELECT -1 + '170141183460469231731687303715884105727'::HUGEINT; +-- +ok +== +SELECT 1 + '-170141183460469231731687303715884105728'::HUGEINT; +-- +ok +== +SELECT '-170141183460469231731687303715884105727'::HUGEINT - 1; +-- +ok +== +SELECT -170141183460469231731687303715884105728 - 1; +-- +ok +== +SELECT 170141183460469231731687303715884105724 - (-1); +-- +ok +== +SELECT 170141183460469231731687303715884105725 - (-1); +-- +ok +== +SELECT 170141183460469231731687303715884105726 - (-1); +-- +ok +== +SELECT 170141183460469231731687303715884105727 - (-1); +-- +ok +== +SELECT 170141183460469231731687303715884105727 - 1; +-- +ok +== +SELECT -170141183460469231731687303715884105728 - (-1); +-- +ok +== +SELECT -1 - 170141183460469231731687303715884105727; +-- +ok +== +SELECT -2 - 170141183460469231731687303715884105727; +-- +ok +== +SELECT 1 - (-170141183460469231731687303715884105724); +-- +ok +== +SELECT 1 - (-170141183460469231731687303715884105725); +-- +ok +== +SELECT 1 - (-170141183460469231731687303715884105726); +-- +ok +== +SELECT 1 - (-170141183460469231731687303715884105728); +-- +ok +== +SELECT -1 - (-170141183460469231731687303715884105728); +-- +ok +== +SELECT 1 - 170141183460469231731687303715884105727; +-- +ok +== +SELECT 170141183460469231731687303715884105727 * 1; +-- +ok +== +SELECT 170141183460469231731687303715884105727 * -1; +-- +ok +== +SELECT -170141183460469231731687303715884105728 * 1; +-- +ok +== +SELECT -170141183460469231731687303715884105727 * -1; +-- +ok +== +SELECT -170141183460469231731687303715884105728 * -1; +-- +ok +== +SELECT -170141183460469231731687303715884105728 * 0; +-- +ok +== +SELECT 85070591730234615865843651857942052864 * 2 +-- +ok +== +SELECT -85070591730234615865843651857942052864 * 2 +-- +ok +== +SELECT 85070591730234615865843651857942052864 * -2 +-- +ok +== +SELECT -85070591730234615865843651857942052864 * -2 +-- +ok +== +SELECT -170141183460469231731687303715884105728 // 2; +-- +ok +== +SELECT -170141183460469231731687303715884105728 // -2; +-- +ok +== +SELECT -170141183460469231731687303715884105728 // -170141183460469231731687303715884105728; +-- +ok +== +SELECT 170141183460469231731687303715884105727 // 170141183460469231731687303715884105727; +-- +ok +== +SELECT 170141183460469231731687303715884105727 // 1; +-- +ok +== +SELECT 170141183460469231731687303715884105727 // -1; +-- +ok +== +SELECT -170141183460469231731687303715884105728 // 1; +-- +ok +== +SELECT -170141183460469231731687303715884105727 // -1; +-- +ok +== +SELECT -170141183460469231731687303715884105728 // -1; +-- +ok +== +SELECT -170141183460469231731687303715884105728 % -1; +-- +ok +== +SELECT -170141183460469231731687303715884105728 % -2; +-- +ok +== +SELECT -170141183460469231731687303715884105728 % 2; +-- +ok +== +SELECT -170141183460469231731687303715884105728 % 3; +-- +ok +== +SELECT -170141183460469231731687303715884105727 % -170141183460469231731687303715884105726; +-- +ok +== +SELECT -170141183460469231731687303715884105728 % -170141183460469231731687303715884105727; +-- +ok +== +SELECT -170141183460469231731687303715884105728 % -170141183460469231731687303715884105728; +-- +ok +== +SELECT -170141183460469231731687303715884105728 % 170141183460469231731687303715884105727; +-- +ok +== +SELECT -170141183460469231731687303715884105728 % 170141183460469231731687303715884105728; +-- +ok +== +SELECT 170141183460469231731687303715884105727 % -170141183460469231731687303715884105726; +-- +ok +== +SELECT 170141183460469231731687303715884105727 % -170141183460469231731687303715884105727; +-- +ok +== +SELECT 170141183460469231731687303715884105727 % -170141183460469231731687303715884105728; +-- +ok +== +SELECT 170141183460469231731687303715884105727 % 170141183460469231731687303715884105726; +-- +ok +== +SELECT '5'::HUGEINT <> '5'::HUGEINT, '5'::HUGEINT <> '18446744073709551621'::HUGEINT +-- +ok +== diff --git a/parser/testdata/corpus/sql/types/hugeint/test_hugeint_auto_cast.test b/parser/testdata/corpus/sql/types/hugeint/test_hugeint_auto_cast.test new file mode 100644 index 0000000..1e653e6 --- /dev/null +++ b/parser/testdata/corpus/sql/types/hugeint/test_hugeint_auto_cast.test @@ -0,0 +1,21 @@ +# source: test/sql/types/hugeint/test_hugeint_auto_cast.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +SELECT 10000000000000000000::HUGEINT + 100::TINYINT, 10000000000000000000::HUGEINT + 100::SMALLINT, 10000000000000000000::HUGEINT + 100::INTEGER, 10000000000000000000::HUGEINT + 100::BIGINT; +-- +ok +== +SELECT 100::HUGEINT + 0.5 +-- +ok +== +SELECT COS(100::HUGEINT) +-- +ok +== +SELECT CONCAT('hello number ', 100::HUGEINT) +-- +ok +== diff --git a/parser/testdata/corpus/sql/types/hugeint/test_hugeint_bitwise.test b/parser/testdata/corpus/sql/types/hugeint/test_hugeint_bitwise.test new file mode 100644 index 0000000..2f63cd6 --- /dev/null +++ b/parser/testdata/corpus/sql/types/hugeint/test_hugeint_bitwise.test @@ -0,0 +1,145 @@ +# source: test/sql/types/hugeint/test_hugeint_bitwise.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +SELECT 1::HUGEINT << 3 +-- +ok +== +SELECT 27::HUGEINT << 0 +-- +ok +== +SELECT -27::HUGEINT << 1 +-- +ok +== +select 1::HUGEINT << 50, 1::HUGEINT << 100; +-- +ok +== +select (((((1::HUGEINT << 50) << 50) << 2) << 3) << 8), (1::HUGEINT)<<50<<20<<7<<18<<3<<6<<9 +-- +ok +== +select 1::HUGEINT << 64; +-- +ok +== +select 1::HUGEINT << 200 +-- +ok +== +SELECT '1329227995784915872903807060280344576'::HUGEINT << 50; +-- +ok +== +SELECT 27::HUGEINT << -1 +-- +ok +== +SELECT 100::HUGEINT << '1329227995784915872903807060280344576'::HUGEINT +-- +ok +== +SELECT 8::HUGEINT >> 3 +-- +ok +== +SELECT 27::HUGEINT >> 0 +-- +ok +== +SELECT -27::HUGEINT >> 1 +-- +ok +== +SELECT 27::HUGEINT >> -1 +-- +ok +== +select (1::HUGEINT << 100) >> 50, (1::HUGEINT << 120)>>108; +-- +ok +== +SELECT '1329227995784915872903807060280344576'::HUGEINT >> 200 +-- +ok +== +select -11367237885269962203896920952509169001 >> 200; +-- +ok +== +SELECT '1329227995784915872903807060280344576'::HUGEINT >> 64 +-- +ok +== +select -11367237885269962203896920952509169001 >> 64; +-- +ok +== +SELECT '1329227995784915872903807060280344576'::HUGEINT >> 96 +-- +ok +== +select -11367237885269962203896920952509169001 >> 96; +-- +ok +== +SELECT '1329227995784915872903807060280344576'::HUGEINT >> 4 >> 5 >> 7 >> 9 >> 12 >> 13 +-- +ok +== +SELECT -11367237885269962203896920952509169001 >> 4 >> 5 >> 7 >> 9 >> 12 >> 13 +-- +ok +== +select 1::HUGEINT & 3::HUGEINT +-- +ok +== +select 51290852742897895128414::HUGEINT & 4923847238975289723895239078235::HUGEINT +-- +ok +== +select 1::HUGEINT | 2::HUGEINT +-- +ok +== +select 51290852742897895128414::HUGEINT | 4923847238975289723895239078235::HUGEINT +-- +ok +== +select xor(1::HUGEINT, 3::HUGEINT) +-- +ok +== +select xor(51290852742897895128414::HUGEINT, 4923847238975289723895239078235::HUGEINT) +-- +ok +== +select ~(1::HUGEINT) +-- +ok +== +select ~(4923847238975289723895239078235::HUGEINT) +-- +ok +== +select 1::hugeint >> 1000; +-- +ok +== +select 1 >> 170141183460469231731687303715884105727::hugeint; +-- +ok +== +select 1::hugeint << 1000; +-- +ok +== +select 1 << 170141183460469231731687303715884105727::hugeint; +-- +ok +== diff --git a/parser/testdata/corpus/sql/types/hugeint/test_hugeint_conversion.test b/parser/testdata/corpus/sql/types/hugeint/test_hugeint_conversion.test new file mode 100644 index 0000000..1ec5297 --- /dev/null +++ b/parser/testdata/corpus/sql/types/hugeint/test_hugeint_conversion.test @@ -0,0 +1,149 @@ +# source: test/sql/types/hugeint/test_hugeint_conversion.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +SELECT '7'::HUGEINT, '130'::HUGEINT, '924829852'::HUGEINT +-- +ok +== +SELECT '0'::HUGEINT, '-0'::HUGEINT +-- +ok +== +SELECT '-7'::HUGEINT, '-130'::HUGEINT, '-924829852'::HUGEINT +-- +ok +== +SELECT '10000000000000000000000000000'::HUGEINT; +-- +ok +== +SELECT '1267650600228229401496703205376'::HUGEINT, '17014118346046923173168730371588410572'::HUGEINT; +-- +ok +== +SELECT '-1267650600228229401496703205376'::HUGEINT, '-17014118346046923173168730371588410572'::HUGEINT; +-- +ok +== +SELECT '1701411834604692317316873037158841057200'::HUGEINT; +-- +ok +== +SELECT '-1701411834604692317316873037158841057200'::HUGEINT; +-- +ok +== +SELECT '170141183460469231731687303715884105727'::HUGEINT, '-170141183460469231731687303715884105728'::HUGEINT; +-- +ok +== +SELECT '170141183460469231731687303715884105728'::HUGEINT; +-- +ok +== +SELECT '-170141183460469231731687303715884105729'::HUGEINT; +-- +ok +== +SELECT 42::TINYINT::HUGEINT, 42::SMALLINT::HUGEINT, 42::INTEGER::HUGEINT, 42::BIGINT::HUGEINT, 42::FLOAT::HUGEINT, 42::DOUBLE::HUGEINT; +-- +ok +== +SELECT (-42)::TINYINT::HUGEINT, (-42)::SMALLINT::HUGEINT, (-42)::INTEGER::HUGEINT, (-42)::BIGINT::HUGEINT, (-42)::FLOAT::HUGEINT, (-42)::DOUBLE::HUGEINT; +-- +ok +== +SELECT 42::HUGEINT::TINYINT, 42::HUGEINT::SMALLINT, 42::HUGEINT::INTEGER, 42::HUGEINT::BIGINT, 42::HUGEINT::FLOAT, 42::HUGEINT::DOUBLE; +-- +ok +== +SELECT (-42)::HUGEINT::TINYINT, (-42)::HUGEINT::SMALLINT, (-42)::HUGEINT::INTEGER, (-42)::HUGEINT::BIGINT, (-42)::HUGEINT::FLOAT, (-42)::HUGEINT::DOUBLE; +-- +ok +== +SELECT 1000::HUGEINT::TINYINT; +-- +ok +== +SELECT 128::HUGEINT::TINYINT; +-- +ok +== +SELECT -128::HUGEINT::TINYINT; +-- +ok +== +SELECT 127::HUGEINT::TINYINT, -127::HUGEINT::TINYINT; +-- +ok +== +SELECT 100000::HUGEINT::SMALLINT; +-- +ok +== +SELECT 32768::HUGEINT::SMALLINT; +-- +ok +== +SELECT -32768::HUGEINT::SMALLINT; +-- +ok +== +SELECT 32767::HUGEINT::SMALLINT, -32767::HUGEINT::SMALLINT; +-- +ok +== +SELECT 100000000000::HUGEINT::INTEGER; +-- +ok +== +SELECT 2147483648::HUGEINT::INTEGER; +-- +ok +== +SELECT -2147483648::HUGEINT::INTEGER; +-- +ok +== +SELECT 2147483647::HUGEINT::INTEGER, -2147483647::HUGEINT::INTEGER; +-- +ok +== +SELECT 10000000000000000000::HUGEINT::BIGINT; +-- +ok +== +SELECT '9223372036854775808'::HUGEINT::BIGINT; +-- +ok +== +SELECT '-9223372036854775809'::HUGEINT::BIGINT; +-- +ok +== +SELECT 9223372036854775807::HUGEINT::BIGINT, (-9223372036854775808)::HUGEINT::BIGINT; +-- +ok +== +SELECT 1e100::FLOAT::HUGEINT; +-- +ok +== +SELECT 1e100::DOUBLE::HUGEINT; +-- +ok +== +SELECT typeof(10), typeof(10000000000), typeof(170141183460469231731687303715884105727), typeof(170141183460469231731687303715884105728), typeof(170141183460469231731687303715884105728000) +-- +ok +== +select 1e30, 1e100, 1e-1 +-- +ok +== +select typeof(1e30), typeof(1e100), typeof(1e-1) +-- +ok +== diff --git a/parser/testdata/corpus/sql/types/hugeint/test_hugeint_exponent.test b/parser/testdata/corpus/sql/types/hugeint/test_hugeint_exponent.test new file mode 100644 index 0000000..6430e1c --- /dev/null +++ b/parser/testdata/corpus/sql/types/hugeint/test_hugeint_exponent.test @@ -0,0 +1,37 @@ +# source: test/sql/types/hugeint/test_hugeint_exponent.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +select '170141183460469231731687303715884105700e0'::hugeint +-- +ok +== +select '170141183460469231731687303715884105727e0'::hugeint +-- +ok +== +select '170141183460469231731687303715884105735e0'::hugeint +-- +ok +== +select '1.7e39'::hugeint +-- +ok +== +select '2e38'::hugeint +-- +ok +== +select '0.0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000001e5'::hugeint; +-- +ok +== +select '1.0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000001e5'::hugeint; +-- +ok +== +select '1.1000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000001e5'::hugeint; +-- +ok +== diff --git a/parser/testdata/corpus/sql/types/hugeint/test_hugeint_functions.test b/parser/testdata/corpus/sql/types/hugeint/test_hugeint_functions.test new file mode 100644 index 0000000..1808e5b --- /dev/null +++ b/parser/testdata/corpus/sql/types/hugeint/test_hugeint_functions.test @@ -0,0 +1,33 @@ +# source: test/sql/types/hugeint/test_hugeint_functions.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +select abs(1::HUGEINT), abs('-1329227995784915872903807060280344576'::HUGEINT), abs(0::HUGEINT) +-- +ok +== +select sign(1::HUGEINT), sign('-1329227995784915872903807060280344576'::HUGEINT), sign(0::HUGEINT) +-- +ok +== +select round(1::HUGEINT, 0), round('-1329227995784915872903807060280344576'::HUGEINT, 0), round(0::HUGEINT, 0) +-- +ok +== +select floor(1::HUGEINT), floor('-1329227995784915872903807060280344576'::HUGEINT), floor(0::HUGEINT) +-- +ok +== +select ceil(1::HUGEINT), ceil('-1329227995784915872903807060280344576'::HUGEINT), ceil(0::HUGEINT) +-- +ok +== +select LEAST(1::HUGEINT, '-1329227995784915872903807060280344576'::HUGEINT, 0::HUGEINT) +-- +ok +== +select GREATEST(1::HUGEINT, '-1329227995784915872903807060280344576'::HUGEINT, 0::HUGEINT) +-- +ok +== diff --git a/parser/testdata/corpus/sql/types/hugeint/test_hugeint_null_value.test b/parser/testdata/corpus/sql/types/hugeint/test_hugeint_null_value.test new file mode 100644 index 0000000..8eb0593 --- /dev/null +++ b/parser/testdata/corpus/sql/types/hugeint/test_hugeint_null_value.test @@ -0,0 +1,37 @@ +# source: test/sql/types/hugeint/test_hugeint_null_value.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +SELECT NULL::HUGEINT +-- +ok +== +CREATE TABLE hugeints(id INTEGER, h HUGEINT) +-- +ok +== +INSERT INTO hugeints VALUES (1, NULL), (1, 1), (1, 2) +-- +ok +== +SELECT id, FIRST(h), LAST(h) FROM hugeints WHERE h IS NULL GROUP BY id +-- +ok +== +SELECT h, SUM(id) FROM hugeints GROUP BY h ORDER BY 1 +-- +ok +== +SELECT id, h1.h, h2.h FROM hugeints h1 JOIN hugeints h2 USING (id) WHERE h1.h IS NULL AND h2.h IS NULL +-- +ok +== +SELECT (SELECT h1.h) FROM hugeints h1 ORDER BY 1 +-- +ok +== +SELECT h1.h NOT IN (SELECT h1.h+h2.h FROM hugeints h2) FROM hugeints h1 ORDER BY 1 +-- +ok +== diff --git a/parser/testdata/corpus/sql/types/hugeint/test_hugeint_ops.test b/parser/testdata/corpus/sql/types/hugeint/test_hugeint_ops.test new file mode 100644 index 0000000..a0429db --- /dev/null +++ b/parser/testdata/corpus/sql/types/hugeint/test_hugeint_ops.test @@ -0,0 +1,58 @@ +# source: test/sql/types/hugeint/test_hugeint_ops.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +CREATE TABLE hugeints(h HUGEINT); +-- +ok +== +INSERT INTO hugeints VALUES (42::HUGEINT), ('1267650600228229401496703205376'::HUGEINT); +-- +ok +== +SELECT h::INTEGER FROM hugeints WHERE h < 100 +-- +ok +== +SELECT COUNT(*) FROM hugeints WHERE h = 42::HUGEINT +-- +ok +== +SELECT COUNT(*) FROM hugeints WHERE h <> '1267650600228229401496703205376'::HUGEINT +-- +ok +== +SELECT COUNT(*) FROM hugeints WHERE h < '1267650600228229401496703205376'::HUGEINT +-- +ok +== +SELECT COUNT(*) FROM hugeints WHERE h <= '1267650600228229401496703205376'::HUGEINT +-- +ok +== +SELECT COUNT(*) FROM hugeints WHERE h > '1267650600228229401496703205375'::HUGEINT +-- +ok +== +SELECT COUNT(*) FROM hugeints WHERE h >= 42::HUGEINT +-- +ok +== +CREATE TABLE hugeints2(h HUGEINT); +INSERT INTO hugeints2 VALUES (42::HUGEINT); +-- +ok +== +SELECT * FROM hugeints JOIN hugeints2 USING (h); +-- +ok +== +SELECT * FROM hugeints t1 JOIN hugeints2 t2 ON t1.h <> t2.h +-- +ok +== +SELECT * FROM hugeints t1 JOIN hugeints2 t2 ON t1.h >= t2.h ORDER BY 1 LIMIT 2 +-- +ok +== diff --git a/parser/testdata/corpus/sql/types/interval/frac_interval.test b/parser/testdata/corpus/sql/types/interval/frac_interval.test new file mode 100644 index 0000000..c584610 --- /dev/null +++ b/parser/testdata/corpus/sql/types/interval/frac_interval.test @@ -0,0 +1,101 @@ +# source: test/sql/types/interval/frac_interval.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +select interval '0.00005 MILLENNIUM'; +-- +ok +== +select interval '0.00004 MILLENNIUM'; +-- +ok +== +select interval '0.0005 CENTURY'; +-- +ok +== +select interval '0.0004 CENTURY'; +-- +ok +== +select interval '0.005 DECADE'; +-- +ok +== +select interval '0.004 DECADE'; +-- +ok +== +select interval '0.05 YEAR'; +-- +ok +== +select interval '0.04 YEAR'; +-- +ok +== +select interval '0.05 MONTH'; +-- +ok +== +select interval '0.04 MONTH'; +-- +ok +== +select interval '0.05 WEEK'; +-- +ok +== +select interval '0.04 WEEK'; +-- +ok +== +select interval '0.0000000005 DAY'; +-- +ok +== +select interval '0.0000000004 DAY'; +-- +ok +== +select interval '0.0000000005 HOUR'; +-- +ok +== +select interval '0.0000000004 HOUR'; +-- +ok +== +select interval '0.00000005 MINUTE'; +-- +ok +== +select interval '0.00000004 MINUTE'; +-- +ok +== +select interval '0.000005 SECOND'; +-- +ok +== +select interval '0.000004 SECOND'; +-- +ok +== +select interval '0.005 MILLISECONDS'; +-- +ok +== +select interval '0.004 MILLISECONDS'; +-- +ok +== +select interval '0.5 MICROSECONDS'; +-- +ok +== +select interval '0.4 MICROSECONDS'; +-- +ok +== diff --git a/parser/testdata/corpus/sql/types/interval/interval_alias.test b/parser/testdata/corpus/sql/types/interval/interval_alias.test new file mode 100644 index 0000000..1aa8829 --- /dev/null +++ b/parser/testdata/corpus/sql/types/interval/interval_alias.test @@ -0,0 +1,9 @@ +# source: test/sql/types/interval/interval_alias.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +SELECT alias('5 days'::INTERVAL DAY TO SECOND); +-- +ok +== diff --git a/parser/testdata/corpus/sql/types/interval/interval_constants.test b/parser/testdata/corpus/sql/types/interval/interval_constants.test new file mode 100644 index 0000000..db33515 --- /dev/null +++ b/parser/testdata/corpus/sql/types/interval/interval_constants.test @@ -0,0 +1,369 @@ +# source: test/sql/types/interval/interval_constants.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +SELECT interval 2 days; +-- +ok +== +SELECT interval (2) day; +-- +ok +== +SELECT interval (1+1) days; +-- +ok +== +SELECT interval '2' days; +-- +ok +== +SELECT to_years(2), to_months(2), to_days(2), to_hours(2), to_minutes(2), to_seconds(2); +-- +ok +== +SELECT interval (i) day from range(1, 4) tbl(i); +-- +ok +== +SELECT interval (i + 1) day from range(1, 4) tbl(i); +-- +ok +== +SELECT interval 2 years, interval 2 year; +-- +ok +== +SELECT interval 2 months, interval 2 month; +-- +ok +== +SELECT interval 2 days, interval 2 day; +-- +ok +== +SELECT interval 2 hours, interval 2 hour; +-- +ok +== +SELECT interval 2 minutes, interval 2 minute; +-- +ok +== +SELECT interval 2 seconds, interval 2 second; +-- +ok +== +SELECT interval '2 10' years to months +-- +error: Parser Error: YEAR TO MONTH is not supported +== +SELECT interval '2 10' days to hours +-- +error: Parser Error: DAY TO HOUR is not supported +== +SELECT interval '12 15:06' days to minutes +-- +error: Parser Error: DAY TO MINUTE is not supported +== +SELECT interval '12 15:06:04.123' days to seconds +-- +error: Parser Error: DAY TO SECOND is not supported +== +SELECT interval '12:30' hours to minutes +-- +error: Parser Error: HOUR TO MINUTE is not supported +== +SELECT interval '15:06:04.123' hours to seconds +-- +error: Parser Error: HOUR TO SECOND is not supported +== +SELECT interval '12:30' minutes to seconds +-- +error: Parser Error: MINUTE TO SECOND is not supported +== +SELECT interval '99999999999999' years; +-- +ok +== +SELECT interval '214748364' years; +-- +ok +== +SELECT interval '9223372036854775807' hours; +-- +ok +== +SELECT interval '9223372036854775807' minutes; +-- +ok +== +SELECT interval '9223372036854775807' seconds; +-- +ok +== +SELECT interval '9223372036854775807' milliseconds; +-- +ok +== +SELECT interval 3 millisecond, interval 3 milliseconds; +-- +ok +== +SELECT interval 3 microsecond, interval 3 microseconds; +-- +ok +== +SELECT interval 3 week, interval 3 weeks; +-- +ok +== +SELECT interval 3 decade, interval 3 decades; +-- +ok +== +SELECT interval 3 century, interval 3 centuries; +-- +ok +== +SELECT interval 3 millennium, interval 3 millennia; +-- +ok +== +select timestamp '1992-01-01 12:00:00' + interval 3 microseconds + interval 3 milliseconds +-- +ok +== +select timestamp '1992-01-01 12:00:00' + (interval 3 microseconds + interval 3 milliseconds) +-- +ok +== +select interval '10.123' second; +-- +ok +== +select '47.210'::interval; +-- +ok +== +select '-47.210'::interval; +-- +ok +== +select '47.210 '::interval; +-- +ok +== +select '31.123456789'::interval; +-- +ok +== +select '47.210 5'::interval; +-- +ok +== +SELECT INTERVAL '1.5' MICROSECOND; +-- +ok +== +SELECT INTERVAL '1.5' MILLISECOND; +-- +ok +== +SELECT INTERVAL '1.5' SECOND; +-- +ok +== +SELECT INTERVAL '1.5' MINUTE; +-- +ok +== +SELECT INTERVAL '1.5' HOUR; +-- +ok +== +SELECT INTERVAL '1.5' DAY; +-- +ok +== +SELECT INTERVAL '1.5' WEEK; +-- +ok +== +SELECT INTERVAL '1.5' MONTH; +-- +ok +== +SELECT INTERVAL '1.5' YEAR; +-- +ok +== +SELECT INTERVAL '1.5' DECADE; +-- +ok +== +SELECT INTERVAL '1.5' CENTURY; +-- +ok +== +SELECT INTERVAL '1.5' MILLENNIA; +-- +ok +== +SELECT INTERVAL '-1.5' MICROSECOND; +-- +ok +== +SELECT INTERVAL '-1.5' MILLISECOND; +-- +ok +== +SELECT INTERVAL '-1.5' SECOND; +-- +ok +== +SELECT INTERVAL '-1.5' MINUTE; +-- +ok +== +SELECT INTERVAL '-1.5' HOUR; +-- +ok +== +SELECT INTERVAL '-1.5' DAY; +-- +ok +== +SELECT INTERVAL '-1.5' WEEK; +-- +ok +== +SELECT INTERVAL '-1.5' MONTH; +-- +ok +== +SELECT INTERVAL '-1.5' YEAR; +-- +ok +== +SELECT INTERVAL '-1.5' DECADE; +-- +ok +== +SELECT INTERVAL '-1.5' CENTURY; +-- +ok +== +SELECT INTERVAL '-1.5' MILLENNIA; +-- +ok +== +SELECT '1.5 MICROSECOND'::INTERVAL; +-- +ok +== +SELECT '1.5 MILLISECOND'::INTERVAL; +-- +ok +== +SELECT '1.5 SECOND'::INTERVAL; +-- +ok +== +SELECT '1.5 MINUTE'::INTERVAL; +-- +ok +== +SELECT '1.5 HOUR'::INTERVAL; +-- +ok +== +SELECT '1.5 DAY'::INTERVAL; +-- +ok +== +SELECT '1.5 WEEK'::INTERVAL; +-- +ok +== +SELECT '1.5 MONTH'::INTERVAL; +-- +ok +== +SELECT '1.5 QUARTER'::INTERVAL; +-- +ok +== +SELECT '1.5 YEAR'::INTERVAL +-- +ok +== +SELECT '1.5 DECADE'::INTERVAL +-- +ok +== +SELECT '1.5 CENTURY'::INTERVAL +-- +ok +== +SELECT '1.5 MILLENIUM'::INTERVAL +-- +ok +== +SELECT '-1.5 MICROSECOND'::INTERVAL; +-- +ok +== +SELECT '-1.5 MILLISECOND'::INTERVAL; +-- +ok +== +SELECT '-1.5 SECOND'::INTERVAL; +-- +ok +== +SELECT '-1.5 MINUTE'::INTERVAL; +-- +ok +== +SELECT '-1.5 HOUR'::INTERVAL; +-- +ok +== +SELECT '-1.5 DAY'::INTERVAL; +-- +ok +== +SELECT '-1.5 WEEK'::INTERVAL; +-- +ok +== +SELECT '-1.5 MONTH'::INTERVAL; +-- +ok +== +SELECT '-1.5 QUARTER'::INTERVAL; +-- +ok +== +SELECT '-1.5 YEAR'::INTERVAL +-- +ok +== +SELECT '-1.5 DECADE'::INTERVAL +-- +ok +== +SELECT '-1.5 CENTURY'::INTERVAL +-- +ok +== +SELECT '-1.5 MILLENIUM'::INTERVAL +-- +ok +== +select {func}(84::{type}); +-- +error: Parser Error: syntax error at or near "}" +== diff --git a/parser/testdata/corpus/sql/types/interval/interval_constants.test.metadata.json b/parser/testdata/corpus/sql/types/interval/interval_constants.test.metadata.json new file mode 100644 index 0000000..4409b90 --- /dev/null +++ b/parser/testdata/corpus/sql/types/interval/interval_constants.test.metadata.json @@ -0,0 +1,11 @@ +{ + "todo": { + "04ee46798d97f4b6": "transformer-raised parser error: upstream rejects in the transformer, not the grammar; expected to clear as transformers land (milestones 3-5)", + "6124af0548343e75": "transformer-raised parser error: upstream rejects in the transformer, not the grammar; expected to clear as transformers land (milestones 3-5)", + "7368d1dbd4b24fc7": "transformer-raised parser error: upstream rejects in the transformer, not the grammar; expected to clear as transformers land (milestones 3-5)", + "80b6093f251a3f04": "transformer-raised parser error: upstream rejects in the transformer, not the grammar; expected to clear as transformers land (milestones 3-5)", + "90584cf0d74da9a8": "transformer-raised parser error: upstream rejects in the transformer, not the grammar; expected to clear as transformers land (milestones 3-5)", + "a9dad68a8d894d49": "transformer-raised parser error: upstream rejects in the transformer, not the grammar; expected to clear as transformers land (milestones 3-5)", + "db10f4deff33212f": "transformer-raised parser error: upstream rejects in the transformer, not the grammar; expected to clear as transformers land (milestones 3-5)" + } +} diff --git a/parser/testdata/corpus/sql/types/interval/interval_try_cast.test b/parser/testdata/corpus/sql/types/interval/interval_try_cast.test new file mode 100644 index 0000000..29c1f59 --- /dev/null +++ b/parser/testdata/corpus/sql/types/interval/interval_try_cast.test @@ -0,0 +1,89 @@ +# source: test/sql/types/interval/interval_try_cast.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +SELECT cast(' ' as interval) +-- +ok +== +SELECT cast('AAAA' as interval) +-- +ok +== +SELECT cast('00:00:' as interval) +-- +ok +== +SELECT cast('3 doopiedoos' as interval) +-- +ok +== +SELECT cast('3 years 2 doy' as interval) +-- +ok +== +SELECT cast('3 yearweek' as interval) +-- +ok +== +SELECT cast(NULL as interval) +-- +ok +== +SELECT try_cast(' ' as interval) +-- +ok +== +SELECT try_cast('AAAA' as interval) +-- +ok +== +SELECT try_cast('00:00:' as interval) +-- +ok +== +SELECT try_cast('3 doopiedoos' as interval) +-- +ok +== +SELECT try_cast('3 years 2 doy' as interval) +-- +ok +== +SELECT try_cast(NULL as interval) +-- +ok +== +SELECT + TRY_CAST('42 seconds' AS INTERVAL), + TRY_CAST('42 ' AS INTERVAL), + TRY_CAST('42' AS INTERVAL), + TRY_CAST(' 42' AS INTERVAL); +-- +ok +== +SELECT + TRY_CAST('42x' AS INTERVAL) +-- +ok +== +SELECT + TRY_CAST('42.5' AS INTERVAL), + TRY_CAST('42.5 ' AS INTERVAL), + '42.5'::INTERVAL; +-- +ok +== +SELECT + TRY_CAST('2147483648 days' AS INTERVAL), + TRY_CAST('-2147483649 days' AS INTERVAL), + TRY_CAST('2147483648 months' AS INTERVAL), + TRY_CAST('9223372036854775808 microseconds' AS INTERVAL); +-- +ok +== +SELECT CAST('2147483648 days' AS INTERVAL); +-- +ok +== diff --git a/parser/testdata/corpus/sql/types/interval/test_interval.test b/parser/testdata/corpus/sql/types/interval/test_interval.test new file mode 100644 index 0000000..f32fba2 --- /dev/null +++ b/parser/testdata/corpus/sql/types/interval/test_interval.test @@ -0,0 +1,315 @@ +# source: test/sql/types/interval/test_interval.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +SELECT INTERVAL '2 years' +-- +ok +== +SELECT INTERVAL '2 years'::VARCHAR +-- +ok +== +SELECT INTERVAL '2Y 1 M'; +-- +ok +== +SELECT INTERVAL '2Y 1 month 1 M 3S 20mS 16uS'; +-- +ok +== +SELECT INTERVAL '2Y 1 month 02:01:03.020016'; +-- +ok +== +SELECT INTERVAL '2Y 1 month 1M 3S 20mS 16uS'::VARCHAR; +-- +ok +== +SELECT INTERVAL '2 yr 1 mon 1 min 3 sec 20 msec 16 usec'; +-- +ok +== +SELECT INTERVAL '2 yrs 1 mons 1 mins 3 secs 20 msecs 16 usecs'; +-- +ok +== +SELECT INTERVAL '-2Y 4 days 5 Hours 1 MinUteS 3S 20mS 16uS'; +-- +ok +== +SELECT INTERVAL '-2Y 4 days 5 Hours 1 MinUteS 3S 20mS 16uS'::VARCHAR; +-- +ok +== +SELECT INTERVAL '-2yr 4 d 5 hr 1 min 3 second 20 msecond 16 usecond'; +-- +ok +== +SELECT INTERVAL '-2yrs 4 d 5 hrs 1 mins 3 seconds 20 mseconds 16 useconds'::VARCHAR; +-- +ok +== +SELECT INTERVAL '2Y 4 days 1 MinUteS 3S 20mS 16uS ago'::VARCHAR; +-- +ok +== +SELECT INTERVAL '2Y 4 days 1 MinUteS 3S 20mS 16uS ago '::VARCHAR; +-- +ok +== +SELECT interval '-2147483648 months' AS without_ago, + interval '-2147483648 months ago' AS with_ago, + interval '-2147483648 months' = interval '-2147483648 months ago' AS are_equal; +-- +ok +== +SELECT INTERVAL '@2mons 1H'; +-- +ok +== +select interval '05:12:34.567890' as test_interval; +-- +ok +== +select interval '-05:12:34.567890' as test_interval; +-- +ok +== +SELECT ('35:10:00'::interval); +-- +ok +== +select '876:54:32.101234'::INTERVAL, '-876:54:32.101234'::INTERVAL; +-- +ok +== +select '999999999:54:32.101234'::INTERVAL, '-999999999:54:32.101234'::INTERVAL; +-- +ok +== +select '9999999999:54:32.101234'::INTERVAL; +-- +ok +== +select '-9999999999:54:32.101234'::INTERVAL; +-- +ok +== +SELECT INTERVAL 'P2MT1H1M'; +-- +ok +== +SELECT INTERVAL 'P00-02-00T01:00:01'; +-- +ok +== +SELECT INTERVAL '90' DAY; +-- +ok +== +SELECT INTERVAL '90' YEAR; +-- +ok +== +SELECT INTERVAL '90' QUARTER; +-- +ok +== +SELECT INTERVAL '90' MONTH; +-- +ok +== +SELECT INTERVAL '90' SECOND; +-- +ok +== +SELECT INTERVAL '90' MINUTE; +-- +ok +== +SELECT INTERVAL '90' HOUR; +-- +ok +== +SELECT INTERVAL '2 month' + INTERVAL '1 month 3 days'; +-- +ok +== +SELECT INTERVAL '2 month' - INTERVAL '1 month 3 days'; +-- +ok +== +SELECT INTERVAL '2 month' * INTERVAL '1 month 3 days'; +-- +ok +== +SELECT INTERVAL '1 year 2 days 2 seconds' * 2; +-- +ok +== +SELECT 2 * INTERVAL '1 year 2 days 2 seconds'; +-- +ok +== +SELECT INTERVAL '1 year 2 days 2 seconds' / 2; +-- +ok +== +SELECT 2 / INTERVAL '1 year 2 days 2 seconds'; +-- +ok +== +SELECT INTERVAL '1 year 2 days 2 seconds' / 0; +-- +ok +== +SELECT INTERVAL ''; +-- +ok +== +SELECT INTERVAL ' '; +-- +ok +== +SELECT INTERVAL 'years'; +-- +ok +== +SELECT INTERVAL '-years'; +-- +ok +== +SELECT INTERVAL 'aergjaerghiuaehrgiuhaerg'; +-- +ok +== +SELECT INTERVAL '100000000000000000year'; +-- +ok +== +SELECT INTERVAL '100000000000000000months'; +-- +ok +== +SELECT INTERVAL '4294967296months'; +-- +ok +== +SELECT INTERVAL '1294967296months'; +-- +ok +== +SELECT INTERVAL '1294967296months 1294967296months'; +-- +ok +== +SELECT INTERVAL '1294967296months -1294967296months'; +-- +ok +== +SELECT INTERVAL '-1294967296months -1294967296months'; +-- +ok +== +SELECT INTERVAL '100000000000000000days'; +-- +ok +== +SELECT INTERVAL '1294967296days 1294967296days'; +-- +ok +== +SELECT INTERVAL '100000000000000000000msecs'; +-- +ok +== +SELECT INTERVAL '100000000000000000hours'; +-- +ok +== +SELECT INTERVAL '2562047788 hours'; +-- +ok +== +SELECT INTERVAL '2562047788 hours 2562047788 hours'; +-- +ok +== +SELECT INTERVAL '-9223372036854775msecs'; +-- +ok +== +SELECT INTERVAL '9223372036854775msecs'; +-- +ok +== +SELECT INTERVAL '1 week'; +-- +ok +== +SELECT INTERVAL '1 millennium 2 centuries 1 decade 3 quarter'; +-- +ok +== +SELECT INTERVAL '1 millenniums 2 century 1 dec 3 quarter'; +-- +ok +== +SELECT INTERVAL '1 mil 2 cent 1 decs 3 quarter'; +-- +ok +== +SELECT INTERVAL '1 mils 2 c 1 decades 3 quarter'; +-- +ok +== +SELECT INTERVAL '-2147483647 months -2147483647 days -9223372036854775msecs'; +-- +ok +== +SELECT INTERVAL '2147483647 months 2147483647 days 9223372036854775msecs'; +-- +ok +== +SELECT INTERVAL '9223372036854775810msecs'; +-- +ok +== +SELECT INTERVAL '-9223372036854775810msecs'; +-- +ok +== +SELECT INTERVAL 'aa' DAY; +-- +ok +== +SELECT INTERVAL '100 months' DAY; +-- +ok +== +SELECT '100'::INTERVAL; +-- +ok +== +SELECT '100 unknowns'::INTERVAL; +-- +ok +== +SELECT '100 months a'::INTERVAL; +-- +ok +== +SELECT '100 months axo'::INTERVAL; +-- +ok +== +SELECT '100 months agb'::INTERVAL; +-- +ok +== +SELECT '100 months agob'::INTERVAL; +-- +ok +== diff --git a/parser/testdata/corpus/sql/types/interval/test_interval_addition.test b/parser/testdata/corpus/sql/types/interval/test_interval_addition.test new file mode 100644 index 0000000..2d917d8 --- /dev/null +++ b/parser/testdata/corpus/sql/types/interval/test_interval_addition.test @@ -0,0 +1,250 @@ +# source: test/sql/types/interval/test_interval_addition.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +SELECT DATE '1992-03-01' + INTERVAL '1' YEAR +-- +ok +== +SELECT DATE '1992-03-01' + INTERVAL '0' MONTH +-- +ok +== +SELECT DATE '1992-03-01' - INTERVAL '0' MONTH +-- +ok +== +SELECT DATE '1992-03-01' + INTERVAL '1' MONTH +-- +ok +== +SELECT DATE '1992-03-01' - INTERVAL '1' MONTH +-- +ok +== +SELECT DATE '1992-03-01' + INTERVAL '2' MONTH +-- +ok +== +SELECT DATE '1992-03-01' - INTERVAL '2' MONTH +-- +ok +== +SELECT DATE '1992-03-01' + INTERVAL '3' MONTH +-- +ok +== +SELECT DATE '1992-03-01' - INTERVAL '3' MONTH +-- +ok +== +SELECT DATE '1992-03-01' + INTERVAL '4' MONTH +-- +ok +== +SELECT DATE '1992-03-01' - INTERVAL '4' MONTH +-- +ok +== +SELECT DATE '1992-03-01' + INTERVAL '5' MONTH +-- +ok +== +SELECT DATE '1992-03-01' - INTERVAL '5' MONTH +-- +ok +== +SELECT DATE '1992-03-01' + INTERVAL '6' MONTH +-- +ok +== +SELECT DATE '1992-03-01' - INTERVAL '6' MONTH +-- +ok +== +SELECT DATE '1992-03-01' + INTERVAL '7' MONTH +-- +ok +== +SELECT DATE '1992-03-01' - INTERVAL '7' MONTH +-- +ok +== +SELECT DATE '1992-03-01' + INTERVAL '8' MONTH +-- +ok +== +SELECT DATE '1992-03-01' - INTERVAL '8' MONTH +-- +ok +== +SELECT DATE '1992-03-01' + INTERVAL '9' MONTH +-- +ok +== +SELECT DATE '1992-03-01' - INTERVAL '9' MONTH +-- +ok +== +SELECT DATE '1992-03-01' + INTERVAL '10' MONTH +-- +ok +== +SELECT DATE '1992-03-01' - INTERVAL '10' MONTH +-- +ok +== +SELECT DATE '1992-03-01' + INTERVAL '11' MONTH +-- +ok +== +SELECT DATE '1992-03-01' - INTERVAL '11' MONTH +-- +ok +== +SELECT DATE '1992-03-01' + INTERVAL '12' MONTH +-- +ok +== +SELECT DATE '1992-03-01' - INTERVAL '12' MONTH +-- +ok +== +SELECT DATE '1992-03-01' + INTERVAL '10' DAY +-- +ok +== +SELECT DATE '1992-03-01' - INTERVAL '10' DAY +-- +ok +== +SELECT DATE '1993-03-01' - INTERVAL '10' DAY +-- +ok +== +SELECT DATE '1993-03-01' + INTERVAL '1' SECOND +-- +ok +== +SELECT DATE '1993-03-01' - INTERVAL '1' SECOND +-- +ok +== +SELECT DATE '1993-03-01' + INTERVAL '1000000' SECOND +-- +ok +== +SELECT DATE '1993-03-01' - INTERVAL '1000000' SECOND +-- +ok +== +SELECT INTERVAL '1000000' SECOND - DATE '1993-03-01' +-- +ok +== +SELECT TIME '10:00:00' + INTERVAL '5' SECOND +-- +ok +== +SELECT INTERVAL '5' SECOND + TIME '10:00:00' +-- +ok +== +SELECT TIME '10:00:00' - INTERVAL '5' SECOND +-- +ok +== +SELECT TIME '10:00:00' + INTERVAL '1' DAY +-- +ok +== +SELECT TIME '23:00:00' + INTERVAL '1' HOUR +-- +ok +== +SELECT TIME '00:00:00' - INTERVAL '1' HOUR +-- +ok +== +SELECT TIME '00:00:00' + INTERVAL '-1' HOUR +-- +ok +== +select '12:15:37.123456-08'::TIMETZ + INTERVAL '2 HOUR'; +-- +ok +== +select '12:15:37.123456-08'::TIMETZ + INTERVAL '22 HOUR'; +-- +ok +== +select '12:15:37.123456-08'::TIMETZ + INTERVAL '2 DAY'; +-- +ok +== +select INTERVAL '2 HOUR' + '12:15:37.123456-08'::TIMETZ; +-- +ok +== +select INTERVAL '22 HOUR' + '12:15:37.123456-08'::TIMETZ; +-- +ok +== +select INTERVAL '2 DAY' + '12:15:37.123456-08'::TIMETZ; +-- +ok +== +select '12:15:37.123456-08'::TIMETZ - INTERVAL '2 HOUR'; +-- +ok +== +select '12:15:37.123456-08'::TIMETZ - INTERVAL '22 HOUR'; +-- +ok +== +select '12:15:37.123456-08'::TIMETZ - INTERVAL '2 DAY'; +-- +ok +== +select INTERVAL '2 HOUR' - '12:15:37.123456-08'::TIMETZ; +-- +ok +== +SELECT TIMESTAMP '1992-01-01 10:00:00' + INTERVAL '1' DAY +-- +ok +== +SELECT INTERVAL '1' DAY + TIMESTAMP '1992-01-01 10:00:00' +-- +ok +== +SELECT TIMESTAMP '1992-01-01 10:00:05' + INTERVAL '17 years 3 months 1 day 2 hours 1 minute 57 seconds' +-- +ok +== +SELECT TIMESTAMP '1992-01-01 10:00:00' - INTERVAL '1' DAY +-- +ok +== +select timestamp '1993-01-01 00:00:00' - timestamp '1991-01-01 01:00:30'; +-- +ok +== +CREATE TABLE issue1998(id INTEGER, lhs TIMESTAMP, rhs TIMESTAMP); +-- +ok +== +INSERT INTO issue1998 VALUES + (0, '2020-07-07 02:01:01', '2020-08-05 07:51:47'), + (1, '2020-02-08 19:26:38', '2020-09-21 10:02:28'), + (2, '2020-06-19 20:45:41', '2020-01-04 05:44:42'), + (3, '2020-11-18 18:22:26', '2020-06-14 02:46:55'), + (4, '2020-08-24 03:31:52', '2020-07-05 19:04:34') +-- +ok +== +SELECT id, lhs - rhs FROM issue1998 ORDER BY 1 +-- +ok +== diff --git a/parser/testdata/corpus/sql/types/interval/test_interval_between.test b/parser/testdata/corpus/sql/types/interval/test_interval_between.test new file mode 100644 index 0000000..e7098a2 --- /dev/null +++ b/parser/testdata/corpus/sql/types/interval/test_interval_between.test @@ -0,0 +1,37 @@ +# source: test/sql/types/interval/test_interval_between.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +WITH d(y) AS ( + SELECT UNNEST(range( + '2023-05-11 4:00:00'::TIMESTAMP, + '2023-05-11 4:00:00'::TIMESTAMP + TO_DAYS(7), + TO_HOURS(6) + )) +) +SELECT + y, + y - ('2023-05-11 4:00:00'::TIMESTAMP) AS x +FROM d +WHERE + x BETWEEN TO_HOURS(-44) AND TO_HOURS(44) +-- +ok +== +WITH d(y) AS ( + SELECT UNNEST(range( + '2023-05-11 4:00:00'::TIMESTAMP, + '2023-05-11 4:00:00'::TIMESTAMP + TO_DAYS(7), + TO_HOURS(6) + )) +) +SELECT + y, + y - ('2023-05-11 4:00:00'::TIMESTAMP) AS x +FROM d +WHERE + x >= TO_HOURS(-44) AND x <= TO_HOURS(44) +-- +ok +== diff --git a/parser/testdata/corpus/sql/types/interval/test_interval_comparison.test b/parser/testdata/corpus/sql/types/interval/test_interval_comparison.test new file mode 100644 index 0000000..09ea46f --- /dev/null +++ b/parser/testdata/corpus/sql/types/interval/test_interval_comparison.test @@ -0,0 +1,119 @@ +# source: test/sql/types/interval/test_interval_comparison.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +SELECT INTERVAL '30' DAY > INTERVAL '1' MONTH +-- +ok +== +SELECT INTERVAL '30' DAY = INTERVAL '1' MONTH +-- +ok +== +SELECT INTERVAL '30' DAY >= INTERVAL '1' MONTH +-- +ok +== +SELECT INTERVAL '31' DAY > INTERVAL '1' MONTH +-- +ok +== +SELECT INTERVAL '1' HOUR < INTERVAL '1' DAY +-- +ok +== +SELECT INTERVAL '30' HOUR <= INTERVAL '1' DAY +-- +ok +== +SELECT INTERVAL '1' HOUR = INTERVAL '1' HOUR +-- +ok +== +SELECT INTERVAL '1' YEAR = INTERVAL '12' MONTH +-- +ok +== +select interval '28 days 432000 seconds' = interval '1 month 3 days'; +-- +ok +== +select interval '1 month' - interval '4 days' = interval '26 days'; +-- +ok +== +select interval '26 days' < (interval '1 month' - interval '4 days'); +-- +ok +== +select interval '1 day' - interval '1 hour' = interval '23 hours'; +-- +ok +== +select interval '2 months' - interval '40 days' = interval '20 days'; +-- +ok +== +select interval '-1 month' + interval '4 days' = interval '-26 days'; +-- +ok +== +select normalized_interval(interval '-2147483648 months -2147483648 days -9223372036854775807 microseconds'); +-- +ok +== +select normalized_interval(interval '2147483647 months 2147483647 days 9223372036854775807 microseconds'); +-- +ok +== +CREATE TABLE issue14384(i INTERVAL); +-- +ok +== +INSERT INTO issue14384(i) VALUES + ('2 years 3 months'), + ('-1734799452 DAYS'), + ('2 DAYS'), + ('13 days'), + ('1 month'), + ('3 days'), +; +-- +ok +== +SELECT i FROM issue14384 ORDER BY ALL; +-- +ok +== +SELECT * +FROM issue14384 +INNER JOIN ( + SELECT INTERVAL 1000 DAY AS col0 + FROM issue14384) AS sub0 + ON (issue14384.i < sub0.col0) +ORDER BY ALL; +-- +ok +== +SELECT * +FROM issue14384 +INNER JOIN ( + SELECT INTERVAL 1000 DAY AS col0 FROM issue14384) AS sub0 + ON (issue14384.i < sub0.col0) +WHERE (NOT (issue14384.i != issue14384.i)) +ORDER BY ALL; +-- +ok +== +INSERT INTO issue14384(i) VALUES + ('1000 DAY'), + ('28 days 432000 seconds'), + ('1 month 3 days'), + ('2147483647 months 2147483647 days 9223372036854775807 microseconds'), + ('-2147483648 months -2147483648 days -9223372036854775807 microseconds'), + (NULL) +; +-- +ok +== diff --git a/parser/testdata/corpus/sql/types/interval/test_interval_ops.test b/parser/testdata/corpus/sql/types/interval/test_interval_ops.test new file mode 100644 index 0000000..5cffda1 --- /dev/null +++ b/parser/testdata/corpus/sql/types/interval/test_interval_ops.test @@ -0,0 +1,21 @@ +# source: test/sql/types/interval/test_interval_ops.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +SELECT * FROM interval i1 JOIN interval i2 USING (t) ORDER BY 1 +-- +ok +== +SELECT * FROM interval i1 JOIN interval i2 ON (i1.t <> i2.t) ORDER BY 1 +-- +ok +== +SELECT * FROM interval i1 JOIN interval i2 ON (i1.t > i2.t) ORDER BY 1 +-- +ok +== +SELECT t, row_number() OVER (PARTITION BY t ORDER BY t) FROM interval ORDER BY 1, 2; +-- +ok +== diff --git a/parser/testdata/corpus/sql/types/list/list_case.test b/parser/testdata/corpus/sql/types/list/list_case.test new file mode 100644 index 0000000..b27bf75 --- /dev/null +++ b/parser/testdata/corpus/sql/types/list/list_case.test @@ -0,0 +1,25 @@ +# source: test/sql/types/list/list_case.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +SELECT case when 1=1 then [1] else [2] end +-- +ok +== +SELECT case when 1=0 then [1] else [2] end +-- +ok +== +SELECT case when i%2=0 then [i] else [-i] end from range(5) tbl(i) +-- +ok +== +CREATE TABLE a AS SELECT case when i%2=0 then null else [i] end i from range(10) tbl(i) +-- +ok +== +select case when i=[1] then [3] else [4] end from a +-- +ok +== diff --git a/parser/testdata/corpus/sql/types/list/list_comparison.test b/parser/testdata/corpus/sql/types/list/list_comparison.test new file mode 100644 index 0000000..7eb73be --- /dev/null +++ b/parser/testdata/corpus/sql/types/list/list_comparison.test @@ -0,0 +1,612 @@ +# source: test/sql/types/list/list_comparison.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +SELECT [1] < [2] +-- +ok +== +SELECT [1] < [1] +-- +ok +== +SELECT NULL < [1] +-- +ok +== +SELECT [1] < NULL +-- +ok +== +SELECT [1] <= [2] +-- +ok +== +SELECT [1] <= [1] +-- +ok +== +SELECT NULL <= [1] +-- +ok +== +SELECT [1] <= NULL +-- +ok +== +SELECT [1] = [2] +-- +ok +== +SELECT [1] = [1] +-- +ok +== +SELECT NULL = [1] +-- +ok +== +SELECT [1] = NULL +-- +ok +== +SELECT [1] <> [2] +-- +ok +== +SELECT [1] <> [1] +-- +ok +== +SELECT NULL <> [1] +-- +ok +== +SELECT [1] <> NULL +-- +ok +== +SELECT [1] >= [2] +-- +ok +== +SELECT [1] >= [1] +-- +ok +== +SELECT NULL >= [1] +-- +ok +== +SELECT [1] >= NULL +-- +ok +== +SELECT [1] > [2] +-- +ok +== +SELECT [1] > [1] +-- +ok +== +SELECT NULL > [1] +-- +ok +== +SELECT [1] > NULL +-- +ok +== +CREATE VIEW list_int1 AS SELECT * FROM (VALUES + ([1], [1]), + ([1], [2]), + ([2], [1]), + (NULL, [1]), + ([2], NULL), + (NULL, NULL) + ) tbl(l, r); +-- +ok +== +SELECT l < r FROM list_int1 +-- +ok +== +SELECT l <= r FROM list_int1 +-- +ok +== +SELECT l = r FROM list_int1 +-- +ok +== +SELECT l <> r FROM list_int1 +-- +ok +== +SELECT l >= r FROM list_int1 +-- +ok +== +SELECT l > r FROM list_int1 +-- +ok +== +SELECT [1] < [1, 2] +-- +ok +== +SELECT [1] <= [1, 2] +-- +ok +== +SELECT [1] = [1, 2] +-- +ok +== +SELECT [1] <> [1, 2] +-- +ok +== +SELECT [1] >= [1, 2] +-- +ok +== +SELECT [1] > [1, 2] +-- +ok +== +CREATE VIEW list_int AS SELECT * FROM (VALUES + ([1], [1]), + ([1], [1, 2]), + ([1, 2], [1]), + (NULL, [1]), + ([1, 2], NULL), + (NULL, NULL) + ) tbl(l, r); +-- +ok +== +SELECT l < r FROM list_int +-- +ok +== +SELECT l <= r FROM list_int +-- +ok +== +SELECT l = r FROM list_int +-- +ok +== +SELECT l <> r FROM list_int +-- +ok +== +SELECT l >= r FROM list_int +-- +ok +== +SELECT l > r FROM list_int +-- +ok +== +SELECT [] < [1, 2] +-- +ok +== +SELECT [] < [] +-- +ok +== +SELECT NULL < [] +-- +ok +== +SELECT [] < NULL +-- +ok +== +SELECT [] <= [1, 2] +-- +ok +== +SELECT [] <= [] +-- +ok +== +SELECT NULL <= [] +-- +ok +== +SELECT [] <= NULL +-- +ok +== +SELECT [] = [1, 2] +-- +ok +== +SELECT [] = [] +-- +ok +== +SELECT NULL = [] +-- +ok +== +SELECT [] = NULL +-- +ok +== +SELECT [] <> [1, 2] +-- +ok +== +SELECT [] <> [] +-- +ok +== +SELECT NULL <> [] +-- +ok +== +SELECT [] <> NULL +-- +ok +== +SELECT [] >= [1, 2] +-- +ok +== +SELECT [] >= [] +-- +ok +== +SELECT NULL >= [] +-- +ok +== +SELECT [] >= NULL +-- +ok +== +SELECT [] > [1, 2] +-- +ok +== +SELECT [] > [] +-- +ok +== +SELECT NULL > [] +-- +ok +== +SELECT [] > NULL +-- +ok +== +CREATE VIEW list_int_empty AS SELECT * FROM (VALUES + ([], []), + ([], [1, 2]), + ([1, 2], []), + (NULL, []), + ([1, 2], NULL), + (NULL, NULL) + ) tbl(l, r); +-- +ok +== +SELECT l < r FROM list_int_empty +-- +ok +== +SELECT l <= r FROM list_int_empty +-- +ok +== +SELECT l = r FROM list_int_empty +-- +ok +== +SELECT l <> r FROM list_int_empty +-- +ok +== +SELECT l >= r FROM list_int_empty +-- +ok +== +SELECT l > r FROM list_int_empty +-- +ok +== +SELECT ['duck'] < ['duck', 'goose'] +-- +ok +== +SELECT ['duck'] < ['duck'] +-- +ok +== +SELECT NULL < ['duck'] +-- +ok +== +SELECT ['duck'] < NULL +-- +ok +== +SELECT ['duck'] <= ['duck', 'goose'] +-- +ok +== +SELECT ['duck'] <= ['duck'] +-- +ok +== +SELECT NULL <= ['duck'] +-- +ok +== +SELECT ['duck'] <= NULL +-- +ok +== +SELECT ['duck'] = ['duck', 'goose'] +-- +ok +== +SELECT ['duck'] = ['duck'] +-- +ok +== +SELECT NULL = ['duck'] +-- +ok +== +SELECT ['duck'] = NULL +-- +ok +== +SELECT ['duck'] <> ['duck', 'goose'] +-- +ok +== +SELECT ['duck'] <> ['duck'] +-- +ok +== +SELECT NULL <> ['duck'] +-- +ok +== +SELECT ['duck'] <> NULL +-- +ok +== +SELECT ['duck'] >= ['duck', 'goose'] +-- +ok +== +SELECT ['duck'] >= ['duck'] +-- +ok +== +SELECT NULL >= ['duck'] +-- +ok +== +SELECT ['duck'] >= NULL +-- +ok +== +SELECT ['duck'] > ['duck', 'goose'] +-- +ok +== +SELECT ['duck'] > ['duck'] +-- +ok +== +SELECT NULL > ['duck'] +-- +ok +== +SELECT ['duck'] > NULL +-- +ok +== +CREATE VIEW list_str AS SELECT * FROM (VALUES + (['duck'], ['duck']), + (['duck'], ['duck', 'goose']), + (['duck', 'goose'], ['duck']), + (NULL, ['duck']), + (['duck', 'goose'], NULL), + (NULL, NULL) + ) tbl(l, r); +-- +ok +== +SELECT l < r FROM list_str +-- +ok +== +SELECT l <= r FROM list_str +-- +ok +== +SELECT l = r FROM list_str +-- +ok +== +SELECT l <> r FROM list_str +-- +ok +== +SELECT l >= r FROM list_str +-- +ok +== +SELECT l > r FROM list_str +-- +ok +== +SELECT [{'x': 'duck', 'y': 1}] < [{'x': 'duck', 'y': 1}, {'x': 'goose', 'y': 2}] +-- +ok +== +SELECT [{'x': 'duck', 'y': 1}] < [{'x': 'duck', 'y': 1}] +-- +ok +== +SELECT NULL < [{'x': 'duck', 'y': 1}] +-- +ok +== +SELECT [{'x': 'duck', 'y': 1}] < NULL +-- +ok +== +SELECT [{'x': 'duck', 'y': 1}] <= [{'x': 'duck', 'y': 1}, {'x': 'goose', 'y': 2}] +-- +ok +== +SELECT [{'x': 'duck', 'y': 1}] <= [{'x': 'duck', 'y': 1}] +-- +ok +== +SELECT NULL <= [{'x': 'duck', 'y': 1}] +-- +ok +== +SELECT [{'x': 'duck', 'y': 1}] <= NULL +-- +ok +== +SELECT [{'x': 'duck', 'y': 1}] = [{'x': 'duck', 'y': 1}, {'x': 'goose', 'y': 2}] +-- +ok +== +SELECT [{'x': 'duck', 'y': 1}] = [{'x': 'duck', 'y': 1}] +-- +ok +== +SELECT NULL = [{'x': 'duck', 'y': 1}] +-- +ok +== +SELECT [{'x': 'duck', 'y': 1}] = NULL +-- +ok +== +SELECT [{'x': 'duck', 'y': 1}] <> [{'x': 'duck', 'y': 1}, {'x': 'goose', 'y': 2}] +-- +ok +== +SELECT [{'x': 'duck', 'y': 1}] <> [{'x': 'duck', 'y': 1}] +-- +ok +== +SELECT NULL <> [{'x': 'duck', 'y': 1}] +-- +ok +== +SELECT [{'x': 'duck', 'y': 1}] <> NULL +-- +ok +== +SELECT [{'x': 'duck', 'y': 1}] >= [{'x': 'duck', 'y': 1}, {'x': 'goose', 'y': 2}] +-- +ok +== +SELECT [{'x': 'duck', 'y': 1}] >= [{'x': 'duck', 'y': 1}] +-- +ok +== +SELECT NULL >= [{'x': 'duck', 'y': 1}] +-- +ok +== +SELECT [{'x': 'duck', 'y': 1}] >= NULL +-- +ok +== +SELECT [{'x': 'duck', 'y': 1}] > [{'x': 'duck', 'y': 1}, {'x': 'goose', 'y': 2}] +-- +ok +== +SELECT [{'x': 'duck', 'y': 1}] > [{'x': 'duck', 'y': 1}] +-- +ok +== +SELECT NULL > [{'x': 'duck', 'y': 1}] +-- +ok +== +SELECT [{'x': 'duck', 'y': 1}] > NULL +-- +ok +== +CREATE VIEW list_of_struct AS SELECT * FROM (VALUES + ([{'x': 'duck', 'y': 1}], [{'x': 'duck', 'y': 1}]), + ([{'x': 'duck', 'y': 1}], [{'x': 'duck', 'y': 1}, {'x': 'goose', 'y': 2}]), + ([{'x': 'duck', 'y': 1}, {'x': 'goose', 'y': 2}], [{'x': 'duck', 'y': 1}]), + (NULL, [{'x': 'duck', 'y': 1}]), + ([{'x': 'duck', 'y': 1}, {'x': 'goose', 'y': 2}], NULL), + (NULL, NULL) + ) tbl(l, r); +-- +ok +== +SELECT l < r FROM list_of_struct +-- +ok +== +SELECT l <= r FROM list_of_struct +-- +ok +== +SELECT l = r FROM list_of_struct +-- +ok +== +SELECT l <> r FROM list_of_struct +-- +ok +== +SELECT l >= r FROM list_of_struct +-- +ok +== +SELECT l > r FROM list_of_struct +-- +ok +== +select [a,a+1,a+2]<[1,2,3] from range(5) tbl(a); +-- +ok +== +select [a,a+1,a+2]<=[1,2,3] from range(5) tbl(a); +-- +ok +== +select [a,a+1,a+2]=[1,2,3] from range(5) tbl(a); +-- +ok +== +select [a,a+1,a+2]<>[1,2,3] from range(5) tbl(a); +-- +ok +== +select [a,a+1,a+2]>=[1,2,3] from range(5) tbl(a); +-- +ok +== +select [a,a+1,a+2]>[1,2,3] from range(5) tbl(a); +-- +ok +== diff --git a/parser/testdata/corpus/sql/types/list/list_concat_null.test b/parser/testdata/corpus/sql/types/list/list_concat_null.test new file mode 100644 index 0000000..ec58ea8 --- /dev/null +++ b/parser/testdata/corpus/sql/types/list/list_concat_null.test @@ -0,0 +1,81 @@ +# source: test/sql/types/list/list_concat_null.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +CREATE table x1 (b INT[]); +-- +ok +== +SELECT b || NULL from x1; +-- +ok +== +SELECT NULL || NULL from x1; +-- +ok +== +SELECT NULL || b || NULL from x1; +-- +ok +== +SELECT b || NULL || b from x1; +-- +ok +== +select concat([42]); +-- +ok +== +select concat([42], [43], [], [44], [], [45]); +-- +ok +== +select concat([42]::INT[1], [43]::INT[1], NULL::INT[1], [44]::INT[1], NULL::INT[1], [45]::INT[1]); +-- +ok +== +select list_concat([42]); +-- +ok +== +select list_concat([42], [43], [], [44], [], [45]); +-- +ok +== +select list_concat([42]::INT[1], [43]::INT[1], NULL::INT[1], [44]::INT[1], NULL::INT[1], [45]::INT[1]); +-- +ok +== +select list_concat([1]::INT[1], [2, 3]::INT[2]); +-- +ok +== +SELECT list_concat(NULL) +-- +ok +== +SELECT list_concat(NULL, NULL) +-- +ok +== +SELECT NULL || NULL +-- +ok +== +SELECT concat(NULL) is NULL +-- +ok +== +SELECT '' = concat(NULL) +-- +ok +== +SELECT '' = concat(NULL, NULL) +-- +ok +== +SELECT ''~concat(NULL) +-- +ok +== diff --git a/parser/testdata/corpus/sql/types/list/list_cross_product.test b/parser/testdata/corpus/sql/types/list/list_cross_product.test new file mode 100644 index 0000000..4086b41 --- /dev/null +++ b/parser/testdata/corpus/sql/types/list/list_cross_product.test @@ -0,0 +1,65 @@ +# source: test/sql/types/list/list_cross_product.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +CREATE VIEW v1 AS SELECT * FROM (VALUES (1, [1, 2, 3]), (2, NULL), (3, [NULL, 3, 4])) tbl (a, b); +-- +ok +== +SELECT * FROM v1 v, v1 w ORDER BY v.a, w.a; +-- +ok +== +SELECT * FROM v1 v, v1 w WHERE v.a >= w.a ORDER BY v.a, w.a; +-- +ok +== +SELECT * FROM v1 v, v1 w WHERE v.a <> w.a ORDER BY v.a, w.a; +-- +ok +== +SELECT * FROM v1 v, v1 w WHERE v.a <> w.a OR v.a>w.a ORDER BY v.a, w.a; +-- +ok +== +CREATE VIEW v2 AS SELECT * FROM (VALUES (1, {'a': [1, 2, 3]}), (2, NULL), (3, {'a': [NULL, 3, 4]})) tbl (a, b); +-- +ok +== +SELECT * FROM v2 v, v2 w ORDER BY v.a, w.a; +-- +ok +== +SELECT * FROM v2 v, v2 w WHERE v.a >= w.a ORDER BY v.a, w.a; +-- +ok +== +SELECT * FROM v2 v, v2 w WHERE v.a <> w.a ORDER BY v.a, w.a; +-- +ok +== +SELECT * FROM v2 v, v2 w WHERE v.a <> w.a OR v.a > w.a ORDER BY v.a, w.a; +-- +ok +== +CREATE VIEW v3 AS SELECT * FROM (VALUES (1, [[1, 2], [3]]), (2, NULL), (3, [[NULL, 3], [4]])) tbl (a, b); +-- +ok +== +SELECT * FROM v3 v, v3 w ORDER BY v.a, w.a; +-- +ok +== +SELECT * FROM v3 v, v3 w WHERE v.a >= w.a ORDER BY v.a, w.a; +-- +ok +== +SELECT * FROM v3 v, v3 w WHERE v.a <> w.a ORDER BY v.a, w.a; +-- +ok +== +SELECT * FROM v3 v, v3 w WHERE v.a <> w.a OR v.a > w.a ORDER BY v.a, w.a; +-- +ok +== diff --git a/parser/testdata/corpus/sql/types/list/list_distinct.test b/parser/testdata/corpus/sql/types/list/list_distinct.test new file mode 100644 index 0000000..c754752 --- /dev/null +++ b/parser/testdata/corpus/sql/types/list/list_distinct.test @@ -0,0 +1,189 @@ +# source: test/sql/types/list/list_distinct.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +SELECT [1] IS NOT DISTINCT FROM [2] +-- +ok +== +SELECT [1] IS NOT DISTINCT FROM [1] +-- +ok +== +SELECT NULL IS NOT DISTINCT FROM [1] +-- +ok +== +SELECT [1] IS NOT DISTINCT FROM NULL +-- +ok +== +SELECT [1] IS DISTINCT FROM [2] +-- +ok +== +SELECT [1] IS DISTINCT FROM [1] +-- +ok +== +SELECT NULL IS DISTINCT FROM [1] +-- +ok +== +SELECT [1] IS DISTINCT FROM NULL +-- +ok +== +SELECT l IS NOT DISTINCT FROM r FROM list_int1 +-- +ok +== +SELECT l IS DISTINCT FROM r FROM list_int1 +-- +ok +== +SELECT [1] IS NOT DISTINCT FROM [1, 2] +-- +ok +== +SELECT [1] IS DISTINCT FROM [1, 2] +-- +ok +== +SELECT l IS NOT DISTINCT FROM r FROM list_int +-- +ok +== +SELECT l IS DISTINCT FROM r FROM list_int +-- +ok +== +SELECT [] IS NOT DISTINCT FROM [1, 2] +-- +ok +== +SELECT [] IS NOT DISTINCT FROM [] +-- +ok +== +SELECT NULL IS NOT DISTINCT FROM [] +-- +ok +== +SELECT [] IS NOT DISTINCT FROM NULL +-- +ok +== +SELECT [] IS DISTINCT FROM [1, 2] +-- +ok +== +SELECT [] IS DISTINCT FROM [] +-- +ok +== +SELECT NULL IS DISTINCT FROM [] +-- +ok +== +SELECT [] IS DISTINCT FROM NULL +-- +ok +== +SELECT l IS NOT DISTINCT FROM r FROM list_int_empty +-- +ok +== +SELECT l IS DISTINCT FROM r FROM list_int_empty +-- +ok +== +SELECT ['duck'] IS NOT DISTINCT FROM ['duck', 'goose'] +-- +ok +== +SELECT ['duck'] IS NOT DISTINCT FROM ['duck'] +-- +ok +== +SELECT NULL IS NOT DISTINCT FROM ['duck'] +-- +ok +== +SELECT ['duck'] IS NOT DISTINCT FROM NULL +-- +ok +== +SELECT ['duck'] IS DISTINCT FROM ['duck', 'goose'] +-- +ok +== +SELECT ['duck'] IS DISTINCT FROM ['duck'] +-- +ok +== +SELECT NULL IS DISTINCT FROM ['duck'] +-- +ok +== +SELECT ['duck'] IS DISTINCT FROM NULL +-- +ok +== +SELECT l IS NOT DISTINCT FROM r FROM list_str +-- +ok +== +SELECT l IS DISTINCT FROM r FROM list_str +-- +ok +== +SELECT [{'x': 'duck', 'y': 1}] IS NOT DISTINCT FROM [{'x': 'duck', 'y': 1}, {'x': 'goose', 'y': 2}] +-- +ok +== +SELECT [{'x': 'duck', 'y': 1}] IS NOT DISTINCT FROM [{'x': 'duck', 'y': 1}] +-- +ok +== +SELECT NULL IS NOT DISTINCT FROM [{'x': 'duck', 'y': 1}] +-- +ok +== +SELECT [{'x': 'duck', 'y': 1}] IS NOT DISTINCT FROM NULL +-- +ok +== +SELECT [{'x': 'duck', 'y': 1}] IS DISTINCT FROM [{'x': 'duck', 'y': 1}, {'x': 'goose', 'y': 2}] +-- +ok +== +SELECT [{'x': 'duck', 'y': 1}] IS DISTINCT FROM [{'x': 'duck', 'y': 1}] +-- +ok +== +SELECT NULL IS DISTINCT FROM [{'x': 'duck', 'y': 1}] +-- +ok +== +SELECT [{'x': 'duck', 'y': 1}] IS DISTINCT FROM NULL +-- +ok +== +SELECT l IS NOT DISTINCT FROM r FROM list_of_struct +-- +ok +== +SELECT l IS DISTINCT FROM r FROM list_of_struct +-- +ok +== +select CASE WHEN a < 4 THEN [a,a+1,a+2] ELSE NULL END IS NOT DISTINCT FROM [1,2,3] from range(5) tbl(a); +-- +ok +== +select CASE WHEN a < 4 THEN [a,a+1,a+2] ELSE NULL END IS DISTINCT FROM [1,2,3] from range(5) tbl(a); +-- +ok +== diff --git a/parser/testdata/corpus/sql/types/list/list_extract_internal_issue2747.test b/parser/testdata/corpus/sql/types/list/list_extract_internal_issue2747.test new file mode 100644 index 0000000..c072c9b --- /dev/null +++ b/parser/testdata/corpus/sql/types/list/list_extract_internal_issue2747.test @@ -0,0 +1,9 @@ +# source: test/sql/types/list/list_extract_internal_issue2747.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +select string_split(string_agg(NULL, ','), ',')[100] from range(10); +-- +ok +== diff --git a/parser/testdata/corpus/sql/types/list/list_extract_struct.test b/parser/testdata/corpus/sql/types/list/list_extract_struct.test new file mode 100644 index 0000000..3d06e23 --- /dev/null +++ b/parser/testdata/corpus/sql/types/list/list_extract_struct.test @@ -0,0 +1,65 @@ +# source: test/sql/types/list/list_extract_struct.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +CREATE TABLE a AS SELECT + [ + {'a': 3, 'b': NULL}, + NULL, + {'a': NULL, 'b': 'hello'} + ] l; +-- +ok +== +SELECT l[1] FROM a +-- +ok +== +SELECT l[2] FROM a +-- +ok +== +SELECT l[3] FROM a +-- +ok +== +CREATE TABLE nested AS SELECT + [ + {'a': 3, 'b': {'x': 3, 'y': [1, 2, 3]}}, + NULL, + {'a': NULL, 'b': {'x': NULL, 'y': [4, 5]}}, + {'a': 27, 'b': NULL}, + {'a': NULL, 'b': {'x': 7, 'y': NULL}} + ] l; +-- +ok +== +SELECT * FROM nested +-- +ok +== +SELECT l[1] FROM nested +-- +ok +== +SELECT l[2] FROM nested +-- +ok +== +SELECT l[3] FROM nested +-- +ok +== +SELECT l[4] FROM nested +-- +ok +== +SELECT l[5] FROM nested +-- +ok +== +SELECT l[5]['b'] FROM nested +-- +ok +== diff --git a/parser/testdata/corpus/sql/types/list/list_index.test b/parser/testdata/corpus/sql/types/list/list_index.test new file mode 100644 index 0000000..57fb4a7 --- /dev/null +++ b/parser/testdata/corpus/sql/types/list/list_index.test @@ -0,0 +1,17 @@ +# source: test/sql/types/list/list_index.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +INSERT INTO a VALUES (2, NULL), (3, [NULL]), (4, [4, 5, NULL, 6]); +-- +ok +== +INSERT INTO a VALUES (1, [1, 2, 3]), (2, NULL), (3, [NULL]), (4, [4, 5, NULL, 6]); +-- +ok +== +INSERT INTO a VALUES (1, [4, 5, NULL]), (1, NULL), (1, [NULL]), (1, [7, 8, 9, 10, 11, 12, 13, 14, 15]); +-- +ok +== diff --git a/parser/testdata/corpus/sql/types/list/list_index_abort_small.test b/parser/testdata/corpus/sql/types/list/list_index_abort_small.test new file mode 100644 index 0000000..ee76a45 --- /dev/null +++ b/parser/testdata/corpus/sql/types/list/list_index_abort_small.test @@ -0,0 +1,33 @@ +# source: test/sql/types/list/list_index_abort_small.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +INSERT INTO a SELECT i id, NULL c FROM range(2, 2500, 1) tbl(i) +-- +ok +== +INSERT INTO a VALUES (1, [4, 5]) +-- +ok +== +INSERT INTO a SELECT i id, [-i, i, 33] c FROM range(-2, -2500, -1) tbl(i) +-- +ok +== +INSERT INTO a SELECT i id, [1, 2, 3, 4, 5, i, -33] c FROM range(2500, 5000, 1) tbl(i) +-- +ok +== +INSERT INTO a VALUES (2, [4, 5]) +-- +ok +== +INSERT INTO a VALUES (3, NULL) +-- +ok +== +INSERT INTO a VALUES (4, [NULL]) +-- +ok +== diff --git a/parser/testdata/corpus/sql/types/list/list_index_abort_small_nested.test b/parser/testdata/corpus/sql/types/list/list_index_abort_small_nested.test new file mode 100644 index 0000000..c425be2 --- /dev/null +++ b/parser/testdata/corpus/sql/types/list/list_index_abort_small_nested.test @@ -0,0 +1,33 @@ +# source: test/sql/types/list/list_index_abort_small_nested.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +CREATE TABLE a(id INTEGER PRIMARY KEY, c INT[][]); +-- +ok +== +INSERT INTO a VALUES (1, [[1, 2, 3], [4, 5]]) +-- +ok +== +INSERT INTO a VALUES (1, [[4, 5]]) +-- +ok +== +INSERT INTO a SELECT i id, [[-i], [i, 33]] c FROM range(-2, -2500, -1) tbl(i) +-- +ok +== +INSERT INTO a SELECT i id, [[1, 2], [3, 4], [5, i, -33]] c FROM range(2500, 5000, 1) tbl(i) +-- +ok +== +INSERT INTO a VALUES (2, [[4, 5]]) +-- +ok +== +INSERT INTO a VALUES (5, [[NULL], [NULL]]) +-- +ok +== diff --git a/parser/testdata/corpus/sql/types/list/list_indexing.test b/parser/testdata/corpus/sql/types/list/list_indexing.test new file mode 100644 index 0000000..e92ed60 --- /dev/null +++ b/parser/testdata/corpus/sql/types/list/list_indexing.test @@ -0,0 +1,37 @@ +# source: test/sql/types/list/list_indexing.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +CREATE TABLE test (l INTEGER[]); +-- +ok +== +INSERT INTO test VALUES ([1, 2, 3]), ([NULL]), (NULL), ([-2, NULL, 4, 2]); +-- +ok +== +SELECT list_extract(l, 0) FROM test; +-- +ok +== +SELECT list_extract(l, 1) FROM test; +-- +ok +== +SELECT l[:] FROM test; +-- +ok +== +SELECT l[0:0] FROM test; +-- +ok +== +SELECT l[0:1] FROM test; +-- +ok +== +SELECT l[1:0] FROM test; +-- +ok +== diff --git a/parser/testdata/corpus/sql/types/list/list_null_members.test b/parser/testdata/corpus/sql/types/list/list_null_members.test new file mode 100644 index 0000000..3bba304 --- /dev/null +++ b/parser/testdata/corpus/sql/types/list/list_null_members.test @@ -0,0 +1,51 @@ +# source: test/sql/types/list/list_null_members.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +CREATE VIEW list_int AS +SELECT * FROM (VALUES + ([1]), + ([1, 2]), + ([1, NULL]), + ([NULL, 2]), + ([NULL, NULL]), + ([NULL]), + (NULL) +) tbl(i); +-- +ok +== +SELECT lhs.i, rhs.i, + lhs.i < rhs.i, lhs.i <= rhs.i, + lhs.i = rhs.i, lhs.i <> rhs.i, + lhs.i > rhs.i, lhs.i >= rhs.i, + lhs.i IS NOT DISTINCT FROM rhs.i, lhs.i IS DISTINCT FROM rhs.i +FROM list_int lhs, list_int rhs +ORDER BY 1, 2 +-- +ok +== +CREATE VIEW list_str AS +SELECT * FROM (VALUES + (['duck']), + (['duck', 'goose']), + (['duck', NULL]), + ([NULL, 'goose']), + ([NULL, NULL]), + ([NULL]), + (NULL) +) tbl(i); +-- +ok +== +SELECT lhs.i, rhs.i, + lhs.i < rhs.i, lhs.i <= rhs.i, + lhs.i = rhs.i, lhs.i <> rhs.i, + lhs.i > rhs.i, lhs.i >= rhs.i, + lhs.i IS NOT DISTINCT FROM rhs.i, lhs.i IS DISTINCT FROM rhs.i +FROM list_str lhs, list_str rhs +ORDER BY 1, 2 +-- +ok +== diff --git a/parser/testdata/corpus/sql/types/list/list_null_members_small.test b/parser/testdata/corpus/sql/types/list/list_null_members_small.test new file mode 100644 index 0000000..b86c975 --- /dev/null +++ b/parser/testdata/corpus/sql/types/list/list_null_members_small.test @@ -0,0 +1,38 @@ +# source: test/sql/types/list/list_null_members_small.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +CREATE VIEW list_int AS +SELECT * FROM VALUES ( + ([1]), + ([NULL]) +) tbl(a, b); +-- +ok +== +SELECT tbl.a, tbl.b, + tbl.a < tbl.b, tbl.a <= tbl.b, + tbl.a = tbl.b, tbl.a <> tbl.b, + tbl.a > tbl.b, tbl.a >= tbl.b, + tbl.a IS NOT DISTINCT FROM tbl.b, tbl.a IS DISTINCT FROM tbl.b +FROM list_int tbl +-- +ok +== +SELECT [NULL,1.0] = [2,1.0]; +-- +ok +== +SELECT [NULL,1.0] <> [2,1.0]; +-- +ok +== +SELECT [NULL,1.0] = [2,3.0]; +-- +ok +== +SELECT [NULL,1.0] <> [2,3.0]; +-- +ok +== diff --git a/parser/testdata/corpus/sql/types/list/list_of_struct.test b/parser/testdata/corpus/sql/types/list/list_of_struct.test new file mode 100644 index 0000000..b96dfb4 --- /dev/null +++ b/parser/testdata/corpus/sql/types/list/list_of_struct.test @@ -0,0 +1,58 @@ +# source: test/sql/types/list/list_of_struct.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +CREATE TABLE a AS SELECT [{'a': 3, 'b': 'hello'}, NULL, {'a': NULL, 'b': 'thisisalongstring'}] l; +-- +ok +== +INSERT INTO a VALUES (NULL) +-- +ok +== +INSERT INTO a VALUES ([{'a': 17, 'b': 'world'}]) +-- +ok +== +SELECT UNNEST(l) FROM a +-- +ok +== +CREATE TABLE b AS SELECT [ + {'a': {'a1': [1, 2, 3], 'a2': 17}, 'b': 'hello'}, + NULL, + {'a': {'a1': [NULL, 4, 5], 'a2': NULL}, 'b': 'thisisalongstring'}, + {'a': {'a1': NULL, 'a2': 22}, 'b': NULL}, + {'a': NULL, 'b': 'aaaaaaaaaaaaaaaaaaaaaaaa'}] l; +-- +ok +== +SELECT * FROM b; +-- +ok +== +SELECT UNNEST(l) FROM b; +-- +ok +== +SELECT UNNEST(l)['a']['a1'] FROM b; +-- +ok +== +SELECT UNNEST(l)['a']['a2'] FROM b; +-- +ok +== +INSERT INTO b VALUES (NULL), ([ + {'a': {'a1': [6, 7, 8, 9], 'a2': 17}, 'b': 'world1'}, + NULL, + {'a': {'a1': [10, 11, 12], 'a2': 22}, 'b': 'world2'} +]) +-- +ok +== +SELECT UNNEST(l)['a'] FROM b; +-- +ok +== diff --git a/parser/testdata/corpus/sql/types/list/list_parse_recursion.test b/parser/testdata/corpus/sql/types/list/list_parse_recursion.test new file mode 100644 index 0000000..562f9e0 --- /dev/null +++ b/parser/testdata/corpus/sql/types/list/list_parse_recursion.test @@ -0,0 +1,9 @@ +# source: test/sql/types/list/list_parse_recursion.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +SELECT REPEAT ( '[{"a":' , 100000 )::INT[] +-- +ok +== diff --git a/parser/testdata/corpus/sql/types/list/list_stats.test b/parser/testdata/corpus/sql/types/list/list_stats.test new file mode 100644 index 0000000..23bbbb5 --- /dev/null +++ b/parser/testdata/corpus/sql/types/list/list_stats.test @@ -0,0 +1,77 @@ +# source: test/sql/types/list/list_stats.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +SELECT s.child_stats.min, s.child_stats.max FROM (SELECT STATS([3, 4]) s) +-- +ok +== +SELECT [3, 4] +-- +ok +== +SELECT s.has_null, s.has_no_null FROM (SELECT STATS(NULL::INT[]) s) +-- +ok +== +SELECT NULL::INT[] +-- +ok +== +SELECT STATS(['hello', 'world']) +-- +ok +== +SELECT STATS([interval 1 year, interval 2 year]) +-- +ok +== +SELECT ['hello', 'world'] +-- +ok +== +SELECT [interval 1 year, interval 2 year] +-- +ok +== +insert into integers values (3), (4); +-- +ok +== +SELECT s.child_stats.min, s.child_stats.max, s.child_stats.has_null, s.has_null FROM (SELECT STATS([i]) s FROM integers LIMIT 1) +-- +ok +== +SELECT [i] FROM integers +-- +ok +== +insert into integers values (NULL); +-- +ok +== +CREATE TABLE lists AS SELECT [3, 4] l +-- +ok +== +SELECT s.min, s.max, s.has_null FROM (SELECT STATS(l[1]) s FROM lists LIMIT 1) +-- +ok +== +SELECT l[1] FROM lists +-- +ok +== +INSERT INTO lists VALUES ([]) +-- +ok +== +INSERT INTO lists VALUES (NULL) +-- +ok +== +INSERT INTO lists VALUES ([NULL]) +-- +ok +== diff --git a/parser/testdata/corpus/sql/types/list/list_test_many_deletes.test b/parser/testdata/corpus/sql/types/list/list_test_many_deletes.test new file mode 100644 index 0000000..33bd0ea --- /dev/null +++ b/parser/testdata/corpus/sql/types/list/list_test_many_deletes.test @@ -0,0 +1,33 @@ +# source: test/sql/types/list/list_test_many_deletes.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +CREATE TABLE lists(i INT[]) +-- +ok +== +INSERT INTO lists SELECT [i, NULL, i+1] FROM range(10000) tbl(i); +-- +ok +== +DELETE FROM lists WHERE i[1] <= 9995 +-- +ok +== +DROP TABLE lists +-- +ok +== +CREATE TABLE lists(i INT[][]) +-- +ok +== +INSERT INTO lists SELECT [[i], NULL, [i+1, 4], [NULL, 1, 2]] FROM range(10000) tbl(i); +-- +ok +== +DELETE FROM lists WHERE i[1][1] <= 9995 +-- +ok +== diff --git a/parser/testdata/corpus/sql/types/list/list_to_varchar_cast.test b/parser/testdata/corpus/sql/types/list/list_to_varchar_cast.test new file mode 100644 index 0000000..e7d2613 --- /dev/null +++ b/parser/testdata/corpus/sql/types/list/list_to_varchar_cast.test @@ -0,0 +1,9 @@ +# source: test/sql/types/list/list_to_varchar_cast.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +SELECT concat_ws('.', list_reverse(string_split('1.2..3', '.'))); +-- +ok +== diff --git a/parser/testdata/corpus/sql/types/list/list_update_with_many_matches.test b/parser/testdata/corpus/sql/types/list/list_update_with_many_matches.test new file mode 100644 index 0000000..04c4bf3 --- /dev/null +++ b/parser/testdata/corpus/sql/types/list/list_update_with_many_matches.test @@ -0,0 +1,21 @@ +# source: test/sql/types/list/list_update_with_many_matches.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +create table lists(id int, i int[]); +-- +ok +== +insert into lists values (1, [1, 2, 3]), (2, [4, 5]), (3, [NULL]); +-- +ok +== +select * from lists order by id; +-- +ok +== +update lists set i=[5,6,7] from lists l2 where lists.id=1; +-- +ok +== diff --git a/parser/testdata/corpus/sql/types/list/list_updates.test b/parser/testdata/corpus/sql/types/list/list_updates.test new file mode 100644 index 0000000..8a81af6 --- /dev/null +++ b/parser/testdata/corpus/sql/types/list/list_updates.test @@ -0,0 +1,33 @@ +# source: test/sql/types/list/list_updates.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +CREATE TABLE a(id INTEGER, b INTEGER[]); +-- +ok +== +INSERT INTO a VALUES (0, [1, 2]), (1, NULL), (2, [3, 4, 5, 6]), (3, [NULL, 7]); +-- +ok +== +SELECT * FROM a ORDER BY id +-- +ok +== +UPDATE a SET b=[7, 8, 9] WHERE b IS NULL +-- +ok +== +UPDATE a SET b=NULL WHERE id>=2 +-- +ok +== +UPDATE a SET b=[NULL] WHERE id=2 +-- +ok +== +UPDATE a SET b=NULL +-- +ok +== diff --git a/parser/testdata/corpus/sql/types/list/list_updates_varchar.test b/parser/testdata/corpus/sql/types/list/list_updates_varchar.test new file mode 100644 index 0000000..6f5740c --- /dev/null +++ b/parser/testdata/corpus/sql/types/list/list_updates_varchar.test @@ -0,0 +1,25 @@ +# source: test/sql/types/list/list_updates_varchar.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +CREATE TABLE a(id INTEGER, b VARCHAR[]); +-- +ok +== +INSERT INTO a VALUES (0, ['hello world', 'bananas']), (1, NULL), (2, ['3, 4, 5, 6', 'numbers']), (3, [NULL, 'not a number']); +-- +ok +== +DELETE FROM a WHERE b[1][1]='3' +-- +ok +== +UPDATE a SET b=['very very long string', '123', 'test 123 123'] WHERE b IS NULL +-- +ok +== +UPDATE a SET b=[NULL, 'hello again', NULL] WHERE id=1 +-- +ok +== diff --git a/parser/testdata/corpus/sql/types/list/mix_numeric_types.test b/parser/testdata/corpus/sql/types/list/mix_numeric_types.test new file mode 100644 index 0000000..a4a67f0 --- /dev/null +++ b/parser/testdata/corpus/sql/types/list/mix_numeric_types.test @@ -0,0 +1,37 @@ +# source: test/sql/types/list/mix_numeric_types.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +select [100::UTINYINT, 10000::SMALLINT]; +-- +ok +== +select [100::USMALLINT, 10000::INTEGER]; +-- +ok +== +select [100::USMALLINT, 10000.5]; +-- +ok +== +select [100::USMALLINT, 0.5::DOUBLE]; +-- +ok +== +select [-100::TINYINT, 200::UTINYINT]; +-- +ok +== +select [-100::SMALLINT, 50000::USMALLINT]; +-- +ok +== +select [-100::INTEGER, 3000000000::UINTEGER]; +-- +ok +== +select [-100::BIGINT, 9999999999999999999::UBIGINT]; +-- +ok +== diff --git a/parser/testdata/corpus/sql/types/list/nested_list_extract.test b/parser/testdata/corpus/sql/types/list/nested_list_extract.test new file mode 100644 index 0000000..f524d99 --- /dev/null +++ b/parser/testdata/corpus/sql/types/list/nested_list_extract.test @@ -0,0 +1,77 @@ +# source: test/sql/types/list/nested_list_extract.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +CREATE TABLE a(id INTEGER, b INTEGER[][]); +-- +ok +== +INSERT INTO a VALUES (0, [[1, 2], NULL, [3, NULL]]), (1, NULL), (2, [[4, 5, 6, 7], [NULL]]) +-- +ok +== +SELECT id, b[1] FROM a ORDER BY id +-- +ok +== +SELECT id, b[1][1] FROM a ORDER BY id +-- +ok +== +SELECT id, b[0][0] FROM a ORDER BY id +-- +ok +== +SELECT id, b[0][1] FROM a ORDER BY id +-- +ok +== +SELECT id, b[1][0] FROM a ORDER BY id +-- +ok +== +SELECT id, b[1][4] FROM a ORDER BY id +-- +ok +== +SELECT * FROM a WHERE b[1][1]=1 +-- +ok +== +SELECT * FROM a WHERE b[1][1]=1 OR b[1][2]=2 +-- +ok +== +CREATE TABLE nested(id INTEGER, b INTEGER[][][]); +-- +ok +== +INSERT INTO nested VALUES (0, [[[1, 2], [3, 4]], NULL, [NULL, [2, 5]]]), (1, NULL), (2, [[[6, 7, 8, 9], [10, 11], [12, 13]], NULL, [NULL, [10, 11], [12, 13]]]); +-- +ok +== +SELECT * FROM nested ORDER BY id +-- +ok +== +SELECT id, b[1] FROM nested ORDER BY id +-- +ok +== +SELECT id, b[1][1] FROM nested ORDER BY id +-- +ok +== +SELECT id, b[1][3] FROM nested ORDER BY id +-- +ok +== +SELECT id, b[1][3][1] FROM nested ORDER BY id +-- +ok +== +SELECT id, b[1][3][4] FROM nested ORDER BY id +-- +ok +== diff --git a/parser/testdata/corpus/sql/types/list/nested_list_slice.test b/parser/testdata/corpus/sql/types/list/nested_list_slice.test new file mode 100644 index 0000000..477253d --- /dev/null +++ b/parser/testdata/corpus/sql/types/list/nested_list_slice.test @@ -0,0 +1,33 @@ +# source: test/sql/types/list/nested_list_slice.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +SELECT id, b[0:1] FROM a ORDER BY id +-- +ok +== +SELECT id, b[0:2] FROM a ORDER BY id +-- +ok +== +SELECT id, b[1:1] FROM a ORDER BY id +-- +ok +== +SELECT id, b[1:2] FROM a ORDER BY id +-- +ok +== +SELECT id, b[0:0] FROM a ORDER BY id +-- +ok +== +SELECT id, b[:] FROM a ORDER BY id +-- +ok +== +SELECT id, list_extract(b[:], 0) FROM a ORDER BY id +-- +ok +== diff --git a/parser/testdata/corpus/sql/types/list/nested_list_updates.test b/parser/testdata/corpus/sql/types/list/nested_list_updates.test new file mode 100644 index 0000000..d055527 --- /dev/null +++ b/parser/testdata/corpus/sql/types/list/nested_list_updates.test @@ -0,0 +1,17 @@ +# source: test/sql/types/list/nested_list_updates.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +UPDATE a SET b=[[7, 8, 9], [10, 11]] WHERE b IS NULL +-- +ok +== +UPDATE a SET b=NULL WHERE id>=1 +-- +ok +== +UPDATE a SET b=[[NULL], NULL, [NULL]] WHERE id=1 +-- +ok +== diff --git a/parser/testdata/corpus/sql/types/list/recursive_unnest.test b/parser/testdata/corpus/sql/types/list/recursive_unnest.test new file mode 100644 index 0000000..fad92d3 --- /dev/null +++ b/parser/testdata/corpus/sql/types/list/recursive_unnest.test @@ -0,0 +1,81 @@ +# source: test/sql/types/list/recursive_unnest.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +SELECT UNNEST([[1, 2, 3]], recursive := true) +-- +ok +== +SELECT UNNEST([[[[[1, 2], [3, 4]], [[5]]], [[[]]]]], recursive := true) +-- +ok +== +SELECT UNNEST([[[[[1, 2], [3, 4]], [[5]]], [[[]]]]], RECURSIVE := true) +-- +ok +== +SELECT UNNEST([[[[[1, 2], [3, 4]], [[5]]], [[[]]]]], max_depth := 1) +-- +ok +== +SELECT UNNEST([[[[[1, 2], [3, 4]], [[5]]], [[[]]]]], max_depth := 2) +-- +ok +== +SELECT UNNEST([[[[[1, 2], [3, 4]], [[5]]], [[[]]]]], max_depth := 3) +-- +ok +== +SELECT UNNEST([[[[[1, 2], [3, 4]], [[5]]], [[[]]]]], max_depth := 4) +-- +ok +== +SELECT UNNEST([[[[[1, 2], [3, 4]], [[5]]], [[[]]]]], max_depth := 5) +-- +ok +== +SELECT UNNEST([[1, 2, 3], [4, 5]]) AS a, UNNEST([1, 2, 3]) AS b +-- +ok +== +SELECT UNNEST([[1, 2, 3], [4, 5]], recursive := true) AS a, UNNEST([1, 2, 3]) AS b ORDER BY a NULLS LAST +-- +ok +== +SELECT UNNEST(a), b FROM (SELECT UNNEST([[1, 2, 3], [4, 5]]) AS a, UNNEST([1, 2, 3]) AS b) +-- +ok +== +SELECT UNNEST(UNNEST([[1, 2, 3]])) +-- +ok +== +SELECT UNNEST(); +-- +ok +== +SELECT UNNEST([1, 2, 3], 'hello'); +-- +ok +== +SELECT UNNEST([1, 2, 3], recursive := 'hello'); +-- +ok +== +SELECT UNNEST([1, 2, 3], rec := true); +-- +ok +== +SELECT UNNEST([1, 2, 3], recursive := true, recursive := true); +-- +ok +== +SELECT UNNEST([1, 2, 3], max_depth := 9999, recursive := true); +-- +ok +== +SELECT UNNEST([1, 2, 3], max_depth := 0); +-- +ok +== diff --git a/parser/testdata/corpus/sql/types/list/unnest_aggregate.test b/parser/testdata/corpus/sql/types/list/unnest_aggregate.test new file mode 100644 index 0000000..c465852 --- /dev/null +++ b/parser/testdata/corpus/sql/types/list/unnest_aggregate.test @@ -0,0 +1,17 @@ +# source: test/sql/types/list/unnest_aggregate.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +SELECT SUM(a) FROM UNNEST(RANGE(1, 11)) t(a); +-- +ok +== +create or replace function rnv(a,b) as (select a + b * pi()); +-- +ok +== +select rnv(0, 1) from unnest( range(0,2) ); +-- +ok +== diff --git a/parser/testdata/corpus/sql/types/list/unnest_array.test b/parser/testdata/corpus/sql/types/list/unnest_array.test new file mode 100644 index 0000000..cb40261 --- /dev/null +++ b/parser/testdata/corpus/sql/types/list/unnest_array.test @@ -0,0 +1,21 @@ +# source: test/sql/types/list/unnest_array.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +SELECT unnest([[1, 2], [3, 4]]::int[][], recursive:=true) +-- +ok +== +SELECT unnest([[1, 2], [3, 4]]::int[2][2], recursive:=true) +-- +ok +== +SELECT unnest([[1, 2], [3, 4]]::int[2][], recursive:=true) +-- +ok +== +SELECT unnest([[[1, 2], [3, 4]], [[5, 6], [7, 8]]]::int[2][2][2], recursive:=true) +-- +ok +== diff --git a/parser/testdata/corpus/sql/types/list/unnest_complex_types.test b/parser/testdata/corpus/sql/types/list/unnest_complex_types.test new file mode 100644 index 0000000..47cc16e --- /dev/null +++ b/parser/testdata/corpus/sql/types/list/unnest_complex_types.test @@ -0,0 +1,49 @@ +# source: test/sql/types/list/unnest_complex_types.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +SELECT id, UNNEST(i), UNNEST(j) FROM (VALUES (3, ['hello', NULL, 'world'], [NULL])) tbl(id, i, j) +-- +ok +== +SELECT id, UNNEST(i), UNNEST(j) FROM (VALUES (1, ['abcd', 'efgh'], ['123456789abcd']), (2, NULL, ['123456789efgh', '123456789klmnop']), (3, ['hello', NULL, 'world'], [NULL])) tbl(id, i, j) +-- +ok +== +SELECT id, UNNEST(i), UNNEST(j) FROM (VALUES (1, [1, 2], [10]), (2, NULL, [11, 12]), (3, [3, NULL, 4], [NULL])) tbl(id, i, j) +-- +ok +== +SELECT UNNEST(i) FROM (VALUES ([[1, 2, 3], [4, 5]]), (NULL), ([[6, 7], NULL, [8, 9, NULL]])) tbl(i) +-- +ok +== +SELECT UNNEST(i), UNNEST(j) FROM (VALUES ([[1, 2, 3], [4, 5]], [[10, 11], [12, 13]]), (NULL, [[14, 15], [NULL, 16], NULL, NULL]), ([[6, 7], NULL, [8, 9, NULL]], NULL)) tbl(i, j) +-- +ok +== +SELECT UNNEST(i) FROM (VALUES ([{'a': 10, 'b': 1}, {'a': 11, 'b': 2}]), (NULL), ([{'a': 12, 'b': 3}, NULL, {'a': NULL, 'b': NULL}])) tbl(i) +-- +ok +== +SELECT UNNEST(i) FROM (VALUES ([{'a': {'a1': 7, 'a2': NULL}, 'b': 1}, {'a': {'a1': 9, 'a2': 10}, 'b': 2}]), (NULL), ([{'a': {'a1': 11, 'a2': 12}, 'b': 3}, NULL, {'a': NULL, 'b': NULL}, {'a': {'a1': NULL, 'a2': NULL}, 'b': 3}])) tbl(i) +-- +ok +== +SELECT id, UNNEST(i), UNNEST(j) FROM (VALUES (1, [{'a': 1, 'b': NULL}, {'a': 2, 'b': 'hello'}], [[1, 2, 3], [4, 5]]), (2, NULL, [[11, 12], NULL]), (3, [{'a': 3, 'b': 'test the best unnest fest'}, NULL, {'a': 4, 'b': 'abcd'}], [NULL])) tbl(id, i, j) +-- +ok +== +SELECT id, UNNEST(i), UNNEST(j) FROM (VALUES (1, [{'a': [1, 2], 'b': NULL}, {'a': NULL, 'b': 'hello'}], [[1, 2, 3], [4, 5]]), (2, NULL, [[11, 12], NULL]), (3, [{'a': [NULL, 4, 5], 'b': 'test the best unnest fest'}, NULL, {'a': [6, 7, NULL, 9], 'b': 'abcd'}], [NULL])) tbl(id, i, j) +-- +ok +== +SELECT id, UNNEST(i) FROM (VALUES (1, [[1,2], [3, 4]]::INT[2][]), (2, [[5, NULL], [7, 8]]::INT[2][]), (3, NULL::INT[2][]), (4, [[9, 10], NULL, [11, 12]]::INT[2][]), (5, []::INT[2][])) tbl(id, i) +-- +ok +== +SELECT id, UNNEST(i) FROM (VALUES (1, {'a': [1,2]::INT[2], 'b': [3, 4]::INT[2]}), (2, {'a': [5, NULL]::INT[2], 'b': [7, 8]::INT[2]}), (3, {'a': NULL::INT[2], 'b': [9, 10]::INT[2]}), (4, {'a': [11, 12]::INT[2], 'b': NULL::INT[2]}), (5, {'a': NULL, 'b': [13, 14]::INT[2]})) tbl(id, i); +-- +ok +== diff --git a/parser/testdata/corpus/sql/types/list/unnest_expand.test b/parser/testdata/corpus/sql/types/list/unnest_expand.test new file mode 100644 index 0000000..41fc88d --- /dev/null +++ b/parser/testdata/corpus/sql/types/list/unnest_expand.test @@ -0,0 +1,45 @@ +# source: test/sql/types/list/unnest_expand.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +CREATE TABLE tbl1 (str VARCHAR, str_list VARCHAR[]); +-- +ok +== +INSERT INTO tbl1 VALUES ('a', ['vibrant', 'plant', 'day']); +-- +ok +== +CREATE TABLE tbl2 (data struct (str VARCHAR, str_list VARCHAR[])); +-- +ok +== +INSERT INTO tbl2 VALUES (('a', ['sunny', 'vibrant', 'day'])); +-- +ok +== +SELECT UNNEST(data) FROM tbl2; +-- +ok +== +SELECT UNNEST(str_list) FROM tbl1; +-- +ok +== +SELECT UNNEST(data) FROM tbl2 INTERSECT SELECT * FROM tbl1; +-- +ok +== +CREATE TABLE test (id VARCHAR, b STRUCT("n" VARCHAR, "v" STRUCT("n" VARCHAR, "v" BIGINT)[])[]); +-- +ok +== +SELECT DISTINCT * FROM (SELECT id, UNNEST(b, recursive := true) FROM test); +-- +ok +== +SELECT DISTINCT id, UNNEST(b, recursive := true) FROM test; +-- +ok +== diff --git a/parser/testdata/corpus/sql/types/list/unnest_group_by.test b/parser/testdata/corpus/sql/types/list/unnest_group_by.test new file mode 100644 index 0000000..0f21f8b --- /dev/null +++ b/parser/testdata/corpus/sql/types/list/unnest_group_by.test @@ -0,0 +1,147 @@ +# source: test/sql/types/list/unnest_group_by.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +SELECT unnest(['a', 'b']) AS tag, count(*) FROM range(1) GROUP BY tag ORDER BY tag +-- +ok +== +SELECT unnest(['a', 'b']) AS tag, count(*) FROM range(1) GROUP BY 1 ORDER BY 1 +-- +ok +== +SELECT trim(unnest([' a ', 'b '])) AS tag ORDER BY tag +-- +ok +== +CREATE TABLE grouped_unnest_strings(tags VARCHAR); +-- +ok +== +INSERT INTO grouped_unnest_strings VALUES ('a>b'), ('a>c'), ('b'); +-- +ok +== +SELECT unnest(string_split(tags, '>')) AS tag, count(*) +FROM grouped_unnest_strings +GROUP BY tag +ORDER BY tag +-- +ok +== +SELECT unnest(string_split(tags, '>')) AS tag, count(*) +FROM grouped_unnest_strings +GROUP BY unnest(string_split(tags, '>')) +ORDER BY tag +-- +ok +== +SELECT trim(unnest(string_split(tags, '>'))) AS tag, count(*) +FROM grouped_unnest_strings +GROUP BY tag +ORDER BY tag +-- +ok +== +SELECT upper(unnest(string_split(tags, '>'))) AS tag, count(*) +FROM grouped_unnest_strings +GROUP BY upper(unnest(string_split(tags, '>'))) +ORDER BY tag +-- +ok +== +SELECT nullif(unnest([1, 2]), 0) AS tag, count(*) +FROM range(1) +GROUP BY tag +ORDER BY tag +-- +ok +== +SELECT nullif(unnest([1, 2]), 0) AS tag, count(*) +FROM range(1) +GROUP BY nullif(unnest([1, 2]), 0) +ORDER BY tag +-- +ok +== +SELECT unnest([1, 2]) AS a, unnest([10, 20]) AS b, count(*) +FROM range(1) +GROUP BY a, b +ORDER BY a, b +-- +ok +== +SELECT unnest([1, 2]) AS g, unnest([10, 20]) AS s, count(*) +FROM range(1) +GROUP BY g +ORDER BY g, s +-- +ok +== +SELECT unnest(['a', 'b']) AS tag, count(*) FROM range(1) GROUP BY ALL; +-- +ok +== +SELECT count(*) FROM range(3) t(i) GROUP BY unnest([sum(i)]); +-- +ok +== +SELECT count(*) FROM range(3) t(i) GROUP BY unnest([row_number() OVER ()]); +-- +ok +== +SELECT count(*) FROM range(1) GROUP BY unnest({'a': 1, 'b': 2}); +-- +ok +== +SELECT count(*) FROM range(1) GROUP BY lower(unnest({'a': 'x'})); +-- +ok +== +SELECT coalesce(unnest([1, 2]), 0) AS tag, count(*) +FROM range(1) +GROUP BY tag +ORDER BY tag +-- +ok +== +SELECT coalesce(unnest([1, 2]), 0) AS tag, count(*) +FROM range(1) +GROUP BY coalesce(unnest([1, 2]), 0) +ORDER BY tag +-- +ok +== +SELECT abs(coalesce(unnest([-1, -2]), 0)) AS tag, count(*) +FROM range(1) +GROUP BY tag +ORDER BY tag +-- +ok +== +SELECT CASE WHEN true THEN unnest([1, 2]) ELSE 0 END AS tag, count(*) +FROM range(1) +GROUP BY tag +ORDER BY tag +-- +ok +== +SELECT CASE WHEN true THEN unnest([1, 2]) ELSE 0 END AS tag, count(*) +FROM range(1) +GROUP BY CASE WHEN true THEN unnest([1, 2]) ELSE 0 END +ORDER BY tag +-- +ok +== +SELECT abs(CASE WHEN true THEN unnest([-1, -2]) ELSE 0 END) AS tag, count(*) +FROM range(1) +GROUP BY tag +ORDER BY tag +-- +ok +== +DROP TABLE grouped_unnest_strings; +-- +ok +== diff --git a/parser/testdata/corpus/sql/types/list/unnest_having_qualify.test b/parser/testdata/corpus/sql/types/list/unnest_having_qualify.test new file mode 100644 index 0000000..1239498 --- /dev/null +++ b/parser/testdata/corpus/sql/types/list/unnest_having_qualify.test @@ -0,0 +1,13 @@ +# source: test/sql/types/list/unnest_having_qualify.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +select 42 having unnest([1,2,3]); +-- +ok +== +select row_number() over () qualify unnest([1,2,3]); +-- +ok +== diff --git a/parser/testdata/corpus/sql/types/list/unnest_null_empty.test b/parser/testdata/corpus/sql/types/list/unnest_null_empty.test new file mode 100644 index 0000000..97569ae --- /dev/null +++ b/parser/testdata/corpus/sql/types/list/unnest_null_empty.test @@ -0,0 +1,99 @@ +# source: test/sql/types/list/unnest_null_empty.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +CREATE TABLE people(id INTEGER, name VARCHAR, address VARCHAR[]); +-- +ok +== +insert into people values (1, 'Zuckerberg', ARRAY['New York']); +-- +ok +== +insert into people values (2, 'Bezos', ARRAY['Washington', 'Space']); +-- +ok +== +insert into people values (3, 'Tim', NULL); +-- +ok +== +insert into people values (4, 'Elvis', ARRAY[NULL, NULL, NULL]); +-- +ok +== +insert into people values (5, 'Mark', ARRAY[]::VARCHAR[]); +-- +ok +== +SELECT UNNEST(NULL); +-- +ok +== +SELECT UNNEST(NULL::BOOLEAN[]); +-- +ok +== +SELECT name, UNNEST(address) FROM people; +-- +ok +== +SELECT name, UNNEST(address), UNNEST([1]) FROM people; +-- +ok +== +WITH t AS ( + SELECT 1 AS r, ARRAY[1, 2, 3] AS a + UNION SELECT 2 AS r, ARRAY[4] AS a + UNION SELECT 3 AS r, NULL AS a) +SELECT r, a, UNNEST(a) AS n +FROM t +ORDER BY r, n; +-- +ok +== +WITH t AS ( + SELECT 1 AS r, ARRAY[1, 2, 3] AS a + UNION SELECT 2 AS r, ARRAY[4] AS a + UNION SELECT 3 AS r, NULL AS a) +SELECT r, a.value +FROM t, (SELECT UNNEST(a)) AS a(value) +ORDER BY r, a.value +-- +ok +== +WITH t AS ( + SELECT 1 AS r, ARRAY[1, 2, 3] AS a + UNION SELECT 2 AS r, ARRAY[4] AS a + UNION SELECT 3 AS r, NULL AS a) +SELECT r, a.value +FROM t, UNNEST(a) AS a(value) +ORDER BY r, a.value +-- +ok +== +CREATE TABLE t AS SELECT 5 AS r, ARRAY[1, 2, 3] AS a; +-- +ok +== +INSERT INTO t VALUES (6, [4]), (7, NULL); +-- +ok +== +SELECT r, a.value +FROM t, UNNEST(a) AS a(value) +ORDER BY r, a.value +-- +ok +== +WITH t AS ( + SELECT 5 AS r, ARRAY[1, 2, 3] AS a + UNION SELECT 6 AS r, ARRAY[4] AS a + UNION SELECT 7 AS r, NULL AS a) +SELECT r, a.value +FROM t, UNNEST(a) AS a(value) +ORDER BY r, a.value +-- +ok +== diff --git a/parser/testdata/corpus/sql/types/list/unnest_table_function.test b/parser/testdata/corpus/sql/types/list/unnest_table_function.test new file mode 100644 index 0000000..47440cb --- /dev/null +++ b/parser/testdata/corpus/sql/types/list/unnest_table_function.test @@ -0,0 +1,119 @@ +# source: test/sql/types/list/unnest_table_function.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +SELECT * FROM UNNEST(ARRAY[1, 2, 3]); +-- +ok +== +SELECT * FROM UNNEST([1, 2, 3]::INT ARRAY); +-- +ok +== +SELECT i FROM UNNEST(ARRAY[1, 2, 3]) AS tbl(i); +-- +ok +== +SELECT i FROM UNNEST(ARRAY[NULL, 'hello', 'world', 'bleorkbaejkoreijgaiorjgare']) AS tbl(i); +-- +ok +== +SELECT i FROM UNNEST([[1, 2], [3, 4], NULL, [4, 5, 6, 7]]) AS tbl(i); +-- +ok +== +SELECT i FROM UNNEST([{'a': [1, 2, 3], 'b': [4, 5, 6]}, {'a': [4, 5], 'b': [7, 8, 9, 10]}]) AS tbl(i); +-- +ok +== +SELECT COUNT(*) FROM UNNEST((SELECT LIST(range) FROM range(4000))) AS tbl(i); +-- +ok +== +SELECT i FROM UNNEST(NULL::INT[]) AS tbl(i); +-- +ok +== +SELECT i FROM UNNEST([]::INT[]) AS tbl(i); +-- +ok +== +SELECT * FROM UNNEST((SELECT ARRAY[1,2,3] UNION ALL SELECT ARRAY[1,2,3])); +-- +ok +== +CREATE TABLE lists AS SELECT [1,2,3] l UNION ALL SELECT [4,5] UNION ALL SELECT [] UNION ALL SELECT [NULL] UNION ALL SELECT [7, 8]; +-- +ok +== +SELECT u FROM lists, UNNEST(l) AS unnest(u) ORDER BY l, u; +-- +ok +== +PREPARE v1 AS SELECT * FROM UNNEST(?::INT[]); +-- +ok +== +EXECUTE v1([1,2,3,4,5]); +-- +ok +== +SELECT i FROM UNNEST(NULL) AS tbl(i); +-- +ok +== +SELECT i FROM UNNEST(1) AS tbl(i); +-- +ok +== +SELECT i FROM UNNEST([1, 2], [3, 4]) AS tbl(i); +-- +ok +== +CREATE TABLE tbl AS +SELECT * FROM (VALUES + ('a', array[4, 5, 5], array[5, 7]), + ('b', array[2, 3], array[1, 2, 3, 4]), + ('c', array[2, 3], array[4]) +) t(k, a,b); +-- +ok +== +SELECT list_sort(array( + SELECT list_contains(b, ax) + FROM UNNEST(a) ta(ax) +)) ab_intersect +FROM tbl +ORDER BY ALL; +-- +ok +== +SELECT k, a, b, + list_sort(ARRAY( + SELECT DISTINCT ax + FROM UNNEST(a) ta(ax) + WHERE ax = any(b) + ORDER BY ALL + )) ab_intersect + FROM tbl + ORDER BY k; +-- +ok +== +SELECT unnest FROM UNNEST(ARRAY[1,2,3]); +-- +ok +== +SELECT a FROM UNNEST(ARRAY[1,2,3]) t(a); +-- +ok +== +SELECT unnest FROM (SELECT ARRAY[1,2,3] AS x), UNNEST(x); +-- +ok +== +SELECT b FROM (SELECT ARRAY[1,2,3] AS x), UNNEST(x) t(b); +-- +ok +== diff --git a/parser/testdata/corpus/sql/types/list/unnest_types.test b/parser/testdata/corpus/sql/types/list/unnest_types.test new file mode 100644 index 0000000..cacb505 --- /dev/null +++ b/parser/testdata/corpus/sql/types/list/unnest_types.test @@ -0,0 +1,33 @@ +# source: test/sql/types/list/unnest_types.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +create table a as select list(i::{type}) AS l from range(1, 6, 1) t1(i) +-- +error: Parser Error: syntax error at or near "{" +== +select l from a order by 1; +-- +ok +== +select unnest(l) from a order by 1 +-- +ok +== +create table a as select list(('1e'||i::varchar)::{type}) AS l from range(1, 6, 1) t1(i) +-- +error: Parser Error: syntax error at or near "{" +== +create table a as select list(interval (i) years) AS l from range(1, 6, 1) t1(i) +-- +ok +== +create table a as select list(i%2=0) AS l from range(1, 6, 1) t1(i); +-- +ok +== +select unnest(l) from a order by 1; +-- +ok +== diff --git a/parser/testdata/corpus/sql/types/map/map_cast.test b/parser/testdata/corpus/sql/types/map/map_cast.test new file mode 100644 index 0000000..e5a1a49 --- /dev/null +++ b/parser/testdata/corpus/sql/types/map/map_cast.test @@ -0,0 +1,45 @@ +# source: test/sql/types/map/map_cast.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +SELECT MAP(['a', 'b', 'c'], [1, 2, NULL])::MAP(VARCHAR, VARCHAR) +-- +ok +== +SELECT MAP(['a', 'b', 'c'], [1, 2, NULL])::MAP(VARCHAR, BIGINT) +-- +ok +== +SELECT MAP([1, 2, 3], [1, 2, NULL])::MAP(VARCHAR, BIGINT) +-- +ok +== +SELECT MAP([[1, 2, 3], [0], [123]], [1.0, 2.1, 4.9])::MAP(VARCHAR[], TINYINT) +-- +ok +== +SELECT MAP([1, 2, 'hi'::VARCHAR], [1.0, 2.1, 4.9])::MAP(VARCHAR, TINYINT) +-- +ok +== +SELECT MAP([1, 2, 3], ['A', 'B', 'C'])::MAP(TINYINT, VARCHAR) +-- +ok +== +SELECT MAP(['1', '01'], [10, 20])::MAP(INTEGER, INTEGER) +-- +ok +== +SELECT TRY_CAST(MAP(['1', '01'], [10, 20]) AS MAP(INTEGER, INTEGER)) +-- +ok +== +SELECT TRY_CAST(MAP(['a'], ['x']) AS MAP(VARCHAR, INTEGER)) +-- +ok +== +SELECT TRY_CAST([MAP{'a':1}, MAP{'3':3}, MAP{'b':2}] AS MAP(INT,INT)[]) +-- +ok +== diff --git a/parser/testdata/corpus/sql/types/map/map_const_and_col_combination.test b/parser/testdata/corpus/sql/types/map/map_const_and_col_combination.test new file mode 100644 index 0000000..1573c66 --- /dev/null +++ b/parser/testdata/corpus/sql/types/map/map_const_and_col_combination.test @@ -0,0 +1,125 @@ +# source: test/sql/types/map/map_const_and_col_combination.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +CREATE TABLE ints (i INT); +-- +ok +== +INSERT INTO ints VALUES (1), (2), (3); +-- +ok +== +SELECT MAP(['name'], [i]) FROM ints; +-- +ok +== +SELECT MAP(['x', 'y'], [i] ) FROM ints; +-- +ok +== +SELECT MAP([i], ['name'] ) FROM ints; +-- +ok +== +SELECT MAP([i, i+1], ['x', 'y']) FROM ints; +-- +ok +== +SELECT MAP([i, i+1], ['x', 'y']) FROM ints WHERE i > 1; +-- +ok +== +SELECT MAP(['x'], [m]) FROM (SELECT MAP([i], ['y']) m FROM ints WHERE i <> 1); +-- +ok +== +SELECT MAP(['key'], [range]) FROM range(5) WHERE range > 2; +-- +ok +== +SELECT MAP(['🦆', '🦤', '🐓'], [i, i+1, i+2]) FROM ints; +-- +ok +== +SELECT MAP([10, i, i+1, 9], [i, 3.14, 0.12, 8.0]) FROM ints; +-- +ok +== +CREATE TABLE tbl (v VARCHAR[]); +-- +ok +== +INSERT INTO tbl VALUES (ARRAY['test', 'string']), (ARRAY['foo', 'bar']); +-- +ok +== +SELECT MAP(['x', 'y'], v ) FROM tbl; +-- +ok +== +CREATE TABLE MAP_input (keys INT[], values INT[]); +-- +ok +== +INSERT INTO MAP_input VALUES ([1, 0], [2]), ([3], [4, 9]); +-- +ok +== +SELECT MAP(keys, values) FROM MAP_input; +-- +ok +== +CREATE TABLE groups (category INT, score INT); +-- +ok +== +INSERT INTO groups VALUES (1,2), (1,8), (1,3), (2,3), (2,4), (2,5), (3,6), (3,1), (3,9) +-- +ok +== +SELECT MAP(['category', 'min', 'max'], [category, MIN(score), MAX(score)]) FROM groups GROUP BY category ORDER BY ALL; +-- +ok +== +SELECT MAP([range], ['a']) FROM range(10000) WHERE range = 9999; +-- +ok +== +CREATE TABLE align_tbl (i INT[]); +-- +ok +== +INSERT INTO align_tbl VALUES ([1, 2]), ([100, 200]); +-- +ok +== +SELECT MAP(['x', 'y'], i) FROM align_tbl; +-- +ok +== +INSERT INTO align_tbl VALUES ([1, 2, 3, 4, 5, 6]), ([20, 30, 40, 50]); +-- +ok +== +SELECT MAP(['x', 'y', '1', '2', '3', '4'], i) FROM align_tbl; +-- +ok +== +SELECT MAP(i, ['x', 'y']) FROM align_tbl; +-- +ok +== +CREATE TABLE allconst (i INT); +-- +ok +== +INSERT INTO allconst VALUES (1), (2), (3); +-- +ok +== +SELECT MAP(['name'], [2]) FROM allconst; +-- +ok +== diff --git a/parser/testdata/corpus/sql/types/map/map_empty.test b/parser/testdata/corpus/sql/types/map/map_empty.test new file mode 100644 index 0000000..ee579b6 --- /dev/null +++ b/parser/testdata/corpus/sql/types/map/map_empty.test @@ -0,0 +1,9 @@ +# source: test/sql/types/map/map_empty.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +SELECT DISTINCT MAP { * : ? IN ( SELECT TRUE ) } ; +-- +ok +== diff --git a/parser/testdata/corpus/sql/types/map/map_extract_nested_null.test b/parser/testdata/corpus/sql/types/map/map_extract_nested_null.test new file mode 100644 index 0000000..5bced05 --- /dev/null +++ b/parser/testdata/corpus/sql/types/map/map_extract_nested_null.test @@ -0,0 +1,17 @@ +# source: test/sql/types/map/map_extract_nested_null.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +CREATE TABLE test(id int, attr MAP(VARCHAR, UNION(i INT, s VARCHAR))); +-- +ok +== +INSERT INTO test VALUES (1, MAP{'key1': 'str'}); +-- +ok +== +SELECT id, attr['key2'] FROM test; +-- +ok +== diff --git a/parser/testdata/corpus/sql/types/map/map_null.test b/parser/testdata/corpus/sql/types/map/map_null.test new file mode 100644 index 0000000..ca94777 --- /dev/null +++ b/parser/testdata/corpus/sql/types/map/map_null.test @@ -0,0 +1,51 @@ +# source: test/sql/types/map/map_null.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +select map(NULL::INT[], [1,2,3]) +-- +ok +== +select map(NULL, [1,2,3]) +-- +ok +== +select map(NULL, NULL) +-- +ok +== +select map(NULL, [1,2,3]) IS NULL +-- +ok +== +select map([1,2,3], NULL) +-- +ok +== +select map([1,2,3], NULL::INT[]) +-- +ok +== +SELECT * FROM ( VALUES + (MAP(NULL, NULL)), + (MAP(NULL::INT[], NULL::INT[])), + (MAP([1,2,3], [1,2,3])) +) +-- +ok +== +select MAP(a, b) FROM ( VALUES + (NULL, ['b', 'c']), + (NULL::INT[], NULL), + (NULL::INT[], NULL::VARCHAR[]), + (NULL::INT[], ['a', 'b', 'c']), + (NULL, ['longer string than inlined', 'smol']), + (NULL, NULL), + ([1,2,3], NULL), + ([1,2,3], ['z', 'y', 'x']), + ([1,2,3], NULL::VARCHAR[]), +) t(a, b) +-- +ok +== diff --git a/parser/testdata/corpus/sql/types/nested/array/array_aggregate.test b/parser/testdata/corpus/sql/types/nested/array/array_aggregate.test new file mode 100644 index 0000000..740d62a --- /dev/null +++ b/parser/testdata/corpus/sql/types/nested/array/array_aggregate.test @@ -0,0 +1,29 @@ +# source: test/sql/types/nested/array/array_aggregate.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +CREATE TABLE tbl1 (a INT[3]); +-- +ok +== +INSERT INTO tbl1 VALUES ([1, 2, 3]), ([4, NULL, 6]), ([7, 8, 9]), (NULL), ([10, 11, 12]) +-- +ok +== +SELECT FIRST(a ORDER BY ALL), LAST(a ORDER BY ALL) FROM tbl1; +-- +ok +== +SELECT COUNT(*), max(a) FROM tbl1 GROUP BY list_sum(a::INT[]) % 2 == 0; +-- +ok +== +SELECT COUNT(*), max(a) FROM tbl1 GROUP BY list_sum(a::INT[]) % 2 == 0 HAVING list_sum(a::INT[]) % 2 == 0 NOT NULL; +-- +ok +== +SELECT MAX(a), MIN(a) FROM tbl1; +-- +ok +== diff --git a/parser/testdata/corpus/sql/types/nested/array/array_cast.test b/parser/testdata/corpus/sql/types/nested/array/array_cast.test new file mode 100644 index 0000000..5155234 --- /dev/null +++ b/parser/testdata/corpus/sql/types/nested/array/array_cast.test @@ -0,0 +1,141 @@ +# source: test/sql/types/nested/array/array_cast.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +SELECT array_value(1, 2, 3)::VARCHAR +-- +ok +== +SELECT array_value(1, 2, 3)::INT[] +-- +ok +== +SELECT list_extract(array_value(1, 2, 3), 2) +-- +ok +== +SELECT * FROM UNNEST(array_value(1, 2, 3)) +-- +ok +== +SELECT unnest(array_value(1, 2, 3)::INT[]) +-- +ok +== +SELECT array_value('1.0', '2.0', '3.0')::DOUBLE[3] +-- +ok +== +SELECT array_value(1, 2, 3)::INT[2] +-- +ok +== +SELECT array_value(1, 2, 3)::INT[4] +-- +ok +== +SELECT [1,2,3]::INT[3] +-- +ok +== +SELECT ['1.0', '2.0', '3.0']::DOUBLE[3] +-- +ok +== +SELECT [1, 2, 3]::BLOB[3] +-- +ok +== +SELECT NULL::INT[3] +-- +ok +== +SELECT [[1, 2, 3], [4, 5, 6]]::INT[3][2] +-- +ok +== +SELECT (NULL::INT[])::INT[3] +-- +ok +== +SELECT c::INT[3] FROM (VALUES ([1,2,3]), ([4,NULL,6]), (NULL), ([7,8,9])) as t(c); +-- +ok +== +SELECT [[1, 2, 3], [4, 5, 6, 7]]::INT[3][2] +-- +ok +== +CREATE OR REPLACE TABLE t1 AS SELECT [1, 2, 3]::INT[3]; +-- +ok +== +CREATE OR REPLACE TABLE t2 AS SELECT ['4', '5', '6']::VARCHAR[3]; +-- +ok +== +INSERT INTO t2 SELECT * FROM t1; +-- +ok +== +SELECT ([1, NULL, 3]::INT[3])::VARCHAR[3] +-- +ok +== +SELECT (NULL::INT[3])::VARCHAR +-- +ok +== +SELECT (['2', 'abc', '3']::VARCHAR[3])::INT[] +-- +ok +== +SELECT ([1,2,3]::INT[3])::INT; +-- +ok +== +SELECT TRY_CAST([42, 999, NULL, NULL, -42]::INT[5] AS TIMESTAMP WITH TIME ZONE[]); +-- +ok +== +select (NULL::INT[3])::VARCHAR[3]; +-- +ok +== +SELECT '[1, 2, 3]'::INTEGER[3] +-- +ok +== +SELECT TRY_CAST(l AS INTEGER[][3]) FROM VALUES (['foo']) as v(l); +-- +ok +== +CREATE TABLE list_child_offset AS + SELECT i, [(i * 3 + 1)::VARCHAR, (i * 3 + 2)::VARCHAR, (i * 3 + 3)::VARCHAR] AS l + FROM range(100) t(i); +-- +ok +== +SELECT i, l::INT[3] FROM list_child_offset WHERE i = 99 +-- +ok +== +SELECT i, l::INT[3] FROM list_child_offset WHERE i IN (50, 99) ORDER BY i +-- +ok +== +CREATE TABLE unreferenced_bad_child AS + SELECT i, CASE WHEN i = 0 THEN ['1', '2', '3'] ELSE ['x', 'y', 'z'] END AS l + FROM range(100) t(i); +-- +ok +== +SELECT l::INT[3] FROM unreferenced_bad_child WHERE i = 0 +-- +ok +== +SELECT TRY_CAST(l AS INT[3]) FROM unreferenced_bad_child WHERE i = 1 +-- +ok +== diff --git a/parser/testdata/corpus/sql/types/nested/array/array_coverage.test b/parser/testdata/corpus/sql/types/nested/array/array_coverage.test new file mode 100644 index 0000000..a8fc094 --- /dev/null +++ b/parser/testdata/corpus/sql/types/nested/array/array_coverage.test @@ -0,0 +1,29 @@ +# source: test/sql/types/nested/array/array_coverage.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +SELECT DISTINCT array_value(array_value(1, 2, 3), array_value(4,5,6)); +-- +ok +== +SELECT DISTINCT array_value([1,2,3], [4,5,6]); +-- +ok +== +SELECT DISTINCT [array_value(1,2,3), array_value(4,5,6)]; +-- +ok +== +SELECT * FROM (VALUES (array_value(NULL, 'abc')), (array_value(NULL, 'defg')), (NULL)) ORDER BY 1 DESC; +-- +ok +== +SELECT * FROM (VALUES (array_value(NULL, 'ghf', NULL)), (array_value(NULL, NULL, 'defg')), (NULL)) ORDER BY 1 DESC; +-- +ok +== +SELECT * FROM (VALUES (array_value(NULL, NULL, 'ghf')), (array_value(NULL, 'defg', NULL)), (NULL)) ORDER BY 1 DESC; +-- +ok +== diff --git a/parser/testdata/corpus/sql/types/nested/array/array_fuzzer_failures.test b/parser/testdata/corpus/sql/types/nested/array/array_fuzzer_failures.test new file mode 100644 index 0000000..0e6d518 --- /dev/null +++ b/parser/testdata/corpus/sql/types/nested/array/array_fuzzer_failures.test @@ -0,0 +1,17 @@ +# source: test/sql/types/nested/array/array_fuzzer_failures.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +CREATE TABLE array_tbl(c50 INTEGER[2][]);; +-- +ok +== +SELECT subq_0.c2 AS c4 FROM (SELECT ref_1.fixed_nested_int_array AS c2 FROM main.all_types AS ref_0 LEFT JOIN main.all_types AS ref_1 ON ((ref_0."varchar" !~~* ref_1."varchar"))) AS subq_0 RIGHT JOIN main.all_types AS ref_2 ON ((subq_0.c2 = ref_2.fixed_nested_int_array)) +-- +ok +== +SELECT TRY_CAST(c36 AS INTEGER[][3]) FROM all_types AS t51(c1, c2, c3, c4, c5, c6, c7, c8, c9, c10, c11, c12, c13, c14, c15, c16, c17, c18, c19, c20, c21, c22, c23, c24, c25, c26, c27, c28, c29, c30, c31, c32, c33, c34, c35, c36, c37, c38, c39, c40, c41, c42, c43, c44, c45, c46, c47, c48, c49, c50) WHERE c6 +-- +ok +== diff --git a/parser/testdata/corpus/sql/types/nested/array/array_invalid.test b/parser/testdata/corpus/sql/types/nested/array/array_invalid.test new file mode 100644 index 0000000..11d34b8 --- /dev/null +++ b/parser/testdata/corpus/sql/types/nested/array/array_invalid.test @@ -0,0 +1,45 @@ +# source: test/sql/types/nested/array/array_invalid.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +CREATE TABLE t1(a INT, b INT[0]); +-- +ok +== +CREATE TABLE t1(a INT, b INT[4294967299]); +-- +ok +== +CREATE TABLE t1(a INT, b INT[2147483647]); +-- +ok +== +SELECT array_value(); +-- +ok +== +CREATE TABLE t1(a INT, b INT[-1]); +-- +error: Parser Error: Array size must be greater than 0 +== +CREATE TABLE t1(a INT, b INT['foobar']); +-- +ok +== +SELECT ([1,2,3]::INTEGER[3])::INTEGER[0]; +-- +ok +== +SELECT ([1,2,3]::INTEGER[3])::INTEGER[-1]; +-- +error: Parser Error: Array size must be greater than 0 +== +SELECT ([1,2,3]::INTEGER[3])::INTEGER[1.5]; +-- +ok +== +SELECT ([1,2,3]::INTEGER[3])::INTEGER['foobar']; +-- +ok +== diff --git a/parser/testdata/corpus/sql/types/nested/array/array_invalid.test.metadata.json b/parser/testdata/corpus/sql/types/nested/array/array_invalid.test.metadata.json new file mode 100644 index 0000000..f6b4873 --- /dev/null +++ b/parser/testdata/corpus/sql/types/nested/array/array_invalid.test.metadata.json @@ -0,0 +1,6 @@ +{ + "todo": { + "0f113ab0c062fe35": "transformer-raised parser error: upstream rejects in the transformer, not the grammar; expected to clear as transformers land (milestones 3-5)", + "d589194f95624c58": "transformer-raised parser error: upstream rejects in the transformer, not the grammar; expected to clear as transformers land (milestones 3-5)" + } +} diff --git a/parser/testdata/corpus/sql/types/nested/array/array_joins.test b/parser/testdata/corpus/sql/types/nested/array/array_joins.test new file mode 100644 index 0000000..bf2a47e --- /dev/null +++ b/parser/testdata/corpus/sql/types/nested/array/array_joins.test @@ -0,0 +1,72 @@ +# source: test/sql/types/nested/array/array_joins.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +CREATE TABLE t1(i INTEGER, a INTEGER[3]) +-- +ok +== +INSERT INTO t1 VALUES + (1, array_value(1,2,3)), + (2, array_value(NULL,5,6)), + (3, array_value(7,NULL,9)), + (4, array_value(10,11,NULL)); +-- +ok +== +SELECT DISTINCT * FROM t1 ORDER BY ALL; +-- +ok +== +CREATE OR REPLACE TABLE t1(i INTEGER, a INTEGER[][3]) +-- +ok +== +INSERT INTO t1 +SELECT + i, + array_value(list_value(i, i + 1, i + 2), list_value(i + 3, i + 4, i + 5), list_value(i + 6,i + 7,i + 8)) +FROM range(0,9*9,9) as r(i); +-- +ok +== +CREATE OR REPLACE TABLE t1 AS SELECT * FROM ( + VALUES + (1, {COLLECTION}(1,2)), + (2, {COLLECTION}(NULL,5)), + (3, NULL), +) as t(i, a); +-- +error: Parser Error: syntax error at or near "}" +== +CREATE OR REPLACE TABLE t2 AS SELECT * FROM ( + VALUES + (1, {COLLECTION}(4,5)), + (2, {COLLECTION}(8,9)), + (3, {COLLECTION}(6,7)), + (4, {COLLECTION}(1,2)) +) as t(i, a); +-- +error: Parser Error: syntax error at or near "}" +== +SELECT * FROM t1 JOIN t2 USING (i) ORDER BY ALL; +-- +ok +== +SELECT * FROM t1 JOIN t2 ON t1.a = t2.a ORDER BY ALL; +-- +ok +== +SELECT * FROM t1 FULL OUTER JOIN t2 USING (i) ORDER BY ALL; +-- +ok +== +CREATE OR REPLACE TABLE t1 AS SELECT * FROM (VALUES (1, [1,2,3]::{COLLECTION}), (2, [4,5,6]::{COLLECTION}), (3, [1,2,3]::{COLLECTION})); +-- +error: Parser Error: syntax error at or near "{" +== +SELECT * FROM t1 as a JOIN t1 as b ON (a.col1 != b.col1) ORDER BY ALL; +-- +ok +== diff --git a/parser/testdata/corpus/sql/types/nested/array/array_joins_2.test b/parser/testdata/corpus/sql/types/nested/array/array_joins_2.test new file mode 100644 index 0000000..e427950 --- /dev/null +++ b/parser/testdata/corpus/sql/types/nested/array/array_joins_2.test @@ -0,0 +1,29 @@ +# source: test/sql/types/nested/array/array_joins_2.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +CREATE TABLE test_array (c1 int[3]); +-- +ok +== +INSERT INTO test_array values (null), (array[1, 2, 3]), (array[4, 5, 6]), (array[7, 8, 9]); +-- +ok +== +SELECT * FROM test_array JOIN test_array AS t2 ON t2.c1 = test_array.c1; +-- +ok +== +INSERT INTO test_array values (null); +-- +ok +== +INSERT INTO test_array values (array[10, 11, 12]); +-- +ok +== +SELECT * FROM test_array JOIN test_array AS t2 ON t2.c1 = test_array.c1 ORDER BY test_array.c1; +-- +ok +== diff --git a/parser/testdata/corpus/sql/types/nested/array/array_large.test b/parser/testdata/corpus/sql/types/nested/array/array_large.test new file mode 100644 index 0000000..4a0cb55 --- /dev/null +++ b/parser/testdata/corpus/sql/types/nested/array/array_large.test @@ -0,0 +1,49 @@ +# source: test/sql/types/nested/array/array_large.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +CREATE TABLE t1 (a INT[4096]); +-- +ok +== +INSERT INTO t1 VALUES (range(0, 4096)); +-- +ok +== +SELECT list_sum(a::INT[]) == list_sum(range(0, 4096)) FROM t1; +-- +ok +== +CREATE TABLE t2 AS SELECT array_value(a) AS i FROM range(0, 4096) r(a); +-- +ok +== +SELECT sum(i[1]) FROM t2; +-- +ok +== +CREATE TABLE t3 AS SELECT array_value(a, a+1) AS i FROM range(0, 4096) r(a); +-- +ok +== +SELECT sum(i[1]) == 8386560 AND sum(i[2]) == 8390656 FROM t3; +-- +ok +== +CREATE OR REPLACE TABLE t4 AS SELECT * FROM range(0, 4096) as r(a); +-- +ok +== +UPDATE t4 SET a = NULL WHERE a % 2 = 0; +-- +ok +== +CREATE TABLE t5 AS SELECT array_value(a) AS i FROM t4; +-- +ok +== +SELECT sum(i[1]) FROM t5; +-- +ok +== diff --git a/parser/testdata/corpus/sql/types/nested/array/array_limit_offset.test b/parser/testdata/corpus/sql/types/nested/array/array_limit_offset.test new file mode 100644 index 0000000..7177999 --- /dev/null +++ b/parser/testdata/corpus/sql/types/nested/array/array_limit_offset.test @@ -0,0 +1,21 @@ +# source: test/sql/types/nested/array/array_limit_offset.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +INSERT INTO tbl1 VALUES ([1, 2, 3]), ([4, NULL, 6]), ([7, 8, 9]), (NULL), ([10, 11, 12]); +-- +ok +== +SELECT * FROM tbl1 LIMIT 1; +-- +ok +== +SELECT * FROM tbl1 OFFSET 1; +-- +ok +== +SELECT * FROM tbl1 OFFSET 1 LIMIT 1; +-- +ok +== diff --git a/parser/testdata/corpus/sql/types/nested/array/array_list_agg.test b/parser/testdata/corpus/sql/types/nested/array/array_list_agg.test new file mode 100644 index 0000000..ad5f68b --- /dev/null +++ b/parser/testdata/corpus/sql/types/nested/array/array_list_agg.test @@ -0,0 +1,29 @@ +# source: test/sql/types/nested/array/array_list_agg.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +CREATE TABLE arrays (a INTEGER[3]); +-- +ok +== +INSERT INTO arrays VALUES ([1, 2, 3]), ([1, 2, 4]), ([7, 8, 9]), ([-1, -2, -3]), (NULL), ([4, NULL, 2]) +-- +ok +== +SELECT list(a) FROM arrays; +-- +ok +== +SELECT list(a ORDER BY a[3] ASC) FROM arrays; +-- +ok +== +SELECT list(a ORDER BY a[3] DESC) FROM arrays; +-- +ok +== +SELECT list(array_value({'foo': [10]})); +-- +ok +== diff --git a/parser/testdata/corpus/sql/types/nested/array/array_list_aggregate.test b/parser/testdata/corpus/sql/types/nested/array/array_list_aggregate.test new file mode 100644 index 0000000..79ff1dd --- /dev/null +++ b/parser/testdata/corpus/sql/types/nested/array/array_list_aggregate.test @@ -0,0 +1,17 @@ +# source: test/sql/types/nested/array/array_list_aggregate.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +CREATE TABLE t1 (a INT, b INT, c INT); +-- +ok +== +INSERT INTO t1 VALUES (1,2,3), (4,5,6); +-- +ok +== +SELECT list(array_value(a,b,c) ORDER By b) FROM t1 GROUP by c; +-- +ok +== diff --git a/parser/testdata/corpus/sql/types/nested/array/array_misc.test b/parser/testdata/corpus/sql/types/nested/array/array_misc.test new file mode 100644 index 0000000..9493c14 --- /dev/null +++ b/parser/testdata/corpus/sql/types/nested/array/array_misc.test @@ -0,0 +1,71 @@ +# source: test/sql/types/nested/array/array_misc.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +CREATE TABLE arrays (a INTEGER[3]) +-- +ok +== +SELECT a[3] FROM arrays +-- +ok +== +SELECT DISTINCT a FROM arrays ORDER BY ALL +-- +ok +== +SELECT DISTINCT a FROM arrays WHERE a[1] > 0 ORDER BY ALL +-- +ok +== +SELECT * FROM ( + SELECT a FROM ARRAYS + UNION + SELECT a FROM ARRAYS +) +ORDER BY ALL +-- +ok +== +SELECT * FROM ( + SELECT a FROM ARRAYS WHERE a[1] > 0 + UNION + SELECT a FROM ARRAYS WHERE a[1] > 0 +) +ORDER BY ALL +-- +ok +== +SELECT first(DISTINCT a ORDER BY a) FROM arrays +-- +ok +== +SELECT a::VARCHAR FROM arrays ORDER BY ALL +-- +ok +== +SELECT TRY_CAST(a::INTEGER[] AS INTEGER[3]) FROM ARRAYS ORDER BY ALL +-- +ok +== +SELECT a[2:-1] FROM arrays +-- +ok +== +SELECT a[3:99] FROM arrays +-- +ok +== +DESCRIBE SELECT * FROM arrays +-- +ok +== +SELECT a.filter(lambda x: x > 0) FROM arrays +-- +ok +== +SELECT a.apply(lambda x: x + 1)::INTEGER[3] FROM arrays +-- +ok +== diff --git a/parser/testdata/corpus/sql/types/nested/array/array_roundtrip_csv.test b/parser/testdata/corpus/sql/types/nested/array/array_roundtrip_csv.test new file mode 100644 index 0000000..d06f88d --- /dev/null +++ b/parser/testdata/corpus/sql/types/nested/array/array_roundtrip_csv.test @@ -0,0 +1,21 @@ +# source: test/sql/types/nested/array/array_roundtrip_csv.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +CREATE OR REPLACE TABLE arrays2 (a INTEGER[3]) +-- +ok +== +COPY (SELECT [range, range + 1, range + 2] a FROM range(3)) TO '{TEST_DIR}/arrays_csv_test.csv' +-- +ok +== +COPY arrays2 FROM '{TEST_DIR}/arrays_csv_test.csv' +-- +ok +== +SELECT * FROM arrays2 +-- +ok +== diff --git a/parser/testdata/corpus/sql/types/nested/array/array_roundtrip_json.test b/parser/testdata/corpus/sql/types/nested/array/array_roundtrip_json.test new file mode 100644 index 0000000..4d19cf2 --- /dev/null +++ b/parser/testdata/corpus/sql/types/nested/array/array_roundtrip_json.test @@ -0,0 +1,17 @@ +# source: test/sql/types/nested/array/array_roundtrip_json.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +SELECT a::JSON FROM arrays +-- +ok +== +COPY (SELECT [range, range + 1, range + 2] a FROM range(3)) TO '{TEST_DIR}/arrays_parquet_test.json' +-- +ok +== +COPY arrays2 FROM '{TEST_DIR}/arrays_parquet_test.json' +-- +ok +== diff --git a/parser/testdata/corpus/sql/types/nested/array/array_roundtrip_parquet.test b/parser/testdata/corpus/sql/types/nested/array/array_roundtrip_parquet.test new file mode 100644 index 0000000..564cd94 --- /dev/null +++ b/parser/testdata/corpus/sql/types/nested/array/array_roundtrip_parquet.test @@ -0,0 +1,13 @@ +# source: test/sql/types/nested/array/array_roundtrip_parquet.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +COPY (SELECT [range, range + 1, range + 2] a FROM range(3)) TO '{TEST_DIR}/arrays_parquet_test.parquet' +-- +ok +== +COPY arrays2 FROM '{TEST_DIR}/arrays_parquet_test.parquet' +-- +ok +== diff --git a/parser/testdata/corpus/sql/types/nested/array/array_rowgroup.test b/parser/testdata/corpus/sql/types/nested/array/array_rowgroup.test new file mode 100644 index 0000000..6339aad --- /dev/null +++ b/parser/testdata/corpus/sql/types/nested/array/array_rowgroup.test @@ -0,0 +1,17 @@ +# source: test/sql/types/nested/array/array_rowgroup.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +create table arrays(id int primary key, a int[3]); +-- +ok +== +insert into arrays select i, [i, i + 1, i +2] from range(200000) t(i); +-- +ok +== +select * from arrays where id=150000; +-- +ok +== diff --git a/parser/testdata/corpus/sql/types/nested/array/array_simple.test b/parser/testdata/corpus/sql/types/nested/array/array_simple.test new file mode 100644 index 0000000..0def06e --- /dev/null +++ b/parser/testdata/corpus/sql/types/nested/array/array_simple.test @@ -0,0 +1,64 @@ +# source: test/sql/types/nested/array/array_simple.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +SELECT array_value(1, 2, 3); +-- +ok +== +SELECT array_value(i -1, i, i + 1) +FROM range(1,4) as r(i); +-- +ok +== +CREATE TABLE t1 (c INT[2]) +-- +ok +== +INSERT INTO t1 VALUES (array_value(1, 2)) +-- +ok +== +INSERT INTO t1 VALUES (array_value(3, 4)) +-- +ok +== +SELECT * FROM t1 ORDER BY c DESC +-- +ok +== +CREATE OR REPLACE TABLE t1 AS SELECT * FROM (VALUES (array_value(6, NULL)), (array_value(1, 2)), (array_value(NULL,NULL)), (array_value(NULL, 3))); +-- +ok +== +SELECT * FROM t1 ORDER BY 1 DESC; +-- +ok +== +SELECT * FROM t1 ORDER BY 1 ASC; +-- +ok +== +CREATE OR REPLACE TABLE t1 AS SELECT * FROM VALUES + (array_value(1,2), 1), + (array_value(3,4), 2) as t(a, i); +-- +ok +== +SELECT MAX(i), arg_max(a, i) FROM t1; +-- +ok +== +CREATE TABLE t4(a BIGINT); +-- +ok +== +INSERT INTO t4 VALUES (1), (2), (3); +-- +ok +== +SELECT array_value(a, 42), typeof(array_value(a, 42)) FROM t4; +-- +ok +== diff --git a/parser/testdata/corpus/sql/types/nested/array/array_statistics.test b/parser/testdata/corpus/sql/types/nested/array/array_statistics.test new file mode 100644 index 0000000..9e0e29b --- /dev/null +++ b/parser/testdata/corpus/sql/types/nested/array/array_statistics.test @@ -0,0 +1,13 @@ +# source: test/sql/types/nested/array/array_statistics.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +SELECT s.child_stats.min, s.child_stats.max, s.has_no_null, s.has_null FROM (SELECT STATS(array_value(1,2)) s) +-- +ok +== +PREPARE v1 AS SELECT array_cross_product($1::float[3], $2::float[3]) +-- +ok +== diff --git a/parser/testdata/corpus/sql/types/nested/array/array_storage_3.test b/parser/testdata/corpus/sql/types/nested/array/array_storage_3.test new file mode 100644 index 0000000..0028096 --- /dev/null +++ b/parser/testdata/corpus/sql/types/nested/array/array_storage_3.test @@ -0,0 +1,29 @@ +# source: test/sql/types/nested/array/array_storage_3.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +pragma preserve_insertion_order=true +-- +ok +== +CREATE TABLE tbl1 AS SELECT array_value(a, a) FROM range(0,122881) AS r1(a) +-- +ok +== +SELECT * FROM tbl1 LIMIT 1 OFFSET 0; +-- +ok +== +SELECT * FROM tbl1 LIMIT 1 OFFSET 122880 // 2 +-- +ok +== +SELECT * FROM tbl1 LIMIT 1 OFFSET 122879 +-- +ok +== +SELECT * FROM tbl1 LIMIT 1 OFFSET 122880 +-- +ok +== diff --git a/parser/testdata/corpus/sql/types/nested/array/array_summarize.test b/parser/testdata/corpus/sql/types/nested/array/array_summarize.test new file mode 100644 index 0000000..4e9372f --- /dev/null +++ b/parser/testdata/corpus/sql/types/nested/array/array_summarize.test @@ -0,0 +1,25 @@ +# source: test/sql/types/nested/array/array_summarize.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +SUMMARIZE arrays +-- +ok +== +SELECT a FROM arrays ORDER BY a LIMIT 1 +-- +ok +== +SELECT min(a) FROM arrays +-- +ok +== +SELECT max(a) FROM arrays +-- +ok +== +INSERT INTO arrays VALUES ([-7, -8, -9]), ([-8, -9, -10]) +-- +ok +== diff --git a/parser/testdata/corpus/sql/types/nested/array/array_try_cast.test b/parser/testdata/corpus/sql/types/nested/array/array_try_cast.test new file mode 100644 index 0000000..c6d702a --- /dev/null +++ b/parser/testdata/corpus/sql/types/nested/array/array_try_cast.test @@ -0,0 +1,65 @@ +# source: test/sql/types/nested/array/array_try_cast.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +SELECT TRY_CAST(array_value(1,2) as INTEGER[3]); +-- +ok +== +SELECT CAST(array_value(1,2) as INTEGER[3]); +-- +ok +== +SELECT TRY_CAST(x as INT[2][2]) FROM (VALUES ([[1,2],[3,4]]), ([[5,6],[7,8]])) AS t(x) +-- +ok +== +SELECT TRY_CAST(x as INT[2][2]) FROM (VALUES ([[1,2],[3,4]]), ([[5,6],[7,8,9]])) AS t(x) +-- +ok +== +SELECT CAST(x as INT[2][2]) FROM (VALUES ([[1,2],[3,4]]), ([[5,6],[7,8,9]])) AS t(x) +-- +ok +== +SELECT TRY_CAST(x as INT[2][2]) FROM (VALUES ([[1,2],[3,4]]), ([[5,6],[7,8],[9,10]])) AS t(x) +-- +ok +== +SELECT CAST(x as INT[2][2]) FROM (VALUES ([[1,2],[3,4]]), ([[5,6],[7,8],[9,10]])) AS t(x) +-- +ok +== +SELECT TRY_CAST('[1,2]' as INTEGER[3]); +-- +ok +== +SELECT CAST('[1,2]' as INTEGER[3]); +-- +ok +== +SELECT CAST('[NULL, [1], [NULL]]' as INTEGER[1][3]); +-- +ok +== +SELECT TRY_CAST('[NULL, [1], [abc]]' as INTEGER[1][3]) +-- +ok +== +SELECT TRY_CAST('[NULL, [1,NULL,3], [1,2,3]]' as INTEGER[3][3]); +-- +ok +== +SELECT CAST('[NULL, [1,NULL,3], [1,2,3]]' as INTEGER[3][3]); +-- +ok +== +SELECT CAST('[NULL, [1,NULL,3], [1,2]]' as INTEGER[3][3]); +-- +ok +== +SELECT TRY_CAST('[NULL, [1,NULL,3], [1,2]]' as INTEGER[3][3]); +-- +ok +== diff --git a/parser/testdata/corpus/sql/types/nested/array/array_try_cast_vector_types.test b/parser/testdata/corpus/sql/types/nested/array/array_try_cast_vector_types.test new file mode 100644 index 0000000..8e5fdd6 --- /dev/null +++ b/parser/testdata/corpus/sql/types/nested/array/array_try_cast_vector_types.test @@ -0,0 +1,13 @@ +# source: test/sql/types/nested/array/array_try_cast_vector_types.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +SELECT TRY_CAST(test_vector AS INT[2]) AS a FROM test_vector_types(NULL::INTEGER[]) +-- +ok +== +SELECT CAST(test_vector AS INT[2]) AS a FROM test_vector_types(NULL::INTEGER[]) +-- +ok +== diff --git a/parser/testdata/corpus/sql/types/nested/array/array_tupleformat.test b/parser/testdata/corpus/sql/types/nested/array/array_tupleformat.test new file mode 100644 index 0000000..ac50a54 --- /dev/null +++ b/parser/testdata/corpus/sql/types/nested/array/array_tupleformat.test @@ -0,0 +1,80 @@ +# source: test/sql/types/nested/array/array_tupleformat.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +CREATE TABLE t1 (i VARCHAR[3]) +-- +ok +== +INSERT INTO t1 VALUES (array_value('1',NULL,'3')), (NULL), (array_value(NULL,'5','6')); +-- +ok +== +SELECT DISTINCT * FROM t1; +-- +ok +== +CREATE TABLE t2(i VARCHAR[2][2]) +-- +ok +== +INSERT INTO t2 VALUES (array_value(array_value('1', NULL), array_value(NULL, '2'))), (NULL), (array_value(array_value('3', NULL), array_value(NULL, '4'))); +-- +ok +== +SELECT DISTINCT * FROM t2; +-- +ok +== +CREATE TABLE t3(i VARCHAR[2][]) +-- +ok +== +INSERT INTO t3 VALUES (array_value(list_value('1', NULL), list_value(NULL, '2'))), (NULL), (array_value(list_value('3', NULL), list_value(NULL, '4'))); +-- +ok +== +SELECT DISTINCT * FROM t3; +-- +ok +== +CREATE TABLE t4(i VARCHAR[][2]) +-- +ok +== +INSERT INTO t4 VALUES (list_value(array_value('1', NULL), array_value(NULL, '2'))), (NULL), (list_value(array_value('3', NULL), array_value(NULL, '4'))); +-- +ok +== +SELECT DISTINCT * FROM t4; +-- +ok +== +CREATE TABLE t5(i VARCHAR[][2][]) +-- +ok +== +INSERT INTO t5 VALUES (list_value(list_value(array_value('1', NULL), array_value(NULL, '2')))), (NULL), (list_value(list_value(array_value('3', NULL), array_value(NULL, '4')))); +-- +ok +== +SELECT DISTINCT * FROM t5; +-- +ok +== +CREATE TABLE t6(i VARCHAR[2][][2]) +-- +ok +== +INSERT INTO t6 VALUES + (array_value([array_value('1', NULL)], [array_value(NULL, '2')])), + (NULL), + (array_value([array_value('3', NULL)], [array_value(NULL, '4')])); +-- +ok +== +SELECT DISTINCT * FROM t6; +-- +ok +== diff --git a/parser/testdata/corpus/sql/types/nested/array/array_unnest.test b/parser/testdata/corpus/sql/types/nested/array/array_unnest.test new file mode 100644 index 0000000..eeecc95 --- /dev/null +++ b/parser/testdata/corpus/sql/types/nested/array/array_unnest.test @@ -0,0 +1,37 @@ +# source: test/sql/types/nested/array/array_unnest.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +SELECT UNNEST(array_value(1, 2, NULL, 4, 5)); +-- +ok +== +SELECT UNNEST(array_value('this is', 'a test', NULL, 'of unnesting arrays')); +-- +ok +== +CREATE TABLE t1 AS SELECT array_value(i + 1, i + 2) j FROM range(0, 10, 2) as t(i) +-- +ok +== +SELECT j, UNNEST(j) FROM t1 +-- +ok +== +CREATE TABLE doubles_table (doubles_dynamic DOUBLE[], doubles_fixed DOUBLE[2]); +-- +ok +== +INSERT INTO doubles_table VALUES ([1.2, 2.3], [1.2, 2.3]); +-- +ok +== +SELECT UNNEST(doubles_dynamic) FROM doubles_table; +-- +ok +== +SELECT UNNEST(doubles_fixed) FROM doubles_table; +-- +ok +== diff --git a/parser/testdata/corpus/sql/types/nested/list/any_list.test b/parser/testdata/corpus/sql/types/nested/list/any_list.test new file mode 100644 index 0000000..0f64c99 --- /dev/null +++ b/parser/testdata/corpus/sql/types/nested/list/any_list.test @@ -0,0 +1,85 @@ +# source: test/sql/types/nested/list/any_list.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +SELECT 1=ALL([1, 2, 3]); +-- +ok +== +SELECT 1=ALL([1, 2, 3, NULL]); +-- +ok +== +SELECT 1=ANY([1, 2, 3]); +-- +ok +== +SELECT 4=ANY([1, 2, 3]); +-- +ok +== +SELECT 4=ANY([1, 2, 3, NULL]); +-- +ok +== +SELECT 4>ALL([1, 2, 3]); +-- +ok +== +SELECT 4>ALL([1, 2, 3, NULL]); +-- +ok +== +SELECT 1=ANY(NULL); +-- +ok +== +CREATE VIEW v1 AS SELECT LIST(i) l FROM RANGE(5) tbl(i) +-- +ok +== +SELECT 1=ANY(l) FROM v1; +-- +ok +== +SELECT 6=ANY(l) FROM v1; +-- +ok +== +SELECT NULL=ANY(l) FROM v1; +-- +ok +== +CREATE VIEW v2 AS SELECT LIST(case when i % 2 = 0 then null else i end) l FROM RANGE(5) tbl(i) +-- +ok +== +SELECT 1=ANY(l) FROM v2; +-- +ok +== +SELECT 6=ANY(l) FROM v2; +-- +ok +== +SELECT NULL=ANY(l) FROM v2; +-- +ok +== +SELECT g, 5=ANY(l) FROM v3 ORDER BY g; +-- +ok +== +SELECT g, 3>ANY(l) FROM v3 ORDER BY g; +-- +ok +== +SELECT g, 100>ALL(l) FROM v3 ORDER BY g; +-- +ok +== +SELECT g, (SELECT 5=ANY(l)) FROM v3 ORDER BY g; +-- +ok +== diff --git a/parser/testdata/corpus/sql/types/nested/list/array.test b/parser/testdata/corpus/sql/types/nested/list/array.test new file mode 100644 index 0000000..ed9cfd2 --- /dev/null +++ b/parser/testdata/corpus/sql/types/nested/list/array.test @@ -0,0 +1,65 @@ +# source: test/sql/types/nested/list/array.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +SELECT ARRAY[1,2], ARRAY[NULL], ARRAY['hello', 'world'], ARRAY[] +-- +ok +== +SELECT ARRAY[ARRAY[1,2]], ARRAY[ARRAY[ARRAY[1, 2], ARRAY[2, 3]], ARRAY[ARRAY[5], ARRAY[3, 4]]]; +-- +ok +== +SELECT ARRAY[1,2,3,4,5,6,7,8,9,10,NULL] +-- +ok +== +SELECT ARRAY[1, i] FROM range(3) tbl(i) ORDER BY i +-- +ok +== +SELECT ARRAY[i] FROM range(3) tbl(i) WHERE (ARRAY[i])[1] == 1 +-- +ok +== +SELECT ARRAY[i, 'hello'] FROM generate_series(0,2) tbl(i) WHERE (ARRAY[i])[1] == 1 +-- +ok +== +SELECT ARRAY[ARRAY[1], ARRAY['hello']] +-- +ok +== +SELECT ARRAY[1]::BIGINT[] +-- +ok +== +SELECT ARRAY[1]::BIGINT ARRAY +-- +ok +== +SELECT ARRAY[[1, 2], [3, 4]]::BIGINT[][] +-- +ok +== +SELECT ARRAY[[1, 2], [3, 4]]::BIGINT[] +-- +ok +== +SELECT ARRAY[[1, 2], [3, 4]]::VARCHAR[] +-- +ok +== +SELECT UNNEST(UNNEST(ARRAY[[1, 2], [3, 4]]::VARCHAR[][])) +-- +ok +== +SELECT UNNEST(ARRAY[[1, 2], [3, 4]]::VARCHAR[]) +-- +ok +== +SELECT ARRAY[[1, 2], [3, 4]]::VARCHAR +-- +ok +== diff --git a/parser/testdata/corpus/sql/types/nested/list/array_agg.test b/parser/testdata/corpus/sql/types/nested/list/array_agg.test new file mode 100644 index 0000000..24a2aeb --- /dev/null +++ b/parser/testdata/corpus/sql/types/nested/list/array_agg.test @@ -0,0 +1,62 @@ +# source: test/sql/types/nested/list/array_agg.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +SELECT ARRAY_AGG(NULL), ARRAY_AGG(42) +-- +ok +== +SELECT ARRAY_AGG(i) FROM range(0, 3) tbl(i) +-- +ok +== +SELECT ARRAY_AGG(i) FROM range(0, 0) tbl(i) +-- +ok +== +CREATE TABLE films(film_id INTEGER, title VARCHAR) +-- +ok +== +CREATE TABLE actors(actor_id INTEGER, first_name VARCHAR, last_name VARCHAR) +-- +ok +== +CREATE TABLE film_actor(film_id INTEGER, actor_id INTEGER) +-- +ok +== +INSERT INTO films VALUES (1, 'The Martian'), (2, 'Saving Private Ryan'), (3, 'Team America'); +-- +ok +== +INSERT INTO actors VALUES (1, 'Matt', 'Damon'), (2, 'Jessica', 'Chastain'), (3, 'Tom', 'Hanks'), (4, 'Edward', 'Burns'), + (5, 'Kim', 'Jong Un'), (6, 'Alec', 'Baldwin'); +-- +ok +== +INSERT INTO film_actor VALUES (1, 1), (2, 1), (3, 1), (1, 2), (2, 3), (2, 4), (3, 5), (3, 6); +-- +ok +== +SELECT + title, + ARRAY_AGG ( + CASE WHEN first_name='Matt' and title='Team America' + THEN 'MATT DAAAMON' + ELSE first_name || ' ' || last_name END order by actor_id) actors +FROM films +JOIN film_actor USING (film_id) +JOIN actors USING (actor_id) +GROUP BY + title +ORDER BY + title; +-- +ok +== +select film_id, ARRAY_AGG(actor_id order by actor_id) FROM film_actor GROUP BY film_id ORDER BY ALL; +-- +ok +== diff --git a/parser/testdata/corpus/sql/types/nested/list/internal_issue_2457.test b/parser/testdata/corpus/sql/types/nested/list/internal_issue_2457.test new file mode 100644 index 0000000..5a56f4e --- /dev/null +++ b/parser/testdata/corpus/sql/types/nested/list/internal_issue_2457.test @@ -0,0 +1,29 @@ +# source: test/sql/types/nested/list/internal_issue_2457.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +CREATE OR REPLACE TABLE t1 (i INT, l INT[]); +-- +ok +== +INSERT INTO t1 VALUES (1, []), (2, []), (3, [1,2]), (4, []), (5, [1,2]); +-- +ok +== +SELECT i, l, row_number() OVER (PARTITION BY l ORDER BY i) as rid +FROM t1 +ORDER BY l, i +-- +ok +== +INSERT INTO t1 VALUES (6, NULL) +-- +ok +== +SELECT i, l, row_number() OVER (PARTITION BY l ORDER BY i) as rid +FROM t1 +ORDER BY l NULLS FIRST, i +-- +ok +== diff --git a/parser/testdata/corpus/sql/types/nested/list/list_aggr_parameter.test b/parser/testdata/corpus/sql/types/nested/list/list_aggr_parameter.test new file mode 100644 index 0000000..2a02cdb --- /dev/null +++ b/parser/testdata/corpus/sql/types/nested/list/list_aggr_parameter.test @@ -0,0 +1,37 @@ +# source: test/sql/types/nested/list/list_aggr_parameter.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +SELECT list_aggr(list(i), 'quantile', 0.5) FROM range(1, 11) tbl(i); +-- +ok +== +SELECT list_aggr(list(i), 'quantile', [0.25, 0.5, 0.75]) FROM range(1, 11) tbl(i); +-- +ok +== +SELECT list_aggr(list(i)::varchar[], 'string_agg', '|') FROM range(1, 4) tbl(i); +-- +ok +== +SELECT list_aggr([0, 1, 2, 3], 'arg_min', i) FROM range(1, 4) tbl(i); +-- +ok +== +SELECT list_aggr(list(i), 'quantile') FROM range(10) tbl(i); +-- +ok +== +SELECT list_aggr(list(i), 'min', 1) FROM range(10) tbl(i); +-- +ok +== +SELECT list_aggr(list(i), 'quantile', 0.5, 0.3, 0.5) FROM range(10) tbl(i); +-- +ok +== +SELECT list_aggr(list(i), 'quantile', i) FROM range(10) tbl(i); +-- +ok +== diff --git a/parser/testdata/corpus/sql/types/nested/list/list_aggregate_dict.test b/parser/testdata/corpus/sql/types/nested/list/list_aggregate_dict.test new file mode 100644 index 0000000..2e01d85 --- /dev/null +++ b/parser/testdata/corpus/sql/types/nested/list/list_aggregate_dict.test @@ -0,0 +1,29 @@ +# source: test/sql/types/nested/list/list_aggregate_dict.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +pragma force_compression='dictionary'; +-- +ok +== +CREATE TABLE Hosts (ips varchar[]); +-- +ok +== +INSERT INTO Hosts SELECT * FROM '{DATA_DIR}/csv/ips.csv.gz'; +-- +ok +== +SELECT min(list_string_agg(ips)) FROM Hosts +-- +ok +== +SELECT min(ips[1]) FROM Hosts +-- +ok +== +SELECT min([x[2:4] for x in ips if x[1]::int > 1]) FROM Hosts +-- +ok +== diff --git a/parser/testdata/corpus/sql/types/nested/list/list_aggregates.test b/parser/testdata/corpus/sql/types/nested/list/list_aggregates.test new file mode 100644 index 0000000..699b7a4 --- /dev/null +++ b/parser/testdata/corpus/sql/types/nested/list/list_aggregates.test @@ -0,0 +1,69 @@ +# source: test/sql/types/nested/list/list_aggregates.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +select min(i::varchar), max(i::varchar) from range(10) tbl(i); +-- +ok +== +select min(list_value(i)), max(list_value(i)) from range(10) tbl(i); +-- +ok +== +select min(list_value(-i)), max(list_value(i+2)) from range(10) tbl(i); +-- +ok +== +select min(i), max(i) from list_int; +-- +ok +== +select first([i]) from range(10) tbl(i); +-- +ok +== +select first([0]) from range(10) tbl(i); +-- +ok +== +select first(i) from range(10) tbl(i) WHERE i=-1; +-- +ok +== +select first(NULL::INT[]) from range(10) tbl(i) WHERE i=-1; +-- +ok +== +select i%3 a, first([i]) from range(10) tbl(i) group by a order by a; +-- +ok +== +select i%3 a, unnest(first([i])) from range(10) tbl(i) group by a order by a; +-- +ok +== +select string_agg(list_value(i)::varchar, ',') from range(10) tbl(i); +-- +ok +== +select i, i % 2, min(list_value(i)) over(partition by i % 2 order by i) from range(10) tbl(i) ORDER BY 1; +-- +ok +== +select i, i % 2, list(i) over(partition by i % 2 order by i) from range(10) tbl(i) ORDER BY 2, 1; +-- +ok +== +select i, i % 2, list(i) over(partition by i % 2 order by i rows between 1 preceding and 1 following) from range(10) tbl(i) ORDER BY 2, 1; +-- +ok +== +PREPARE rebind_stmt AS SELECT list(list_value({'foo': [?]})); +-- +ok +== +EXECUTE rebind_stmt(10); +-- +ok +== diff --git a/parser/testdata/corpus/sql/types/nested/list/list_subquery.test b/parser/testdata/corpus/sql/types/nested/list/list_subquery.test new file mode 100644 index 0000000..4112b2c --- /dev/null +++ b/parser/testdata/corpus/sql/types/nested/list/list_subquery.test @@ -0,0 +1,29 @@ +# source: test/sql/types/nested/list/list_subquery.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +SELECT (SELECT [1, 2]) +-- +ok +== +SELECT UNNEST((SELECT [1, 2])) +-- +ok +== +SELECT (SELECT [[1, 2], [3, 4]]) +-- +ok +== +SELECT (SELECT {'a': [1, 2, 3], 'b': 7}) +-- +ok +== +SELECT (SELECT LIST_VALUE()) +-- +ok +== +SELECT (SELECT CASE WHEN 1=0 THEN LIST_VALUE() ELSE NULL END) +-- +ok +== diff --git a/parser/testdata/corpus/sql/types/nested/list/test_list_extract.test b/parser/testdata/corpus/sql/types/nested/list/test_list_extract.test new file mode 100644 index 0000000..360d852 --- /dev/null +++ b/parser/testdata/corpus/sql/types/nested/list/test_list_extract.test @@ -0,0 +1,205 @@ +# source: test/sql/types/nested/list/test_list_extract.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +SELECT LIST_EXTRACT(NULL, 1) +-- +ok +== +SELECT LIST_EXTRACT(42, 1) +-- +ok +== +SELECT LIST_EXTRACT(LIST_VALUE(), 1) +-- +ok +== +SELECT LIST_EXTRACT(LIST_VALUE(NULL), 1) +-- +ok +== +SELECT LIST_EXTRACT(LIST_VALUE(NULL), -1) +-- +ok +== +SELECT LIST_EXTRACT(LIST_VALUE(42), NULL) +-- +ok +== +SELECT LIST_EXTRACT(LIST_VALUE(42), 1) +-- +ok +== +SELECT LIST_ELEMENT(LIST_VALUE(42), 1) +-- +ok +== +SELECT LIST_EXTRACT(LIST_VALUE(42, 43), 2) +-- +ok +== +SELECT LIST_EXTRACT(LIST_VALUE(42, 43, 44, 45), -1) +-- +ok +== +SELECT LIST_EXTRACT(LIST_VALUE(42, 43, 44, 45), -2) +-- +ok +== +SELECT LIST_EXTRACT(LIST_VALUE(42, 43, 44, 45), -4) +-- +ok +== +SELECT LIST_EXTRACT(LIST_VALUE(42, 43, 44, 45), -5) +-- +ok +== +SELECT ([{ t:'abc', len:5 }][1]).t, ([{ t:'abc', len:5 }][1]).len +-- +ok +== +SELECT [{ t:'abc', len:5 }][1]=1 +-- +ok +== +SELECT ([{ parent: { t:'abc', len:5 } }][1]).parent.len +-- +ok +== +SELECT [{ parent: { t:'abc', len:5 } }][1]=1 +-- +ok +== +SELECT ([{ parent: { child: { t:'abc' } }, n: 42 }][1]).parent.child.t +-- +ok +== +SELECT [{ parent: { child: { t:'abc' } }, n: 42 }][1]=1 +-- +ok +== +SELECT LIST_EXTRACT(LIST_VALUE(42), 2) +-- +ok +== +SELECT LIST_EXTRACT(LIST_VALUE('Hello', 'World'), 1) +-- +ok +== +SELECT LIST_EXTRACT(LIST_VALUE('Hello', 'World'), 2) +-- +ok +== +SELECT LIST_EXTRACT(LIST_VALUE(42::UTINYINT), 1) +-- +ok +== +SELECT LIST_EXTRACT(LIST_VALUE(42::TINYINT), 1) +-- +ok +== +SELECT LIST_EXTRACT(LIST_VALUE(42::USMALLINT), 1) +-- +ok +== +SELECT LIST_EXTRACT(LIST_VALUE(42::SMALLINT), 1) +-- +ok +== +SELECT LIST_EXTRACT(LIST_VALUE(42::UINTEGER), 1) +-- +ok +== +SELECT LIST_EXTRACT(LIST_VALUE(42::INTEGER), 1) +-- +ok +== +SELECT LIST_EXTRACT(LIST_VALUE(42::UBIGINT), 1) +-- +ok +== +SELECT LIST_EXTRACT(LIST_VALUE(42::BIGINT), 1) +-- +ok +== +SELECT LIST_EXTRACT(LIST_VALUE(42::HUGEINT), 1) +-- +ok +== +SELECT LIST_EXTRACT(LIST_VALUE(42::UHUGEINT), 1) +-- +ok +== +SELECT LIST_EXTRACT(LIST_VALUE(42::FLOAT), 1) +-- +ok +== +SELECT LIST_EXTRACT(LIST_VALUE(42::DOUBLE), 1) +-- +ok +== +SELECT LIST_EXTRACT(LIST_VALUE('2019-11-26'::DATE), 1) +-- +ok +== +SELECT LIST_EXTRACT(LIST_VALUE('21:42:00'::TIME), 1) +-- +ok +== +SELECT LIST_EXTRACT(LIST_VALUE('2019-11-26 09:42:00'::TIMESTAMP), 1) +-- +ok +== +SELECT list_extract('1', 9223372036854775807); +-- +ok +== +SELECT list_extract('1', -9223372036854775808); +-- +ok +== +SELECT list_extract('1', 0); +-- +ok +== +SELECT list_extract('1', 1); +-- +ok +== +SELECT list_extract([1, 2, 3], -9223372036854775808); +-- +ok +== +CREATE TABLE list_array_table(a int[3][]); +-- +ok +== +INSERT INTO list_array_table VALUES ([[1,2,3], NULL, [4,5,6]]); +-- +ok +== +SELECT list_extract(a, 1) FROM list_array_table; +-- +ok +== +SELECT list_extract(a, 2) FROM list_array_table; +-- +ok +== +SELECT list_extract(a, 3) FROM list_array_table; +-- +ok +== +SELECT list_extract(a, 4) FROM list_array_table; +-- +ok +== +SELECT list_extract(a, -1) FROM list_array_table; +-- +ok +== +SELECT list_extract(a, 0) FROM list_array_table; +-- +ok +== diff --git a/parser/testdata/corpus/sql/types/nested/list/test_list_functions_with_null_structs.test b/parser/testdata/corpus/sql/types/nested/list/test_list_functions_with_null_structs.test new file mode 100644 index 0000000..bd8d171 --- /dev/null +++ b/parser/testdata/corpus/sql/types/nested/list/test_list_functions_with_null_structs.test @@ -0,0 +1,129 @@ +# source: test/sql/types/nested/list/test_list_functions_with_null_structs.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +CREATE TABLE struct_data(str STRUCT(val VARCHAR)[]); +-- +ok +== +INSERT INTO struct_data VALUES (NULL); +-- +ok +== +SELECT list_resize(str, 1) FROM struct_data; +-- +ok +== +SELECT list_reduce(str, lambda a, b: a) FROM struct_data; +-- +ok +== +SELECT str[1] FROM struct_data; +-- +ok +== +SELECT list_aggregate(str, 'count') FROM struct_data; +-- +ok +== +SELECT {f}(str) FROM struct_data; +-- +error: Parser Error: syntax error at or near "}" +== +CREATE TABLE nested_struct_data(str STRUCT(str_nested STRUCT(val VARCHAR))[]); +-- +ok +== +INSERT INTO nested_struct_data VALUES ([NULL]); +-- +ok +== +SELECT list_transform(str, lambda x: x) FROM nested_struct_data; +-- +ok +== +SELECT list_filter(str, lambda x: x.str_nested IS NULL) FROM nested_struct_data; +-- +ok +== +CREATE TABLE struct_data_two_lists(str STRUCT(val VARCHAR)[][]); +-- +ok +== +INSERT INTO struct_data_two_lists VALUES (NULL); +-- +ok +== +SELECT flatten(str) FROM struct_data_two_lists; +-- +ok +== +CREATE TABLE many_structs_data(str1 STRUCT(val VARCHAR, str2 STRUCT(val INT[]))[]); +-- +ok +== +INSERT INTO many_structs_data VALUES (NULL), ([{'val': 'hello', 'str2': NULL}, (NULL, NULL), {'val': 'world', 'str2': {'val': [1, 2]}}]); +-- +ok +== +SELECT list_reduce(str1, lambda a, b: a) FROM many_structs_data; +-- +ok +== +WITH foo AS ( + SELECT str.reduce(lambda a, b: a) AS str FROM struct_data +) +SELECT str, str.val, str.val = '', str.val IS NULL, str IS NULL FROM foo; +-- +ok +== +CREATE TABLE filter_data(foo text[]); +-- +ok +== +INSERT INTO filter_data VALUES + (['some value']), + (['some value', 'other value']), + (['some value', 'other value', 'some value']), + (['some value', 'other value', 'some value', 'other value']), + (['some value', 'other value', 'some value', 'other value', 'some value']), + (['some value', 'other value', 'some value', 'other value', 'some value', 'other value']), + (['some value', 'other value', 'some value', 'other value', 'some value', 'other value', 'some value']); +-- +ok +== +WITH transformed AS ( + SELECT foo.list_transform( + lambda x: struct_pack(val := x, conflict := false) + ).reduce( + lambda res, x: CASE + WHEN res.conflict THEN res + WHEN res.val = x.val THEN res + ELSE struct_pack(val := null, conflict := true) + END + ) AS result + FROM filter_data + ) +SELECT result, result.val = '' FROM transformed; +-- +ok +== +WITH data_(foo) AS (VALUES (null::text[]), (['a', 'b', 'c']) + ), transformed AS ( + SELECT + foo.list_transform( + lambda x: struct_pack(val := x, conflict := false) + ).reduce( + lambda res, x: CASE + WHEN res.conflict THEN res + WHEN res.val = x.val THEN res + ELSE struct_pack(val := null, conflict := true) + END + ) AS result + FROM data_ + ) +SELECT result, result.val = '' FROM transformed; +-- +ok +== diff --git a/parser/testdata/corpus/sql/types/nested/list/test_list_index.test b/parser/testdata/corpus/sql/types/nested/list/test_list_index.test new file mode 100644 index 0000000..1482a78 --- /dev/null +++ b/parser/testdata/corpus/sql/types/nested/list/test_list_index.test @@ -0,0 +1,73 @@ +# source: test/sql/types/nested/list/test_list_index.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +SELECT a[1] FROM (VALUES (LIST_VALUE())) tbl(a) +-- +ok +== +SELECT a[1] FROM (VALUES (LIST_VALUE(NULL))) tbl(a) +-- +ok +== +SELECT a[-1] FROM (VALUES (LIST_VALUE(NULL))) tbl(a) +-- +ok +== +SELECT a[NULL] FROM (VALUES (LIST_VALUE(42))) tbl(a) +-- +ok +== +SELECT a[1] FROM (VALUES (LIST_VALUE(42))) tbl(a) +-- +ok +== +SELECT a[1+1-1] FROM (VALUES (LIST_VALUE(42))) tbl(a) +-- +ok +== +SELECT a[b] FROM (VALUES (LIST_VALUE(42), 1)) tbl(a, b) +-- +ok +== +SELECT (LIST_VALUE(42))[1] +-- +ok +== +SELECT LIST_VALUE(42)[1] +-- +ok +== +SELECT a[2:] FROM (VALUES (LIST_VALUE(42, 43, 44))) tbl(a) +-- +ok +== +SELECT a[1:] FROM (VALUES (LIST_VALUE(42, 43, 44))) tbl(a) +-- +ok +== +SELECT a[:1] FROM (VALUES (LIST_VALUE(42, 43, 44))) tbl(a) +-- +ok +== +SELECT a[0:1] FROM (VALUES (LIST_VALUE(42, 43, 44))) tbl(a) +-- +ok +== +SELECT a[0:-1] FROM (VALUES (LIST_VALUE(42, 43, 44))) tbl(a) +-- +ok +== +SELECT a[-3:-1] FROM (VALUES (LIST_VALUE(42, 43, 44))) tbl(a) +-- +ok +== +SELECT a[-5:] FROM (VALUES (LIST_VALUE(42, 43, 44))) tbl(a) +-- +ok +== +SELECT a[:5] FROM (VALUES (LIST_VALUE(42, 43, 44))) tbl(a) +-- +ok +== diff --git a/parser/testdata/corpus/sql/types/nested/list/test_list_slice.test b/parser/testdata/corpus/sql/types/nested/list/test_list_slice.test new file mode 100644 index 0000000..a328e61 --- /dev/null +++ b/parser/testdata/corpus/sql/types/nested/list/test_list_slice.test @@ -0,0 +1,178 @@ +# source: test/sql/types/nested/list/test_list_slice.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +CREATE TABLE listdata ( + c0 char(1), + c1 char(1), + c2 char(1), + c3 char(1), + c4 char(1), + off integer, + length integer) +-- +ok +== +INSERT INTO listdata VALUES + ('h', 'e', 'l', 'l', 'o', 1, 2), + ('w', 'o', 'r', 'l', 'd', 2, 3), + ('b', NULL, NULL, NULL, NULL, 0, 1), + (NULL, NULL, NULL, NULL, NULL, 0, 2); +-- +ok +== +CREATE VIEW lists AS + SELECT CASE + WHEN c0 = 'b' THEN LIST_VALUE(c0) + WHEN c0 IS NULL THEN NULL + ELSE LIST_VALUE(c0, c1, c2, c3, c4) + END AS s, + off, length FROM listdata; +-- +ok +== +SELECT s from lists +-- +ok +== +CREATE TABLE duckdata(c0 char(1), c1 char(1), c2 char(1)); +-- +ok +== +INSERT INTO duckdata VALUES ('🦆', 'a', 'b'), ('a', 'b', 'c') +-- +ok +== +CREATE VIEW ducks AS SELECT LIST_VALUE(c0, c1, c2) AS d from duckdata; +-- +ok +== +CREATE VIEW hello AS SELECT s AS hello FROM lists WHERE off = 1 AND length = 2 +-- +ok +== +CREATE VIEW nulltable as SELECT s as n FROM lists WHERE off = 0 AND length = 2 +-- +ok +== +SELECT d from ducks +-- +ok +== +SELECT d[0:0] FROM ducks +-- +ok +== +SELECT s[1:2] FROM lists +-- +ok +== +SELECT s[1:3] FROM lists +-- +ok +== +SELECT s[off:length+off] FROM lists +-- +ok +== +SELECT s[off:2+off] FROM lists +-- +ok +== +SELECT s[0:length] FROM lists +-- +ok +== +SELECT hello[off:length+off] FROM lists, hello +-- +ok +== +SELECT n[off:length+off] FROM lists, nulltable +-- +ok +== +SELECT hello[NULL:length+NULL] FROM lists, hello +-- +ok +== +SELECT hello[:length] FROM lists, hello +-- +ok +== +SELECT hello[off:NULL+off] FROM lists, hello +-- +ok +== +SELECT n[NULL:length+NULL] FROM lists, nulltable +-- +ok +== +SELECT hello[NULL:NULL+NULL] FROM lists, hello +-- +ok +== +SELECT n[off:NULL+off] FROM lists, nulltable +-- +ok +== +SELECT n[NULL:NULL+NULL] FROM lists, nulltable +-- +ok +== +SELECT n[:] FROM lists, nulltable +-- +ok +== +SELECT s[-2:] FROM lists +-- +ok +== +SELECT s[0:1] FROM lists +-- +ok +== +SELECT s[-4:-2] FROM lists +-- +ok +== +SELECT s[1:1] FROM lists +-- +ok +== +SELECT s[1:] FROM lists +-- +ok +== +SELECT s[2:] FROM lists +-- +ok +== +SELECT s[(2147483647-1):1] FROM lists +-- +ok +== +SELECT s[(2147483647-1):-1] FROM lists +-- +ok +== +SELECT s[(-2147483646-1):-1] FROM lists +-- +ok +== +SELECT s[(-2147483646-1):-2147483647] FROM lists +-- +ok +== +SELECT ARRAY_POP_BACK(s) FROM lists; +-- +ok +== +SELECT ARRAY_POP_FRONT(s) FROM lists; +-- +ok +== +SELECT (1)[1:2]; +-- +ok +== diff --git a/parser/testdata/corpus/sql/types/nested/list/test_list_slice_negative_step.test b/parser/testdata/corpus/sql/types/nested/list/test_list_slice_negative_step.test new file mode 100644 index 0000000..99e29f6 --- /dev/null +++ b/parser/testdata/corpus/sql/types/nested/list/test_list_slice_negative_step.test @@ -0,0 +1,75 @@ +# source: test/sql/types/nested/list/test_list_slice_negative_step.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +SELECT list_slice([1,2,3,4,5], 1, 3, -1); +-- +ok +== +SELECT list_slice([1,2,3,4,5], 1, 3, -2); +-- +ok +== +SELECT ([1,2,3])[1:-:-1]; +-- +ok +== +SELECT ([1,2,3])[:3:-1]; +-- +ok +== +SELECT ([1,2,3,4,5])[:-:-1]; +-- +ok +== +SELECT ([1,2,3,4,5])[:-:-2]; +-- +ok +== +CREATE TABLE tbl (a INT[], start int, stop int, step int); +-- +ok +== +INSERT INTO tbl VALUES ([1,2,3,4,5], 1, 3, -2); +-- +ok +== +INSERT INTO tbl VALUES ([1,4,5,6,7,8], 3, 1, -2); +-- +ok +== +INSERT INTO tbl VALUES ([1,2,3,4,5], -4, -1, -2); +-- +ok +== +INSERT INTO tbl VALUES ([1,2,3,4,5], 1, 3, -1); +-- +ok +== +SELECT a[start:stop:step] FROM tbl; +-- +ok +== +select a[:stop:step] from tbl; +-- +ok +== +select a[start:-:step] from tbl; +-- +ok +== +SELECT + arr, + list_concat(arr[1:-:2], arr) +FROM (SELECT [1,2,3,4,5]) AS _(arr); +-- +ok +== +SELECT + arr, + list_concat(arr[1:-:2], arr) +FROM (SELECT a FROM tbl) AS _(arr); +-- +ok +== diff --git a/parser/testdata/corpus/sql/types/nested/list/test_list_slice_numeric_limits.test b/parser/testdata/corpus/sql/types/nested/list/test_list_slice_numeric_limits.test new file mode 100644 index 0000000..41b6cde --- /dev/null +++ b/parser/testdata/corpus/sql/types/nested/list/test_list_slice_numeric_limits.test @@ -0,0 +1,77 @@ +# source: test/sql/types/nested/list/test_list_slice_numeric_limits.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +SELECT ([1,2,3,4,5,6])[-9223372036854775808:5]; +-- +ok +== +SELECT ([1,2,3,4,5,6])[-9223372036854775808:5:2]; +-- +ok +== +SELECT ([1,2,3,4,5,6])[1:9223372036854775807]; +-- +ok +== +SELECT ([1,2,3,4,5,6])[1:9223372036854775807:2]; +-- +ok +== +SELECT ([1,2,3,4,5,6])[9223372036854775807:9223372036854775807]; +-- +ok +== +SELECT ([1,2,3,4,5,6])[9223372036854775807:-9223372036854775808]; +-- +ok +== +SELECT ([1,2,3,4,5,6])[9223372036854775807:-9223372036854775808:-1]; +-- +ok +== +SELECT ([1,2,3,4,5,6])[-9223372036854775808 + 1:5]; +-- +ok +== +CREATE TABLE tbl (a INT[], start bigint, stop bigint, step bigint); +-- +ok +== +INSERT INTO tbl VALUES ([1,2,3,4,5], -9223372036854775808, 9223372036854775807, -1); +-- +ok +== +INSERT INTO tbl VALUES ([1,2,3,4,5], -9223372036854775808 + 1, 9223372036854775807 - 1, -1); +-- +ok +== +SELECT a[-9223372036854775808:9223372036854775807:step] FROM tbl; +-- +ok +== +create table tbl (a int[], start bigint, stop bigint, step bigint); +-- +ok +== +INSERT INTO tbl VALUES ([1,2,3,4,5], 1, 5, 9223372036854775807); +-- +ok +== +INSERT INTO tbl VALUES ([1,2,3,4,5], 1, 5, -9223372036854775808); +-- +ok +== +SELECT ([1,2,3,4,5])[-9223372036854775808 + 1:9223372036854775807 - 1:-1]; +-- +ok +== +SELECT ([1,2,3,4,5])[1:5:9223372036854775807]; +-- +ok +== +SELECT ([1,2,3,4,5])[1:5:-9223372036854775808]; +-- +ok +== diff --git a/parser/testdata/corpus/sql/types/nested/list/test_list_slice_step.test b/parser/testdata/corpus/sql/types/nested/list/test_list_slice_step.test new file mode 100644 index 0000000..19f1f31 --- /dev/null +++ b/parser/testdata/corpus/sql/types/nested/list/test_list_slice_step.test @@ -0,0 +1,221 @@ +# source: test/sql/types/nested/list/test_list_slice_step.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +SELECT ([1,2,3,4,5,6])[-10:-10]; +-- +ok +== +SELECT ([])[1:3:2]; +-- +ok +== +SELECT ([1,2,3,4,5,6])[5:3:2]; +-- +ok +== +SELECT ([1,2,3,4,5,6])[5:3]; +-- +ok +== +SELECT ([1,2,3,4,5])[1:-:2]; +-- +ok +== +SELECT 'abcdefg'[1:3]; +-- +ok +== +SELECT 'abcdefg'[:3]; +-- +ok +== +SELECT list_slice([1,2,3,4,5], 1, 3, 1); +-- +ok +== +SELECT ([])[1:3]; +-- +ok +== +SELECT ([1,2,3,4,5])[-1:3]; +-- +ok +== +SELECT ([1,2,3,4,5])[1:-3]; +-- +ok +== +SELECT ([1,2,3,4,5])[6:8]; +-- +ok +== +SELECT ([1,2,3,4,5])[1:10]; +-- +ok +== +SELECT ([1,2,3,4,5])[:3]; +-- +ok +== +SELECT ([1,2,3,4,5])[1:]; +-- +ok +== +SELECT ([1,2,3,4,5])[:]; +-- +ok +== +SELECT ([1,2,3,4,5])[NULL:3]; +-- +ok +== +SELECT ([1,2,3,4,5])[1:3:2]; +-- +ok +== +SELECT ([1,2,3,4,5])[1:3:3]; +-- +ok +== +SELECT ([1,2,3,4,5,6])[1:5:2]; +-- +ok +== +SELECT ([1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,17])[1:17:20]; +-- +ok +== +SELECT ([1,2,3,4,5])[-4:-1:2]; +-- +ok +== +INSERT INTO tbl VALUES ([1,2,3,4,5], 1, 3, 2); +-- +ok +== +INSERT INTO tbl VALUES ([1,4,5,6,7,8], 1, 3, 2); +-- +ok +== +INSERT INTO tbl VALUES ([1,2,3,4,5], -4, -1, 2); +-- +ok +== +INSERT INTO tbl VALUES ([1,2,3,4,5], 1, 3, 1); +-- +ok +== +select a[:-:step] from tbl; +-- +ok +== +SELECT '12345'[1:3:2]; +-- +ok +== +SELECT ([1,2,3,4,5])[1:3:0]; +-- +ok +== +CREATE TABLE err(a INT[], start int, stop int, step int); +-- +ok +== +INSERT INTO err VALUES ([1,2,3,4,5], 1, 3, 0); +-- +ok +== +INSERT INTO err VALUES ([1,4,5,6,7,8], 1, 3, 0); +-- +ok +== +SELECT a[start:stop:step] from err; +-- +ok +== +SELECT list_slice(NULL, 1, 3, 2); +-- +ok +== +SELECT list_slice(NULL, 0, 0); +-- +ok +== +SELECT list_slice(NULL, 1, 3, -1); +-- +ok +== +SELECT ([1,2,3,4,5])[1:3:NULL]; +-- +ok +== +SELECT ([1,2,3,4,5])[1:NULL:2]; +-- +ok +== +SELECT ([1,2,3,4,5])[NULL:3:2]; +-- +ok +== +CREATE TABLE null_tbl (a INT[], start int, stop int, step int); +-- +ok +== +INSERT INTO null_tbl VALUES ([1,2,3,4,5], NULL, 3, 2); +-- +ok +== +INSERT INTO null_tbl VALUES ([1,4,5,6,7,8], 1, NULL, 2); +-- +ok +== +INSERT INTO null_tbl VALUES ([1,2,3,4,5], -4, -1, NULL); +-- +ok +== +INSERT INTO null_tbl VALUES (NULL, 1, 3, 2); +-- +ok +== +INSERT INTO null_tbl VALUES ([1,2,NULL], 1, 3, 2); +-- +ok +== +INSERT INTO null_tbl VALUES ([], 1, 3, 2); +-- +ok +== +SELECT a[start:stop:step] FROM null_tbl; +-- +ok +== +SELECT ([1,2,3,4,5])[1:[NULL]:2]; +-- +ok +== +SELECT ([1,2,3,4,5])[[NULL]:3:2]; +-- +ok +== +SELECT ([1,2,3,4,5])[1:'a':2]; +-- +ok +== +SELECT ([1,2,3,4,5])['a':3:2]; +-- +ok +== +SELECT ([1,2,3,4,5])[1:[]:2]; +-- +ok +== +SELECT ([1,2,3,4,5])[1:list_slice([1,2,3,4,5], 2, 3):2]; +-- +ok +== +SELECT ([1,2,3,4,5])[1:[1]:2]; +-- +ok +== diff --git a/parser/testdata/corpus/sql/types/nested/list/test_nested_list.test b/parser/testdata/corpus/sql/types/nested/list/test_nested_list.test new file mode 100644 index 0000000..4ff7123 --- /dev/null +++ b/parser/testdata/corpus/sql/types/nested/list/test_nested_list.test @@ -0,0 +1,185 @@ +# source: test/sql/types/nested/list/test_nested_list.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +SELECT [{'i': 1,'j': [2, 3]}, NULL, {'i': 1, 'j': [2, 3]}]; +-- +ok +== +CREATE TABLE list_data (g INTEGER, e INTEGER) +-- +ok +== +INSERT INTO list_data VALUES (1, 1), (1, 2), (2, 3), (2, 4), (2, 5), (3, 6), (5, NULL) +-- +ok +== +SELECT LIST(a) l1 FROM (VALUES (1), (2), (3)) AS t1 (a) +-- +ok +== +SELECT UNNEST(l1) FROM (SELECT LIST(a) l1 FROM (VALUES (1), (2), (3)) AS t1 (a)) t1 +-- +ok +== +SELECT * FROM (SELECT LIST(a) l1 FROM (VALUES (1), (2), (3)) AS t1 (a)) t1, (SELECT LIST(b) l2 FROM (VALUES (4), (5), (6), (7)) AS t2 (b)) t2 +-- +ok +== +SELECT UNNEST(l1) u1, UNNEST(l2) u2 FROM (SELECT LIST(a) l1 FROM (VALUES (1), (2), (3)) AS t1 (a)) t1, (SELECT LIST(b) l2 FROM (VALUES (4), (5), (6), (7)) AS t2 (b)) t2 +-- +ok +== +SELECT UNNEST(l1), l2 FROM (SELECT LIST(a) l1 FROM (VALUES (1), (2), (3)) AS t1 (a)) t1, (SELECT LIST(b) l2 FROM (VALUES (4), (5), (6), (7)) AS t2 (b)) t2 +-- +ok +== +SELECT l1, UNNEST(l2) FROM (SELECT LIST(a) l1 FROM (VALUES (1), (2), (3)) AS t1 (a)) t1, (SELECT LIST(b) l2 FROM (VALUES (4), (5), (6), (7)) AS t2 (b)) t2 +-- +ok +== +SELECT UNNEST(LIST(e)) ue, LIST(g) from list_data ORDER BY 1 NULLS LAST +-- +ok +== +SELECT g, LIST(e) from list_data GROUP BY g ORDER BY g +-- +ok +== +SELECT g, LIST(e) l1, LIST(e) l2 from list_data GROUP BY g ORDER BY g +-- +ok +== +SELECT g, LIST(e/2.0) from list_data GROUP BY g order by g +-- +ok +== +SELECT g, LIST(CAST(e AS VARCHAR)) from list_data GROUP BY g order by g +-- +ok +== +SELECT LIST(e) from list_data +-- +ok +== +SELECT UNNEST(LIST(e)) ue from list_data ORDER BY ue +-- +ok +== +SELECT LIST(e), LIST(g) from list_data +-- +ok +== +SELECT LIST(42) +-- +ok +== +SELECT LIST(42) FROM list_data +-- +ok +== +SELECT UNNEST(LIST(42)) +-- +ok +== +SELECT UNLIST(LIST(42)) +-- +ok +== +SELECT UNNEST(LIST(e)) ue, UNNEST(LIST(g)) ug from list_data ORDER BY ue +-- +ok +== +SELECT g, UNNEST(LIST(e)) ue, UNNEST(LIST(e+1)) ue2 from list_data GROUP BY g ORDER BY ue +-- +ok +== +SELECT g, UNNEST(l) u FROM (SELECT g, LIST(e) l FROM list_data GROUP BY g) u1 ORDER BY u +-- +ok +== +SELECT g, UNNEST(l)+1 u FROM (SELECT g, LIST(e) l FROM list_data GROUP BY g) u1 ORDER BY u +-- +ok +== +SELECT g, STRUCT_PACK(a := g, b := le) sl FROM (SELECT g, LIST(e) le from list_data GROUP BY g) xx WHERE g < 3 ORDER BY g +-- +ok +== +SELECT LIST(STRUCT_PACK(a := g, b := le)) mind_blown FROM (SELECT g, LIST(e) le from list_data GROUP BY g ORDER BY g) xx +-- +ok +== +SELECT g, LIST(STRUCT_PACK(a := e, b := e+1)) ls from list_data GROUP BY g ORDER BY g +-- +ok +== +SELECT g, LIST(STRUCT_PACK(a := e, b := e+1)) ls from list_data WHERE g > 2 GROUP BY g ORDER BY g +-- +ok +== +SELECT g2, LIST(le) FROM (SELECT g % 2 g2, LIST(e) le from list_data GROUP BY g ORDER BY g) sq GROUP BY g2 ORDER BY g2 +-- +ok +== +SELECT SUM(ue) FROM (SELECT UNNEST(le) ue FROM (SELECT g, LIST(e) le from list_data GROUP BY g ORDER BY g) xx) xy +-- +ok +== +SELECT SUM(UNNEST(le)) FROM ( SELECT g, LIST(e) le from list_data GROUP BY g ORDER BY g) xx +-- +ok +== +SELECT LIST(LIST(42)) +-- +ok +== +SELECT UNNEST(UNNEST(LIST(42)) +-- +error: Parser Error: syntax error at or near ")" +== +SELECT LIST() +-- +ok +== +SELECT LIST() FROM list_data +-- +ok +== +SELECT LIST(e, g) FROM list_data +-- +ok +== +SELECT g, UNNEST(l+1) u FROM (SELECT g, LIST(e) l FROM list_data GROUP BY g) u1 +-- +ok +== +SELECT g, UNNEST(g) u FROM (SELECT g, LIST(e) l FROM list_data GROUP BY g) u1 +-- +ok +== +SELECT g, UNNEST() u FROM (SELECT g, LIST(e) l FROM list_data GROUP BY g) u1 +-- +ok +== +SELECT UNNEST(42) +-- +ok +== +SELECT UNNEST() +-- +ok +== +SELECT UNNEST(42) from list_data +-- +ok +== +SELECT UNNEST() from list_data +-- +ok +== +SELECT g FROM (SELECT g, LIST(e) l FROM list_data GROUP BY g) u1 where UNNEST(l) > 42 +-- +ok +== diff --git a/parser/testdata/corpus/sql/types/nested/list/test_scalar_list.test b/parser/testdata/corpus/sql/types/nested/list/test_scalar_list.test new file mode 100644 index 0000000..a76daf0 --- /dev/null +++ b/parser/testdata/corpus/sql/types/nested/list/test_scalar_list.test @@ -0,0 +1,89 @@ +# source: test/sql/types/nested/list/test_scalar_list.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +SELECT LIST_VALUE('hello') +-- +ok +== +SELECT LIST_VALUE('hello')::VARCHAR +-- +ok +== +SELECT l::VARChAR FROM (VALUES (LIST_VALUE('hello', 'world')), (LIST_VALUE('a', 'b', 'c'))) t(l) +-- +ok +== +SELECT LIST_VALUE(1, 2, 3, '4') a, LIST_VALUE('a','b','c') b, LIST_VALUE(42, NULL) c, LIST_VALUE(NULL, NULL, NULL) d, LIST_VALUE() e +-- +ok +== +SELECT a FROM (VALUES (LIST_VALUE(1, 2, 3, 4)), (LIST_VALUE()), (LIST_VALUE(NULL::INTEGER)), (LIST_VALUE(42))) lv(a) +-- +ok +== +SELECT a FROM (VALUES (LIST_VALUE('hello', 'world')), (LIST_VALUE()), (LIST_VALUE(NULL::VARCHAR)), (LIST_VALUE('42'))) lv(a) +-- +ok +== +SELECT * FROM (VALUES ((LIST_VALUE()), (LIST_VALUE(NULL)), LIST_VALUE(1, 2))) lv(a) +-- +ok +== +SELECT * FROM (VALUES (LIST_VALUE(1, 2)), (LIST_VALUE()), (LIST_VALUE(NULL::INTEGER))) lv(a) +-- +ok +== +SELECT LIST_VALUE(1, 2, 3) UNION ALL SELECT LIST_VALUE(NULL::INTEGER) UNION ALL SELECT LIST_VALUE() UNION ALL SELECT NULL +-- +ok +== +SELECT NULL UNION ALL SELECT LIST_VALUE() UNION ALL SELECT LIST_VALUE(NULL::INTEGER) UNION ALL SELECT LIST_VALUE(1, 2, 3) +-- +ok +== +SELECT UNNEST(a) ua FROM (VALUES (LIST_VALUE(1, 2, 3, 4)), (LIST_VALUE()), (LIST_VALUE(NULL::INTEGER)), (LIST_VALUE(42))) lv(a) +-- +ok +== +SELECT UNNEST(a) ua FROM (VALUES (LIST_VALUE()), (LIST_VALUE(1, 2, 3, 4)), (LIST_VALUE(NULL)), (LIST_VALUE(42))) lv(a); +-- +ok +== +SELECT * FROM (VALUES (LIST_VALUE(1, 2)), (LIST_VALUE()), (LIST_VALUE('a'))) lv(a) +-- +ok +== +SELECT CAST(LIST_VALUE(42) AS INTEGER) +-- +ok +== +SELECT LIST_VALUE(42) + 4 +-- +ok +== +SELECT LIST_VALUE(42, '84') +-- +ok +== +SELECT CAST(UNNEST(LIST_VALUE(42))+2 AS INTEGER) +-- +ok +== +SELECT LIST_VALUE(g, e, 42, NULL) FROM list_data WHERE g > 2 +-- +ok +== +SELECT CASE WHEN g = 2 THEN LIST_VALUE(g, e, 42) ELSE LIST_VALUE(84, NULL) END FROM list_data WHERE g > 1 UNION ALL SELECT LIST_VALUE(NULL::INTEGER) +-- +ok +== +SELECT CASE WHEN g = 2 THEN LIST_VALUE(g, e, 42)::VARCHAR[] ELSE LIST_VALUE('eeek') END FROM list_data WHERE g > 1 +-- +ok +== +select * from (values ([1, NULL, 3]), ([NULL, 2, 3]), ([1, 2, NULL]), (NULL), ([1, 2, 3])) tbl(i); +-- +ok +== diff --git a/parser/testdata/corpus/sql/types/nested/map/map_error.test b/parser/testdata/corpus/sql/types/nested/map/map_error.test new file mode 100644 index 0000000..d679eda --- /dev/null +++ b/parser/testdata/corpus/sql/types/nested/map/map_error.test @@ -0,0 +1,89 @@ +# source: test/sql/types/nested/map/map_error.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +SELECT MAP(list_value(NULL, NULL, NULL, NULL, NULL), list_value(10, 9, 10, 11, 13)) +-- +ok +== +SELECT MAP(list_value(1, NULL, 3), list_value(6, 5, 4)) +-- +ok +== +SELECT MAP(list_value(1, 2, 3, 4, 1), list_value(10, 9, 8, 7, 6)) +-- +ok +== +SELECT MAP(NULL) +-- +ok +== +SELECT MAP 'a' +-- +ok +== +CREATE TABLE tbl (a INTEGER[], b TEXT[]) +-- +ok +== +INSERT INTO tbl VALUES (ARRAY[7, 5, 7], ARRAY['a', 'b', 'c']) +-- +ok +== +SELECT MAP(a, b) FROM tbl; +-- +ok +== +SELECT MAP(list_value(10), list_value()) +-- +ok +== +SELECT MAP(10, 12) +-- +ok +== +SELECT MAP(list_value(10), list_value(10), list_value(10)) +-- +ok +== +SELECT MAP(list_value(10), 10) +-- +ok +== +SELECT MAP(list_value(10, 20), list_value(10)) +-- +ok +== +CREATE TABLE t AS SELECT MAP(list_value(1, 2, 3), list_value(10, 9, 10)) AS m; +-- +ok +== +SELECT struct_extract(m, 'key') FROM t; +-- +ok +== +CREATE TABLE null_keys_list (k INT[], v INT[]); +-- +ok +== +INSERT INTO null_keys_list VALUES ([1], [2]), (NULL, [4]); +-- +ok +== +SELECT MAP(k, v) FROM null_keys_list; +-- +ok +== +CREATE TABLE null_values_list (k INT[], v INT[]); +-- +ok +== +INSERT INTO null_values_list VALUES ([1], [2]), ([4], NULL); +-- +ok +== +SELECT MAP(k, v) FROM null_values_list; +-- +ok +== diff --git a/parser/testdata/corpus/sql/types/nested/map/map_from_entries/column.test b/parser/testdata/corpus/sql/types/nested/map/map_from_entries/column.test new file mode 100644 index 0000000..21407ac --- /dev/null +++ b/parser/testdata/corpus/sql/types/nested/map/map_from_entries/column.test @@ -0,0 +1,29 @@ +# source: test/sql/types/nested/map/map_from_entries/column.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +CREATE TABLE t1 (list STRUCT(a INT, b VARCHAR)[]); +-- +ok +== +INSERT INTO t1 VALUES (ARRAY[(1, 'x'), (2, 'y'), (4, 's')]); +-- +ok +== +INSERT INTO t1 VALUES (ARRAY[(2, 'a'), (3,'b')]) +-- +ok +== +INSERT INTO t1 VALUES (ARRAY[(6, 'h'), (7,'g')]) +-- +ok +== +SELECT MAP_FROM_ENTRIES(list) FROM t1; +-- +ok +== +INSERT INTO t1 VALUES (NULL) +-- +ok +== diff --git a/parser/testdata/corpus/sql/types/nested/map/map_from_entries/column_null_entry.test b/parser/testdata/corpus/sql/types/nested/map/map_from_entries/column_null_entry.test new file mode 100644 index 0000000..ab60892 --- /dev/null +++ b/parser/testdata/corpus/sql/types/nested/map/map_from_entries/column_null_entry.test @@ -0,0 +1,13 @@ +# source: test/sql/types/nested/map/map_from_entries/column_null_entry.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +INSERT INTO t1 VALUES (ARRAY[(10, NULL), (7,'g')]) +-- +ok +== +INSERT INTO t1 VALUES (ARRAY[NULL, NULL]) +-- +ok +== diff --git a/parser/testdata/corpus/sql/types/nested/map/map_from_entries/data_types.test b/parser/testdata/corpus/sql/types/nested/map/map_from_entries/data_types.test new file mode 100644 index 0000000..cb5b718 --- /dev/null +++ b/parser/testdata/corpus/sql/types/nested/map/map_from_entries/data_types.test @@ -0,0 +1,261 @@ +# source: test/sql/types/nested/map/map_from_entries/data_types.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +create table string_key as select MAP_FROM_ENTRIES(ARRAY[('a', 'x'), ('b', 'y')]) col; +-- +ok +== +select * from string_key; +-- +ok +== +select col['a'] from string_key; +-- +ok +== +create table string_key_dup as select MAP_FROM_ENTRIES(ARRAY[('a', 'x'), ('a', 'y')]) col; +-- +ok +== +create table tinyint_key as select MAP_FROM_ENTRIES(ARRAY[(123::TINYINT, 'x'), (-123::TINYINT, 'y')]) col; +-- +ok +== +select * from tinyint_key; +-- +ok +== +select col[123] from tinyint_key; +-- +ok +== +create table tinyint_key_dup as select MAP_FROM_ENTRIES(ARRAY[(123, 'x'), (123, 'y')]) col; +-- +ok +== +create table smallint_key as select MAP_FROM_ENTRIES(ARRAY[(123::SMALLINT, 'x'), (-123::SMALLINT, 'y')]) col; +-- +ok +== +select * from smallint_key; +-- +ok +== +select col[123] from smallint_key; +-- +ok +== +create table smallint_key_dup as select MAP_FROM_ENTRIES(ARRAY[(123, 'x'), (123, 'y')]) col; +-- +ok +== +create table integer_key as select MAP_FROM_ENTRIES(ARRAY[(123::INTEGER, 'x'), (-123::INTEGER, 'y')]) col; +-- +ok +== +select * from integer_key; +-- +ok +== +select col[123] from integer_key; +-- +ok +== +create table integer_key_dup as select MAP_FROM_ENTRIES(ARRAY[(123, 'x'), (123, 'y')]) col; +-- +ok +== +create table bigint_key as select MAP_FROM_ENTRIES(ARRAY[(123::BIGINT, 'x'), (-123::BIGINT, 'y')]) col; +-- +ok +== +select * from bigint_key; +-- +ok +== +select col[123] from bigint_key; +-- +ok +== +create table bigint_key_dup as select MAP_FROM_ENTRIES(ARRAY[(123, 'x'), (123, 'y')]) col; +-- +ok +== +create table hugeint_key as select MAP_FROM_ENTRIES(ARRAY[(123::HUGEINT, 'x'), (-123::HUGEINT, 'y')]) col; +-- +ok +== +select * from hugeint_key; +-- +ok +== +select col[123] from hugeint_key; +-- +ok +== +create table hugeint_key as select MAP_FROM_ENTRIES(ARRAY[(123, 'x'), (123, 'y')]) col; +-- +ok +== +create table boolean_key as select MAP_FROM_ENTRIES(ARRAY[(True, 'x'), (False, 'y')]) col; +-- +ok +== +select * from boolean_key; +-- +ok +== +select col[True] from boolean_key; +-- +ok +== +create table boolean_key_dup as select MAP_FROM_ENTRIES(ARRAY[(True, 'x'), (True, 'y')]) col; +-- +ok +== +create table blob_key as select MAP_FROM_ENTRIES(ARRAY[('\xF0\x9F\xA6\x86'::BLOB, 'x'), ('\xF0\x9F\xA6\x87'::BLOB, 'y')]) col; +-- +ok +== +select * from blob_key; +-- +ok +== +select col['\xF0\x9F\xA6\x86'::BLOB] from blob_key; +-- +ok +== +create table blob_key_dup as select MAP_FROM_ENTRIES(ARRAY[('\xF0\x9F\xA6\x86'::BLOB, 'x'), ('\xF0\x9F\xA6\x86'::BLOB, 'y')]) col; +-- +ok +== +create table date_key as select MAP_FROM_ENTRIES(ARRAY[('1992-09-20'::DATE, 'x'), ('1992-12-20'::DATE, 'y')]) col; +-- +ok +== +select * from date_key; +-- +ok +== +select col['1992-09-20'::DATE] from date_key; +-- +ok +== +create table date_key_dup as select MAP_FROM_ENTRIES(ARRAY[('1992-09-20'::DATE, 'x'), ('1992-09-20'::DATE, 'y')]) col; +-- +ok +== +create table double_key as select MAP_FROM_ENTRIES(ARRAY[('12.3'::DOUBLE, 'x'), ('12.4'::DOUBLE, 'y')]) col; +-- +ok +== +select * from double_key; +-- +ok +== +select col['12.3'::DOUBLE] from double_key; +-- +ok +== +create table double_key_dup as select MAP_FROM_ENTRIES(ARRAY[('12.3'::DOUBLE, 'x'), ('12.3'::DOUBLE, 'y')]) col; +-- +ok +== +create table real_key as select MAP_FROM_ENTRIES(ARRAY[('12.3'::REAL, 'x'), ('12.4'::REAL, 'y')]) col; +-- +ok +== +select * from real_key; +-- +ok +== +select col['12.3'::REAL] from real_key; +-- +ok +== +create table real_key_dup as select MAP_FROM_ENTRIES(ARRAY[('12.3'::REAL, 'x'), ('12.3'::REAL, 'y')]) col; +-- +ok +== +create table decimal_key as select MAP_FROM_ENTRIES(ARRAY[('12.3'::DECIMAL, 'x'), ('12.4'::DECIMAL, 'y')]) col; +-- +ok +== +select * from decimal_key; +-- +ok +== +select col['12.3'::DECIMAL] from decimal_key; +-- +ok +== +create table decimal_key_dup as select MAP_FROM_ENTRIES(ARRAY[('12.3'::DECIMAL, 'x'), ('12.3'::DECIMAL, 'y')]) col; +-- +ok +== +create table interval_key as select MAP_FROM_ENTRIES(ARRAY[(('2022-01-02 01:00:00'::TIMESTAMP - '2022-01-01'::TIMESTAMP), 'x'), (('2022-01-02 01:00:00'::TIMESTAMP - '2021-01-01'::TIMESTAMP), 'y')]) col; +-- +ok +== +select * from interval_key; +-- +ok +== +select col[('2022-01-02 01:00:00'::TIMESTAMP - '2022-01-01'::TIMESTAMP)] from interval_key; +-- +ok +== +create table interval_key_dup as select MAP_FROM_ENTRIES(ARRAY[(('2022-01-02 01:00:00'::TIMESTAMP - '2022-01-01'::TIMESTAMP), 'x'), (('2022-01-02 01:00:00'::TIMESTAMP - '2022-01-01'::TIMESTAMP), 'y')]) col; +-- +ok +== +create table time_key as select MAP_FROM_ENTRIES(ARRAY[('12:30:00'::TIME, 'x'), ('00:30:00'::TIME, 'y')]) col; +-- +ok +== +select * from time_key; +-- +ok +== +select col['12:30:00'::TIME] from time_key; +-- +ok +== +create table time_key_dup as select MAP_FROM_ENTRIES(ARRAY[('12:30:00'::TIME, 'x'), ('12:30:00'::TIME, 'y')]) col; +-- +ok +== +create table timestamp_key as select MAP_FROM_ENTRIES(ARRAY[('1992-09-20 11:30:00'::TIMESTAMP, 'x'), ('1992-10-20 11:30:00'::TIMESTAMP, 'y')]) col; +-- +ok +== +select * from timestamp_key; +-- +ok +== +select col['1992-09-20 11:30:00'::TIMESTAMP] from timestamp_key; +-- +ok +== +create table timestamp_key_dup as select MAP_FROM_ENTRIES(ARRAY[('1992-09-20 11:30:00'::TIMESTAMP, 'x'), ('1992-09-20 11:30:00'::TIMESTAMP, 'y')]) col; +-- +ok +== +create table uuid_key as select MAP_FROM_ENTRIES(ARRAY[('eeccb8c5-9943-b2bb-bb5e-222f4e14b687'::UUID, 'x'), ('eeccb8c5-9943-b2bb-bb5e-222f4e14b600'::UUID, 'y')]) col; +-- +ok +== +select * from uuid_key; +-- +ok +== +select col['eeccb8c5-9943-b2bb-bb5e-222f4e14b687'::UUID] from uuid_key; +-- +ok +== +create table uuid_key_dup as select MAP_FROM_ENTRIES(ARRAY[('eeccb8c5-9943-b2bb-bb5e-222f4e14b687'::UUID, 'x'), ('eeccb8c5-9943-b2bb-bb5e-222f4e14b687'::UUID, 'y')]) col; +-- +ok +== diff --git a/parser/testdata/corpus/sql/types/nested/map/map_from_entries/dictionary_vector.test b/parser/testdata/corpus/sql/types/nested/map/map_from_entries/dictionary_vector.test new file mode 100644 index 0000000..df2efda --- /dev/null +++ b/parser/testdata/corpus/sql/types/nested/map/map_from_entries/dictionary_vector.test @@ -0,0 +1,25 @@ +# source: test/sql/types/nested/map/map_from_entries/dictionary_vector.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +create table t1 as select + id, + [{'key': 0, 'value': id}] as entry +from range(1000) t(id) +-- +ok +== +create table t2 as + select 0 id +from range(5); +-- +ok +== +select + t1.id, + map_from_entries(entry) +from t1 join t2 using (id); +-- +ok +== diff --git a/parser/testdata/corpus/sql/types/nested/map/map_from_entries/empty.test b/parser/testdata/corpus/sql/types/nested/map/map_from_entries/empty.test new file mode 100644 index 0000000..9b2b75d --- /dev/null +++ b/parser/testdata/corpus/sql/types/nested/map/map_from_entries/empty.test @@ -0,0 +1,9 @@ +# source: test/sql/types/nested/map/map_from_entries/empty.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +SELECT map_from_entries(); +-- +ok +== diff --git a/parser/testdata/corpus/sql/types/nested/map/map_from_entries/invalid.test b/parser/testdata/corpus/sql/types/nested/map/map_from_entries/invalid.test new file mode 100644 index 0000000..d99e137 --- /dev/null +++ b/parser/testdata/corpus/sql/types/nested/map/map_from_entries/invalid.test @@ -0,0 +1,29 @@ +# source: test/sql/types/nested/map/map_from_entries/invalid.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +SELECT map_from_entries(ARRAY[(1,2), (3,4)], ARRAY[(5,6), (7,8)]); +-- +ok +== +SELECT map_from_entries(5); +-- +ok +== +SELECT map_from_entries(ARRAY[5,4,3]); +-- +ok +== +select MAP_FROM_ENTRIES(ARRAY[(1, 'x', 'extra'), (2, 'y', 'extra')]); +-- +ok +== +SELECT MAP_FROM_ENTRIES(ARRAY[(1, 'x'), (2, 'y', 'extra')]); +-- +ok +== +SELECT MAP_FROM_ENTRIES(ARRAY[(NULL, 2), ([3,4], 4)]); +-- +ok +== diff --git a/parser/testdata/corpus/sql/types/nested/map/map_from_entries/nested.test b/parser/testdata/corpus/sql/types/nested/map/map_from_entries/nested.test new file mode 100644 index 0000000..689098e --- /dev/null +++ b/parser/testdata/corpus/sql/types/nested/map/map_from_entries/nested.test @@ -0,0 +1,37 @@ +# source: test/sql/types/nested/map/map_from_entries/nested.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +SELECT MAP_FROM_ENTRIES(ARRAY[([1,2], 2), ([3,4], 4)]); +-- +ok +== +SELECT MAP_FROM_ENTRIES(ARRAY[([1,2], 2), ([1,2], 4)]); +-- +ok +== +SELECT MAP_FROM_ENTRIES(ARRAY[({'a':5, 'b':7}, 2), ({'a':3, 'b':8}, 4)]); +-- +ok +== +SELECT MAP_FROM_ENTRIES(ARRAY[({'a':5, 'b':7}, 2), ({'a':5, 'b':7}, 4)]); +-- +ok +== +SELECT MAP_FROM_ENTRIES(ARRAY[(MAP([5,3,4], ['a', 'b', 'c']), 2), (MAP([4,3,5], ['a', 'b', 'c']), 4)]); +-- +ok +== +SELECT MAP_FROM_ENTRIES(ARRAY[(MAP([5,3,4], ['a', 'b', 'c']), 2), (MAP([5,3,4], ['a', 'b', 'c']), 4)]); +-- +ok +== +SELECT MAP_FROM_ENTRIES(ARRAY[([{'a':5, 'b':7}, {'a':5, 'b':7}], 2), ([{'a':5, 'b':7}, {'a':5, 'b':8}], 4)]); +-- +ok +== +SELECT MAP_FROM_ENTRIES(ARRAY[([{'a':5, 'b':7}, {'a':5, 'b':8}], 2), ([{'a':5, 'b':7}, {'a':5, 'b':8}], 4)]); +-- +ok +== diff --git a/parser/testdata/corpus/sql/types/nested/map/map_from_entries/null.test b/parser/testdata/corpus/sql/types/nested/map/map_from_entries/null.test new file mode 100644 index 0000000..6ca357f --- /dev/null +++ b/parser/testdata/corpus/sql/types/nested/map/map_from_entries/null.test @@ -0,0 +1,34 @@ +# source: test/sql/types/nested/map/map_from_entries/null.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +SELECT MAP_FROM_ENTRIES(NULL); +-- +ok +== +CREATE TABLE tbl ( + input STRUCT(a INTEGER, b INTEGER)[] +); +INSERT INTO tbl VALUES(NULL); +INSERT INTO tbl VALUES(NULL); +INSERT INTO tbl VALUES(NULL); +-- +ok +== +SELECT input FROM tbl; +-- +ok +== +SELECT MAP_FROM_ENTRIES(input) FROM tbl; +-- +ok +== +INSERT INTO tbl VALUES ([(5,3), (6,4), (7,3)]) +-- +ok +== +INSERT INTO tbl VALUES (NULL) +-- +ok +== diff --git a/parser/testdata/corpus/sql/types/nested/map/map_from_entries/null_entry.test b/parser/testdata/corpus/sql/types/nested/map/map_from_entries/null_entry.test new file mode 100644 index 0000000..7113622 --- /dev/null +++ b/parser/testdata/corpus/sql/types/nested/map/map_from_entries/null_entry.test @@ -0,0 +1,27 @@ +# source: test/sql/types/nested/map/map_from_entries/null_entry.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +SELECT MAP_FROM_ENTRIES(ARRAY[NULL, (1, 'x'), NULL, (2, 'y')]); +-- +ok +== +SELECT MAP_FROM_ENTRIES(ARRAY[(1, 'x'), (NULL, 'z'), (2, 'y')]); +-- +ok +== +CREATE TABLE tbl ( + input STRUCT(a INTEGER, b INTEGER)[] +); +INSERT INTO tbl VALUES(NULL); +INSERT INTO tbl VALUES([(5,3), (6,4), (7,3)]); +INSERT INTO tbl VALUES([(5,3), (6,4), (7,3)]); +INSERT INTO tbl VALUES([]); +-- +ok +== +SELECT MAP_FROM_ENTRIES(input) FROM tbl +-- +ok +== diff --git a/parser/testdata/corpus/sql/types/nested/map/test_map.test b/parser/testdata/corpus/sql/types/nested/map/test_map.test new file mode 100644 index 0000000..31c28ae --- /dev/null +++ b/parser/testdata/corpus/sql/types/nested/map/test_map.test @@ -0,0 +1,41 @@ +# source: test/sql/types/nested/map/test_map.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +SELECT MAP(list_value(1, 2, 3), list_value(10, 9, 8)) +-- +ok +== +SELECT MAP(list_value({'i':1,'j':2}, {'i':3,'j':4}), list_value({'i':1,'j':2}, {'i':3,'j':4})) +-- +ok +== +SELECT MAP(list_value(1, 2, 3), list_value(6, NULL, 4)) +-- +ok +== +SELECT MAP(list_value(1, 2, 3, 4), list_value(10, 9, 8, 7)) +-- +ok +== +SELECT MAP(list_value(), list_value()) +-- +ok +== +SELECT MAP() +-- +ok +== +INSERT INTO tbl VALUES (ARRAY[5, 7], ARRAY['test', 'string']), (ARRAY[6, 3], ARRAY['foo', 'bar']) +-- +ok +== +INSERT INTO tbl VALUES (ARRAY[5, 7], ARRAY['also_test', 'also_string']) +-- +ok +== +SELECT MAP(list_value([1], [2], [3], [4]), list_value(10, 9, 8, 7)) +-- +ok +== diff --git a/parser/testdata/corpus/sql/types/nested/map/test_map_and_lambdas.test b/parser/testdata/corpus/sql/types/nested/map/test_map_and_lambdas.test new file mode 100644 index 0000000..62bf55e --- /dev/null +++ b/parser/testdata/corpus/sql/types/nested/map/test_map_and_lambdas.test @@ -0,0 +1,13 @@ +# source: test/sql/types/nested/map/test_map_and_lambdas.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +CREATE TABLE i AS SELECT str_split('my yay', ' ') AS l, range AS i FROM range(3); +-- +ok +== +SELECT list_transform(l, lambda x: {'map1': MAP {x::VARCHAR:1::VARCHAR, 'b'::VARCHAR: x::VARCHAR}}) FROM i; +-- +ok +== diff --git a/parser/testdata/corpus/sql/types/nested/map/test_map_cardinality.test b/parser/testdata/corpus/sql/types/nested/map/test_map_cardinality.test new file mode 100644 index 0000000..914c4bd --- /dev/null +++ b/parser/testdata/corpus/sql/types/nested/map/test_map_cardinality.test @@ -0,0 +1,45 @@ +# source: test/sql/types/nested/map/test_map_cardinality.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +select cardinality(NULL) +-- +ok +== +select CARDINALITY(MAP(LIST_VALUE(1, 2, 3, 4),LIST_VALUE(10, 9, 8, 7))) +-- +ok +== +select CARDINALITY(MAP(LIST_VALUE(),LIST_VALUE())) +-- +ok +== +select CARDINALITY(MAP()) +-- +ok +== +create table ints (a integer, b integer) +-- +ok +== +insert into ints values (1,1),(5,2),(6,3),(2,2),(7,3),(3,3),(4,4) +-- +ok +== +select a, cardinality(m) from (select a,MAP(lsta,lstb) as m from (SELECT list(a) as lsta, list(b) as lstb, a FROM ints group by a) as lst_tbl) as T ORDER BY ALL +-- +ok +== +select a, cardinality(m) from (select a,MAP(lsta,lstb) as m from (SELECT list(a) as lsta, list(b) as lstb, a FROM ints where b < 3 group by a) as lst_tbl) as T ORDER BY ALL +-- +ok +== +select cardinality(m) from (select MAP(list_value(1), list_value(2)) from range(5) tbl(i)) tbl(m); +-- +ok +== +select grp, m, case when grp>1 then cardinality(m) else 0 end from (select grp, MAP(lsta,lstb) as m from (SELECT a%4 as grp, list(a) as lsta, list(a) as lstb FROM range(7) tbl(a) group by grp) as lst_tbl) as T; +-- +ok +== diff --git a/parser/testdata/corpus/sql/types/nested/map/test_map_concat.test b/parser/testdata/corpus/sql/types/nested/map/test_map_concat.test new file mode 100644 index 0000000..589690b --- /dev/null +++ b/parser/testdata/corpus/sql/types/nested/map/test_map_concat.test @@ -0,0 +1,149 @@ +# source: test/sql/types/nested/map/test_map_concat.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +select map_concat(map([3,4,5], ['a', 'b', 'c']), map([1], ['d'])); +-- +ok +== +select map_concat(map([3,4,5], ['a', 'b', 'c']), map([], [])); +-- +ok +== +select map_concat(map([], []), map([], [])) +-- +ok +== +select map_concat(map([], []), map([3,4,5], ['a', 'b', 'c'])); +-- +ok +== +select map_concat(map([], []), NULL); +-- +ok +== +select map_concat(NULL, NULL); +-- +ok +== +select map_concat(map([1], NULL), NULL) +-- +ok +== +select map_concat(map([1], [1]), NULL); +-- +ok +== +select map_concat( + map([3,4,5], ['a', 'b', 'c']), + map([3,4,5], ['a', 'b', 'c']), + map([3,4,5], ['a', 'b', 'd']) +); +-- +ok +== +select map_concat(); +-- +ok +== +select map_concat(map([], [])); +-- +ok +== +create table tbl( + x map(BIGINT, VARCHAR), + y map(BIGINT, VARCHAR), + z map(BIGINT, VARCHAR), +); +-- +ok +== +insert into tbl values +( + map([3,4,2], ['abc', 'over_twelve_characters', 'input']), + map([3,1,5,2], ['cba', 'a', 'b', 'c']), + map([3,7,6], ['1', NULL, '123']) +), +( + map([42, 1, 0], ['tiny', 'small', 'bigger']), + map([0, 42, 1], ['tiny', 'small', 'bigger']), + map([1], ['this is a long string']) +), +( + map([5, 1337, 0], ['long', 'longer', 'longest']), + map([], []), + NULL +), +( + NULL, NULL, NULL +); +-- +ok +== +select map_concat(x, y, z) from tbl; +-- +ok +== +select map_concat(x, y, z) from tbl where rowid != 0; +-- +ok +== +select map_concat(x, y, z) from tbl where rowid == 1; +-- +ok +== +create table tbl as select + map(lower_range, lower_range) as c1, + map(upper_range, upper_range) as c2 from ( + select + range(3000) as lower_range, + [i + 3000 for i in range(3000)] as upper_range + ) +-- +ok +== +select map_concat(c1, c2) from tbl; +-- +ok +== +select map(range(6000), range(6000)); +-- +ok +== +create table tbl as select + map([i], [i]) as c1, + map([i + 1], [i + 1]) as c2 from ( + select * from range(3000) tbl(i) + ) +-- +ok +== +select map(range(i, i+2), range(i, i+2)) from ( + select * from range(3000) tbl(i) +); +-- +ok +== +select map(c1, c1) as val from test_vector_types(NULL::VARCHAR[]) tbl(c1) where c1 != [] and c1 != [NULL] +-- +ok +== +select map_concat(val, val, val) from ( + select map(c1, c1) as val from test_vector_types(NULL::VARCHAR[]) tbl(c1) where c1 != [] and c1 != [NULL] +) +-- +ok +== +prepare q1 as select map_concat($1, $2, $3); +-- +ok +== +execute q1( + MAP([1,2,7], ['a', 'b', 'non_inlined_string']), + MAP([], []), + MAP([2,3,4,5], ['a', 'b', 'c', 'd']) +) +-- +ok +== diff --git a/parser/testdata/corpus/sql/types/nested/map/test_map_constant.test b/parser/testdata/corpus/sql/types/nested/map/test_map_constant.test new file mode 100644 index 0000000..a8f82b9 --- /dev/null +++ b/parser/testdata/corpus/sql/types/nested/map/test_map_constant.test @@ -0,0 +1,29 @@ +# source: test/sql/types/nested/map/test_map_constant.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +SELECT MAP {}; +-- +ok +== +SELECT MAP { 'hello': 'world', 'HELLO': 'WORLD' }; +-- +ok +== +SELECT MAP { 1: 'a', 2: 'b' }; +-- +ok +== +SELECT MAP { i: 'a' || i } FROM range(5) t(i); +-- +ok +== +SELECT MAP { [i]: [i + 1] } FROM range(5) t(i); +-- +ok +== +SELECT MAP { NULL: 'a' || i } FROM range(5) t(i); +-- +ok +== diff --git a/parser/testdata/corpus/sql/types/nested/map/test_map_contains.test b/parser/testdata/corpus/sql/types/nested/map/test_map_contains.test new file mode 100644 index 0000000..c68e34b --- /dev/null +++ b/parser/testdata/corpus/sql/types/nested/map/test_map_contains.test @@ -0,0 +1,77 @@ +# source: test/sql/types/nested/map/test_map_contains.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +SELECT map_contains_entry(map([1,2,3],[4,5,6]), 2, 5) AS res; +-- +ok +== +SELECT map_contains_value(map([1,2,3],[4,5,6]), 10) AS res; +-- +ok +== +SELECT map_contains(map([1,2,3],[4,5,6]), 1) AS res; +-- +ok +== +SELECT map_contains(map([1,2,3],[4,5,6]), 6) AS res; +-- +ok +== +SELECT map_contains_value(map([1,2,3],[4,5,6]), 4) AS res; +-- +ok +== +SELECT map_contains_value(map([1,2,3],[4,5,6]), 2) AS res; +-- +ok +== +SELECT map_contains_entry(map([],[]), 1, 2) AS res; +-- +ok +== +SELECT map_contains(map([],[]), 1) AS res; +-- +ok +== +SELECT map_contains_value(map([],[]), 1) AS res; +-- +ok +== +CREATE TABLE test_maps(m MAP(INT, INT), k INT, v INT, res_val BOOLEAN, res_key BOOLEAN); +-- +ok +== +INSERT INTO test_maps(m, k, v, res_key, res_val) VALUES +(map([1,2,3],[4,5,6]), 2, 5, true, true), +(map([7,8,9],[10,11,12]), 8, 11, true, true), +(map([13,14,15],[16,17,18]), 14, 17, true, true), +(map([19,20,21],[22,23,24]), 20, 23, true, true), +(map([25,26,27],[28,29,30]), 26, 29, true, true), +(map([1,2,3],[4,5,6]), 10, 7, false, false), +(map([7,8,9],[10,11,12]), 1, 13, false, false), +(map([13,14,15],[16,17,18]), 19, 20, false, false), +(map([19,20,21],[22,23,24]), 25, 26, false, false), +(map([25,26,27],[28,29,30]), 31, 32, false, false), +(map([1,2,3],[4,5,6]), 2, 7, true, false), +(map([7,8,9],[10,11,12]), 10, 11, false, true), +(map([13,14,15],[16,17,18]), 14, 20, true, false), +(map([19,20,21],[22,23,24]), 25, 23, false, true), +(map([25,26,27],[28,29,30]), 26, 31, true, false); +-- +ok +== +SELECT bool_and(map_contains(m, k) = res_key) = bool_and(map_contains_value(m, v) = res_val) +FROM test_maps; +-- +ok +== +SELECT 'my_key' IN map(['my_key'], ['my_value']) AS res; +-- +ok +== +SELECT 'my_keyz' IN map(['my_key'], ['my_value']) AS res; +-- +ok +== diff --git a/parser/testdata/corpus/sql/types/nested/map/test_map_entries.test b/parser/testdata/corpus/sql/types/nested/map/test_map_entries.test new file mode 100644 index 0000000..242bc51 --- /dev/null +++ b/parser/testdata/corpus/sql/types/nested/map/test_map_entries.test @@ -0,0 +1,54 @@ +# source: test/sql/types/nested/map/test_map_entries.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +select map_entries(MAP()) +-- +ok +== +SELECT map_entries(map_from_entries([('a', 5)])); +-- +ok +== +SELECT map_entries(map_from_entries([ + ('a', 5), ('b', 6), ('x', 21), ('abc', 0) +])); +-- +ok +== +SELECT map_entries(map([5], [NULL])) +-- +ok +== +SELECT map_entries(map_from_entries( + [ + ('a', 5), + ('b', 6), + ('x', 21), + ('abc', 0) + ] +)); +-- +ok +== +select MAP_ENTRIES(MAP([],[])) +-- +ok +== +select MAP_ENTRIES(MAP(NULL, NULL)) +-- +ok +== +select MAP_ENTRIES(NULL) +-- +ok +== +select MAP_ENTRIES(NULL::MAP("NULL", "NULL")) +-- +ok +== +select MAP_ENTRIES(NULL::MAP(INT, BIGINT)) +-- +ok +== diff --git a/parser/testdata/corpus/sql/types/nested/map/test_map_keys.test b/parser/testdata/corpus/sql/types/nested/map/test_map_keys.test new file mode 100644 index 0000000..da6f45d --- /dev/null +++ b/parser/testdata/corpus/sql/types/nested/map/test_map_keys.test @@ -0,0 +1,108 @@ +# source: test/sql/types/nested/map/test_map_keys.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +select map_keys(MAP([],[])); +-- +ok +== +select map_keys(MAP(['a'],[5])); +-- +ok +== +select map_keys(MAP(['a', 'b', 'c', 'd'], [5,1,8,3])) +-- +ok +== +select map_keys(NULL) +-- +ok +== +SELECT map_keys(MAP_FROM_ENTRIES(list)) FROM t1; +-- +ok +== +create table tbl ( + maps MAP(integer, text)[] +); +-- +ok +== +insert into tbl VALUES ( + [ + MAP([5,3,2],['a','c','b']), + MAP([1], [NULL]), + MAP([7,9,1,3,5,6], ['ab','c','d','ef','ba','he']) + ] +); +-- +ok +== +select list_apply(maps, lambda x: map_keys(x)) from tbl; +-- +ok +== +CREATE MACRO map_keys_macro(x) AS (map_keys(x)) +-- +ok +== +select map_keys_macro(map_from_entries(list)) from t1; +-- +ok +== +select maps, list_apply(maps, lambda x: list_sort(map_keys(x))) from tbl; +-- +ok +== +select maps, list_apply(maps, lambda x: map(list_sort(map_keys(x)), list_sort(map_values(x)))) from tbl; +-- +ok +== +create table filtered ( + col map(integer, integer), + idx integer +); +-- +ok +== +insert into filtered VALUES ( + map([7,4,9,1],[NULL,4,7,5]), + 0 +), ( + map([6,3,87,2],[0,NULL,5,NULL]), + 1 +), ( + map([7,4,9],[8,3,4]), + 2 +), ( + map([9,2,7,5,8,1],[NULL,NULL,4,5,6,7]), + 3 +); +-- +ok +== +select map_keys(col) from filtered where idx % 2 != 0; +-- +ok +== +select MAP_KEYS(MAP([],[])) +-- +ok +== +select MAP_KEYS(MAP(NULL, NULL)) +-- +ok +== +select MAP_KEYS(NULL) +-- +ok +== +select MAP_KEYS(NULL::MAP("NULL", "NULL")) +-- +ok +== +select MAP_KEYS(NULL::MAP(INT, BIGINT)) +-- +ok +== diff --git a/parser/testdata/corpus/sql/types/nested/map/test_map_nested_keys.test b/parser/testdata/corpus/sql/types/nested/map/test_map_nested_keys.test new file mode 100644 index 0000000..732ce44 --- /dev/null +++ b/parser/testdata/corpus/sql/types/nested/map/test_map_nested_keys.test @@ -0,0 +1,124 @@ +# source: test/sql/types/nested/map/test_map_nested_keys.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +SELECT MAP( + [ + [1],[2],[3] + ], + [ + 4,2,0 + ] +); +-- +ok +== +CREATE TABLE tbl(a INT[][], b VARCHAR[]); +-- +ok +== +INSERT INTO tbl VALUES([[2],[3],[4]], ['a', 'b', 'c']); +-- +ok +== +INSERT INTO tbl VALUES([[5],[6],[7]], ['d', 'e', 'f']); +-- +ok +== +INSERT INTO tbl VALUES([[8],[9],[10]], ['g', 'h', 'i']); +-- +ok +== +SELECT MAP(a, b) from tbl; +-- +ok +== +SELECT MAP( + [ + [1,2],[2,1],[3,1],[4,2],[4,2,0],[1,2] + ], + [ + NULL,NULL,NULL,NULL,NULL,NULL + ] +); +-- +ok +== +SELECT MAP( + [ + [1,2],[2,1],[3,1],[4,2],[4,2,0],NULL + ], + [ + NULL,NULL,NULL,NULL,NULL,NULL + ] +); +-- +ok +== +SELECT MAP( + [ + {'foo': True}, {'foo': False}, {'foo': NULL} + ], + [ + 4,2,0 + ] +); +-- +ok +== +SELECT MAP( + [ + {'foo': True}, {'foo': False}, {'foo': NULL}, {'foo': True} + ], + [ + 'n', 'o', 'p', 'e' + ] +); +-- +ok +== +SELECT MAP( + [ + {'foo': 0}, {'foo': 1}, NULL, {'foo': 2}, {'foo': 3} + ], + [ + 'e', 'r', 'r', 'o', 'r' + ] +); +-- +ok +== +SELECT MAP( + [ + MAP([5],[4]), MAP([10],[2]), MAP([2,3],[3,2]), MAP([10],[3]), MAP([3,2], [2,3]) + ], + [ + 0,1,2,3,4 + ] +); +-- +ok +== +SELECT MAP( + [ + MAP([5],[4]), MAP([10],[2]), MAP([2,3],[3,2]), MAP([10],[3]), MAP([3,2], [2,3]), MAP([5],[4]) + ], + [ + 0,1,2,3,4,5 + ] +); +-- +ok +== +SELECT MAP( + [ + MAP([5],[4]), MAP([10],[2]), MAP([2,3],[3,2]), NULL, MAP([3,2], [2,3]) + ], + [ + 0,1,2,3,4 + ] +); +-- +ok +== diff --git a/parser/testdata/corpus/sql/types/nested/map/test_map_subscript.test b/parser/testdata/corpus/sql/types/nested/map/test_map_subscript.test new file mode 100644 index 0000000..7871839 --- /dev/null +++ b/parser/testdata/corpus/sql/types/nested/map/test_map_subscript.test @@ -0,0 +1,191 @@ +# source: test/sql/types/nested/map/test_map_subscript.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +select m[1] from (select MAP(LIST_VALUE(1, 2, 3, 4),LIST_VALUE(10, 9, 8, 7)) as m) as T +-- +ok +== +select m[0] from (select MAP(LIST_VALUE(1, 2, 3, 4,5),LIST_VALUE(10, 9, 8, 7,11)) as m) as T +-- +ok +== +select m[NULL] from (select MAP(LIST_VALUE(1, 2, 3, 4,5, NULL),LIST_VALUE(10, 9, 8, 7,11,42)) as m) as T +-- +ok +== +select m[NULL] from (select MAP(LIST_VALUE(1, 2, 3, 4,5),LIST_VALUE(10, 9, 8, 7,11)) as m) as T +-- +ok +== +select m[2] from (select MAP(LIST_VALUE(1, 2, 3, 4,2),LIST_VALUE(10, 9, 8, 7,11)) as m) as T +-- +ok +== +select m[2] from (select MAP(LIST_VALUE(),LIST_VALUE()) as m) as T +-- +ok +== +select m[2] from (select MAP() as m) as T +-- +ok +== +select m[2::TINYINT] from (select MAP(LIST_VALUE(1, 2, 3, 4,5),LIST_VALUE(10, 9, 8, 7,11)) as m) as T +-- +ok +== +select m['Jon Lajoie'] from (select MAP(LIST_VALUE('Jon Lajoie', 'Backstreet Boys', 'Tenacious D','Jon Lajoie' ),LIST_VALUE(10,9,10,11)) as m) as T +-- +ok +== +select m['Spice Girls'] from (select MAP(LIST_VALUE('Jon Lajoie', 'Backstreet Boys', 'Tenacious D' ),LIST_VALUE(10,9,10)) as m) as T +-- +ok +== +select m[NULL] from (select MAP(LIST_VALUE('Jon Lajoie', 'Backstreet Boys', 'Tenacious D' ),LIST_VALUE(10,9,10)) as m) as T +-- +ok +== +select m['Tenacious D'] from (select MAP(LIST_VALUE('Jon Lajoie', 'Backstreet Boys', 'Tenacious D'),LIST_VALUE(10,9,1)) as m) as T +-- +ok +== +select m[0] from (select MAP(LIST_VALUE('Jon Lajoie', 'Backstreet Boys', 'Tenacious D' ),LIST_VALUE(10,9,10)) as m) as T +-- +ok +== +select map_extract(m,1) from (select MAP(LIST_VALUE(1, 2, 3, 4),LIST_VALUE(10, 9, 8, 7)) as m) as T +-- +ok +== +select map_extract(m,3) from (select MAP(LIST_VALUE(1, 2, 3, 4),LIST_VALUE(10, 9, 8, 7)) as m) as T +-- +ok +== +select m[3] from (select MAP(LIST_VALUE(1, 2, 3, 4),LIST_VALUE(10, 9, 8, 7)) as m) as T +-- +ok +== +select element_at(m,1) from (select MAP(LIST_VALUE(1, 2, 3, 4),LIST_VALUE(10, 9, 8, 7)) as m) as T +-- +ok +== +select element_at(m,3) from (select MAP(LIST_VALUE(1, 2, 3, 4),LIST_VALUE(10, 9, 8, 7)) as m) as T +-- +ok +== +select m[10] from (select MAP(lst,lst) as m from (SELECT LIST(i) as lst FROM range(10000) tbl(i)) as lst_tbl) as T +-- +ok +== +select m[1] from (select MAP(LIST_VALUE(1, 1, 1, 4),LIST_VALUE(10, 9, 8, 7)) as m) as T +-- +ok +== +select m[NULL] from (select MAP(LIST_VALUE('Jon Lajoie', NULL, 'Tenacious D',NULL,NULL ),LIST_VALUE(10,9,10,11,13)) as m) as T +-- +ok +== +select m['Jon Lajoie'] from (select MAP(LIST_VALUE('Jon Lajoie', 'Tenacious D'),LIST_VALUE(10,1)) as m) as T +-- +ok +== +select m[10] from (select MAP(LIST_VALUE(10,9,1,11,13),LIST_VALUE(NULL, NULL, NULL,NULL,NULL)) as m) as T +-- +ok +== +select m[NULL] from (select MAP(LIST_VALUE(NULL, NULL, NULL,NULL,NULL ),LIST_VALUE(10,9,10,11,13)) as m) as T +-- +ok +== +select m[NULL] from (select MAP(LIST_VALUE(NULL, NULL, NULL,NULL, NULL),LIST_VALUE(NULL, NULL, NULL,NULL,NULL )) as m) as T +-- +ok +== +insert into ints values (1,1), (2,2),(3,3),(4,4) +-- +ok +== +select m from (select MAP(lsta,lstb) as m from (SELECT list(a) as lsta, list(b) as lstb FROM ints where a < 4 and b > 1) as lst_tbl) as T +-- +ok +== +select m[2] from (select MAP(lsta,lstb) as m from (SELECT list(a) as lsta, list(b) as lstb FROM ints where a < 4 and b > 1) as lst_tbl) as T +-- +ok +== +insert into ints values (5,1), (1,2),(2,3),(6,4) +-- +ok +== +select m from (select MAP(lsta,lstb) as m from (SELECT list(a) as lsta, list(b) as lstb FROM ints group by b) as lst_tbl) as T ORDER BY ALL +-- +ok +== +select m[1] from (select MAP(lsta,lstb) as m from (SELECT list(a) as lsta, list(b) as lstb FROM ints group by b) as lst_tbl) as T ORDER BY ALL +-- +ok +== +insert into ints values (1,4) +-- +ok +== +select m[1] from (select MAP(lsta,lstb) as m from (SELECT list(a) as lsta, list(b) as lstb FROM ints where b <4 group by b) as lst_tbl) as T ORDER BY ALL +-- +ok +== +SELECT map_extract(MAP(LIST_VALUE(10,9,12,11,13),LIST_VALUE(10,9,10,11,13)),10) +-- +ok +== +select m[1] from (select MAP(list_value(1), list_value(2)) from range(5) tbl(i)) tbl(m); +-- +ok +== +select grp, m, case when grp>1 then m[0] else null end +from (select grp, MAP(lsta,lstb) as m +from (SELECT a%4 as grp, list(a) as lsta, list(a) as lstb FROM range(7) tbl(a) group by grp) as lst_tbl) as T; +-- +ok +== +select MAP_EXTRACT(MAP([],[]), NULL) +-- +ok +== +select MAP_EXTRACT(MAP(NULL, NULL), NULL) +-- +ok +== +select MAP_EXTRACT(NULL, NULL) +-- +ok +== +select MAP_EXTRACT(NULL::MAP("NULL", "NULL"), NULL) +-- +ok +== +select MAP_EXTRACT(NULL::MAP(INT, BIGINT), NULL) +-- +ok +== +select MAP_EXTRACT_VALUE(MAP([],[]), NULL) +-- +ok +== +select MAP_EXTRACT_VALUE(MAP(NULL, NULL), NULL) +-- +ok +== +select MAP_EXTRACT_VALUE(NULL, NULL) +-- +ok +== +select MAP_EXTRACT_VALUE(NULL::MAP("NULL", "NULL"), NULL) +-- +ok +== +select MAP_EXTRACT_VALUE(NULL::MAP(INT, BIGINT), NULL) +-- +ok +== diff --git a/parser/testdata/corpus/sql/types/nested/map/test_map_subscript_composite.test b/parser/testdata/corpus/sql/types/nested/map/test_map_subscript_composite.test new file mode 100644 index 0000000..6506ac7 --- /dev/null +++ b/parser/testdata/corpus/sql/types/nested/map/test_map_subscript_composite.test @@ -0,0 +1,113 @@ +# source: test/sql/types/nested/map/test_map_subscript_composite.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +select m[[2,0]] from (select MAP(LIST_VALUE([0], [1], [2,0], [3]),LIST_VALUE(10, 9, 8, 7)) as m) as T +-- +ok +== +select m[[2,3]] from (select MAP(LIST_VALUE([0], [1], [2,0], [3], [5]),LIST_VALUE(10, 9, 8, 7,11)) as m) as T +-- +ok +== +select m[NULL] from (select MAP(LIST_VALUE([2], [NULL], [3,0], [NULL,NULL],[5,4], NULL),LIST_VALUE(10, 9, 8, 7,11,42)) as m) as T +-- +ok +== +select m[NULL] from (select MAP(LIST_VALUE({a:3}, {a:4}, {a:5}, {a:6},{a:7}),LIST_VALUE(10, 9, 8, 7,11)) as m) as T +-- +ok +== +select m[2] from (select MAP(LIST_VALUE([2,2], [2], [3,3], [4,4,4],[2]),LIST_VALUE(10, 9, 8, 7,11)) as m) as T +-- +ok +== +select m[[2::TINYINT,3::BIGINT]] from (select MAP(LIST_VALUE([1], [2,3], [3], [2],[3,2]),LIST_VALUE(10, 9, 8, 7,11)) as m) as T +-- +ok +== +select m[[10,11]] from (select MAP(lst,lst) as m from (SELECT LIST([i,i+1]) as lst FROM range(10000) tbl(i)) as lst_tbl) as T +-- +ok +== +select m[[1]] from (select MAP(LIST_VALUE([1], [1], [1], [4]),LIST_VALUE(10, 9, 8, 7)) as m) as T +-- +ok +== +select m[['Tenacious D', 'test']] from (select MAP(LIST_VALUE(['Jon Lajoie'], ['test', NULL], ['Tenacious D', 'test'], ['test', 'Tenacious D']),LIST_VALUE(5,10,9,11)) as m) as T +-- +ok +== +select m[['Jon Lajoie']] from (select MAP(LIST_VALUE(['Jon Lajoie'], ['Tenacious D', 'a', 'b', 'c']),LIST_VALUE(10,1)) as m) as T +-- +ok +== +create table ints (a integer[], b integer[]) +-- +ok +== +insert into ints values ([1],[1]), ([2],[2]),([3],[3]),([4],[4]) +-- +ok +== +select m from (select MAP(lsta,lstb) as m from (SELECT list(a) as lsta, list(b) as lstb FROM ints where a[1] < 4 and b[1] > 1) as lst_tbl) as T +-- +ok +== +select m[[2]] from (select MAP(lsta,lstb) as m from (SELECT list(a) as lsta, list(b) as lstb FROM ints where a[1] < 4 and b[1] > 1) as lst_tbl) as T +-- +ok +== +insert into ints values ([5],[1]), ([1],[2]),([2],[3]),([6],[4]) +-- +ok +== +select m from (select MAP(lsta,lstb) as m from (SELECT list(a) as lsta, list(b) as lstb FROM ints group by b) as lst_tbl) as T +-- +ok +== +select m[[1]] from (select MAP(lsta,lstb) as m from (SELECT list(a) as lsta, list(b) as lstb FROM ints group by b) as lst_tbl) as T +-- +ok +== +insert into ints values ([1],[4]) +-- +ok +== +select m[[1]] from (select MAP(lsta,lstb) as m from (SELECT list(a) as lsta, list(b) as lstb FROM ints where b[1] <4 group by b) as lst_tbl) as T +-- +ok +== +SELECT map_extract(MAP(LIST_VALUE([10],[9],[12],[11],[13]),LIST_VALUE(10,9,10,11,13)),[10]) +-- +ok +== +select m[{a:1, b:2, c:3}] from (select MAP(list_value({a:1, b:2, c:3}), list_value(2)) from range(5) tbl(i)) tbl(m); +-- +ok +== +select grp, m, case when grp>1 then m[[0]] else null end +from (select grp, MAP(lsta,lstb) as m +from (SELECT a%4 as grp, list([a]) as lsta, list(a) as lstb FROM range(7) tbl(a) group by grp) as lst_tbl) as T; +-- +ok +== +select map([3, 2, 1], +[ + [ + [4], + [4] + ], + [ + [4,3] + ], + [ + [3,3,3], + [2], + [NULL, 3, 2] + ] +])[1] +-- +ok +== diff --git a/parser/testdata/corpus/sql/types/nested/map/test_map_subscript_from_column.test b/parser/testdata/corpus/sql/types/nested/map/test_map_subscript_from_column.test new file mode 100644 index 0000000..330fc5f --- /dev/null +++ b/parser/testdata/corpus/sql/types/nested/map/test_map_subscript_from_column.test @@ -0,0 +1,41 @@ +# source: test/sql/types/nested/map/test_map_subscript_from_column.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +create table t1 ( + id int, + k integer[], + v decimal[] +); +-- +ok +== +insert into t1 +SELECT * FROM (VALUES + (0, [1,2,3,4], [1.0, 2.0, 3.0, 4.0]), + (1, [5,6,7,8], [5.0, 6.0, 7.0, 8.0]), + (2, [9,10,11,12], [9.0, 10.0, 11.0, 12.0]), + (3, [13,14,15,16], [13.0, 14.0, 15.0, 16.0]), + (4, [17,18,19,20], [17.0, 18.0, 19.0, 20.0]), + (5, [21,22,23,24], [21.0, 22.0, 23.0, 24.0]), + (6, [25,26,27,28], [25.0, 26.0, 27.0, 28.0]), + (7, [29,30,31,32], [29.0, 30.0, 31.0, 32.0]), + (8, [33,34,35,36], [33.0, 34.0, 35.0, 36.0]), + (9, [37,38,39,40], [37.0, 38.0, 39.0, 40.0]) +) +-- +ok +== +create table t2 (id int, v_map map(integer, decimal), k integer[]); +-- +ok +== +insert into t2 select id, map(k,v), k from t1; +-- +ok +== +select v_map[array_sort(k, 'DESC', 'NULLS LAST')[1]] from t2 limit 10; +-- +ok +== diff --git a/parser/testdata/corpus/sql/types/nested/map/test_map_subscript_vector_types.test b/parser/testdata/corpus/sql/types/nested/map/test_map_subscript_vector_types.test new file mode 100644 index 0000000..e9281d5 --- /dev/null +++ b/parser/testdata/corpus/sql/types/nested/map/test_map_subscript_vector_types.test @@ -0,0 +1,67 @@ +# source: test/sql/types/nested/map/test_map_subscript_vector_types.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +SELECT true as equal +FROM test_vector_types(NULL::INT[]) t(c) +WHERE c IS NOT NULL; +-- +ok +== +SELECT map([c], [c])[c] IS NOT DISTINCT FROM c as equal +FROM test_vector_types(NULL::INT[]) t(c) +WHERE c IS NOT NULL; +-- +ok +== +SELECT filtered, last_element, pos, true +from +( + SELECT + list_distinct(c) as filtered, + filtered[-1] as last_element, + CASE + WHEN last_element IS NULL + THEN 0 + ELSE list_position(filtered, last_element) + END as pos, + CASE + WHEN last_element IS NULL + THEN [] + ELSE [list_position(filtered, last_element)] + END as expected_result, + FROM test_vector_types(NULL::INT[]) t(c) + WHERE c IS NOT NULL +); +-- +ok +== +SELECT + filtered, + last_element, + pos, + expected_result IS NOT DISTINCT FROM result as equal +from +( + SELECT + list_distinct(c) as filtered, + map(filtered, range(1, len(filtered)+1)) as mymap, + filtered[-1] as last_element, + CASE + WHEN last_element IS NULL + THEN 0 + ELSE list_position(filtered, last_element) + END as pos, + CASE + WHEN last_element IS NULL + THEN NULL + ELSE list_position(filtered, last_element) + END as expected_result, + mymap[last_element] as result, + FROM test_vector_types(NULL::INT[]) t(c) + WHERE c IS NOT NULL +); +-- +ok +== diff --git a/parser/testdata/corpus/sql/types/nested/map/test_map_subscript_where.test b/parser/testdata/corpus/sql/types/nested/map/test_map_subscript_where.test new file mode 100644 index 0000000..57e3e27 --- /dev/null +++ b/parser/testdata/corpus/sql/types/nested/map/test_map_subscript_where.test @@ -0,0 +1,38 @@ +# source: test/sql/types/nested/map/test_map_subscript_where.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +insert into t1 +SELECT * FROM (VALUES + (0, [1,2,3,4], [1.0, 2.0, 3.0, 4.0]), + (1, [5,6,7,8], [5.0, 6.0, 7.0, 8.0]), + (2, [9,10,11,12], [9.0, 10.0, 11.0, 12.0]), + (3, [13,14,15,16], [13.0, 14.0, 15.0, 16.0]), + (4, [17,18,19,20], [17.0, 18.0, 19.0, 20.0]), + (5, [21,22,23,24], [21.0, 22.0, 23.0, 24.0]), + (6, [25,26,27,28], [25.0, 26.0, 27.0, 28.0]), + (7, [29,30,31,32], [29.0, 30.0, 31.0, 32.0]), + (8, [33,34,35,36], [33.0, 34.0, 35.0, 36.0]), + (9, [37,38,39,40], [37.0, 38.0, 39.0, 40.0]) +) +-- +ok +== +select id, v_map[array_sort(k, 'DESC', 'NULLS LAST')[1]] from t2 where id > 3 limit 10; +-- +ok +== +CREATE table tbl (key INT, val VARCHAR); +-- +ok +== +INSERT INTO tbl VALUES (1,'duck'), (2,'DB'), (3,'duckDB'); +-- +ok +== +SELECT MAP([key], [val])[key] FROM tbl +WHERE key <> '2'; +-- +ok +== diff --git a/parser/testdata/corpus/sql/types/nested/map/test_map_values.test b/parser/testdata/corpus/sql/types/nested/map/test_map_values.test new file mode 100644 index 0000000..58c22fd --- /dev/null +++ b/parser/testdata/corpus/sql/types/nested/map/test_map_values.test @@ -0,0 +1,69 @@ +# source: test/sql/types/nested/map/test_map_values.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +select map_values(MAP([],[])); +-- +ok +== +select map_values(MAP(['a'],[5])); +-- +ok +== +select map_values(MAP(['a', 'b', 'c', 'd'], [5,1,8,3])) +-- +ok +== +select map_values(NULL) +-- +ok +== +select map_values(MAP(['a', 'b', 'c', 'd', 'e'], [NULL, 0, 1, NULL, 3])) +-- +ok +== +SELECT map_values(MAP_FROM_ENTRIES(list)) FROM t1; +-- +ok +== +select list_apply(maps, lambda x: map_values(x)) from tbl; +-- +ok +== +CREATE MACRO map_values_macro(x) AS (map_values(x)) +-- +ok +== +select map_values_macro(map_from_entries(list)) from t1; +-- +ok +== +select maps, list_apply(maps, lambda x: list_sort(map_values(x))) from tbl; +-- +ok +== +select map_values(col) from filtered where idx % 2 != 0; +-- +ok +== +select MAP_VALUES(MAP([],[])) +-- +ok +== +select MAP_VALUES(MAP(NULL, NULL)) +-- +ok +== +select MAP_VALUES(NULL) +-- +ok +== +select MAP_VALUES(NULL::MAP("NULL", "NULL")) +-- +ok +== +select MAP_VALUES(NULL::MAP(INT, BIGINT)) +-- +ok +== diff --git a/parser/testdata/corpus/sql/types/nested/map/test_map_vector_types.test b/parser/testdata/corpus/sql/types/nested/map/test_map_vector_types.test new file mode 100644 index 0000000..663e696 --- /dev/null +++ b/parser/testdata/corpus/sql/types/nested/map/test_map_vector_types.test @@ -0,0 +1,84 @@ +# source: test/sql/types/nested/map/test_map_vector_types.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +create macro input() as table + select * + from test_vector_types(NULL::INTEGER[]) t(i) where [x for x in i if x IS NOT NULL] != [] offset 3; +-- +ok +== +select true, true from input() +-- +ok +== +select map_keys(m) = input, map_values(m) = input from ( + select + map(input, input) m, + input + from input() t(input) +) m; +-- +ok +== +create table tbl ( + not_filtered bool, + keys INTEGER[], + vals VARCHAR[] +); +-- +ok +== +insert into tbl select + case when + i >= 500 + then + true + else + false + end as not_filtered, + [x for x in range(length)] keys, + ['a' || i + x for x in range(length)] vals + from ( + select 1 + (random() * 5)::BIGINT as length, i from range(1000) t(i) + ) +-- +ok +== +select + vals[1] as val, + keys[1] as key, + map(keys, vals)[key] as first_map_entry, + from tbl + where + not_filtered and first_map_entry != val; +-- +ok +== +create table data as from ( + values + ([1], [3]), + ([2], [9]), + ([3], [15]), + ([4], [21]), +) as t(l, r); +-- +ok +== +select l[1], r[1], map(l, r) from data where r[1] != 3; +-- +ok +== +select l[1], r[1], map(l, r) from data where r[1] != 9; +-- +ok +== +select l[1], r[1], map(l, r) from data where r[1] != 15; +-- +ok +== +select * from test_vector_types(NULL::MAP(varchar, int)) limit 1; +-- +ok +== diff --git a/parser/testdata/corpus/sql/types/nested/map/test_null_map_interaction.test b/parser/testdata/corpus/sql/types/nested/map/test_null_map_interaction.test new file mode 100644 index 0000000..4788e07 --- /dev/null +++ b/parser/testdata/corpus/sql/types/nested/map/test_null_map_interaction.test @@ -0,0 +1,45 @@ +# source: test/sql/types/nested/map/test_null_map_interaction.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +SELECT TYPEOF(MAP_KEYS(NULL::MAP(TEXT, BIGINT))); +-- +ok +== +SELECT TYPEOF(MAP_KEYS(NULL)); +-- +ok +== +SELECT TYPEOF(MAP_VALUES(NULL::MAP(TEXT, BIGINT))); +-- +ok +== +SELECT TYPEOF(MAP_VALUES(NULL)); +-- +ok +== +SELECT TYPEOF(MAP_ENTRIES(NULL::MAP(TEXT, BIGINT))); +-- +ok +== +SELECT TYPEOF(MAP_ENTRIES(NULL)); +-- +ok +== +SELECT TYPEOF(MAP_EXTRACT(NULL::MAP(TEXT, BIGINT), 'a')); +-- +ok +== +SELECT TYPEOF((NULL::MAP(TEXT, BIGINT))['a']); +-- +ok +== +SELECT TYPEOF(MAP_EXTRACT(NULL, 'a')); +-- +ok +== +SELECT TYPEOF(MAP_EXTRACT_VALUE(NULL, 'a')); +-- +ok +== diff --git a/parser/testdata/corpus/sql/types/nested/nested_nested_types.test b/parser/testdata/corpus/sql/types/nested/nested_nested_types.test new file mode 100644 index 0000000..2d8a817 --- /dev/null +++ b/parser/testdata/corpus/sql/types/nested/nested_nested_types.test @@ -0,0 +1,21 @@ +# source: test/sql/types/nested/nested_nested_types.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +SELECT [{'i':1,'j':[2,3]},NULL] +-- +ok +== +SELECT [{'i':1,'j':[2,3]},NULL, {'i':1,'j':[2,3]}] +-- +ok +== +SELECT * FROM (VALUES (MAP(LIST_VALUE(1,2),LIST_VALUE(3,4))), (NULL), (MAP(LIST_VALUE(1,2),LIST_VALUE(3,4))), (NULL)) as a +-- +ok +== +SELECT MAP(LIST_VALUE({'i':1,'j':2},{'i':3,'j':4}),LIST_VALUE({'i':1,'j':2},{'i':3,'j':4})) +-- +ok +== diff --git a/parser/testdata/corpus/sql/types/nested/struct/struct_aggregates.test b/parser/testdata/corpus/sql/types/nested/struct/struct_aggregates.test new file mode 100644 index 0000000..42b26d1 --- /dev/null +++ b/parser/testdata/corpus/sql/types/nested/struct/struct_aggregates.test @@ -0,0 +1,38 @@ +# source: test/sql/types/nested/struct/struct_aggregates.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +select min(struct_pack(i := i, j := i + 2)), max(struct_pack(i := i, j := i + 2)), first(struct_pack(i := i, j := i + 2)) from range(10) tbl(i); +-- +ok +== +select min(struct_pack(i := -i, j := -i - 2)), max(struct_pack(i := i + 2, j := i + 4)), first(struct_pack(i := i, j := i + 2)) from range(10) tbl(i); +-- +ok +== +select string_agg(struct_pack(i := i, j := i + 2)::VARCHAR, ',') from range(10) tbl(i); +-- +ok +== +CREATE VIEW struct_int AS +SELECT * FROM (VALUES + ({'x': 1, 'y': 0}), + ({'x': 1, 'y': 2}), + ({'x': 1, 'y': NULL}), + ({'x': NULL, 'y': 2}), + ({'x': NULL, 'y': NULL}), + ({'x': NULL, 'y': 0}), + (NULL) +) tbl(i); +-- +ok +== +select min(i), max(i), from struct_int; +-- +ok +== +select min(i), max(i), first(i) from struct_int; +-- +ok +== diff --git a/parser/testdata/corpus/sql/types/nested/struct/struct_aggregates_types.test b/parser/testdata/corpus/sql/types/nested/struct/struct_aggregates_types.test new file mode 100644 index 0000000..bc51dd1 --- /dev/null +++ b/parser/testdata/corpus/sql/types/nested/struct/struct_aggregates_types.test @@ -0,0 +1,53 @@ +# source: test/sql/types/nested/struct/struct_aggregates_types.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +CREATE TABLE structs AS SELECT {'i': i::{type}} AS s FROM range(11) tbl(i) +-- +error: Parser Error: syntax error at or near "{" +== +SELECT MIN(s), MAX(s) FROM structs +-- +ok +== +DROP TABLE structs +-- +ok +== +SELECT MIN(s)['i'], MAX(s)['i'] FROM structs +-- +ok +== +CREATE TABLE structs AS SELECT {'i': i%2} AS s FROM range(11) tbl(i) +-- +ok +== +CREATE TABLE structs AS SELECT {'i': interval (i+1) year} AS s FROM range(11) tbl(i) +-- +ok +== +CREATE TABLE structs AS SELECT {'i': i::varchar || 'thisisalongsuffix'} AS s FROM range(11) tbl(i) +-- +ok +== +CREATE TABLE structs AS SELECT {'i': 1} AS s FROM range(11) tbl(i) +-- +ok +== +CREATE TABLE structs AS SELECT {'i': NULL} AS s FROM range(11) tbl(i) +-- +ok +== +CREATE TABLE structs AS SELECT NULL::ROW(i INTEGER) AS s FROM range(11) tbl(i) +-- +ok +== +CREATE TABLE structs AS SELECT {'i': NULL::ROW(i INTEGER)} AS s FROM range(11) tbl(i) +-- +ok +== +CREATE TABLE structs AS SELECT [NULL::ROW(i INTEGER)] AS s FROM range(11) tbl(i) +-- +ok +== diff --git a/parser/testdata/corpus/sql/types/nested/struct/struct_dict.test b/parser/testdata/corpus/sql/types/nested/struct/struct_dict.test new file mode 100644 index 0000000..26123fb --- /dev/null +++ b/parser/testdata/corpus/sql/types/nested/struct/struct_dict.test @@ -0,0 +1,37 @@ +# source: test/sql/types/nested/struct/struct_dict.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +SELECT {'i': 1, 'j': 2}; +-- +ok +== +SELECT {'i': NULL, 'j': 2}; +-- +ok +== +SELECT {'i': [], 'j': 2}; +-- +ok +== +SELECT {'i': [1, 2, 3], 'j': 2}; +-- +ok +== +SELECT {i: r, j: 2} FROM range(3) tbl(r); +-- +ok +== +SELECT {'i': 3, 'i': 4} +-- +ok +== +SELECT {}; +-- +ok +== +SELECT {1:3}; +-- +error: Parser Error: syntax error at or near "1" +== diff --git a/parser/testdata/corpus/sql/types/nested/struct/struct_is_null.test b/parser/testdata/corpus/sql/types/nested/struct/struct_is_null.test new file mode 100644 index 0000000..fb72164 --- /dev/null +++ b/parser/testdata/corpus/sql/types/nested/struct/struct_is_null.test @@ -0,0 +1,17 @@ +# source: test/sql/types/nested/struct/struct_is_null.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +create table tbl (data struct(str varchar)[]); +-- +ok +== +insert into tbl (data) values ([struct_pack(str := 'value')]), (null), (null), (null); +-- +ok +== +select data[1].str as str from tbl where str is not null; +-- +ok +== diff --git a/parser/testdata/corpus/sql/types/nested/struct/struct_of_lists_where.test b/parser/testdata/corpus/sql/types/nested/struct/struct_of_lists_where.test new file mode 100644 index 0000000..43258ab --- /dev/null +++ b/parser/testdata/corpus/sql/types/nested/struct/struct_of_lists_where.test @@ -0,0 +1,21 @@ +# source: test/sql/types/nested/struct/struct_of_lists_where.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +create table t2 (id int, v_map struct(key integer[], val decimal[]), k integer[]); +-- +ok +== +insert into t2 select id, {'key': k, 'val': v}, k from t1; +-- +ok +== +SELECT * FROM t2 order by id +-- +ok +== +SELECT * FROM t2 where id>=4 order by id +-- +ok +== diff --git a/parser/testdata/corpus/sql/types/nested/struct/struct_subquery.test b/parser/testdata/corpus/sql/types/nested/struct/struct_subquery.test new file mode 100644 index 0000000..791829d --- /dev/null +++ b/parser/testdata/corpus/sql/types/nested/struct/struct_subquery.test @@ -0,0 +1,17 @@ +# source: test/sql/types/nested/struct/struct_subquery.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +SELECT (SELECT {'a': 3}) +-- +ok +== +SELECT (SELECT {'a': 3})['a'] +-- +ok +== +SELECT (SELECT CASE WHEN 1=0 THEN {'a': 3} ELSE NULL END) +-- +ok +== diff --git a/parser/testdata/corpus/sql/types/nested/struct/test_struct.test b/parser/testdata/corpus/sql/types/nested/struct/test_struct.test new file mode 100644 index 0000000..a91901f --- /dev/null +++ b/parser/testdata/corpus/sql/types/nested/struct/test_struct.test @@ -0,0 +1,129 @@ +# source: test/sql/types/nested/struct/test_struct.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +SELECT e, STRUCT_PACK(e) FROM struct_data ORDER BY e LIMIT 2 +-- +ok +== +SELECT STRUCT_PACK(a := 42, b := 43) as struct +-- +ok +== +select null::row(a integer); +-- +ok +== +select STRUCT_PACK(a := NULL, b := NULL) as struct +-- +ok +== +SELECT e, STRUCT_EXTRACT(STRUCT_PACK(xx := e, yy := g), 'xx') as ee FROM struct_data +-- +ok +== +SELECT e, (STRUCT_PACK(xx := e, yy := g)).xx as ee FROM struct_data +-- +ok +== +SELECT e, (a).xx as ee FROM (SELECT e, STRUCT_PACK(xx := e, yy := g) FROM struct_data) tbl(e, a) +-- +ok +== +SELECT e, STRUCT_EXTRACT(STRUCT_PACK(xx := e, yy := g), 'xx') as s FROM struct_data WHERE e > 4 +-- +ok +== +SELECT e, STRUCT_EXTRACT(STRUCT_PACK(xx := e, yy := g), 'xx') as s FROM struct_data WHERE e IS NULL +-- +ok +== +SELECT e, STRUCT_EXTRACT(STRUCT_PACK(xx := e//2), 'xx') as s FROM struct_data WHERE e > 4 +-- +ok +== +SELECT e, STRUCT_EXTRACT(STRUCT_PACK(xx := e//2), 'xx')*2 as s FROM struct_data WHERE e > 4 +-- +ok +== +SELECT e, STRUCT_EXTRACT(STRUCT_PACK(xx := e, yy := g), 'xx') as ee FROM struct_data ORDER BY e DESC +-- +ok +== +SELECT e, STRUCT_EXTRACT(STRUCT_PACK(a := e, b := ROWID, c := 42), 'c') as ee FROM struct_data ORDER BY ROWID +-- +ok +== +SELECT STRUCT_EXTRACT(STRUCT_PACK(a := 42, b := 43), 'a') FROM struct_data +-- +ok +== +SELECT STRUCT_EXTRACT(STRUCT_PACK(a := 42, b := 43), 'a') s +-- +ok +== +SELECT STRUCT_EXTRACT(STRUCT_EXTRACT(STRUCT_PACK(a := STRUCT_PACK(x := 'asdf', y := NULL), b := 43), 'a'), 'x') s +-- +ok +== +SELECT STRUCT_PACK() FROM struct_data +-- +ok +== +SELECT STRUCT_PACK(e+1) FROM struct_data +-- +ok +== +SELECT STRUCT_PACK(a := e, a := g) FROM struct_data +-- +ok +== +SELECT STRUCT_PACK(e, e) FROM struct_data +-- +ok +== +SELECT STRUCT_EXTRACT(e, 'e') FROM struct_data +-- +ok +== +SELECT STRUCT_EXTRACT(e) FROM struct_data +-- +ok +== +SELECT STRUCT_EXTRACT('e') FROM struct_data +-- +ok +== +SELECT STRUCT_EXTRACT() FROM struct_data +-- +ok +== +SELECT STRUCT_EXTRACT(STRUCT_PACK(xx := e, yy := g), 'zz') FROM struct_data +-- +ok +== +SELECT STRUCT_EXTRACT(STRUCT_PACK(xx := e, yy := g)) FROM struct_data +-- +ok +== +SELECT STRUCT_EXTRACT(STRUCT_PACK(xx := e, yy := g), g) FROM struct_data +-- +ok +== +SELECT STRUCT_EXTRACT(STRUCT_PACK(xx := e, yy := g), '42') FROM struct_data +-- +ok +== +CREATE TABLE test AS SELECT e, STRUCT_PACK(e) FROM struct_data +-- +ok +== +SELECT STRUCT_PACK(i := range, j := 'asdf') FROM range(2); +-- +ok +== +SELECT STRUCT_PACK(i := range, j := 42) FROM range(2); +-- +ok +== diff --git a/parser/testdata/corpus/sql/types/nested/struct/test_struct_keys.test b/parser/testdata/corpus/sql/types/nested/struct/test_struct_keys.test new file mode 100644 index 0000000..59ab2ed --- /dev/null +++ b/parser/testdata/corpus/sql/types/nested/struct/test_struct_keys.test @@ -0,0 +1,77 @@ +# source: test/sql/types/nested/struct/test_struct_keys.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +select struct_keys({a: 1, b: 2, c: 3, d: 4, e: 5}); +-- +ok +== +select struct_keys(NULL::STRUCT(a INT, b VARCHAR)); +-- +ok +== +select struct_keys(NULL); +-- +ok +== +CREATE TABLE t_struct_constant(x INTEGER); +-- +ok +== +INSERT INTO t_struct_constant VALUES (1), (2), (3); +-- +ok +== +SELECT struct_keys({a: 1, b: 2}) FROM t_struct_constant; +-- +ok +== +CREATE TABLE t_struct_flat(col STRUCT(a INT, b VARCHAR), idx INTEGER); +-- +ok +== +INSERT INTO t_struct_flat VALUES + (ROW(1, 'x')::STRUCT(a INT, b VARCHAR), 0), + (ROW(2, 'y')::STRUCT(a INT, b VARCHAR), 1), + (ROW(3, 'z')::STRUCT(a INT, b VARCHAR), 2), + (NULL::STRUCT(a INT, b VARCHAR), 3), + (ROW(4, 'q')::STRUCT(a INT, b VARCHAR), 4); +-- +ok +== +SELECT struct_keys(col) FROM t_struct_flat; +-- +ok +== +CREATE TABLE filtered_struct ( + col STRUCT(a INT, b VARCHAR), + idx INTEGER +); +-- +ok +== +INSERT INTO filtered_struct VALUES + (ROW(1, 'x')::STRUCT(a INT, b VARCHAR), 0), + (ROW(2, 'y')::STRUCT(a INT, b VARCHAR), 1), + (NULL::STRUCT(a INT, b VARCHAR), 3), + (ROW(4, 'q')::STRUCT(a INT, b VARCHAR), 2); +-- +ok +== +SELECT struct_keys(col) FROM filtered_struct WHERE idx % 2 != 0 ORDER BY idx; +-- +ok +== +select struct_keys(ROW(1, 2)); +-- +ok +== +select struct_keys(42); +-- +ok +== +select struct_keys(['a', 'b']); +-- +ok +== diff --git a/parser/testdata/corpus/sql/types/nested/struct/test_struct_values.test b/parser/testdata/corpus/sql/types/nested/struct/test_struct_values.test new file mode 100644 index 0000000..f33aaa7 --- /dev/null +++ b/parser/testdata/corpus/sql/types/nested/struct/test_struct_values.test @@ -0,0 +1,93 @@ +# source: test/sql/types/nested/struct/test_struct_values.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +select struct_values({a: 1, b: 'x', c: 3}); +-- +ok +== +select struct_values(NULL::STRUCT(a INT, b VARCHAR)); +-- +ok +== +select struct_values(NULL); +-- +ok +== +SELECT struct_values({a: 1, b: 'y'}) FROM range(3); +-- +ok +== +CREATE TABLE t_struct_values_flat(col STRUCT(a INT, b VARCHAR), idx INTEGER); +-- +ok +== +INSERT INTO t_struct_values_flat VALUES + ((1, 'x'), 0), + ((2, 'y'), 1), + ((3, 'z'), 2), + (NULL, 3), + ((4, 'q'), 4); +-- +ok +== +SELECT struct_values(col) FROM t_struct_values_flat; +-- +ok +== +CREATE TABLE filtered_struct_values ( + col STRUCT(a INT, b VARCHAR), + idx INTEGER +); +-- +ok +== +INSERT INTO filtered_struct_values VALUES + ((1, 'x'), 0), + ((2, 'y'), 1), + (NULL, 3), + ((4, 'q'), 2); +-- +ok +== +SELECT struct_values(col) FROM filtered_struct_values WHERE idx % 2 != 0 ORDER BY idx; +-- +ok +== +select struct_values((10, 'hello')); +-- +ok +== +select struct_values({a: NULL, b: 'not null'}); +-- +ok +== +select struct_values({a: 1, b: {x: 'nested', y: 2}}); +-- +ok +== +select struct_values(struct_values({a: 1, b: {x: 'deep', y: 3}})); +-- +ok +== +select struct_values({a: struct_values({x: 7, y: 'inside'}), b: 'outer'}); +-- +ok +== +PREPARE stmt as SELECT struct_values(?); +-- +ok +== +EXECUTE stmt({x: 5, y: 'test'}); +-- +ok +== +select struct_values(42); +-- +ok +== +select struct_values(['a', 'b']); +-- +ok +== diff --git a/parser/testdata/corpus/sql/types/nested/unnest_range_plan.test b/parser/testdata/corpus/sql/types/nested/unnest_range_plan.test new file mode 100644 index 0000000..0d2b5a3 --- /dev/null +++ b/parser/testdata/corpus/sql/types/nested/unnest_range_plan.test @@ -0,0 +1,12 @@ +# source: test/sql/types/nested/unnest_range_plan.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +SELECT * +FROM UNNEST(ARRAY[6]) AS x +UNION ALL +SELECT 2 FROM generate_series(1, 1); +-- +ok +== diff --git a/parser/testdata/corpus/sql/types/null/test_boolean_null.test b/parser/testdata/corpus/sql/types/null/test_boolean_null.test new file mode 100644 index 0000000..f68bcb6 --- /dev/null +++ b/parser/testdata/corpus/sql/types/null/test_boolean_null.test @@ -0,0 +1,73 @@ +# source: test/sql/types/null/test_boolean_null.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +SELECT 0 AND 0, 0 AND 1, 1 AND 0, 1 AND 1, NULL AND 0, NULL AND 1, 0 AND NULL, 1 AND NULL, NULL AND NULL +-- +ok +== +SELECT 0 OR 0, 0 OR 1, 1 OR 0, 1 OR 1, NULL OR 0, NULL OR 1, 0 OR NULL, 1 OR NULL, NULL OR NULL +-- +ok +== +SELECT NOT(0), NOT(1), NOT(NULL) +-- +ok +== +SELECT NULL IS NULL, NULL IS NOT NULL, 42 IS NULL, 42 IS NOT NULL +-- +ok +== +SELECT + NULL IS DISTINCT FROM NULL, + NULL IS NOT DISTINCT FROM NULL, + NULL IS DISTINCT FROM 42, + NULL IS NOT DISTINCT FROM 42, + 42 IS DISTINCT FROM NULL, + 42 IS NOT DISTINCT FROM NULL, + 42 IS DISTINCT FROM 42, + 42 IS NOT DISTINCT FROM 42, + 42 IS DISTINCT FROM 43, + 42 IS NOT DISTINCT FROM 43 +-- +ok +== +SELECT + x, + x IS NULL, + x IS NOT NULL, + x IS DISTINCT FROM NULL, + x IS NOT DISTINCT FROM NULL, + NULL IS DISTINCT FROM x, + NULL IS NOT DISTINCT FROM x, + x IS DISTINCT FROM 1, + x IS NOT DISTINCT FROM 1 +FROM (VALUES (NULL), (1), (2)) t(x) +ORDER BY x +-- +ok +== +SELECT + x, + (x + 1) IS DISTINCT FROM NULL, + (x + 1) IS NOT DISTINCT FROM NULL, + NULL IS DISTINCT FROM (x + 1), + NULL IS NOT DISTINCT FROM (x + 1) +FROM (VALUES (NULL), (1), (2)) t(x) +ORDER BY x +-- +ok +== +SELECT NULL = NULL, NULL <> NULL, 42 = NULL, 42 <> NULL +-- +ok +== +INSERT INTO test VALUES (11, 22), (NULL, 21), (13, 22), (12, NULL), (16, NULL) +-- +ok +== +SELECT b, COUNT(a), SUM(a), MIN(a), MAX(a) FROM test GROUP BY b ORDER BY b +-- +ok +== diff --git a/parser/testdata/corpus/sql/types/null/test_is_null.test b/parser/testdata/corpus/sql/types/null/test_is_null.test new file mode 100644 index 0000000..ecf5c97 --- /dev/null +++ b/parser/testdata/corpus/sql/types/null/test_is_null.test @@ -0,0 +1,17 @@ +# source: test/sql/types/null/test_is_null.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +INSERT INTO test VALUES (11, 1), (NULL, 2), (13, 3) +-- +ok +== +SELECT a IS NULL, a IS NOT NULL, rowid IS NULL, (a = NULL) IS NULL FROM test ORDER BY b +-- +ok +== +SELECT a IS NULL, a IS NOT NULL, rowid IS NULL, (a = NULL) IS NULL FROM test WHERE b != 1 ORDER BY b +-- +ok +== diff --git a/parser/testdata/corpus/sql/types/null/test_null.test b/parser/testdata/corpus/sql/types/null/test_null.test new file mode 100644 index 0000000..ab96e3c --- /dev/null +++ b/parser/testdata/corpus/sql/types/null/test_null.test @@ -0,0 +1,45 @@ +# source: test/sql/types/null/test_null.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +SELECT 3 + NULL +-- +ok +== +SELECT NULL + 3 +-- +ok +== +SELECT NULL + NULL +-- +ok +== +SELECT 1 + (NULL + NULL) +-- +ok +== +SELECT 4 / 0 +-- +ok +== +INSERT INTO test VALUES (11, 22), (NULL, 21), (13, 22) +-- +ok +== +SELECT cast(a AS BIGINT) FROM test; +-- +ok +== +SELECT a / 0 FROM test; +-- +ok +== +SELECT a / (a - a) FROM test; +-- +ok +== +SELECT a + b FROM test +-- +ok +== diff --git a/parser/testdata/corpus/sql/types/null/test_null_aggr.test b/parser/testdata/corpus/sql/types/null/test_null_aggr.test new file mode 100644 index 0000000..2c12ed1 --- /dev/null +++ b/parser/testdata/corpus/sql/types/null/test_null_aggr.test @@ -0,0 +1,21 @@ +# source: test/sql/types/null/test_null_aggr.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +SELECT SUM(a), MIN(a), MAX(a) FROM test +-- +ok +== +SELECT COUNT(*), COUNT(a), COUNT(b) FROM test +-- +ok +== +INSERT INTO test VALUES (12, NULL), (16, NULL) +-- +ok +== +INSERT INTO test VALUES (NULL, NULL), (NULL, 22) +-- +ok +== diff --git a/parser/testdata/corpus/sql/types/null/test_null_cast.test b/parser/testdata/corpus/sql/types/null/test_null_cast.test new file mode 100644 index 0000000..8c49af0 --- /dev/null +++ b/parser/testdata/corpus/sql/types/null/test_null_cast.test @@ -0,0 +1,9 @@ +# source: test/sql/types/null/test_null_cast.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +SELECT NULL::BIGINT::VARCHAR::INT[]::ROW(i INTEGER, k INTEGER)::DECIMAL(4,0) +-- +ok +== diff --git a/parser/testdata/corpus/sql/types/numeric/arithmetic_vector_types.test b/parser/testdata/corpus/sql/types/numeric/arithmetic_vector_types.test new file mode 100644 index 0000000..d1bdec8 --- /dev/null +++ b/parser/testdata/corpus/sql/types/numeric/arithmetic_vector_types.test @@ -0,0 +1,9 @@ +# source: test/sql/types/numeric/arithmetic_vector_types.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +SELECT a + b FROM test_vector_types(NULL::INT, NULL::INT) t(a, b) +-- +ok +== diff --git a/parser/testdata/corpus/sql/types/numeric/bigint_try_cast.test b/parser/testdata/corpus/sql/types/numeric/bigint_try_cast.test new file mode 100644 index 0000000..70b9882 --- /dev/null +++ b/parser/testdata/corpus/sql/types/numeric/bigint_try_cast.test @@ -0,0 +1,149 @@ +# source: test/sql/types/numeric/bigint_try_cast.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +CREATE TABLE bigints AS SELECT i::BIGINT i FROM (VALUES (-9223372036854775808), (0), (9223372036854775807)) tbl(i) +-- +ok +== +SELECT i::UTINYINT FROM bigints +-- +ok +== +SELECT i::USMALLINT FROM bigints +-- +ok +== +SELECT i::UINTEGER FROM bigints +-- +ok +== +SELECT i::UBIGINT FROM bigints +-- +ok +== +SELECT i::UTINYINT FROM bigints WHERE i>=0 ORDER BY i +-- +ok +== +SELECT i::USMALLINT FROM bigints WHERE i>=0 ORDER BY i +-- +ok +== +SELECT i::UINTEGER FROM bigints WHERE i>=0 ORDER BY i +-- +ok +== +SELECT i::UBIGINT FROM bigints WHERE i>=0 ORDER BY i +-- +ok +== +SELECT TRY_CAST(i AS UTINYINT) FROM bigints ORDER BY i +-- +ok +== +SELECT TRY_CAST(i AS USMALLINT) FROM bigints ORDER BY i +-- +ok +== +SELECT TRY_CAST(i AS UINTEGER) FROM bigints ORDER BY i +-- +ok +== +SELECT TRY_CAST(i AS UBIGINT) FROM bigints ORDER BY i +-- +ok +== +SELECT i::TINYINT FROM bigints ORDER BY i +-- +ok +== +SELECT TRY_CAST(i AS TINYINT) FROM bigints ORDER BY i +-- +ok +== +SELECT i::SMALLINT FROM bigints ORDER BY i +-- +ok +== +SELECT TRY_CAST(i AS SMALLINT) FROM bigints ORDER BY i +-- +ok +== +SELECT i::INTEGER FROM bigints ORDER BY i +-- +ok +== +SELECT TRY_CAST(i AS INTEGER) FROM bigints ORDER BY i +-- +ok +== +SELECT i::HUGEINT::BIGINT FROM bigints ORDER BY i +-- +ok +== +SELECT i::FLOAT FROM bigints ORDER BY i +-- +ok +== +SELECT i::DOUBLE FROM bigints ORDER BY i +-- +ok +== +SELECT i::BOOL FROM bigints ORDER BY i +-- +ok +== +SELECT i::VARCHAR FROM bigints ORDER BY i +-- +ok +== +CREATE TABLE strings AS SELECT * FROM (VALUES (' '), ('blablabla'), ('-10000000000000000000'), ('-9223372036854775808'), ('0'), ('9223372036854775807'), ('10000000000000000000')) tbl(s) +-- +ok +== +SELECT s::BIGINT FROM strings +-- +ok +== +SELECT TRY_CAST(s AS BIGINT) FROM strings +-- +ok +== +SELECT i::DECIMAL(3,0)::BIGINT FROM bigints ORDER BY i +-- +ok +== +SELECT i::DECIMAL(9,0)::BIGINT FROM bigints ORDER BY i +-- +ok +== +SELECT i::DECIMAL(18,0)::BIGINT FROM bigints ORDER BY i +-- +ok +== +SELECT i::DECIMAL(38,0)::BIGINT FROM bigints ORDER BY i +-- +ok +== +SELECT i::DECIMAL(38,20)::BIGINT FROM bigints ORDER BY i +-- +ok +== +SELECT TRY_CAST(i AS DECIMAL(3,0))::BIGINT FROM bigints ORDER BY i +-- +ok +== +SELECT TRY_CAST(i AS DECIMAL(9,0))::BIGINT FROM bigints ORDER BY i +-- +ok +== +SELECT TRY_CAST(i AS DECIMAL(18,0))::BIGINT FROM bigints ORDER BY i +-- +ok +== +SELECT TRY_CAST(i AS DECIMAL(38,20))::BIGINT FROM bigints ORDER BY i +-- +ok +== diff --git a/parser/testdata/corpus/sql/types/numeric/bool_casts.test b/parser/testdata/corpus/sql/types/numeric/bool_casts.test new file mode 100644 index 0000000..f8a2d32 --- /dev/null +++ b/parser/testdata/corpus/sql/types/numeric/bool_casts.test @@ -0,0 +1,21 @@ +# source: test/sql/types/numeric/bool_casts.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +CREATE TABLE booleans AS SELECT b::BOOLEAN b FROM (VALUES (NULL), (0), (1)) tbl(b) +-- +ok +== +SELECT b::{type} FROM booleans +-- +error: Parser Error: syntax error at or near "{" +== +SELECT b::{type}::bool FROM booleans +-- +error: Parser Error: syntax error at or near "{" +== +SELECT b::{type}::VARCHAR FROM booleans +-- +error: Parser Error: syntax error at or near "{" +== diff --git a/parser/testdata/corpus/sql/types/numeric/combinations/decimal_combinations.test b/parser/testdata/corpus/sql/types/numeric/combinations/decimal_combinations.test new file mode 100644 index 0000000..4a1598b --- /dev/null +++ b/parser/testdata/corpus/sql/types/numeric/combinations/decimal_combinations.test @@ -0,0 +1,57 @@ +# source: test/sql/types/numeric/combinations/decimal_combinations.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +CREATE TABLE tinyint_limits AS SELECT (-128)::TINYINT min, 127::TINYINT max +-- +ok +== +CREATE TABLE smallint_limits AS SELECT (-32768)::SMALLINT min, 32767::SMALLINT max +-- +ok +== +CREATE TABLE integer_limits AS SELECT (-2147483648)::INTEGER min, 2147483647::INTEGER max +-- +ok +== +CREATE TABLE bigint_limits AS SELECT (-9223372036854775808)::BIGINT min, 9223372036854775807::BIGINT max +-- +ok +== +CREATE TABLE utinyint_limits AS SELECT (0)::UTINYINT min, 255::UTINYINT max +-- +ok +== +CREATE TABLE usmallint_limits AS SELECT (0)::USMALLINT min, 65535::USMALLINT max +-- +ok +== +CREATE TABLE uinteger_limits AS SELECT (0)::UINTEGER min, 4294967295::UINTEGER max +-- +ok +== +CREATE TABLE ubigint_limits AS SELECT (0)::UBIGINT min, 18446744073709551615::UBIGINT max +-- +ok +== +CREATE TABLE hugeint_limits AS SELECT (-17014118346046923173168730371588410572)::HUGEINT min, 17014118346046923173168730371588410572::HUGEINT max +-- +ok +== +select (typeof([(SELECT max from {type}_limits), 1.00005])::VARCHAR)[:7] +-- +error: Parser Error: syntax error at or near "{" +== +select (typeof([(SELECT min from {type}_limits), 1.00005])::VARCHAR)[:7] +-- +error: Parser Error: syntax error at or near "{" +== +select [(SELECT min from hugeint_limits), 1.00005] +-- +ok +== +select [(SELECT max from hugeint_limits), 1.00005] +-- +ok +== diff --git a/parser/testdata/corpus/sql/types/numeric/combinations/usmallint_combinations.test b/parser/testdata/corpus/sql/types/numeric/combinations/usmallint_combinations.test new file mode 100644 index 0000000..ac87b95 --- /dev/null +++ b/parser/testdata/corpus/sql/types/numeric/combinations/usmallint_combinations.test @@ -0,0 +1,21 @@ +# source: test/sql/types/numeric/combinations/usmallint_combinations.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +select typeof([100::USMALLINT, 10000::SMALLINT]); +-- +ok +== +select typeof([100::USMALLINT, 127::TINYINT]); +-- +ok +== +select typeof([100::USMALLINT, 127::USMALLINT]); +-- +ok +== +select typeof([100::USMALLINT, 10.5::DECIMAL]); +-- +ok +== diff --git a/parser/testdata/corpus/sql/types/numeric/combinations/utinyint_combinations.test b/parser/testdata/corpus/sql/types/numeric/combinations/utinyint_combinations.test new file mode 100644 index 0000000..9e5e820 --- /dev/null +++ b/parser/testdata/corpus/sql/types/numeric/combinations/utinyint_combinations.test @@ -0,0 +1,25 @@ +# source: test/sql/types/numeric/combinations/utinyint_combinations.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +select typeof([100::UTINYINT, 10000::SMALLINT]); +-- +ok +== +select typeof([100::UTINYINT, 127::TINYINT]); +-- +ok +== +select typeof([100::UTINYINT, 127::UTINYINT]); +-- +ok +== +select typeof([100::UTINYINT, 127::USMALLINT]); +-- +ok +== +select typeof([100::UTINYINT, 10.5::DECIMAL]); +-- +ok +== diff --git a/parser/testdata/corpus/sql/types/numeric/hugeint_try_cast.test b/parser/testdata/corpus/sql/types/numeric/hugeint_try_cast.test new file mode 100644 index 0000000..0712c6f --- /dev/null +++ b/parser/testdata/corpus/sql/types/numeric/hugeint_try_cast.test @@ -0,0 +1,149 @@ +# source: test/sql/types/numeric/hugeint_try_cast.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +CREATE TABLE hugeints AS SELECT i::HUGEINT i FROM (VALUES (-170141183460469231731687303715884105728), (0), (170141183460469231731687303715884105727)) tbl(i) +-- +ok +== +SELECT i::UTINYINT FROM hugeints +-- +ok +== +SELECT i::USMALLINT FROM hugeints +-- +ok +== +SELECT i::UINTEGER FROM hugeints +-- +ok +== +SELECT i::UBIGINT FROM hugeints +-- +ok +== +SELECT i::UTINYINT FROM hugeints WHERE i>=0 ORDER BY i +-- +ok +== +SELECT i::USMALLINT FROM hugeints WHERE i>=0 ORDER BY i +-- +ok +== +SELECT i::UINTEGER FROM hugeints WHERE i>=0 ORDER BY i +-- +ok +== +SELECT i::UBIGINT FROM hugeints WHERE i>=0 ORDER BY i +-- +ok +== +SELECT TRY_CAST(i AS UTINYINT) FROM hugeints ORDER BY i +-- +ok +== +SELECT TRY_CAST(i AS USMALLINT) FROM hugeints ORDER BY i +-- +ok +== +SELECT TRY_CAST(i AS UINTEGER) FROM hugeints ORDER BY i +-- +ok +== +SELECT TRY_CAST(i AS UBIGINT) FROM hugeints ORDER BY i +-- +ok +== +SELECT i::TINYINT FROM hugeints ORDER BY i +-- +ok +== +SELECT TRY_CAST(i AS TINYINT) FROM hugeints ORDER BY i +-- +ok +== +SELECT i::SMALLINT FROM hugeints ORDER BY i +-- +ok +== +SELECT TRY_CAST(i AS SMALLINT) FROM hugeints ORDER BY i +-- +ok +== +SELECT i::INTEGER FROM hugeints ORDER BY i +-- +ok +== +SELECT TRY_CAST(i AS INTEGER) FROM hugeints ORDER BY i +-- +ok +== +SELECT i::BIGINT FROM hugeints ORDER BY i +-- +ok +== +SELECT TRY_CAST(i AS BIGINT) FROM hugeints ORDER BY i +-- +ok +== +SELECT i::FLOAT FROM hugeints ORDER BY i +-- +ok +== +SELECT i::DOUBLE FROM hugeints ORDER BY i +-- +ok +== +SELECT i::BOOL FROM hugeints ORDER BY i +-- +ok +== +SELECT i::VARCHAR FROM hugeints ORDER BY i +-- +ok +== +CREATE TABLE strings AS SELECT * FROM (VALUES (' '), ('blablabla'), ('-1000000000000000000000000000000000000000'), ('-170141183460469231731687303715884105728'), ('0'), ('170141183460469231731687303715884105727'), ('1000000000000000000000000000000000000000')) tbl(s) +-- +ok +== +SELECT s::HUGEINT FROM strings +-- +ok +== +SELECT TRY_CAST(s AS HUGEINT) FROM strings +-- +ok +== +SELECT i::DECIMAL(3,0)::HUGEINT FROM hugeints ORDER BY i +-- +ok +== +SELECT i::DECIMAL(9,0)::HUGEINT FROM hugeints ORDER BY i +-- +ok +== +SELECT i::DECIMAL(18,0)::HUGEINT FROM hugeints ORDER BY i +-- +ok +== +SELECT i::DECIMAL(38,0)::HUGEINT FROM hugeints ORDER BY i +-- +ok +== +SELECT TRY_CAST(i AS DECIMAL(3,0))::HUGEINT FROM hugeints ORDER BY i +-- +ok +== +SELECT TRY_CAST(i AS DECIMAL(9,0))::HUGEINT FROM hugeints ORDER BY i +-- +ok +== +SELECT TRY_CAST(i AS DECIMAL(18,0))::HUGEINT FROM hugeints ORDER BY i +-- +ok +== +SELECT TRY_CAST(i AS DECIMAL(38,0))::HUGEINT FROM hugeints ORDER BY i +-- +ok +== diff --git a/parser/testdata/corpus/sql/types/numeric/integer_try_cast.test b/parser/testdata/corpus/sql/types/numeric/integer_try_cast.test new file mode 100644 index 0000000..805c21e --- /dev/null +++ b/parser/testdata/corpus/sql/types/numeric/integer_try_cast.test @@ -0,0 +1,149 @@ +# source: test/sql/types/numeric/integer_try_cast.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +CREATE TABLE integers AS SELECT i::INTEGER i FROM (VALUES (-2147483648), (0), (2147483647)) tbl(i) +-- +ok +== +SELECT i::UTINYINT FROM integers +-- +ok +== +SELECT i::USMALLINT FROM integers +-- +ok +== +SELECT i::UINTEGER FROM integers +-- +ok +== +SELECT i::UBIGINT FROM integers +-- +ok +== +SELECT i::UTINYINT FROM integers WHERE i>=0 ORDER BY i +-- +ok +== +SELECT i::USMALLINT FROM integers WHERE i>=0 ORDER BY i +-- +ok +== +SELECT i::UINTEGER FROM integers WHERE i>=0 ORDER BY i +-- +ok +== +SELECT i::UBIGINT FROM integers WHERE i>=0 ORDER BY i +-- +ok +== +SELECT TRY_CAST(i AS UTINYINT)::INTEGER FROM integers ORDER BY i +-- +ok +== +SELECT TRY_CAST(i AS USMALLINT)::INTEGER FROM integers ORDER BY i +-- +ok +== +SELECT TRY_CAST(i AS UINTEGER)::INTEGER FROM integers ORDER BY i +-- +ok +== +SELECT TRY_CAST(i AS UBIGINT)::INTEGER FROM integers ORDER BY i +-- +ok +== +SELECT i::TINYINT FROM integers ORDER BY i +-- +ok +== +SELECT TRY_CAST(i AS TINYINT) FROM integers ORDER BY i +-- +ok +== +SELECT i::SMALLINT FROM integers ORDER BY i +-- +ok +== +SELECT TRY_CAST(i AS SMALLINT) FROM integers ORDER BY i +-- +ok +== +SELECT i::BIGINT::INTEGER FROM integers ORDER BY i +-- +ok +== +SELECT i::HUGEINT::INTEGER FROM integers ORDER BY i +-- +ok +== +SELECT i::FLOAT FROM integers ORDER BY i +-- +ok +== +SELECT i::DOUBLE FROM integers ORDER BY i +-- +ok +== +SELECT i::BOOL FROM integers ORDER BY i +-- +ok +== +SELECT i::VARCHAR FROM integers ORDER BY i +-- +ok +== +CREATE TABLE strings AS SELECT * FROM (VALUES (' '), ('blablabla'), ('-10000000000'), ('-2147483648'), ('0'), ('2147483647'), ('10000000000')) tbl(s) +-- +ok +== +SELECT s::INTEGER FROM strings +-- +ok +== +SELECT TRY_CAST(s AS INTEGER) FROM strings +-- +ok +== +SELECT i::DECIMAL(3,0)::INTEGER FROM integers ORDER BY i +-- +ok +== +SELECT i::DECIMAL(9,0)::INTEGER FROM integers ORDER BY i +-- +ok +== +SELECT i::DECIMAL(18,0)::INTEGER FROM integers ORDER BY i +-- +ok +== +SELECT i::DECIMAL(38,0)::INTEGER FROM integers ORDER BY i +-- +ok +== +SELECT i::DECIMAL(18,9)::INTEGER FROM integers ORDER BY i +-- +ok +== +SELECT i::DECIMAL(38,29)::INTEGER FROM integers ORDER BY i +-- +ok +== +SELECT TRY_CAST(i AS DECIMAL(3,0))::INTEGER FROM integers ORDER BY i +-- +ok +== +SELECT TRY_CAST(i AS DECIMAL(9,0))::INTEGER FROM integers ORDER BY i +-- +ok +== +SELECT TRY_CAST(i AS DECIMAL(18,9))::INTEGER FROM integers ORDER BY i +-- +ok +== +SELECT TRY_CAST(i AS DECIMAL(38,29))::INTEGER FROM integers ORDER BY i +-- +ok +== diff --git a/parser/testdata/corpus/sql/types/numeric/smallint_try_cast.test b/parser/testdata/corpus/sql/types/numeric/smallint_try_cast.test new file mode 100644 index 0000000..9f25f61 --- /dev/null +++ b/parser/testdata/corpus/sql/types/numeric/smallint_try_cast.test @@ -0,0 +1,149 @@ +# source: test/sql/types/numeric/smallint_try_cast.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +CREATE TABLE smallints AS SELECT i::SMALLINT i FROM (VALUES (-32768), (0), (32767)) tbl(i) +-- +ok +== +SELECT i::UTINYINT FROM smallints +-- +ok +== +SELECT i::USMALLINT FROM smallints +-- +ok +== +SELECT i::UINTEGER FROM smallints +-- +ok +== +SELECT i::UBIGINT FROM smallints +-- +ok +== +SELECT i::UTINYINT FROM smallints WHERE i>=0 ORDER BY i +-- +ok +== +SELECT i::USMALLINT FROM smallints WHERE i>=0 ORDER BY i +-- +ok +== +SELECT i::UINTEGER FROM smallints WHERE i>=0 ORDER BY i +-- +ok +== +SELECT i::UBIGINT FROM smallints WHERE i>=0 ORDER BY i +-- +ok +== +SELECT TRY_CAST(i AS UTINYINT)::SMALLINT FROM smallints ORDER BY i +-- +ok +== +SELECT TRY_CAST(i AS USMALLINT)::SMALLINT FROM smallints ORDER BY i +-- +ok +== +SELECT TRY_CAST(i AS UINTEGER)::SMALLINT FROM smallints ORDER BY i +-- +ok +== +SELECT TRY_CAST(i AS UBIGINT)::SMALLINT FROM smallints ORDER BY i +-- +ok +== +SELECT i::TINYINT FROM smallints ORDER BY i +-- +ok +== +SELECT TRY_CAST(i AS TINYINT)::SMALLINT FROM smallints ORDER BY i +-- +ok +== +SELECT i::INTEGER::SMALLINT FROM smallints ORDER BY i +-- +ok +== +SELECT i::BIGINT::SMALLINT FROM smallints ORDER BY i +-- +ok +== +SELECT i::HUGEINT::SMALLINT FROM smallints ORDER BY i +-- +ok +== +SELECT i::FLOAT FROM smallints ORDER BY i +-- +ok +== +SELECT i::DOUBLE FROM smallints ORDER BY i +-- +ok +== +SELECT i::BOOL FROM smallints ORDER BY i +-- +ok +== +SELECT i::VARCHAR FROM smallints ORDER BY i +-- +ok +== +CREATE TABLE strings AS SELECT * FROM (VALUES (' '), ('blablabla'), ('-100000'), ('-32768'), ('0'), ('32767'), ('100000')) tbl(s) +-- +ok +== +SELECT s::SMALLINT FROM strings +-- +ok +== +SELECT TRY_CAST(s AS SMALLINT) FROM strings +-- +ok +== +SELECT i::DECIMAL(3,0)::SMALLINT FROM smallints ORDER BY i +-- +ok +== +SELECT i::DECIMAL(9,0)::SMALLINT FROM smallints ORDER BY i +-- +ok +== +SELECT i::DECIMAL(18,0)::SMALLINT FROM smallints ORDER BY i +-- +ok +== +SELECT i::DECIMAL(38,0)::SMALLINT FROM smallints ORDER BY i +-- +ok +== +SELECT i::DECIMAL(9,5)::SMALLINT FROM smallints ORDER BY i +-- +ok +== +SELECT i::DECIMAL(18,14)::SMALLINT FROM smallints ORDER BY i +-- +ok +== +SELECT i::DECIMAL(38,34)::SMALLINT FROM smallints ORDER BY i +-- +ok +== +SELECT TRY_CAST(i AS DECIMAL(3,0))::SMALLINT FROM smallints ORDER BY i +-- +ok +== +SELECT TRY_CAST(i AS DECIMAL(9,5))::SMALLINT FROM smallints ORDER BY i +-- +ok +== +SELECT TRY_CAST(i AS DECIMAL(18,14))::SMALLINT FROM smallints ORDER BY i +-- +ok +== +SELECT TRY_CAST(i AS DECIMAL(38,34))::SMALLINT FROM smallints ORDER BY i +-- +ok +== diff --git a/parser/testdata/corpus/sql/types/numeric/test_empty_numeric.test b/parser/testdata/corpus/sql/types/numeric/test_empty_numeric.test new file mode 100644 index 0000000..d143103 --- /dev/null +++ b/parser/testdata/corpus/sql/types/numeric/test_empty_numeric.test @@ -0,0 +1,21 @@ +# source: test/sql/types/numeric/test_empty_numeric.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +CREATE TABLE numerics(i NUMERIC(), j NUMERIC) +-- +ok +== +INSERT INTO numerics VALUES (0176030871715840, 2.2) +-- +ok +== +SELECT * FROM numerics +-- +ok +== +SELECT 1.25::FLOAT::NUMERIC, 1.25::FLOAT::NUMERIC() +-- +ok +== diff --git a/parser/testdata/corpus/sql/types/numeric/tinyint_try_cast.test b/parser/testdata/corpus/sql/types/numeric/tinyint_try_cast.test new file mode 100644 index 0000000..75b098b --- /dev/null +++ b/parser/testdata/corpus/sql/types/numeric/tinyint_try_cast.test @@ -0,0 +1,149 @@ +# source: test/sql/types/numeric/tinyint_try_cast.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +CREATE TABLE tinyints AS SELECT i::TINYINT i FROM (VALUES (-128), (0), (127)) tbl(i) +-- +ok +== +SELECT i::UTINYINT FROM tinyints +-- +ok +== +SELECT i::USMALLINT FROM tinyints +-- +ok +== +SELECT i::UINTEGER FROM tinyints +-- +ok +== +SELECT i::UBIGINT FROM tinyints +-- +ok +== +SELECT i::UTINYINT::TINYINT FROM tinyints WHERE i>=0 ORDER BY i +-- +ok +== +SELECT i::USMALLINT::TINYINT FROM tinyints WHERE i>=0 ORDER BY i +-- +ok +== +SELECT i::UINTEGER::TINYINT FROM tinyints WHERE i>=0 ORDER BY i +-- +ok +== +SELECT i::UBIGINT::TINYINT FROM tinyints WHERE i>=0 ORDER BY i +-- +ok +== +SELECT TRY_CAST(i AS UTINYINT) FROM tinyints ORDER BY i +-- +ok +== +SELECT TRY_CAST(i AS USMALLINT) FROM tinyints ORDER BY i +-- +ok +== +SELECT TRY_CAST(i AS UINTEGER) FROM tinyints ORDER BY i +-- +ok +== +SELECT TRY_CAST(i AS UBIGINT) FROM tinyints ORDER BY i +-- +ok +== +SELECT i::SMALLINT::TINYINT FROM tinyints ORDER BY i +-- +ok +== +SELECT i::INTEGER::TINYINT FROM tinyints ORDER BY i +-- +ok +== +SELECT i::BIGINT::TINYINT FROM tinyints ORDER BY i +-- +ok +== +SELECT i::HUGEINT::TINYINT FROM tinyints ORDER BY i +-- +ok +== +SELECT i::FLOAT FROM tinyints ORDER BY i +-- +ok +== +SELECT i::DOUBLE FROM tinyints ORDER BY i +-- +ok +== +SELECT i::BOOL FROM tinyints ORDER BY i +-- +ok +== +SELECT i::VARCHAR::TINYINT FROM tinyints ORDER BY i +-- +ok +== +CREATE TABLE strings AS SELECT * FROM (VALUES (' '), ('blablabla'), ('-1000'), ('-128'), ('0'), ('127'), ('1000')) tbl(s) +-- +ok +== +SELECT s::TINYINT FROM strings +-- +ok +== +SELECT TRY_CAST(s AS TINYINT) FROM strings +-- +ok +== +SELECT i::DECIMAL(3,0)::TINYINT FROM tinyints ORDER BY i +-- +ok +== +SELECT i::DECIMAL(9,0)::TINYINT FROM tinyints ORDER BY i +-- +ok +== +SELECT i::DECIMAL(18,0)::TINYINT FROM tinyints ORDER BY i +-- +ok +== +SELECT i::DECIMAL(38,0)::TINYINT FROM tinyints ORDER BY i +-- +ok +== +SELECT i::DECIMAL(3,1)::TINYINT FROM tinyints ORDER BY i +-- +ok +== +SELECT i::DECIMAL(9,7)::TINYINT FROM tinyints ORDER BY i +-- +ok +== +SELECT i::DECIMAL(18,16)::TINYINT FROM tinyints ORDER BY i +-- +ok +== +SELECT i::DECIMAL(38,36)::TINYINT FROM tinyints ORDER BY i +-- +ok +== +SELECT TRY_CAST(i AS DECIMAL(3,1))::TINYINT FROM tinyints ORDER BY i +-- +ok +== +SELECT TRY_CAST(i AS DECIMAL(9,7))::TINYINT FROM tinyints ORDER BY i +-- +ok +== +SELECT TRY_CAST(i AS DECIMAL(18,16))::TINYINT FROM tinyints ORDER BY i +-- +ok +== +SELECT TRY_CAST(i AS DECIMAL(38,36))::TINYINT FROM tinyints ORDER BY i +-- +ok +== diff --git a/parser/testdata/corpus/sql/types/numeric/ubigint_arithmetic_casting.test b/parser/testdata/corpus/sql/types/numeric/ubigint_arithmetic_casting.test new file mode 100644 index 0000000..965fdd1 --- /dev/null +++ b/parser/testdata/corpus/sql/types/numeric/ubigint_arithmetic_casting.test @@ -0,0 +1,17 @@ +# source: test/sql/types/numeric/ubigint_arithmetic_casting.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +SELECT typeof(1::UBIGINT + 1::TINYINT) +-- +ok +== +SELECT typeof(1::UBIGINT + 1) +-- +ok +== +SELECT typeof(1::UBIGINT + 10000) +-- +ok +== diff --git a/parser/testdata/corpus/sql/types/numeric/ubigint_try_cast.test b/parser/testdata/corpus/sql/types/numeric/ubigint_try_cast.test new file mode 100644 index 0000000..c370cf3 --- /dev/null +++ b/parser/testdata/corpus/sql/types/numeric/ubigint_try_cast.test @@ -0,0 +1,133 @@ +# source: test/sql/types/numeric/ubigint_try_cast.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +CREATE TABLE ubigints AS SELECT i::UBIGINT i FROM (VALUES (0), (18446744073709551615)) tbl(i) +-- +ok +== +SELECT i::UTINYINT FROM ubigints ORDER BY i +-- +ok +== +SELECT TRY_CAST(i AS UTINYINT) FROM ubigints ORDER BY i +-- +ok +== +SELECT i::USMALLINT FROM ubigints ORDER BY i +-- +ok +== +SELECT TRY_CAST(i AS USMALLINT) FROM ubigints ORDER BY i +-- +ok +== +SELECT i::UINTEGER FROM ubigints ORDER BY i +-- +ok +== +SELECT TRY_CAST(i AS UINTEGER) FROM ubigints ORDER BY i +-- +ok +== +SELECT i::TINYINT FROM ubigints ORDER BY i +-- +ok +== +SELECT TRY_CAST(i AS TINYINT) FROM ubigints ORDER BY i +-- +ok +== +SELECT i::SMALLINT FROM ubigints ORDER BY i +-- +ok +== +SELECT TRY_CAST(i AS SMALLINT) FROM ubigints ORDER BY i +-- +ok +== +SELECT i::INTEGER FROM ubigints ORDER BY i +-- +ok +== +SELECT TRY_CAST(i AS INTEGER) FROM ubigints ORDER BY i +-- +ok +== +SELECT i::BIGINT FROM ubigints ORDER BY i +-- +ok +== +SELECT TRY_CAST(i AS BIGINT) FROM ubigints ORDER BY i +-- +ok +== +SELECT i::HUGEINT FROM ubigints ORDER BY i +-- +ok +== +SELECT i::FLOAT FROM ubigints ORDER BY i +-- +ok +== +SELECT i::DOUBLE FROM ubigints ORDER BY i +-- +ok +== +SELECT i::BOOL FROM ubigints ORDER BY i +-- +ok +== +SELECT i::VARCHAR FROM ubigints ORDER BY i +-- +ok +== +CREATE TABLE strings AS SELECT * FROM (VALUES (' '), ('blablabla'), ('-1000'), ('-1'), ('-0'), ('0'), ('18446744073709551615'), ('100000000000000000000')) tbl(s) +-- +ok +== +SELECT s::UBIGINT FROM strings +-- +ok +== +SELECT TRY_CAST(s AS UBIGINT) FROM strings +-- +ok +== +SELECT i::DECIMAL(3,0)::UBIGINT FROM ubigints ORDER BY i +-- +ok +== +SELECT i::DECIMAL(9,0)::UBIGINT FROM ubigints ORDER BY i +-- +ok +== +SELECT i::DECIMAL(18,0)::UBIGINT FROM ubigints ORDER BY i +-- +ok +== +SELECT i::DECIMAL(38,0)::UBIGINT FROM ubigints ORDER BY i +-- +ok +== +SELECT i::DECIMAL(38,20)::UBIGINT FROM ubigints ORDER BY i +-- +ok +== +SELECT TRY_CAST(i AS DECIMAL(3,0))::UBIGINT FROM ubigints ORDER BY i +-- +ok +== +SELECT TRY_CAST(i AS DECIMAL(9,0))::UBIGINT FROM ubigints ORDER BY i +-- +ok +== +SELECT TRY_CAST(i AS DECIMAL(18,0))::UBIGINT FROM ubigints ORDER BY i +-- +ok +== +SELECT TRY_CAST(i AS DECIMAL(38,20))::UBIGINT FROM ubigints ORDER BY i +-- +ok +== diff --git a/parser/testdata/corpus/sql/types/numeric/uhugeint_try_cast.test b/parser/testdata/corpus/sql/types/numeric/uhugeint_try_cast.test new file mode 100644 index 0000000..21226f2 --- /dev/null +++ b/parser/testdata/corpus/sql/types/numeric/uhugeint_try_cast.test @@ -0,0 +1,133 @@ +# source: test/sql/types/numeric/uhugeint_try_cast.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +CREATE TABLE uhugeints AS SELECT i::UHUGEINT i FROM (VALUES (0::UHUGEINT), (1::UHUGEINT), ('340282366920938463463374607431768211455'::UHUGEINT)) tbl(i) +-- +ok +== +SELECT i::TINYINT FROM uhugeints +-- +ok +== +SELECT i::SMALLINT FROM uhugeints +-- +ok +== +SELECT i::INTEGER FROM uhugeints +-- +ok +== +SELECT i::BIGINT FROM uhugeints +-- +ok +== +SELECT TRY_CAST(i AS TINYINT) FROM uhugeints ORDER BY i +-- +ok +== +SELECT TRY_CAST(i AS SMALLINT) FROM uhugeints ORDER BY i +-- +ok +== +SELECT TRY_CAST(i AS INTEGER) FROM uhugeints ORDER BY i +-- +ok +== +SELECT TRY_CAST(i AS BIGINT) FROM uhugeints ORDER BY i +-- +ok +== +SELECT i::UTINYINT FROM uhugeints ORDER BY i +-- +ok +== +SELECT TRY_CAST(i AS UTINYINT) FROM uhugeints ORDER BY i +-- +ok +== +SELECT i::USMALLINT FROM uhugeints ORDER BY i +-- +ok +== +SELECT TRY_CAST(i AS USMALLINT) FROM uhugeints ORDER BY i +-- +ok +== +SELECT i::UINTEGER FROM uhugeints ORDER BY i +-- +ok +== +SELECT TRY_CAST(i AS UINTEGER) FROM uhugeints ORDER BY i +-- +ok +== +SELECT i::UBIGINT FROM uhugeints ORDER BY i +-- +ok +== +SELECT TRY_CAST(i AS UBIGINT) FROM uhugeints ORDER BY i +-- +ok +== +SELECT i::FLOAT FROM uhugeints ORDER BY i +-- +ok +== +SELECT i::DOUBLE FROM uhugeints ORDER BY i +-- +ok +== +SELECT i::BOOL FROM uhugeints ORDER BY i +-- +ok +== +SELECT i::VARCHAR FROM uhugeints ORDER BY i +-- +ok +== +CREATE TABLE strings AS SELECT * FROM (VALUES (' '), ('blablabla'), ('-1000000000000000000000000000000000000000'), ('0'), ('1'), ('340282366920938463463374607431768211455'), ('1000000000000000000000000000000000000000')) tbl(s) +-- +ok +== +SELECT s::UHUGEINT FROM strings +-- +ok +== +SELECT TRY_CAST(s AS UHUGEINT) FROM strings +-- +ok +== +SELECT i::DECIMAL(3,0)::UHUGEINT FROM uhugeints ORDER BY i +-- +ok +== +SELECT i::DECIMAL(9,0)::UHUGEINT FROM uhugeints ORDER BY i +-- +ok +== +SELECT i::DECIMAL(18,0)::UHUGEINT FROM uhugeints ORDER BY i +-- +ok +== +SELECT i::DECIMAL(38,0)::UHUGEINT FROM uhugeints ORDER BY i +-- +ok +== +SELECT TRY_CAST(i AS DECIMAL(3,0))::UHUGEINT FROM uhugeints ORDER BY i +-- +ok +== +SELECT TRY_CAST(i AS DECIMAL(9,0))::UHUGEINT FROM uhugeints ORDER BY i +-- +ok +== +SELECT TRY_CAST(i AS DECIMAL(18,0))::UHUGEINT FROM uhugeints ORDER BY i +-- +ok +== +SELECT TRY_CAST(i AS DECIMAL(38,0))::UHUGEINT FROM uhugeints ORDER BY i +-- +ok +== diff --git a/parser/testdata/corpus/sql/types/numeric/uinteger_try_cast.test b/parser/testdata/corpus/sql/types/numeric/uinteger_try_cast.test new file mode 100644 index 0000000..59824b9 --- /dev/null +++ b/parser/testdata/corpus/sql/types/numeric/uinteger_try_cast.test @@ -0,0 +1,129 @@ +# source: test/sql/types/numeric/uinteger_try_cast.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +CREATE TABLE uintegers AS SELECT i::UINTEGER i FROM (VALUES (0), (4294967295)) tbl(i) +-- +ok +== +SELECT i::UTINYINT FROM uintegers ORDER BY i +-- +ok +== +SELECT TRY_CAST(i AS UTINYINT) FROM uintegers ORDER BY i +-- +ok +== +SELECT i::USMALLINT FROM uintegers ORDER BY i +-- +ok +== +SELECT TRY_CAST(i AS USMALLINT) FROM uintegers ORDER BY i +-- +ok +== +SELECT i::UBIGINT FROM uintegers ORDER BY i +-- +ok +== +SELECT i::TINYINT FROM uintegers ORDER BY i +-- +ok +== +SELECT TRY_CAST(i AS TINYINT) FROM uintegers ORDER BY i +-- +ok +== +SELECT i::SMALLINT FROM uintegers ORDER BY i +-- +ok +== +SELECT TRY_CAST(i AS SMALLINT) FROM uintegers ORDER BY i +-- +ok +== +SELECT i::INTEGER FROM uintegers ORDER BY i +-- +ok +== +SELECT TRY_CAST(i AS INTEGER) FROM uintegers ORDER BY i +-- +ok +== +SELECT i::BIGINT FROM uintegers ORDER BY i +-- +ok +== +SELECT i::HUGEINT FROM uintegers ORDER BY i +-- +ok +== +SELECT i::FLOAT FROM uintegers ORDER BY i +-- +ok +== +SELECT i::DOUBLE FROM uintegers ORDER BY i +-- +ok +== +SELECT i::BOOL FROM uintegers ORDER BY i +-- +ok +== +SELECT i::VARCHAR FROM uintegers ORDER BY i +-- +ok +== +CREATE TABLE strings AS SELECT * FROM (VALUES (' '), ('blablabla'), ('-1000'), ('-1'), ('-0'), ('0'), ('4294967295'), ('10000000000')) tbl(s) +-- +ok +== +SELECT s::UINTEGER FROM strings +-- +ok +== +SELECT TRY_CAST(s AS UINTEGER) FROM strings +-- +ok +== +SELECT i::DECIMAL(3,0)::UINTEGER FROM uintegers ORDER BY i +-- +ok +== +SELECT i::DECIMAL(9,0)::UINTEGER FROM uintegers ORDER BY i +-- +ok +== +SELECT i::DECIMAL(18,0)::UINTEGER FROM uintegers ORDER BY i +-- +ok +== +SELECT i::DECIMAL(38,0)::UINTEGER FROM uintegers ORDER BY i +-- +ok +== +SELECT i::DECIMAL(18,9)::UINTEGER FROM uintegers ORDER BY i +-- +ok +== +SELECT i::DECIMAL(38,29)::UINTEGER FROM uintegers ORDER BY i +-- +ok +== +SELECT TRY_CAST(i AS DECIMAL(3,0))::UINTEGER FROM uintegers ORDER BY i +-- +ok +== +SELECT TRY_CAST(i AS DECIMAL(9,0))::UINTEGER FROM uintegers ORDER BY i +-- +ok +== +SELECT TRY_CAST(i AS DECIMAL(18,9))::UINTEGER FROM uintegers ORDER BY i +-- +ok +== +SELECT TRY_CAST(i AS DECIMAL(38,29))::UINTEGER FROM uintegers ORDER BY i +-- +ok +== diff --git a/parser/testdata/corpus/sql/types/numeric/usmallint_try_cast.test b/parser/testdata/corpus/sql/types/numeric/usmallint_try_cast.test new file mode 100644 index 0000000..0f2227b --- /dev/null +++ b/parser/testdata/corpus/sql/types/numeric/usmallint_try_cast.test @@ -0,0 +1,125 @@ +# source: test/sql/types/numeric/usmallint_try_cast.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +CREATE TABLE usmallints AS SELECT i::USMALLINT i FROM (VALUES (0), (65535)) tbl(i) +-- +ok +== +SELECT i::UTINYINT FROM usmallints ORDER BY i +-- +ok +== +SELECT TRY_CAST(i AS UTINYINT) FROM usmallints ORDER BY i +-- +ok +== +SELECT i::UINTEGER FROM usmallints ORDER BY i +-- +ok +== +SELECT i::UBIGINT FROM usmallints ORDER BY i +-- +ok +== +SELECT i::TINYINT FROM usmallints ORDER BY i +-- +ok +== +SELECT TRY_CAST(i AS TINYINT) FROM usmallints ORDER BY i +-- +ok +== +SELECT i::SMALLINT FROM usmallints ORDER BY i +-- +ok +== +SELECT TRY_CAST(i AS SMALLINT) FROM usmallints ORDER BY i +-- +ok +== +SELECT i::INTEGER FROM usmallints ORDER BY i +-- +ok +== +SELECT i::BIGINT FROM usmallints ORDER BY i +-- +ok +== +SELECT i::HUGEINT::USMALLINT FROM usmallints ORDER BY i +-- +ok +== +SELECT i::FLOAT FROM usmallints ORDER BY i +-- +ok +== +SELECT i::DOUBLE FROM usmallints ORDER BY i +-- +ok +== +SELECT i::BOOL FROM usmallints ORDER BY i +-- +ok +== +SELECT i::VARCHAR FROM usmallints ORDER BY i +-- +ok +== +CREATE TABLE strings AS SELECT * FROM (VALUES (' '), ('blablabla'), ('-1000'), ('-1'), ('-0'), ('0'), ('65535'), ('100000')) tbl(s) +-- +ok +== +SELECT s::USMALLINT FROM strings +-- +ok +== +SELECT TRY_CAST(s AS USMALLINT) FROM strings +-- +ok +== +SELECT i::DECIMAL(3,0)::USMALLINT FROM usmallints ORDER BY i +-- +ok +== +SELECT i::DECIMAL(9,0)::USMALLINT FROM usmallints ORDER BY i +-- +ok +== +SELECT i::DECIMAL(18,0)::USMALLINT FROM usmallints ORDER BY i +-- +ok +== +SELECT i::DECIMAL(38,0)::USMALLINT FROM usmallints ORDER BY i +-- +ok +== +SELECT i::DECIMAL(9,5)::USMALLINT FROM usmallints ORDER BY i +-- +ok +== +SELECT i::DECIMAL(18,14)::USMALLINT FROM usmallints ORDER BY i +-- +ok +== +SELECT i::DECIMAL(38,34)::USMALLINT FROM usmallints ORDER BY i +-- +ok +== +SELECT TRY_CAST(i AS DECIMAL(3,0))::USMALLINT FROM usmallints ORDER BY i +-- +ok +== +SELECT TRY_CAST(i AS DECIMAL(9,5))::USMALLINT FROM usmallints ORDER BY i +-- +ok +== +SELECT TRY_CAST(i AS DECIMAL(18,14))::USMALLINT FROM usmallints ORDER BY i +-- +ok +== +SELECT TRY_CAST(i AS DECIMAL(38,34))::USMALLINT FROM usmallints ORDER BY i +-- +ok +== diff --git a/parser/testdata/corpus/sql/types/numeric/utinyint_try_cast.test b/parser/testdata/corpus/sql/types/numeric/utinyint_try_cast.test new file mode 100644 index 0000000..d08feef --- /dev/null +++ b/parser/testdata/corpus/sql/types/numeric/utinyint_try_cast.test @@ -0,0 +1,121 @@ +# source: test/sql/types/numeric/utinyint_try_cast.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +CREATE TABLE utinyints AS SELECT i::UTINYINT i FROM (VALUES (0), (255)) tbl(i) +-- +ok +== +SELECT i::USMALLINT FROM utinyints ORDER BY i +-- +ok +== +SELECT i::UINTEGER FROM utinyints ORDER BY i +-- +ok +== +SELECT i::UBIGINT FROM utinyints ORDER BY i +-- +ok +== +SELECT i::TINYINT FROM utinyints ORDER BY i +-- +ok +== +SELECT TRY_CAST(i AS TINYINT) FROM utinyints ORDER BY i +-- +ok +== +SELECT i::SMALLINT FROM utinyints ORDER BY i +-- +ok +== +SELECT i::INTEGER FROM utinyints ORDER BY i +-- +ok +== +SELECT i::BIGINT FROM utinyints ORDER BY i +-- +ok +== +SELECT i::HUGEINT FROM utinyints ORDER BY i +-- +ok +== +SELECT i::FLOAT FROM utinyints ORDER BY i +-- +ok +== +SELECT i::DOUBLE FROM utinyints ORDER BY i +-- +ok +== +SELECT i::BOOL FROM utinyints ORDER BY i +-- +ok +== +SELECT i::VARCHAR FROM utinyints ORDER BY i +-- +ok +== +CREATE TABLE strings AS SELECT * FROM (VALUES (' '), ('blablabla'), ('-1000'), ('-1'), ('-0'), ('0'), ('255'), ('1000')) tbl(s) +-- +ok +== +SELECT s::UTINYINT FROM strings +-- +ok +== +SELECT TRY_CAST(s AS UTINYINT) FROM strings +-- +ok +== +SELECT i::DECIMAL(3,0)::UTINYINT FROM utinyints ORDER BY i +-- +ok +== +SELECT i::DECIMAL(9,0)::UTINYINT FROM utinyints ORDER BY i +-- +ok +== +SELECT i::DECIMAL(18,0)::UTINYINT FROM utinyints ORDER BY i +-- +ok +== +SELECT i::DECIMAL(38,0)::UTINYINT FROM utinyints ORDER BY i +-- +ok +== +SELECT i::DECIMAL(3,1)::UTINYINT FROM utinyints ORDER BY i +-- +ok +== +SELECT i::DECIMAL(9,7)::UTINYINT FROM utinyints ORDER BY i +-- +ok +== +SELECT i::DECIMAL(18,16)::UTINYINT FROM utinyints ORDER BY i +-- +ok +== +SELECT i::DECIMAL(38,36)::UTINYINT FROM utinyints ORDER BY i +-- +ok +== +SELECT TRY_CAST(i AS DECIMAL(3,1))::UTINYINT FROM utinyints ORDER BY i +-- +ok +== +SELECT TRY_CAST(i AS DECIMAL(9,7))::UTINYINT FROM utinyints ORDER BY i +-- +ok +== +SELECT TRY_CAST(i AS DECIMAL(18,16))::UTINYINT FROM utinyints ORDER BY i +-- +ok +== +SELECT TRY_CAST(i AS DECIMAL(38,36))::UTINYINT FROM utinyints ORDER BY i +-- +ok +== diff --git a/parser/testdata/corpus/sql/types/string/test_big_strings.test b/parser/testdata/corpus/sql/types/string/test_big_strings.test new file mode 100644 index 0000000..d04b5e9 --- /dev/null +++ b/parser/testdata/corpus/sql/types/string/test_big_strings.test @@ -0,0 +1,17 @@ +# source: test/sql/types/string/test_big_strings.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +INSERT INTO test VALUES ('aaaaaaaaaa') +-- +ok +== +INSERT INTO test SELECT a||a||a||a||a||a||a||a||a||a FROM test WHERE LENGTH(a)=(SELECT MAX(LENGTH(a)) FROM test) +-- +ok +== +SELECT LENGTH(a) FROM test ORDER BY 1 +-- +ok +== diff --git a/parser/testdata/corpus/sql/types/string/test_unicode.test b/parser/testdata/corpus/sql/types/string/test_unicode.test new file mode 100644 index 0000000..937ec2f --- /dev/null +++ b/parser/testdata/corpus/sql/types/string/test_unicode.test @@ -0,0 +1,41 @@ +# source: test/sql/types/string/test_unicode.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +CREATE TABLE emojis(id INTEGER, s VARCHAR); +-- +ok +== +INSERT INTO emojis VALUES (1, '🦆'), (2, '🦆🍞🦆') +-- +ok +== +SELECT * FROM emojis ORDER BY id +-- +ok +== +SELECT substring(s, 1, 1), substring(s, 2, 1) FROM emojis ORDER BY id +-- +ok +== +SELECT substring(decode('u\xD5\x8D1'::BLOB)::VARCHAR, -1); +-- +ok +== +SELECT substring('u🦆', -2, 1); +-- +ok +== +SELECT substring('A3🦤u🦆f', -3, 3); +-- +ok +== +SELECT substring('🦤🦆f', -3, 2); +-- +ok +== +SELECT length(s) FROM emojis ORDER BY id +-- +ok +== diff --git a/parser/testdata/corpus/sql/types/struct/create_qualified_type_array.test b/parser/testdata/corpus/sql/types/struct/create_qualified_type_array.test new file mode 100644 index 0000000..3d02dfa --- /dev/null +++ b/parser/testdata/corpus/sql/types/struct/create_qualified_type_array.test @@ -0,0 +1,89 @@ +# source: test/sql/types/struct/create_qualified_type_array.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +create type u as struct (i int, j int); +-- +ok +== +select cast (null as huh.what.u array); +-- +ok +== +select cast (null as what.u array); +-- +ok +== +select cast (null as u array); +-- +ok +== +select cast (null as main.u); +-- +ok +== +select cast (null as main.u[]); +-- +ok +== +select cast (null as main.u ARRAY); +-- +ok +== +select cast (null as SETOF main.u ARRAY); +-- +ok +== +select cast (null as main.u ARRAY[1]); +-- +ok +== +create or replace table i (j struct(i double, j double)); +-- +ok +== +insert into i values ({'i': 1.0, 'j': 2.0}); +-- +ok +== +select j::main.u from i; +-- +ok +== +select j::main.u[] from i; +-- +ok +== +select cast (null as u array[1]); +-- +ok +== +select cast (null as u []); +-- +ok +== +CREATE SCHEMA schema2; +-- +ok +== +checkpoint; +-- +ok +== +use schema2; +-- +ok +== +create type u2 as struct(i int, j int); +-- +ok +== +select cast (null as u2 []); +-- +ok +== +use main; +-- +ok +== diff --git a/parser/testdata/corpus/sql/types/struct/create_type_struct.test b/parser/testdata/corpus/sql/types/struct/create_type_struct.test new file mode 100644 index 0000000..9066811 --- /dev/null +++ b/parser/testdata/corpus/sql/types/struct/create_type_struct.test @@ -0,0 +1,37 @@ +# source: test/sql/types/struct/create_type_struct.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +CREATE TYPE app.item AS STRUCT ( + id uuid, + code UINTEGER +); +-- +ok +== +CREATE TYPE app.product as STRUCT ( + id uuid, + items app.item[] +); +-- +ok +== +CREATE SCHEMA app2; +-- +ok +== +CREATE TYPE app2.item AS STRUCT ( + id uuid, + code UINTEGER +); +-- +ok +== +CREATE TYPE app2.product as STRUCT ( + id uuid, + items item[] +); +-- +ok +== diff --git a/parser/testdata/corpus/sql/types/struct/empty_struct.test b/parser/testdata/corpus/sql/types/struct/empty_struct.test new file mode 100644 index 0000000..b5abebe --- /dev/null +++ b/parser/testdata/corpus/sql/types/struct/empty_struct.test @@ -0,0 +1,101 @@ +# source: test/sql/types/struct/empty_struct.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +SELECT row(), struct_pack() +-- +ok +== +SELECT {}, typeof({}) +-- +ok +== +SELECT typeof(row()) +-- +ok +== +SELECT typeof(struct_pack()) +-- +ok +== +SELECT typeof(NULL::STRUCT) +-- +ok +== +SELECT NULL::STRUCT() +-- +error: Parser Error: syntax error at or near ")" +== +SELECT NULL::STRUCT, row()::STRUCT +-- +ok +== +CREATE TABLE t(i INTEGER, s STRUCT) +-- +ok +== +INSERT INTO t VALUES (1, row()), (2, NULL), (3, row()) +-- +ok +== +SELECT i, s FROM t ORDER BY i +-- +ok +== +SELECT count(*) FROM t WHERE s IS NOT NULL +-- +ok +== +SELECT i FROM t ORDER BY s, i +-- +ok +== +SELECT s, count(*) FROM t WHERE s IS NOT NULL GROUP BY s +-- +ok +== +SELECT count(*) FROM (SELECT DISTINCT s FROM t) +-- +ok +== +SELECT row() = row(), row() IS NOT DISTINCT FROM row() +-- +ok +== +SELECT t1.i, t2.i, t1.s FROM t t1 JOIN t t2 USING (s) WHERE t1.s IS NOT NULL AND t1.i < t2.i ORDER BY 1, 2 +-- +ok +== +SELECT {'a': struct_pack(), 'b': 1}, [struct_pack(), struct_pack()], typeof({'a': struct_pack()}) +-- +ok +== +SELECT struct_pack()::VARCHAR +-- +ok +== +SELECT struct_concat(row(), row()), struct_concat(row(), {'x': 1}), struct_concat({'x': 1}, row()) +-- +ok +== +SELECT struct_concat(row(), row(1, 2)) +-- +ok +== +SELECT struct_contains(row(), 'a'), struct_contains(row(), 5) +-- +ok +== +SELECT struct_extract(row(), 'a') +-- +ok +== +SELECT row()[1] +-- +ok +== +SELECT unnest(row()) +-- +ok +== diff --git a/parser/testdata/corpus/sql/types/struct/inet_struct_comparison.test b/parser/testdata/corpus/sql/types/struct/inet_struct_comparison.test new file mode 100644 index 0000000..e23df44 --- /dev/null +++ b/parser/testdata/corpus/sql/types/struct/inet_struct_comparison.test @@ -0,0 +1,35 @@ +# source: test/sql/types/struct/inet_struct_comparison.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +CREATE TABLE t1(c0 INT, c1 INET); +-- +ok +== +INSERT INTO t1(c0, c1) VALUES (1, '192.168.1.1'); +-- +ok +== +SELECT ((NULL, t1.c0, NULL) IS DISTINCT FROM (t1.c1)) FROM t1; +-- +ok +== +SELECT * FROM t1 WHERE ((NULL, t1.c0, NULL) IS DISTINCT FROM (t1.c1)); +-- +ok +== +SELECT * +FROM t1 +WHERE ((NULL, t1.c0, NULL) IS DISTINCT FROM (t1.c1)) +UNION ALL +SELECT * +FROM t1 +WHERE (NOT ((NULL, t1.c0, NULL) IS DISTINCT FROM (t1.c1))) +UNION ALL +SELECT * +FROM t1 +WHERE ((((NULL, t1.c0, NULL)<>(t1.c1))) IS NULL); +-- +ok +== diff --git a/parser/testdata/corpus/sql/types/struct/nested_struct_projection_pushdown.test b/parser/testdata/corpus/sql/types/struct/nested_struct_projection_pushdown.test new file mode 100644 index 0000000..feb8f36 --- /dev/null +++ b/parser/testdata/corpus/sql/types/struct/nested_struct_projection_pushdown.test @@ -0,0 +1,152 @@ +# source: test/sql/types/struct/nested_struct_projection_pushdown.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +CREATE OR REPLACE TABLE test_structs( + id INT, + s STRUCT( + name STRUCT( + v VARCHAR, + id INT + ), + nested_struct STRUCT( + a integer, + b bool + ) + ) +); +-- +ok +== +CREATE OR REPLACE TABLE test_structs( + id INT, + s VARIANT +); +-- +ok +== +INSERT INTO test_structs +VALUES (1, {'name': {'v': 'Row 1', 'id': 1}, 'nested_struct': {'a': 42, 'b': true}}), + (2, NULL), + (3, {'name': {'v': 'Row 3', 'id': 3}, 'nested_struct': {'a': 84, 'b': NULL}}), + (4, {'name': NULL, 'nested_struct': {'a': NULL, 'b': false}}); +-- +ok +== +COPY test_structs TO '{TEST_DIR}/test_structs.parquet' +-- +ok +== +SELECT s.nested_struct FROM {source} +-- +error: Parser Error: syntax error at or near "{" +== +SELECT s.nested_struct::STRUCT(b BOOL, a INTEGER) FROM {source} +-- +error: Parser Error: syntax error at or near "{" +== +select s.nested_struct::STRUCT(b INTEGER, a BIGINT) from {source} +-- +error: Parser Error: syntax error at or near "{" +== +SELECT s.nested_struct.a FROM {source} +-- +error: Parser Error: syntax error at or near "{" +== +SELECT s.nested_struct.a::BIGINT FROM {source} +-- +error: Parser Error: syntax error at or near "{" +== +SELECT s.nested_struct.a, s.name.v FROM {source} +-- +error: Parser Error: syntax error at or near "{" +== +SELECT s.nested_struct.a, s.nested_struct.b, s.nested_struct.a, s.nested_struct, id FROM {source} +-- +error: Parser Error: syntax error at or near "{" +== +SELECT s.nested_struct.a::BIGINT, s.nested_struct.b, s.nested_struct.a::TINYINT, id FROM {source} +-- +error: Parser Error: syntax error at or near "{" +== +SELECT s.nested_struct.a, s.nested_struct FROM {source} +-- +error: Parser Error: syntax error at or near "{" +== +SELECT s.nested_struct, s.nested_struct.a FROM {source} +-- +error: Parser Error: syntax error at or near "{" +== +SELECT s.nested_struct, s.nested_struct.a::VARCHAR FROM {source} +-- +error: Parser Error: syntax error at or near "{" +== +SELECT s.name.id, s.nested_struct.b, FROM {source} +-- +error: Parser Error: syntax error at or near "{" +== +SELECT s.name.v FROM {source} WHERE s.nested_struct.b +-- +error: Parser Error: syntax error at or near "{" +== +CREATE OR REPLACE TABLE test_structs_nested(id INT, base STRUCT(s STRUCT(name STRUCT(v VARCHAR, id INT), nested_struct STRUCT(a integer, b bool)))); +-- +ok +== +CREATE OR REPLACE TABLE test_structs_nested(id INT, base VARIANT); +-- +ok +== +INSERT INTO test_structs_nested +VALUES (1, {'s': {'name': {'v': 'Row 1', 'id': 1}, 'nested_struct': {'a': 42, 'b': true}}}), + (2, NULL), + (3, {'s': {'name': {'v': 'Row 3', 'id': 3}, 'nested_struct': {'a': 84, 'b': NULL}}}), + (4, {'s': {'name': NULL, 'nested_struct': {'a': NULL, 'b': false}}}); +-- +ok +== +COPY test_structs_nested TO '{TEST_DIR}/test_structs.parquet' +-- +ok +== +SELECT base.s.nested_struct FROM {source} +-- +error: Parser Error: syntax error at or near "{" +== +SELECT base.s.nested_struct.a FROM {source} +-- +error: Parser Error: syntax error at or near "{" +== +SELECT base.s.nested_struct.a, base.s.name.v FROM {source} +-- +error: Parser Error: syntax error at or near "{" +== +SELECT base.s.nested_struct.a, base.s.nested_struct.b, base.s.nested_struct FROM {source} +-- +error: Parser Error: syntax error at or near "{" +== +SELECT base.s.nested_struct.a, base.s.nested_struct FROM {source} +-- +error: Parser Error: syntax error at or near "{" +== +SELECT base.s.nested_struct.a, base.s FROM {source} +-- +error: Parser Error: syntax error at or near "{" +== +SELECT base.s.nested_struct.a, variant_normalize(base.s) FROM {source} +-- +error: Parser Error: syntax error at or near "{" +== +SELECT base.s.nested_struct, base.s.nested_struct.a FROM {source} +-- +error: Parser Error: syntax error at or near "{" +== +SELECT base.s.name.id, base.s.nested_struct.b, FROM {source} +-- +error: Parser Error: syntax error at or near "{" +== +SELECT base.s.name.v FROM {source} WHERE base.s.nested_struct.b +-- +error: Parser Error: syntax error at or near "{" +== diff --git a/parser/testdata/corpus/sql/types/struct/nested_structs.test b/parser/testdata/corpus/sql/types/struct/nested_structs.test new file mode 100644 index 0000000..f603769 --- /dev/null +++ b/parser/testdata/corpus/sql/types/struct/nested_structs.test @@ -0,0 +1,55 @@ +# source: test/sql/types/struct/nested_structs.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +CREATE TABLE a(c ROW(i ROW(a INTEGER), j INTEGER)); +-- +ok +== +INSERT INTO a VALUES ({ + 'i': { + 'a': 3 + }, + 'j': 4 +}) +-- +ok +== +SELECT ((c).i).a FROM a +-- +ok +== +INSERT INTO a VALUES (ROW(ROW(NULL), 1)) +-- +ok +== +INSERT INTO a VALUES (ROW(ROW(1), NULL)) +-- +ok +== +INSERT INTO a VALUES (ROW(NULL, 1)) +-- +ok +== +CREATE TABLE b AS SELECT { + 'a': { + 'a': 1, + 'b': 'hello' + } +} c; +-- +ok +== +SELECT (c).a FROM b +-- +ok +== +INSERT INTO a VALUES (ROW(1, 2)) +-- +ok +== +INSERT INTO a VALUES (ROW(ROW(1, 2, 3), 1)) +-- +ok +== diff --git a/parser/testdata/corpus/sql/types/struct/remap_struct.test b/parser/testdata/corpus/sql/types/struct/remap_struct.test new file mode 100644 index 0000000..2c1a501 --- /dev/null +++ b/parser/testdata/corpus/sql/types/struct/remap_struct.test @@ -0,0 +1,170 @@ +# source: test/sql/types/struct/remap_struct.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +SELECT remap_struct({'i': 1, 'j': 2}, NULL::ROW(v2 INT), NULL, {'v2': NULL::INTEGER}); +-- +ok +== +select remap_struct(42, NULL::ROW(v1 INT, v2 INT, v3 INT), {'v1': 'j', 'v3': 'i'}, {'v2': NULL::INTEGER}) +-- +ok +== +SELECT remap_struct({'i': 1, 'j': 2}, NULL::ROW(v1 INT, v2 INT, v3 INT), {'v1': 'j', 'v3': 'i'}, {'v2': NULL::INTEGER}); +-- +ok +== +SELECT remap_struct({'i': 1, 'j': 2}, NULL::ROW(v1 VARCHAR, v2 VARCHAR, v3 VARCHAR), {'v1': 'j', 'v3': 'i'}, {'v2': 'hello'}); +-- +ok +== +SELECT remap_struct( + { + 'i': 1, + 'j': { + 'x': 42, + 'z': 100 + } + }, -- data + NULL::ROW( + v1 INT, + v2 STRUCT( + x INT, + y INT, + z INT + ), + v3 VARCHAR + ), -- target type + { + 'v1': 'i', + 'v2': ROW( + 'j', { + 'x': 'x', + 'z': 'z' + } + ) + }, -- remapping data -> target_type + { + 'v2': { + 'y': NULL::INT + }, + 'v3': NULL::VARCHAR + } +); -- defaults +-- +ok +== +SELECT remap_struct( + {'i': 1, 'j': {'x': 42, 'y': 100}}, + NULL::ROW(v1 INT, v2 STRUCT(x INT, y INT, z STRUCT(a INT, b INT))), + {'v1': 'i', 'v2': ROW('j', {'x': 'x', 'y': 'y'})}, + {'v2': {'z': NULL::STRUCT(a INT, b INT)}}); +-- +ok +== +SELECT remap_struct( + {'i': 1, 'j': {'x': 42, 'y': 100, 'z': 1000}}, + NULL::ROW(v1 INT, v2 STRUCT(x INT, z INT), v3 VARCHAR), + {'v1': 'i', 'v2': ROW('j', {'x': 'x', 'z': 'z'})}, + {'v3': NULL::VARCHAR}); +-- +ok +== +SELECT remap_struct( + {'i': 1}, + NULL::ROW(v1 INT, v2 STRUCT(x INT, y INT, z INT), v3 VARCHAR), + {'v1': 'i'}, + {'v2': {'x': NULL::INT, 'y': NULL::INT, 'z': NULL::INT}, 'v3': NULL::VARCHAR}); +-- +ok +== +CREATE TABLE structs(struct_val STRUCT(i INT, j VARCHAR)); +-- +ok +== +INSERT INTO structs VALUES ({'i': 42, 'j': 'hello world this is my string'}), (NULL), ({'i': 100, 'j': NULL}), ({'i': NULL, 'j': 'string string string'}); +-- +ok +== +SELECT remap_struct(struct_val, NULL::ROW(v1 VARCHAR, v2 VARCHAR, v3 VARCHAR), {'v1': 'j', 'v3': 'i'}, {'v2': 'hello'}) +FROM structs +-- +ok +== +SELECT remap_struct(struct_val, NULL::ROW(v1 VARCHAR, v2 VARCHAR, v3 VARCHAR), {'v1': 'j', 'v3': 'i'}, {'v2': NULL::VARCHAR}) +FROM structs +-- +ok +== +SELECT remap_struct({'i': 1, 'j': 2}, NULL::ROW(v1 INT, v2 INT), {'v1': 'j', 'v2': 'i'}, NULL); +-- +ok +== +SELECT remap_struct({'i': 1, 'j': 2}, NULL::ROW(v1 VARCHAR), {'v2': 'i'}, NULL); +-- +ok +== +SELECT remap_struct({'i': 1, 'j': 2}, NULL, {'v2': 'i'}, NULL); +-- +ok +== +SELECT remap_struct(ROW(1, 2), NULL::ROW(v1 VARCHAR), {'v2': 'i'}, NULL); +-- +ok +== +SELECT remap_struct({'i': 1, 'j': 2}, NULL::ROW(v1 VARCHAR), {'v1': 'k'}, NULL); +-- +ok +== +SELECT remap_struct({'i': 1, 'j': 2}, NULL::ROW(v1 VARCHAR), {'v1': 'i'}, {'v1': NULL::VARCHAR}); +-- +ok +== +SELECT remap_struct({'i': 1, 'j': 2}, NULL::ROW(v1 VARCHAR, v2 VARCHAR), {'v1': 'i'}, NULL); +-- +ok +== +SELECT remap_struct(struct_val, NULL::ROW(v1 VARCHAR, v2 VARCHAR, v3 VARCHAR), {'v1': 'j', 'v3': 'i'}, struct_val) +FROM structs +-- +ok +== +SELECT remap_struct({'i': 1, 'j': 2}, NULL::ROW(v1 INT, v2 INT, v3 INT), {'v1': 'j', 'v3': 'i'}, {'v2': 'hello'}); +-- +ok +== +SELECT remap_struct( + {'i': 1, 'j': {'x': 42, 'z': 100}}, + NULL::ROW(v1 INT, v2 STRUCT(x INT, y INT), v3 VARCHAR), + {'v1': 'i', 'v2': ROW('j', {'x': 'x', 'y': 'z'})}, + {'v2': {'y': NULL::INT}, 'v3': NULL::VARCHAR}); +-- +ok +== +SELECT remap_struct( + {'i': 1, 'j': {'x': 42, 'z': 100}}, + NULL::ROW(v1 INT, v2 STRUCT(x INT, y INT), v3 VARCHAR), + {'v1': 'i', 'v2': ROW('j', {'x': 'x', 'y': 'z'})}, + {'v2': NULL, 'v3': NULL::VARCHAR}); +-- +ok +== +SELECT remap_struct( + [ + { + 'i': 1, + 'j': 42 + } + ], + NULL::STRUCT(k INT)[], + {'list': 'list'}, + { + 'list': { + 'k': NULL + } + } + ); +-- +ok +== diff --git a/parser/testdata/corpus/sql/types/struct/remap_struct_in_list.test b/parser/testdata/corpus/sql/types/struct/remap_struct_in_list.test new file mode 100644 index 0000000..b25c6ac --- /dev/null +++ b/parser/testdata/corpus/sql/types/struct/remap_struct_in_list.test @@ -0,0 +1,64 @@ +# source: test/sql/types/struct/remap_struct_in_list.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +SELECT remap_struct( + [ + { + 'i': 1, + 'j': { + 'x': 42, + 'z': 100 + } + } + ], -- data + NULL::STRUCT( + v1 INT, + v2 STRUCT( + x INT, + y INT, + z INT + ), + v3 VARCHAR + )[], -- target type + { + 'list': ROW( + 'list', { + 'v1': 'i', + 'v2': ROW( + 'j', { + 'x': 'x', + 'z': 'z' + } + ) + } + ) + }, -- remapping data -> target_type + { + 'list': { + 'v2': { + 'y': NULL::INT + }, + 'v3': NULL::VARCHAR + } + } +); -- defaults +-- +ok +== +CREATE TABLE large_list(s STRUCT(i INTEGER)[]); +-- +ok +== +INSERT INTO large_list (SELECT LIST(CASE WHEN i%2=0 THEN {'i': i} ELSE NULL END) FROM range(5000) t(i)); +-- +ok +== +SELECT COUNT(*), COUNT(j), SUM(j) +FROM ( + SELECT UNNEST(remap_struct(s, NULL::ROW(j INTEGER)[], {'list': ROW('list', {'j': 'i'})}, NULL), recursive := True) FROM large_list +) +-- +ok +== diff --git a/parser/testdata/corpus/sql/types/struct/remap_struct_in_map.test b/parser/testdata/corpus/sql/types/struct/remap_struct_in_map.test new file mode 100644 index 0000000..a360b3d --- /dev/null +++ b/parser/testdata/corpus/sql/types/struct/remap_struct_in_map.test @@ -0,0 +1,136 @@ +# source: test/sql/types/struct/remap_struct_in_map.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +SELECT remap_struct( + MAP { + 'my_key1' : { + 'i': 10, + 'j': { + 'x': 42, + 'z': 100 + } + }, + 'my_key2' : { + 'i': 20, + 'j': { + 'x': 21, + 'z': 50 + } + } + }, -- data + NULL::MAP(VARCHAR, STRUCT( + v1 INT, + v2 STRUCT( + x INT, + y INT, + z INT + ), + v3 VARCHAR + )), -- target type + { + 'key': 'key', + 'value': ROW( + 'value', { + 'v1': 'i', + 'v2': ROW( + 'j', { + 'x': 'x', + 'z': 'z' + } + ) + } + ) + }, -- remapping data -> target_type + { + 'value': { + 'v2': { + 'y': NULL::INT + }, + 'v3': NULL::VARCHAR + } + } +); -- defaults +-- +ok +== +SELECT remap_struct( + MAP { + [1,2,3] : 'test', + [6,4,5] : 'world' + }, -- data + NULL::MAP(INT[], VARCHAR), -- target type + { + 'key': 'key', + 'value': 'value' + }, -- remapping data -> target_type + NULL -- defaults +); +-- +ok +== +SELECT remap_struct( + MAP { + [1,2,3] : 'test', + [6,4,5] : 'world' + }, -- data + NULL::MAP(BIGINT[], VARCHAR), -- target type + { + 'key': 'key', + 'value': 'value' + }, -- remapping data -> target_type + NULL -- defaults +); +-- +ok +== +SELECT remap_struct( + MAP { + [1,2,3] : 'test', + [6,4,5] : 'world' + }, -- data + NULL::STRUCT("key" BIGINT[], "value" VARCHAR), -- target type + { + 'key': 'key', + 'value': 'value' + }, -- remapping data -> target_type + NULL -- defaults +); +-- +ok +== +SELECT remap_struct( + MAP { + [1,2,3] : ['test'], + [6,4,5] : ['world'] + }, -- data + NULL::MAP(BIGINT[], MAP(VARCHAR, VARCHAR)), -- target type + { + 'key': 'key', + 'value': 'value' + }, -- remapping data -> target_type + NULL -- defaults +); +-- +ok +== +SELECT remap_struct( + MAP { + [1,2,3] : ['test'], + [6,4,5] : ['world'] + }, -- data + NULL::MAP(INT[], VARCHAR[]), -- target type + { + 'key': ROW( + 'key', { + 'list': 'list' + } + ), + 'value': 'value' + }, -- remapping data -> target_type + NULL -- defaults +); +-- +ok +== diff --git a/parser/testdata/corpus/sql/types/struct/remap_struct_list_source_name.test b/parser/testdata/corpus/sql/types/struct/remap_struct_list_source_name.test new file mode 100644 index 0000000..7259997 --- /dev/null +++ b/parser/testdata/corpus/sql/types/struct/remap_struct_list_source_name.test @@ -0,0 +1,57 @@ +# source: test/sql/types/struct/remap_struct_list_source_name.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +SELECT remap_struct( + [ {'first_name': 'Alice', 'age': 43} ], + NULL::STRUCT(age INTEGER, given_name VARCHAR)[], + { 'list': ROW('list', { 'age': 'age', 'given_name': 'first_name' }) }, + NULL +); +-- +ok +== +SELECT remap_struct( + [ {'first_name': 'Alice', 'age': 43}, {'first_name': 'Bob', 'age': 35} ], + NULL::STRUCT(age INTEGER, given_name VARCHAR)[], + { 'list': ROW('array', { 'age': 'age', 'given_name': 'first_name' }) }, + NULL +); +-- +ok +== +SELECT remap_struct( + [ {'first_name': 'Alice', 'age': 43} ], + NULL::STRUCT(age INTEGER, given_name VARCHAR)[], + { 'list': ROW('bag', { 'age': 'age', 'given_name': 'first_name' }) }, + NULL +); +-- +ok +== +SELECT remap_struct( + [ {'first_name': 'Alice'} ], + NULL::STRUCT(given_name VARCHAR, verified BOOLEAN)[], + { 'list': ROW('array', { 'given_name': 'first_name' }) }, + { 'list': { 'verified': NULL::BOOLEAN } } +); +-- +ok +== +SELECT remap_struct( + {'people': [ {'first_name': 'Alice', 'age': 43}, {'first_name': 'Bob', 'age': 35} ]}, + NULL::STRUCT(people STRUCT(age INTEGER, given_name VARCHAR)[]), + { 'people': ROW('people', { 'list': ROW('array', { 'age': 'age', 'given_name': 'first_name' }) }) }, + NULL +); +-- +ok +== +SELECT COUNT(*), COUNT(j), SUM(j) +FROM ( + SELECT UNNEST(remap_struct(s, NULL::ROW(j INTEGER)[], {'list': ROW('array', {'j': 'i'})}, NULL), recursive := True) FROM large_list +) +-- +ok +== diff --git a/parser/testdata/corpus/sql/types/struct/remap_struct_size.test b/parser/testdata/corpus/sql/types/struct/remap_struct_size.test new file mode 100644 index 0000000..c78c76c --- /dev/null +++ b/parser/testdata/corpus/sql/types/struct/remap_struct_size.test @@ -0,0 +1,39 @@ +# source: test/sql/types/struct/remap_struct_size.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +CREATE TABLE src(col1 STRUCT(i INT, j INT)[]); +-- +ok +== +INSERT INTO src VALUES ([{'i': 1, 'j': 2}]); +-- +ok +== +CREATE TABLE t AS +SELECT remap_struct(col1, NULL::STRUCT(k INTEGER)[], NULL, + struct_pack(list := struct_pack(k := NULL::INTEGER))) AS col1 +FROM src; +-- +ok +== +FROM t ORDER BY ALL +-- +ok +== +INSERT INTO src VALUES ([{'i': 3, 'j': 4}]), ([{'i': 5, 'j': 6}]); +-- +ok +== +CREATE TABLE t2 AS +SELECT remap_struct(col1, NULL::STRUCT(k INTEGER)[], NULL, + struct_pack(list := struct_pack(k := NULL::INTEGER))) AS col1 +FROM src; +-- +ok +== +FROM t2 ORDER BY ALL +-- +ok +== diff --git a/parser/testdata/corpus/sql/types/struct/struct_case.test b/parser/testdata/corpus/sql/types/struct/struct_case.test new file mode 100644 index 0000000..0dc7d05 --- /dev/null +++ b/parser/testdata/corpus/sql/types/struct/struct_case.test @@ -0,0 +1,53 @@ +# source: test/sql/types/struct/struct_case.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +SELECT CASE WHEN 1=1 THEN {'i': 1} ELSE {'i': 2} END +-- +ok +== +SELECT CASE WHEN 1=0 THEN {'i': 1} ELSE {'i': 2} END +-- +ok +== +SELECT CASE WHEN 1=1 THEN NULL ELSE {'i': 2} END +-- +ok +== +SELECT CASE WHEN 1=0 THEN NULL ELSE {'i': NULL} END +-- +ok +== +SELECT i, CASE WHEN i%2=0 THEN {'i': 1} ELSE {'i': 2} END FROM range(6) tbl(i) +-- +ok +== +SELECT i, CASE WHEN i%2=0 THEN {'i': 'hello'} ELSE {'i': 'world'} END FROM range(6) tbl(i) +-- +ok +== +SELECT i, CASE WHEN i%2=0 THEN {'i': 'hello', 'j': {'a': 3, 'b': NULL}} ELSE {'i': 'world', 'j': {'a': 7, 'b': 22}} END FROM range(6) tbl(i) +-- +ok +== +SELECT i, CASE WHEN i%2=0 THEN {'i': [1,2,3]} ELSE {'i': [7,8]} END FROM range(6) tbl(i) +-- +ok +== +SELECT i, CASE WHEN i%2=0 THEN {'i': [1,2,3]} ELSE NULL END FROM range(6) tbl(i) +-- +ok +== +SELECT i, CASE WHEN i%2=0 THEN {'i': [1,2,3]} ELSE {'i': NULL} END FROM range(6) tbl(i) +-- +ok +== +SELECT i, CASE WHEN i%2=0 THEN {'i': [1::INT,2::INT,3::INT]} ELSE {'i': [0::UBIGINT]} END FROM range(6) tbl(i) +-- +ok +== +SELECT i, CASE WHEN i%2=0 THEN {'i': [1,2,3]} ELSE {'i': ['hello']} END FROM range(6) tbl(i) +-- +ok +== diff --git a/parser/testdata/corpus/sql/types/struct/struct_case_insensitivity.test b/parser/testdata/corpus/sql/types/struct/struct_case_insensitivity.test new file mode 100644 index 0000000..d37f41e --- /dev/null +++ b/parser/testdata/corpus/sql/types/struct/struct_case_insensitivity.test @@ -0,0 +1,41 @@ +# source: test/sql/types/struct/struct_case_insensitivity.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +CREATE TABLE tbl AS SELECT ({'HELLO': 3}) col; +-- +ok +== +SELECT col['HELLO'] FROM tbl +-- +ok +== +SELECT col['hello'] FROM tbl +-- +ok +== +SELECT col.hello FROM tbl +-- +ok +== +SELECT "COL"."HELLO" FROM tbl +-- +ok +== +SELECT ({'hello': 3, 'hello': 4}) col; +-- +ok +== +SELECT ({'HELLO': 3, 'HELLO': 4}) col; +-- +ok +== +SELECT ({'HELLO': 3, 'hello': 4}) col; +-- +ok +== +SELECT col['HELL'] FROM tbl +-- +ok +== diff --git a/parser/testdata/corpus/sql/types/struct/struct_cast.test b/parser/testdata/corpus/sql/types/struct/struct_cast.test new file mode 100644 index 0000000..8e57e23 --- /dev/null +++ b/parser/testdata/corpus/sql/types/struct/struct_cast.test @@ -0,0 +1,120 @@ +# source: test/sql/types/struct/struct_cast.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +SELECT {'i': 1, 'j': 2}::ROW(i BIGINT, j VARCHAR); +-- +ok +== +SELECT {'i': NULL, 'j': 'hello'}::ROW(i BIGINT, j VARCHAR); +-- +ok +== +SELECT {'i': NULL, 'j': NULL}::ROW(i BIGINT, j VARCHAR); +-- +ok +== +SELECT NULL::ROW(i BIGINT, j VARCHAR); +-- +ok +== +SELECT ({'i': NULL, 'j': NULL}::ROW(i BIGINT, j VARCHAR))['i']; +-- +ok +== +SELECT ({'i': NULL, 'j': NULL})['i'] +-- +ok +== +SELECT (NULL::ROW(i BIGINT, j VARCHAR))['i']; +-- +ok +== +SELECT {'i': 1, 'j': {'a': 2, 'b': 3}}::ROW(i BIGINT, j ROW(a BIGINT, b VARCHAR)); +-- +ok +== +SELECT {'i': 1, 'j': {'a': NULL, 'b': 3}}::ROW(i BIGINT, j ROW(a BIGINT, b VARCHAR)); +-- +ok +== +SELECT {'i': 1, 'j': {'a': 2, 'b': NULL}}::ROW(i BIGINT, j ROW(a BIGINT, b VARCHAR)); +-- +ok +== +SELECT {'i': 1, 'j': NULL}::ROW(i BIGINT, j ROW(a BIGINT, b VARCHAR)); +-- +ok +== +SELECT ({'i': 1, 'j': NULL}::ROW(i BIGINT, j ROW(a BIGINT, b VARCHAR)))['j']['a']; +-- +ok +== +SELECT NULL::ROW(i BIGINT, j ROW(a BIGINT, b VARCHAR)); +-- +ok +== +CREATE TABLE structs(s ROW(i INTEGER, j INTEGER)) +-- +ok +== +INSERT INTO structs VALUES ({'i': 1, 'j': 2}), ({'i': NULL, 'j': 2}), ({'i': 1, 'j': NULL}), (NULL) +-- +ok +== +SELECT s::ROW(i BIGINT, j VARCHAR) FROM structs +-- +ok +== +CREATE TABLE nested_structs(s ROW(i INTEGER, j ROW(a INTEGER, b INTEGER))) +-- +ok +== +INSERT INTO nested_structs VALUES +({'i': 1, 'j': {'a': 2, 'b': 3}}), +({'i': 1, 'j': {'a': NULL, 'b': 3}}), +({'i': 1, 'j': {'a': 2, 'b': NULL}}), +({'i': 1, 'j': NULL}), +(NULL) +-- +ok +== +SELECT s::ROW(i BIGINT, j ROW(a BIGINT, b VARCHAR)) FROM nested_structs +-- +ok +== +SELECT col::STRUCT(duck INT) +FROM VALUES + ('{"duck": null}'), + ('{"duck": nulL}'), + ('{"duck": nuLl}'), + ('{"duck": nuLL}'), + ('{"duck": nUll}'), + ('{"duck": nUlL}'), + ('{"duck": nULl}'), + ('{"duck": nULL}'), + ('{"duck": Null}'), + ('{"duck": NulL}'), + ('{"duck": NuLl}'), + ('{"duck": NuLL}'), + ('{"duck": NUll}'), + ('{"duck": NUlL}'), + ('{"duck": NULl}'), + ('{"duck": NULL}'), +AS tab(col) +-- +ok +== +SELECT {'i': 42, 'j': 84}::STRUCT(i INT) AS result; +-- +ok +== +SELECT {'i': 42}::STRUCT(i INT, j INT) AS result; +-- +ok +== +SELECT {'a': 7, 'i': 42, 'j': 84, 'k': 42}::STRUCT(m INT, k INT, l INT) AS result; +-- +ok +== diff --git a/parser/testdata/corpus/sql/types/struct/struct_cast_superset.test b/parser/testdata/corpus/sql/types/struct/struct_cast_superset.test new file mode 100644 index 0000000..d2290ac --- /dev/null +++ b/parser/testdata/corpus/sql/types/struct/struct_cast_superset.test @@ -0,0 +1,38 @@ +# source: test/sql/types/struct/struct_cast_superset.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +CREATE TABLE t1 (s1 STRUCT(a INT, b INT)); +-- +ok +== +INSERT INTO t1 VALUES ({a: 42, b: 43}); +-- +ok +== +CREATE TABLE t2 (s1 STRUCT(a INT, c INT)); +-- +ok +== +INSERT INTO t2 VALUES ({a: 100, c: 101}); +-- +ok +== +COPY t1 TO '{TEST_DIR}/struct_cast_t1.parquet' (FORMAT 'parquet'); +-- +ok +== +COPY t2 TO '{TEST_DIR}/struct_cast_t2.parquet' (FORMAT 'parquet'); +-- +ok +== +SELECT * FROM read_parquet('{TEST_DIR}/struct_cast_*.parquet', union_by_name = TRUE); +-- +ok +== +SELECT {'a': {'e1': 42, 'e2': 42}} AS c +UNION ALL BY NAME SELECT {'a': {'e2': 'hello', 'e3': 'world'}, 'b': '100'} AS c; +-- +ok +== diff --git a/parser/testdata/corpus/sql/types/struct/struct_comparison.test b/parser/testdata/corpus/sql/types/struct/struct_comparison.test new file mode 100644 index 0000000..755a793 --- /dev/null +++ b/parser/testdata/corpus/sql/types/struct/struct_comparison.test @@ -0,0 +1,696 @@ +# source: test/sql/types/struct/struct_comparison.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +SELECT {'x': 1} < {'x': 2} +-- +ok +== +SELECT {'x': 1} < {'x': 1} +-- +ok +== +SELECT NULL < {'x': 1} +-- +ok +== +SELECT {'x': 1} < NULL +-- +ok +== +SELECT {'x': 1} <= {'x': 2} +-- +ok +== +SELECT {'x': 1} <= {'x': 1} +-- +ok +== +SELECT NULL <= {'x': 1} +-- +ok +== +SELECT {'x': 1} <= NULL +-- +ok +== +SELECT {'x': 1} = {'x': 2} +-- +ok +== +SELECT {'x': 1} = {'x': 1} +-- +ok +== +SELECT NULL = {'x': 1} +-- +ok +== +SELECT {'x': 1} = NULL +-- +ok +== +SELECT {'x': 1} <> {'x': 2} +-- +ok +== +SELECT {'x': 1} <> {'x': 1} +-- +ok +== +SELECT {'x': 1} <> NULL +-- +ok +== +SELECT NULL <>{'x': 1} +-- +ok +== +SELECT {'x': 1} >= {'x': 2} +-- +ok +== +SELECT {'x': 1} >= {'x': 1} +-- +ok +== +SELECT NULL >= {'x': 1} +-- +ok +== +SELECT {'x': 1} >= NULL +-- +ok +== +SELECT {'x': 1} > {'x': 2} +-- +ok +== +SELECT {'x': 1} > {'x': 1} +-- +ok +== +SELECT NULL > {'x': 1} +-- +ok +== +SELECT {'x': 1} > NULL +-- +ok +== +CREATE VIEW struct_int AS SELECT * FROM (VALUES + ({'x': 1}, {'x': 1}), + ({'x': 1}, {'x': 2}), + ({'x': 2}, {'x': 1}), + (NULL, {'x': 1}), + ({'x': 2}, NULL), + (NULL, NULL) + ) tbl(l, r); +-- +ok +== +SELECT l < r FROM struct_int +-- +ok +== +SELECT l <= r FROM struct_int +-- +ok +== +SELECT l = r FROM struct_int +-- +ok +== +SELECT l <> r FROM struct_int +-- +ok +== +SELECT l >= r FROM struct_int +-- +ok +== +SELECT l > r FROM struct_int +-- +ok +== +SELECT {'x': 'duck'} < {'x': 'goose'} +-- +ok +== +SELECT {'x': 'duck'} < {'x': 'duck'} +-- +ok +== +SELECT NULL < {'x': 'duck'} +-- +ok +== +SELECT {'x': 'duck'} < NULL +-- +ok +== +SELECT {'x': 'duck'} <= {'x': 'goose'} +-- +ok +== +SELECT {'x': 'duck'} <= {'x': 'duck'} +-- +ok +== +SELECT NULL <= {'x': 'duck'} +-- +ok +== +SELECT {'x': 'duck'} <= NULL +-- +ok +== +SELECT {'x': 'duck'} = {'x': 'goose'} +-- +ok +== +SELECT {'x': 'duck'} = {'x': 'duck'} +-- +ok +== +SELECT NULL = {'x': 'duck'} +-- +ok +== +SELECT {'x': 'duck'} = NULL +-- +ok +== +SELECT {'x': 'duck'} <> {'x': 'goose'} +-- +ok +== +SELECT {'x': 'duck'} <> {'x': 'duck'} +-- +ok +== +SELECT NULL <> {'x': 'duck'} +-- +ok +== +SELECT {'x': 'duck'} <> NULL +-- +ok +== +SELECT {'x': 'duck'} >= {'x': 'goose'} +-- +ok +== +SELECT {'x': 'duck'} >= {'x': 'duck'} +-- +ok +== +SELECT NULL >= {'x': 'duck'} +-- +ok +== +SELECT {'x': 'duck'} >= NULL +-- +ok +== +SELECT {'x': 'duck'} > {'x': 'goose'} +-- +ok +== +SELECT {'x': 'duck'} > {'x': 'duck'} +-- +ok +== +SELECT NULL > {'x': 'duck'} +-- +ok +== +SELECT {'x': 'duck'} > NULL +-- +ok +== +CREATE VIEW struct_str AS SELECT * FROM (VALUES + ({'x': 'duck'}, {'x': 'duck'}), + ({'x': 'duck'}, {'x': 'goose'}), + ({'x': 'goose'}, {'x': 'duck'}), + (NULL, {'x': 'duck'}), + ({'x': 'goose'}, NULL), + (NULL, NULL) + ) tbl(l, r); +-- +ok +== +SELECT l < r FROM struct_str +-- +ok +== +SELECT l <= r FROM struct_str +-- +ok +== +SELECT l = r FROM struct_str +-- +ok +== +SELECT l <> r FROM struct_str +-- +ok +== +SELECT l >= r FROM struct_str +-- +ok +== +SELECT l > r FROM struct_str +-- +ok +== +SELECT {'x': 'duck', 'y': 1} < {'x': 'goose', 'y': 2} +-- +ok +== +SELECT {'x': 'duck', 'y': 1} < {'x': 'duck', 'y': 1} +-- +ok +== +SELECT {'x': 'duck', 'y': 1} < {'x': 'duck', 'y': 2} +-- +ok +== +SELECT NULL < {'x': 'duck', 'y': 1} +-- +ok +== +SELECT {'x': 'duck', 'y': 1} < NULL +-- +ok +== +SELECT {'x': 'duck', 'y': 1} <= {'x': 'goose', 'y': 2} +-- +ok +== +SELECT {'x': 'duck', 'y': 1} <= {'x': 'duck', 'y': 1} +-- +ok +== +SELECT {'x': 'duck', 'y': 1} <= {'x': 'duck', 'y': 2} +-- +ok +== +SELECT NULL <= {'x': 'duck', 'y': 1} +-- +ok +== +SELECT {'x': 'duck', 'y': 1} <= NULL +-- +ok +== +SELECT {'x': 'duck', 'y': 1} = {'x': 'goose', 'y': 2} +-- +ok +== +SELECT {'x': 'duck', 'y': 1} = {'x': 'duck', 'y': 1} +-- +ok +== +SELECT NULL = {'x': 'duck', 'y': 1} +-- +ok +== +SELECT {'x': 'duck', 'y': 1} = NULL +-- +ok +== +SELECT {'x': 'duck', 'y': 1} <> {'x': 'goose', 'y': 2} +-- +ok +== +SELECT {'x': 'duck', 'y': 1} <> {'x': 'duck', 'y': 1} +-- +ok +== +SELECT NULL <> {'x': 'duck', 'y': 1} +-- +ok +== +SELECT {'x': 'duck', 'y': 1} <> NULL +-- +ok +== +SELECT {'x': 'duck', 'y': 1} >= {'x': 'goose', 'y': 2} +-- +ok +== +SELECT {'x': 'duck', 'y': 1} >= {'x': 'duck', 'y': 1} +-- +ok +== +SELECT NULL >= {'x': 'duck', 'y': 1} +-- +ok +== +SELECT {'x': 'duck', 'y': 1} >= NULL +-- +ok +== +SELECT {'x': 'duck', 'y': 1} > {'x': 'goose', 'y': 2} +-- +ok +== +SELECT {'x': 'duck', 'y': 1} > {'x': 'duck', 'y': 1} +-- +ok +== +SELECT {'x': 'duck', 'y': 2} > {'x': 'duck', 'y': 1} +-- +ok +== +SELECT NULL > {'x': 'duck', 'y': 1} +-- +ok +== +SELECT {'x': 'duck', 'y': 1} > NULL +-- +ok +== +CREATE VIEW struct_str_int AS SELECT * FROM (VALUES + ({'x': 'duck', 'y': 1}, {'x': 'duck', 'y': 1}), + ({'x': 'duck', 'y': 1}, {'x': 'goose', 'y': 2}), + ({'x': 'goose', 'y': 2}, {'x': 'duck', 'y': 1}), + (NULL, {'x': 'duck', 'y': 1}), + ({'x': 'goose', 'y': 2}, NULL), + (NULL, NULL) + ) tbl(l, r); +-- +ok +== +SELECT l < r FROM struct_str_int +-- +ok +== +SELECT l <= r FROM struct_str_int +-- +ok +== +SELECT l = r FROM struct_str_int +-- +ok +== +SELECT l <> r FROM struct_str_int +-- +ok +== +SELECT l >= r FROM struct_str_int +-- +ok +== +SELECT l > r FROM struct_str_int +-- +ok +== +SELECT {'x': 1, 'y': {'a': 'duck', 'b': 1.5}} < {'x': 2, 'y': {'a': 'goose', 'b': 2.5}} +-- +ok +== +SELECT {'x': 1, 'y': {'a': 'duck', 'b': 1.5}} < {'x': 1, 'y': {'a': 'duck', 'b': 1.5}} +-- +ok +== +SELECT NULL < {'x': 1, 'y': {'a': 'duck', 'b': 1.5}} +-- +ok +== +SELECT {'x': 1, 'y': {'a': 'duck', 'b': 1.5}} < NULL +-- +ok +== +SELECT {'x': 1, 'y': {'a': 'duck', 'b': 1.5}} <= {'x': 2, 'y': {'a': 'goose', 'b': 2.5}} +-- +ok +== +SELECT {'x': 1, 'y': {'a': 'duck', 'b': 1.5}} <= {'x': 1, 'y': {'a': 'duck', 'b': 1.5}} +-- +ok +== +SELECT NULL <= {'x': 1, 'y': {'a': 'duck', 'b': 1.5}} +-- +ok +== +SELECT {'x': 1, 'y': {'a': 'duck', 'b': 1.5}} <= NULL +-- +ok +== +SELECT {'x': 1, 'y': {'a': 'duck', 'b': 1.5}} = {'x': 2, 'y': {'a': 'goose', 'b': 2.5}} +-- +ok +== +SELECT {'x': 1, 'y': {'a': 'duck', 'b': 1.5}} = {'x': 1, 'y': {'a': 'duck', 'b': 1.5}} +-- +ok +== +SELECT NULL = {'x': 1, 'y': {'a': 'duck', 'b': 1.5}} +-- +ok +== +SELECT {'x': 1, 'y': {'a': 'duck', 'b': 1.5}} = NULL +-- +ok +== +SELECT {'x': 1, 'y': {'a': 'duck', 'b': 1.5}} <> {'x': 2, 'y': {'a': 'goose', 'b': 2.5}} +-- +ok +== +SELECT {'x': 1, 'y': {'a': 'duck', 'b': 1.5}} <> {'x': 1, 'y': {'a': 'duck', 'b': 1.5}} +-- +ok +== +SELECT NULL <> {'x': 1, 'y': {'a': 'duck', 'b': 1.5}} +-- +ok +== +SELECT {'x': 1, 'y': {'a': 'duck', 'b': 1.5}} <> NULL +-- +ok +== +SELECT {'x': 1, 'y': {'a': 'duck', 'b': 1.5}} >= {'x': 2, 'y': {'a': 'goose', 'b': 2.5}} +-- +ok +== +SELECT {'x': 1, 'y': {'a': 'duck', 'b': 1.5}} >= {'x': 1, 'y': {'a': 'duck', 'b': 1.5}} +-- +ok +== +SELECT NULL >= {'x': 1, 'y': {'a': 'duck', 'b': 1.5}} +-- +ok +== +SELECT {'x': 1, 'y': {'a': 'duck', 'b': 1.5}} >= NULL +-- +ok +== +SELECT {'x': 1, 'y': {'a': 'duck', 'b': 1.5}} > {'x': 2, 'y': {'a': 'goose', 'b': 2.5}} +-- +ok +== +SELECT {'x': 1, 'y': {'a': 'duck', 'b': 1.5}} > {'x': 1, 'y': {'a': 'duck', 'b': 1.5}} +-- +ok +== +SELECT NULL > {'x': 1, 'y': {'a': 'duck', 'b': 1.5}} +-- +ok +== +SELECT {'x': 1, 'y': {'a': 'duck', 'b': 1.5}} > NULL +-- +ok +== +CREATE VIEW struct_nested AS SELECT * FROM (VALUES + ({'x': 1, 'y': {'a': 'duck', 'b': 1.5}}, {'x': 1, 'y': {'a': 'duck', 'b': 1.5}}), + ({'x': 1, 'y': {'a': 'duck', 'b': 1.5}}, {'x': 2, 'y': {'a': 'goose', 'b': 2.5}}), + ({'x': 2, 'y': {'a': 'goose', 'b': 2.5}}, {'x': 1, 'y': {'a': 'duck', 'b': 1.5}}), + (NULL, {'x': 1, 'y': {'a': 'duck', 'b': 1.5}}), + ({'x': 2, 'y': {'a': 'goose', 'b': 2.5}}, NULL), + (NULL, NULL) + ) tbl(l, r); +-- +ok +== +SELECT l < r FROM struct_nested +-- +ok +== +SELECT l <= r FROM struct_nested +-- +ok +== +SELECT l = r FROM struct_nested +-- +ok +== +SELECT l <> r FROM struct_nested +-- +ok +== +SELECT l >= r FROM struct_nested +-- +ok +== +SELECT l > r FROM struct_nested +-- +ok +== +SELECT {'x': 1, 'y': ['duck', 'somateria']} < {'x': 2, 'y': ['goose']} +-- +ok +== +SELECT {'x': 1, 'y': ['duck', 'somateria']} < {'x': 1, 'y': ['duck', 'somateria']} +-- +ok +== +SELECT NULL < {'x': 1, 'y': ['duck', 'somateria']} +-- +ok +== +SELECT {'x': 1, 'y': ['duck', 'somateria']} < NULL +-- +ok +== +SELECT {'x': 1, 'y': ['duck', 'somateria']} <= {'x': 2, 'y': ['goose']} +-- +ok +== +SELECT {'x': 1, 'y': ['duck', 'somateria']} <= {'x': 1, 'y': ['duck', 'somateria']} +-- +ok +== +SELECT NULL <= {'x': 1, 'y': ['duck', 'somateria']} +-- +ok +== +SELECT {'x': 1, 'y': ['duck', 'somateria']} <= NULL +-- +ok +== +SELECT {'x': 1, 'y': ['duck', 'somateria']} = {'x': 2, 'y': ['goose']} +-- +ok +== +SELECT {'x': 1, 'y': ['duck', 'somateria']} = {'x': 1, 'y': ['duck', 'somateria']} +-- +ok +== +SELECT NULL = {'x': 1, 'y': ['duck', 'somateria']} +-- +ok +== +SELECT {'x': 1, 'y': ['duck', 'somateria']} = NULL +-- +ok +== +SELECT {'x': 1, 'y': ['duck', 'somateria']} <> {'x': 2, 'y': ['goose']} +-- +ok +== +SELECT {'x': 1, 'y': ['duck', 'somateria']} <> {'x': 1, 'y': ['duck', 'somateria']} +-- +ok +== +SELECT NULL <> {'x': 1, 'y': ['duck', 'somateria']} +-- +ok +== +SELECT {'x': 1, 'y': ['duck', 'somateria']} <> NULL +-- +ok +== +SELECT {'x': 1, 'y': ['duck', 'somateria']} >= {'x': 2, 'y': ['goose']} +-- +ok +== +SELECT {'x': 1, 'y': ['duck', 'somateria']} >= {'x': 1, 'y': ['duck', 'somateria']} +-- +ok +== +SELECT NULL >= {'x': 1, 'y': ['duck', 'somateria']} +-- +ok +== +SELECT {'x': 1, 'y': ['duck', 'somateria']} >= NULL +-- +ok +== +SELECT {'x': 1, 'y': ['duck', 'somateria']} > {'x': 2, 'y': ['goose']} +-- +ok +== +SELECT {'x': 1, 'y': ['duck', 'somateria']} > {'x': 1, 'y': ['duck', 'somateria']} +-- +ok +== +SELECT NULL > {'x': 1, 'y': ['duck', 'somateria']} +-- +ok +== +SELECT {'x': 1, 'y': ['duck', 'somateria']} > NULL +-- +ok +== +CREATE VIEW list_in_struct AS SELECT * FROM (VALUES + ({'x': 1, 'y': ['duck', 'somateria']}, {'x': 1, 'y': ['duck', 'somateria']}), + ({'x': 1, 'y': ['duck', 'somateria']}, {'x': 2, 'y': ['goose']}), + ({'x': 2, 'y': ['goose']}, {'x': 1, 'y': ['duck', 'somateria']}), + (NULL, {'x': 1, 'y': ['duck', 'somateria']}), + ({'x': 2, 'y': ['goose']}, NULL), + (NULL, NULL) + ) tbl(l, r); +-- +ok +== +SELECT l < r FROM list_in_struct +-- +ok +== +SELECT l <= r FROM list_in_struct +-- +ok +== +SELECT l = r FROM list_in_struct +-- +ok +== +SELECT l <> r FROM list_in_struct +-- +ok +== +SELECT l >= r FROM list_in_struct +-- +ok +== +SELECT l > r FROM list_in_struct +-- +ok +== +select {'x': a, 'y': a+1, 'z': a+2}<{'x': 1, 'y': 2, 'z': 3} from range(5) tbl(a); +-- +ok +== +select {'x': a, 'y': a+1, 'z': a+2}<={'x': 1, 'y': 2, 'z': 3} from range(5) tbl(a); +-- +ok +== +select {'x': a, 'y': a+1, 'z': a+2}={'x': 1, 'y': 2, 'z': 3} from range(5) tbl(a); +-- +ok +== +select {'x': a, 'y': a+1, 'z': a+2}<>{'x': 1, 'y': 2, 'z': 3} from range(5) tbl(a); +-- +ok +== +select {'x': a, 'y': a+1, 'z': a+2}>={'x': 1, 'y': 2, 'z': 3} from range(5) tbl(a); +-- +ok +== +select {'x': a, 'y': a+1, 'z': a+2}>{'x': 1, 'y': 2, 'z': 3} from range(5) tbl(a); +-- +ok +== diff --git a/parser/testdata/corpus/sql/types/struct/struct_concat.test b/parser/testdata/corpus/sql/types/struct/struct_concat.test new file mode 100644 index 0000000..1307a90 --- /dev/null +++ b/parser/testdata/corpus/sql/types/struct/struct_concat.test @@ -0,0 +1,65 @@ +# source: test/sql/types/struct/struct_concat.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +SELECT struct_concat({'a': 1}, {'b': NULL}, NULL::STRUCT(k INT), struct_pack( x := 'foobar'));; +-- +ok +== +CREATE TABLE t1 AS SELECT {'i': i, 'j': i + i % 2} as s FROM generate_series(1, 15) AS t(i); +-- +ok +== +SELECT struct_concat({'a': 2, 'b': NULL}, s) FROM t1; +-- +ok +== +SELECT struct_concat(s, {'a': 2, 'b': NULL}) FROM t1 WHERE s.i % 2 = 0; +-- +ok +== +SELECT struct_concat(); +-- +ok +== +SELECT struct_concat(NULL::STRUCT(k INT), 'not a struct'); +-- +ok +== +SELECT struct_concat({'a': 'first struct'}, {'a': 'second struct'}); +-- +ok +== +SELECT struct_concat({'a': 'first struct'}, {'A': 'second struct'}); +-- +ok +== +SELECT struct_concat({'a': 1}, NULL); +-- +ok +== +SELECT struct_concat({'a': 'named struct'}, row(10)); +-- +ok +== +SELECT struct_concat(row('a'), row('b')); +-- +ok +== +PREPARE v1 AS SELECT struct_concat({'a': 1}, ?); +-- +ok +== +EXECUTE v1({'b': 42}); +-- +ok +== +PREPARE v2 AS SELECT struct_concat({'a': ?}, {'b': 42}); +-- +ok +== +EXECUTE v2(1); +-- +ok +== diff --git a/parser/testdata/corpus/sql/types/struct/struct_contains.test b/parser/testdata/corpus/sql/types/struct/struct_contains.test new file mode 100644 index 0000000..db10247 --- /dev/null +++ b/parser/testdata/corpus/sql/types/struct/struct_contains.test @@ -0,0 +1,161 @@ +# source: test/sql/types/struct/struct_contains.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +SELECT struct_contains(ROW(1, 2), 2); +-- +ok +== +SELECT struct_contains(ROW(1, 2), 3); +-- +ok +== +SELECT struct_contains(ROW(1, 2), NULL); +-- +ok +== +SELECT struct_contains(ROW(1, NULL), 1); +-- +ok +== +SELECT struct_contains(ROW(1, NULL), NULL); +-- +ok +== +SELECT struct_contains(NULL, 1); +-- +ok +== +SELECT struct_contains(ROW(1), NULL); +-- +ok +== +SELECT struct_contains(ROW(NULL), NULL); +-- +ok +== +SELECT struct_contains(ROW('test', 'notest'), 'notest'); +-- +ok +== +SELECT struct_contains(ROW('test', 'notest'), 'a'); +-- +ok +== +SELECT struct_contains(ROW(1, 2, 3), TRUE); +-- +ok +== +SELECT struct_contains(ROW(1, 2, 3), 1.0); +-- +ok +== +SELECT struct_contains(ROW(1.0, 2.0, 3.0), 2); +-- +ok +== +CREATE TABLE t1 (c0 INT, c1 INT, c2 INT, c3 VARCHAR); +-- +ok +== +INSERT INTO t1 VALUES (1, 2, 3, 'a'), (4, 5, 6, 'b'), (7, 8, 9, 'c'), (NULL, 10, 11, 'd'), (12, 13, 14, NULL); +-- +ok +== +SELECT struct_contains(ROW(c0, c1, c2), 1) FROM t1; +-- +ok +== +SELECT struct_contains(ROW(c0, c1, c2), NULL) FROM t1; +-- +ok +== +SELECT struct_contains(ROW(c0, c1, c2, c3), 1) FROM t1; +-- +ok +== +SELECT struct_contains(ROW(c0, c1, c2, c3), 'a') FROM t1; +-- +ok +== +SELECT ROW(c0, c1, c2, c3), c0, struct_contains(ROW(c0, c1, c2, c3), c0) FROM t1; +-- +ok +== +SELECT struct_contains(row(1, TRUE, 1.0), '1'); +-- +ok +== +CREATE TABLE mixed_types(c0 INT, c1 BOOL, c2 DECIMAL(10, 2), val VARCHAR); +-- +ok +== +INSERT INTO mixed_types VALUES (1, TRUE, 1.0, '1'), (2, FALSE, 2.0, '2'), (3, TRUE, 3.0, NULL), (NULL, NULL, NULL, '4'); +-- +ok +== +SELECT ROW(c0, c1, c2), val, struct_contains(ROW(c0, c1, c2), val) FROM mixed_types; +-- +ok +== +SELECT struct_contains(ROW(ROW(1, 2), ROW(3, 4)), ROW(1, 2)); +-- +ok +== +SELECT struct_contains(ROW([1, 2], 3), [1, 2]); +-- +ok +== +SELECT struct_contains(ROW(ROW(1, 2), [1,2]), ROW(5, 6)); +-- +ok +== +SELECT struct_contains(ROW(ROW(1, 2), [1,2]), ROW(1, 2)); +-- +ok +== +SELECT struct_contains(ROW(ROW(1, 2), [1,2]), [1, 2]); +-- +ok +== +SELECT struct_contains(ROW(ROW(NULL), [1,2]), ROW(NULL)); +-- +ok +== +SELECT struct_contains(ROW(MAP([1], [2])), MAP([1], [2])); +-- +ok +== +SELECT struct_contains(ROW(MAP([1], [2])), MAP([1], [3])); +-- +ok +== +SELECT struct_contains(ROW(ROW(c0, c1), [c0, c1]), ROW(1, 2)) FROM t1; +-- +ok +== +SELECT struct_contains(ROW(ROW(c0, c1), [c0, c1]), [1, 2]) FROM t1; +-- +ok +== +SELECT struct_contains(NULL, row(c1, c2)) FROM t1; +-- +ok +== +SELECT 1 in x FROM (SELECT (1, 2) AS x); +-- +ok +== +INSERT INTO t0 VALUES (1, 2), (3, 4), (5, 6); +-- +ok +== +SELECT c0, c0 IN x FROM (SELECT [c0, c1] AS x FROM t0) AS y, t0 ORDER BY c0, x; +-- +ok +== +SELECT struct_contains({'a': 1, 'b': 2}, 2); +-- +ok +== diff --git a/parser/testdata/corpus/sql/types/struct/struct_cross_product.test b/parser/testdata/corpus/sql/types/struct/struct_cross_product.test new file mode 100644 index 0000000..2ef7527 --- /dev/null +++ b/parser/testdata/corpus/sql/types/struct/struct_cross_product.test @@ -0,0 +1,13 @@ +# source: test/sql/types/struct/struct_cross_product.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +CREATE VIEW v1 AS SELECT * FROM (VALUES (1, {'a': {'a1': 3, 'a2': 7}, 'b': [1, 2, 3]}), (2, NULL), (3, {'a': NULL, 'b': [4, 5, NULL]})) tbl (a, b); +-- +ok +== +SELECT * FROM v1 v, v1 w WHERE v.a <> w.a OR v.a > w.a ORDER BY v.a, w.a; +-- +ok +== diff --git a/parser/testdata/corpus/sql/types/struct/struct_different_names.test b/parser/testdata/corpus/sql/types/struct/struct_different_names.test new file mode 100644 index 0000000..8eb4935 --- /dev/null +++ b/parser/testdata/corpus/sql/types/struct/struct_different_names.test @@ -0,0 +1,97 @@ +# source: test/sql/types/struct/struct_different_names.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +CREATE TABLE wrong AS FROM (VALUES (ROW(3))); +-- +ok +== +SELECT column_type FROM (DESCRIBE wrong); +-- +ok +== +CREATE TABLE t1 (s STRUCT(v VARCHAR)); +-- +ok +== +INSERT INTO t1 VALUES (ROW(NULL)); +-- +ok +== +INSERT INTO t1 VALUES ({c: 34}); +-- +ok +== +SELECT s FROM t1 ORDER BY ALL; +-- +ok +== +CREATE TABLE foo (bar struct(pip int)); +-- +ok +== +INSERT INTO foo VALUES ({'ignoreme': 3}); +-- +ok +== +INSERT INTO foo VALUES (ROW(42)); +-- +ok +== +SELECT bar FROM foo ORDER BY ALL; +-- +ok +== +CREATE OR REPLACE TABLE T AS SELECT [{'a': 'A', 'b':'B'}] AS x, [{'b':'BB','a':'AA'}] AS y; +-- +ok +== +SELECT x, y, ARRAY_CONCAT(x, y) FROM T; +-- +ok +== +CREATE OR REPLACE TABLE T (s STRUCT(a INT, b INT)); +-- +ok +== +INSERT INTO T VALUES ({l: 1, m: 2}), ({x: 3, y: 4}); +-- +ok +== +SELECT s FROM T ORDER BY ALL; +-- +ok +== +CREATE TABLE tbl (a STRUCT(a INT, b VARCHAR)); +-- +ok +== +INSERT INTO tbl VALUES (ROW(5, 'hello')); +-- +ok +== +CREATE TABLE tbl2 AS SELECT ROW(42, 'world') a; +-- +ok +== +SELECT [{'foo': True}, {'bar': False}, {'foobar': NULL}]; +-- +ok +== +select [(13, 24), {'a': 42, 'b': 84}, (43, 85), {'b': 10, 'a': 123123}] AS res; +-- +ok +== +PREPARE v1 AS SELECT ROW(?); +-- +ok +== +EXECUTE v1(42); +-- +ok +== +CREATE VIEW v1 AS SELECT ROW(42); +-- +ok +== diff --git a/parser/testdata/corpus/sql/types/struct/struct_distinct.test b/parser/testdata/corpus/sql/types/struct/struct_distinct.test new file mode 100644 index 0000000..5654daf --- /dev/null +++ b/parser/testdata/corpus/sql/types/struct/struct_distinct.test @@ -0,0 +1,218 @@ +# source: test/sql/types/struct/struct_distinct.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +SELECT {'x': 1::{type}} IS NOT DISTINCT FROM {'x': 2::{type}} +-- +error: Parser Error: syntax error at or near "{" +== +SELECT {'x': 1::{type}} IS NOT DISTINCT FROM {'x': 1::{type}} +-- +error: Parser Error: syntax error at or near "{" +== +SELECT NULL IS NOT DISTINCT FROM {'x': 1::{type}} +-- +error: Parser Error: syntax error at or near "{" +== +SELECT {'x': 1::{type}} IS DISTINCT FROM {'x': 2::{type}} +-- +error: Parser Error: syntax error at or near "{" +== +SELECT {'x': 1::{type}} IS DISTINCT FROM {'x': 1::{type}} +-- +error: Parser Error: syntax error at or near "{" +== +SELECT {'x': 1::{type}} IS DISTINCT FROM NULL +-- +error: Parser Error: syntax error at or near "{" +== +CREATE OR REPLACE VIEW struct_int AS SELECT * FROM (VALUES + ({'x': 1::{type}}, {'x': 1::{type}}), + ({'x': 1::{type}}, {'x': 2::{type}}), + ({'x': 2::{type}}, {'x': 1::{type}}), + (NULL, {'x': 1::{type}}), + ({'x': 2::{type}}, NULL), + (NULL, NULL) + ) tbl(l, r); +-- +error: Parser Error: syntax error at or near "{" +== +SELECT l IS NOT DISTINCT FROM r FROM struct_int +-- +ok +== +SELECT l IS DISTINCT FROM r FROM struct_int +-- +ok +== +SELECT {'x': 'duck'} IS NOT DISTINCT FROM {'x': 'goose'} +-- +ok +== +SELECT {'x': 'duck'} IS NOT DISTINCT FROM {'x': 'duck'} +-- +ok +== +SELECT {'x': 'duck'} IS NOT DISTINCT FROM NULL +-- +ok +== +SELECT NULL IS NOT DISTINCT FROM {'x': 'duck'} +-- +ok +== +SELECT {'x': 'duck'} IS DISTINCT FROM {'x': 'goose'} +-- +ok +== +SELECT {'x': 'duck'} IS DISTINCT FROM {'x': 'duck'} +-- +ok +== +SELECT {'x': 'duck'} IS DISTINCT FROM NULL +-- +ok +== +SELECT NULL IS DISTINCT FROM {'x': 'duck'} +-- +ok +== +SELECT l IS NOT DISTINCT FROM r FROM struct_str +-- +ok +== +SELECT l IS DISTINCT FROM r FROM struct_str +-- +ok +== +SELECT {'x': 'duck', 'y': 1} IS NOT DISTINCT FROM {'x': 'goose', 'y': 2} +-- +ok +== +SELECT {'x': 'duck', 'y': 1} IS NOT DISTINCT FROM {'x': 'duck', 'y': 1} +-- +ok +== +SELECT NULL IS NOT DISTINCT FROM {'x': 'duck', 'y': 1} +-- +ok +== +SELECT {'x': 'duck', 'y': 1} IS NOT DISTINCT FROM NULL +-- +ok +== +SELECT {'x': 'duck', 'y': 1} IS DISTINCT FROM {'x': 'goose', 'y': 2} +-- +ok +== +SELECT {'x': 'duck', 'y': 1} IS DISTINCT FROM {'x': 'duck', 'y': 1} +-- +ok +== +SELECT NULL IS DISTINCT FROM {'x': 'duck', 'y': 1} +-- +ok +== +SELECT {'x': 'duck', 'y': 1} IS DISTINCT FROM NULL +-- +ok +== +SELECT l IS NOT DISTINCT FROM r FROM struct_str_int +-- +ok +== +SELECT l IS DISTINCT FROM r FROM struct_str_int +-- +ok +== +SELECT {'x': 1, 'y': {'a': 'duck', 'b': 1.5}} IS NOT DISTINCT FROM {'x': 2, 'y': {'a': 'goose', 'b': 2.5}} +-- +ok +== +SELECT {'x': 1, 'y': {'a': 'duck', 'b': 1.5}} IS NOT DISTINCT FROM {'x': 1, 'y': {'a': 'duck', 'b': 1.5}} +-- +ok +== +SELECT NULL IS NOT DISTINCT FROM {'x': 1, 'y': {'a': 'duck', 'b': 1.5}} +-- +ok +== +SELECT {'x': 1, 'y': {'a': 'duck', 'b': 1.5}} IS NOT DISTINCT FROM NULL +-- +ok +== +SELECT {'x': 1, 'y': {'a': 'duck', 'b': 1.5}} IS DISTINCT FROM {'x': 2, 'y': {'a': 'goose', 'b': 2.5}} +-- +ok +== +SELECT {'x': 1, 'y': {'a': 'duck', 'b': 1.5}} IS DISTINCT FROM {'x': 1, 'y': {'a': 'duck', 'b': 1.5}} +-- +ok +== +SELECT NULL IS DISTINCT FROM {'x': 1, 'y': {'a': 'duck', 'b': 1.5}} +-- +ok +== +SELECT {'x': 1, 'y': {'a': 'duck', 'b': 1.5}} IS DISTINCT FROM NULL +-- +ok +== +SELECT l IS NOT DISTINCT FROM r FROM struct_nested +-- +ok +== +SELECT l IS DISTINCT FROM r FROM struct_nested +-- +ok +== +SELECT {'x': 1, 'y': ['duck', 'somateria']} IS NOT DISTINCT FROM {'x': 2, 'y': ['goose']} +-- +ok +== +SELECT {'x': 1, 'y': ['duck', 'somateria']} IS NOT DISTINCT FROM {'x': 1, 'y': ['duck', 'somateria']} +-- +ok +== +SELECT NULL IS NOT DISTINCT FROM {'x': 1, 'y': ['duck', 'somateria']} +-- +ok +== +SELECT {'x': 1, 'y': ['duck', 'somateria']} IS NOT DISTINCT FROM NULL +-- +ok +== +SELECT {'x': 1, 'y': ['duck', 'somateria']} IS DISTINCT FROM {'x': 2, 'y': ['goose']} +-- +ok +== +SELECT {'x': 1, 'y': ['duck', 'somateria']} IS DISTINCT FROM {'x': 1, 'y': ['duck', 'somateria']} +-- +ok +== +SELECT NULL IS DISTINCT FROM {'x': 1, 'y': ['duck', 'somateria']} +-- +ok +== +SELECT {'x': 1, 'y': ['duck', 'somateria']} IS DISTINCT FROM NULL +-- +ok +== +SELECT l IS NOT DISTINCT FROM r FROM list_in_struct +-- +ok +== +SELECT l IS DISTINCT FROM r FROM list_in_struct +-- +ok +== +select CASE WHEN a < 4 THEN {'x': a, 'y': a+1, 'z': a+2} ELSE NULL END IS NOT DISTINCT FROM {'x': 1, 'y': 2, 'z': 3} +from range(5) tbl(a); +-- +ok +== +select CASE WHEN a < 4 THEN {'x': a, 'y': a+1, 'z': a+2} ELSE NULL END IS DISTINCT FROM {'x': 1, 'y': 2, 'z': 3} +from range(5) tbl(a); +-- +ok +== diff --git a/parser/testdata/corpus/sql/types/struct/struct_equality_bug.test b/parser/testdata/corpus/sql/types/struct/struct_equality_bug.test new file mode 100644 index 0000000..182cd81 --- /dev/null +++ b/parser/testdata/corpus/sql/types/struct/struct_equality_bug.test @@ -0,0 +1,13 @@ +# source: test/sql/types/struct/struct_equality_bug.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +INSERT INTO integers VALUES (1),(1),(3),(20),(20),(20); +-- +ok +== +select unnest(map_entries(histogram(i))) FROM integers; +-- +ok +== diff --git a/parser/testdata/corpus/sql/types/struct/struct_index.test b/parser/testdata/corpus/sql/types/struct/struct_index.test new file mode 100644 index 0000000..e6f0fe7 --- /dev/null +++ b/parser/testdata/corpus/sql/types/struct/struct_index.test @@ -0,0 +1,54 @@ +# source: test/sql/types/struct/struct_index.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +CREATE TABLE a(id INTEGER PRIMARY KEY, c ROW(i ROW(a INTEGER), j INTEGER)); +-- +ok +== +INSERT INTO a VALUES (1, { + 'i': { + 'a': 3 + }, + 'j': 4 +}) +-- +ok +== +INSERT INTO a VALUES (3, ROW(ROW(NULL), 1)) +-- +ok +== +INSERT INTO a VALUES (4, ROW(ROW(1), NULL)) +-- +ok +== +INSERT INTO a VALUES (5, ROW(NULL, 1)) +-- +ok +== +SELECT * FROM a WHERE id=5 +-- +ok +== +CREATE TABLE a(id INTEGER, c ROW(i ROW(a INTEGER), j INTEGER)); +-- +ok +== +INSERT INTO a VALUES (1, ROW(ROW(NULL), 1)) +-- +ok +== +INSERT INTO a VALUES (1, ROW(ROW(1), NULL)) +-- +ok +== +INSERT INTO a VALUES (1, ROW(NULL, 1)) +-- +ok +== +SELECT * FROM a WHERE id=1 ORDER BY c['i']['a'] +-- +ok +== diff --git a/parser/testdata/corpus/sql/types/struct/struct_named_cast.test b/parser/testdata/corpus/sql/types/struct/struct_named_cast.test new file mode 100644 index 0000000..f403b0d --- /dev/null +++ b/parser/testdata/corpus/sql/types/struct/struct_named_cast.test @@ -0,0 +1,25 @@ +# source: test/sql/types/struct/struct_named_cast.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +SELECT {'a': 42, 'b': 84}::STRUCT(b INT, a INT) +-- +ok +== +SELECT {'a': ['1', '2', '3'], 'b': 84}::STRUCT(b INT, a INT[]) +-- +ok +== +SELECT {'a': ['1', '2', '3'], 'b': 84}::STRUCT(b INT, A INT[]) +-- +ok +== +SELECT {'a': ['1', '2', '3'], 'b': 84}::STRUCT(b INT, c INT[]) +-- +ok +== +SELECT ROW(42, 84)::STRUCT(a INT, b INT) +-- +ok +== diff --git a/parser/testdata/corpus/sql/types/struct/struct_null_members.test b/parser/testdata/corpus/sql/types/struct/struct_null_members.test new file mode 100644 index 0000000..2a000de --- /dev/null +++ b/parser/testdata/corpus/sql/types/struct/struct_null_members.test @@ -0,0 +1,113 @@ +# source: test/sql/types/struct/struct_null_members.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +SELECT lhs.i, rhs.i, + lhs.i < rhs.i, lhs.i <= rhs.i, + lhs.i = rhs.i, lhs.i <> rhs.i, + lhs.i > rhs.i, lhs.i >= rhs.i, + lhs.i IS NOT DISTINCT FROM rhs.i, lhs.i IS DISTINCT FROM rhs.i +FROM struct_int lhs, struct_int rhs +-- +ok +== +CREATE VIEW list_str AS +SELECT * FROM (VALUES + ({'x': 'duck', 'y': ''}), + ({'x': 'duck', 'y': 'goose'}), + ({'x': 'duck', 'y': NULL}), + ({'x': NULL, 'y': 'goose'}), + ({'x': NULL, 'y': NULL}), + ({'x': NULL, 'y': '0'}), + (NULL) +) tbl(i); +-- +ok +== +SELECT lhs.i, rhs.i, + lhs.i < rhs.i, lhs.i <= rhs.i, + lhs.i = rhs.i, lhs.i <> rhs.i, + lhs.i > rhs.i, lhs.i >= rhs.i, + lhs.i IS NOT DISTINCT FROM rhs.i, lhs.i IS DISTINCT FROM rhs.i +FROM list_str lhs, list_str rhs; +-- +ok +== +CREATE TABLE nested_values(id INTEGER, value STRUCT(child STRUCT(i INTEGER))); +-- +ok +== +INSERT INTO nested_values VALUES + (1, {'child': {'i': 1}}), + (2, {'child': {'i': 2}}), + (3, {'child': NULL}); +-- +ok +== +SELECT id, value <= value FROM nested_values ORDER BY id; +-- +ok +== +SELECT lhs.id * 10 + rhs.id +FROM nested_values lhs +JOIN nested_values rhs ON lhs.value <= rhs.value +ORDER BY ALL; +-- +ok +== +SELECT id, value < value FROM nested_values ORDER BY id; +-- +ok +== +SELECT lhs.id * 10 + rhs.id +FROM nested_values lhs +JOIN nested_values rhs ON lhs.value < rhs.value +ORDER BY ALL; +-- +ok +== +SELECT id, value >= value FROM nested_values ORDER BY id; +-- +ok +== +SELECT lhs.id * 10 + rhs.id +FROM nested_values lhs +JOIN nested_values rhs ON lhs.value >= rhs.value +ORDER BY ALL; +-- +ok +== +SELECT id, value > value FROM nested_values ORDER BY id; +-- +ok +== +SELECT lhs.id * 10 + rhs.id +FROM nested_values lhs +JOIN nested_values rhs ON lhs.value > rhs.value +ORDER BY ALL; +-- +ok +== +SELECT id, value <> value FROM nested_values ORDER BY id; +-- +ok +== +SELECT lhs.id * 10 + rhs.id +FROM nested_values lhs +JOIN nested_values rhs ON lhs.value <> rhs.value +ORDER BY ALL; +-- +ok +== +SELECT id, value = value FROM nested_values ORDER BY id; +-- +ok +== +SELECT lhs.id * 10 + rhs.id +FROM nested_values lhs +JOIN nested_values rhs ON lhs.value = rhs.value +ORDER BY ALL; +-- +ok +== diff --git a/parser/testdata/corpus/sql/types/struct/struct_operations.test b/parser/testdata/corpus/sql/types/struct/struct_operations.test new file mode 100644 index 0000000..a94edd9 --- /dev/null +++ b/parser/testdata/corpus/sql/types/struct/struct_operations.test @@ -0,0 +1,41 @@ +# source: test/sql/types/struct/struct_operations.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +CREATE TABLE a(id INTEGER, b ROW(i INTEGER, j INTEGER)); +-- +ok +== +INSERT INTO a VALUES (1, {i: 1, j: 2}); +-- +ok +== +CREATE TABLE b(id INTEGER, j VARCHAR); +-- +ok +== +INSERT INTO b VALUES (1, 'hello'); +-- +ok +== +SELECT * FROM a LEFT JOIN b ON a.id<>b.id +-- +ok +== +SELECT * FROM a RIGHT JOIN b ON a.id<>b.id +-- +ok +== +SELECT * FROM a LEFT JOIN b ON a.id>b.id +-- +ok +== +SELECT * FROM a RIGHT JOIN b ON a.id>b.id +-- +ok +== +SELECT (SELECT b FROM a) +-- +ok +== diff --git a/parser/testdata/corpus/sql/types/struct/struct_pack_list.test b/parser/testdata/corpus/sql/types/struct/struct_pack_list.test new file mode 100644 index 0000000..3ce7154 --- /dev/null +++ b/parser/testdata/corpus/sql/types/struct/struct_pack_list.test @@ -0,0 +1,25 @@ +# source: test/sql/types/struct/struct_pack_list.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +SELECT a from (SELECT STRUCT_PACK(a := 42, b := 43) as a) as t +-- +ok +== +SELECT a from (SELECT STRUCT_PACK(a := NULL, b := 43) as a) as t +-- +ok +== +SELECT a from (SELECT STRUCT_PACK(a := NULL) as a) as t +-- +ok +== +SELECT a from (SELECT STRUCT_PACK(a := i, b := i) as a FROM range(10000) tbl(i)) as t +-- +ok +== +SELECT a from (SELECT STRUCT_PACK(a := LIST_VALUE(1,2,3), b := i) as a FROM range(10000) tbl(i)) as t +-- +ok +== diff --git a/parser/testdata/corpus/sql/types/struct/struct_position.test b/parser/testdata/corpus/sql/types/struct/struct_position.test new file mode 100644 index 0000000..37adb90 --- /dev/null +++ b/parser/testdata/corpus/sql/types/struct/struct_position.test @@ -0,0 +1,181 @@ +# source: test/sql/types/struct/struct_position.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +SELECT struct_position(ROW(7, 2, 5), 7) +-- +ok +== +SELECT struct_position(ROW(7, 2, 5), 2) +-- +ok +== +SELECT struct_position(ROW(7, 2, 5), 5) +-- +ok +== +SELECT struct_position(ROW(1, 2, 3), 1.0) +-- +ok +== +SELECT struct_position(ROW(1.0, 2.0, 3.0, 4.0), 1) +-- +ok +== +SELECT struct_position(ROW(1, 2, 3), 4.0) +-- +ok +== +SELECT struct_position(ROW(1.0, 2.0, 3.0), 4) +-- +ok +== +SELECT struct_position(ROW(7), 5) +-- +ok +== +SELECT struct_position(ROW(1, 2, 3, 4), 4) +-- +ok +== +SELECT struct_position(ROW(true, false), true) +-- +ok +== +SELECT struct_position(ROW(true, true), false) +-- +ok +== +SELECT struct_position(ROW('test', 'notest'), 'notest') +-- +ok +== +SELECT struct_position(ROW('test', 'notest'), 'a') +-- +ok +== +SELECT struct_position(NULL, 1) +-- +ok +== +SELECT struct_position(ROW(1), NULL) +-- +ok +== +SELECT struct_position(ROW(NULL), NULL) +-- +ok +== +SELECT struct_position(ROW(NULL, 1), NULL) +-- +ok +== +SELECT struct_position(ROW(NULL, 1), 1) +-- +ok +== +SELECT struct_position(ROW(NULL, 0), 1) +-- +ok +== +SELECT struct_position(ROW(NULL, 7), 7) +-- +ok +== +SELECT struct_position(NULL, NULL) +-- +ok +== +CREATE TABLE test (col1 INTEGER, col2 INTEGER, col3 INTEGER, val INTEGER); +-- +ok +== +INSERT INTO test VALUES (2, 1, 3, 2), (2, 3, 4, 5), (1, 0, 0, NULL), (1, NULL, 2, NULL); +-- +ok +== +SELECT ROW(col1, col2, col3), val, struct_position(ROW(col1, col2, col3), val) FROM test; +-- +ok +== +SELECT ROW(col1, col2, col3), val, struct_position(ROW(col1, col2, col3), 1) FROM test; +-- +ok +== +CREATE TABLE str_test (col1 VARCHAR, col2 VARCHAR, col3 VARCHAR, val VARCHAR); +-- +ok +== +INSERT INTO str_test VALUES ('a', 'b', 'c', 'a'), ('d', 'a', 'e', 'b'), ('b', 'x', 'y', NULL), ('aa', NULL, 'bb', NULL); +-- +ok +== +SELECT ROW(col1, col2, col3), val, struct_position(ROW(col1, col2, col3), val) FROM str_test; +-- +ok +== +SELECT ROW(col1, col2, col3), val, struct_position(ROW(col1, col2, col3), 'a') FROM str_test; +-- +ok +== +DROP TABLE str_test; +-- +ok +== +SELECT struct_position(row(1, TRUE, 1.0), '1'); +-- +ok +== +SELECT ROW(c0, c1, c2), val, struct_position(ROW(c0, c1, c2), val) FROM mixed_types; +-- +ok +== +SELECT struct_position(ROW(ROW(1, 2), ROW(3, 4)), ROW(1, 2)) +-- +ok +== +SELECT struct_position(ROW(ROW(1, 2), ROW(3, 4)), ROW(5, 6)) +-- +ok +== +SELECT struct_position(ROW([1, 2, 3], [1]), [2]) +-- +ok +== +SELECT struct_position(ROW([1, 2, 3], [1]), [1, 2, 3]) +-- +ok +== +SELECT struct_position(ROW([NULL], [1], [1, 2, 3]), NULL) +-- +ok +== +SELECT struct_position(ROW([1, NULL], [1], [1, 2, 3]), [1, NULL]) +-- +ok +== +SELECT struct_position(ROW({'a': 1}, {'a': 2}), {'a': 2}) +-- +ok +== +SELECT struct_position(ROW({'a': 1}, {'a': 2}), {'a': 3}) +-- +ok +== +SELECT struct_position(ROW({'a': 1, 'b': 3}, {'a': 2, 'b': 2}), {'a': 2, 'b': 2}) +-- +ok +== +SELECT struct_position(ROW(MAP([1], [2])), MAP([1], [2])) +-- +ok +== +SELECT struct_position(ROW(MAP([1], [2])), MAP([1], [3])) +-- +ok +== +SELECT struct_position({'a': 1, 'b': 2}, 2); +-- +ok +== diff --git a/parser/testdata/corpus/sql/types/struct/struct_projection_pushdown.test b/parser/testdata/corpus/sql/types/struct/struct_projection_pushdown.test new file mode 100644 index 0000000..f6ed051 --- /dev/null +++ b/parser/testdata/corpus/sql/types/struct/struct_projection_pushdown.test @@ -0,0 +1,94 @@ +# source: test/sql/types/struct/struct_projection_pushdown.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +CREATE OR REPLACE TABLE test_structs(id INT, s STRUCT(a integer, b bool)); +-- +ok +== +CREATE OR REPLACE TABLE test_structs(id INT, s VARIANT); +-- +ok +== +INSERT INTO test_structs VALUES + ( + 1, + { + 'a': 42, + 'b': true + } + ), + ( + 2, + NULL + ), + ( + 3, + { + 'a': 84, + 'b': NULL + } + ), + ( + 4, + { + 'a': NULL, + 'b': false + } + ); +-- +ok +== +SELECT s.b FROM {source} +-- +error: Parser Error: syntax error at or near "{" +== +SELECT s.b::INTEGER FROM {source} +-- +error: Parser Error: syntax error at or near "{" +== +SELECT s['b'] FROM {source} +-- +error: Parser Error: syntax error at or near "{" +== +SELECT s['b'], s FROM {source} +-- +error: Parser Error: syntax error at or near "{" +== +SELECT s['b']::INTEGER, s FROM {source} +-- +error: Parser Error: syntax error at or near "{" +== +SELECT s.b, s.a FROM {source} +-- +error: Parser Error: syntax error at or near "{" +== +SELECT s.b::INTEGER, s.a::BIGINT FROM {source} +-- +error: Parser Error: syntax error at or near "{" +== +SELECT s FROM {source} WHERE s.b +-- +error: Parser Error: syntax error at or near "{" +== +SELECT a FROM (SELECT UNNEST(s) FROM {source}) WHERE b +-- +error: Parser Error: syntax error at or near "{" +== +SELECT a::BIGINT FROM (SELECT UNNEST(s) FROM {source}) WHERE b::INTEGER +-- +error: Parser Error: syntax error at or near "{" +== +SELECT id FROM {source} WHERE s.b +-- +error: Parser Error: syntax error at or near "{" +== +UPDATE test_structs SET s={'a': 84, 'b': false} WHERE id=2 +-- +ok +== +SELECT s['b'], s.a FROM test_structs WHERE id=2 +-- +ok +== diff --git a/parser/testdata/corpus/sql/types/struct/struct_projection_pushdown_in_storage.test b/parser/testdata/corpus/sql/types/struct/struct_projection_pushdown_in_storage.test new file mode 100644 index 0000000..a1d2b9c --- /dev/null +++ b/parser/testdata/corpus/sql/types/struct/struct_projection_pushdown_in_storage.test @@ -0,0 +1,41 @@ +# source: test/sql/types/struct/struct_projection_pushdown_in_storage.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +CREATE TABLE test_structs( + col VARCHAR, + i STRUCT(a integer, b bool, c VARCHAR) +); +-- +ok +== +INSERT INTO test_structs VALUES + ('test', {'a': 1, 'b': true, 'c': 'test'}), + ('test', {'a': 2, 'b': false, 'c': 'hello'}), + ('hello', NULL), + ('test', {'a': 3, 'b': true, 'c': 'this is a long string'}), + ('test', {'a': NULL, 'b': NULL, 'c': NULL}); +-- +ok +== +SELECT i.a FROM test_structs; +-- +ok +== +SELECT i.a, i.c FROM test_structs +-- +ok +== +SELECT i.a, i.c FROM test_structs where col == 'test' +-- +ok +== +pragma explain_output = optimized_only +-- +ok +== +EXPLAIN SELECT i.a FROM test_structs; +-- +ok +== diff --git a/parser/testdata/corpus/sql/types/struct/struct_projection_pushdown_optimizer_bug.test b/parser/testdata/corpus/sql/types/struct/struct_projection_pushdown_optimizer_bug.test new file mode 100644 index 0000000..c1af034 --- /dev/null +++ b/parser/testdata/corpus/sql/types/struct/struct_projection_pushdown_optimizer_bug.test @@ -0,0 +1,36 @@ +# source: test/sql/types/struct/struct_projection_pushdown_optimizer_bug.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +CREATE TABLE tbl( + -- 0 + s1 STRUCT( + i SMALLINT + ), + -- 1 + s2 STRUCT( + f DATE + ), + -- 2 + id INT +); +-- +ok +== +INSERT INTO tbl VALUES + (ROW(1), ROW(DATE '2024-01-30'), 0); +-- +ok +== +WITH subq AS + (FROM tbl) -- project 0,1,2 +SELECT + id, -- 2 + min(subq.s1.i), -- 0.0 + min(subq.s2.f) -- 1.0 +FROM subq +GROUP BY id; +-- +ok +== diff --git a/parser/testdata/corpus/sql/types/struct/struct_projection_pushdown_unnamed.test b/parser/testdata/corpus/sql/types/struct/struct_projection_pushdown_unnamed.test new file mode 100644 index 0000000..63e154b --- /dev/null +++ b/parser/testdata/corpus/sql/types/struct/struct_projection_pushdown_unnamed.test @@ -0,0 +1,21 @@ +# source: test/sql/types/struct/struct_projection_pushdown_unnamed.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +SELECT x[2].k +FROM (SELECT unnest([(0, {'k': 42})]) AS x) +WHERE x[2] IS NOT NULL; +-- +ok +== +SELECT x[2].payload[2].value +FROM (SELECT unnest([(0, {'payload': (10, {'value': 42})})]) AS x); +-- +ok +== +SELECT x.payload[2].value +FROM (SELECT unnest([{'payload': (10, {'value': 42})}]) AS x); +-- +ok +== diff --git a/parser/testdata/corpus/sql/types/struct/struct_stats.test b/parser/testdata/corpus/sql/types/struct/struct_stats.test new file mode 100644 index 0000000..6386da1 --- /dev/null +++ b/parser/testdata/corpus/sql/types/struct/struct_stats.test @@ -0,0 +1,29 @@ +# source: test/sql/types/struct/struct_stats.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +SELECT s.child_stats.i.min, s.child_stats.j.min FROM (SELECT STATS({'i': 3, 'j': 4}) s) +-- +ok +== +SELECT STATS(NULL::ROW(i INTEGER)).has_null +-- +ok +== +CREATE TABLE integers AS SELECT 3 i, 4 j +-- +ok +== +SELECT s.child_stats.i.min, s.child_stats.j.min FROM (SELECT STATS({'i': i, 'j': j}) s FROM integers) +-- +ok +== +CREATE TABLE structs AS SELECT {'i': 3, 'j': 4} s +-- +ok +== +SELECT s.min, s.max FROM (SELECT STATS(s['i']) s FROM structs) +-- +ok +== diff --git a/parser/testdata/corpus/sql/types/struct/struct_subquery.test b/parser/testdata/corpus/sql/types/struct/struct_subquery.test new file mode 100644 index 0000000..e037ce2 --- /dev/null +++ b/parser/testdata/corpus/sql/types/struct/struct_subquery.test @@ -0,0 +1,13 @@ +# source: test/sql/types/struct/struct_subquery.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +SELECT (SELECT tbl.a['i'] + tbl.b['j'] FROM (VALUES ({'i': 1, 'j': 2})) tbl(b)) FROM (VALUES ({'i': 1, 'j': 2})) tbl(a); +-- +ok +== +SELECT (SELECT tbl2.a['i'] + tbl.b['j'] FROM (VALUES ({'i': 1, 'j': 2})) tbl(b)) FROM (VALUES ({'i': 1, 'j': 2})) tbl2(a); +-- +ok +== diff --git a/parser/testdata/corpus/sql/types/struct/struct_tables.test b/parser/testdata/corpus/sql/types/struct/struct_tables.test new file mode 100644 index 0000000..32c6bf8 --- /dev/null +++ b/parser/testdata/corpus/sql/types/struct/struct_tables.test @@ -0,0 +1,21 @@ +# source: test/sql/types/struct/struct_tables.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +CREATE TABLE a(b ROW(i INTEGER, j INTEGER)); +-- +ok +== +INSERT INTO a VALUES (STRUCT_PACK(i := 1, j:= 2)); +-- +ok +== +SELECT * FROM a ORDER BY (b).i; +-- +ok +== +SELECT * FROM a ORDER BY (b).i, (b).j; +-- +ok +== diff --git a/parser/testdata/corpus/sql/types/struct/struct_unnest_recursion.test b/parser/testdata/corpus/sql/types/struct/struct_unnest_recursion.test new file mode 100644 index 0000000..7687dbf --- /dev/null +++ b/parser/testdata/corpus/sql/types/struct/struct_unnest_recursion.test @@ -0,0 +1,13 @@ +# source: test/sql/types/struct/struct_unnest_recursion.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +SELECT UNNEST ( ( '1,2,3,4,,6' , ( 1 ) ) ) , x x; +-- +ok +== +SELECT UNNEST ( ( '1,2,3,4,,6' , ( case when random() < 10 then 0 else 1 end ) ) ), 42 x, x; +-- +ok +== diff --git a/parser/testdata/corpus/sql/types/struct/struct_updates.test b/parser/testdata/corpus/sql/types/struct/struct_updates.test new file mode 100644 index 0000000..602d098 --- /dev/null +++ b/parser/testdata/corpus/sql/types/struct/struct_updates.test @@ -0,0 +1,29 @@ +# source: test/sql/types/struct/struct_updates.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +INSERT INTO a VALUES ({'i': 1, 'j': 2}); +-- +ok +== +UPDATE a SET b={'i': 3, 'j': 4} +-- +ok +== +UPDATE a SET b={'i': NULL, 'j': 4} +-- +ok +== +UPDATE a SET b={'i': 3, 'j': NULL} +-- +ok +== +INSERT INTO a VALUES ({'i': 2, 'j': 3}); +-- +ok +== +UPDATE a SET b={'i': NULL, 'j': NULL} WHERE (b).j>=3 +-- +ok +== diff --git a/parser/testdata/corpus/sql/types/struct/test_tuple.test b/parser/testdata/corpus/sql/types/struct/test_tuple.test new file mode 100644 index 0000000..aa5310b --- /dev/null +++ b/parser/testdata/corpus/sql/types/struct/test_tuple.test @@ -0,0 +1,141 @@ +# source: test/sql/types/struct/test_tuple.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +SELECT typeof(row(1, 'a')); +-- +ok +== +SELECT (), typeof(()); +-- +ok +== +SELECT (1, 'a'), typeof((1, 'a')); +-- +ok +== +SELECT (42,), typeof((42,)); +-- +ok +== +SELECT (42,)::VARCHAR::TUPLE(INTEGER); +-- +ok +== +SELECT (42), typeof((42)); +-- +ok +== +SELECT typeof(struct_pack(a := 1, b := 'a')); +-- +ok +== +SELECT typeof(row()), typeof(struct_pack()); +-- +ok +== +SELECT row(), struct_pack(); +-- +ok +== +SELECT row()::STRUCT, struct_pack() = row(); +-- +ok +== +SELECT row(1, 'a'); +-- +ok +== +SELECT typeof(NULL::TUPLE(INTEGER, VARCHAR)); +-- +ok +== +CREATE TABLE t(c TUPLE(INTEGER, VARCHAR)); +-- +ok +== +SELECT column_type FROM (DESCRIBE t); +-- +ok +== +SELECT struct_extract(row(1, 'a'), 1), struct_extract(row(1, 'a'), 2); +-- +ok +== +SELECT struct_extract(row(1, 'a'), 'x'); +-- +ok +== +SELECT struct_keys(row(1, 'a')); +-- +ok +== +SELECT row(1, 'a')::STRUCT(x INTEGER, y VARCHAR); +-- +ok +== +SELECT {'x': 1, 'y': 'a'}::TUPLE(INTEGER, VARCHAR); +-- +ok +== +SELECT typeof(row(1, 'a')) = typeof(struct_pack(a := 1, b := 'a')); +-- +ok +== +SELECT typeof([row(1, 'a'), row(2, 'b')]); +-- +ok +== +SELECT typeof(struct_values({'a': 1, 'b': 'x'})); +-- +ok +== +SELECT typeof(t.c) FROM (SELECT row(1, 'a') AS c UNION ALL SELECT row(2, 'b')) t LIMIT 1; +-- +ok +== +INSERT INTO t VALUES (row(1, 'a')), (row(2, 'b')), (NULL); +-- +ok +== +SELECT c, typeof(c) FROM t ORDER BY c; +-- +ok +== +SELECT struct_extract(c, 1), struct_extract(c, 2) FROM t WHERE c IS NOT NULL ORDER BY 1; +-- +ok +== +ATTACH '{TEST_DIR}/tuple_v2.db' AS v2 (STORAGE_VERSION 'v2.0.0'); +-- +ok +== +CREATE TABLE v2.tup AS SELECT row() AS e, row(1) AS one, row(2, 'b') AS two; +-- +ok +== +DETACH v2; +-- +ok +== +ATTACH '{TEST_DIR}/tuple_v2.db' AS v2 (READ_ONLY); +-- +ok +== +SELECT e, typeof(e), one, typeof(one), two, typeof(two) FROM v2.tup; +-- +ok +== +ATTACH '{TEST_DIR}/tuple_v15.db' AS v15 (STORAGE_VERSION 'v1.5.0'); +-- +ok +== +CREATE TABLE v15.tup AS SELECT row(2, 'b') AS two; +-- +ok +== +DETACH v15; +-- +ok +== diff --git a/parser/testdata/corpus/sql/types/struct/unnamed_struct_casts.test b/parser/testdata/corpus/sql/types/struct/unnamed_struct_casts.test new file mode 100644 index 0000000..14e53ea --- /dev/null +++ b/parser/testdata/corpus/sql/types/struct/unnamed_struct_casts.test @@ -0,0 +1,13 @@ +# source: test/sql/types/struct/unnamed_struct_casts.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +select row(42, 'hello') union all select '{'': 42,'': hello}'; +-- +ok +== +select row(42, 'hello') union all select '(84, world)'; +-- +ok +== diff --git a/parser/testdata/corpus/sql/types/struct/unnamed_struct_comparison.test b/parser/testdata/corpus/sql/types/struct/unnamed_struct_comparison.test new file mode 100644 index 0000000..c74f833 --- /dev/null +++ b/parser/testdata/corpus/sql/types/struct/unnamed_struct_comparison.test @@ -0,0 +1,50 @@ +# source: test/sql/types/struct/unnamed_struct_comparison.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +select a IS DISTINCT FROM b from VALUES ((NULL, 1, NULL), (5, 6, 7)) t(a, b); +-- +ok +== +select a<>b is null from VALUES ((NULL, 1, NULL), (5, 6, 7)) t(a, b); +-- +ok +== +select 1 from values (struct_pack(k := NULL)) t(a) where 1 <> a.k; +-- +ok +== +select [NULL, 6] IS DISTINCT FROM [6, 5]; +-- +ok +== +select 1 from VALUES ([NULL, 6], [5, 6]) t(a, b) where a IS DISTINCT FROM b; +-- +ok +== +select 1 from VALUES ([NULL, 1, NULL], [5, 6, 7]) t(a, b) where a=b; +-- +ok +== +select 1 from VALUES ((NULL, 1, NULL), (5, 6, 7)) t(a, b) where a<>b; +-- +ok +== +select 1 from VALUES ((NULL, 1, NULL), (5, 6, 7)) t(a, b) where a<>b is null; +-- +ok +== +select a<>b is null from VALUES ((NULL, 1, NULL), (5, 6, 7)) t(a, b) where NULL; +-- +ok +== +select 1 from VALUES ((NULL, 1, NULL), (5, 6, 7), (NULL, 2), (4, 5)) t(a, b, c, d) where a<>b and c<>d; +-- +ok +== +select a<>b, c<>d +from VALUES ((NULL, 1, NULL), (5, 6, 7), (NULL, 2), (4, 5)) t(a, b, c, d); +-- +ok +== diff --git a/parser/testdata/corpus/sql/types/struct/unnamed_struct_mix.test b/parser/testdata/corpus/sql/types/struct/unnamed_struct_mix.test new file mode 100644 index 0000000..cdbc6d9 --- /dev/null +++ b/parser/testdata/corpus/sql/types/struct/unnamed_struct_mix.test @@ -0,0 +1,13 @@ +# source: test/sql/types/struct/unnamed_struct_mix.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +select [{ t:'abc', len:5 }, ('abc', 2)] +-- +ok +== +select [('abc', 2), { t:'abc', len:5 }] +-- +ok +== diff --git a/parser/testdata/corpus/sql/types/struct/unnest_column_names.test b/parser/testdata/corpus/sql/types/struct/unnest_column_names.test new file mode 100644 index 0000000..19acdb1 --- /dev/null +++ b/parser/testdata/corpus/sql/types/struct/unnest_column_names.test @@ -0,0 +1,69 @@ +# source: test/sql/types/struct/unnest_column_names.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +SELECT unnest([{'a':{ 'aa': 42}, 'b':{'bb': 84}}], recursive := true, keep_parent_names := true); +-- +ok +== +SELECT column_name, column_type FROM (DESCRIBE SELECT unnest([{'a':{ 'aa': 42}, 'b':{'bb': 84}}], recursive := true, keep_parent_names := true)) +-- +ok +== +SELECT column_name, column_type FROM (DESCRIBE SELECT unnest([{'a':{ 'aa': {'aaa': 42}}, 'b':{'bb': 84}}], recursive := true, keep_parent_names := true)); +-- +ok +== +SELECT column_name, column_type FROM (DESCRIBE SELECT unnest([{'a': 12, 'b': {'bb': {'bbb': 12}}}], recursive := true, keep_parent_names := true)); +-- +ok +== +SELECT column_name, column_type FROM (DESCRIBE SELECT unnest([{'a': 12, 'b': {'bb': {'bbb': 12}}}], recursive := true, keep_parent_names := false)); +-- +ok +== +SELECT column_name, column_type FROM (DESCRIBE SELECT unnest([{'a': 12, 'b': {'bb': {'bbb': 12}}}], recursive := true, max_depth := 3, keep_parent_names := true)); +-- +ok +== +SELECT column_name, column_type FROM (DESCRIBE SELECT unnest([{'a': 12, 'b': {'bb': {'bbb': 12}}}], recursive := true, max_depth := 2, keep_parent_names := true)); +-- +ok +== +SELECT column_name, column_type FROM (DESCRIBE SELECT unnest([{'a': 12, 'b': {'bb': {'bbb': 12}}}], max_depth := 3)); +-- +ok +== +SELECT column_name, column_type FROM (DESCRIBE SELECT unnest(row(row(42)), recursive := true, keep_parent_names := true)); +-- +ok +== +SELECT column_name, column_type FROM (DESCRIBE SELECT unnest(row(row(42)), recursive := true)); +-- +ok +== +SELECT column_name, column_type FROM (DESCRIBE SELECT unnest(row(row(42)))); +-- +ok +== +SELECT column_name, column_type FROM (DESCRIBE SELECT unnest([{'a': 12, 'b': {'': {'': 12}}}], max_depth := 3)); +-- +ok +== +SELECT column_name, column_type FROM (DESCRIBE SELECT unnest([{'': {'': 12}}], recursive := true, keep_parent_names := true)); +-- +ok +== +SELECT column_name, column_type FROM (DESCRIBE SELECT unnest([{}], recursive := true, keep_parent_names := true)); +-- +ok +== +SELECT column_name, column_type FROM (DESCRIBE SELECT unnest([]), recursive := true, keep_parent_names := true)); +-- +error: Parser Error: syntax error at or near ":=" +== +SELECT column_name, column_type FROM (DESCRIBE SELECT unnest(row(row(42), 41), keep_parent_names := true, recursive := true)); +-- +ok +== diff --git a/parser/testdata/corpus/sql/types/struct/unnest_struct.test b/parser/testdata/corpus/sql/types/struct/unnest_struct.test new file mode 100644 index 0000000..03ab188 --- /dev/null +++ b/parser/testdata/corpus/sql/types/struct/unnest_struct.test @@ -0,0 +1,85 @@ +# source: test/sql/types/struct/unnest_struct.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +SELECT UNNEST({'a': 42, 'b': 88}) +-- +ok +== +SELECT a, b FROM (SELECT UNNEST({'a': 42, 'b': 88})) +-- +ok +== +SELECT UNNEST({'a': 42, 'b': {'c': 88, 'd': 99}}) +-- +ok +== +SELECT UNNEST({'a': 42, 'b': {'c': 88, 'd': 99}}, recursive := true) +-- +ok +== +SELECT UNNEST({'a': 42, 'b': {'c': {'x': 4}, 'd': 99}}, max_depth := 2) +-- +ok +== +SELECT a, c, d FROM (SELECT UNNEST({'a': 42, 'b': {'c': 88, 'd': 99}}, recursive := true)) +-- +ok +== +SELECT a, "b.c", "b.d" FROM (SELECT UNNEST({'a': 42, 'b': {'c': 88, 'd': 99}}, recursive := true, keep_parent_names := true)) +-- +ok +== +SELECT UNNEST([{'a': 42, 'b': 88}, {'a': NULL, 'b': 99}]) +-- +ok +== +SELECT UNNEST([{'a': 42, 'b': 88}, {'a': NULL, 'b': 99}], recursive := true) +-- +ok +== +SELECT UNNEST([[{'a': 42, 'b': {'x': 99}}, {'a': NULL, 'b': {'x': NULL}}]], max_depth:=1) +-- +ok +== +SELECT UNNEST([[{'a': 42, 'b': {'x': 99}}, {'a': NULL, 'b': {'x': NULL}}]], max_depth:=2) +-- +ok +== +SELECT UNNEST([[{'a': 42, 'b': {'x': 99}}, {'a': NULL, 'b': {'x': NULL}}]], max_depth:=3) +-- +ok +== +SELECT UNNEST([[{'a': 42, 'b': {'x': 99}}, {'a': NULL, 'b': {'x': NULL}}]], max_depth:=4) +-- +ok +== +SELECT UNNEST({'a': [1, 2, 3]}, recursive := true) +-- +ok +== +SELECT UNNEST({'a': 44, 'b': 88}), UNNEST([1, 2, 3]) +-- +ok +== +SELECT UNNEST({'a': 44, 'b': 88}), UNNEST([[1, 2, 3], [4, 5]], recursive := true) +-- +ok +== +SELECT a, a_1, b FROM (SELECT UNNEST({'a': 42, 'b': {'a': 88, 'b': 99}}, recursive := true)) +-- +ok +== +SELECT a, "b.a", "b.b" FROM (SELECT UNNEST({'a': 42, 'b': {'a': 88, 'b': 99}}, recursive := true, keep_parent_names := true)) +-- +ok +== +SELECT UNNEST({'a': 42, 'b': 88}) + 42 +-- +ok +== +SELECT UNNEST(UNNEST([{'a': 42, 'b': 88}, {'a': NULL, 'b': 99}])) +-- +ok +== diff --git a/parser/testdata/corpus/sql/types/struct/unnest_struct_mix.test b/parser/testdata/corpus/sql/types/struct/unnest_struct_mix.test new file mode 100644 index 0000000..adf2ef3 --- /dev/null +++ b/parser/testdata/corpus/sql/types/struct/unnest_struct_mix.test @@ -0,0 +1,73 @@ +# source: test/sql/types/struct/unnest_struct_mix.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +CREATE TABLE tbl_structs AS SELECT {'a': 1, 'b': 2, 'c': 3} AS s; +-- +ok +== +INSERT INTO tbl_structs VALUES ({'a': 2, 'b': 3, 'c': 1}); +-- +ok +== +INSERT INTO tbl_structs VALUES ({'a': 3, 'b': 1, 'c': 2}); +-- +ok +== +SELECT UNNEST(s) FROM tbl_structs UNION ALL SELECT s.a, s.b, s.c FROM tbl_structs ORDER BY s.a, s.b, s.c; +-- +ok +== +SELECT * FROM tbl_structs ORDER BY UNNEST(s); +-- +ok +== +CREATE OR REPLACE TABLE tbl_structs AS SELECT {'a': 1, 'b': 2, 'c': 3} AS s; +-- +ok +== +INSERT INTO tbl_structs VALUES ({'a': 1, 'b': 3, 'c': 1}); +-- +ok +== +INSERT INTO tbl_structs VALUES ({'a': 1, 'b': 1, 'c': 2}); +-- +ok +== +select unnest(s) from tbl_structs order by all; +-- +ok +== +select unnest(s) from tbl_structs order by 2 collate nocase; +-- +ok +== +CREATE OR REPLACE TABLE tbl_structs AS SELECT {'a': 'hello'} s; +-- +ok +== +INSERT INTO tbl_structs VALUES ({'a': 'WORLD'}); +-- +ok +== +SELECT UNNEST(s) FROM tbl_structs ORDER BY 1 COLLATE NOCASE; +-- +ok +== +CREATE OR REPLACE TABLE tbl_structs AS SELECT {'a': 'hello', 'b': 1} s; +-- +ok +== +INSERT INTO tbl_structs VALUES ({'a': 'WORLD', 'b': 2}); +-- +ok +== +SELECT UNNEST(s) FROM tbl_structs UNION ALL SELECT s.a, s.b FROM tbl_structs ORDER BY 1 COLLATE NOCASE; +-- +ok +== +SELECT UNNEST(s), -s.b AS id FROM tbl_structs UNION ALL SELECT s.a, s.b, s.b FROM tbl_structs ORDER BY id; +-- +ok +== diff --git a/parser/testdata/corpus/sql/types/struct/unnest_struct_subquery.test b/parser/testdata/corpus/sql/types/struct/unnest_struct_subquery.test new file mode 100644 index 0000000..b8e2d0d --- /dev/null +++ b/parser/testdata/corpus/sql/types/struct/unnest_struct_subquery.test @@ -0,0 +1,17 @@ +# source: test/sql/types/struct/unnest_struct_subquery.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +SELECT (SELECT UNNEST(a).a) FROM (VALUES ({'a': 42, 'b': 88})) t(a); +-- +ok +== +SELECT UNNEST(a) FROM (VALUES ({'a': 42, 'b': 88})) t(a); +-- +ok +== +SELECT (SELECT t.x FROM (SELECT UNNEST(a)) t(x)) FROM (VALUES ({'a': 42, 'b': 88})) t(a); +-- +ok +== diff --git a/parser/testdata/corpus/sql/types/struct/update_empty_row.test b/parser/testdata/corpus/sql/types/struct/update_empty_row.test new file mode 100644 index 0000000..f5931bd --- /dev/null +++ b/parser/testdata/corpus/sql/types/struct/update_empty_row.test @@ -0,0 +1,9 @@ +# source: test/sql/types/struct/update_empty_row.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +UPDATE t0 SET (c0) = ROW(); +-- +error: Parser Error: Could not perform assignment, expected 1 values, got 0 +== diff --git a/parser/testdata/corpus/sql/types/struct/update_empty_row.test.metadata.json b/parser/testdata/corpus/sql/types/struct/update_empty_row.test.metadata.json new file mode 100644 index 0000000..81a2428 --- /dev/null +++ b/parser/testdata/corpus/sql/types/struct/update_empty_row.test.metadata.json @@ -0,0 +1,5 @@ +{ + "todo": { + "72cdb7d3a7763501": "transformer-raised parser error: upstream rejects in the transformer, not the grammar; expected to clear as transformers land (milestones 3-5)" + } +} diff --git a/parser/testdata/corpus/sql/types/test_date_cast.test b/parser/testdata/corpus/sql/types/test_date_cast.test new file mode 100644 index 0000000..74614de --- /dev/null +++ b/parser/testdata/corpus/sql/types/test_date_cast.test @@ -0,0 +1,22 @@ +# source: test/sql/types/test_date_cast.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +CREATE TABLE df (x VARCHAR, y BIGINT); +-- +ok +== +INSERT INTO df VALUES ('2021-01-01 12:00:00', 1); +-- +ok +== +select + CAST(x as DATE) = '2021-01-01' a, + IF(CAST(x as DATE) = '2021-01-01', y, 0) b, + CASE WHEN CAST(x as DATE) = '2021-01-01' THEN y ELSE 0 END c, + IF(CAST(x as DATE) = '2021-01-01', 1, 0) d +from df +-- +ok +== diff --git a/parser/testdata/corpus/sql/types/test_null_type.test b/parser/testdata/corpus/sql/types/test_null_type.test new file mode 100644 index 0000000..2f662d2 --- /dev/null +++ b/parser/testdata/corpus/sql/types/test_null_type.test @@ -0,0 +1,77 @@ +# source: test/sql/types/test_null_type.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +create table null_table (i "null") +-- +ok +== +select typeof(i) from null_table; +-- +ok +== +insert into null_table values (null) +-- +ok +== +select 42::{type}::"null" +-- +error: Parser Error: syntax error at or near "{" +== +insert into null_table values (42::{type}) +-- +error: Parser Error: syntax error at or near "{" +== +create table null_list (i "null"[]) +-- +ok +== +insert into null_list values (null), ([null]) +-- +ok +== +select i from null_list +-- +ok +== +select i::{type}[] from null_list +-- +error: Parser Error: syntax error at or near "{" +== +insert into null_list values ([42::{type}]) +-- +error: Parser Error: syntax error at or near "{" +== +create table null_struct (i struct(n "null")) +-- +ok +== +insert into null_struct values (null), ({n:null}) +-- +ok +== +select i from null_struct +-- +ok +== +select i::struct(n {type}) from null_struct +-- +error: Parser Error: syntax error at or near "{" +== +insert into null_struct values ({n: 42::{type}}) +-- +error: Parser Error: syntax error at or near "{" +== +create table null_map (i map("null", "null")) +-- +ok +== +insert into null_map values (null), (map([null], [null])) +-- +ok +== +insert into null_map values (map([42::{type}], [7::{type}])) +-- +error: Parser Error: syntax error at or near "{" +== diff --git a/parser/testdata/corpus/sql/types/test_qualified_type_cast.test b/parser/testdata/corpus/sql/types/test_qualified_type_cast.test new file mode 100644 index 0000000..d14f00b --- /dev/null +++ b/parser/testdata/corpus/sql/types/test_qualified_type_cast.test @@ -0,0 +1,33 @@ +# source: test/sql/types/test_qualified_type_cast.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +select 'abc'::text; +-- +ok +== +select 'abc'::main.text; +-- +ok +== +select 'abc'::pg_catalog.text; +-- +ok +== +select 'abc'::main.char; +-- +ok +== +select cast(1 as memory.main.bla.text); +-- +error: Parser Error: syntax error at or near "." +== +SELECT cast (1 as main.{type}) +-- +error: Parser Error: syntax error at or near "{" +== +SELECT cast('2026-01-01' as main.{type}) +-- +error: Parser Error: syntax error at or near "{" +== diff --git a/parser/testdata/corpus/sql/types/test_quotes.test b/parser/testdata/corpus/sql/types/test_quotes.test new file mode 100644 index 0000000..eeae4d8 --- /dev/null +++ b/parser/testdata/corpus/sql/types/test_quotes.test @@ -0,0 +1,120 @@ +# source: test/sql/types/test_quotes.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +CREATE TABLE t_defaults ( + a UTINYINT DEFAULT CAST(1 AS UTINYINT), + b USMALLINT DEFAULT CAST(1 AS USMALLINT), + c UINTEGER DEFAULT CAST(1 AS UINTEGER), + d UBIGINT DEFAULT CAST(1 AS UBIGINT), + e UHUGEINT DEFAULT CAST(1 AS UHUGEINT), + f TINYINT DEFAULT CAST(1 AS TINYINT), + g HUGEINT DEFAULT CAST(1 AS HUGEINT), + h DOUBLE DEFAULT CAST(1.0 AS DOUBLE), + i SMALLINT DEFAULT CAST(1 AS SMALLINT), + j INTEGER DEFAULT CAST(1 AS INTEGER) +); +-- +ok +== +SELECT column_name, column_default, data_type +FROM information_schema.columns +WHERE table_name = 't_defaults' +ORDER BY column_name; +-- +ok +== +CREATE VIEW v_utiny AS SELECT CAST(1 AS UTINYINT); +-- +ok +== +CREATE VIEW v_usmall AS SELECT CAST(1 AS USMALLINT); +-- +ok +== +CREATE VIEW v_uint AS SELECT CAST(1 AS UINTEGER); +-- +ok +== +CREATE VIEW v_ubig AS SELECT CAST(1 AS UBIGINT); +-- +ok +== +CREATE VIEW v_uhuge AS SELECT CAST(1 AS UHUGEINT); +-- +ok +== +CREATE VIEW v_tiny AS SELECT CAST(1 AS TINYINT); +-- +ok +== +CREATE VIEW v_huge AS SELECT CAST(1 AS HUGEINT); +-- +ok +== +CREATE VIEW v_dbl AS SELECT CAST(1.0 AS DOUBLE); +-- +ok +== +CREATE VIEW v_small AS SELECT CAST(1 AS SMALLINT); +-- +ok +== +CREATE VIEW v_int AS SELECT CAST(1 AS INTEGER); +-- +ok +== +SELECT view_name, sql +FROM duckdb_views() +WHERE view_name IN ('v_utiny','v_usmall','v_uint','v_ubig','v_uhuge', + 'v_tiny','v_huge','v_dbl', 'v_small','v_int') +ORDER BY view_name; +-- +ok +== +CREATE VIEW v_struct AS SELECT CAST({'x': 1, 'y': 2} AS STRUCT(x UTINYINT, y USMALLINT)) AS s; +-- +ok +== +CREATE VIEW v_list AS SELECT CAST([1, 2] AS UTINYINT[]) AS l; +-- +ok +== +SELECT sql FROM duckdb_views() WHERE view_name = 'v_struct'; +-- +ok +== +SELECT sql FROM duckdb_views() WHERE view_name = 'v_list'; +-- +ok +== +CREATE TYPE "coalesce" AS ENUM('a', 'b', 'c'); +-- +ok +== +CREATE TYPE "select" AS ENUM('x', 'y', 'z'); +-- +ok +== +CREATE TABLE t_kw_udt ( + a VARCHAR DEFAULT CAST('a' AS "coalesce"), + b VARCHAR DEFAULT CAST('x' AS "select") +); +-- +ok +== +SELECT column_name, column_default, data_type +FROM information_schema.columns +WHERE table_name = 't_kw_udt' +ORDER BY column_name; +-- +ok +== +CREATE TABLE t_kw_udt2 ( + a VARCHAR DEFAULT CAST('a' AS "coalesce"), + b VARCHAR DEFAULT CAST('x' AS "select") +); +-- +ok +== diff --git a/parser/testdata/corpus/sql/types/test_typeof.test b/parser/testdata/corpus/sql/types/test_typeof.test new file mode 100644 index 0000000..b795b79 --- /dev/null +++ b/parser/testdata/corpus/sql/types/test_typeof.test @@ -0,0 +1,9 @@ +# source: test/sql/types/test_typeof.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +SELECT typeof(1) +-- +ok +== diff --git a/parser/testdata/corpus/sql/types/test_user_type_errors_18452.test b/parser/testdata/corpus/sql/types/test_user_type_errors_18452.test new file mode 100644 index 0000000..6a29fe7 --- /dev/null +++ b/parser/testdata/corpus/sql/types/test_user_type_errors_18452.test @@ -0,0 +1,21 @@ +# source: test/sql/types/test_user_type_errors_18452.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +CREATE TYPE l AS X(0,0,0,0,0,0,0,0,0,0,0); +-- +ok +== +CREATE TYPE ll AS XX(1,2,3,4,5,6,7,8,9,10); +-- +ok +== +CREATE TYPE ll AS XX(1,2,3,4,5,6,7,8,9); +-- +ok +== +CREATE TYPE ll AS XX(a,2,3,4,5,6,7,8,9); +-- +error: Parser Error: Expected a constant as type modifier +== diff --git a/parser/testdata/corpus/sql/types/test_user_type_errors_18452.test.metadata.json b/parser/testdata/corpus/sql/types/test_user_type_errors_18452.test.metadata.json new file mode 100644 index 0000000..75e2ee3 --- /dev/null +++ b/parser/testdata/corpus/sql/types/test_user_type_errors_18452.test.metadata.json @@ -0,0 +1,5 @@ +{ + "todo": { + "cd46323b2b96778c": "transformer-raised parser error: upstream rejects in the transformer, not the grammar; expected to clear as transformers land (milestones 3-5)" + } +} diff --git a/parser/testdata/corpus/sql/types/time/test_time.test b/parser/testdata/corpus/sql/types/time/test_time.test new file mode 100644 index 0000000..dcf54ea --- /dev/null +++ b/parser/testdata/corpus/sql/types/time/test_time.test @@ -0,0 +1,53 @@ +# source: test/sql/types/time/test_time.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +SELECT * FROM times +-- +ok +== +SELECT cast(i AS VARCHAR) FROM times +-- +ok +== +SELECT ''::TIME +-- +ok +== +SELECT ' '::TIME +-- +ok +== +SELECT ' '::TIME +-- +ok +== +SELECT '1'::TIME +-- +ok +== +SELECT '11'::TIME +-- +ok +== +SELECT '11:'::TIME +-- +ok +== +SELECT '11:1'::TIME +-- +ok +== +SELECT '11:11'::TIME +-- +ok +== +SELECT '11:11:'::TIME +-- +ok +== +SELECT '11:11:f'::TIME +-- +ok +== diff --git a/parser/testdata/corpus/sql/types/time/test_time_2411.test b/parser/testdata/corpus/sql/types/time/test_time_2411.test new file mode 100644 index 0000000..2661ca8 --- /dev/null +++ b/parser/testdata/corpus/sql/types/time/test_time_2411.test @@ -0,0 +1,13 @@ +# source: test/sql/types/time/test_time_2411.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +INSERT INTO times VALUES ('00:00:01') +-- +ok +== +select count(*) from times inner join timestamp on (timestamp.i::TIME = times.i) +-- +ok +== diff --git a/parser/testdata/corpus/sql/types/time/test_time_ns.test b/parser/testdata/corpus/sql/types/time/test_time_ns.test new file mode 100644 index 0000000..4b1c9c4 --- /dev/null +++ b/parser/testdata/corpus/sql/types/time/test_time_ns.test @@ -0,0 +1,136 @@ +# source: test/sql/types/time/test_time_ns.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +SELECT '15:30:00.123456789'::TIME_NS; +-- +ok +== +CREATE TABLE times(tns TIME_NS) +-- +ok +== +INSERT INTO times VALUES + ('00:00:00'), + ('00:01:20'), + ('10:21:00.0'), + ('10:21:00.1'), + ('10:21:00.9'), + ('16:04:22.01'), + ('16:04:22.12'), + ('16:04:22.97'), + ('20:08:10.001'), + ('20:08:10.123'), + ('20:08:10.998'), + ('03:45:47.0001'), + ('03:45:47.1234'), + ('03:45:47.9999'), + ('02:27:19.00001'), + ('02:27:19.12345'), + ('02:27:19.99899'), + ('09:01:54.000001'), + ('09:01:54.123456'), + ('09:01:54.999978'), + ('23:35:57.0000001'), + ('23:35:57.1234567'), + ('23:35:57.9999999'), + ('13:00:00.00000001'), + ('13:00:00.12345678'), + ('13:00:00.99999989'), + ('23:59:59.000000001'), + ('23:59:59.123456789'), + ('23:59:59.999999999'), + ('24:00:00.000000000'), + (NULL) +-- +ok +== +SELECT tns, + DATE_PART('hour', tns), + DATE_PART('minute', tns), + DATE_PART('second', tns), +FROM times; +-- +ok +== +SELECT tns, + DATE_PART('millisecond', tns), + DATE_PART('microsecond', tns), + nanosecond(tns), + DATE_PART('epoch', tns), +FROM times; +-- +ok +== +SELECT tns, DATE_PART('{part}', tns) p +FROM times +WHERE p <> 0 +-- +ok +== +SELECT tns, DATE_PART(['hour', 'minute', 'second'], tns) +FROM times; +-- +ok +== +SELECT tns, DATE_PART(['millisecond', 'microsecond', 'epoch'], tns) +FROM times; +-- +ok +== +SELECT tns, DATE_PART(['timezone', 'timezone_hour', 'timezone_minute'], tns) p +FROM times +WHERE p <> {'timezone': 0, 'timezone_hour': 0, 'timezone_minute': 0} +-- +ok +== +SELECT date_part('{part}', '23:59:59.123456789'::TIME_NS); +-- +ok +== +SELECT date_part(['{part}'], '23:59:59.123456789'::TIME_NS); +-- +ok +== +SELECT date_part('julian', '23:59:59.123456789'::TIME_NS); +-- +ok +== +SELECT date_part(['julian'], '23:59:59.123456789'::TIME_NS); +-- +ok +== +SELECT '23:59:59.123456'::TIME::TIME_NS; +-- +ok +== +SELECT tns, tns::TIME t +FROM times +-- +ok +== +SELECT '2025-05-20 15:30:00.123456789'::TIMESTAMP_NS::TIME_NS t; +-- +ok +== +SELECT '1962-05-20 15:30:00.123456789'::TIMESTAMP_NS::TIME_NS t; +-- +ok +== +SELECT (TIMESTAMP_NS '1969-12-31 23:59:59.999999999'::TIME_NS)::VARCHAR t; +-- +ok +== +SELECT '1969-12-31 23:59:59.999999'::TIMESTAMP_NS::TIME_NS t; +-- +ok +== +SELECT '1969-12-31 23:59:59.000000001'::TIMESTAMP_NS::TIME_NS t; +-- +ok +== +SELECT '1969-06-15 08:30:15.123456789'::TIMESTAMP_NS::TIME_NS t; +-- +ok +== diff --git a/parser/testdata/corpus/sql/types/time/test_time_tz.test b/parser/testdata/corpus/sql/types/time/test_time_tz.test new file mode 100644 index 0000000..d13dce3 --- /dev/null +++ b/parser/testdata/corpus/sql/types/time/test_time_tz.test @@ -0,0 +1,95 @@ +# source: test/sql/types/time/test_time_tz.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +select timetz '02:30:00'; +-- +ok +== +SELECT '02:30:00+04'::TIMETZ; +-- +ok +== +SELECT '02:30:00+04:30'::TIMETZ; +-- +ok +== +SELECT '02:30:00+04:30:45'::TIMETZ; +-- +ok +== +SELECT '2023-08-20 16:15:03.123456'::TIMETZ; +-- +ok +== +SELECT '02:30:00+1200'::TIMETZ; +-- +ok +== +SELECT '02:30:00-1200'::TIMETZ; +-- +ok +== +SELECT '2023-08-20 16:15:03.123456'::TIMESTAMP::TIMETZ; +-- +ok +== +SELECT '16:15:03.123456'::TIME::TIMETZ; +-- +ok +== +SELECT '02:30:00+04'::TIMETZ::TIME; +-- +ok +== +SELECT '2021-08-20'::TIME; +-- +ok +== +SELECT * FROM timetzs ORDER BY ALL +-- +ok +== +SELECT + lhs.ttz, + rhs.ttz, + lhs.ttz < rhs.ttz, + lhs.ttz <= rhs.ttz, + lhs.ttz = rhs.ttz, + lhs.ttz >= rhs.ttz, + lhs.ttz > rhs.ttz, + lhs.ttz <> rhs.ttz, +FROM timetzs lhs, timetzs rhs +ORDER BY ALL +-- +ok +== +SELECT '02:30:00>04'::TIMETZ; +-- +ok +== +SELECT '02:30:00+4'::TIMETZ; +-- +ok +== +SELECT '02:30:00+4xx'::TIMETZ; +-- +ok +== +SELECT '02:30:00+2000'::TIMETZ; +-- +ok +== +SELECT '02:30:00+20:xx'::TIMETZ; +-- +ok +== +SELECT '02:30:00+20:45:xx'::TIMETZ; +-- +ok +== +SELECT 'infinity'::TIMETZ; +-- +ok +== diff --git a/parser/testdata/corpus/sql/types/time/test_time_tz_collate.test b/parser/testdata/corpus/sql/types/time/test_time_tz_collate.test new file mode 100644 index 0000000..0684213 --- /dev/null +++ b/parser/testdata/corpus/sql/types/time/test_time_tz_collate.test @@ -0,0 +1,55 @@ +# source: test/sql/types/time/test_time_tz_collate.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +SELECT {comparison_type}'09:00:00+00:00'::TIMETZ) >{comparison_type}'09:01:00+01:00'::TIMETZ); +-- +error: Parser Error: syntax error at or near "}" +== +SELECT {comparison_type}'08:00:00+01:00'::TIMETZ) >{comparison_type}'09:01:00+01:00'::TIMETZ); +-- +error: Parser Error: syntax error at or near "}" +== +SELECT {comparison_type}'08:00:00+01:00'::TIMETZ) = {comparison_type}'09:01:00+01:00'::TIMETZ); +-- +error: Parser Error: syntax error at or near "}" +== +SELECT {comparison_type}'08:01:00+00:00'::TIMETZ) = {comparison_type}'09:01:00+01:00'::TIMETZ); +-- +error: Parser Error: syntax error at or near "}" +== +SELECT {comparison_type}'08:01:00+00:00'::TIMETZ) > {comparison_type}'09:01:00+01:00'::TIMETZ); +-- +error: Parser Error: syntax error at or near "}" +== +SELECT {comparison_type}'08:02:00+00:00'::TIMETZ) > {comparison_type}'09:01:00+01:00'::TIMETZ); +-- +error: Parser Error: syntax error at or near "}" +== +SELECT {comparison_type}'08:00:00+00:00'::TIMETZ) > {comparison_type}'09:01:00+01:00'::TIMETZ); +-- +error: Parser Error: syntax error at or near "}" +== +SELECT {comparison_type}'10:01:00+02:00'::TIMETZ) > {comparison_type}'09:01:00+01:00'::TIMETZ); +-- +error: Parser Error: syntax error at or near "}" +== +SELECT * FROM timetzs ORDER BY {comparison_type}ttz) +-- +error: Parser Error: syntax error at or near "}" +== +SELECT + lhs.ttz, + rhs.ttz, + {comparison_type}lhs.ttz) < {comparison_type}rhs.ttz), + {comparison_type}lhs.ttz) <= {comparison_type}rhs.ttz), + {comparison_type}lhs.ttz) = {comparison_type}rhs.ttz), + {comparison_type}lhs.ttz) >= {comparison_type}rhs.ttz), + {comparison_type}lhs.ttz) > {comparison_type}rhs.ttz), + {comparison_type}lhs.ttz) <> {comparison_type}rhs.ttz), +FROM timetzs lhs, timetzs rhs +ORDER BY {comparison_type}lhs.ttz), {comparison_type}rhs.ttz) +-- +error: Parser Error: syntax error at or near "}" +== diff --git a/parser/testdata/corpus/sql/types/time/test_time_tz_icu.test b/parser/testdata/corpus/sql/types/time/test_time_tz_icu.test new file mode 100644 index 0000000..a66d08b --- /dev/null +++ b/parser/testdata/corpus/sql/types/time/test_time_tz_icu.test @@ -0,0 +1,66 @@ +# source: test/sql/types/time/test_time_tz_icu.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +SET TimeZone='Asia/Singapore'; +-- +ok +== +CREATE OR REPLACE TABLE single(c0 TIME WITH TIME ZONE); +-- +ok +== +INSERT INTO single(c0) VALUES ('12:34:56'); +-- +ok +== +SELECT + c0, + c0::TIME AS t, + c0::TIME::TIMETZ AS tz, +FROM single; +-- +ok +== +SELECT + (c0::TIME = '12:34:56') AS e, + (c0::TIME <> '12:34:56') AS u, + (c0::TIME IN ('12:34:56')) AS i, + (c0::TIME NOT IN ('12:34:56')) AS n, +FROM single; +-- +ok +== +SET TimeZone='America/Phoenix'; +-- +ok +== +SELECT '01:00:00'::TIMETZ AS ttz +-- +ok +== +SELECT '01:00:00+02'::TIMETZ AS ttz +-- +ok +== +SELECT '01:00:00'::TIME::TIMETZ AS ttz +-- +ok +== +SET TimeZone='Asia/Kolkata'; +-- +ok +== +SELECT '00:00:00'::TIMETZ AS ttz +-- +ok +== +SELECT '00:00:00'::TIME::TIMETZ AS ttz +-- +ok +== +SELECT ('00:00:00'::TIMETZ = '00:00:00'::TIME::TIMETZ) AS same +-- +ok +== diff --git a/parser/testdata/corpus/sql/types/time/time_limits.test b/parser/testdata/corpus/sql/types/time/time_limits.test new file mode 100644 index 0000000..c45bdf7 --- /dev/null +++ b/parser/testdata/corpus/sql/types/time/time_limits.test @@ -0,0 +1,37 @@ +# source: test/sql/types/time/time_limits.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +select time '23:59:59.999999' +-- +ok +== +select time '23:59:59.999999' + interval (1) microsecond +-- +ok +== +select time '23:59:59.999999' + interval (1) second +-- +ok +== +select time '23:59:59.999999' + interval (1) minute +-- +ok +== +select time '23:59:59.999999' + interval (1) hour +-- +ok +== +select time '23:59:59.999999' + interval (1) day +-- +ok +== +select time '23:59:59.999999' + interval (1) month +-- +ok +== +select time '23:59:59.999999' + interval (1) year +-- +ok +== diff --git a/parser/testdata/corpus/sql/types/time/time_parsing.test b/parser/testdata/corpus/sql/types/time/time_parsing.test new file mode 100644 index 0000000..95dd8f9 --- /dev/null +++ b/parser/testdata/corpus/sql/types/time/time_parsing.test @@ -0,0 +1,73 @@ +# source: test/sql/types/time/time_parsing.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +SELECT '14:42:04'::TIME::VARCHAR +-- +ok +== +SELECT '14:42:04.35'::TIME::VARCHAR +-- +ok +== +SELECT '14:42:04.999999'::TIME::VARCHAR +-- +ok +== +SELECT '14:42:04.999999999'::TIME::VARCHAR +-- +ok +== +SELECT '14:42:04.000000'::TIME::VARCHAR +-- +ok +== +SELECT '14:42:04.500'::TIME::VARCHAR +-- +ok +== +SELECT '50:42:04.500'::TIME::VARCHAR +-- +ok +== +SELECT '100:42:04.500'::TIME::VARCHAR +-- +ok +== +SELECT '14:70:04.500'::TIME::VARCHAR +-- +ok +== +SELECT '14:100:04.500'::TIME::VARCHAR +-- +ok +== +SELECT '14:42:70.500'::TIME::VARCHAR +-- +ok +== +SELECT '14-42-04'::TIME::VARCHAR +-- +ok +== +SELECT '1:2'::VARIANT::TIME +-- +ok +== +SELECT '123:4'::VARIANT::TIME +-- +ok +== +SELECT '12:3'::VARIANT::TIME +-- +ok +== +SELECT '11:22'::VARIANT::TIME +-- +ok +== +SELECT '11:22:33'::VARIANT::TIME +-- +ok +== diff --git a/parser/testdata/corpus/sql/types/time/time_try_cast.test b/parser/testdata/corpus/sql/types/time/time_try_cast.test new file mode 100644 index 0000000..c772577 --- /dev/null +++ b/parser/testdata/corpus/sql/types/time/time_try_cast.test @@ -0,0 +1,69 @@ +# source: test/sql/types/time/time_try_cast.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +select try_cast('' as time) +-- +ok +== +select try_cast(' ' as time) +-- +ok +== +select try_cast('11' as time) +-- +ok +== +select try_cast('11:' as time) +-- +ok +== +select try_cast('11:11' as time) +-- +ok +== +select try_cast('11:11:' as time) +-- +ok +== +select try_cast('11:11:A' as time) +-- +ok +== +select try_cast('11:11:A1' as time) +-- +ok +== +select try_cast('11/11/11' as time) +-- +ok +== +select try_cast(' 11:11:11 ' as time) +-- +ok +== +select try_cast('24:00:00' as time) +-- +ok +== +select try_cast('24:00:01' as time) +-- +ok +== +select try_cast('23:60:00' as time) +-- +ok +== +select try_cast('23:59:60' as time) +-- +ok +== +select try_cast('23:59:59' as time) +-- +ok +== +select try_cast('23:59:59.999999' as time) +-- +ok +== diff --git a/parser/testdata/corpus/sql/types/timestamp/alternative_timestamp_casts.test b/parser/testdata/corpus/sql/types/timestamp/alternative_timestamp_casts.test new file mode 100644 index 0000000..6a98f12 --- /dev/null +++ b/parser/testdata/corpus/sql/types/timestamp/alternative_timestamp_casts.test @@ -0,0 +1,67 @@ +# source: test/sql/types/timestamp/alternative_timestamp_casts.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +SELECT DATE '1992-01-01'::TIMESTAMP_MS +-- +ok +== +SELECT DATE '1992-01-01'::TIMESTAMP_S +-- +ok +== +SELECT DATE '1992-01-01'::TIMESTAMP_NS +-- +ok +== +select '2023-12-08 08:51:39.123456'::TIMESTAMP_MS::TIME; +-- +ok +== +select '2023-12-08 08:51:39.123456'::TIMESTAMP_S::TIME; +-- +ok +== +select '2023-12-08 08:51:39.123456'::TIMESTAMP_NS::TIME; +-- +ok +== +select '2024-05-10 11:06:33.446'::TIMESTAMP_S; +-- +ok +== +select '2024-05-10 11:06:33.846'::TIMESTAMP_S; +-- +ok +== +select '2024-05-10 11:06:33.123446'::TIMESTAMP_MS; +-- +ok +== +select '2024-05-10 11:06:33.123846'::TIMESTAMP_MS; +-- +ok +== +CREATE TABLE issue11995 (t TIMESTAMP); +-- +ok +== +INSERT INTO issue11995 VALUES + ('2024-05-10 11:06:33.446'), + ('2024-05-10 11:06:33.846'), + ('2024-05-10 11:06:33.123446'), + ('2024-05-10 11:06:33.523846') +; +-- +ok +== +SELECT t, t::TIMESTAMP_MS, t::TIMESTAMP_S +FROM issue11995 +-- +ok +== +select '1900-01-01 03:08:47'::TIMESTAMP::TIMESTAMP_MS; +-- +ok +== diff --git a/parser/testdata/corpus/sql/types/timestamp/bc_timestamp.test b/parser/testdata/corpus/sql/types/timestamp/bc_timestamp.test new file mode 100644 index 0000000..5bf55ab --- /dev/null +++ b/parser/testdata/corpus/sql/types/timestamp/bc_timestamp.test @@ -0,0 +1,17 @@ +# source: test/sql/types/timestamp/bc_timestamp.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +SELECT '1969-01-01 01:03:20.45432'::TIMESTAMP::VARCHAR +-- +ok +== +SELECT '-1000-01-01 01:03:20.45432'::TIMESTAMP::VARCHAR +-- +ok +== +SELECT '1000-01-01 (BC) 01:03:20.45432'::TIMESTAMP::VARCHAR +-- +ok +== diff --git a/parser/testdata/corpus/sql/types/timestamp/infinity_cast_coverage.test b/parser/testdata/corpus/sql/types/timestamp/infinity_cast_coverage.test new file mode 100644 index 0000000..fe188f3 --- /dev/null +++ b/parser/testdata/corpus/sql/types/timestamp/infinity_cast_coverage.test @@ -0,0 +1,9 @@ +# source: test/sql/types/timestamp/infinity_cast_coverage.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +select '{infinity_string}'::{base_type}::{target_type} == '{infinity_string}' +-- +error: Parser Error: syntax error at or near "{" +== diff --git a/parser/testdata/corpus/sql/types/timestamp/test_incorrect_timestamp.test b/parser/testdata/corpus/sql/types/timestamp/test_incorrect_timestamp.test new file mode 100644 index 0000000..17ac41d --- /dev/null +++ b/parser/testdata/corpus/sql/types/timestamp/test_incorrect_timestamp.test @@ -0,0 +1,65 @@ +# source: test/sql/types/timestamp/test_incorrect_timestamp.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +CREATE TABLE timestamp(t TIMESTAMP) +-- +ok +== +INSERT INTO timestamp VALUES ('blabla') +-- +ok +== +INSERT INTO timestamp VALUES ('1993-20-14 00:00:00') +-- +ok +== +INSERT INTO timestamp VALUES ('1993-08-99 00:00:00') +-- +ok +== +INSERT INTO timestamp VALUES ('1993-02-29 00:00:00') +-- +ok +== +INSERT INTO timestamp VALUES ('1900-02-29 00:00:00') +-- +ok +== +INSERT INTO timestamp VALUES ('1992-02-29 00:00:00') +-- +ok +== +INSERT INTO timestamp VALUES ('2000-02-29 00:00:00') +-- +ok +== +INSERT INTO timestamp VALUES ('02-02-1992 00:00:00') +-- +ok +== +INSERT INTO timestamp VALUES ('1900-1-1 59:59:23') +-- +ok +== +INSERT INTO timestamp VALUES ('1900a01a01 00:00:00') +-- +ok +== +INSERT INTO timestamp VALUES ('1900-1-1 00;00;00') +-- +ok +== +INSERT INTO timestamp VALUES ('1900-1-1 00a00a00') +-- +ok +== +INSERT INTO timestamp VALUES ('1900-1-1 00/00/00') +-- +ok +== +INSERT INTO timestamp VALUES ('1900-1-1 00-00-00') +-- +ok +== diff --git a/parser/testdata/corpus/sql/types/timestamp/test_infinite_time.test b/parser/testdata/corpus/sql/types/timestamp/test_infinite_time.test new file mode 100644 index 0000000..be24055 --- /dev/null +++ b/parser/testdata/corpus/sql/types/timestamp/test_infinite_time.test @@ -0,0 +1,219 @@ +# source: test/sql/types/timestamp/test_infinite_time.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +SELECT '{str}'::{datatype}, '-{str}'::{datatype}; +-- +error: Parser Error: syntax error at or near "{" +== +SELECT '{special} 00:00:00'::{datatype}; +-- +error: Parser Error: syntax error at or near "{" +== +CREATE TABLE specials (ts TIMESTAMP, tstz TIMESTAMPTZ, dt DATE); +-- +ok +== +INSERT INTO specials VALUES + ('infinity'::TIMESTAMP, 'infinity'::TIMESTAMPTZ, 'infinity'::DATE), + ('-infinity'::TIMESTAMP, '-infinity'::TIMESTAMPTZ, '-infinity'::DATE), + ('epoch'::TIMESTAMP, 'epoch'::TIMESTAMPTZ, 'epoch'::DATE), +; +-- +ok +== +SELECT * FROM specials; +-- +ok +== +CREATE TABLE abbreviations (ts TIMESTAMP, tstz TIMESTAMPTZ, dt DATE); +-- +ok +== +INSERT INTO abbreviations VALUES + ('inf'::TIMESTAMP, 'inf'::TIMESTAMPTZ, 'inf'::DATE), + ('-inf'::TIMESTAMP, '-inf'::TIMESTAMPTZ, '-inf'::DATE), +; +-- +ok +== +SELECT * FROM abbreviations; +-- +ok +== +SELECT lhs.ts, rhs.ts, + lhs.ts < rhs.ts, lhs.ts <= rhs.ts, + lhs.ts = rhs.ts, lhs.ts <> rhs.ts, + lhs.ts >= rhs.ts, lhs.ts > rhs.ts, +FROM specials lhs, specials rhs +ORDER BY 1, 2 +-- +ok +== +SELECT lhs.tstz, rhs.tstz, + lhs.tstz < rhs.tstz, lhs.tstz <= rhs.tstz, + lhs.tstz = rhs.tstz, lhs.tstz <> rhs.tstz, + lhs.tstz >= rhs.tstz, lhs.tstz > rhs.tstz, +FROM specials lhs, specials rhs +ORDER BY 1, 2 +-- +ok +== +SELECT lhs.dt, rhs.dt, + lhs.dt < rhs.dt, lhs.dt <= rhs.dt, + lhs.dt = rhs.dt, lhs.dt <> rhs.dt, + lhs.dt >= rhs.dt, lhs.dt > rhs.dt, +FROM specials lhs, specials rhs +ORDER BY 1, 2 +-- +ok +== +SELECT MIN(ts), MAX(ts), MIN(tstz), MAX(tstz), MIN(dt), MAX(dt) +FROM specials; +-- +ok +== +SELECT MEDIAN(ts), MEDIAN(tstz), MEDIAN(dt) +FROM specials; +-- +ok +== +SELECT MODE(ts ORDER BY ts DESC), MODE(tstz ORDER BY tstz DESC), MODE(dt ORDER BY dt DESC) +FROM specials; +-- +ok +== +SELECT APPROX_COUNT_DISTINCT(ts), APPROX_COUNT_DISTINCT(tstz), APPROX_COUNT_DISTINCT(dt) +FROM specials; +-- +ok +== +SELECT ARBITRARY(ts), FIRST(ts), LAST(ts) +FROM specials; +-- +ok +== +SELECT ARBITRARY(tstz), FIRST(tstz), LAST(tstz) +FROM specials; +-- +ok +== +SELECT ARBITRARY(dt), FIRST(dt), LAST(dt) +FROM specials; +-- +ok +== +SELECT ARG_MIN({arg}, {val}), ARG_MAX({arg}, {val}) FROM specials; +-- +error: Parser Error: syntax error at or near "}" +== +SELECT HISTOGRAM(ts), HISTOGRAM(tstz), HISTOGRAM(dt) +FROM specials; +-- +ok +== +SELECT QUANTILE_DISC(ts, 0.32), QUANTILE_DISC(tstz, 0.32), QUANTILE_DISC(dt, 0.32) +FROM specials; +-- +ok +== +SELECT QUANTILE_DISC(ts, [0.0, 0.5, 1.0]), QUANTILE_DISC(tstz, [0.0, 0.5, 1.0]), QUANTILE_DISC(dt, [0.0, 0.5, 1.0]) +FROM specials; +-- +ok +== +SELECT QUANTILE_CONT(ts, 0.25), QUANTILE_CONT(tstz, 0.25), QUANTILE_CONT(dt, 0.25) +FROM specials; +-- +ok +== +SELECT QUANTILE_CONT(ts, [0.25, 0.5, 0.75]), QUANTILE_CONT(tstz, [0.25, 0.5, 0.75]), QUANTILE_CONT(dt, [0.25, 0.5, 0.75]) +FROM specials; +-- +ok +== +SELECT MAD(ts), MAD(tstz), MAD(dt) +FROM specials; +-- +ok +== +SELECT ENTROPY(ts), ENTROPY(tstz), ENTROPY(dt) FROM specials; +-- +ok +== +SELECT 'infinity'::{datatype} + INTERVAL (1) {datepart}; +-- +error: Parser Error: syntax error at or near "{" +== +SELECT '-infinity'::{datatype} + INTERVAL (1) {datepart}; +-- +error: Parser Error: syntax error at or near "{" +== +SELECT 'infinity'::{datatype} - INTERVAL (1) {datepart}; +-- +error: Parser Error: syntax error at or near "{" +== +SELECT '-infinity'::{datatype} - INTERVAL (1) {datepart}; +-- +error: Parser Error: syntax error at or near "{" +== +SELECT dt + 1, dt - 1 FROM specials +-- +ok +== +SELECT dt + '12:34:56'::TIME FROM specials +-- +ok +== +SELECT isfinite(ts), isfinite(tstz), isfinite(dt) +FROM specials; +-- +ok +== +SELECT isinf(ts), isinf(tstz), isinf(dt) +FROM specials; +-- +ok +== +select ts::VARCHAR, tstz::VARCHAR, dt::VARCHAR FROM specials +-- +ok +== +select ts::TIME, tstz::TIME, dt::TIME FROM specials +-- +ok +== +select 'infinity'::TIME; +-- +ok +== +select + subtract( + cast('infinity' as timestamp), timestamp '1970-01-01') +-- +ok +== +select + subtract( + timestamp '1970-01-01', + cast('-infinity' as timestamp)) +-- +ok +== +SELECT 'e'::TIMESTAMP +-- +ok +== +SELECT 'e'::DATE +-- +ok +== +SELECT 'i'::TIMESTAMP +-- +ok +== +SELECT 'i'::DATE +-- +ok +== diff --git a/parser/testdata/corpus/sql/types/timestamp/test_timestamp.test b/parser/testdata/corpus/sql/types/timestamp/test_timestamp.test new file mode 100644 index 0000000..0653fa3 --- /dev/null +++ b/parser/testdata/corpus/sql/types/timestamp/test_timestamp.test @@ -0,0 +1,117 @@ +# source: test/sql/types/timestamp/test_timestamp.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +SELECT timestamp '2017-07-23 13:10:11'; +-- +ok +== +SELECT timestamp '2017-07-23T13:10:11', timestamp '2017-07-23T13:10:11Z'; +-- +ok +== +SELECT timestamp '1970-01-01 00:00Z'; +-- +ok +== +SELECT timestamp ' 2017-07-23 13:10:11 '; +-- +ok +== +SELECT timestamp ' 2017-07-23 13:10:11 AA'; +-- +ok +== +SELECT timestamp 'AA2017-07-23 13:10:11'; +-- +ok +== +SELECT timestamp '2017-07-23A13:10:11'; +-- +ok +== +SELECT t FROM timestamp ORDER BY t; +-- +ok +== +SELECT MIN(t) FROM timestamp; +-- +ok +== +SELECT MAX(t) FROM timestamp; +-- +ok +== +SELECT SUM(t) FROM timestamp +-- +ok +== +SELECT AVG(t) FROM timestamp +-- +ok +== +SELECT t+t FROM timestamp +-- +ok +== +SELECT t*t FROM timestamp +-- +ok +== +SELECT t/t FROM timestamp +-- +ok +== +SELECT t%t FROM timestamp +-- +ok +== +SELECT t-t FROM timestamp +-- +ok +== +SELECT YEAR(TIMESTAMP '1992-01-01 01:01:01'); +-- +ok +== +SELECT YEAR(TIMESTAMP '1992-01-01 01:01:01'::DATE); +-- +ok +== +SELECT (TIMESTAMP '1992-01-01 01:01:01')::DATE; +-- +ok +== +SELECT (TIMESTAMP '1992-01-01 01:01:01')::TIME; +-- +ok +== +SELECT t::DATE FROM timestamp WHERE EXTRACT(YEAR from t)=2007 ORDER BY 1 +-- +ok +== +SELECT t::TIME FROM timestamp WHERE EXTRACT(YEAR from t)=2007 ORDER BY 1 +-- +ok +== +SELECT (DATE '1992-01-01')::TIMESTAMP; +-- +ok +== +SELECT TIMESTAMP '2008-01-01 00:00:01.5'::VARCHAR +-- +ok +== +SELECT TIMESTAMP '-8-01-01 00:00:01.5'::VARCHAR +-- +ok +== +SELECT TIMESTAMP '100000-01-01 00:00:01.5'::VARCHAR +-- +ok +== +SELECT CAST(REPEAT('1992-02-02 ', 100000) AS TIMESTAMP); +-- +ok +== diff --git a/parser/testdata/corpus/sql/types/timestamp/test_timestamp_2411.test b/parser/testdata/corpus/sql/types/timestamp/test_timestamp_2411.test new file mode 100644 index 0000000..4c3c293 --- /dev/null +++ b/parser/testdata/corpus/sql/types/timestamp/test_timestamp_2411.test @@ -0,0 +1,25 @@ +# source: test/sql/types/timestamp/test_timestamp_2411.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +CREATE TABLE timestamp1(i TIMESTAMP) +-- +ok +== +CREATE TABLE timestamp2(i TIMESTAMP) +-- +ok +== +INSERT INTO timestamp1 VALUES ('1993-08-14 00:00:01') +-- +ok +== +INSERT INTO timestamp2 VALUES ('1993-08-14 00:00:01') +-- +ok +== +select count(*) from timestamp2 inner join timestamp1 on (timestamp1.i = timestamp2.i) +-- +ok +== diff --git a/parser/testdata/corpus/sql/types/timestamp/test_timestamp_auto_casting.test b/parser/testdata/corpus/sql/types/timestamp/test_timestamp_auto_casting.test new file mode 100644 index 0000000..fcadec8 --- /dev/null +++ b/parser/testdata/corpus/sql/types/timestamp/test_timestamp_auto_casting.test @@ -0,0 +1,38 @@ +# source: test/sql/types/timestamp/test_timestamp_auto_casting.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +CREATE TABLE timestamps(ts_SEC TIMESTAMP_S, ts_MS TIMESTAMP_MS, ts TIMESTAMP, ts_NS TIMESTAMP_NS) +-- +ok +== +INSERT INTO timestamps VALUES ('2000-01-01 01:12:23', '2000-01-01 01:12:23.123', '2000-01-01 01:12:23.123456', '2000-01-01 01:12:23.123457'); +-- +ok +== +SELECT + ts_SEC=ts_MS, + ts_SEC=ts, + ts_SEC=ts_NS, + ts_MS=ts, + ts_MS=ts_NS, + ts=ts_NS, + ts_MS=ts_SEC, + ts=ts_SEC, + ts_SEC=ts_NS, + ts=ts_MS, + ts_NS=ts_MS, + ts_NS=ts, +FROM timestamps +-- +ok +== +SELECT typeof([TIMESTAMP '2000-01-01 01:12:23.123456', TIMESTAMP_NS '2000-01-01 01:12:23.123456']) +-- +ok +== +SELECT typeof([TIMESTAMP_NS '2000-01-01 01:12:23.123456', TIMESTAMP '2000-01-01 01:12:23.123456']) +-- +ok +== diff --git a/parser/testdata/corpus/sql/types/timestamp/test_timestamp_ms.test b/parser/testdata/corpus/sql/types/timestamp/test_timestamp_ms.test new file mode 100644 index 0000000..e944517 --- /dev/null +++ b/parser/testdata/corpus/sql/types/timestamp/test_timestamp_ms.test @@ -0,0 +1,13 @@ +# source: test/sql/types/timestamp/test_timestamp_ms.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +SELECT CAST('2001-04-20 14:42:11.123' AS TIMESTAMP) a, CAST('2001-04-20 14:42:11.0' AS TIMESTAMP) b; +-- +ok +== +SELECT TIMESTAMP '2001-04-20 14:42:11.12300000000000000000'; +-- +ok +== diff --git a/parser/testdata/corpus/sql/types/timestamp/test_timestamp_to_tz_cast.test b/parser/testdata/corpus/sql/types/timestamp/test_timestamp_to_tz_cast.test new file mode 100644 index 0000000..978d723 --- /dev/null +++ b/parser/testdata/corpus/sql/types/timestamp/test_timestamp_to_tz_cast.test @@ -0,0 +1,69 @@ +# source: test/sql/types/timestamp/test_timestamp_to_tz_cast.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +create table ts_{unit}_tbl_1 as from VALUES + ('1990/12/21'::{unit}) +as t(ts); +-- +error: Parser Error: syntax error at or near "{" +== +create table ts_{unit}_tbl_null as FROM VALUES + (NULL::{unit}) +as t(ts); +-- +error: Parser Error: syntax error at or near "{" +== +create table ts_{unit}_tbl_posinf as from VALUES + ('infinity'::{unit}) +as t(ts); +-- +error: Parser Error: syntax error at or near "{" +== +create table ts_{unit}_tbl_mininf as from VALUES + ('-infinity'::{unit}) +as t(ts); +-- +error: Parser Error: syntax error at or near "{" +== +create table ts_{unit}_tbl_2 as from VALUES + ('294247-01-10'::{unit}) +as t(ts); +-- +error: Parser Error: syntax error at or near "{" +== +create table ts_{unit}_tbl_3 as from VALUES + ('29720-04-05 (BC) 22:13:20'::{unit}) +as t(ts); +-- +error: Parser Error: syntax error at or near "{" +== +select ts as base, base::TIMESTAMPTZ as tstz from ts_{unit}_tbl_1; +-- +error: Parser Error: syntax error at or near "{" +== +select ts as base, base::TIMESTAMPTZ as tstz from ts_{unit}_tbl_2; +-- +error: Parser Error: syntax error at or near "{" +== +select ts as base, base::TIMESTAMPTZ as tstz from ts_{unit}_tbl_3; +-- +error: Parser Error: syntax error at or near "{" +== +select ts as base, base::TIMESTAMPTZ as tstz from ts_{unit}_tbl_posinf; +-- +error: Parser Error: syntax error at or near "{" +== +select ts as base, base::TIMESTAMPTZ as tstz from ts_{unit}_tbl_mininf; +-- +error: Parser Error: syntax error at or near "{" +== +select ts as base, base::TIMESTAMPTZ as tstz from ts_{unit}_tbl_null; +-- +error: Parser Error: syntax error at or near "{" +== +SET TimeZone='Etc/GMT-6' +-- +ok +== diff --git a/parser/testdata/corpus/sql/types/timestamp/test_timestamp_types.test b/parser/testdata/corpus/sql/types/timestamp/test_timestamp_types.test new file mode 100644 index 0000000..9623e03 --- /dev/null +++ b/parser/testdata/corpus/sql/types/timestamp/test_timestamp_types.test @@ -0,0 +1,180 @@ +# source: test/sql/types/timestamp/test_timestamp_types.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +CREATE TABLE IF NOT EXISTS timestamp (sec TIMESTAMP_S, milli TIMESTAMP_MS,micro TIMESTAMP_US, nano TIMESTAMP_NS ); +-- +ok +== +SELECT * from timestamp; +-- +ok +== +SELECT YEAR(sec),YEAR(milli),YEAR(nano) from timestamp; +-- +ok +== +SELECT nano::TIMESTAMP, milli::TIMESTAMP,sec::TIMESTAMP from timestamp; +-- +ok +== +SELECT micro::TIMESTAMP_S, micro::TIMESTAMP_MS,micro::TIMESTAMP_NS from timestamp; +-- +ok +== +select '90000-01-19 03:14:07.999999'::TIMESTAMP_US::TIMESTAMP_NS +-- +ok +== +SELECT s::TIMESTAMP_NS +FROM VALUES + ('2024-06-04 10:17:10.987654321'), + ('2024-06-04 10:17:10.98765432'), + ('2024-06-04 10:17:10.9876543'), + ('2024-06-04 10:17:10.9876543'), + ('2024-06-04 10:17:10.987654'), + ('2024-06-04 10:17:10.98765'), + ('2024-06-04 10:17:10.9876'), + ('2024-06-04 10:17:10.987'), + ('2024-06-04 10:17:10.98'), + ('2024-06-04 10:17:10.9'), + ('2024-06-04 10:17:10') +AS tbl(s) +-- +ok +== +SELECT TIMESTAMP_NS '2262-04-11 23:47:16.854775808'; +-- +ok +== +select '1969-01-01T23:59:59.9999999'::timestamp_ns; +-- +ok +== +SELECT '1970-01-01 00:00:00.000000123'::TIMESTAMP_NS; +-- +ok +== +select sec::TIME from timestamp; +-- +ok +== +select milli::TIME from timestamp; +-- +ok +== +select nano::TIME from timestamp; +-- +ok +== +SELECT {src}, {dst} +FROM timestamp +WHERE {src} = {dst} ; +-- +error: Parser Error: syntax error at or near "}" +== +SELECT {src}::DATE from timestamp +-- +error: Parser Error: syntax error at or near "}" +== +select sec from timestamp order by sec; +-- +ok +== +select milli from timestamp order by milli; +-- +ok +== +select nano from timestamp order by nano; +-- +ok +== +select count(*), nano from timestamp group by nano order by nano; +-- +ok +== +select count(*), sec from timestamp group by sec order by sec; +-- +ok +== +select count(*), milli from timestamp group by milli order by milli; +-- +ok +== +CREATE TABLE IF NOT EXISTS timestamp_two (sec TIMESTAMP_S, milli TIMESTAMP_MS,micro TIMESTAMP_US, nano TIMESTAMP_NS ); +-- +ok +== +INSERT INTO timestamp_two VALUES ('2008-01-01 00:00:11','2008-01-01 00:00:01.794','2008-01-01 00:00:01.98926','2008-01-01 00:00:01.899268321' ) +-- +ok +== +select timestamp.sec from timestamp inner join timestamp_two on (timestamp.sec = timestamp_two.sec); +-- +ok +== +select timestamp.milli from timestamp inner join timestamp_two on (timestamp.milli = timestamp_two.milli); +-- +ok +== +select timestamp.nano from timestamp inner join timestamp_two on (timestamp.nano = timestamp_two.nano); +-- +ok +== +select '2008-01-01 00:00:11'::TIMESTAMP_US = '2008-01-01 00:00:11'::TIMESTAMP_MS +-- +ok +== +select '2008-01-01 00:00:11'::TIMESTAMP_US = '2008-01-01 00:00:11'::TIMESTAMP_NS +-- +ok +== +select '2008-01-01 00:00:11'::TIMESTAMP_US = '2008-01-01 00:00:11'::TIMESTAMP_S +-- +ok +== +select '2008-01-01 00:00:11.1'::TIMESTAMP_US = '2008-01-01 00:00:11'::TIMESTAMP_MS +-- +ok +== +select '2008-01-01 00:00:11.1'::TIMESTAMP_US = '2008-01-01 00:00:11'::TIMESTAMP_NS +-- +ok +== +select '2008-01-01 00:00:11.1'::TIMESTAMP_US = '2008-01-01 00:00:11.1'::TIMESTAMP_S +-- +ok +== +select '2008-01-01 00:00:11.1'::TIMESTAMP_MS = '2008-01-01 00:00:11'::TIMESTAMP_NS +-- +ok +== +select '2008-01-01 00:00:11.1'::TIMESTAMP_MS = '2008-01-01 00:00:11'::TIMESTAMP_S +-- +ok +== +select '2008-01-01 00:00:11.1'::TIMESTAMP_NS = '2008-01-01 00:00:11'::TIMESTAMP_S +-- +ok +== +select '2008-01-01 00:00:11'::TIMESTAMP_MS = '2008-01-01 00:00:11'::TIMESTAMP_NS +-- +ok +== +select '2008-01-01 00:00:11'::TIMESTAMP_MS = '2008-01-01 00:00:11'::TIMESTAMP_S +-- +ok +== +select '2008-01-01 00:00:11'::TIMESTAMP_NS = '2008-01-01 00:00:11'::TIMESTAMP_S +-- +ok +== +SELECT CAST(t0.c0 AS TIME)>=('12:34:56') FROM values ('2030-01-01'::TIMESTAMP_S), ('1969-12-23 20:44:40'::TIMESTAMP_S) as t0(c0) +-- +ok +== +SELECT NOT CAST(t0.c0 AS TIME)>=('12:34:56') FROM values ('2030-01-01'::TIMESTAMP_MS), ('1969-12-23 20:44:40'::TIMESTAMP_MS) as t0(c0) +-- +ok +== diff --git a/parser/testdata/corpus/sql/types/timestamp/test_timestamp_tz.test b/parser/testdata/corpus/sql/types/timestamp/test_timestamp_tz.test new file mode 100644 index 0000000..439c820 --- /dev/null +++ b/parser/testdata/corpus/sql/types/timestamp/test_timestamp_tz.test @@ -0,0 +1,21 @@ +# source: test/sql/types/timestamp/test_timestamp_tz.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +select timestamptz '2021-11-15 02:30:00'; +-- +ok +== +select '2021-11-15 02:30:00'::TIMESTAMP::TIMESTAMPTZ; +-- +ok +== +SELECT '2021-04-29 10:50:09-05'::TIMESTAMPTZ::{datatype} +-- +error: Parser Error: syntax error at or near "{" +== +SELECT '1880-05-15T12:00:00+00:50:20'::TIMESTAMPTZ; +-- +ok +== diff --git a/parser/testdata/corpus/sql/types/timestamp/timestamp_limits.test b/parser/testdata/corpus/sql/types/timestamp/timestamp_limits.test new file mode 100644 index 0000000..662dd28 --- /dev/null +++ b/parser/testdata/corpus/sql/types/timestamp/timestamp_limits.test @@ -0,0 +1,97 @@ +# source: test/sql/types/timestamp/timestamp_limits.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +select timestamp '1970-01-01'; +-- +ok +== +select '290309-12-22 (BC) 00:00:00'::timestamp +-- +ok +== +select '290309-12-21 (BC) 12:59:59.999999'::timestamp +-- +ok +== +select '290309-12-22 (BC) 00:00:00'::timestamp + interval (1) day +-- +ok +== +select '290309-12-22 (BC) 00:00:00'::timestamp - interval (1) microsecond +-- +ok +== +select '290309-12-22 (BC) 00:00:00'::timestamp - interval (1) second +-- +ok +== +select '290309-12-22 (BC) 00:00:00'::timestamp - interval (1) day +-- +ok +== +select '290309-12-22 (BC) 00:00:00'::timestamp - interval (1) month +-- +ok +== +select '290309-12-22 (BC) 00:00:00'::timestamp - interval (1) year +-- +ok +== +select timestamp '294247-01-10 04:00:54.775806' +-- +ok +== +select timestamp '294247-01-10 04:00:54.775807' +-- +ok +== +select timestamp '294247-01-10 04:00:54.775808' +-- +ok +== +select timestamp '294247-01-10 04:00:54.775806' + interval (1) microsecond +-- +ok +== +select timestamp '294247-01-10 04:00:54.775806' + interval (1) second +-- +ok +== +select timestamp '294247-01-10 04:00:54.775806' + interval (1) hour +-- +ok +== +select timestamp '294247-01-10 04:00:54.775806' + interval (1) day +-- +ok +== +select timestamp '294247-01-10 04:00:54.775806' + interval (1) month +-- +ok +== +select timestamp '294247-01-10 04:00:54.775806' + interval (1) year +-- +ok +== +select epoch(timestamp '294247-01-10 04:00:54.775806'), epoch(timestamp '290309-12-22 (BC) 00:00:00') +-- +ok +== +select year(timestamp '294247-01-10 04:00:54.775806'), year(timestamp '290309-12-22 (BC) 00:00:00') +-- +ok +== +select decade(timestamp '294247-01-10 04:00:54.775806'), decade(timestamp '290309-12-22 (BC) 00:00:00') +-- +ok +== +select monthname(timestamp '294247-01-10 04:00:54.775806'), monthname(timestamp '290309-12-22 (BC) 00:00:00') +-- +ok +== +select age(timestamp '294247-01-10 04:00:54.775806', '290309-12-22 (BC) 00:00:00'::timestamp) +-- +ok +== diff --git a/parser/testdata/corpus/sql/types/timestamp/timestamp_precision.test b/parser/testdata/corpus/sql/types/timestamp/timestamp_precision.test new file mode 100644 index 0000000..f9c6bb9 --- /dev/null +++ b/parser/testdata/corpus/sql/types/timestamp/timestamp_precision.test @@ -0,0 +1,46 @@ +# source: test/sql/types/timestamp/timestamp_precision.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +CREATE TABLE ts_precision( + sec TIMESTAMP(0), + msec TIMESTAMP(3), + micros TIMESTAMP(6), + nanos TIMESTAMP (9) +); +-- +ok +== +INSERT INTO ts_precision VALUES ('2020-01-01 01:23:45.123456789', '2020-01-01 01:23:45.123456789', '2020-01-01 01:23:45.123456789', '2020-01-01 01:23:45.123456789'); +-- +ok +== +SELECT sec::VARCHAR, msec::VARCHAR, micros::VARCHAR, nanos::VARCHAR FROM ts_precision +-- +ok +== +SELECT EXTRACT(microseconds FROM sec), EXTRACT(microseconds FROM msec), EXTRACT(microseconds FROM micros), EXTRACT(microseconds FROM nanos) FROM ts_precision +-- +ok +== +SELECT '2020-01-01 01:23:45.123456789'::TIMESTAMP({i}) +-- +error: Parser Error: syntax error at or near "}" +== +CREATE TABLE ts_precision(sec TIMESTAMP(10)); +-- +ok +== +CREATE TABLE ts_precision(sec TIMESTAMP(99999)); +-- +error: Parser Error: TIMESTAMP only supports until nano-second precision (9) +== +CREATE TABLE ts_precision(sec TIMESTAMP(1, 1)); +-- +error: Parser Error: TIMESTAMP only supports a single modifier +== +SELECT TIMESTAMP_NS '2262-04-11 23:47:16.854775807'; +-- +ok +== diff --git a/parser/testdata/corpus/sql/types/timestamp/timestamp_precision.test.metadata.json b/parser/testdata/corpus/sql/types/timestamp/timestamp_precision.test.metadata.json new file mode 100644 index 0000000..494a4d2 --- /dev/null +++ b/parser/testdata/corpus/sql/types/timestamp/timestamp_precision.test.metadata.json @@ -0,0 +1,6 @@ +{ + "todo": { + "ae7b463600077701": "transformer-raised parser error: upstream rejects in the transformer, not the grammar; expected to clear as transformers land (milestones 3-5)", + "f6204ac9392856de": "transformer-raised parser error: upstream rejects in the transformer, not the grammar; expected to clear as transformers land (milestones 3-5)" + } +} diff --git a/parser/testdata/corpus/sql/types/timestamp/timestamp_timezone_cast.test b/parser/testdata/corpus/sql/types/timestamp/timestamp_timezone_cast.test new file mode 100644 index 0000000..904237b --- /dev/null +++ b/parser/testdata/corpus/sql/types/timestamp/timestamp_timezone_cast.test @@ -0,0 +1,41 @@ +# source: test/sql/types/timestamp/timestamp_timezone_cast.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +SELECT TIMESTAMP '2021-05-25 04:55:03.382494 UTC'; +-- +ok +== +SELECT TIMESTAMP '2021-05-25 04:55:03.382494 utc'; +-- +ok +== +SELECT TIMESTAMP '2021-05-25 04:55:03.382494 uTc'; +-- +ok +== +SELECT TIMESTAMP '2021-05-25 04:55:03.382494 EST'; +-- +ok +== +set Calendar='gregorian'; +-- +ok +== +SELECT TIMESTAMPTZ '2021-05-25 04:55:03.382494 EST'; +-- +ok +== +set TimeZone='America/Phoenix'; +-- +ok +== +SELECT + DATE_DIFF( + 'HOUR', + TIMESTAMP '2010-07-07 10:20:00' AT TIME ZONE 'Asia/Bangkok', + TIMESTAMP '2010-07-07 10:20:00+00') AS hours; +-- +ok +== diff --git a/parser/testdata/corpus/sql/types/timestamp/timestamp_try_cast.test b/parser/testdata/corpus/sql/types/timestamp/timestamp_try_cast.test new file mode 100644 index 0000000..7e31ba2 --- /dev/null +++ b/parser/testdata/corpus/sql/types/timestamp/timestamp_try_cast.test @@ -0,0 +1,89 @@ +# source: test/sql/types/timestamp/timestamp_try_cast.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +select try_cast('' as timestamp) +-- +ok +== +select try_cast(' ' as timestamp) +-- +ok +== +select try_cast('1111' as timestamp) +-- +ok +== +select try_cast(' 1111 ' as timestamp) +-- +ok +== +select try_cast('1111-' as timestamp) +-- +ok +== +select try_cast('1111-11' as timestamp) +-- +ok +== +select try_cast('1111-11-' as timestamp) +-- +ok +== +select try_cast('1111-111-1' as timestamp) +-- +ok +== +select try_cast('1111-11-111' as timestamp) +-- +ok +== +select try_cast('1111-11-11 11' as timestamp) +-- +ok +== +select try_cast('1111-11-11 11:11' as timestamp) +-- +ok +== +select try_cast('1111-11-11 11:11:999' as timestamp) +-- +ok +== +select try_cast('1111-11-11 11:11:11.AAA' as timestamp) +-- +ok +== +select try_cast('1111-11-11 11X11A11' as timestamp) +-- +ok +== +select try_cast('1111-11-11 11:11:11' as timestamp) +-- +ok +== +select try_cast('290309-12-21 (BC) 12:59:59.999999' as timestamp) +-- +ok +== +select try_cast('294247-01-10 04:00:54.775807' as timestamp) +-- +ok +== +select try_cast('290309-12-22 (BC) 00:00:00' as timestamp) +-- +ok +== +select try_cast('294247-01-10 04:00:54.775806' as timestamp) +-- +ok +== +select try_cast('infinity' as timestamp) +-- +ok +== +select try_cast('-infinity' as timestamp) +-- +ok +== diff --git a/parser/testdata/corpus/sql/types/timestamp/utc_offset.test b/parser/testdata/corpus/sql/types/timestamp/utc_offset.test new file mode 100644 index 0000000..6a812bb --- /dev/null +++ b/parser/testdata/corpus/sql/types/timestamp/utc_offset.test @@ -0,0 +1,49 @@ +# source: test/sql/types/timestamp/utc_offset.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +SELECT '2025-01-01T08:00:00+08'::TIMESTAMP AS c; +-- +ok +== +SELECT '2025-01-01T08:00:00+08'::TIMESTAMPTZ AS c; +-- +ok +== +select timestamptz '2020-12-31 21:25:58.745232'; +-- +ok +== +select timestamptz '2020-12-31 21:25:58.745232+00'; +-- +ok +== +select timestamptz '2020-12-31 21:25:58.745232+0000'; +-- +ok +== +select timestamptz '2020-12-31 21:25:58.745232+02'; +-- +ok +== +select timestamptz '2020-12-31 21:25:58.745232-02'; +-- +ok +== +select timestamptz '2020-12-31 21:25:58.745232+0215'; +-- +ok +== +select timestamptz '2020-12-31 21:25:58.745232+02:15'; +-- +ok +== +select timestamptz '2020-12-31 21:25:58.745232-0215'; +-- +ok +== +select timestamptz '2020-12-31 21:25:58+02:15'; +-- +ok +== diff --git a/parser/testdata/corpus/sql/types/type/test_make_get_type.test b/parser/testdata/corpus/sql/types/type/test_make_get_type.test new file mode 100644 index 0000000..ac1dbb9 --- /dev/null +++ b/parser/testdata/corpus/sql/types/type/test_make_get_type.test @@ -0,0 +1,29 @@ +# source: test/sql/types/type/test_make_get_type.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +SELECT get_type(NULL); +-- +ok +== +SELECT get_type(1); +-- +ok +== +SELECT get_type('hello'); +-- +ok +== +SELECT make_type('STRUCT', a := make_type('INTEGER'), b := make_type('VARCHAR')); +-- +ok +== +SELECT make_type('STRUCT', make_type('INTEGER'), b := make_type('VARCHAR')); +-- +ok +== +SELECT make_type('LIST', make_type('STRUCT', a := make_type('STRUCT', x := make_type('INTEGER')), b := make_type('VARCHAR'))); +-- +ok +== diff --git a/parser/testdata/corpus/sql/types/type/test_type_storage.test b/parser/testdata/corpus/sql/types/type/test_type_storage.test new file mode 100644 index 0000000..b34e5cb --- /dev/null +++ b/parser/testdata/corpus/sql/types/type/test_type_storage.test @@ -0,0 +1,9 @@ +# source: test/sql/types/type/test_type_storage.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +CREATE TABLE T (v TYPE); +-- +ok +== diff --git a/parser/testdata/corpus/sql/types/type_literal.test b/parser/testdata/corpus/sql/types/type_literal.test new file mode 100644 index 0000000..94d5958 --- /dev/null +++ b/parser/testdata/corpus/sql/types/type_literal.test @@ -0,0 +1,52 @@ +# source: test/sql/types/type_literal.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +SELECT typeof(DECIMAL(4,2) '1.23'), DECIMAL(4,2) '1.23', typeof(STRUCT(a INTEGER) '{"a": 42}'); +-- +ok +== +SELECT INTEGER[] '[1,2,3]'; +-- +ok +== +SELECT typeof(TIMESTAMP WITH TIME ZONE '2023-01-01 00:00:00+00'); +-- +ok +== +SELECT typeof(TIME WITH TIME ZONE '12:00:00+00'); +-- +ok +== +SELECT typeof(CHARACTER VARYING 'text'); +-- +ok +== +SELECT typeof(NATIONAL CHARACTER 'x'); +-- +ok +== +SELECT typeof(NUMERIC(10, 2) '5.5'); +-- +ok +== +SELECT typeof(VARCHAR(5) '12345'); +-- +ok +== +SELECT typeof(TIMESTAMP(3) '2024-01-01 00:00:00'); +-- +ok +== +CREATE TABLE Produce AS + SELECT 'Kale' AS product, 51 AS sales, 'Q1' AS quarter, 2020 AS year; +-- +ok +== +SELECT * FROM Produce +PIVOT(SUM(sales) FOR quarter IN ('Q1', 'Q2', Q3', $Q4')) +ORDER BY ALL; +-- +ok +== diff --git a/parser/testdata/corpus/sql/types/uhugeint/test_uhugeint_aggregates.test b/parser/testdata/corpus/sql/types/uhugeint/test_uhugeint_aggregates.test new file mode 100644 index 0000000..ff03f74 --- /dev/null +++ b/parser/testdata/corpus/sql/types/uhugeint/test_uhugeint_aggregates.test @@ -0,0 +1,13 @@ +# source: test/sql/types/uhugeint/test_uhugeint_aggregates.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +CREATE TABLE hugeints(g INTEGER, h UHUGEINT); +-- +ok +== +INSERT INTO hugeints VALUES (1, 42), (2, 1267650600228229401496703205376), (2, 0), (1, '8'); +-- +ok +== diff --git a/parser/testdata/corpus/sql/types/uhugeint/test_uhugeint_arithmetic.test b/parser/testdata/corpus/sql/types/uhugeint/test_uhugeint_arithmetic.test new file mode 100644 index 0000000..ae42f69 --- /dev/null +++ b/parser/testdata/corpus/sql/types/uhugeint/test_uhugeint_arithmetic.test @@ -0,0 +1,129 @@ +# source: test/sql/types/uhugeint/test_uhugeint_arithmetic.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +SELECT -(50::UHUGEINT) +-- +ok +== +SELECT -(0::UHUGEINT) +-- +ok +== +SELECT 42::UHUGEINT + 42::UHUGEINT; +-- +ok +== +SELECT '100000000000000000000'::UHUGEINT + '100000000000000000000'::UHUGEINT; +-- +ok +== +SELECT '340282366920938463463374607431768211455'::UHUGEINT + '340282366920938463463374607431768211455'::UHUGEINT; +-- +ok +== +SELECT '340282366920938463463374607431768211455'::UHUGEINT + '10'::UHUGEINT; +-- +ok +== +SELECT '340282366920938463463374607431768211455'::UHUGEINT - 10::UHUGEINT + 10::UHUGEINT +-- +ok +== +SELECT '340282366920938463463374607431768211455'::UHUGEINT - 10::UHUGEINT + 11::UHUGEINT +-- +ok +== +SELECT 100::UHUGEINT - 42::UHUGEINT, 3::UHUGEINT - 2::UHUGEINT; +-- +ok +== +SELECT '0'::UHUGEINT - '1'::UHUGEINT; +-- +ok +== +SELECT 100::UHUGEINT * 50::UHUGEINT; +-- +ok +== +SELECT '1701411834604692317'::UHUGEINT * '2'::UHUGEINT, '100000000000000000000'::UHUGEINT * '1000000000000000000'::UHUGEINT +-- +ok +== +SELECT '340282366920938463463374607431768211455'::UHUGEINT * 1::UHUGEINT +-- +ok +== +SELECT '340282366920938463463374607431768211455'::UHUGEINT * 2::UHUGEINT +-- +ok +== +SELECT '34028236692093846346'::UHUGEINT * '33746074317682114556'::UHUGEINT +-- +ok +== +SELECT 100::UHUGEINT // 20::UHUGEINT, 90::UHUGEINT // 20::UHUGEINT +-- +ok +== +SELECT 100::UHUGEINT // 0::UHUGEINT +-- +ok +== +SELECT '100000000000000000000000000000000000000'::UHUGEINT // '10000000000000'::UHUGEINT, '100000000000000000000000000000000000000'::UHUGEINT // '2'::UHUGEINT +-- +ok +== +SELECT 100::UHUGEINT % 20::UHUGEINT, 90::UHUGEINT % 20::UHUGEINT +-- +ok +== +SELECT 100::UHUGEINT % 0::UHUGEINT +-- +ok +== +SELECT '100000000000000000000000000000000000000'::UHUGEINT % '6587689457689375689735'::UHUGEINT, '100000000000000000000000000000000000000'::UHUGEINT % '3'::UHUGEINT +-- +ok +== +SELECT ABS('100'::UHUGEINT); +-- +ok +== +SELECT '340282366920938463463374607431768211454'::UHUGEINT + 1; +-- +ok +== +SELECT '340282366920938463463374607431768211455'::UHUGEINT - 1; +-- +ok +== +SELECT 1 + '340282366920938463463374607431768211454'::UHUGEINT; +-- +ok +== +SELECT 1::UHUGEINT + '340282366920938463463374607431768211455'::UHUGEINT; +-- +ok +== +SELECT 1 - 1::UHUGEINT; +-- +ok +== +SELECT 0::UHUGEINT - 1::UHUGEINT; +-- +ok +== +SELECT '340282366920938463463374607431768211455'::UHUGEINT // 1; +-- +ok +== +SELECT '340282366920938463463374607431768211455'::UHUGEINT // '340282366920938463463374607431768211455'::UHUGEINT; +-- +ok +== +SELECT '5'::UHUGEINT <> '5'::UHUGEINT, '5'::UHUGEINT <> '18446744073709551621'::UHUGEINT +-- +ok +== diff --git a/parser/testdata/corpus/sql/types/uhugeint/test_uhugeint_auto_cast.test b/parser/testdata/corpus/sql/types/uhugeint/test_uhugeint_auto_cast.test new file mode 100644 index 0000000..eed89af --- /dev/null +++ b/parser/testdata/corpus/sql/types/uhugeint/test_uhugeint_auto_cast.test @@ -0,0 +1,21 @@ +# source: test/sql/types/uhugeint/test_uhugeint_auto_cast.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +SELECT 10000000000000000000::UHUGEINT + 100::TINYINT, 10000000000000000000::UHUGEINT + 100::SMALLINT, 10000000000000000000::UHUGEINT + 100::INTEGER, 10000000000000000000::UHUGEINT + 100::BIGINT; +-- +ok +== +SELECT 100::UHUGEINT + 0.5 +-- +ok +== +SELECT COS(100::UHUGEINT) +-- +ok +== +SELECT CONCAT('hello number ', 100::UHUGEINT) +-- +ok +== diff --git a/parser/testdata/corpus/sql/types/uhugeint/test_uhugeint_conversion.test b/parser/testdata/corpus/sql/types/uhugeint/test_uhugeint_conversion.test new file mode 100644 index 0000000..c7264c8 --- /dev/null +++ b/parser/testdata/corpus/sql/types/uhugeint/test_uhugeint_conversion.test @@ -0,0 +1,105 @@ +# source: test/sql/types/uhugeint/test_uhugeint_conversion.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +SELECT '7'::UHUGEINT, '130'::UHUGEINT, '924829852'::UHUGEINT +-- +ok +== +SELECT '0'::UHUGEINT, '-0'::UHUGEINT +-- +ok +== +SELECT '10000000000000000000000000000'::UHUGEINT; +-- +ok +== +SELECT '1267650600228229401496703205376'::UHUGEINT, '340282366920938463463374607431768211455'::UHUGEINT; +-- +ok +== +SELECT '-1267650600228229401496703205376'::UHUGEINT, '-17014118346046923173168730371588410572'::UHUGEINT; +-- +ok +== +SELECT '340282366920938463463374607431768211456'::UHUGEINT; +-- +ok +== +SELECT '-1'::UHUGEINT; +-- +ok +== +SELECT '340282366920938463463374607431768211455'::UHUGEINT, '0'::UHUGEINT; +-- +ok +== +SELECT 42::TINYINT::UHUGEINT, 42::SMALLINT::UHUGEINT, 42::INTEGER::UHUGEINT, 42::BIGINT::UHUGEINT, 42::FLOAT::UHUGEINT, 42::DOUBLE::UHUGEINT; +-- +ok +== +SELECT (-42)::TINYINT::UHUGEINT, (-42)::SMALLINT::UHUGEINT, (-42)::INTEGER::UHUGEINT, (-42)::BIGINT::UHUGEINT, (-42)::FLOAT::UHUGEINT, (-42)::DOUBLE::UHUGEINT; +-- +ok +== +SELECT 42::UHUGEINT::TINYINT, 42::UHUGEINT::SMALLINT, 42::UHUGEINT::INTEGER, 42::UHUGEINT::BIGINT, 42::UHUGEINT::FLOAT, 42::UHUGEINT::DOUBLE; +-- +ok +== +SELECT 1000::UHUGEINT::TINYINT; +-- +ok +== +SELECT 128::UHUGEINT::TINYINT; +-- +ok +== +SELECT 127::UHUGEINT::TINYINT; +-- +ok +== +SELECT 100000::UHUGEINT::SMALLINT; +-- +ok +== +SELECT 32768::UHUGEINT::SMALLINT; +-- +ok +== +SELECT 32767::UHUGEINT::SMALLINT; +-- +ok +== +SELECT 100000000000::UHUGEINT::INTEGER; +-- +ok +== +SELECT 2147483648::UHUGEINT::INTEGER; +-- +ok +== +SELECT 2147483647::UHUGEINT::INTEGER; +-- +ok +== +SELECT 10000000000000000000::UHUGEINT::BIGINT; +-- +ok +== +SELECT '9223372036854775808'::UHUGEINT::BIGINT; +-- +ok +== +SELECT 9223372036854775807::UHUGEINT::BIGINT; +-- +ok +== +SELECT 1e100::FLOAT::UHUGEINT; +-- +ok +== +SELECT 1e100::DOUBLE::UHUGEINT; +-- +ok +== diff --git a/parser/testdata/corpus/sql/types/uhugeint/test_uhugeint_exponent.test b/parser/testdata/corpus/sql/types/uhugeint/test_uhugeint_exponent.test new file mode 100644 index 0000000..a22a65e --- /dev/null +++ b/parser/testdata/corpus/sql/types/uhugeint/test_uhugeint_exponent.test @@ -0,0 +1,37 @@ +# source: test/sql/types/uhugeint/test_uhugeint_exponent.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +select '170141183460469231731687303715884105700e0'::UHUGEINT +-- +ok +== +select '340282366920938463463374607431768211455e0'::UHUGEINT +-- +ok +== +select 5.4321e4::UHUGEINT +-- +ok +== +select (0.00000000000000000000002e+44)::UHUGEINT; +-- +ok +== +select '340282366920938463463374607431768211456e0'::UHUGEINT +-- +ok +== +select '3.4e39'::UHUGEINT +-- +ok +== +select '3.4e38'::UHUGEINT +-- +ok +== +select '3.5e38'::UHUGEINT +-- +ok +== diff --git a/parser/testdata/corpus/sql/types/uhugeint/test_uhugeint_functions.test b/parser/testdata/corpus/sql/types/uhugeint/test_uhugeint_functions.test new file mode 100644 index 0000000..bf58802 --- /dev/null +++ b/parser/testdata/corpus/sql/types/uhugeint/test_uhugeint_functions.test @@ -0,0 +1,33 @@ +# source: test/sql/types/uhugeint/test_uhugeint_functions.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +select abs(1::UHUGEINT), abs('1329227995784915872903807060280344576'::UHUGEINT), abs(0::UHUGEINT) +-- +ok +== +select sign(1::UHUGEINT), sign(0::UHUGEINT) +-- +ok +== +select round(1::UHUGEINT, 0), round('1329227995784915872903807060280344576'::UHUGEINT, 0), round(0::UHUGEINT, 0) +-- +ok +== +select floor(1::UHUGEINT), floor('1329227995784915872903807060280344576'::UHUGEINT), floor(0::UHUGEINT) +-- +ok +== +select ceil(1::UHUGEINT), ceil('1329227995784915872903807060280344576'::UHUGEINT), ceil(0::UHUGEINT) +-- +ok +== +select LEAST(1::UHUGEINT, '1329227995784915872903807060280344576'::UHUGEINT, 0::UHUGEINT) +-- +ok +== +select GREATEST(1::UHUGEINT, '1329227995784915872903807060280344576'::UHUGEINT, 0::UHUGEINT) +-- +ok +== diff --git a/parser/testdata/corpus/sql/types/uhugeint/test_uhugeint_null_value.test b/parser/testdata/corpus/sql/types/uhugeint/test_uhugeint_null_value.test new file mode 100644 index 0000000..3555638 --- /dev/null +++ b/parser/testdata/corpus/sql/types/uhugeint/test_uhugeint_null_value.test @@ -0,0 +1,13 @@ +# source: test/sql/types/uhugeint/test_uhugeint_null_value.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +SELECT NULL::UHUGEINT +-- +ok +== +CREATE TABLE hugeints(id INTEGER, h UHUGEINT) +-- +ok +== diff --git a/parser/testdata/corpus/sql/types/uhugeint/test_uhugeint_ops.test b/parser/testdata/corpus/sql/types/uhugeint/test_uhugeint_ops.test new file mode 100644 index 0000000..92acf17 --- /dev/null +++ b/parser/testdata/corpus/sql/types/uhugeint/test_uhugeint_ops.test @@ -0,0 +1,58 @@ +# source: test/sql/types/uhugeint/test_uhugeint_ops.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +CREATE TABLE uhugeints(h UHUGEINT); +-- +ok +== +INSERT INTO uhugeints VALUES (42::UHUGEINT), ('1267650600228229401496703205376'::UHUGEINT); +-- +ok +== +SELECT h::UINTEGER FROM uhugeints WHERE h < 100::UINTEGER +-- +ok +== +SELECT COUNT(*) FROM uhugeints WHERE h = 42::UHUGEINT +-- +ok +== +SELECT COUNT(*) FROM uhugeints WHERE h <> '1267650600228229401496703205376'::UHUGEINT +-- +ok +== +SELECT COUNT(*) FROM uhugeints WHERE h < '1267650600228229401496703205376'::UHUGEINT +-- +ok +== +SELECT COUNT(*) FROM uhugeints WHERE h <= '1267650600228229401496703205376'::UHUGEINT +-- +ok +== +SELECT COUNT(*) FROM uhugeints WHERE h > '1267650600228229401496703205375'::UHUGEINT +-- +ok +== +SELECT COUNT(*) FROM uhugeints WHERE h >= 42::UHUGEINT +-- +ok +== +CREATE TABLE uhugeints2(h UHUGEINT); +INSERT INTO uhugeints2 VALUES (42::UHUGEINT); +-- +ok +== +SELECT * FROM uhugeints JOIN uhugeints2 USING (h); +-- +ok +== +SELECT * FROM uhugeints t1 JOIN uhugeints2 t2 ON t1.h <> t2.h +-- +ok +== +SELECT * FROM uhugeints t1 JOIN uhugeints2 t2 ON t1.h >= t2.h ORDER BY 1 LIMIT 2 +-- +ok +== diff --git a/parser/testdata/corpus/sql/types/uhugeint/uhugeint_literal.test b/parser/testdata/corpus/sql/types/uhugeint/uhugeint_literal.test new file mode 100644 index 0000000..119d3e9 --- /dev/null +++ b/parser/testdata/corpus/sql/types/uhugeint/uhugeint_literal.test @@ -0,0 +1,21 @@ +# source: test/sql/types/uhugeint/uhugeint_literal.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +select 340282366920938463463374607431768211455 +-- +ok +== +select typeof(340282366920938463463374607431768211455) +-- +ok +== +select 340282366920938463463374607431768211456 +-- +ok +== +select typeof(340282366920938463463374607431768211456) +-- +ok +== diff --git a/parser/testdata/corpus/sql/types/uhugeint/uhugeint_multiply.test b/parser/testdata/corpus/sql/types/uhugeint/uhugeint_multiply.test new file mode 100644 index 0000000..1b20400 --- /dev/null +++ b/parser/testdata/corpus/sql/types/uhugeint/uhugeint_multiply.test @@ -0,0 +1,125 @@ +# source: test/sql/types/uhugeint/uhugeint_multiply.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +SELECT 251658240::UHUGEINT * 251658240::UHUGEINT +-- +ok +== +SELECT 251658240::UHUGEINT * 1080863910568919040::UHUGEINT +-- +ok +== +SELECT 251658240::UHUGEINT * 4642275147320176030871715840::UHUGEINT +-- +ok +== +SELECT 251658240::UHUGEINT * 19938419936773738093557105904205168640::UHUGEINT +-- +ok +== +SELECT 1080863910568919040::UHUGEINT * 251658240::UHUGEINT +-- +ok +== +SELECT 1080863910568919040::UHUGEINT * 1080863910568919040::UHUGEINT +-- +ok +== +SELECT 1080863910568919040::UHUGEINT * 4642275147320176030871715840::UHUGEINT +-- +ok +== +SELECT 1080863910568919040::UHUGEINT * 19938419936773738093557105904205168640::UHUGEINT +-- +ok +== +SELECT 4642275147320176030871715840::UHUGEINT * 251658240::UHUGEINT +-- +ok +== +SELECT 4642275147320176030871715840::UHUGEINT * 1080863910568919040::UHUGEINT +-- +ok +== +SELECT 4642275147320176030871715840::UHUGEINT * 4642275147320176030871715840::UHUGEINT +-- +ok +== +SELECT 4642275147320176030871715840::UHUGEINT * 19938419936773738093557105904205168640::UHUGEINT +-- +ok +== +SELECT 19938419936773738093557105904205168640::UHUGEINT * 251658240::UHUGEINT +-- +ok +== +SELECT 19938419936773738093557105904205168640::UHUGEINT * 1080863910568919040::UHUGEINT +-- +ok +== +SELECT 19938419936773738093557105904205168640::UHUGEINT * 4642275147320176030871715840::UHUGEINT +-- +ok +== +SELECT 19938419936773738093557105904205168640::UHUGEINT * 19938419936773738093557105904205168640::UHUGEINT +-- +ok +== +SELECT 170141183460469231731687303715884105727::UHUGEINT * 2::UHUGEINT +-- +ok +== +SELECT 170141183460469231731687303715884105728::UHUGEINT * 2::UHUGEINT +-- +ok +== +SELECT 19807040628566084398385987583::UHUGEINT * 8589934592::UHUGEINT +-- +ok +== +SELECT 19807040628566084398385987584::UHUGEINT*85899345928::UHUGEINT; +-- +ok +== +SELECT 36893488147419103231::UHUGEINT * 4611686018427387904::UHUGEINT +-- +ok +== +SELECT 368934881474191032324::UHUGEINT * 4611686018427387904::UHUGEINT +-- +ok +== +SELECT 2::UHUGEINT * 170141183460469231731687303715884105727::UHUGEINT +-- +ok +== +SELECT 2::UHUGEINT * 170141183460469231731687303715884105728::UHUGEINT +-- +ok +== +SELECT 8589934592::UHUGEINT * 19807040628566084398385987583::UHUGEINT +-- +ok +== +SELECT 85899345923::UHUGEINT * 19807040628566084398385987584::UHUGEINT +-- +ok +== +SELECT 4611686018427387904::UHUGEINT * 36893488147419103231::UHUGEINT +-- +ok +== +SELECT 4611686018427387904::UHUGEINT * 368934881474191032323::UHUGEINT +-- +ok +== +SELECT 10376293541461622783::UHUGEINT * 10376293541461622783::UHUGEINT +-- +ok +== +SELECT 172938225691027046399::UHUGEINT * 10376293541461622783::UHUGEINT +-- +ok +== diff --git a/parser/testdata/corpus/sql/types/uhugeint/uhugeint_try_cast.test b/parser/testdata/corpus/sql/types/uhugeint/uhugeint_try_cast.test new file mode 100644 index 0000000..ae652a4 --- /dev/null +++ b/parser/testdata/corpus/sql/types/uhugeint/uhugeint_try_cast.test @@ -0,0 +1,29 @@ +# source: test/sql/types/uhugeint/uhugeint_try_cast.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +SELECT CAST('340282366920938463463374607431768211456' AS UHUGEINT) +-- +ok +== +SELECT CAST('340282366920938463463374607431768211456'::DOUBLE AS UHUGEINT) +-- +ok +== +SELECT CAST('-1' AS UHUGEINT) +-- +ok +== +SELECT TRY_CAST('340282366920938463463374607431768211456' AS UHUGEINT) +-- +ok +== +SELECT TRY_CAST('340282366920938463463374607431768211456'::DOUBLE AS UHUGEINT) +-- +ok +== +SELECT TRY_CAST('-1' AS UHUGEINT) +-- +ok +== diff --git a/parser/testdata/corpus/sql/types/union/struct_to_json_union.test b/parser/testdata/corpus/sql/types/union/struct_to_json_union.test new file mode 100644 index 0000000..19b53d1 --- /dev/null +++ b/parser/testdata/corpus/sql/types/union/struct_to_json_union.test @@ -0,0 +1,49 @@ +# source: test/sql/types/union/struct_to_json_union.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +create table union_tbl( + col UNION( + a JSON, + b INTEGER, + c TINYINT + ) +) +-- +ok +== +insert into union_tbl VALUES ( + { + tag: 0::UINT8, + a: '{"a": "hello", "b": true}', + b: null::INTEGER, + c: null::TINYINT + } +) +-- +ok +== +insert into union_tbl VALUES ( + { + tag: 0::UINT8, + a: '{"c": "world"}'::JSON, + b: null::INTEGER, + c: null::TINYINT + } +) +-- +ok +== +select * from union_tbl; +-- +ok +== +EXPORT DATABASE '{TEST_DIR}/json_union' (FORMAT PARQUET); +-- +ok +== +IMPORT DATABASE '{TEST_DIR}/json_union'; +-- +ok +== diff --git a/parser/testdata/corpus/sql/types/union/struct_to_union.test b/parser/testdata/corpus/sql/types/union/struct_to_union.test new file mode 100644 index 0000000..50d2582 --- /dev/null +++ b/parser/testdata/corpus/sql/types/union/struct_to_union.test @@ -0,0 +1,87 @@ +# source: test/sql/types/union/struct_to_union.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +create table union_tbl( + col UNION( + a BOOL, + b INTEGER, + c TINYINT + ) +) +-- +ok +== +insert into union_tbl VALUES + ({tag: '0', a: true, b: null, c: null}) +-- +ok +== +insert into union_tbl VALUES + ({tag: 0::UINT8, a: true, b: null::INTEGER, d: null::TINYINT}) +-- +ok +== +insert into union_tbl VALUES + ({tag: 0::UINT8, a: 1, b: null::INTEGER, c: null::TINYINT}) +-- +ok +== +insert into union_tbl VALUES + ({tag: 4::UINT8, a: true, b: null::INTEGER, c: null::TINYINT}) +-- +ok +== +create table struct_tbl( + col STRUCT( + tag UINT8, + A BOOL, + B INTEGER, + C TINYINT + ) +) +-- +ok +== +INSERT INTO struct_tbl VALUES + (ROW(0, True, NULL, NULL)), + (ROW(1, NULL, 23423, NULL)), + (ROW(0, True, NULL, NULL)) +-- +ok +== +insert into union_tbl select * from struct_tbl; +-- +ok +== +delete from struct_tbl; +-- +ok +== +INSERT INTO struct_tbl VALUES + (ROW(0, True, NULL, NULL)), + (ROW(1, NULL, 23423, NULL)), + (ROW(2, True, NULL, NULL)) +-- +ok +== +insert into union_tbl VALUES( + {tag: 0::UINT8, a: False, b: NULL::INTEGER, c: NULL::TINYINT} +) +-- +ok +== +insert into union_tbl VALUES( + {tag: 1::UINT8, a: NULL::BOOLEAN, b: 32412, c: 123::TINYINT} +) +-- +ok +== +insert into struct_tbl VALUES + (ROW(1::UINT8, NULL, 1, NULL)), + (ROW(1::UINT8, NULL, 2, NULL)), + (ROW(1::UINT8, NULL, 3, 0)) +-- +ok +== diff --git a/parser/testdata/corpus/sql/types/union/union_aggregate.test b/parser/testdata/corpus/sql/types/union/union_aggregate.test new file mode 100644 index 0000000..b713f79 --- /dev/null +++ b/parser/testdata/corpus/sql/types/union/union_aggregate.test @@ -0,0 +1,37 @@ +# source: test/sql/types/union/union_aggregate.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +CREATE TABLE tbl1 (u UNION(num INT, str VARCHAR)); +-- +ok +== +INSERT INTO tbl1 VALUES (1), ('bar'), (3), ('foo'), (2), ('baz'); +-- +ok +== +SELECT FIRST(u), LAST(u) FROM tbl1; +-- +ok +== +SELECT union_tag(u), max(u) FROM tbl1 GROUP BY union_tag(u); +-- +ok +== +SELECT union_tag(u), min(u) FROM tbl1 GROUP BY union_tag(u); +-- +ok +== +SELECT sum(u.num) FROM tbl1; +-- +ok +== +SELECT LAST(u) FROM tbl1 GROUP BY union_tag(u) HAVING union_tag(u) = 'num'; +-- +ok +== +SELECT max(u), min(u) FROM tbl1; +-- +ok +== diff --git a/parser/testdata/corpus/sql/types/union/union_ambiguous.test b/parser/testdata/corpus/sql/types/union/union_ambiguous.test new file mode 100644 index 0000000..4fe6749 --- /dev/null +++ b/parser/testdata/corpus/sql/types/union/union_ambiguous.test @@ -0,0 +1,77 @@ +# source: test/sql/types/union/union_ambiguous.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +CREATE TABLE tbl(a UNION(b INT, b INT)); +-- +ok +== +CREATE TABLE tbl(a UNION(b INT, B INT)); +-- +ok +== +CREATE TABLE tbl(a UNION(b INT, c INT)); +-- +ok +== +INSERT INTO tbl VALUES (union_value(b := 1)), (union_value(c := 2)), (union_value(b := 3)); +-- +ok +== +INSERT INTO tbl VALUES (union_value(b := 3)), (union_value(a := 4)), (union_value(b := 5)); +-- +ok +== +SELECT a.b FROM tbl +-- +ok +== +SELECT a.c FROM tbl +-- +ok +== +SELECT a FROM tbl +-- +ok +== +CREATE TABLE tbl2(a UNION(b STRUCT(foo VARCHAR), c STRUCT(foo VARCHAR))); +-- +ok +== +INSERT INTO tbl2 VALUES ({'foo': 'bar'}), ({'foo': 'baz'}); +-- +ok +== +INSERT INTO tbl2 VALUES (union_value(b := {'foo': 'bar'})), (union_value(c := {'foo': 'baz'})), (union_value(d := {'foo': 'qux'})); +-- +ok +== +INSERT INTO tbl2 VALUES (union_value(b := {'foo': 'bar'})), (union_value(c := {'foo': 'baz'})); +-- +ok +== +SELECT a.b.foo FROM tbl2 +-- +ok +== +SELECT a.c.foo FROM tbl2 +-- +ok +== +SELECT a FROM tbl2 +-- +ok +== +CREATE TABLE tbl3(a UNION(b INT, c STRUCT(b INT))); +-- +ok +== +INSERT INTO tbl3 VALUES (1), (union_value(b := 2)), (union_value(c := {'b': 3})); +-- +ok +== +SELECT a FROM tbl3 +-- +ok +== diff --git a/parser/testdata/corpus/sql/types/union/union_cast.test b/parser/testdata/corpus/sql/types/union/union_cast.test new file mode 100644 index 0000000..d9e29f0 --- /dev/null +++ b/parser/testdata/corpus/sql/types/union/union_cast.test @@ -0,0 +1,158 @@ +# source: test/sql/types/union/union_cast.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +create table tbl1(u UNION(i32 INT, str VARCHAR)); +-- +ok +== +insert into tbl1 values (1) , ('two') , ('three') +-- +ok +== +SELECT u::int FROM tbl1; +-- +ok +== +SELECT u::varchar FROM tbl1; +-- +ok +== +create table tbl2(u UNION(str VARCHAR, i32 INT, f32 FLOAT)); +-- +ok +== +insert into tbl2 values ('five'), (4), (6.0); +-- +ok +== +SELECT u.i32, u.str, u.f32 FROM tbl2; +-- +ok +== +SELECT * FROM tbl2 UNION ALL SELECT * FROM tbl1; +-- +ok +== +SELECT * FROM tbl1 UNION ALL SELECT * FROM tbl2; +-- +ok +== +SELECT u.i32, u.str, u.f32 FROM tbl2 UNION ALL SELECT u.i32, u.str, NULL FROM tbl1 ORDER BY ALL; +-- +ok +== +INSERT INTO tbl2 SELECT * FROM tbl1; +-- +ok +== +SELECT u.f32 FROM tbl2; +-- +ok +== +SELECT union_tag(u), u.i32, u.str, u.f32 FROM tbl2; +-- +ok +== +CREATE TABLE tbl3 (u UNION(i INT)); +-- +ok +== +INSERT INTO tbl3 VALUES (1), (2), (3); +-- +ok +== +SELECT u::UNION(i SMALLINT) FROM tbl3 ORDER BY ALL;; +-- +ok +== +CREATE TABLE tbl4 (u UNION(i INT, b BLOB)); +-- +ok +== +INSERT INTO tbl4 VALUES (1), ('010203'::BLOB), (3), ('070809'::BLOB); +-- +ok +== +SELECT u::UNION(i SMALLINT, v VARCHAR) FROM tbl4; +-- +ok +== +SELECT u::UNION(i SMALLINT, b VARCHAR) FROM tbl4 ORDER BY ALL;; +-- +ok +== +SELECT u::UNION(i SMALLINT, b INT) FROM tbl4; +-- +ok +== +DELETE FROM tbl4 WHERE union_tag(u) == 'b'; +-- +ok +== +INSERT INTO tbl4 VALUES (union_value(b := NULL::BLOB)), (union_value(b := NULL)), (NULL), (NULL::BLOB); +-- +ok +== +SELECT union_tag(u), union_tag(u::UNION(i SMALLINT, b INT)), u::UNION(i SMALLINT, b INT) FROM tbl4 ORDER BY ALL;; +-- +ok +== +select [ + true::UNION( + a integer, + c bool + ) +] as a from range(10); +-- +ok +== +CREATE TABLE t3 (id integer, u union(s1 struct(f1 varchar, f2 int), s2 struct(b1 varchar))); +-- +ok +== +INSERT INTO t3 VALUES (1, {b1: 'a'}); +-- +ok +== +INSERT INTO t3 VALUES (2, row('s1', 2)); +-- +ok +== +INSERT INTO t3 VALUES (3, {f1: 'c', f2: 3}); +-- +ok +== +INSERT INTO t3 VALUES (4, row('s2')); +-- +ok +== +SELECT union_tag(1::INTEGER::UNION(f1 VARCHAR, t DOUBLE, f2 BOOLEAN)) +-- +ok +== +SELECT union_tag(1::INTEGER::UNION(t BIGINT, f1 STRUCT(i INTEGER), f2 BOOLEAN)) +-- +ok +== +SELECT union_tag(1::FLOAT::UNION(f1 VARCHAR, f2 DOUBLE, t FLOAT)) +-- +ok +== +SELECT union_tag(1::INTEGER::UNION(lu UNION(f1 VARCHAR, f2 BOOL), ru UNION(t BIGINT, f3 TINYINT))) +-- +ok +== +SELECT union_tag((1::INTEGER::UNION(lu UNION(f1 VARCHAR, f2 BOOL), ru UNION(t BIGINT, f3 TINYINT))).ru); +-- +ok +== +SELECT union_tag(1::INTEGER::UNION(lu UNION(f1 VARCHAR, t2 BIGINT), ru UNION(t2 BIGINT, f3 TINYINT))); +-- +ok +== +SELECT union_tag(1::INTEGER::UNION(f1 VARCHAR, t2 BIGINT)::UNION(F1 VARCHAR, T2 BIGINT, F3 TINYINT)) +-- +ok +== diff --git a/parser/testdata/corpus/sql/types/union/union_compare.test b/parser/testdata/corpus/sql/types/union/union_compare.test new file mode 100644 index 0000000..3e3ae3b --- /dev/null +++ b/parser/testdata/corpus/sql/types/union/union_compare.test @@ -0,0 +1,39 @@ +# source: test/sql/types/union/union_compare.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +create or replace table unions(u UNION(num INTEGER, str VARCHAR)); +-- +ok +== +insert into unions values (1), ('two'), (NULL), (union_value(str := NULL)); +-- +ok +== +select l.u, r.u, l.u = r.u, l.u <> r.u +from unions l, unions r +order by all; +-- +ok +== +select union_value(str := NULL) = union_value(str := NULL); +-- +ok +== +WITH vals AS ( + SELECT + union_value(str := 'a')::UNION(num INT, str VARCHAR) AS a, + union_value(str := NULL)::UNION(num INT, str VARCHAR) AS n, + union_value(str := 'b')::UNION(num INT, str VARCHAR) AS b +) +SELECT + a = n, + n = b, + a = b, + a IS NOT DISTINCT FROM n, + {'u': a} = {'u': n} +FROM vals; +-- +ok +== diff --git a/parser/testdata/corpus/sql/types/union/union_extract.test b/parser/testdata/corpus/sql/types/union/union_extract.test new file mode 100644 index 0000000..d439b38 --- /dev/null +++ b/parser/testdata/corpus/sql/types/union/union_extract.test @@ -0,0 +1,97 @@ +# source: test/sql/types/union/union_extract.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +SELECT union_extract(1, 'b'); +-- +ok +== +SELECT union_extract(1::UNION(a INT, b FLOAT), 'a'); +-- +ok +== +CREATE TABLE tbl1 (u UNION(a INT, b FLOAT, c VARCHAR)); +-- +ok +== +INSERT INTO tbl1 VALUES (1), ('text'), (2.0); +-- +ok +== +SELECT u.a FROM tbl1 WHERE u.a IS NOT NULL +-- +ok +== +SELECT u.a FROM tbl1 +-- +ok +== +SELECT u.b FROM tbl1 WHERE u.b IS NOT NULL +-- +ok +== +SELECT u.b FROM tbl1 +-- +ok +== +SELECT u.c FROM tbl1 WHERE u.c IS NOT NULL +-- +ok +== +SELECT u.c FROM tbl1 +-- +ok +== +SELECT u.a, u.b, u.c FROM tbl1 +-- +ok +== +SELECT union_extract(u, 'a') FROM tbl1 WHERE union_extract(u, 'a') IS NOT NULL +-- +ok +== +SELECT union_extract(u, 'a') FROM tbl1 +-- +ok +== +SELECT union_extract(u, 'b') FROM tbl1 WHERE union_extract(u, 'b') IS NOT NULL +-- +ok +== +SELECT union_extract(u, 'b') FROM tbl1 +-- +ok +== +SELECT union_extract(u, 'c') FROM tbl1 WHERE union_extract(u, 'c') IS NOT NULL +-- +ok +== +SELECT union_extract(u, 'c') FROM tbl1 +-- +ok +== +SELECT + union_extract(u, 'a'), + union_extract(u, 'c'), + union_extract(u, 'b') +FROM tbl1 +-- +ok +== +PREPARE p1 AS SELECT union_extract(u, ?) FROM tbl1; +-- +ok +== +EXECUTE p1('a'); +-- +ok +== +EXECUTE p1('b'); +-- +ok +== +EXECUTE p1('c'); +-- +ok +== diff --git a/parser/testdata/corpus/sql/types/union/union_join.test b/parser/testdata/corpus/sql/types/union/union_join.test new file mode 100644 index 0000000..eff7699 --- /dev/null +++ b/parser/testdata/corpus/sql/types/union/union_join.test @@ -0,0 +1,74 @@ +# source: test/sql/types/union/union_join.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +CREATE TABLE tbl1(id INT, a UNION(b INT, c VARCHAR)); +-- +ok +== +CREATE TABLE tbl2(id INT, d UNION(e INT, f VARCHAR)); +-- +ok +== +INSERT INTO tbl1 VALUES (1, 1), (3, 'foo'), (2, 2), (4, 'bar'); +-- +ok +== +INSERT INTO tbl2 VALUES (1, 'foo'), (2, 'bar'), (3, 1), (4, 2); +-- +ok +== +SELECT id, union_tag(a), a.b, a.c FROM tbl1 UNION SELECT id, union_tag(d), d.e, d.f FROM tbl2 ORDER BY ALL; +-- +ok +== +SELECT id, union_tag(a) as tag, a.b as v1, a.c as v2 FROM tbl1 UNION SELECT id, union_tag(d) as tag, d.e as v1, d.f as v2 FROM tbl2 ORDER BY ALL; +-- +ok +== +SELECT tbl1.a.c, tbl1.id, tbl2.id FROM tbl2 JOIN tbl1 ON tbl1.a.c = tbl2.d.f ORDER BY ALL; +-- +ok +== +SELECT t1.id FROM tbl1 as t1 JOIN tbl1 as t2 ON t1.a = t2.a ORDER BY ALL; +-- +ok +== +DROP TABLE tbl1; +DROP TABLE tbl2; +CREATE TABLE tbl1(id INT, a UNION(num INT, str VARCHAR)); +CREATE TABLE tbl2(id INT, b UNION(num INT, str VARCHAR)); +INSERT INTO tbl1 VALUES (1, 1), (3, 'foo'), (2, 2), (4, 'bar'), (5, 1), (4, NULL); +INSERT INTO tbl2 VALUES (1, 'foo'), (2, 'bar'), (3, 1), (4, 2), (5, 'qux'); +-- +ok +== +SELECT tbl1.a, tbl1.id, tbl2.id FROM tbl2 INNER JOIN tbl1 ON tbl1.a = tbl2.b ORDER BY ALL; +-- +ok +== +SELECT tbl1.a, tbl1.id, tbl2.id FROM tbl2 FULL OUTER JOIN tbl1 ON tbl1.a = tbl2.b ORDER BY ALL; +-- +ok +== +SELECT tbl1.a, tbl1.id, tbl2.id FROM tbl2 LEFT OUTER JOIN tbl1 ON tbl1.a = tbl2.b ORDER BY ALL; +-- +ok +== +SELECT tbl1.a, tbl1.id, tbl2.id FROM tbl2 RIGHT OUTER JOIN tbl1 ON tbl1.a = tbl2.b ORDER BY ALL; +-- +ok +== +SELECT id FROM tbl1 WHERE a = union_value(str :='foo') +-- +ok +== +SELECT id from tbl1 where a = 'foo'::UNION(num INT, str VARCHAR) +-- +ok +== +SELECT union_tag('foo'::UNION(num INT, str VARCHAR)) +-- +ok +== diff --git a/parser/testdata/corpus/sql/types/union/union_limit_offset.test b/parser/testdata/corpus/sql/types/union/union_limit_offset.test new file mode 100644 index 0000000..dd27b6b --- /dev/null +++ b/parser/testdata/corpus/sql/types/union/union_limit_offset.test @@ -0,0 +1,17 @@ +# source: test/sql/types/union/union_limit_offset.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +INSERT INTO tbl1 VALUES (1), ('bar'), (2), ('foo'), (3), ('baz'); +-- +ok +== +SELECT * FROM tbl1 WHERE u.str IS NOT NULL OFFSET 1 +-- +ok +== +SELECT * FROM tbl1 WHERE u.str IS NOT NULL LIMIT 1 OFFSET 1 +-- +ok +== diff --git a/parser/testdata/corpus/sql/types/union/union_limits.test b/parser/testdata/corpus/sql/types/union/union_limits.test new file mode 100644 index 0000000..f8b63f3 --- /dev/null +++ b/parser/testdata/corpus/sql/types/union/union_limits.test @@ -0,0 +1,95 @@ +# source: test/sql/types/union/union_limits.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +CREATE TABLE tbl1 (u UNION( + a1 INT, a2 INT, a3 INT, a4 INT, a5 INT, a6 INT, a7 INT, a8 INT, + a9 INT, a10 INT, a11 INT, a12 INT, a13 INT, a14 INT, a15 INT, a16 INT, + a17 INT, a18 INT, a19 INT, a20 INT, a21 INT, a22 INT, a23 INT, a24 INT, + a25 INT, a26 INT, a27 INT, a28 INT, a29 INT, a30 INT, a31 INT, a32 INT, + a33 INT, a34 INT, a35 INT, a36 INT, a37 INT, a38 INT, a39 INT, a40 INT, + a41 INT, a42 INT, a43 INT, a44 INT, a45 INT, a46 INT, a47 INT, a48 INT, + a49 INT, a50 INT, a51 INT, a52 INT, a53 INT, a54 INT, a55 INT, a56 INT, + a57 INT, a58 INT, a59 INT, a60 INT, a61 INT, a62 INT, a63 INT, a64 INT, + a65 INT, a66 INT, a67 INT, a68 INT, a69 INT, a70 INT, a71 INT, a72 INT, + a73 INT, a74 INT, a75 INT, a76 INT, a77 INT, a78 INT, a79 INT, a80 INT, + a81 INT, a82 INT, a83 INT, a84 INT, a85 INT, a86 INT, a87 INT, a88 INT, + a89 INT, a90 INT, a91 INT, a92 INT, a93 INT, a94 INT, a95 INT, a96 INT, + a97 INT, a98 INT, a99 INT, a100 INT, a101 INT, a102 INT, a103 INT, a104 INT, + a105 INT, a106 INT, a107 INT, a108 INT, a109 INT, a110 INT, a111 INT, a112 INT, + a113 INT, a114 INT, a115 INT, a116 INT, a117 INT, a118 INT, a119 INT, a120 INT, + a121 INT, a122 INT, a123 INT, a124 INT, a125 INT, a126 INT, a127 INT, a128 INT, + a129 INT, a130 INT, a131 INT, a132 INT, a133 INT, a134 INT, a135 INT, a136 INT, + a137 INT, a138 INT, a139 INT, a140 INT, a141 INT, a142 INT, a143 INT, a144 INT, + a145 INT, a146 INT, a147 INT, a148 INT, a149 INT, a150 INT, a151 INT, a152 INT, + a153 INT, a154 INT, a155 INT, a156 INT, a157 INT, a158 INT, a159 INT, a160 INT, + a161 INT, a162 INT, a163 INT, a164 INT, a165 INT, a166 INT, a167 INT, a168 INT, + a169 INT, a170 INT, a171 INT, a172 INT, a173 INT, a174 INT, a175 INT, a176 INT, + a177 INT, a178 INT, a179 INT, a180 INT, a181 INT, a182 INT, a183 INT, a184 INT, + a185 INT, a186 INT, a187 INT, a188 INT, a189 INT, a190 INT, a191 INT, a192 INT, + a193 INT, a194 INT, a195 INT, a196 INT, a197 INT, a198 INT, a199 INT, a200 INT, + a201 INT, a202 INT, a203 INT, a204 INT, a205 INT, a206 INT, a207 INT, a208 INT, + a209 INT, a210 INT, a211 INT, a212 INT, a213 INT, a214 INT, a215 INT, a216 INT, + a217 INT, a218 INT, a219 INT, a220 INT, a221 INT, a222 INT, a223 INT, a224 INT, + a225 INT, a226 INT, a227 INT, a228 INT, a229 INT, a230 INT, a231 INT, a232 INT, + a233 INT, a234 INT, a235 INT, a236 INT, a237 INT, a238 INT, a239 INT, a240 INT, + a241 INT, a242 INT, a243 INT, a244 INT, a245 INT, a246 INT, a247 INT, a248 INT, + a249 INT, a250 INT, a251 INT, a252 INT, a253 INT, a254 INT, a255 INT, a256 INT +)) +-- +ok +== +INSERT INTO tbl1 VALUES (union_value(a256 := 1337)), (union_value(a1 := 42)) +-- +ok +== +SELECT u.a256 FROM tbl1; +-- +ok +== +SELECT u.a1 FROM tbl1; +-- +ok +== +CREATE TABLE tbl1 (u UNION( + a1 INT, a2 INT, a3 INT, a4 INT, a5 INT, a6 INT, a7 INT, a8 INT, + a9 INT, a10 INT, a11 INT, a12 INT, a13 INT, a14 INT, a15 INT, a16 INT, + a17 INT, a18 INT, a19 INT, a20 INT, a21 INT, a22 INT, a23 INT, a24 INT, + a25 INT, a26 INT, a27 INT, a28 INT, a29 INT, a30 INT, a31 INT, a32 INT, + a33 INT, a34 INT, a35 INT, a36 INT, a37 INT, a38 INT, a39 INT, a40 INT, + a41 INT, a42 INT, a43 INT, a44 INT, a45 INT, a46 INT, a47 INT, a48 INT, + a49 INT, a50 INT, a51 INT, a52 INT, a53 INT, a54 INT, a55 INT, a56 INT, + a57 INT, a58 INT, a59 INT, a60 INT, a61 INT, a62 INT, a63 INT, a64 INT, + a65 INT, a66 INT, a67 INT, a68 INT, a69 INT, a70 INT, a71 INT, a72 INT, + a73 INT, a74 INT, a75 INT, a76 INT, a77 INT, a78 INT, a79 INT, a80 INT, + a81 INT, a82 INT, a83 INT, a84 INT, a85 INT, a86 INT, a87 INT, a88 INT, + a89 INT, a90 INT, a91 INT, a92 INT, a93 INT, a94 INT, a95 INT, a96 INT, + a97 INT, a98 INT, a99 INT, a100 INT, a101 INT, a102 INT, a103 INT, a104 INT, + a105 INT, a106 INT, a107 INT, a108 INT, a109 INT, a110 INT, a111 INT, a112 INT, + a113 INT, a114 INT, a115 INT, a116 INT, a117 INT, a118 INT, a119 INT, a120 INT, + a121 INT, a122 INT, a123 INT, a124 INT, a125 INT, a126 INT, a127 INT, a128 INT, + a129 INT, a130 INT, a131 INT, a132 INT, a133 INT, a134 INT, a135 INT, a136 INT, + a137 INT, a138 INT, a139 INT, a140 INT, a141 INT, a142 INT, a143 INT, a144 INT, + a145 INT, a146 INT, a147 INT, a148 INT, a149 INT, a150 INT, a151 INT, a152 INT, + a153 INT, a154 INT, a155 INT, a156 INT, a157 INT, a158 INT, a159 INT, a160 INT, + a161 INT, a162 INT, a163 INT, a164 INT, a165 INT, a166 INT, a167 INT, a168 INT, + a169 INT, a170 INT, a171 INT, a172 INT, a173 INT, a174 INT, a175 INT, a176 INT, + a177 INT, a178 INT, a179 INT, a180 INT, a181 INT, a182 INT, a183 INT, a184 INT, + a185 INT, a186 INT, a187 INT, a188 INT, a189 INT, a190 INT, a191 INT, a192 INT, + a193 INT, a194 INT, a195 INT, a196 INT, a197 INT, a198 INT, a199 INT, a200 INT, + a201 INT, a202 INT, a203 INT, a204 INT, a205 INT, a206 INT, a207 INT, a208 INT, + a209 INT, a210 INT, a211 INT, a212 INT, a213 INT, a214 INT, a215 INT, a216 INT, + a217 INT, a218 INT, a219 INT, a220 INT, a221 INT, a222 INT, a223 INT, a224 INT, + a225 INT, a226 INT, a227 INT, a228 INT, a229 INT, a230 INT, a231 INT, a232 INT, + a233 INT, a234 INT, a235 INT, a236 INT, a237 INT, a238 INT, a239 INT, a240 INT, + a241 INT, a242 INT, a243 INT, a244 INT, a245 INT, a246 INT, a247 INT, a248 INT, + a249 INT, a250 INT, a251 INT, a252 INT, a253 INT, a254 INT, a255 INT, a256 INT, a257 +)) +-- +error: Parser Error: syntax error at or near ")" +== +CREATE TABLE tbl1 (u UNION()) +-- +error: Parser Error: syntax error at or near ")" +== diff --git a/parser/testdata/corpus/sql/types/union/union_list.test b/parser/testdata/corpus/sql/types/union/union_list.test new file mode 100644 index 0000000..200671b --- /dev/null +++ b/parser/testdata/corpus/sql/types/union/union_list.test @@ -0,0 +1,72 @@ +# source: test/sql/types/union/union_list.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +CREATE TABLE tbl1 (union_list UNION(str VARCHAR, num INT)[]); +-- +ok +== +INSERT INTO tbl1 VALUES ([1::UNION(str VARCHAR, num INT), 'one']), (['two'::UNION(str VARCHAR, num INT), 2]), ([3::UNION(str VARCHAR, num INT), 'three', '3']), ([4]), (list_value('five')), ([6]) +-- +ok +== +CREATE TABLE tbl2 (union_with_list UNION(list INT[], num INT)); +-- +ok +== +INSERT INTO tbl2 VALUES ([1, 2, 3]), (4), ([5]), (6), (NULL), (7), (list_value(8, 9, 10)); +-- +ok +== +SELECT * FROM tbl2 WHERE union_with_list = [5] +-- +ok +== +SELECT union_with_list.num FROM tbl2; +-- +ok +== +SELECT union_list[1] FROM tbl2 JOIN tbl1 ON union_with_list.num = union_list[1].num; +-- +ok +== +SELECT union_list[1] FROM tbl2 JOIN tbl1 ON union_with_list.num = union_list[1]; +-- +ok +== +CREATE TABLE tbl3 (union_with_lists UNION(strs VARCHAR[], nums INT[])); +-- +ok +== +INSERT INTO tbl3 VALUES + (union_value(strs:=['one', 'two'])), + (union_value(nums:=[1, 2])), + (union_value(strs:=['three', NULL])), + (union_value(nums:=[3, 4])), + (union_value(strs:=['five'])), + (union_value(nums:=[5])), + (union_value(strs:=['six'])), + (union_value(nums:=[NULL, 6])), + (union_value(strs:=NULL)), + (union_value(strs:=[1])) +-- +ok +== +SELECT union_tag(union_with_lists), union_with_lists FROM tbl3 +-- +ok +== +WITH t(id, l, r) AS ( + VALUES + (0, + [union_value(num := 1)::UNION(num INT, str VARCHAR), union_value(num := 2)::UNION(num INT, str VARCHAR)]::UNION(num INT, str VARCHAR)[], + [union_value(num := 1)::UNION(num INT, str VARCHAR), union_value(num := 2)::UNION(num INT, str VARCHAR)]::UNION(num INT, str VARCHAR)[]), + (1, + [union_value(str := 'x')::UNION(num INT, str VARCHAR)]::UNION(num INT, str VARCHAR)[], + [union_value(str := 'x')::UNION(num INT, str VARCHAR)]::UNION(num INT, str VARCHAR)[]) +) +SELECT id, l = r, l IS NOT DISTINCT FROM r FROM t ORDER BY id; +-- +ok +== diff --git a/parser/testdata/corpus/sql/types/union/union_sort.test b/parser/testdata/corpus/sql/types/union/union_sort.test new file mode 100644 index 0000000..0c30052 --- /dev/null +++ b/parser/testdata/corpus/sql/types/union/union_sort.test @@ -0,0 +1,57 @@ +# source: test/sql/types/union/union_sort.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +CREATE TABLE tbl (a UNION(a INT, b INT)); +-- +ok +== +INSERT INTO tbl VALUES (union_value(b := 1)), (union_value(a := 4)), (union_value(a := 1)), (union_value(b := 2)), (union_value(a := 3)), (NULL); +-- +ok +== +SELECT union_tag(a), a FROM tbl ORDER BY a ASC; +-- +ok +== +SELECT union_tag(a), a FROM tbl ORDER BY a DESC; +-- +ok +== +CREATE TABLE tbl5 (a UNION(lft INT, u UNION(lft VARCHAR, rght INT))); +-- +ok +== +INSERT INTO tbl5 VALUES (union_value(lft := 1)) +-- +ok +== +CREATE TABLE tbl2 (u UNION(lft INT, u UNION(lft VARCHAR, rght INT))); +-- +ok +== +INSERT INTO tbl2 VALUES (union_value(lft := 1)); +-- +ok +== +INSERT INTO tbl2 VALUES (NULL); +-- +ok +== +INSERT INTO tbl2 VALUES (union_value(u := union_value(rght := 2))); +-- +ok +== +INSERT INTO tbl2 VALUES (union_value(u := union_value(lft := '3'))); +-- +ok +== +INSERT INTO tbl2 VALUES (union_value(u := '4')); +-- +ok +== +SELECT u, union_tag(u), union_tag(u.u) FROM tbl2 ORDER BY u; +-- +ok +== diff --git a/parser/testdata/corpus/sql/types/union/union_struct.test b/parser/testdata/corpus/sql/types/union/union_struct.test new file mode 100644 index 0000000..30af3a8 --- /dev/null +++ b/parser/testdata/corpus/sql/types/union/union_struct.test @@ -0,0 +1,53 @@ +# source: test/sql/types/union/union_struct.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +CREATE TABLE tbl1 (union_struct UNION(str VARCHAR, obj STRUCT(k VARCHAR, v INT))) +-- +ok +== +INSERT INTO tbl1 VALUES + ({'k': 'key1', 'v': 1}), + ('not a struct'), + (NULL), + ({'k': NULL, 'v': 1}), + ({'k': 'key2', 'v': NULL}), + ('key2') +-- +ok +== +SELECT union_struct.obj.k FROM tbl1 +-- +ok +== +SELECT union_struct.obj.v FROM tbl1 +-- +ok +== +SELECT union_struct.str FROM tbl1 +-- +ok +== +SELECT * FROM tbl1 as l JOIN tbl1 as r ON l.union_struct.str = r.union_struct.obj.k +-- +ok +== +CREATE TABLE tbl2 (struct_union STRUCT(str VARCHAR, alt UNION(k VARCHAR, v INT))) +-- +ok +== +INSERT INTO tbl2 VALUES + ({'str': 'key1', 'alt': 1}), + ({'str': 'key2', 'alt': 'key2'}), + ({'str': NULL, 'alt': NULL}), + ({'str': NULL, 'alt': union_value(v := NULL)}), + ({'str': 'key3', 'alt': union_value(k := NULL)}), + ({'str': 'key4', 'alt': 'key2'}) +-- +ok +== +SELECT * FROM tbl1 JOIN tbl2 ON tbl1.union_struct.str = tbl2.struct_union.alt.k order by all +-- +ok +== diff --git a/parser/testdata/corpus/sql/types/union/union_tag.test b/parser/testdata/corpus/sql/types/union/union_tag.test new file mode 100644 index 0000000..19a473e --- /dev/null +++ b/parser/testdata/corpus/sql/types/union/union_tag.test @@ -0,0 +1,57 @@ +# source: test/sql/types/union/union_tag.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +SELECT union_tag(1); +-- +ok +== +SELECT union_tag(1::UNION(a INT, b VARCHAR)); +-- +ok +== +SELECT union_tag(u) FROM tbl1 +-- +ok +== +SELECT u FROM tbl1; +-- +ok +== +SELECT union_tag(u) FROM tbl1 WHERE u = (1::UNION(a INT, b FLOAT, c VARCHAR)); +-- +ok +== +SELECT enum_first(union_tag(u)) FROM tbl1 LIMIT 1; +-- +ok +== +SELECT enum_last(union_tag(u)) FROM tbl1 LIMIT 1; +-- +ok +== +SELECT enum_range(union_tag(u)) FROM tbl1 LIMIT 1; +-- +ok +== +PREPARE p1 as SELECT union_tag(u) FROM tbl1; +-- +ok +== +EXECUTE p1; +-- +ok +== +PREPARE p2 as SELECT union_tag(?); +-- +ok +== +EXECUTE p2(1); +-- +ok +== +EXECUTE p2('woo'::UNION(a INT, b VARCHAR)); +-- +ok +== diff --git a/parser/testdata/corpus/sql/types/union/union_test.test b/parser/testdata/corpus/sql/types/union/union_test.test new file mode 100644 index 0000000..f5c7140 --- /dev/null +++ b/parser/testdata/corpus/sql/types/union/union_test.test @@ -0,0 +1,57 @@ +# source: test/sql/types/union/union_test.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +CREATE TABLE tbl(u UNION(i INTEGER, f FLOAT)); +-- +ok +== +INSERT INTO tbl VALUES (1::INTEGER); +-- +ok +== +SELECT * from tbl; +-- +ok +== +INSERT INTO tbl VALUES (2.0::FLOAT); +-- +ok +== +SELECT u.i FROM tbl; +-- +ok +== +SELECT union_tag(u) FROM tbl; +-- +ok +== +INSERT INTO tbl SELECT i from range(10) tbl(i); +-- +ok +== +CREATE TABLE tbl2(k VARCHAR, u UNION(num INTEGER, str VARCHAR) DEFAULT 'not set'); +-- +ok +== +INSERT INTO tbl2(k) VALUES ('a'), ('b'), ('c'); +-- +ok +== +SELECT u FROM tbl2; +-- +ok +== +CREATE TABLE tbl3(k VARCHAR, u UNION(numeric UNION(i INTEGER, f FLOAT), str VARCHAR) DEFAULT 13.37::FLOAT); +-- +ok +== +INSERT INTO tbl3(k) VALUES ('a'), ('b'), ('c'); +-- +ok +== +SELECT u.numeric.f FROM tbl3; +-- +ok +== diff --git a/parser/testdata/corpus/sql/types/union/union_validity.test b/parser/testdata/corpus/sql/types/union/union_validity.test new file mode 100644 index 0000000..e17fc4b --- /dev/null +++ b/parser/testdata/corpus/sql/types/union/union_validity.test @@ -0,0 +1,17 @@ +# source: test/sql/types/union/union_validity.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +CREATE TABLE tbl (u UNION(a INT, b VARCHAR)); +-- +ok +== +INSERT INTO tbl VALUES (1), (NULL), (NULL::VARCHAR), (NULL::INT); +-- +ok +== +SELECT union_tag(u) as tag, u as val FROM tbl; +-- +ok +== diff --git a/parser/testdata/corpus/sql/types/union/union_value.test b/parser/testdata/corpus/sql/types/union/union_value.test new file mode 100644 index 0000000..5f85a17 --- /dev/null +++ b/parser/testdata/corpus/sql/types/union/union_value.test @@ -0,0 +1,68 @@ +# source: test/sql/types/union/union_value.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +CREATE TABLE tbl(u UNION(num INTEGER, str STRING)); +-- +ok +== +INSERT INTO tbl VALUES (union_value(num := 1)); +-- +ok +== +INSERT INTO tbl VALUES (union_value()); +-- +ok +== +INSERT INTO tbl VALUES (union_value(num := 1, other := 2)) +-- +ok +== +INSERT INTO tbl VALUES (union_value(key := 1)) +-- +ok +== +INSERT INTO tbl VALUES (union_value(num := 1)), (1), (union_value(str := 'hello')), (2), ('world'); +-- +ok +== +INSERT INTO tbl SELECT + union_value(num := 1)::UNION(num INTEGER, str STRING) +UNION ALL SELECT + union_value(str := 'hello')::UNION(num INTEGER, str STRING) +-- +ok +== +SELECT CASE WHEN union_tag(u) = 'num' THEN u ELSE NULL END AS num FROM tbl; +-- +ok +== +CREATE TABLE tbl3 (u UNION(num INTEGER, str STRING)); +-- +ok +== +INSERT INTO tbl3 VALUES + (union_value(num := 1)), + (union_value(num := NULL)), + (union_value(str := '3')), + (union_value(str := NULL)), +-- +ok +== +SELECT u from tbl3 where u = NULL +-- +ok +== +SELECT union_value(str := NULL) IS NULL; +-- +ok +== +SELECT union_tag(union_value(str := NULL)) +-- +ok +== +SELECT union_tag(u), u FROM tbl3; +-- +ok +== diff --git a/parser/testdata/corpus/sql/types/unsigned/test_unsigned_arithmetic.test b/parser/testdata/corpus/sql/types/unsigned/test_unsigned_arithmetic.test new file mode 100644 index 0000000..099f72e --- /dev/null +++ b/parser/testdata/corpus/sql/types/unsigned/test_unsigned_arithmetic.test @@ -0,0 +1,81 @@ +# source: test/sql/types/unsigned/test_unsigned_arithmetic.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +CREATE TABLE unsigned(a UTINYINT,b USMALLINT, c UINTEGER, d UBIGINT); +-- +ok +== +INSERT INTO unsigned VALUES (1,1,1,1), (2,2,2,2); +-- +ok +== +select * from unsigned; +-- +ok +== +SELECT (200)::UTINYINT + (200)::UTINYINT; +-- +ok +== +SELECT (20)::UTINYINT + (200)::USMALLINT; +-- +ok +== +SELECT (20)::UBIGINT + (200)::UBIGINT; +-- +ok +== +SELECT (18446744073709551615)::UBIGINT + (18446744073709551615)::UBIGINT; +-- +ok +== +SELECT (200)::UTINYINT * (200)::UTINYINT; +-- +ok +== +SELECT (200)::UTINYINT * (200)::USMALLINT; +-- +ok +== +SELECT (200)::UBIGINT * (200)::UBIGINT; +-- +ok +== +SELECT (18446744073709551615)::UBIGINT * (3)::UBIGINT; +-- +ok +== +SELECT (200)::UTINYINT - (201)::UTINYINT; +-- +ok +== +SELECT (200)::UTINYINT - (201)::USMALLINT; +-- +ok +== +SELECT (200)::UTINYINT - (20)::USMALLINT; +-- +ok +== +SELECT 100::UTINYINT // 20::UTINYINT, 90::UTINYINT // 20::UTINYINT +-- +ok +== +SELECT 100::UTINYINT // 20::UBIGINT, 90::UTINYINT // 20::UBIGINT +-- +ok +== +SELECT 100::UTINYINT // 0::UTINYINT +-- +ok +== +SELECT 100::UTINYINT % 20::UTINYINT, 90::UTINYINT % 20::UTINYINT +-- +ok +== +SELECT 100::UTINYINT % 0::UTINYINT +-- +ok +== diff --git a/parser/testdata/corpus/sql/types/unsigned/test_unsigned_auto_cast.test b/parser/testdata/corpus/sql/types/unsigned/test_unsigned_auto_cast.test new file mode 100644 index 0000000..566b047 --- /dev/null +++ b/parser/testdata/corpus/sql/types/unsigned/test_unsigned_auto_cast.test @@ -0,0 +1,149 @@ +# source: test/sql/types/unsigned/test_unsigned_auto_cast.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +SELECT 200::UTINYINT + 0.5 +-- +ok +== +SELECT COS(100::UTINYINT) +-- +ok +== +SELECT CONCAT('hello number ', 100::UTINYINT) +-- +ok +== +SELECT 100000000::INTEGER + 100::USMALLINT +-- +ok +== +SELECT 100::USMALLINT + 0.5 +-- +ok +== +SELECT COS(100::USMALLINT) +-- +ok +== +SELECT CONCAT('hello number ', 100::USMALLINT) +-- +ok +== +SELECT 100000000::INTEGER + 100::UINTEGER +-- +ok +== +SELECT 100::UINTEGER + 0.5 +-- +ok +== +SELECT COS(100::UINTEGER) +-- +ok +== +SELECT CONCAT('hello number ', 100::UINTEGER) +-- +ok +== +SELECT 100000000::INTEGER + 100::UBIGINT +-- +ok +== +SELECT 100::UBIGINT + 0.5 +-- +ok +== +SELECT COS(100::UBIGINT) +-- +ok +== +SELECT CONCAT('hello number ', 100::UBIGINT) +-- +ok +== +SELECT '255'::UTINYINT; +-- +ok +== +SELECT '256'::UTINYINT; +-- +ok +== +SELECT '255'::USMALLINT; +-- +ok +== +SELECT '65536'::USMALLINT; +-- +ok +== +SELECT '65535'::UINTEGER; +-- +ok +== +SELECT '4294967296'::UINTEGER; +-- +ok +== +SELECT '4294967295'::UBIGINT; +-- +ok +== +SELECT '18446744073709551616'::UBIGINT; +-- +ok +== +SELECT '18446744073709551615'::UBIGINT; +-- +ok +== +SELECT (100::UTINYINT)::DECIMAL(3,0); +-- +ok +== +SELECT (100::UTINYINT)::DECIMAL(2,0); +-- +ok +== +SELECT 100::UTINYINT * 100::DECIMAL(3,0); +-- +ok +== +SELECT (100::USMALLINT)::DECIMAL(3,0); +-- +ok +== +SELECT (100::USMALLINT)::DECIMAL(2,0); +-- +ok +== +SELECT 100::USMALLINT * 100::DECIMAL(3,0); +-- +ok +== +SELECT (100::UINTEGER)::DECIMAL(3,0); +-- +ok +== +SELECT (100::UINTEGER)::DECIMAL(2,0); +-- +ok +== +SELECT 100::UINTEGER * 100::DECIMAL(3,0); +-- +ok +== +SELECT (100::UBIGINT)::DECIMAL(3,0); +-- +ok +== +SELECT (100::UBIGINT)::DECIMAL(2,0); +-- +ok +== +SELECT 100::UBIGINT * 100::DECIMAL(3,0); +-- +ok +== diff --git a/parser/testdata/corpus/sql/types/unsigned/test_unsigned_conversion.test b/parser/testdata/corpus/sql/types/unsigned/test_unsigned_conversion.test new file mode 100644 index 0000000..0e1eb83 --- /dev/null +++ b/parser/testdata/corpus/sql/types/unsigned/test_unsigned_conversion.test @@ -0,0 +1,365 @@ +# source: test/sql/types/unsigned/test_unsigned_conversion.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +SELECT '7'::UTINYINT, '130'::UTINYINT, '255'::UTINYINT +-- +ok +== +SELECT '7'::USMALLINT, '130'::USMALLINT, '65535'::USMALLINT +-- +ok +== +SELECT '7'::UINTEGER, '130'::UINTEGER, '4294967295'::UINTEGER +-- +ok +== +SELECT '7'::UBIGINT, '130'::UBIGINT, '18446744073709551615'::UBIGINT +-- +ok +== +SELECT '265'::UTINYINT +-- +ok +== +SELECT '65536'::USMALLINT +-- +ok +== +SELECT '4294967296'::UINTEGER +-- +ok +== +SELECT '18446744073709551616'::UBIGINT +-- +ok +== +SELECT '-1'::UTINYINT +-- +ok +== +SELECT '-1'::USMALLINT +-- +ok +== +SELECT '-1'::UINTEGER +-- +ok +== +SELECT '-1'::UBIGINT +-- +ok +== +SELECT '0'::UTINYINT, '-0'::UTINYINT +-- +ok +== +SELECT 42::TINYINT::UTINYINT, 42::SMALLINT::UTINYINT, 42::INTEGER::UTINYINT, 42::BIGINT::UTINYINT, 42::FLOAT::UTINYINT, 42::DOUBLE::UTINYINT; +-- +ok +== +SELECT 42::TINYINT::USMALLINT, 42::SMALLINT::USMALLINT, 42::INTEGER::USMALLINT, 42::BIGINT::USMALLINT, 42::FLOAT::USMALLINT, 42::DOUBLE::USMALLINT; +-- +ok +== +SELECT 42::TINYINT::UINTEGER, 42::SMALLINT::UINTEGER, 42::INTEGER::UINTEGER, 42::BIGINT::UINTEGER, 42::FLOAT::UINTEGER, 42::DOUBLE::UINTEGER; +-- +ok +== +SELECT 42::TINYINT::UBIGINT, 42::SMALLINT::UBIGINT, 42::INTEGER::UBIGINT, 42::BIGINT::UBIGINT, 42::FLOAT::UBIGINT, 42::DOUBLE::UBIGINT; +-- +ok +== +SELECT (9223372036854775807)::BIGINT::UTINYINT +-- +ok +== +SELECT (9223372036854775807)::BIGINT::USMALLINT +-- +ok +== +SELECT (9223372036854775807)::BIGINT::UINTEGER +-- +ok +== +SELECT (9223372036854775807)::BIGINT::UBIGINT +-- +ok +== +SELECT (9223372036854775808)::HUGEINT::UBIGINT +-- +ok +== +SELECT (9223372036854775808)::UHUGEINT::UBIGINT +-- +ok +== +SELECT (-42)::TINYINT::UTINYINT +-- +ok +== +SELECT (-42)::TINYINT::USMALLINT +-- +ok +== +SELECT (-42)::TINYINT::UINTEGER +-- +ok +== +SELECT (-42)::TINYINT::UBIGINT +-- +ok +== +SELECT -42::TINYINT::UTINYINT +-- +ok +== +SELECT (-42)::SMALLINT::UTINYINT +-- +ok +== +SELECT (-42)::SMALLINT::USMALLINT +-- +ok +== +SELECT (-42)::SMALLINT::UINTEGER +-- +ok +== +SELECT (-42)::SMALLINT::UBIGINT +-- +ok +== +SELECT (-42)::INTEGER::UTINYINT +-- +ok +== +SELECT (-42)::INTEGER::USMALLINT +-- +ok +== +SELECT (-42)::INTEGER::UINTEGER +-- +ok +== +SELECT (-42)::INTEGER::UBIGINT +-- +ok +== +SELECT (-42)::BIGINT::UTINYINT +-- +ok +== +SELECT (-42)::BIGINT::USMALLINT +-- +ok +== +SELECT (-42)::BIGINT::UINTEGER +-- +ok +== +SELECT (-42)::BIGINT::UBIGINT +-- +ok +== +SELECT (-42)::FLOAT::UTINYINT +-- +ok +== +SELECT (-42)::FLOAT::USMALLINT +-- +ok +== +SELECT (-42)::FLOAT::UINTEGER +-- +ok +== +SELECT (-42)::FLOAT::UBIGINT +-- +ok +== +SELECT (-42)::DOUBLE::UTINYINT +-- +ok +== +SELECT (-42)::DOUBLE::USMALLINT +-- +ok +== +SELECT (-42)::DOUBLE::UINTEGER +-- +ok +== +SELECT (-42)::DOUBLE::UBIGINT +-- +ok +== +SELECT (200)::UTINYINT::TINYINT +-- +ok +== +SELECT (10)::UTINYINT::TINYINT +-- +ok +== +SELECT (10)::UTINYINT::SMALLINT +-- +ok +== +SELECT (10)::UTINYINT::INTEGER +-- +ok +== +SELECT (10)::UTINYINT::BIGINT +-- +ok +== +SELECT (200)::USMALLINT::TINYINT +-- +ok +== +SELECT (33000)::USMALLINT::SMALLINT +-- +ok +== +SELECT (10)::USMALLINT::TINYINT +-- +ok +== +SELECT (10)::USMALLINT::SMALLINT +-- +ok +== +SELECT (10)::USMALLINT::INTEGER +-- +ok +== +SELECT (10)::USMALLINT::BIGINT +-- +ok +== +SELECT (200)::UINTEGER::TINYINT +-- +ok +== +SELECT (33000)::UINTEGER::SMALLINT +-- +ok +== +SELECT (3147483647)::UINTEGER::INTEGER +-- +ok +== +SELECT (10)::UINTEGER::TINYINT +-- +ok +== +SELECT (10)::UINTEGER::SMALLINT +-- +ok +== +SELECT (10)::UINTEGER::INTEGER +-- +ok +== +SELECT (10)::UINTEGER::BIGINT +-- +ok +== +SELECT (200)::UBIGINT::TINYINT +-- +ok +== +SELECT (33000)::UBIGINT::SMALLINT +-- +ok +== +SELECT (3147483647)::UBIGINT::INTEGER +-- +ok +== +SELECT (10223372036854775807)::UBIGINT::INTEGER +-- +ok +== +SELECT (10)::UBIGINT::TINYINT +-- +ok +== +SELECT (10)::UBIGINT::SMALLINT +-- +ok +== +SELECT (10)::UBIGINT::INTEGER +-- +ok +== +SELECT (10)::UBIGINT::BIGINT +-- +ok +== +SELECT (200.32)::DECIMAL::UTINYINT +-- +ok +== +SELECT (260.32)::DECIMAL::UTINYINT +-- +ok +== +SELECT (200.32)::DECIMAL::USMALLINT +-- +ok +== +SELECT (65535.32)::DECIMAL::USMALLINT +-- +ok +== +SELECT (65536.32)::DECIMAL::USMALLINT +-- +ok +== +SELECT (200.32)::DECIMAL::UINTEGER +-- +ok +== +SELECT (4294967295.32)::DECIMAL::UINTEGER +-- +ok +== +SELECT (4294967296.32)::DECIMAL::UINTEGER +-- +ok +== +SELECT (200.32)::DECIMAL::UBIGINT +-- +ok +== +SELECT (200.32)::REAL::UTINYINT +-- +ok +== +SELECT (260.32)::REAL::UTINYINT +-- +ok +== +SELECT (200.32)::REAL::USMALLINT +-- +ok +== +SELECT (65534.32)::REAL::USMALLINT +-- +ok +== +SELECT (65536.32)::REAL::USMALLINT +-- +ok +== +SELECT (200.32)::REAL::UINTEGER +-- +ok +== +SELECT (4294967296.32)::REAL::UBIGINT +-- +ok +== diff --git a/parser/testdata/corpus/sql/types/unsigned/test_unsigned_verify.test b/parser/testdata/corpus/sql/types/unsigned/test_unsigned_verify.test new file mode 100644 index 0000000..b6bce9b --- /dev/null +++ b/parser/testdata/corpus/sql/types/unsigned/test_unsigned_verify.test @@ -0,0 +1,17 @@ +# source: test/sql/types/unsigned/test_unsigned_verify.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +select []::uint16[] +-- +ok +== +select []::uint32[] +-- +ok +== +select []::uint64[] +-- +ok +== diff --git a/parser/testdata/corpus/sql/types/uuid/test_uuid_cast.test b/parser/testdata/corpus/sql/types/uuid/test_uuid_cast.test new file mode 100644 index 0000000..f85327c --- /dev/null +++ b/parser/testdata/corpus/sql/types/uuid/test_uuid_cast.test @@ -0,0 +1,45 @@ +# source: test/sql/types/uuid/test_uuid_cast.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +select try_cast(try_cast('00112233-4455-6677-8899-aabbccddeeff'::UUID AS BLOB) as uuid) as test; +-- +ok +== +SELECT '00112233-4455-6677-8899-aabbccddeeff'::UUID::BLOB; +-- +ok +== +SELECT '\x00\x11\x223DUfw\x88\x99\xAA\xBB\xCC\xDD\xEE\xFF'::BLOB::UUID; +-- +ok +== +SELECT '00112233-4455-6677-8899-aabbccddeeff'::UUID::BLOB::UUID; +-- +ok +== +SELECT try_cast(try_cast('{00112233-4455-6677-8899-aabbccddeeff}'::UUID AS BLOB) as uuid) as test; +-- +ok +== +SELECT try_cast(try_cast(NULL::UUID AS BLOB) as uuid) as test; +-- +ok +== +SELECT try_cast(NULL::BLOB as uuid) as test; +-- +ok +== +SELECT try_cast('\x00\x11\x22\x33'::BLOB as uuid) as test; +-- +ok +== +SELECT try_cast('\x00\x11\x223DUfw\x88\x99\xAA\xBB\xCC\xDD\xEE\xFF\x00'::BLOB as uuid) as test; +-- +ok +== +SELECT try_cast(''::BLOB as uuid) as test; +-- +ok +== diff --git a/parser/testdata/corpus/sql/types/uuid/test_uuid_uhugeint_cast.test b/parser/testdata/corpus/sql/types/uuid/test_uuid_uhugeint_cast.test new file mode 100644 index 0000000..2bd6438 --- /dev/null +++ b/parser/testdata/corpus/sql/types/uuid/test_uuid_uhugeint_cast.test @@ -0,0 +1,53 @@ +# source: test/sql/types/uuid/test_uuid_uhugeint_cast.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +SELECT '00000000-0000-0000-0000-000000000000'::UUID::UHUGEINT; +-- +ok +== +SELECT 0::UHUGEINT::UUID; +-- +ok +== +SELECT '00112233-4455-6677-8899-aabbccddeeff'::UUID::UHUGEINT::UUID; +-- +ok +== +SELECT 123456789::UHUGEINT::UUID::UHUGEINT; +-- +ok +== +SELECT 340282366920938463463374607431768211455::UHUGEINT::UUID::UHUGEINT; +-- +ok +== +SELECT 'ffffffff-ffff-ffff-ffff-ffffffffffff'::UUID::UHUGEINT; +-- +ok +== +SELECT NULL::UUID::UHUGEINT; +-- +ok +== +SELECT NULL::UHUGEINT::UUID; +-- +ok +== +SELECT try_cast(try_cast('12345678-1234-5678-1234-567812345678'::UUID AS UHUGEINT) as uuid); +-- +ok +== +SELECT '12345678-9abc-def0-1234-56789abcdef0'::UUID::UHUGEINT::UUID; +-- +ok +== +SELECT '00000000-0000-0000-0000-000000000000'::UUID::HUGEINT; +-- +ok +== +SELECT 0::HUGEINT::UUID; +-- +ok +== diff --git a/parser/testdata/corpus/sql/types/variant/implicit_cast_from_variant.test b/parser/testdata/corpus/sql/types/variant/implicit_cast_from_variant.test new file mode 100644 index 0000000..9d764ed --- /dev/null +++ b/parser/testdata/corpus/sql/types/variant/implicit_cast_from_variant.test @@ -0,0 +1,220 @@ +# source: test/sql/types/variant/implicit_cast_from_variant.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +select [100::VARIANT, 1.2] +-- +ok +== +select ['test', 'hello', 'world'][1::VARIANT::INTEGER] +-- +ok +== +select ['test', 'hello', 'world'][1::VARIANT] +-- +ok +== +select ['test', 'hello', 'world'][1::BIGINT::VARIANT] +-- +ok +== +select 'true'::VARIANT::BOOL; +-- +ok +== +select {'a': 'true'}::VARIANT::STRUCT(a BOOLEAN); +-- +ok +== +select {'a': 'lalala'}::VARIANT::STRUCT(a BOOLEAN); +-- +ok +== +select {'b': 42, 'a': 'lalala', 'c': {'a': 'test'}}::VARIANT::STRUCT(a BOOLEAN); +-- +ok +== +select '2019/03/21'::TIMESTAMP::VARIANT::TIMESTAMP; +-- +ok +== +select '0.123456789'::DECIMAL(10,9)::VARIANT::DECIMAL(10,9) +-- +ok +== +select '0.123456789'::DECIMAL(10,9)::VARIANT::DECIMAL(10,8) +-- +ok +== +select 'thisisalongblob\x00withnullbytes'::BLOB::VARIANT::BLOB; +-- +ok +== +select 'thisisalongblob\x00withnullbytes'::BLOB::VARIANT::VARCHAR; +-- +ok +== +select {'a': '[1, 2, 3, 4]'}::VARIANT::STRUCT(a INTEGER[]) +-- +ok +== +select {'a': ['1', '2', '3', '4']}::VARIANT::STRUCT(a INTEGER[]) +-- +ok +== +create table struct_cast_tbl(a STRUCT(a VARCHAR)); +-- +ok +== +insert into struct_cast_tbl select {'a': '[1, 2, 3, 4]'}; +-- +ok +== +insert into struct_cast_tbl select {'a': '[8, 7, 6]'}; +-- +ok +== +insert into struct_cast_tbl select {'a': '[]'}; +-- +ok +== +insert into struct_cast_tbl select {'a': '[10, 6, 4, 8, 9, 10, 12]'}; +-- +ok +== +select a::VARIANT::STRUCT(a INTEGER[]) from struct_cast_tbl; +-- +ok +== +create table struct_cast_tbl2(a STRUCT(a INTEGER[])); +-- +ok +== +insert into struct_cast_tbl2 select {'a': [1, 2, 3, 4]}; +-- +ok +== +insert into struct_cast_tbl2 select {'a': [8, 7, 6]}; +-- +ok +== +insert into struct_cast_tbl2 select {'a': []}; +-- +ok +== +insert into struct_cast_tbl2 select {'a': [10, 6, 4, 8, 9, 10, 12]}; +-- +ok +== +select a::VARIANT::STRUCT(a INTEGER[]) from struct_cast_tbl2; +-- +ok +== +create table struct_cast_tbl3(a STRUCT(a STRUCT(b VARCHAR, c BOOL, a DATE)[])); +-- +ok +== +insert into struct_cast_tbl3 select {'a': [ + { + 'b': 'hello', + 'c': NULL, + 'a': '1970/03/15'::DATE + }, + { + 'b': NULL, + 'c': True, + 'a': '2020/11/03'::DATE + } +]}; +-- +ok +== +insert into struct_cast_tbl3 select {'a': [ +]}; +-- +ok +== +insert into struct_cast_tbl3 select {'a': [ + { + 'b': 'this is a long string', + 'c': False, + 'a': '1953/9/16'::DATE + } +]}; +-- +ok +== +select a::VARIANT::STRUCT(a STRUCT(a VARCHAR, b VARCHAR)[]) from struct_cast_tbl3; +-- +ok +== +select [ + { + 'var': {'a': true, 'b': 42}::VARIANT + }, + NULL, + { + 'var': {'c': false}::VARIANT + } +] +-- +ok +== +select [ + 42::UNION(a INTEGER, b BOOLEAN, c VARCHAR), + true::UNION(a INTEGER, b BOOLEAN, c VARCHAR), + 'test'::UNION(a INTEGER, b BOOLEAN, c VARCHAR), +]::VARIANT +-- +ok +== +select [ + 42::UNION(a INTEGER, b BOOLEAN, c VARCHAR)::VARIANT, + true::UNION(a INTEGER, b BOOLEAN, c VARCHAR)::VARIANT, + 'test'::UNION(a INTEGER, b BOOLEAN, c VARCHAR)::VARIANT, +]::VARIANT +-- +ok +== +select [ + 42::UNION(a INTEGER, b BOOLEAN, c VARCHAR)::VARIANT, + null::UNION(a INTEGER, b BOOLEAN, c VARCHAR)::VARIANT, + 'test'::UNION(a INTEGER, b BOOLEAN, c VARCHAR)::VARIANT, +]::VARIANT +-- +ok +== +with base as ( + from (values + (null), + ('test'), + (null) + ) t(a) +) +select + a::UNION(a INTEGER, b BOOLEAN, c VARCHAR)::VARIANT from base; +-- +ok +== +select [ + 42::UNION(a INTEGER, b BOOLEAN, c VARIANT)::VARIANT, + {'a': 21, 'b': false}::VARIANT::UNION(a INTEGER, b BOOLEAN, c VARIANT)::VARIANT, + {'hello': 'world'}, + 'test'::VARIANT::UNION(a INTEGER, b BOOLEAN, c VARIANT)::VARIANT, +]::VARIANT +-- +ok +== +select v::int from (values ({'a': 42}::variant)) t(v); +-- +ok +== +select v.a.b from (values ({'a': 42}::variant)) t(v); +-- +ok +== +select v['helo'] from (values ({'hello': 42}::variant)) t(v); +-- +ok +== diff --git a/parser/testdata/corpus/sql/types/variant/json_cast.test b/parser/testdata/corpus/sql/types/variant/json_cast.test new file mode 100644 index 0000000..d4d6266 --- /dev/null +++ b/parser/testdata/corpus/sql/types/variant/json_cast.test @@ -0,0 +1,152 @@ +# source: test/sql/types/variant/json_cast.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +select '"test"'::JSON::VARIANT; +-- +ok +== +select ['"test"'::JSON for _ in range(10)]::JSON::VARIANT; +-- +ok +== +select '{"hello": [1,2,true, false, null], "test": [1, {"test": false}, ["blob", "this is a long string", 123]]}'::JSON::VARIANT; +-- +ok +== +WITH src(j) AS ( + VALUES ('{"n":123456789012345678901234567890}'::JSON) +) +SELECT + (j::VARIANT).n as value, variant_typeof(value) as variant_type +FROM src; +-- +ok +== +SELECT (v).a, variant_keys(v), v::JSON +FROM (SELECT '{"a":1,"a":2}'::JSON::VARIANT AS v); +-- +ok +== +SELECT (v.outer).a, variant_keys(v, 'outer'), v::JSON +FROM (SELECT '{"outer":{"a":1,"b":2,"a":3}}'::JSON::VARIANT AS v); +-- +ok +== +SELECT (v).a, variant_keys(v), v::JSON +FROM ( + VALUES + ('{"a":null,"a":[1,2]}'::JSON::VARIANT), + ('{"a":[1,2],"a":null}'::JSON::VARIANT) +) t(v); +-- +ok +== +SELECT (v).a, variant_keys(v) +FROM ( + SELECT j::VARIANT AS v + FROM (VALUES ('{"a":1,"a":2}'::JSON), ('{"a":3,"b":4,"a":5}'::JSON)) t(j) +); +-- +ok +== +select '"test"'::JSON::VARIANT::JSON; +-- +ok +== +select ['"test"' for _ in range(10)]::JSON::VARIANT::JSON; +-- +ok +== +select '{"hello": [1,2,true, false, null], "test": [1, {"test": false}, ["blob", "this is a long string", 123]]}'::JSON::VARIANT::JSON; +-- +ok +== +select '{"hello": [1,2,true, false, null], "test": [1, {"test": false}, ["blob", "this is a long string", 123]]}'::JSON::VARIANT::JSON from range(10); +-- +ok +== +SELECT 0.5::DECIMAL(1,1)::VARIANT::JSON, (-0.5::DECIMAL(1,1))::VARIANT::JSON; +-- +ok +== +SELECT 0.5::DECIMAL(4,4)::VARIANT::JSON, + 0.5::DECIMAL(9,9)::VARIANT::JSON, + 0.5::DECIMAL(18,18)::VARIANT::JSON, + 0.5::DECIMAL(38,38)::VARIANT::JSON; +-- +ok +== +SELECT [0.5::DECIMAL(1,1), -0.5::DECIMAL(1,1)]::VARIANT::JSON; +-- +ok +== +SELECT {'positive': 0.5::DECIMAL(1,1), 'negative': -0.5::DECIMAL(1,1)}::VARIANT::JSON; +-- +ok +== +SELECT json_valid(0.5::DECIMAL(1,1)::VARIANT::JSON), + json_valid([0.5::DECIMAL(1,1)]::VARIANT::JSON), + json_valid({'value': -0.5::DECIMAL(1,1)}::VARIANT::JSON); +-- +ok +== +create table tbl(var JSON); +-- +ok +== +insert into tbl select '{"test":123,"hello":[1,2,3],"world":{"test":true}}'; +-- +ok +== +insert into tbl select '{"test":123,"hello":[4,5,6],"world":{"test":true}}'; +-- +ok +== +insert into tbl select '{"test":123,"hello":[],"world":{"test":true}}'; +-- +ok +== +select var::VARIANT from tbl; +-- +ok +== +select var::VARIANT::JSON from tbl; +-- +ok +== +with base as ( + from (VALUES + ( + 'NULL' + ), + ( + '{"b": [1,2,true, "hello"], "a": NULL}' + ), + ( + 'true' + ) + ) t(a) +) +select a::VARIANT from base; +-- +ok +== +with base as ( + from (VALUES + ( + 'null' + ), + ( + '{"b": [1,2,true, "hello"], "a": null}' + ), + ( + 'true' + ) + ) t(a) +) +select {'var': a::JSON}::VARIANT from base; +-- +ok +== diff --git a/parser/testdata/corpus/sql/types/variant/test_all_types.test b/parser/testdata/corpus/sql/types/variant/test_all_types.test new file mode 100644 index 0000000..7311bef --- /dev/null +++ b/parser/testdata/corpus/sql/types/variant/test_all_types.test @@ -0,0 +1,21 @@ +# source: test/sql/types/variant/test_all_types.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +select struct_pack(*COLUMNS(*))::VARIANT::JSON from test_all_types(); +-- +ok +== +select {'var': COLUMNS(*)::VARIANT}::VARIANT from test_all_types(); +-- +ok +== +select [COLUMNS(['tinyint', 'double'])::VARIANT, NULL, COLUMNS(['tinyint', 'double'])::VARIANT] from test_all_types(); +-- +ok +== +select [COLUMNS(['tinyint', 'double'])::JSON, NULL, COLUMNS(['tinyint', 'double'])::JSON] from test_all_types(); +-- +ok +== diff --git a/parser/testdata/corpus/sql/types/variant/tpch_test.test b/parser/testdata/corpus/sql/types/variant/tpch_test.test new file mode 100644 index 0000000..1300bc1 --- /dev/null +++ b/parser/testdata/corpus/sql/types/variant/tpch_test.test @@ -0,0 +1,21 @@ +# source: test/sql/types/variant/tpch_test.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +attach '{TEST_DIR}/tpch_sf0001_variant.db' as foo (STORAGE_VERSION 'v1.5.0'); +-- +ok +== +create table foo.variant_lineitem as select variant_normalize(STRUCT_PACK(*COLUMNS(*))::VARIANT) from lineitem; +-- +ok +== +select * from foo.variant_lineitem limit 10; +-- +ok +== +select COLUMNS(*)::JSON from foo.variant_lineitem limit 10; +-- +ok +== diff --git a/parser/testdata/corpus/sql/types/variant/tpch_test_through_json.test b/parser/testdata/corpus/sql/types/variant/tpch_test_through_json.test new file mode 100644 index 0000000..889e11d --- /dev/null +++ b/parser/testdata/corpus/sql/types/variant/tpch_test_through_json.test @@ -0,0 +1,13 @@ +# source: test/sql/types/variant/tpch_test_through_json.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +select lineitem::json from lineitem limit 2; +-- +ok +== +select lineitem::json::variant::JSON from lineitem limit 2; +-- +ok +== diff --git a/parser/testdata/corpus/sql/types/variant/try_cast_from_variant.test b/parser/testdata/corpus/sql/types/variant/try_cast_from_variant.test new file mode 100644 index 0000000..80c8710 --- /dev/null +++ b/parser/testdata/corpus/sql/types/variant/try_cast_from_variant.test @@ -0,0 +1,81 @@ +# source: test/sql/types/variant/try_cast_from_variant.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +select try_cast('hello world'::variant as int) + 1; +-- +ok +== +select try_cast('hello world'::variant as STRUCT(a varchar, b boolean)); +-- +ok +== +select try_cast({'a': true, 'b': 'foo'}::variant as STRUCT(a varchar, b boolean)); +-- +ok +== +select try_cast({'c': true, 'd': 'foo'}::variant as STRUCT(a varchar, b boolean)); +-- +ok +== +select try_cast('hello world'::variant as INTEGER[]); +-- +ok +== +with cte as ( + from ( values + ('test'::VARIANT), + (null::VARIANT), + (42::VARIANT) + ) t(a) +) +select try_cast(a as INT) from cte; +-- +ok +== +with cte as ( + from ( values + ('test'::VARIANT), + (null::VARIANT), + (42::VARIANT) + ) t(a) +) +select try_cast(a as STRUCT(a varchar, b boolean)) from cte; +-- +ok +== +with cte as ( + from ( values + ('test'::VARIANT), + (null::VARIANT), + (42::VARIANT) + ) t(a) +) +select try_cast(a as BOOLEAN[]) from cte; +-- +ok +== +with cte as ( + from ( values + ('test'::VARIANT), + (null::VARIANT), + (42::VARIANT) + ) t(a) +) +select try_cast(a as UNION(a integer, b decimal)) from cte; +-- +ok +== +select try_cast(json('["1","x"]')::VARIANT as INTEGER[]); +-- +ok +== +select try_cast(json('["1","x"]')::VARIANT as INTEGER[2]); +-- +ok +== +select cast(json('["1","x"]')::VARIANT as INTEGER[2]); +-- +ok +== diff --git a/parser/testdata/corpus/sql/types/variant/variant_cast_stats.test b/parser/testdata/corpus/sql/types/variant/variant_cast_stats.test new file mode 100644 index 0000000..60b443d --- /dev/null +++ b/parser/testdata/corpus/sql/types/variant/variant_cast_stats.test @@ -0,0 +1,91 @@ +# source: test/sql/types/variant/variant_cast_stats.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +CREATE TABLE t AS SELECT range n FROM range(10); +-- +ok +== +SELECT s.shredding_state, s.fully_shredded.type, s.fully_shredded.stats.min, s.fully_shredded.stats.max, + s.fully_shredded.stats.has_null +FROM (SELECT stats(n::VARIANT) s FROM t LIMIT 1); +-- +ok +== +CREATE TABLE s AS SELECT 'val_' || range AS v FROM range(10); +-- +ok +== +SELECT s.shredding_state, s.fully_shredded.type, s.fully_shredded.stats.min, s.fully_shredded.stats.max, + s.fully_shredded.stats.has_null +FROM (SELECT stats(v::VARIANT) s FROM s LIMIT 1); +-- +ok +== +CREATE TABLE nn AS SELECT CASE WHEN range % 2 = 0 THEN range END AS c FROM range(10); +-- +ok +== +SELECT s.shredding_state, s.fully_shredded.type, s.has_null, s.fully_shredded.stats.has_null +FROM (SELECT stats(c::VARIANT) s FROM nn LIMIT 1); +-- +ok +== +SELECT s.shredding_state, s.fully_shredded.type, s.has_null, s.fully_shredded.stats.has_null +FROM (SELECT stats(TRY_CAST(n AS VARIANT)) s FROM t LIMIT 1); +-- +ok +== +CREATE TABLE obj AS SELECT {'a': range, 'b': 'x' || range} AS o, [range, range + 100] AS l FROM range(50); +-- +ok +== +SELECT s.shredding_state, s.fully_shredded.a.type, s.fully_shredded.b.type +FROM (SELECT stats(o::VARIANT) s FROM obj LIMIT 1); +-- +ok +== +SELECT s.fully_shredded.type, s.fully_shredded.stats.min, s.fully_shredded.stats.max +FROM (SELECT stats((o::VARIANT).a) s FROM obj LIMIT 1); +-- +ok +== +SELECT s.fully_shredded.type, s.fully_shredded.stats.min, s.fully_shredded.stats.max +FROM (SELECT stats((o::VARIANT).b) s FROM obj LIMIT 1); +-- +ok +== +SELECT s.fully_shredded.type, s.fully_shredded.stats.min, s.fully_shredded.stats.max +FROM (SELECT stats((l::VARIANT)[1]) s FROM obj LIMIT 1); +-- +ok +== +SELECT s.shredding_state FROM (SELECT stats(MAP {'k': n}::VARIANT) s FROM t LIMIT 1); +-- +ok +== +CREATE TABLE big AS SELECT range m FROM range(100); +-- +ok +== +SELECT count(*) FROM big WHERE m::VARIANT = 50::BIGINT::VARIANT; +-- +ok +== +SELECT count(*) FROM big WHERE m::VARIANT = 5000::BIGINT::VARIANT; +-- +ok +== +SELECT count(*) FROM big WHERE m::VARIANT > 90::BIGINT::VARIANT; +-- +ok +== +SELECT count(*) FROM obj WHERE (o::VARIANT).a::BIGINT = 9999; +-- +ok +== +SELECT count(*) FROM obj WHERE (o::VARIANT).a::BIGINT = 25; +-- +ok +== diff --git a/parser/testdata/corpus/sql/types/variant/variant_casts.test b/parser/testdata/corpus/sql/types/variant/variant_casts.test new file mode 100644 index 0000000..f6e1677 --- /dev/null +++ b/parser/testdata/corpus/sql/types/variant/variant_casts.test @@ -0,0 +1,29 @@ +# source: test/sql/types/variant/variant_casts.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +CREATE TABLE struct AS SELECT {'a': 42, 'b': 84} s +-- +ok +== +select variant 'a' +-- +ok +== +select s::VARIANT FROM struct +-- +ok +== +select (s::VARIANT).a FROM struct +-- +ok +== +select (s::VARIANT).a::BIGINT FROM struct +-- +ok +== +select [1, 2, 3, 4]::VARIANT +-- +ok +== diff --git a/parser/testdata/corpus/sql/types/variant/variant_distinct.test b/parser/testdata/corpus/sql/types/variant/variant_distinct.test new file mode 100644 index 0000000..ab1c39a --- /dev/null +++ b/parser/testdata/corpus/sql/types/variant/variant_distinct.test @@ -0,0 +1,466 @@ +# source: test/sql/types/variant/variant_distinct.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +SELECT [1]::VARIANT IS NOT DISTINCT FROM [2] +-- +ok +== +SELECT [1]::VARIANT IS NOT DISTINCT FROM [1] +-- +ok +== +SELECT NULL IS NOT DISTINCT FROM [1]::VARIANT +-- +ok +== +SELECT [1] IS NOT DISTINCT FROM NULL::VARIANT +-- +ok +== +SELECT [1]::VARIANT IS DISTINCT FROM [2] +-- +ok +== +SELECT [1]::VARIANT IS DISTINCT FROM [1] +-- +ok +== +SELECT NULL::VARIANT IS DISTINCT FROM [1] +-- +ok +== +SELECT [1]::VARIANT IS DISTINCT FROM NULL +-- +ok +== +CREATE VIEW list_int1 AS SELECT COLUMNS(*)::VARIANT FROM (VALUES + ([1], [1]), + ([1], [2]), + ([2], [1]), + (NULL, [1]), + ([2], NULL), + (NULL, NULL) + ) tbl(l, r); +-- +ok +== +SELECT [1]::VARIANT IS NOT DISTINCT FROM [1, 2] +-- +ok +== +SELECT NULL::VARIANT IS NOT DISTINCT FROM [1] +-- +ok +== +SELECT [1]::VARIANT IS DISTINCT FROM [1, 2] +-- +ok +== +SELECT [1] IS DISTINCT FROM NULL::VARIANT +-- +ok +== +CREATE VIEW list_int AS SELECT COLUMNS(*)::VARIANT FROM (VALUES + ([1], [1]), + ([1], [1, 2]), + ([1, 2], [1]), + (NULL, [1]), + ([1, 2], NULL), + (NULL, NULL) + ) tbl(l, r); +-- +ok +== +SELECT []::VARIANT IS NOT DISTINCT FROM [1, 2] +-- +ok +== +SELECT []::VARIANT IS NOT DISTINCT FROM [] +-- +ok +== +SELECT NULL::VARIANT IS NOT DISTINCT FROM [] +-- +ok +== +SELECT []::VARIANT IS NOT DISTINCT FROM NULL +-- +ok +== +SELECT []::VARIANT IS DISTINCT FROM [1, 2] +-- +ok +== +SELECT []::VARIANT IS DISTINCT FROM [] +-- +ok +== +SELECT NULL::VARIANT IS DISTINCT FROM [] +-- +ok +== +SELECT []::VARIANT IS DISTINCT FROM NULL +-- +ok +== +CREATE VIEW list_int_empty AS SELECT COLUMNS(*)::VARIANT FROM (VALUES + ([], []), + ([], [1, 2]), + ([1, 2], []), + (NULL, []), + ([1, 2], NULL), + (NULL, NULL) + ) tbl(l, r); +-- +ok +== +SELECT ['duck']::VARIANT IS NOT DISTINCT FROM ['duck', 'goose'] +-- +ok +== +SELECT ['duck']::VARIANT IS NOT DISTINCT FROM ['duck'] +-- +ok +== +SELECT NULL::VARIANT IS NOT DISTINCT FROM ['duck'] +-- +ok +== +SELECT ['duck']::VARIANT IS NOT DISTINCT FROM NULL +-- +ok +== +SELECT ['duck']::VARIANT IS DISTINCT FROM ['duck', 'goose'] +-- +ok +== +SELECT ['duck']::VARIANT IS DISTINCT FROM ['duck'] +-- +ok +== +SELECT NULL::VARIANT IS DISTINCT FROM ['duck'] +-- +ok +== +SELECT ['duck']::VARIANT IS DISTINCT FROM NULL +-- +ok +== +CREATE VIEW list_str AS SELECT COLUMNS(*)::VARIANT FROM (VALUES + (['duck'], ['duck']), + (['duck'], ['duck', 'goose']), + (['duck', 'goose'], ['duck']), + (NULL, ['duck']), + (['duck', 'goose'], NULL), + (NULL, NULL) + ) tbl(l, r); +-- +ok +== +SELECT [{'x': 'duck', 'y': 1}]::VARIANT IS NOT DISTINCT FROM [{'x': 'duck', 'y': 1}, {'x': 'goose', 'y': 2}] +-- +ok +== +SELECT [{'x': 'duck', 'y': 1}]::VARIANT IS NOT DISTINCT FROM [{'x': 'duck', 'y': 1}] +-- +ok +== +SELECT NULL::VARIANT IS NOT DISTINCT FROM [{'x': 'duck', 'y': 1}] +-- +ok +== +SELECT [{'x': 'duck', 'y': 1}]::VARIANT IS NOT DISTINCT FROM NULL +-- +ok +== +SELECT [{'x': 'duck', 'y': 1}]::VARIANT IS DISTINCT FROM [{'x': 'duck', 'y': 1}, {'x': 'goose', 'y': 2}] +-- +ok +== +SELECT [{'x': 'duck', 'y': 1}]::VARIANT IS DISTINCT FROM [{'x': 'duck', 'y': 1}] +-- +ok +== +SELECT NULL::VARIANT IS DISTINCT FROM [{'x': 'duck', 'y': 1}] +-- +ok +== +SELECT [{'x': 'duck', 'y': 1}]::VARIANT IS DISTINCT FROM NULL +-- +ok +== +CREATE VIEW list_of_struct AS SELECT COLUMNS(*)::VARIANT FROM (VALUES + ([{'x': 'duck', 'y': 1}], [{'x': 'duck', 'y': 1}]), + ([{'x': 'duck', 'y': 1}], [{'x': 'duck', 'y': 1}, {'x': 'goose', 'y': 2}]), + ([{'x': 'duck', 'y': 1}, {'x': 'goose', 'y': 2}], [{'x': 'duck', 'y': 1}]), + (NULL, [{'x': 'duck', 'y': 1}]), + ([{'x': 'duck', 'y': 1}, {'x': 'goose', 'y': 2}], NULL), + (NULL, NULL) + ) tbl(l, r); +-- +ok +== +select CASE WHEN a::INT32::VARIANT < 4 THEN [a,a+1,a+2] ELSE NULL END IS NOT DISTINCT FROM [1::INT32,2,3] from range(5) tbl(a); +-- +ok +== +select CASE WHEN a::INT32::VARIANT < 4 THEN [a,a+1,a+2] ELSE NULL END IS DISTINCT FROM [1::INT32,2,3] from range(5) tbl(a); +-- +ok +== +SELECT {'x': 1::{type}}::VARIANT IS NOT DISTINCT FROM {'x': 2::{type}} +-- +error: Parser Error: syntax error at or near "{" +== +SELECT {'x': 1::{type}}::VARIANT IS NOT DISTINCT FROM {'x': 1::{type}} +-- +error: Parser Error: syntax error at or near "{" +== +SELECT NULL::VARIANT IS NOT DISTINCT FROM {'x': 1::{type}} +-- +error: Parser Error: syntax error at or near "{" +== +SELECT {'x': 1::{type}}::VARIANT IS DISTINCT FROM {'x': 2::{type}} +-- +error: Parser Error: syntax error at or near "{" +== +SELECT {'x': 1::{type}}::VARIANT IS DISTINCT FROM {'x': 1::{type}} +-- +error: Parser Error: syntax error at or near "{" +== +SELECT {'x': 1::{type}}::VARIANT IS DISTINCT FROM NULL +-- +error: Parser Error: syntax error at or near "{" +== +CREATE OR REPLACE VIEW struct_int AS SELECT COLUMNS(*)::VARIANT FROM (VALUES + ({'x': 1::{type}}, {'x': 1::{type}}), + ({'x': 1::{type}}, {'x': 2::{type}}), + ({'x': 2::{type}}, {'x': 1::{type}}), + (NULL, {'x': 1::{type}}), + ({'x': 2::{type}}, NULL), + (NULL, NULL) + ) tbl(l, r); +-- +error: Parser Error: syntax error at or near "{" +== +SELECT {'x': 'duck'}::VARIANT IS NOT DISTINCT FROM {'x': 'goose'} +-- +ok +== +SELECT {'x': 'duck'}::VARIANT IS NOT DISTINCT FROM {'x': 'duck'} +-- +ok +== +SELECT {'x': 'duck'}::VARIANT IS NOT DISTINCT FROM NULL +-- +ok +== +SELECT NULL::VARIANT IS NOT DISTINCT FROM {'x': 'duck'} +-- +ok +== +SELECT {'x': 'duck'}::VARIANT IS DISTINCT FROM {'x': 'goose'} +-- +ok +== +SELECT {'x': 'duck'}::VARIANT IS DISTINCT FROM {'x': 'duck'} +-- +ok +== +SELECT {'x': 'duck'}::VARIANT IS DISTINCT FROM NULL +-- +ok +== +SELECT NULL::VARIANT IS DISTINCT FROM {'x': 'duck'} +-- +ok +== +CREATE VIEW struct_str AS SELECT COLUMNS(*)::VARIANT FROM (VALUES + ({'x': 'duck'}, {'x': 'duck'}), + ({'x': 'duck'}, {'x': 'goose'}), + ({'x': 'goose'}, {'x': 'duck'}), + (NULL, {'x': 'duck'}), + ({'x': 'goose'}, NULL), + (NULL, NULL) + ) tbl(l, r); +-- +ok +== +SELECT {'x': 'duck', 'y': 1}::VARIANT IS NOT DISTINCT FROM {'x': 'goose', 'y': 2} +-- +ok +== +SELECT {'x': 'duck', 'y': 1}::VARIANT IS NOT DISTINCT FROM {'x': 'duck', 'y': 1} +-- +ok +== +SELECT NULL::VARIANT IS NOT DISTINCT FROM {'x': 'duck', 'y': 1} +-- +ok +== +SELECT {'x': 'duck', 'y': 1}::VARIANT IS NOT DISTINCT FROM NULL +-- +ok +== +SELECT {'x': 'duck', 'y': 1}::VARIANT IS DISTINCT FROM {'x': 'goose', 'y': 2} +-- +ok +== +SELECT {'x': 'duck', 'y': 1}::VARIANT IS DISTINCT FROM {'x': 'duck', 'y': 1} +-- +ok +== +SELECT NULL::VARIANT IS DISTINCT FROM {'x': 'duck', 'y': 1} +-- +ok +== +SELECT {'x': 'duck', 'y': 1}::VARIANT IS DISTINCT FROM NULL +-- +ok +== +CREATE VIEW struct_str_int AS SELECT COLUMNS(*)::VARIANT FROM (VALUES + ({'x': 'duck', 'y': 1}, {'x': 'duck', 'y': 1}), + ({'x': 'duck', 'y': 1}, {'x': 'goose', 'y': 2}), + ({'x': 'goose', 'y': 2}, {'x': 'duck', 'y': 1}), + (NULL, {'x': 'duck', 'y': 1}), + ({'x': 'goose', 'y': 2}, NULL), + (NULL, NULL) + ) tbl(l, r); +-- +ok +== +SELECT {'x': 1, 'y': {'a': 'duck', 'b': 1.5}}::VARIANT IS NOT DISTINCT FROM {'x': 2, 'y': {'a': 'goose', 'b': 2.5}} +-- +ok +== +SELECT {'x': 1, 'y': {'a': 'duck', 'b': 1.5}}::VARIANT IS NOT DISTINCT FROM {'x': 1, 'y': {'a': 'duck', 'b': 1.5}} +-- +ok +== +SELECT NULL::VARIANT IS NOT DISTINCT FROM {'x': 1, 'y': {'a': 'duck', 'b': 1.5}} +-- +ok +== +SELECT {'x': 1, 'y': {'a': 'duck', 'b': 1.5}}::VARIANT IS NOT DISTINCT FROM NULL +-- +ok +== +SELECT {'x': 1, 'y': {'a': 'duck', 'b': 1.5}}::VARIANT IS DISTINCT FROM {'x': 2, 'y': {'a': 'goose', 'b': 2.5}} +-- +ok +== +SELECT {'x': 1, 'y': {'a': 'duck', 'b': 1.5}}::VARIANT IS DISTINCT FROM {'x': 1, 'y': {'a': 'duck', 'b': 1.5}} +-- +ok +== +SELECT NULL::VARIANT IS DISTINCT FROM {'x': 1, 'y': {'a': 'duck', 'b': 1.5}} +-- +ok +== +SELECT {'x': 1, 'y': {'a': 'duck', 'b': 1.5}} IS DISTINCT FROM NULL::VARIANT +-- +ok +== +CREATE VIEW struct_nested AS SELECT COLUMNS(*)::VARIANT FROM (VALUES + ({'x': 1, 'y': {'a': 'duck', 'b': 1.5}}, {'x': 1, 'y': {'a': 'duck', 'b': 1.5}}), + ({'x': 1, 'y': {'a': 'duck', 'b': 1.5}}, {'x': 2, 'y': {'a': 'goose', 'b': 2.5}}), + ({'x': 2, 'y': {'a': 'goose', 'b': 2.5}}, {'x': 1, 'y': {'a': 'duck', 'b': 1.5}}), + (NULL, {'x': 1, 'y': {'a': 'duck', 'b': 1.5}}), + ({'x': 2, 'y': {'a': 'goose', 'b': 2.5}}, NULL), + (NULL, NULL) + ) tbl(l, r); +-- +ok +== +SELECT {'x': 1, 'y': ['duck', 'somateria']}::VARIANT IS NOT DISTINCT FROM {'x': 2, 'y': ['goose']} +-- +ok +== +SELECT {'x': 1, 'y': ['duck', 'somateria']}::VARIANT IS NOT DISTINCT FROM {'x': 1, 'y': ['duck', 'somateria']} +-- +ok +== +SELECT NULL::VARIANT IS NOT DISTINCT FROM {'x': 1, 'y': ['duck', 'somateria']} +-- +ok +== +SELECT {'x': 1, 'y': ['duck', 'somateria']}::VARIANT IS NOT DISTINCT FROM NULL +-- +ok +== +SELECT {'x': 1, 'y': ['duck', 'somateria']}::VARIANT IS DISTINCT FROM {'x': 2, 'y': ['goose']} +-- +ok +== +SELECT {'x': 1, 'y': ['duck', 'somateria']}::VARIANT IS DISTINCT FROM {'x': 1, 'y': ['duck', 'somateria']} +-- +ok +== +SELECT NULL::VARIANT IS DISTINCT FROM {'x': 1, 'y': ['duck', 'somateria']} +-- +ok +== +SELECT {'x': 1, 'y': ['duck', 'somateria']}::VARIANT IS DISTINCT FROM NULL +-- +ok +== +CREATE VIEW list_in_struct AS SELECT COLUMNS(*)::VARIANT FROM (VALUES + ({'x': 1, 'y': ['duck', 'somateria']}, {'x': 1, 'y': ['duck', 'somateria']}), + ({'x': 1, 'y': ['duck', 'somateria']}, {'x': 2, 'y': ['goose']}), + ({'x': 2, 'y': ['goose']}, {'x': 1, 'y': ['duck', 'somateria']}), + (NULL, {'x': 1, 'y': ['duck', 'somateria']}), + ({'x': 2, 'y': ['goose']}, NULL), + (NULL, NULL) + ) tbl(l, r); +-- +ok +== +WITH cte as ( + select a::INT32 a from range(5) tbl(a) +) +select + CASE + WHEN a::VARIANT < 4 + THEN { + 'x': a, + 'y': a+1, + 'z': a+2 + }::VARIANT + ELSE NULL + END IS NOT DISTINCT FROM { + 'x': 1::INT32, + 'y': 2::INT32, + 'z': 3::INT32 + } +from cte; +-- +ok +== +WITH cte as ( + select a::INT32 a from range(5) tbl(a) +) +select CASE WHEN a < 4 THEN {'x': a, 'z': a+2, 'y': a+1}::VARIANT ELSE NULL END IS DISTINCT FROM {'x': 1, 'y': 2, 'z': 3} +from cte; +-- +ok +== +WITH cte as ( + select a::INT32 a from range(5) tbl(a) +) +select CASE WHEN a < 4 THEN ({ + 'nested': { + 'x': a, + 'z': a+2, + 'y': a+1 + } +}::VARIANT)['nested'] ELSE NULL END IS DISTINCT FROM { + 'x': 1, + 'y': 2, + 'z': 3 +} +from cte; +-- +ok +== diff --git a/parser/testdata/corpus/sql/types/variant/variant_map_to_variant_filter.test b/parser/testdata/corpus/sql/types/variant/variant_map_to_variant_filter.test new file mode 100644 index 0000000..13fb30a --- /dev/null +++ b/parser/testdata/corpus/sql/types/variant/variant_map_to_variant_filter.test @@ -0,0 +1,21 @@ +# source: test/sql/types/variant/variant_map_to_variant_filter.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +CREATE TABLE t AS SELECT i, MAP{'k': i::VARIANT} AS m FROM range(2) t(i); +-- +ok +== +SELECT m::VARIANT FROM t WHERE i = 1; +-- +ok +== +CREATE TABLE big AS SELECT i, MAP{'k': i::VARIANT} AS m FROM range(3000) t(i); +-- +ok +== +SELECT i, m::VARIANT FROM big WHERE i IN (1, 2, 2050) ORDER BY i; +-- +ok +== diff --git a/parser/testdata/corpus/sql/update/compact_update_allocation.test b/parser/testdata/corpus/sql/update/compact_update_allocation.test new file mode 100644 index 0000000..c8e55e9 --- /dev/null +++ b/parser/testdata/corpus/sql/update/compact_update_allocation.test @@ -0,0 +1,270 @@ +# source: test/sql/update/compact_update_allocation.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +CREATE TABLE mem_test (a INTEGER, b INTEGER, c INTEGER, d VARCHAR) +-- +ok +== +INSERT INTO mem_test SELECT i, i%500, i%200, 'val_' || (i%100)::VARCHAR FROM range(500000) t(i) +-- +ok +== +CREATE TABLE mem_before AS SELECT memory_usage_bytes FROM duckdb_memory() WHERE tag = 'TRANSACTION' +-- +ok +== +UPDATE mem_test SET a = a + 1 WHERE a % 2048 = 0 +-- +ok +== +CREATE TABLE mem_after AS SELECT memory_usage_bytes FROM duckdb_memory() WHERE tag = 'TRANSACTION' +-- +ok +== +SELECT CASE WHEN (a.memory_usage_bytes - b.memory_usage_bytes) < 1500000 + THEN 'ok' + ELSE error(concat('expected < 1.5MB increase, got ', + (a.memory_usage_bytes - b.memory_usage_bytes), ' bytes')) + END +FROM mem_after a, mem_before b +-- +ok +== +DROP TABLE mem_before +-- +ok +== +DROP TABLE mem_after +-- +ok +== +CREATE TABLE single_update (i INTEGER NOT NULL, v VARCHAR) +-- +ok +== +INSERT INTO single_update SELECT range, 'hello' FROM range(10000) +-- +ok +== +UPDATE single_update SET v = 'updated' WHERE i = 5000 +-- +ok +== +SELECT i, v FROM single_update WHERE i = 5000 +-- +ok +== +SELECT count(*) FROM single_update WHERE v = 'hello' +-- +ok +== +UPDATE single_update SET v = 'second' WHERE i = 5001 +-- +ok +== +UPDATE single_update SET v = 'third' WHERE i = 5002 +-- +ok +== +UPDATE single_update SET v = 'fourth' WHERE i = 5003 +-- +ok +== +UPDATE single_update SET v = 'fifth' WHERE i = 5004 +-- +ok +== +UPDATE single_update SET v = 'sixth' WHERE i = 5005 +-- +ok +== +UPDATE single_update SET v = 'seventh' WHERE i = 5006 +-- +ok +== +UPDATE single_update SET v = 'eighth' WHERE i = 5007 +-- +ok +== +UPDATE single_update SET v = 'ninth' WHERE i = 5008 +-- +ok +== +SELECT count(*) FROM single_update WHERE v NOT IN ('hello') +-- +ok +== +SELECT i, v FROM single_update WHERE i BETWEEN 5000 AND 5008 ORDER BY i +-- +ok +== +CREATE TABLE full_vector_update (i INTEGER NOT NULL) +-- +ok +== +INSERT INTO full_vector_update SELECT range FROM range(4096) +-- +ok +== +UPDATE full_vector_update SET i = i + 10000 WHERE i < 2048 +-- +ok +== +SELECT MIN(i) FROM full_vector_update +-- +ok +== +SELECT MAX(i) FROM full_vector_update WHERE i >= 10000 +-- +ok +== +SELECT count(*) FROM full_vector_update WHERE i >= 10000 +-- +ok +== +CREATE TABLE checkpoint_test (a INTEGER, b VARCHAR) +-- +ok +== +INSERT INTO checkpoint_test SELECT range, 'original' FROM range(10000) +-- +ok +== +UPDATE checkpoint_test SET b = 'modified' WHERE a % 1000 = 0 +-- +ok +== +SELECT count(*) FROM checkpoint_test WHERE b = 'modified' +-- +ok +== +SELECT count(*) FROM checkpoint_test WHERE b = 'original' +-- +ok +== +CREATE TABLE rollback_test (i INTEGER NOT NULL) +-- +ok +== +INSERT INTO rollback_test SELECT range FROM range(5000) +-- +ok +== +UPDATE rollback_test SET i = i + 99999 WHERE i = 2500 +-- +ok +== +SELECT i FROM rollback_test WHERE i > 99000 +-- +ok +== +SELECT i FROM rollback_test WHERE i = 2500 +-- +ok +== +SELECT count(*) FROM rollback_test WHERE i > 99000 +-- +ok +== +CREATE TABLE concurrent_test (i INTEGER NOT NULL) +-- +ok +== +INSERT INTO concurrent_test SELECT range FROM range(5000) +-- +ok +== +UPDATE concurrent_test SET i = i + 100000 WHERE i = 1000 +-- +ok +== +SELECT i FROM concurrent_test WHERE i > 99000 +-- +ok +== +CREATE TABLE scatter_test (a BIGINT NOT NULL, b DOUBLE, c VARCHAR) +-- +ok +== +INSERT INTO scatter_test SELECT range, range * 1.5, 'str_' || range::VARCHAR FROM range(100000) +-- +ok +== +UPDATE scatter_test SET b = -1.0, c = 'UPDATED' WHERE a % 2048 = 1024 +-- +ok +== +SELECT count(*) FROM scatter_test WHERE c = 'UPDATED' +-- +ok +== +SELECT count(*) FROM scatter_test WHERE b = -1.0 +-- +ok +== +SELECT count(*) FROM scatter_test WHERE b != -1.0 AND b = a * 1.5 +-- +ok +== +CREATE TABLE null_test (i INTEGER) +-- +ok +== +INSERT INTO null_test SELECT range FROM range(5000) +-- +ok +== +UPDATE null_test SET i = NULL WHERE i % 500 = 0 +-- +ok +== +SELECT count(*) FROM null_test WHERE i IS NULL +-- +ok +== +UPDATE null_test SET i = -1 WHERE i IS NULL +-- +ok +== +SELECT count(*) FROM null_test WHERE i = -1 +-- +ok +== +CREATE TABLE types_test ( + ti TINYINT, + si SMALLINT, + bi BIGINT, + f FLOAT, + d DOUBLE, + v VARCHAR, + bl BOOLEAN +) +-- +ok +== +INSERT INTO types_test +SELECT (range % 127)::TINYINT, + (range % 32000)::SMALLINT, + range::BIGINT, + range::FLOAT, + range::DOUBLE, + range::VARCHAR, + (range % 2 = 0) +FROM range(5000) +-- +ok +== +UPDATE types_test SET ti = -1, si = -1, bi = -1, f = -1.0, d = -1.0, v = 'X', bl = true WHERE bi = 2500 +-- +ok +== +SELECT ti, si, bi, f, d, v, bl FROM types_test WHERE bi = -1 +-- +ok +== +SELECT count(*) FROM types_test WHERE bi >= 0 +-- +ok +== diff --git a/parser/testdata/corpus/sql/update/force_update_to_del_and_insert.test b/parser/testdata/corpus/sql/update/force_update_to_del_and_insert.test new file mode 100644 index 0000000..94a6c32 --- /dev/null +++ b/parser/testdata/corpus/sql/update/force_update_to_del_and_insert.test @@ -0,0 +1,37 @@ +# source: test/sql/update/force_update_to_del_and_insert.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +SELECT current_setting('force_update_to_del_and_insert') +-- +ok +== +CREATE TABLE t(i INTEGER, j INTEGER, k INTEGER); +-- +ok +== +INSERT INTO t VALUES (1, 10, 100), (2, 20, 200), (3, 30, 300); +-- +ok +== +SET force_update_to_del_and_insert=true; +-- +ok +== +UPDATE t SET j=j+1 WHERE i>1; +-- +ok +== +SELECT * FROM t ORDER BY i +-- +ok +== +RESET force_update_to_del_and_insert; +-- +ok +== +UPDATE t SET k=k+1; +-- +ok +== diff --git a/parser/testdata/corpus/sql/update/issue_22392.test b/parser/testdata/corpus/sql/update/issue_22392.test new file mode 100644 index 0000000..65c96b8 --- /dev/null +++ b/parser/testdata/corpus/sql/update/issue_22392.test @@ -0,0 +1,25 @@ +# source: test/sql/update/issue_22392.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +CREATE TABLE t (k INTEGER PRIMARY KEY, v INTEGER); +-- +ok +== +INSERT INTO t VALUES (0, 0), (1, NULL); +-- +ok +== +UPDATE t SET v = 99 WHERE k = 1; +-- +ok +== +SELECT k, v FROM t WHERE k IN (0); +-- +ok +== +SELECT k, v FROM t WHERE k IN (1); +-- +ok +== diff --git a/parser/testdata/corpus/sql/update/null_update_merge.test b/parser/testdata/corpus/sql/update/null_update_merge.test new file mode 100644 index 0000000..e66e219 --- /dev/null +++ b/parser/testdata/corpus/sql/update/null_update_merge.test @@ -0,0 +1,53 @@ +# source: test/sql/update/null_update_merge.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +CREATE TABLE test (id INTEGER, a INTEGER); +-- +ok +== +INSERT INTO test VALUES (1, 1), (2, 2), (3, 3), (4, NULL); +-- +ok +== +SELECT * FROM test ORDER BY id; +-- +ok +== +UPDATE test SET a=CASE WHEN id=1 THEN 7 ELSE NULL END WHERE id <= 2 +-- +ok +== +UPDATE test SET a=17 WHERE id > 2 +-- +ok +== +UPDATE test SET a=CASE WHEN id=4 THEN 1 ELSE NULL END +-- +ok +== +UPDATE test SET a=2 WHERE id >= 2 AND id <= 3 +-- +ok +== +UPDATE test SET a=NULL WHERE id >= 3 +-- +ok +== +UPDATE test SET a=id WHERE id != 3 +-- +ok +== +UPDATE test SET a=NULL WHERE id != 3 +-- +ok +== +UPDATE test SET a=3 WHERE id != 2 +-- +ok +== +UPDATE test SET a=7 WHERE id != 3 +-- +ok +== diff --git a/parser/testdata/corpus/sql/update/null_update_merge_transaction.test b/parser/testdata/corpus/sql/update/null_update_merge_transaction.test new file mode 100644 index 0000000..f87eb14 --- /dev/null +++ b/parser/testdata/corpus/sql/update/null_update_merge_transaction.test @@ -0,0 +1,9 @@ +# source: test/sql/update/null_update_merge_transaction.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +UPDATE test SET a=CASE WHEN a IS NULL THEN 1 ELSE NULL END +-- +ok +== diff --git a/parser/testdata/corpus/sql/update/string_update_null_heap.test b/parser/testdata/corpus/sql/update/string_update_null_heap.test new file mode 100644 index 0000000..849e690 --- /dev/null +++ b/parser/testdata/corpus/sql/update/string_update_null_heap.test @@ -0,0 +1,17 @@ +# source: test/sql/update/string_update_null_heap.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +CREATE TABLE test (id INTEGER, s VARCHAR); +-- +ok +== +INSERT INTO test VALUES (1, 'a'), (2, 'b'); +-- +ok +== +UPDATE test SET s=CASE WHEN id=1 THEN NULL ELSE 'cccccccccccccccccccc' END; +-- +ok +== diff --git a/parser/testdata/corpus/sql/update/string_update_transaction_local_7348.test b/parser/testdata/corpus/sql/update/string_update_transaction_local_7348.test new file mode 100644 index 0000000..9573b01 --- /dev/null +++ b/parser/testdata/corpus/sql/update/string_update_transaction_local_7348.test @@ -0,0 +1,29 @@ +# source: test/sql/update/string_update_transaction_local_7348.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +CREATE TABLE t1(a VARCHAR(256) PRIMARY KEY, b INTEGER); +-- +ok +== +INSERT INTO t1 VALUES(' 4-abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ', 2 + 1); +-- +ok +== +INSERT INTO t1 VALUES(' 34-abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ', 18); +-- +ok +== +INSERT INTO t1 SELECT b, b + 1 FROM t1 WHERE b < 5; +-- +ok +== +FROM t1 +-- +ok +== +UPDATE t1 SET a = CONCAT(a, 'x') WHERE b % 2 = 0; +-- +ok +== diff --git a/parser/testdata/corpus/sql/update/test_big_string_update.test b/parser/testdata/corpus/sql/update/test_big_string_update.test new file mode 100644 index 0000000..62e0f80 --- /dev/null +++ b/parser/testdata/corpus/sql/update/test_big_string_update.test @@ -0,0 +1,21 @@ +# source: test/sql/update/test_big_string_update.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +INSERT INTO test VALUES ('abcdefghijklmnopqrstuvwxyz') +-- +ok +== +INSERT INTO test SELECT a||a||a||a||a||a||a||a||a||a FROM test +-- +ok +== +DELETE FROM test WHERE length(a) = (SELECT MIN(length(a)) FROM test) +-- +ok +== +UPDATE test SET a='a' +-- +ok +== diff --git a/parser/testdata/corpus/sql/update/test_cascading_updates.test b/parser/testdata/corpus/sql/update/test_cascading_updates.test new file mode 100644 index 0000000..8e345e6 --- /dev/null +++ b/parser/testdata/corpus/sql/update/test_cascading_updates.test @@ -0,0 +1,33 @@ +# source: test/sql/update/test_cascading_updates.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +CREATE TABLE integers(id INTEGER, val INTEGER); +-- +ok +== +INSERT INTO integers SELECT i, i FROM range(10000) t(i) +-- +ok +== +PRAGMA checkpoint_threshold='1GB' +-- +ok +== +UPDATE integers SET val=val+1000000 WHERE id=1 +-- +ok +== +UPDATE integers SET val=val+1000000 WHERE id=2 +-- +ok +== +UPDATE integers SET val=val+1000000 WHERE id=3 +-- +ok +== +SELECT COUNT(*) FROM integers WHERE val>1000000 +-- +ok +== diff --git a/parser/testdata/corpus/sql/update/test_multiple_assignment.test b/parser/testdata/corpus/sql/update/test_multiple_assignment.test new file mode 100644 index 0000000..3f5c72a --- /dev/null +++ b/parser/testdata/corpus/sql/update/test_multiple_assignment.test @@ -0,0 +1,45 @@ +# source: test/sql/update/test_multiple_assignment.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +CREATE TABLE tbl (key INT, fruit VARCHAR, cost INT); +-- +ok +== +INSERT INTO tbl VALUES (1, 'apple', 2), (2, 'orange', 3); +-- +ok +== +UPDATE tbl SET (key, fruit, cost) = (1, 'pear', 2); +-- +ok +== +UPDATE tbl SET (key, fruit, cost) = (2, 'apple', 3); +-- +ok +== +UPDATE tbl SET (key, fruit, cost) = 3; +-- +ok +== +UPDATE tbl SET (key, fruit, cost) = (1, 2); +-- +error: Parser Error: Could not perform assignment, expected 3 values, got 2 +== +UPDATE tbl SET (key, fruit, cost) = (1, 2, 3, 4); +-- +error: Parser Error: Could not perform assignment, expected 3 values, got 4 +== +UPDATE tbl SET (key, fruit, cost) = ADD(key, cost); +-- +ok +== +UPDATE tbl SET () = (key, fruit); +-- +error: Parser Error: syntax error at or near ")" +== +UPDATE tbl SET (key, fruit) = (); +-- +error: Parser Error: Could not perform assignment, expected 2 values, got 0 +== diff --git a/parser/testdata/corpus/sql/update/test_multiple_assignment.test.metadata.json b/parser/testdata/corpus/sql/update/test_multiple_assignment.test.metadata.json new file mode 100644 index 0000000..a951546 --- /dev/null +++ b/parser/testdata/corpus/sql/update/test_multiple_assignment.test.metadata.json @@ -0,0 +1,7 @@ +{ + "todo": { + "1af980d640a6e1d3": "transformer-raised parser error: upstream rejects in the transformer, not the grammar; expected to clear as transformers land (milestones 3-5)", + "308b68804dd4a67f": "transformer-raised parser error: upstream rejects in the transformer, not the grammar; expected to clear as transformers land (milestones 3-5)", + "c417249dc9b098ac": "transformer-raised parser error: upstream rejects in the transformer, not the grammar; expected to clear as transformers land (milestones 3-5)" + } +} diff --git a/parser/testdata/corpus/sql/update/test_null_update.test b/parser/testdata/corpus/sql/update/test_null_update.test new file mode 100644 index 0000000..beac068 --- /dev/null +++ b/parser/testdata/corpus/sql/update/test_null_update.test @@ -0,0 +1,21 @@ +# source: test/sql/update/test_null_update.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +INSERT INTO test VALUES (1), (2), (3), (NULL) +-- +ok +== +UPDATE test SET a=NULL WHERE a=2 +-- +ok +== +UPDATE test SET a=NULL WHERE a=3 +-- +ok +== +UPDATE test SET a=10 WHERE a IS NULL +-- +ok +== diff --git a/parser/testdata/corpus/sql/update/test_repeated_string_update.test b/parser/testdata/corpus/sql/update/test_repeated_string_update.test new file mode 100644 index 0000000..327c121 --- /dev/null +++ b/parser/testdata/corpus/sql/update/test_repeated_string_update.test @@ -0,0 +1,17 @@ +# source: test/sql/update/test_repeated_string_update.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +INSERT INTO test VALUES ('hello'), ('world') +-- +ok +== +UPDATE test SET a='test' WHERE a='hello'; +-- +ok +== +UPDATE test SET a='test2' WHERE a='world'; +-- +ok +== diff --git a/parser/testdata/corpus/sql/update/test_stress_update_issue_19688.test b/parser/testdata/corpus/sql/update/test_stress_update_issue_19688.test new file mode 100644 index 0000000..d24c2f1 --- /dev/null +++ b/parser/testdata/corpus/sql/update/test_stress_update_issue_19688.test @@ -0,0 +1,40 @@ +# source: test/sql/update/test_stress_update_issue_19688.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +DROP TABLE IF EXISTS test_stress_update_issue_19688 +-- +ok +== +CREATE TABLE test_stress_update_issue_19688 ( + id INTEGER, + val INTEGER +) +-- +ok +== +INSERT INTO test_stress_update_issue_19688 SELECT range AS id, range * 1000 AS val FROM range(100) +-- +ok +== +SELECT COUNT(*) FROM test_stress_update_issue_19688 +-- +ok +== +UPDATE test_stress_update_issue_19688 SET val = ({threadid} * 10000 + {i}) WHERE id = {i} +-- +error: Parser Error: syntax error at or near "}" +== +DELETE FROM test_stress_update_issue_19688 WHERE id = {i} +-- +error: Parser Error: syntax error at or near "}" +== +INSERT INTO test_stress_update_issue_19688 VALUES ({i}, {threadid} * 10000 + {i}) +-- +error: Parser Error: syntax error at or near "}" +== +SELECT COUNT(DISTINCT id) FROM test_stress_update_issue_19688 +-- +ok +== diff --git a/parser/testdata/corpus/sql/update/test_string_update.test b/parser/testdata/corpus/sql/update/test_string_update.test new file mode 100644 index 0000000..b8ac27b --- /dev/null +++ b/parser/testdata/corpus/sql/update/test_string_update.test @@ -0,0 +1,13 @@ +# source: test/sql/update/test_string_update.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +DELETE FROM test WHERE a='hello'; +-- +ok +== +UPDATE test SET a='hello'; +-- +ok +== diff --git a/parser/testdata/corpus/sql/update/test_string_update_many_strings.test b/parser/testdata/corpus/sql/update/test_string_update_many_strings.test new file mode 100644 index 0000000..a3ff0f2 --- /dev/null +++ b/parser/testdata/corpus/sql/update/test_string_update_many_strings.test @@ -0,0 +1,17 @@ +# source: test/sql/update/test_string_update_many_strings.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +INSERT INTO test VALUES ('a'), ('b'), ('c'), (NULL) +-- +ok +== +INSERT INTO test SELECT * FROM test +-- +ok +== +UPDATE test SET a='aa' WHERE a='a'; +-- +ok +== diff --git a/parser/testdata/corpus/sql/update/test_string_update_null.test b/parser/testdata/corpus/sql/update/test_string_update_null.test new file mode 100644 index 0000000..204f797 --- /dev/null +++ b/parser/testdata/corpus/sql/update/test_string_update_null.test @@ -0,0 +1,9 @@ +# source: test/sql/update/test_string_update_null.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +UPDATE test SET a=NULL where a='world'; +-- +ok +== diff --git a/parser/testdata/corpus/sql/update/test_string_update_rollback.test b/parser/testdata/corpus/sql/update/test_string_update_rollback.test new file mode 100644 index 0000000..d76b8ee --- /dev/null +++ b/parser/testdata/corpus/sql/update/test_string_update_rollback.test @@ -0,0 +1,9 @@ +# source: test/sql/update/test_string_update_rollback.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +UPDATE test SET a='test2' WHERE a='test'; +-- +ok +== diff --git a/parser/testdata/corpus/sql/update/test_string_update_rollback_null.test b/parser/testdata/corpus/sql/update/test_string_update_rollback_null.test new file mode 100644 index 0000000..5fe369a --- /dev/null +++ b/parser/testdata/corpus/sql/update/test_string_update_rollback_null.test @@ -0,0 +1,17 @@ +# source: test/sql/update/test_string_update_rollback_null.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +INSERT INTO test VALUES ('test'), ('world') +-- +ok +== +UPDATE test SET a=NULL WHERE a='world'; +-- +ok +== +UPDATE test SET a='world' WHERE a IS NULL; +-- +ok +== diff --git a/parser/testdata/corpus/sql/update/test_update.test b/parser/testdata/corpus/sql/update/test_update.test new file mode 100644 index 0000000..a638b17 --- /dev/null +++ b/parser/testdata/corpus/sql/update/test_update.test @@ -0,0 +1,21 @@ +# source: test/sql/update/test_update.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +SELECT * FROM test WHERE a=3 +-- +ok +== +UPDATE test SET a=1 +-- +ok +== +SELECT * FROM test WHERE a=1 +-- +ok +== +UPDATE test SET a=4 +-- +ok +== diff --git a/parser/testdata/corpus/sql/update/test_update_delete_same_tuple.test b/parser/testdata/corpus/sql/update/test_update_delete_same_tuple.test new file mode 100644 index 0000000..826606a --- /dev/null +++ b/parser/testdata/corpus/sql/update/test_update_delete_same_tuple.test @@ -0,0 +1,17 @@ +# source: test/sql/update/test_update_delete_same_tuple.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +INSERT INTO test VALUES (1), (2), (3); +-- +ok +== +UPDATE test SET a=a+1; +-- +ok +== +DELETE FROM test +-- +ok +== diff --git a/parser/testdata/corpus/sql/update/test_update_from.test b/parser/testdata/corpus/sql/update/test_update_from.test new file mode 100644 index 0000000..6c1384a --- /dev/null +++ b/parser/testdata/corpus/sql/update/test_update_from.test @@ -0,0 +1,113 @@ +# source: test/sql/update/test_update_from.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +CREATE TABLE src (a INTEGER); +-- +ok +== +INSERT INTO src VALUES (2) +-- +ok +== +SELECT * FROM src +-- +ok +== +UPDATE test SET a=test.a+s.a FROM src s +-- +ok +== +UPDATE test SET a=test.a+t.a FROM test t +-- +ok +== +UPDATE test SET a=t.a+s.a FROM test t, src s +-- +ok +== +UPDATE test SET a=s.q FROM (SELECT a+1 as q FROM src) s +-- +ok +== +CREATE VIEW vt AS (SELECT 17 as v) +-- +ok +== +UPDATE test SET a=v FROM vt +-- +ok +== +UPDATE test SET a=s.a FROM src s WHERE s.a = 2 +-- +ok +== +UPDATE test t SET a=1 FROM src s WHERE s.a = t.a +-- +ok +== +UPDATE test t SET a=9 FROM src s WHERE s.a=t.a +-- +ok +== +INSERT INTO src VALUES (7) +-- +ok +== +UPDATE test SET a=s.a FROM src s +-- +ok +== +SELECT count(*) FROM test +-- +ok +== +SELECT a IN (2, 7) FROM test +-- +ok +== +CREATE TABLE terms(docid INTEGER, term INTEGER); +-- +ok +== +CREATE TABLE docs(id INTEGER, len INTEGER); +-- +ok +== +insert into docs values (1, 0), (2, 0); +-- +ok +== +insert into terms values (1, 1); +-- +ok +== +insert into terms values (2, 1); +-- +ok +== +insert into terms values (2, 2); +-- +ok +== +insert into terms values (2, 3); +-- +ok +== +UPDATE docs +SET len = sq.len +FROM ( + SELECT docid AS id, count(term) AS len + FROM terms + GROUP BY docid + ORDER BY docid +) AS sq +WHERE docs.id = sq.id; +-- +ok +== +select * from docs; +-- +ok +== diff --git a/parser/testdata/corpus/sql/update/test_update_issue_3170.test b/parser/testdata/corpus/sql/update/test_update_issue_3170.test new file mode 100644 index 0000000..75c6840 --- /dev/null +++ b/parser/testdata/corpus/sql/update/test_update_issue_3170.test @@ -0,0 +1,61 @@ +# source: test/sql/update/test_update_issue_3170.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +CREATE TABLE student(id INTEGER, name VARCHAR, PRIMARY KEY(id)); +-- +ok +== +INSERT INTO student SELECT i, 'creator' FROM RANGE(260001) tbl(i) +-- +ok +== +SELECT name FROM student WHERE id = 122879 +-- +ok +== +SELECT name FROM student WHERE id = 122881 +-- +ok +== +SELECT name FROM student WHERE id = 245780 +-- +ok +== +SELECT name FROM student WHERE id = 150881 +-- +ok +== +UPDATE student SET name = 'updator0' WHERE id = 122879 +-- +ok +== +UPDATE student SET name = 'updator1' WHERE id = 122881 +-- +ok +== +UPDATE student SET name = 'updator2' WHERE id = 245780 +-- +ok +== +UPDATE student SET name = 'updator3' WHERE id = 150881 +-- +ok +== +insert into student select i, 'creator' from range(130001) tbl(i); +-- +ok +== +select id, name from student where id=122881; +-- +ok +== +UPDATE student SET name = 'updator' WHERE id = 122881; +-- +ok +== +SELECT id, name FROM student WHERE id = 122881; +-- +ok +== diff --git a/parser/testdata/corpus/sql/update/test_update_many_updaters.test b/parser/testdata/corpus/sql/update/test_update_many_updaters.test new file mode 100644 index 0000000..809efc6 --- /dev/null +++ b/parser/testdata/corpus/sql/update/test_update_many_updaters.test @@ -0,0 +1,45 @@ +# source: test/sql/update/test_update_many_updaters.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +UPDATE test SET a=4 WHERE a=1 +-- +ok +== +UPDATE test SET a=5 WHERE a=2 +-- +ok +== +UPDATE test SET a=6 WHERE a=3 +-- +ok +== +UPDATE test SET a=99 WHERE a=1 +-- +ok +== +UPDATE test SET a=99 WHERE a=2 +-- +ok +== +UPDATE test SET a=99 WHERE a=3 +-- +ok +== +UPDATE test SET a=a-3 +-- +ok +== +UPDATE test SET a=7 WHERE a=4 +-- +ok +== +UPDATE test SET a=8 WHERE a=5 +-- +ok +== +UPDATE test SET a=9 WHERE a=6 +-- +ok +== diff --git a/parser/testdata/corpus/sql/update/test_update_many_updaters_nulls.test b/parser/testdata/corpus/sql/update/test_update_many_updaters_nulls.test new file mode 100644 index 0000000..787b4f6 --- /dev/null +++ b/parser/testdata/corpus/sql/update/test_update_many_updaters_nulls.test @@ -0,0 +1,17 @@ +# source: test/sql/update/test_update_many_updaters_nulls.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +UPDATE test SET a=NULL WHERE a=1 +-- +ok +== +SELECT COUNT(*) FROM test WHERE a IS NULL +-- +ok +== +UPDATE test SET a=99 WHERE a IS NULL +-- +ok +== diff --git a/parser/testdata/corpus/sql/update/test_update_mix.test b/parser/testdata/corpus/sql/update/test_update_mix.test new file mode 100644 index 0000000..a5917d3 --- /dev/null +++ b/parser/testdata/corpus/sql/update/test_update_mix.test @@ -0,0 +1,13 @@ +# source: test/sql/update/test_update_mix.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +INSERT INTO test VALUES (4), (5), (6); +-- +ok +== +DELETE FROM test WHERE a < 4 +-- +ok +== diff --git a/parser/testdata/corpus/sql/update/test_update_same_value.test b/parser/testdata/corpus/sql/update/test_update_same_value.test new file mode 100644 index 0000000..5f58703 --- /dev/null +++ b/parser/testdata/corpus/sql/update/test_update_same_value.test @@ -0,0 +1,25 @@ +# source: test/sql/update/test_update_same_value.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +SELECT * FROM test WHERE a=4 +-- +ok +== +SELECT * FROM test WHERE a=5 +-- +ok +== +UPDATE test SET a=9 WHERE a=5 +-- +ok +== +UPDATE test SET a=7 WHERE a=3 +-- +ok +== +UPDATE test SET a=8 WHERE a=4 +-- +ok +== diff --git a/parser/testdata/corpus/sql/update/test_update_with_non_regular_type.test b/parser/testdata/corpus/sql/update/test_update_with_non_regular_type.test new file mode 100644 index 0000000..8d8c0bb --- /dev/null +++ b/parser/testdata/corpus/sql/update/test_update_with_non_regular_type.test @@ -0,0 +1,45 @@ +# source: test/sql/update/test_update_with_non_regular_type.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +CREATE TABLE t1 (id VARCHAR, new_id VARCHAR, tags VARCHAR[], g GEOMETRY); +-- +ok +== +INSERT INTO t1 VALUES ('A', 'B', ARRAY['tag1', 'tag2'], 'POINT(1 2)'); +-- +ok +== +UPDATE t1 SET new_id = 'C' WHERE id='A'; +-- +ok +== +UPDATE t1 SET tags = ['tag3'] WHERE id='A'; +-- +ok +== +UPDATE t1 SET g = 'POINT(3 4)' WHERE id='A'; +-- +ok +== +CREATE TABLE t2 (id INT, val VARCHAR, tags VARCHAR[], g GEOMETRY); +-- +ok +== +INSERT INTO t2 VALUES (1, 'A', ARRAY['tag1', 'tag2'], 'POINT (5 6)'); +-- +ok +== +UPDATE t2 SET val = t1.new_id FROM t1 WHERE t2.val=t1.id; +-- +ok +== +UPDATE t2 SET tags = ['tag3'] FROM t1 WHERE t2.val=t1.new_id; +-- +ok +== +UPDATE t2 SET g = 'POINT(0 0)' FROM t1 WHERE t2.val=t1.new_id; +-- +ok +== diff --git a/parser/testdata/corpus/sql/update/update_after_commit.test b/parser/testdata/corpus/sql/update/update_after_commit.test new file mode 100644 index 0000000..6643931 --- /dev/null +++ b/parser/testdata/corpus/sql/update/update_after_commit.test @@ -0,0 +1,17 @@ +# source: test/sql/update/update_after_commit.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +CREATE TABLE a (b int); +-- +ok +== +INSERT INTO a VALUES (1); +-- +ok +== +UPDATE a SET b = b + 10; +-- +ok +== diff --git a/parser/testdata/corpus/sql/update/update_default.test b/parser/testdata/corpus/sql/update/update_default.test new file mode 100644 index 0000000..5c6b083 --- /dev/null +++ b/parser/testdata/corpus/sql/update/update_default.test @@ -0,0 +1,9 @@ +# source: test/sql/update/update_default.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +UPDATE t1 SET c0 = DEFAULT; +-- +ok +== diff --git a/parser/testdata/corpus/sql/update/update_delete_wal.test b/parser/testdata/corpus/sql/update/update_delete_wal.test new file mode 100644 index 0000000..abaa85d --- /dev/null +++ b/parser/testdata/corpus/sql/update/update_delete_wal.test @@ -0,0 +1,29 @@ +# source: test/sql/update/update_delete_wal.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +create table test (id bigint primary key, c1 text); +-- +ok +== +insert into test (id, c1) values (1, 'foo'); +-- +ok +== +insert into test (id, c1) values (2, 'bar'); +-- +ok +== +delete from test where id = 1; +-- +ok +== +update test set c1='baz' where id=2; +-- +ok +== +SELECT * FROM test ORDER BY id +-- +ok +== diff --git a/parser/testdata/corpus/sql/update/update_error_suggestions.test b/parser/testdata/corpus/sql/update/update_error_suggestions.test new file mode 100644 index 0000000..88a7808 --- /dev/null +++ b/parser/testdata/corpus/sql/update/update_error_suggestions.test @@ -0,0 +1,17 @@ +# source: test/sql/update/update_error_suggestions.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +CREATE TABLE tbl(mycol INTEGER) +-- +ok +== +UPDATE tbl SET myco=42 +-- +ok +== +UPDATE tbl SET tbl.mycol=42 +-- +error: Parser Error: Qualified column names in UPDATE .. SET not supported +== diff --git a/parser/testdata/corpus/sql/update/update_error_suggestions.test.metadata.json b/parser/testdata/corpus/sql/update/update_error_suggestions.test.metadata.json new file mode 100644 index 0000000..f4739cc --- /dev/null +++ b/parser/testdata/corpus/sql/update/update_error_suggestions.test.metadata.json @@ -0,0 +1,5 @@ +{ + "todo": { + "b5c9ca3822ec9e87": "transformer-raised parser error: upstream rejects in the transformer, not the grammar; expected to clear as transformers land (milestones 3-5)" + } +} diff --git a/parser/testdata/corpus/sql/update/update_from_multi_match.test b/parser/testdata/corpus/sql/update/update_from_multi_match.test new file mode 100644 index 0000000..b65552c --- /dev/null +++ b/parser/testdata/corpus/sql/update/update_from_multi_match.test @@ -0,0 +1,249 @@ +# source: test/sql/update/update_from_multi_match.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +INSERT INTO t VALUES (1, 0); +-- +ok +== +CREATE TABLE s (id INTEGER, v INTEGER); +-- +ok +== +INSERT INTO s VALUES (1, 10), (1, 20), (1, 30); +-- +ok +== +UPDATE t SET v = s.v FROM s WHERE t.id = s.id; +-- +ok +== +SELECT v IN (10, 20, 30) FROM t; +-- +ok +== +CREATE TABLE t2 (id INTEGER, v INTEGER); +-- +ok +== +INSERT INTO t2 SELECT i, -1 FROM range(1, 2000) tbl(i); +-- +ok +== +CREATE TABLE s2 (id INTEGER, v INTEGER); +-- +ok +== +INSERT INTO s2 SELECT i, i * 10 FROM range(1, 2000) tbl(i); +-- +ok +== +INSERT INTO s2 SELECT i, i * 100 FROM range(1, 2000) tbl(i); +-- +ok +== +UPDATE t2 SET v = s2.v FROM s2 WHERE t2.id = s2.id; +-- +ok +== +SELECT count(*) FROM t2; +-- +ok +== +SELECT count(*) FROM t2 WHERE v = id * 10 OR v = id * 100; +-- +ok +== +SELECT count(*) FROM t2 WHERE v = -1; +-- +ok +== +CREATE TABLE t3 (id INTEGER, v INTEGER); +-- +ok +== +INSERT INTO t3 VALUES (1, 0), (2, 0); +-- +ok +== +CREATE TABLE s3 (id INTEGER, v INTEGER); +-- +ok +== +INSERT INTO s3 VALUES (1, 11), (1, 12), (2, 21), (2, 22); +-- +ok +== +UPDATE t3 SET v = s3.v FROM s3 WHERE t3.id = s3.id RETURNING id; +-- +ok +== +CREATE TABLE tcnt (id INTEGER, v INTEGER); +-- +ok +== +INSERT INTO tcnt VALUES (1, 0); +-- +ok +== +CREATE TABLE scnt (id INTEGER, v INTEGER); +-- +ok +== +INSERT INTO scnt VALUES (1, 10), (1, 20), (1, 30); +-- +ok +== +UPDATE tcnt SET v = scnt.v FROM scnt WHERE tcnt.id = scnt.id; +-- +ok +== +CREATE TABLE tcnt2 (id INTEGER, v INTEGER); +-- +ok +== +INSERT INTO tcnt2 VALUES (1, 0), (2, 0); +-- +ok +== +CREATE TABLE scnt2 (id INTEGER, v INTEGER); +-- +ok +== +INSERT INTO scnt2 VALUES (1, 11), (1, 12), (2, 21), (2, 22); +-- +ok +== +UPDATE tcnt2 SET v = scnt2.v FROM scnt2 WHERE tcnt2.id = scnt2.id; +-- +ok +== +UPDATE tcnt2 SET v = v + 1; +-- +ok +== +CREATE TABLE t_self (id INTEGER, v INTEGER); +-- +ok +== +INSERT INTO t_self VALUES (1, 5), (1, 6), (2, 7); +-- +ok +== +UPDATE t_self SET v = o.v FROM t_self o WHERE t_self.id = o.id; +-- +ok +== +SELECT count(*) FROM t_self; +-- +ok +== +CREATE TABLE t5 (id INTEGER, v INTEGER); +-- +ok +== +INSERT INTO t5 SELECT i, -1 FROM range(1, 2000) tbl(i); +-- +ok +== +CREATE TABLE s5 (id INTEGER, v INTEGER); +-- +ok +== +INSERT INTO s5 SELECT i, i * 10 FROM range(1, 2000) tbl(i); +-- +ok +== +INSERT INTO s5 SELECT i, i * 100 FROM range(1, 2000) tbl(i); +-- +ok +== +UPDATE t5 SET v = s5.v FROM s5 WHERE t5.id = s5.id; +-- +ok +== +SELECT count(*) FROM t5; +-- +ok +== +SELECT count(*) FROM t5 WHERE v = id * 10 OR v = id * 100; +-- +ok +== +CREATE TABLE t6 (id INTEGER, v INTEGER); +-- +ok +== +INSERT INTO t6 VALUES (1, 100); +-- +ok +== +CREATE TABLE s6 (id INTEGER, v INTEGER); +-- +ok +== +INSERT INTO s6 VALUES (2, 1), (3, 2); +-- +ok +== +UPDATE t6 SET v = s6.v FROM s6 WHERE t6.id = s6.id; +-- +ok +== +SELECT v FROM t6; +-- +ok +== +CREATE TABLE t4 (id INTEGER, v INTEGER[]); +-- +ok +== +INSERT INTO t4 VALUES (1, [0]); +-- +ok +== +CREATE TABLE s4 (id INTEGER, v INTEGER[]); +-- +ok +== +INSERT INTO s4 VALUES (1, [10]), (1, [20]); +-- +ok +== +UPDATE t4 SET v = s4.v FROM s4 WHERE t4.id = s4.id; +-- +ok +== +SELECT count(*) FROM t4; +-- +ok +== +SELECT len(v) FROM t4; +-- +ok +== +CREATE TABLE target_pk (id INTEGER PRIMARY KEY, value INTEGER); +-- +ok +== +INSERT INTO target_pk VALUES (1, 0), (2, 0); +-- +ok +== +CREATE TABLE source_dup (id INTEGER, value INTEGER); +-- +ok +== +INSERT INTO source_dup VALUES (1, 10), (1, 11), (2, 20), (2, 21); +-- +ok +== +UPDATE target_pk SET value = source_dup.value FROM source_dup WHERE target_pk.id = source_dup.id RETURNING id; +-- +ok +== +SELECT count(*) FROM target_pk WHERE (id = 1 AND value IN (10, 11)) OR (id = 2 AND value IN (20, 21)); +-- +ok +== diff --git a/parser/testdata/corpus/sql/update/update_join_nulls.test b/parser/testdata/corpus/sql/update/update_join_nulls.test new file mode 100644 index 0000000..7611373 --- /dev/null +++ b/parser/testdata/corpus/sql/update/update_join_nulls.test @@ -0,0 +1,20 @@ +# source: test/sql/update/update_join_nulls.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +CREATE TABLE t(table_id BIGINT, val BOOLEAN); +-- +ok +== +WITH new_values(tid, new_val) AS ( + VALUES (1, NULL) +) +UPDATE t +SET val=new_val +FROM new_values +WHERE table_id=tid +; +-- +ok +== diff --git a/parser/testdata/corpus/sql/update/update_null_integers.test b/parser/testdata/corpus/sql/update/update_null_integers.test new file mode 100644 index 0000000..a1930ae --- /dev/null +++ b/parser/testdata/corpus/sql/update/update_null_integers.test @@ -0,0 +1,21 @@ +# source: test/sql/update/update_null_integers.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +CREATE TABLE t(i int, j int); +-- +ok +== +INSERT INTO t SELECT ii, NULL FROM range(1024) tbl(ii); +-- +ok +== +select COUNT(j), MIN(j), MAX(j) from t; +-- +ok +== +UPDATE t SET j = 1; +-- +ok +== diff --git a/parser/testdata/corpus/sql/update/update_query_node.test b/parser/testdata/corpus/sql/update/update_query_node.test new file mode 100644 index 0000000..411d0c6 --- /dev/null +++ b/parser/testdata/corpus/sql/update/update_query_node.test @@ -0,0 +1,50 @@ +# source: test/sql/update/update_query_node.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +UPDATE t SET a = 10 WHERE a = 1; +-- +ok +== +UPDATE t SET a = 0, b = 'changed' WHERE a = 2; +-- +ok +== +UPDATE t SET a = a + 1 WHERE a = 0 RETURNING a, b, c; +-- +ok +== +CREATE TABLE src(id INT, val TEXT); +-- +ok +== +INSERT INTO src VALUES (3, 'updated'); +-- +ok +== +UPDATE t SET b = src.val FROM src WHERE t.a = src.id; +-- +ok +== +WITH new_vals AS (SELECT 100 AS new_a, 3 AS old_a) +UPDATE t SET a = new_vals.new_a FROM new_vals WHERE t.a = new_vals.old_a RETURNING a; +-- +ok +== +INSERT INTO myschema.t2 VALUES (1), (2); +-- +ok +== +UPDATE myschema.t2 SET x = x * 10; +-- +ok +== +UPDATE t SET c = 0.0; +-- +ok +== +SELECT DISTINCT c FROM t; +-- +ok +== diff --git a/parser/testdata/corpus/sql/update/update_string_null_merge_dict_fsst.test b/parser/testdata/corpus/sql/update/update_string_null_merge_dict_fsst.test new file mode 100644 index 0000000..2ced80f --- /dev/null +++ b/parser/testdata/corpus/sql/update/update_string_null_merge_dict_fsst.test @@ -0,0 +1,25 @@ +# source: test/sql/update/update_string_null_merge_dict_fsst.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +create table t as select case when i = 0 or i = 2 then NULL else 'value_' || (i % 50) end s from range(5000) t(i) +-- +ok +== +update t set s='seedseedseed' where rowid = 1 +-- +ok +== +update t set s='merge_value' where rowid = 0 +-- +ok +== +select s from t where rowid < 3 order by rowid +-- +ok +== +select count(*), count(s) from t +-- +ok +== diff --git a/parser/testdata/corpus/sql/upsert/concurrent_insert_or_replace.test b/parser/testdata/corpus/sql/upsert/concurrent_insert_or_replace.test new file mode 100644 index 0000000..7f18ba0 --- /dev/null +++ b/parser/testdata/corpus/sql/upsert/concurrent_insert_or_replace.test @@ -0,0 +1,30 @@ +# source: test/sql/upsert/concurrent_insert_or_replace.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +CREATE SCHEMA IF NOT EXISTS schema__test +-- +ok +== +CREATE OR REPLACE TABLE schema__test.test_table{threadid} ( + id VARCHAR PRIMARY KEY, + available_actions VARCHAR[], + subscriber_ids VARCHAR[] +) +-- +error: Parser Error: syntax error at or near "{" +== +INSERT OR REPLACE INTO schema__test.test_table{threadid} +VALUES ('test:scope/test-worker-{threadid}:test-id-0', ['read', 'write', 'delete'], ['sub-{threadid}', 'sub-{threadid}+{i}']) +-- +error: Parser Error: syntax error at or near "{" +== +SELECT subscriber_ids=['sub-{threadid}', 'sub-{threadid}+{i}'] FROM schema__test.test_table{threadid} WHERE id='test:scope/test-worker-{threadid}:test-id-0' +-- +error: Parser Error: syntax error at or near "{" +== +SELECT subscriber_ids=['sub-{threadid}', 'sub-{threadid}+4'] FROM schema__test.test_table{threadid} WHERE id='test:scope/test-worker-{threadid}:test-id-0' +-- +error: Parser Error: syntax error at or near "{" +== diff --git a/parser/testdata/corpus/sql/upsert/insert_or_replace/issue_20952_non_pk_index_column.test b/parser/testdata/corpus/sql/upsert/insert_or_replace/issue_20952_non_pk_index_column.test new file mode 100644 index 0000000..2546c78 --- /dev/null +++ b/parser/testdata/corpus/sql/upsert/insert_or_replace/issue_20952_non_pk_index_column.test @@ -0,0 +1,107 @@ +# source: test/sql/upsert/insert_or_replace/issue_20952_non_pk_index_column.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +create table t( + id varchar primary key, + state varchar not null, + name varchar not null +); +-- +ok +== +create index idx_state on t(state); +-- +ok +== +insert or replace into t values ('a', 'first', 'jeremy'); +-- +ok +== +insert or replace into t values ('a', 'second', 'tim'); +-- +ok +== +select * from t; +-- +ok +== +insert or replace into t(name, id, state) values ('sam', 'a', 'third'); +-- +ok +== +insert or replace into t(id, state) values ('a', 'fourth'); +-- +ok +== +create table t_offset( + id integer primary key, + dropped_col integer, + state integer not null, + payload integer not null +); +-- +ok +== +insert or replace into t_offset values (1, 111, 10, 20); +-- +ok +== +alter table t_offset drop column dropped_col; +-- +ok +== +create index idx_state_offset on t_offset(state); +-- +ok +== +insert or replace into t_offset values (1, 30, 40); +-- +ok +== +select * from t_offset; +-- +ok +== +insert or replace into t_offset(payload, id, state) values (50, 1, 60); +-- +ok +== +select count(*) from t_offset where state = 10; +-- +ok +== +create table t_comp( + id integer primary key, + a integer, + b integer, + payload varchar +); +-- +ok +== +create index idx_ab on t_comp(a, b); +-- +ok +== +insert or replace into t_comp values (1, 10, 20, 'v1'); +-- +ok +== +insert or replace into t_comp values (1, 11, 21, 'v2'); +-- +ok +== +select * from t_comp; +-- +ok +== +insert or replace into t_comp(id, a) values (1, 12); +-- +ok +== +select count(*) from t_comp where a = 11 and b = 21; +-- +ok +== diff --git a/parser/testdata/corpus/sql/upsert/insert_or_replace/pk_and_non_unique_index.test b/parser/testdata/corpus/sql/upsert/insert_or_replace/pk_and_non_unique_index.test new file mode 100644 index 0000000..78c08d6 --- /dev/null +++ b/parser/testdata/corpus/sql/upsert/insert_or_replace/pk_and_non_unique_index.test @@ -0,0 +1,22 @@ +# source: test/sql/upsert/insert_or_replace/pk_and_non_unique_index.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +create table tbl( + a int, + b int, + c int, + primary key(a,b,c) +); +-- +ok +== +create index non_unique on tbl(b); +-- +ok +== +insert or replace into tbl values (1,2,3); +-- +ok +== diff --git a/parser/testdata/corpus/sql/upsert/insert_or_replace/returning.test b/parser/testdata/corpus/sql/upsert/insert_or_replace/returning.test new file mode 100644 index 0000000..34ada61 --- /dev/null +++ b/parser/testdata/corpus/sql/upsert/insert_or_replace/returning.test @@ -0,0 +1,24 @@ +# source: test/sql/upsert/insert_or_replace/returning.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +create table foo( + bar text primary key, + baz bigint, +); +-- +ok +== +insert or replace into foo(bar, baz) values ('baz', 1) returning bar; +-- +ok +== +insert or replace into foo(bar, baz) values ('baz', 2) returning bar; +-- +ok +== +insert or replace into foo(bar, baz) values ('baz', 1), ('bar', 2) returning bar; +-- +ok +== diff --git a/parser/testdata/corpus/sql/upsert/insert_or_replace/returning_nothing.test b/parser/testdata/corpus/sql/upsert/insert_or_replace/returning_nothing.test new file mode 100644 index 0000000..fb2b5df --- /dev/null +++ b/parser/testdata/corpus/sql/upsert/insert_or_replace/returning_nothing.test @@ -0,0 +1,26 @@ +# source: test/sql/upsert/insert_or_replace/returning_nothing.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +CREATE TABLE bug ( + id INTEGER PRIMARY KEY DEFAULT NEXTVAL('seq'), + name VARCHAR +); +-- +ok +== +CREATE UNIQUE INDEX idx ON bug (name); +-- +ok +== +INSERT OR IGNORE INTO bug VALUES + (DEFAULT, 'toto') RETURNING(id); +-- +ok +== +INSERT OR IGNORE INTO bug VALUES + (DEFAULT, 'toto'), (DEFAULT, 'yoyo') RETURNING(id); +-- +ok +== diff --git a/parser/testdata/corpus/sql/upsert/insert_or_replace/unique_and_non_unique_index.test b/parser/testdata/corpus/sql/upsert/insert_or_replace/unique_and_non_unique_index.test new file mode 100644 index 0000000..48bf5b0 --- /dev/null +++ b/parser/testdata/corpus/sql/upsert/insert_or_replace/unique_and_non_unique_index.test @@ -0,0 +1,21 @@ +# source: test/sql/upsert/insert_or_replace/unique_and_non_unique_index.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +create table tbl( + a int, + b int, + c int +); +-- +ok +== +create UNIQUE index "unique" on tbl(a, b); +-- +ok +== +create index non_unique on tbl(a, b); +-- +ok +== diff --git a/parser/testdata/corpus/sql/upsert/insert_or_replace/unique_constraint.test b/parser/testdata/corpus/sql/upsert/insert_or_replace/unique_constraint.test new file mode 100644 index 0000000..648e367 --- /dev/null +++ b/parser/testdata/corpus/sql/upsert/insert_or_replace/unique_constraint.test @@ -0,0 +1,28 @@ +# source: test/sql/upsert/insert_or_replace/unique_constraint.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +create table tbl( + a int unique, + b int +); +-- +ok +== +insert or replace into tbl values(1, 2); +-- +ok +== +create table multiple_unique( + a int unique, + b int unique, + c int +); +-- +ok +== +insert or replace into multiple_unique values(1, 2, 3); +-- +ok +== diff --git a/parser/testdata/corpus/sql/upsert/insert_or_replace/unique_index.test b/parser/testdata/corpus/sql/upsert/insert_or_replace/unique_index.test new file mode 100644 index 0000000..885362d --- /dev/null +++ b/parser/testdata/corpus/sql/upsert/insert_or_replace/unique_index.test @@ -0,0 +1,21 @@ +# source: test/sql/upsert/insert_or_replace/unique_index.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +CREATE TABLE tbl(a INT, b INT, c INT); +-- +ok +== +CREATE UNIQUE INDEX "unique" ON tbl(a, b); +-- +ok +== +INSERT OR REPLACE INTO tbl VALUES (1, 2, 3); +-- +ok +== +CREATE UNIQUE INDEX idx3 ON tbl(b, c); +-- +ok +== diff --git a/parser/testdata/corpus/sql/upsert/minimal_reproducable_example.test b/parser/testdata/corpus/sql/upsert/minimal_reproducable_example.test new file mode 100644 index 0000000..7bce242 --- /dev/null +++ b/parser/testdata/corpus/sql/upsert/minimal_reproducable_example.test @@ -0,0 +1,21 @@ +# source: test/sql/upsert/minimal_reproducable_example.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +create or replace table tbl( + i integer PRIMARY KEY, + j integer UNIQUE, + k integer +); +-- +ok +== +insert into tbl VALUES (1, 10, 1), (2, 20, 1), (3, 30, 2); +-- +ok +== +insert into tbl VALUES (3,5,1) ON CONFLICT (i) DO UPDATE SET k = k + excluded.k; +-- +ok +== diff --git a/parser/testdata/corpus/sql/upsert/no_complex_default.test b/parser/testdata/corpus/sql/upsert/no_complex_default.test new file mode 100644 index 0000000..2b672e4 --- /dev/null +++ b/parser/testdata/corpus/sql/upsert/no_complex_default.test @@ -0,0 +1,13 @@ +# source: test/sql/upsert/no_complex_default.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +create or replace table tbl (a integer default 3); +-- +ok +== +insert into tbl VALUES ((3+DEFAULT)); +-- +ok +== diff --git a/parser/testdata/corpus/sql/upsert/postgres/composite_key.test b/parser/testdata/corpus/sql/upsert/postgres/composite_key.test new file mode 100644 index 0000000..0219ca2 --- /dev/null +++ b/parser/testdata/corpus/sql/upsert/postgres/composite_key.test @@ -0,0 +1,99 @@ +# source: test/sql/upsert/postgres/composite_key.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +create table insertconflicttest( + key int4, + fruit text, + other int4, + unique (key, fruit) +); +-- +ok +== +insert into insertconflicttest values(0, 'Crowberry', 0) on conflict (key) do nothing; +-- +ok +== +insert into insertconflicttest values(0, 'Crowberry', 0) on conflict (fruit) do nothing; +-- +ok +== +insert into insertconflicttest values(0, 'Crowberry', 0) on conflict (key, fruit) do nothing; +-- +ok +== +insert into insertconflicttest values(0, 'Crowberry', 0) on conflict (fruit, key, fruit, key) do nothing; +-- +ok +== +insert into insertconflicttest +values (0, 'Crowberry', 0) on conflict (key, fruit) do update set other = 1 where exists (select 1 from insertconflicttest ii where ii.key = excluded.key); +-- +ok +== +insert into insertconflicttest values (7, 'Raspberry', 0) on conflict (key, fruit) do update set other = 1 +-- +ok +== +insert into insertconflicttest values (8, 'Lime', 0) on conflict (fruit, key) do update set other = 1 +-- +ok +== +insert into insertconflicttest values (9, 'Banana', 0) on conflict (key) do update set other = 1 +-- +ok +== +insert into insertconflicttest values (10, 'Blueberry', 0) on conflict (key, key, key) do update set other = 1 +-- +ok +== +insert into insertconflicttest values (11, 'Cherry', 0) on conflict (key, fruit) do update set other = 1 +-- +ok +== +insert into insertconflicttest values (12, 'Date', 0) on conflict (fruit, key) do update set other = 1 +-- +ok +== +create unique index part_comp_key_index on insertconflicttest(key, fruit) where key < 5; +-- +ok +== +create unique index expr_part_comp_key_index on insertconflicttest(key, fruit) where key < 5; +-- +ok +== +create unique index expr_key_index on insertconflicttest(fruit); +-- +ok +== +insert into insertconflicttest values (20, 'Quince', 0) on conflict (fruit) do update set other = 1 +-- +ok +== +insert into insertconflicttest values (21, 'Pomegranate', 0) on conflict (fruit, fruit) do update set other = 1 +-- +ok +== +create unique index expr_comp_key_index on insertconflicttest(key, fruit); +-- +ok +== +create unique index tricky_expr_comp_key_index on insertconflicttest(key, fruit, fruit); +-- +ok +== +insert into insertconflicttest values (24, 'Plum', 0) on conflict (key, fruit) do update set other = 1 +-- +ok +== +insert into insertconflicttest values (25, 'Peach', 0) on conflict (fruit, key) do update set other = 1 +-- +ok +== +insert into insertconflicttest values (26, 'Fig', 0) on conflict (fruit, key, fruit, key) do update set other = 1 +-- +ok +== diff --git a/parser/testdata/corpus/sql/upsert/postgres/non_spurious_duplicate_violation.test b/parser/testdata/corpus/sql/upsert/postgres/non_spurious_duplicate_violation.test new file mode 100644 index 0000000..fc51dbb --- /dev/null +++ b/parser/testdata/corpus/sql/upsert/postgres/non_spurious_duplicate_violation.test @@ -0,0 +1,35 @@ +# source: test/sql/upsert/postgres/non_spurious_duplicate_violation.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +create table insertconflicttest( + key int4, + fruit text, + other int4, + unique (key), + unique (fruit) +); +-- +ok +== +insert into insertconflicttest values (25, 'Fig', 0) on conflict (fruit) do update set other = 1 +-- +ok +== +insert into insertconflicttest values (23, 'Blackberry', 0) on conflict (key) do update set other = 1 where fruit like '%berry' +-- +ok +== +insert into insertconflicttest as i values (23, 'Jackfruit', 0) on conflict (key) do update set other = 1 +-- +ok +== +insert into insertconflicttest as i values (23, 'Avocado', 0) on conflict (key) do update set other = 1 +-- +ok +== +drop table insertconflicttest; +-- +ok +== diff --git a/parser/testdata/corpus/sql/upsert/postgres/planner_preprocessing.test b/parser/testdata/corpus/sql/upsert/postgres/planner_preprocessing.test new file mode 100644 index 0000000..e132475 --- /dev/null +++ b/parser/testdata/corpus/sql/upsert/postgres/planner_preprocessing.test @@ -0,0 +1,167 @@ +# source: test/sql/upsert/postgres/planner_preprocessing.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +create table cities ( + name text, + population float8, + altitude int, + unique (name) +); +-- +ok +== +create table capitals ( + name text, + population float8, + altitude int, + state char(2), + unique (name) +); +-- +ok +== +insert into cities values ('San Francisco', 7.24E+5, 63); +-- +ok +== +insert into cities values ('Las Vegas', 2.583E+5, 2174); +-- +ok +== +insert into cities values ('Mariposa', 1200, 1953); +-- +ok +== +insert into capitals values ('Sacramento', 3.694E+5, 30, 'CA'); +-- +ok +== +insert into capitals values ('Madison', 1.913E+5, 845, 'WI'); +-- +ok +== +select * from capitals; +-- +ok +== +insert into cities values ('Las Vegas', 2.583E+5, 2174) on conflict do nothing; +-- +ok +== +insert into capitals values ('Sacramento', 4664.E+5, 30, 'CA') on conflict (name) do update set population = excluded.population; +-- +ok +== +insert into capitals values ('Sacramento', 50, 2267, 'NE') on conflict (name) do nothing; +-- +ok +== +insert into cities values ('Las Vegas', 5.83E+5, 2001) on conflict (name) do update set population = excluded.population, altitude = excluded.altitude; +-- +ok +== +select rowid, * from cities; +-- +ok +== +insert into capitals values ('Las Vegas', 5.83E+5, 2222, 'NV') on conflict (name) do update set population = excluded.population; +-- +ok +== +insert into cities values ('Las Vegas', 5.86E+5, 2223) on conflict (name) do update set population = excluded.population, altitude = excluded.altitude; +select rowid, * from cities; +-- +ok +== +drop table capitals; +-- +ok +== +drop table cities; +-- +ok +== +create table excluded(key int primary key, data text); +-- +ok +== +insert into excluded values(1, '1'); +-- +ok +== +insert into excluded values(1, '2') on conflict (key) do update set data = excluded.data RETURNING *; +-- +ok +== +insert into excluded AS target values(1, '2') on conflict (key) do update set data = excluded.data RETURNING *; +-- +ok +== +insert into excluded AS target values(1, '2') on conflict (key) do update set data = target.data RETURNING *; +-- +ok +== +insert into excluded values(1, '2') on conflict (key) do update set data = 3 RETURNING excluded.*; +-- +ok +== +drop table excluded; +-- +ok +== +create table dropcol(key int primary key, drop1 int, keep1 text, drop2 numeric, keep2 float); +-- +ok +== +insert into dropcol(key, drop1, keep1, drop2, keep2) values(1, 1, '1', '1', 1); +-- +ok +== +insert into dropcol(key, drop1, keep1, drop2, keep2) values(1, 2, '2', '2', 2) on conflict(key) + do update set drop1 = excluded.drop1, keep1 = excluded.keep1, drop2 = excluded.drop2, keep2 = excluded.keep2 + where excluded.drop1 is not null and excluded.keep1 is not null and excluded.drop2 is not null and excluded.keep2 is not null + and dropcol.drop1 is not null and dropcol.keep1 is not null and dropcol.drop2 is not null and dropcol.keep2 is not null + returning *; +; +-- +ok +== +insert into dropcol(key, drop1, keep1, drop2, keep2) values(1, 3, '3', '3', 3) on conflict(key) + do update set drop1 = dropcol.drop1, keep1 = dropcol.keep1, drop2 = dropcol.drop2, keep2 = dropcol.keep2 + returning *; +; +-- +ok +== +alter table dropcol +drop column drop1; +-- +ok +== +alter table dropcol +drop column drop2; +-- +ok +== +insert into dropcol(key, keep1, keep2) values(1, '4', 4) on conflict(key) + do update set keep1 = excluded.keep1, keep2 = excluded.keep2 + where excluded.keep1 is not null and excluded.keep2 is not null + and dropcol.keep1 is not null and dropcol.keep2 is not null + returning *; +; +-- +ok +== +insert into dropcol(key, keep1, keep2) values(1, '5', 5) on conflict(key) + do update set keep1 = dropcol.keep1, keep2 = dropcol.keep2 + returning *; +; +-- +ok +== +DROP TABLE dropcol; +-- +ok +== diff --git a/parser/testdata/corpus/sql/upsert/postgres/single_key.test b/parser/testdata/corpus/sql/upsert/postgres/single_key.test new file mode 100644 index 0000000..ffd185e --- /dev/null +++ b/parser/testdata/corpus/sql/upsert/postgres/single_key.test @@ -0,0 +1,86 @@ +# source: test/sql/upsert/postgres/single_key.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +create table insertconflicttest( + key int4, + fruit text, + unique (key) +); +-- +ok +== +insert into insertconflicttest values (0, 'Bilberry') on conflict (key) do update set fruit = excluded.fruit; +-- +ok +== +insert into insertconflicttest values (0, 'Bilberry') on conflict (key) do update set fruit = excluded.fruit where insertconflicttest.fruit != 'Cawesh'; +-- +ok +== +insert into insertconflicttest values(0, 'Crowberry') on conflict (key) do update set fruit = excluded.fruit where excluded.fruit != 'Elderberry'; +-- +ok +== +insert into insertconflicttest values (0, 'Bilberry') on conflict (key) do update set fruit = excluded.fruit where insertconflicttest.fruit != 'Lime' returning *; +-- +ok +== +insert into insertconflicttest values (1, 'Apple') on conflict do update set fruit = excluded.fruit; +-- +ok +== +insert into insertconflicttest values (1, 'Apple') on conflict (key) do update set fruit = excluded.fruit; +-- +ok +== +insert into insertconflicttest values (2, 'Orange') on conflict (key, key, key) do update set fruit = excluded.fruit; +-- +ok +== +INSERT INTO insertconflicttest VALUES (1, 'Apple'), (2, 'Orange') +ON CONFLICT (key) DO UPDATE SET fruit = excluded.fruit, key = excluded.key; +-- +ok +== +insert into insertconflicttest values (1, 'Apple') on conflict (key) do update set fruit = excluded.fruit RETURNING excluded.fruit; +-- +ok +== +insert into insertconflicttest values (1, 'Apple') on conflict (keyy) do update set fruit = excluded.fruit; +-- +ok +== +insert into insertconflicttest values (1, 'Apple') on conflict (key) do update set fruit = excluded.fruitt; +-- +ok +== +insert into insertconflicttest values (3, 'Kiwi') on conflict (key, fruit) do update set fruit = excluded.fruit; +-- +ok +== +insert into insertconflicttest values (4, 'Mango') on conflict (fruit, key) do update set fruit = excluded.fruit; +-- +ok +== +insert into insertconflicttest values (5, 'Lemon') on conflict (fruit) do update set fruit = excluded.fruit; +-- +ok +== +insert into insertconflicttest values (6, 'Passionfruit') on conflict (fruit) do update set fruit = excluded.fruit; +-- +ok +== +insert into insertconflicttest AS ict values (6, 'Passionfruit') on conflict (key) do update set fruit = excluded.fruit; +-- +ok +== +insert into insertconflicttest AS ict values (6, 'Passionfruit') on conflict (key) do update set fruit = ict.fruit; +-- +ok +== +insert into insertconflicttest AS ict values (6, 'Passionfruit') on conflict (key) do update set fruit = insertconflicttest.fruit; +-- +ok +== diff --git a/parser/testdata/corpus/sql/upsert/test_big_insert.test b/parser/testdata/corpus/sql/upsert/test_big_insert.test new file mode 100644 index 0000000..8c8282f --- /dev/null +++ b/parser/testdata/corpus/sql/upsert/test_big_insert.test @@ -0,0 +1,74 @@ +# source: test/sql/upsert/test_big_insert.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +SET preserve_insertion_order = false; +-- +ok +== +CREATE TABLE integers( + i INT UNIQUE, + j INT DEFAULT 0, + k INT DEFAULT 0 +); +-- +ok +== +INSERT INTO integers(i) SELECT i FROM range(5000) tbl(i); +-- +ok +== +INSERT INTO integers SELECT * FROM integers ON CONFLICT DO NOTHING; +-- +ok +== +INSERT INTO integers SELECT * FROM integers ON CONFLICT DO UPDATE SET j = 10; +-- +ok +== +SELECT COUNT(*) FILTER (WHERE j = 10) FROM integers +-- +ok +== +INSERT INTO integers(i, j) SELECT i % 5, i FROM range(4995, 5000) tbl(i) ON CONFLICT DO UPDATE SET j = excluded.j, k = excluded.i; +-- +ok +== +SELECT j FROM integers LIMIT 5; +-- +ok +== +INSERT INTO integers(i, j) + SELECT CASE WHEN i % 2 = 0 + THEN 4999 - (i // 2) + ELSE i - ((i // 2) + 1) + END, i + FROM range(5000) tbl(i) +ON CONFLICT DO UPDATE SET j = excluded.j; +-- +ok +== +SELECT j FROM integers LIMIT 5 OFFSET 4995; +-- +ok +== +UPDATE integers SET j = 0; +-- +ok +== +INSERT INTO integers(i, j) + SELECT CASE WHEN i % 2 = 0 + THEN 4999 - (i // 2) + ELSE i - ((i // 2) + 1) + END, i + FROM range(5000) tbl(i) +ON CONFLICT DO UPDATE SET j = excluded.j +WHERE i % 2 = 0 AND excluded.j % 2 = 0; +-- +ok +== +SELECT COUNT(j) FILTER (WHERE j != 0) FROM integers; +-- +ok +== diff --git a/parser/testdata/corpus/sql/upsert/test_big_insert_no_vector_verification.test b/parser/testdata/corpus/sql/upsert/test_big_insert_no_vector_verification.test new file mode 100644 index 0000000..c0e69b4 --- /dev/null +++ b/parser/testdata/corpus/sql/upsert/test_big_insert_no_vector_verification.test @@ -0,0 +1,13 @@ +# source: test/sql/upsert/test_big_insert_no_vector_verification.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +INSERT INTO integers(i, j) +SELECT i % 5, i +FROM range(5000) tbl(i) ON CONFLICT DO UPDATE SET + j = excluded.j, + k = excluded.i; +-- +ok +== diff --git a/parser/testdata/corpus/sql/upsert/test_generated_column.test b/parser/testdata/corpus/sql/upsert/test_generated_column.test new file mode 100644 index 0000000..013f6ba --- /dev/null +++ b/parser/testdata/corpus/sql/upsert/test_generated_column.test @@ -0,0 +1,37 @@ +# source: test/sql/upsert/test_generated_column.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +CREATE TABLE t1 ( + a CHAR NOT NULL, + c CHAR GENERATED ALWAYS AS (a) VIRTUAL, + b INT, +); +-- +ok +== +CREATE UNIQUE INDEX t1_idx ON t1 (a); +-- +ok +== +INSERT INTO t1 VALUES ('a', 1) ON CONFLICT(a) DO UPDATE SET b = excluded.b; +-- +ok +== +CREATE TABLE t2 ( + b INT, + c CHAR GENERATED ALWAYS AS (a) VIRTUAL, + a CHAR NOT NULL, +); +-- +ok +== +CREATE UNIQUE INDEX t2_idx ON t2 (a); +-- +ok +== +INSERT INTO t2 VALUES (1, 'a') ON CONFLICT(a) DO UPDATE SET b = excluded.b; +-- +ok +== diff --git a/parser/testdata/corpus/sql/upsert/test_problematic_conditional_do_update.test b/parser/testdata/corpus/sql/upsert/test_problematic_conditional_do_update.test new file mode 100644 index 0000000..def004d --- /dev/null +++ b/parser/testdata/corpus/sql/upsert/test_problematic_conditional_do_update.test @@ -0,0 +1,37 @@ +# source: test/sql/upsert/test_problematic_conditional_do_update.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +CREATE TABLE users ( + id BIGINT PRIMARY KEY, + username TEXT UNIQUE, + email TEXT +); +-- +ok +== +INSERT INTO users (id, username, email) +VALUES + (3, 'inner_conflict', 'test'), + (3, 'inner_conflict2', 'other_test'), + (3, 'inner_conflict3', 'filtered_out') +ON CONFLICT (id) DO + UPDATE SET email = EXCLUDED.email + WHERE EXCLUDED.email != 'filtered_out' +-- +ok +== +INSERT INTO users (id, username, email) +VALUES + (3, 'inner_conflict', 'test'), + (3, 'inner_conflict2', 'other_test'), + (3, 'inner_conflict3', 'yet_another_test'), + (3, 'inner_conflict4', 'dont_skip_me') +ON CONFLICT (id) DO + UPDATE SET email = EXCLUDED.email + WHERE email != 'other_test' OR EXCLUDED.email == 'dont_skip_me' +RETURNING *; +-- +ok +== diff --git a/parser/testdata/corpus/sql/upsert/upsert_aliased.test b/parser/testdata/corpus/sql/upsert/upsert_aliased.test new file mode 100644 index 0000000..b6a9b45 --- /dev/null +++ b/parser/testdata/corpus/sql/upsert/upsert_aliased.test @@ -0,0 +1,48 @@ +# source: test/sql/upsert/upsert_aliased.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +create table tbl ( + i integer, + j integer unique +); +-- +ok +== +insert into tbl values (5,3), (6,7); +-- +ok +== +insert into tbl AS test values (3,5), (8,3), (2,6) on conflict (j) do update set i = excluded.i * 2 where i <= excluded.i; +-- +ok +== +select * from tbl order by all +-- +ok +== +insert into tbl AS test values (2,3) on conflict do update set i = test.i; +-- +ok +== +insert into tbl as test values (2,3) on conflict (j) do update set i = excluded.j where test.i < 5; +-- +ok +== +insert into tbl as test values (2,3) on conflict (j) do update set i = excluded.j where test.i >= 5; +-- +ok +== +insert into tbl as test (j, i) values (5,3) on conflict (j) do update set i = 10 where test.j <= 3; +-- +ok +== +insert into tbl as test (j, i) values (5,3) on conflict (j) do update set i = 10 where test.j > 3; +-- +ok +== +insert into tbl as excluded values (8,3) on conflict (j) do update set i = excluded.i; +-- +ok +== diff --git a/parser/testdata/corpus/sql/upsert/upsert_basic.test b/parser/testdata/corpus/sql/upsert/upsert_basic.test new file mode 100644 index 0000000..925fbb3 --- /dev/null +++ b/parser/testdata/corpus/sql/upsert/upsert_basic.test @@ -0,0 +1,117 @@ +# source: test/sql/upsert/upsert_basic.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +CREATE TABLE tbl( + i INT PRIMARY KEY, + j INT UNIQUE, + k INT +); +-- +ok +== +INSERT INTO tbl VALUES (1, 10, 1), (2, 20, 1), (3, 30, 2); +-- +ok +== +INSERT INTO tbl VALUES (3, 5, 1) +ON CONFLICT (i) DO UPDATE SET i = i + 1; +-- +ok +== +SELECT i, j, k FROM tbl ORDER BY ALL; +-- +ok +== +SELECT i, j, k FROM tbl WHERE i = 4; +-- +ok +== +INSERT INTO tbl VALUES (4, 30, 2) +ON CONFLICT (i) DO UPDATE SET i = i - 1; +-- +ok +== +INSERT INTO tbl VALUES (3, 30, 2) +ON CONFLICT (i) DO UPDATE SET i = i - 2; +-- +ok +== +insert into tbl VALUES + (3,5,1) +ON CONFLICT (i) DO UPDATE SET k = k + excluded.k; +-- +ok +== +insert into tbl VALUES + (3,5,1) +ON CONFLICT (k) DO UPDATE SET k = excluded.k; +-- +ok +== +insert into tbl VALUES + (3,5,1) +ON CONFLICT (i) DO UPDATE SET k = excluded.k; +-- +ok +== +insert into tbl VALUES + (4,2,3), + (3,5,10) +ON CONFLICT (i) DO NOTHING; +-- +ok +== +insert into tbl VALUES + (3,3,10), + (3,3,10) +ON CONFLICT (i) DO UPDATE SET + k = excluded.k; +-- +ok +== +insert into tbl VALUES (3,5,1) ON CONFLICT (i) DO UPDATE SET k = 1 WHERE k < 5; +-- +ok +== +insert into tbl VALUES (3,5,1) ON CONFLICT (i) DO UPDATE SET k = 1 WHERE k >= 5; +-- +ok +== +insert into tbl VALUES (3,5,3) on conflict (i) do update set k = 10 WHERE k != 1; +-- +ok +== +insert into tbl VALUES (3,5,3) on conflict (i) do update set k = 10 WHERE k == 1; +-- +ok +== +insert into tbl VALUES (5,1,0), (3,5,20) ON CONFLICT DO NOTHING; +-- +ok +== +insert into tbl VALUES (5,1,0), (3,5,20) ON CONFLICT DO UPDATE set k = excluded.k; +-- +ok +== +create or replace table single_constraint ( + i integer PRIMARY KEY, + j integer, + k varchar, +); +-- +ok +== +insert into single_constraint values (5,1,'hello'), (1,10,'test'); +-- +ok +== +insert into single_constraint values (1,5,'bye'), (3,10,'quack') on conflict do update set j = excluded.j, k = concat(k, excluded.k); +-- +ok +== +select * from single_constraint +-- +ok +== diff --git a/parser/testdata/corpus/sql/upsert/upsert_conflict_target.test b/parser/testdata/corpus/sql/upsert/upsert_conflict_target.test new file mode 100644 index 0000000..6428c4a --- /dev/null +++ b/parser/testdata/corpus/sql/upsert/upsert_conflict_target.test @@ -0,0 +1,33 @@ +# source: test/sql/upsert/upsert_conflict_target.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +CREATE OR REPLACE TABLE tbl (a INT, b INT, c INT, PRIMARY KEY (a, b)); +-- +ok +== +INSERT INTO tbl VALUES (1, 2, 3), (1, 2, 3); +-- +ok +== +INSERT INTO tbl VALUES (1, 2, 3), (1, 4, 5); +-- +ok +== +INSERT INTO tbl VALUES (1,4,7), (1,8,4) ON CONFLICT (a) DO UPDATE SET c = 5; +-- +ok +== +INSERT INTO tbl VALUES (1,4,7), (1,8,4) ON CONFLICT (b) DO UPDATE SET c = 5; +-- +ok +== +INSERT INTO tbl VALUES (1,4,7), (1,8,4) ON CONFLICT (a,b) DO UPDATE SET c = 5; +-- +ok +== +SELECT a, b, c FROM tbl ORDER BY ALL; +-- +ok +== diff --git a/parser/testdata/corpus/sql/upsert/upsert_conflict_target_index.test b/parser/testdata/corpus/sql/upsert/upsert_conflict_target_index.test new file mode 100644 index 0000000..309feca --- /dev/null +++ b/parser/testdata/corpus/sql/upsert/upsert_conflict_target_index.test @@ -0,0 +1,32 @@ +# source: test/sql/upsert/upsert_conflict_target_index.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +create or replace table index_tbl ( + i integer, + j integer +); +-- +ok +== +insert into index_tbl values (5, 3); +-- +ok +== +create unique index other_index on index_tbl(i); +-- +ok +== +insert into index_tbl values (5, 5); +-- +ok +== +select * from index_tbl; +-- +ok +== +insert into index_tbl values (5, 10) on conflict on constraint other_index do update set j = excluded.j; +-- +ok +== diff --git a/parser/testdata/corpus/sql/upsert/upsert_coverage.test b/parser/testdata/corpus/sql/upsert/upsert_coverage.test new file mode 100644 index 0000000..e35459a --- /dev/null +++ b/parser/testdata/corpus/sql/upsert/upsert_coverage.test @@ -0,0 +1,26 @@ +# source: test/sql/upsert/upsert_coverage.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +CREATE TABLE tbl (a INT, b INT UNIQUE, c INT UNIQUE, d INT UNIQUE); +-- +ok +== +INSERT INTO tbl (b, c, d) VALUES (1, 2, 3), (2, 3, 1), (3, 1, 2) +-- +ok +== +INSERT INTO tbl(b, c, d) VALUES (3, 3, 3) ON CONFLICT DO NOTHING; +-- +ok +== +SELECT b, c, d FROM tbl ORDER BY ALL; +-- +ok +== +INSERT INTO tbl(b, c, d) VALUES (3, 3, 3) +ON CONFLICT DO UPDATE SET b = EXCLUDED.b, c = EXCLUDED.c, d = EXCLUDED.d; +-- +ok +== diff --git a/parser/testdata/corpus/sql/upsert/upsert_default.test b/parser/testdata/corpus/sql/upsert/upsert_default.test new file mode 100644 index 0000000..fd2ef62 --- /dev/null +++ b/parser/testdata/corpus/sql/upsert/upsert_default.test @@ -0,0 +1,77 @@ +# source: test/sql/upsert/upsert_default.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +create table tbl ( + a integer DEFAULT 5, + b integer unique, + c integer DEFAULT 10 +); +-- +ok +== +insert into tbl(b) VALUES (3), (5), (6); +-- +ok +== +insert into tbl(b) VALUES (7), (3), (4) ON CONFLICT do update set c = 5, a = 10; +-- +ok +== +create table t (i int primary key, j int); +-- +ok +== +insert into t values (1, 1) on conflict do nothing; +-- +ok +== +insert into t values (1, 1) on conflict do nothing +-- +ok +== +insert into t values (1, 1) on conflict (i) do update set j = excluded.i; +-- +ok +== +create table t_case (i int not null primary key); +-- +ok +== +insert into t_case (I) select 1 on conflict do nothing; +-- +ok +== +select * from t_case; +-- +ok +== +create table t_case_nullable (i int, j int unique); +-- +ok +== +insert into t_case_nullable (I, J) select 7, 9 on conflict do nothing; +-- +ok +== +select i, j from t_case_nullable; +-- +ok +== +create table t_case_upd (i int primary key, j int); +-- +ok +== +insert into t_case_upd (I, J) select 1, 10 on conflict do nothing; +-- +ok +== +insert into t_case_upd (I, J) select 1, 20 on conflict (I) do update set j = excluded.j; +-- +ok +== +select i, j from t_case_upd; +-- +ok +== diff --git a/parser/testdata/corpus/sql/upsert/upsert_default_expressions.test b/parser/testdata/corpus/sql/upsert/upsert_default_expressions.test new file mode 100644 index 0000000..1675a69 --- /dev/null +++ b/parser/testdata/corpus/sql/upsert/upsert_default_expressions.test @@ -0,0 +1,28 @@ +# source: test/sql/upsert/upsert_default_expressions.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +create or replace table tbl ( + a integer primary key default 4, + b integer DEFAULT 3 +); +-- +ok +== +insert into tbl VALUES (2,3), (4,5) +-- +ok +== +insert into tbl VALUES (DEFAULT, 6) ON CONFLICT (a) DO UPDATE SET b = DEFAULT +-- +ok +== +insert into tbl VALUES (4,8) ON CONFLICT (a) DO UPDATE SET b = excluded.b WHERE a = DEFAULT; +-- +ok +== +insert into tbl VALUES (4,3) ON CONFLICT (a) DO UPDATE SET b = excluded.b WHERE excluded.b = DEFAULT * 2; +-- +ok +== diff --git a/parser/testdata/corpus/sql/upsert/upsert_default_value_causes_conflict.test b/parser/testdata/corpus/sql/upsert/upsert_default_value_causes_conflict.test new file mode 100644 index 0000000..455d033 --- /dev/null +++ b/parser/testdata/corpus/sql/upsert/upsert_default_value_causes_conflict.test @@ -0,0 +1,24 @@ +# source: test/sql/upsert/upsert_default_value_causes_conflict.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +create or replace table tbl ( + a integer primary key default 5, + b integer +); +-- +ok +== +insert into tbl(b) VALUES (10); +-- +ok +== +insert into tbl(b) VALUES (10) ON CONFLICT (a) DO NOTHING; +-- +ok +== +insert into tbl(b) VALUES (10) ON CONFLICT (a) DO UPDATE SET b = excluded.b * 2; +-- +ok +== diff --git a/parser/testdata/corpus/sql/upsert/upsert_default_values.test b/parser/testdata/corpus/sql/upsert/upsert_default_values.test new file mode 100644 index 0000000..b515437 --- /dev/null +++ b/parser/testdata/corpus/sql/upsert/upsert_default_values.test @@ -0,0 +1,16 @@ +# source: test/sql/upsert/upsert_default_values.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +create or replace table tbl ( + a integer primary key DEFAULT 5, + b integer +); +-- +ok +== +insert into tbl DEFAULT VALUES; +-- +ok +== diff --git a/parser/testdata/corpus/sql/upsert/upsert_distinct_bug.test b/parser/testdata/corpus/sql/upsert/upsert_distinct_bug.test new file mode 100644 index 0000000..92189bb --- /dev/null +++ b/parser/testdata/corpus/sql/upsert/upsert_distinct_bug.test @@ -0,0 +1,41 @@ +# source: test/sql/upsert/upsert_distinct_bug.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +CREATE TABLE test_table_raw(id VARCHAR, name VARCHAR); +-- +ok +== +INSERT INTO test_table_raw VALUES + ('abc001','foo'), + ('abc002','bar'), + ('abc001','foo2'), + ('abc002','bar2'); +-- +ok +== +CREATE TABLE test_table(id VARCHAR PRIMARY KEY, name VARCHAR); +-- +ok +== +INSERT INTO test_table +SELECT + DISTINCT(id) as id, + name +FROM test_table_raw; +-- +ok +== +INSERT OR IGNORE INTO test_table +SELECT + DISTINCT(id) as id, + name +FROM test_table_raw; +-- +ok +== +SELECT * FROM test_table_raw; +-- +ok +== diff --git a/parser/testdata/corpus/sql/upsert/upsert_duplicates_issue.test b/parser/testdata/corpus/sql/upsert/upsert_duplicates_issue.test new file mode 100644 index 0000000..c0c78d1 --- /dev/null +++ b/parser/testdata/corpus/sql/upsert/upsert_duplicates_issue.test @@ -0,0 +1,17 @@ +# source: test/sql/upsert/upsert_duplicates_issue.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +CREATE TABLE tmp_edges(from_v VARCHAR, to_v VARCHAR, PRIMARY KEY(from_v, to_v)); +-- +ok +== +INSERT INTO tmp_edges + from '{DATA_DIR}/parquet-testing/upsert_bug.parquet' + ON CONFLICT DO UPDATE SET + from_v = excluded.from_v +; +-- +ok +== diff --git a/parser/testdata/corpus/sql/upsert/upsert_excluded_references.test b/parser/testdata/corpus/sql/upsert/upsert_excluded_references.test new file mode 100644 index 0000000..f603809 --- /dev/null +++ b/parser/testdata/corpus/sql/upsert/upsert_excluded_references.test @@ -0,0 +1,36 @@ +# source: test/sql/upsert/upsert_excluded_references.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +create or replace table tbl ( + a integer primary key, + b integer +); +-- +ok +== +insert into tbl VALUES (1,2), (2,2); +-- +ok +== +insert into tbl VALUES (1,3), (3,4); +-- +ok +== +insert into tbl VALUES (1,3), (3,4) ON CONFLICT (a) DO UPDATE SET b = excluded.b; +-- +ok +== +insert into tbl VALUES (4,3), (3,8) ON CONFLICT (a) WHERE excluded.b < 8 DO NOTHING; +-- +ok +== +insert into tbl VALUES (4,3), (3,8) ON CONFLICT (a) DO UPDATE SET b = 10; +-- +ok +== +insert into tbl VALUES (3,8), (2,2), (7,2) ON CONFLICT (a) DO UPDATE SET b = b*2 WHERE b == excluded.b; +-- +ok +== diff --git a/parser/testdata/corpus/sql/upsert/upsert_explicit_index.test b/parser/testdata/corpus/sql/upsert/upsert_explicit_index.test new file mode 100644 index 0000000..7166a00 --- /dev/null +++ b/parser/testdata/corpus/sql/upsert/upsert_explicit_index.test @@ -0,0 +1,53 @@ +# source: test/sql/upsert/upsert_explicit_index.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +CREATE TABLE tbl (i INT, j INT); +-- +ok +== +INSERT INTO tbl VALUES (5, 3), (3, 2); +-- +ok +== +CREATE UNIQUE INDEX my_index ON tbl(i); +-- +ok +== +INSERT INTO tbl VALUES (5, 2) ON CONFLICT (i) DO UPDATE SET j = 10; +-- +ok +== +SELECT i, j FROM tbl ORDER BY ALL DESC; +-- +ok +== +DROP TABLE tbl CASCADE; +-- +ok +== +CREATE TABLE tbl (i INT PRIMARY KEY, j INT); +-- +ok +== +INSERT INTO tbl VALUES (42, 21), (21, 42); +-- +ok +== +CREATE INDEX my_index ON tbl(j); +-- +ok +== +INSERT INTO tbl VALUES (42, 20) ON CONFLICT DO UPDATE SET j = 30; +-- +ok +== +SELECT i, j, rowid FROM tbl WHERE j = 30; +-- +ok +== +SELECT i, j, rowid FROM tbl ORDER BY ALL; +-- +ok +== diff --git a/parser/testdata/corpus/sql/upsert/upsert_global_mixed_conflicts.test b/parser/testdata/corpus/sql/upsert/upsert_global_mixed_conflicts.test new file mode 100644 index 0000000..40135c0 --- /dev/null +++ b/parser/testdata/corpus/sql/upsert/upsert_global_mixed_conflicts.test @@ -0,0 +1,35 @@ +# source: test/sql/upsert/upsert_global_mixed_conflicts.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +create table tbl ( + number INTEGER PRIMARY KEY, + str VARCHAR +); +-- +ok +== +insert into tbl VALUES + (1, 'd'), + (3, 'nope'), + (2, 'n') +; +-- +ok +== +insert into tbl VALUES + (1, 'c'), -- conflict (existing) + (6, 'yep'), + (3, 'abc'), -- conflict (existing) + (4, 'abc'), + (7, 'tes'), + (2, 'b'), -- conflict (existing) + (1, 'c'), -- conflict (existing + inner) + (5, 'abc'), + (7, 'tes'), -- conflict (inner) + (2, 'b') -- conflict (existing + inner) +ON CONFLICT (number) DO UPDATE SET str = excluded.str || 'e'; +-- +ok +== diff --git a/parser/testdata/corpus/sql/upsert/upsert_inner_conflict_do_nothing.test b/parser/testdata/corpus/sql/upsert/upsert_inner_conflict_do_nothing.test new file mode 100644 index 0000000..f0fc93f --- /dev/null +++ b/parser/testdata/corpus/sql/upsert/upsert_inner_conflict_do_nothing.test @@ -0,0 +1,19 @@ +# source: test/sql/upsert/upsert_inner_conflict_do_nothing.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +create table tbl( + i int primary key +); +-- +ok +== +insert into tbl values (1); +-- +ok +== +insert into tbl select 1 from range(2) on conflict do nothing; +-- +ok +== diff --git a/parser/testdata/corpus/sql/upsert/upsert_lambda.test b/parser/testdata/corpus/sql/upsert/upsert_lambda.test new file mode 100644 index 0000000..afa7a44 --- /dev/null +++ b/parser/testdata/corpus/sql/upsert/upsert_lambda.test @@ -0,0 +1,62 @@ +# source: test/sql/upsert/upsert_lambda.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +CREATE OR REPLACE TABLE foo ( + pk_col INT PRIMARY KEY, + str VARCHAR, + str_list VARCHAR[], + payload_col INT +); +-- +ok +== +INSERT INTO foo +SELECT 1, 'hello', ['x', 'y', 'z'], 40 +ON CONFLICT DO UPDATE SET + str = list_reduce(EXCLUDED.str_list, lambda x, y: x || '||' || y); +-- +ok +== +FROM foo; +-- +ok +== +INSERT INTO foo +SELECT 1, 'world', ['a', 'b', 'c'], 41 +ON CONFLICT DO UPDATE SET + str = list_reduce(EXCLUDED.str_list, lambda x, y: x || '||' || y); +-- +ok +== +INSERT INTO foo +SELECT 1, '', ['1', '2'], 42 +ON CONFLICT DO UPDATE SET + str = list_reduce(EXCLUDED.str_list, lambda x, y: x || '||' || y), + payload_col = EXCLUDED.payload_col; +-- +ok +== +INSERT INTO foo +SELECT 1, '', ['l', 'm', 'n'], 43 +ON CONFLICT DO UPDATE SET + str = list_reduce(str_list, lambda x, y: x || '||' || y); +-- +ok +== +INSERT INTO foo +SELECT 1, 'world', ['s', 't'], 42 +ON CONFLICT DO UPDATE SET + str = list_reduce(EXCLUDED.str_list, lambda x, y: x || str || y || EXCLUDED.str); +-- +ok +== +INSERT INTO foo +SELECT 1, 'motorcycle', ['brrr', 'brrrrrr'], 1042 +ON CONFLICT DO UPDATE SET + str = 'black-bellied whistling duck' + WHERE list_reduce(EXCLUDED.str_list, lambda x, y: x || str || y || EXCLUDED.str) = 'brrrsx||y||ztworldbrrrrrrmotorcycle'; +-- +ok +== diff --git a/parser/testdata/corpus/sql/upsert/upsert_local_no_tuples.test b/parser/testdata/corpus/sql/upsert/upsert_local_no_tuples.test new file mode 100644 index 0000000..594adfd --- /dev/null +++ b/parser/testdata/corpus/sql/upsert/upsert_local_no_tuples.test @@ -0,0 +1,32 @@ +# source: test/sql/upsert/upsert_local_no_tuples.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +create table tbl ( + a short primary key, + b short +); +-- +ok +== +insert into tbl(a, b) values(1, 2); +-- +ok +== +insert into tbl(a, b) values(1, 2) on conflict do nothing; +-- +ok +== +select * from tbl where a = 1; +-- +ok +== +insert into tbl (a, b) values (5,4); +-- +ok +== +select * from tbl order by a; +-- +ok +== diff --git a/parser/testdata/corpus/sql/upsert/upsert_multiple_constraints.test b/parser/testdata/corpus/sql/upsert/upsert_multiple_constraints.test new file mode 100644 index 0000000..ff88585 --- /dev/null +++ b/parser/testdata/corpus/sql/upsert/upsert_multiple_constraints.test @@ -0,0 +1,17 @@ +# source: test/sql/upsert/upsert_multiple_constraints.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +CREATE TABLE IF NOT EXISTS tbl (id INTEGER PRIMARY KEY, uniq INTEGER, UNIQUE(uniq)); +-- +ok +== +INSERT OR IGNORE INTO tbl VALUES (1, 1), (2, 1); +-- +ok +== +SELECT uniq FROM tbl +-- +ok +== diff --git a/parser/testdata/corpus/sql/upsert/upsert_order_coverage.test b/parser/testdata/corpus/sql/upsert/upsert_order_coverage.test new file mode 100644 index 0000000..b7a8fb0 --- /dev/null +++ b/parser/testdata/corpus/sql/upsert/upsert_order_coverage.test @@ -0,0 +1,29 @@ +# source: test/sql/upsert/upsert_order_coverage.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +create or replace table tbl( + i integer UNIQUE, + j integer, + k integer PRIMARY KEY +); +-- +ok +== +insert into tbl values (3,4,2), (5,3,1); +-- +ok +== +insert into tbl(k, i) values (2,3), (4,4), (1,8) on conflict (k) do update set j = excluded.j; +-- +ok +== +insert into tbl(i,k) values (3,2), (5,5) on conflict (k) do update set j = 10; +-- +ok +== +insert into tbl(i,k) values (3,10), (6,2) on conflict(i) do update set j = 10; +-- +ok +== diff --git a/parser/testdata/corpus/sql/upsert/upsert_partial_update.test b/parser/testdata/corpus/sql/upsert/upsert_partial_update.test new file mode 100644 index 0000000..b494630 --- /dev/null +++ b/parser/testdata/corpus/sql/upsert/upsert_partial_update.test @@ -0,0 +1,17 @@ +# source: test/sql/upsert/upsert_partial_update.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +create or replace table tbl (a integer primary key, b integer); +-- +ok +== +insert into tbl VALUES (1,3), (2,2), (3,10), (4,3); +-- +ok +== +insert into tbl VALUES (3,8), (2,2) ON CONFLICT (a) DO UPDATE SET b = b*2 WHERE b == excluded.b; +-- +ok +== diff --git a/parser/testdata/corpus/sql/upsert/upsert_returning.test b/parser/testdata/corpus/sql/upsert/upsert_returning.test new file mode 100644 index 0000000..2f78603 --- /dev/null +++ b/parser/testdata/corpus/sql/upsert/upsert_returning.test @@ -0,0 +1,58 @@ +# source: test/sql/upsert/upsert_returning.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +CREATE TABLE users ( + id BIGINT PRIMARY KEY, + username TEXT UNIQUE, + email TEXT +); +-- +ok +== +INSERT INTO users (id, username, email) VALUES + (1, 'john_doe', 'john@example.com') +ON CONFLICT (username) DO NOTHING +RETURNING *; +-- +ok +== +INSERT INTO users (id, username, email) +VALUES (1, 'john_doe', 'john_new@example.com') +ON CONFLICT (id) DO + UPDATE SET email = EXCLUDED.email + WHERE EXCLUDED.email != 'john_new@example.com' +RETURNING *; +-- +ok +== +INSERT INTO users (id, username, email) +VALUES + (1, 'john_doe', 'john_new@example.com'), + (2, 'not_john_doe', 'not_john_new@example.com') +ON CONFLICT (id) DO + UPDATE SET email = EXCLUDED.email + WHERE EXCLUDED.email != 'john_new@example.com' +RETURNING *; +-- +ok +== +INSERT INTO users (id, username, email) +VALUES + (3, 'inner_conflict', 'test'), + (4, 'a', ''), + (5, 'b', ''), + (6, 'c', ''), + (3, 'inner_conflict2', 'other_test'), + (7, 'd', ''), + (8, 'e', ''), + (9, 'f', ''), + (3, 'inner_conflict3', 'yet_another_test') +ON CONFLICT (id) DO + UPDATE SET email = EXCLUDED.email + WHERE EXCLUDED.email != 'test' +RETURNING *; +-- +ok +== diff --git a/parser/testdata/corpus/sql/upsert/upsert_set_expressions.test b/parser/testdata/corpus/sql/upsert/upsert_set_expressions.test new file mode 100644 index 0000000..1bcf65c --- /dev/null +++ b/parser/testdata/corpus/sql/upsert/upsert_set_expressions.test @@ -0,0 +1,20 @@ +# source: test/sql/upsert/upsert_set_expressions.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +insert into tbl VALUES + (1, 10, 1), + (2, 20, 1), + (3, 30, 2); +-- +ok +== +insert into tbl VALUES (3,5,1) ON CONFLICT (i) DO UPDATE SET k = 5; +-- +ok +== +insert into tbl VALUES (3,5,1) ON CONFLICT (i) DO UPDATE SET k = 1 + excluded.k; +-- +ok +== diff --git a/parser/testdata/corpus/sql/upsert/upsert_shorthand.test b/parser/testdata/corpus/sql/upsert/upsert_shorthand.test new file mode 100644 index 0000000..1eb6165 --- /dev/null +++ b/parser/testdata/corpus/sql/upsert/upsert_shorthand.test @@ -0,0 +1,37 @@ +# source: test/sql/upsert/upsert_shorthand.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +create table tbl (a integer, b integer unique); +-- +ok +== +insert into tbl values (1,2), (2,1); +-- +ok +== +insert into tbl values (1,2) on conflict do update set a = excluded.a; +-- +ok +== +insert or replace into tbl values (4,3) on conflict do nothing; +-- +error: Parser Error: You can not provide both OR REPLACE|IGNORE and an ON CONFLICT clause, please remove the first if you want to have more granular control +== +insert or ignore into tbl values (1,2), (2,1); +-- +ok +== +insert or replace into tbl values (5,2), (10,1); +-- +ok +== +create or replace table tbl (a integer unique, b integer unique); +-- +ok +== +insert or replace into tbl values (1,2); +-- +ok +== diff --git a/parser/testdata/corpus/sql/upsert/upsert_shorthand.test.metadata.json b/parser/testdata/corpus/sql/upsert/upsert_shorthand.test.metadata.json new file mode 100644 index 0000000..79a692f --- /dev/null +++ b/parser/testdata/corpus/sql/upsert/upsert_shorthand.test.metadata.json @@ -0,0 +1,5 @@ +{ + "todo": { + "cfb4db6177cc025a": "transformer-raised parser error: upstream rejects in the transformer, not the grammar; expected to clear as transformers land (milestones 3-5)" + } +} diff --git a/parser/testdata/corpus/sql/upsert/upsert_transaction.test b/parser/testdata/corpus/sql/upsert/upsert_transaction.test new file mode 100644 index 0000000..6961dff --- /dev/null +++ b/parser/testdata/corpus/sql/upsert/upsert_transaction.test @@ -0,0 +1,80 @@ +# source: test/sql/upsert/upsert_transaction.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +CREATE TABLE tbl ( + a SHORT PRIMARY KEY, + b SHORT +); +-- +ok +== +INSERT INTO tbl VALUES + (1, 2) +ON CONFLICT (a) DO UPDATE SET b = excluded.b; +-- +ok +== +INSERT INTO tbl VALUES + (1, 3) +ON CONFLICT (a) DO UPDATE SET b = excluded.b; +-- +ok +== +INSERT INTO tbl VALUES + (2, 1), + (3, 1), + (4, 1); +-- +ok +== +INSERT INTO tbl VALUES + (2, 1), + (3, 1), + (4, 1) +ON CONFLICT (a) DO NOTHING; +-- +ok +== +INSERT INTO tbl VALUES + (5, 0) +-- +ok +== +insert into tbl VALUES + (5, 0), + (5, 1) +ON CONFLICT (a) DO UPDATE SET + b = excluded.b; +-- +ok +== +INSERT INTO tbl VALUES (6,0); +-- +ok +== +INSERT INTO tbl VALUES (5,0), (6,0), (7,0) ON CONFLICT (a) DO UPDATE set b = excluded.b; +-- +ok +== +INSERT INTO tbl VALUES (-1, 0), (5,0), (6,0) ON CONFLICT (a) DO NOTHING; +-- +ok +== +CREATE OR REPLACE TABLE tbl (a SHORT PRIMARY KEY, b SHORT); +-- +ok +== +INSERT INTO tbl (select i, 0 from range(2500) tbl(i)); +-- +ok +== +select max(b) from tbl; +-- +ok +== +INSERT INTO tbl (select i, i from range(2500) tbl(i)) ON CONFLICT (a) DO UPDATE SET b = excluded.b; +-- +ok +== diff --git a/parser/testdata/corpus/sql/upsert/upsert_unique_null.test b/parser/testdata/corpus/sql/upsert/upsert_unique_null.test new file mode 100644 index 0000000..e8c2ec9 --- /dev/null +++ b/parser/testdata/corpus/sql/upsert/upsert_unique_null.test @@ -0,0 +1,20 @@ +# source: test/sql/upsert/upsert_unique_null.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +create or replace table tbl ( + a integer unique, + b integer +); +-- +ok +== +insert into tbl VALUES (3,2), (1,3); +-- +ok +== +insert into tbl(b) VALUES (5) ON CONFLICT (a) DO UPDATE SET b = 8; +-- +ok +== diff --git a/parser/testdata/corpus/sql/vacuum/test_analyze.test b/parser/testdata/corpus/sql/vacuum/test_analyze.test new file mode 100644 index 0000000..4f45aa3 --- /dev/null +++ b/parser/testdata/corpus/sql/vacuum/test_analyze.test @@ -0,0 +1,73 @@ +# source: test/sql/vacuum/test_analyze.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +ANALYZE; +-- +ok +== +ANALYSE; +-- +ok +== +VACUUM; +-- +ok +== +VACUUM ANALYSE; +-- +ok +== +VACUUM test; +-- +ok +== +ANALYZE test; +-- +ok +== +CREATE TABLE test (i INT, j INT); +-- +ok +== +ANALYSE test; +-- +ok +== +CREATE VIEW testview AS SELECT * FROM test; +-- +ok +== +ANALYZE testview; +-- +ok +== +INSERT INTO test SELECT range % 5000, range % 5000 FROM range(10000); +-- +ok +== +SELECT s.min, s.max, s.has_null, s.has_no_null, s.approx_unique FROM (SELECT stats(i) s FROM test LIMIT 1); +-- +ok +== +SELECT s.min, s.max, s.has_null, s.has_no_null, s.approx_unique FROM (SELECT stats(j) s FROM test LIMIT 1); +-- +ok +== +ANALYZE test(i); +-- +ok +== +VACUUM test(i); +-- +ok +== +SELECT s.approx_unique FROM (SELECT stats(i) s FROM test LIMIT 1); +-- +ok +== +SELECT s.approx_unique FROM (SELECT stats(j) s FROM test LIMIT 1); +-- +ok +== diff --git a/parser/testdata/corpus/sql/vacuum/vacuum_nested_types.test b/parser/testdata/corpus/sql/vacuum/vacuum_nested_types.test new file mode 100644 index 0000000..65930de --- /dev/null +++ b/parser/testdata/corpus/sql/vacuum/vacuum_nested_types.test @@ -0,0 +1,13 @@ +# source: test/sql/vacuum/vacuum_nested_types.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +CREATE TABLE test (x INT[], y AS (x || [100])); +-- +ok +== +INSERT INTO test SELECT [range % 5000] FROM range(10000); +-- +ok +== diff --git a/parser/testdata/corpus/sql/variables/test_variable_syntax.test b/parser/testdata/corpus/sql/variables/test_variable_syntax.test new file mode 100644 index 0000000..c71ac04 --- /dev/null +++ b/parser/testdata/corpus/sql/variables/test_variable_syntax.test @@ -0,0 +1,153 @@ +# source: test/sql/variables/test_variable_syntax.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +SET VARIABLE animal = 'duck' +-- +ok +== +SELECT $animal +-- +ok +== +SELECT $animal = getvariable('animal') +-- +ok +== +SET VARIABLE x = 42 +-- +ok +== +SELECT $x + 1 +-- +ok +== +SET VARIABLE greeting = 'hello' +-- +ok +== +SELECT $x, $greeting +-- +ok +== +SET VARIABLE animal = 'goose' +-- +ok +== +RESET VARIABLE animal +-- +ok +== +SELECT $does_not_exist +-- +ok +== +SET VARIABLE multiplier = 10 +-- +ok +== +PREPARE stmt_default AS SELECT $multiplier * $x AS result +-- +ok +== +EXECUTE stmt_default +-- +ok +== +EXECUTE stmt_default(multiplier := 2, x := 5) +-- +ok +== +EXECUTE stmt_default(multiplier := 3) +-- +ok +== +EXECUTE stmt_default(x := 1) +-- +ok +== +SET VARIABLE "1" = 5 +-- +ok +== +PREPARE stmt_positional_auto AS SELECT ? +-- +ok +== +EXECUTE stmt_positional_auto +-- +ok +== +EXECUTE stmt_positional_auto(7) +-- +ok +== +PREPARE stmt_positional_numbered AS SELECT $1 +-- +ok +== +EXECUTE stmt_positional_numbered +-- +ok +== +EXECUTE stmt_positional_numbered(8) +-- +ok +== +SET VARIABLE a1 = 9 +-- +ok +== +PREPARE stmt_named_digit AS SELECT $a1 +-- +ok +== +EXECUTE stmt_named_digit +-- +ok +== +SET VARIABLE multiplier = 100 +-- +ok +== +EXECUTE stmt_default(multiplier := 1, x := 1) +-- +ok +== +INSERT INTO t VALUES (1), (2), (3), (4), (5) +-- +ok +== +SET VARIABLE threshold = 3 +-- +ok +== +SELECT i FROM t WHERE i > $threshold ORDER BY i +-- +ok +== +SELECT count(*) FROM t WHERE i <= $threshold +-- +ok +== +PREPARE filter_stmt AS SELECT i FROM t WHERE i > $threshold ORDER BY i +-- +ok +== +EXECUTE filter_stmt +-- +ok +== +EXECUTE filter_stmt(threshold := 1) +-- +ok +== +SET VARIABLE limit_val = 2 +-- +ok +== +SELECT i FROM t ORDER BY i LIMIT $limit_val +-- +ok +== diff --git a/parser/testdata/corpus/sql/variables/test_variables.test b/parser/testdata/corpus/sql/variables/test_variables.test new file mode 100644 index 0000000..a2451ec --- /dev/null +++ b/parser/testdata/corpus/sql/variables/test_variables.test @@ -0,0 +1,61 @@ +# source: test/sql/variables/test_variables.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +SELECT GETVARIABLE('animal') +-- +ok +== +PREPARE v1 AS SELECT GETVARIABLE($1); +-- +ok +== +EXECUTE v1('animal'); +-- +ok +== +CREATE MACRO _(x) AS getvariable(x); +-- +ok +== +SELECT _('animal') +-- +ok +== +SET VARIABLE animal='bird' +-- +ok +== +FROM duckdb_variables(); +-- +ok +== +SHOW VARIABLES +-- +ok +== +CREATE TABLE animal_list(a VARCHAR); +-- +ok +== +INSERT INTO animal_list VALUES ('duck'), ('goose'); +-- +ok +== +SET VARIABLE animals=(SELECT LIST(a) FROM animal_list) +-- +ok +== +SELECT GETVARIABLE('animals') +-- +ok +== +SET VARIABLE animals=UNNEST([1,2,3]) +-- +ok +== +SELECT GETVARIABLE('xxx') +-- +ok +== diff --git a/parser/testdata/corpus/sql/variant/variant_comparator.test b/parser/testdata/corpus/sql/variant/variant_comparator.test new file mode 100644 index 0000000..5020296 --- /dev/null +++ b/parser/testdata/corpus/sql/variant/variant_comparator.test @@ -0,0 +1,182 @@ +# source: test/sql/variant/variant_comparator.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +SELECT v::INT FROM (VALUES (-123), (5), (-1), (100), (0)) t(v) +ORDER BY v::INT::VARIANT +-- +ok +== +SELECT v::INT FROM (VALUES (-123), (5), (-1), (100), (0)) t(v) +ORDER BY v::INT::VARIANT DESC +-- +ok +== +SELECT v FROM (VALUES ('nan'::DOUBLE), (1.5::DOUBLE), (-1.5::DOUBLE), ('-inf'::DOUBLE), ('inf'::DOUBLE), (0.0::DOUBLE)) t(v) +ORDER BY v::VARIANT +-- +ok +== +SELECT variant_comparator('-0.0'::DOUBLE::VARIANT) = variant_comparator('0.0'::DOUBLE::VARIANT) +-- +ok +== +SELECT v FROM (VALUES ('banana'), ('apple'), ('cherry')) t(v) +ORDER BY v::VARCHAR::VARIANT +-- +ok +== +SELECT variant_comparator({'b': 10, 'a': 1}::VARIANT) = variant_comparator({'a': 1, 'b': 10}::VARIANT) +-- +ok +== +SELECT variant_comparator({'a': 1, 'b': 10}::VARIANT) = variant_comparator({'a': 1, 'b': 11}::VARIANT) +-- +ok +== +SELECT v::INT[]::VARCHAR FROM (VALUES ([1,2,3]), ([1,2]), ([1,3]), ([1])) t(v) +ORDER BY v::INT[]::VARIANT +-- +ok +== +SELECT + variant_comparator(1::TINYINT::VARIANT) = variant_comparator(1::INTEGER::VARIANT), + variant_comparator(1::BIGINT::VARIANT) = variant_comparator(1::UINTEGER::VARIANT), + variant_comparator(1::HUGEINT::VARIANT) = variant_comparator(1::UTINYINT::VARIANT), + variant_comparator(1::INTEGER::VARIANT) = variant_comparator(1::UHUGEINT::VARIANT) +-- +ok +== +SELECT + variant_comparator(5::INTEGER::VARIANT) = variant_comparator(5.00::DECIMAL(5,2)::VARIANT), + variant_comparator(5::BIGINT::VARIANT) = variant_comparator(5::BIGNUM::VARIANT), + variant_comparator(5.00::DECIMAL(5,2)::VARIANT) = variant_comparator(5::BIGNUM::VARIANT) +-- +ok +== +SELECT v::VARCHAR FROM (VALUES + ((-100.5)::DECIMAL(5,1)::VARIANT), + (3::TINYINT::VARIANT), + (1000000000000000000000000000::BIGNUM::VARIANT), + (0::UTINYINT::VARIANT), + (1.5::DECIMAL(2,1)::VARIANT), + ((-128)::TINYINT::VARIANT), + (15::BIGINT::VARIANT) +) t(v) +ORDER BY v +-- +ok +== +SELECT (-100.5)::DECIMAL(5,1)::VARIANT > 0 +-- +ok +== +SELECT variant_comparator(1.5::FLOAT::VARIANT) = variant_comparator(1.5::DOUBLE::VARIANT) +-- +ok +== +SELECT variant_comparator(1::INTEGER::VARIANT) = variant_comparator(1.0::DOUBLE::VARIANT) +-- +ok +== +SELECT v FROM (VALUES (true), (false), (true), (false)) t(v) +ORDER BY v::BOOLEAN::VARIANT +-- +ok +== +SELECT v::VARCHAR FROM (VALUES + ('0'::BIT::VARIANT), + ('10101010'::BIT::VARIANT), + ('00'::BIT::VARIANT), + ('01'::BIT::VARIANT), + ('1'::BIT::VARIANT) +) t(v) +ORDER BY v +-- +ok +== +SELECT + variant_comparator('2020-01-01'::DATE::VARIANT) = variant_comparator('2020-01-01 00:00:00'::TIMESTAMP::VARIANT), + variant_comparator('2020-01-01 00:00:00'::TIMESTAMP_S::VARIANT) = variant_comparator('2020-01-01 00:00:00'::TIMESTAMP_MS::VARIANT), + variant_comparator('2020-01-01 00:00:00'::TIMESTAMP::VARIANT) = variant_comparator('2020-01-01 00:00:00'::TIMESTAMP_NS::VARIANT) +-- +ok +== +SELECT v::VARCHAR FROM (VALUES + ('2019-12-31'::DATE::VARIANT), + ('2020-01-01 00:00:01'::TIMESTAMP_MS::VARIANT), + ('2020-01-01 00:00:00'::TIMESTAMP_S::VARIANT), + ('2020-01-02'::DATE::VARIANT), + ('2020-01-01 00:00:00.5'::TIMESTAMP_NS::VARIANT) +) t(v) +ORDER BY v +-- +ok +== +SELECT variant_comparator('12:00:00'::TIME::VARIANT) = variant_comparator('12:00:00'::TIME_NS::VARIANT) +-- +ok +== +SELECT v::VARCHAR FROM (VALUES + ('12:00:01'::TIME::VARIANT), + ('00:00:00'::TIME_NS::VARIANT), + ('12:00:00.5'::TIME_NS::VARIANT) +) t(v) +ORDER BY v +-- +ok +== +SELECT + variant_comparator('2020-01-01 00:00:00'::TIMESTAMP::VARIANT) = variant_comparator('2020-01-01 00:00:00+00'::TIMESTAMPTZ::VARIANT), + variant_comparator('12:00:00'::TIME::VARIANT) = variant_comparator('2020-01-01 12:00:00'::TIMESTAMP::VARIANT), + variant_comparator('12:00:00'::TIME::VARIANT) = variant_comparator('12:00:00+00'::TIMETZ::VARIANT) +-- +ok +== +SELECT variant_comparator(NULL::VARIANT) IS NULL +-- +ok +== +WITH variants(v) AS (VALUES + (1::INTEGER::VARIANT), + (255::INTEGER::VARIANT), + (256::INTEGER::VARIANT), + (NULL::VARIANT) +) +SELECT min(v)::VARCHAR, max(v)::VARCHAR FROM variants +-- +ok +== +WITH variants(v) AS (VALUES + (1::INTEGER::VARIANT), + (255::INTEGER::VARIANT), + (256::INTEGER::VARIANT), + (NULL::VARIANT) +) +SELECT min(v, 3)::VARCHAR, max(v, 3)::VARCHAR FROM variants +-- +ok +== +WITH variants(v) AS (VALUES + (5::TINYINT::VARIANT), + (5.00::DECIMAL(5,2)::VARIANT), + ((-1)::BIGINT::VARIANT), + (10::BIGNUM::VARIANT) +) +SELECT min(v)::VARCHAR, max(v)::VARCHAR FROM variants +-- +ok +== +WITH variants(v) AS (VALUES + (1::INTEGER::VARIANT), + (255::INTEGER::VARIANT), + (256::INTEGER::VARIANT) +) +SELECT + finalize(min(v) EXPORT_STATE)::VARCHAR, + finalize(max(v) EXPORT_STATE)::VARCHAR +FROM variants +-- +ok +== diff --git a/parser/testdata/corpus/sql/vector_types/list_vector_types.test b/parser/testdata/corpus/sql/vector_types/list_vector_types.test new file mode 100644 index 0000000..af0a5be --- /dev/null +++ b/parser/testdata/corpus/sql/vector_types/list_vector_types.test @@ -0,0 +1,65 @@ +# source: test/sql/vector_types/list_vector_types.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +SELECT * FROM test_vector_types(NULL::INT[], all_flat={all_flat}); +-- +error: Parser Error: syntax error at or near "}" +== +SELECT val[0] FROM test_vector_types(NULL::INT[], all_flat={all_flat}) t(val); +-- +error: Parser Error: syntax error at or near "}" +== +SELECT min(val), max(val) FROM (SELECT row_number() OVER () AS rownum, val FROM test_vector_types(NULL::INT[], all_flat={all_flat}) t(val)) where rownum%2=1; +-- +error: Parser Error: syntax error at or near "}" +== +SELECT min(val), max(val) FROM test_vector_types(NULL::INT[], all_flat={all_flat}) t(val); +-- +error: Parser Error: syntax error at or near "}" +== +SELECT count(distinct val) FROM test_vector_types(NULL::INT[], all_flat={all_flat}) t(val); +-- +error: Parser Error: syntax error at or near "}" +== +SELECT val, count(*) FROM test_vector_types(NULL::INT[], all_flat={all_flat}) t(val) group by val order by all; +-- +error: Parser Error: syntax error at or near "}" +== +SELECT * FROM test_vector_types(NULL::INT[], all_flat={all_flat}) t(val) ORDER BY 1; +-- +error: Parser Error: syntax error at or near "}" +== +SELECT {'a': val, 'b': val} FROM test_vector_types(NULL::INT[], all_flat={all_flat}) t(val) +-- +error: Parser Error: syntax error at or near "}" +== +SELECT [NULL, val, NULL, val] FROM test_vector_types(NULL::INT[], all_flat={all_flat}) t(val) +-- +error: Parser Error: syntax error at or near "}" +== +SELECT list(val) FROM test_vector_types(NULL::INT[], all_flat={all_flat}) t(val) +-- +error: Parser Error: syntax error at or near "}" +== +SELECT val IS NOT DISTINCT FROM val FROM test_vector_types(NULL::INT[], all_flat={all_flat}) t(val) +-- +error: Parser Error: syntax error at or near "}" +== +SELECT val IS DISTINCT FROM val FROM test_vector_types(NULL::INT[], all_flat={all_flat}) t(val) +-- +error: Parser Error: syntax error at or near "}" +== +SELECT val=val FROM test_vector_types(NULL::INT[], all_flat={all_flat}) t(val) +-- +error: Parser Error: syntax error at or near "}" +== +SELECT val<>val FROM test_vector_types(NULL::INT[], all_flat={all_flat}) t(val) +-- +error: Parser Error: syntax error at or near "}" +== +SELECT * FROM test_vector_types(NULL::INT[], all_flat={all_flat}) t(val) JOIN test_vector_types(NULL::INT[], all_flat={all_flat}) t2(val) USING (val) +-- +error: Parser Error: syntax error at or near "}" +== diff --git a/parser/testdata/corpus/sql/vector_types/vector_types_errors.test b/parser/testdata/corpus/sql/vector_types/vector_types_errors.test new file mode 100644 index 0000000..ad96d83 --- /dev/null +++ b/parser/testdata/corpus/sql/vector_types/vector_types_errors.test @@ -0,0 +1,13 @@ +# source: test/sql/vector_types/vector_types_errors.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +FROM test_vector_types(NULL::VARIANT); +-- +ok +== +FROM test_vector_types({a: 1, b: 2}::VARIANT); +-- +ok +== diff --git a/parser/testdata/corpus/sql/window/test_basic_window.test b/parser/testdata/corpus/sql/window/test_basic_window.test new file mode 100644 index 0000000..5f389fe --- /dev/null +++ b/parser/testdata/corpus/sql/window/test_basic_window.test @@ -0,0 +1,114 @@ +# source: test/sql/window/test_basic_window.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +CREATE TABLE empsalary (depname varchar, empno bigint, salary int, enroll_date date) +-- +ok +== +INSERT INTO empsalary VALUES ('develop', 10, 5200, '2007-08-01'), ('sales', 1, 5000, '2006-10-01'), ('personnel', 5, 3500, '2007-12-10'), ('sales', 4, 4800, '2007-08-08'), ('personnel', 2, 3900, '2006-12-23'), ('develop', 7, 4200, '2008-01-01'), ('develop', 9, 4500, '2008-01-01'), ('sales', 3, 4800, '2007-08-01'), ('develop', 8, 6000, '2006-10-01'), ('develop', 11, 5200, '2007-08-15') +-- +ok +== +SELECT depname, empno, salary, sum(salary) OVER (PARTITION BY depname ORDER BY empno) FROM empsalary ORDER BY depname, empno +-- +ok +== +SELECT sum(salary) OVER (PARTITION BY depname ORDER BY salary) ss FROM empsalary ORDER BY depname, ss +-- +ok +== +SELECT row_number() OVER (PARTITION BY depname ORDER BY salary) rn FROM empsalary ORDER BY depname, rn +-- +ok +== +SELECT empno, first_value(empno) OVER (PARTITION BY depname ORDER BY empno) fv FROM empsalary ORDER BY 2 DESC, 1 ASC +-- +ok +== +SELECT depname, empno, + last_value(empno) OVER ( + PARTITION BY depname ORDER BY empno ASC + ROWS BETWEEN CURRENT ROW AND UNBOUNDED FOLLOWING + ) fv +FROM empsalary +ORDER BY 1, 2 +-- +ok +== +SELECT depname, salary, dense_rank() OVER (PARTITION BY depname ORDER BY salary) FROM empsalary order by depname, salary +-- +ok +== +SELECT depname, salary, rank() OVER (PARTITION BY depname ORDER BY salary) FROM empsalary order by depname, salary +-- +ok +== +SELECT depname, min(salary) OVER (PARTITION BY depname ORDER BY salary, empno) m1, max(salary) OVER (PARTITION BY depname ORDER BY salary, empno) m2, AVG(salary) OVER (PARTITION BY depname ORDER BY salary, empno) m3 FROM empsalary ORDER BY depname, empno +-- +ok +== +SELECT depname, STDDEV_POP(salary) OVER (PARTITION BY depname ORDER BY salary, empno) s FROM empsalary ORDER BY depname, empno +-- +ok +== +SELECT depname, COVAR_POP(salary, empno) OVER (PARTITION BY depname ORDER BY salary, empno) c FROM empsalary ORDER BY depname, empno +-- +ok +== +WITH t AS ( + SELECT i, CASE WHEN i % 5 = 0 THEN NULL ELSE i % 7 END AS p, i % 3 AS q + FROM range(10000) tbl(i) +), w AS ( + SELECT i, p, q, count(*) OVER (PARTITION BY p, q) AS c + FROM t +), g AS ( + SELECT p, q, count(*) AS c + FROM t + GROUP BY ALL +) +SELECT count(*), sum(CASE WHEN w.c = g.c THEN 1 ELSE 0 END) +FROM w +JOIN g ON w.p IS NOT DISTINCT FROM g.p AND w.q = g.q +-- +ok +== +WITH t AS ( + SELECT + i, + CASE WHEN i % 11 = 0 THEN NULL ELSE 'grp_' || (i % 17)::VARCHAR END AS p, + CASE WHEN i % 13 = 0 THEN NULL ELSE 'tag_' || (i % 5)::VARCHAR END AS q + FROM range(3000) tbl(i) +), w AS ( + SELECT i, p, q, count(*) OVER (PARTITION BY p, q) AS c + FROM t +), g AS ( + SELECT p, q, count(*) AS c + FROM t + GROUP BY ALL +) +SELECT count(*), sum(CASE WHEN w.c = g.c THEN 1 ELSE 0 END) +FROM w +JOIN g ON w.p IS NOT DISTINCT FROM g.p AND w.q IS NOT DISTINCT FROM g.q +-- +ok +== +WITH t AS ( + SELECT i, i % 5 AS p + FROM range(1000) tbl(i) +), w AS ( + SELECT i, p, row_number() OVER (PARTITION BY p ORDER BY i DESC) AS rn + FROM t +), g AS ( + SELECT p, max(i) AS max_i + FROM t + GROUP BY p +) +SELECT count(*) +FROM w +JOIN g USING (p) +WHERE rn = 1 AND i = max_i +-- +ok +== diff --git a/parser/testdata/corpus/sql/window/test_boundary_expr.test b/parser/testdata/corpus/sql/window/test_boundary_expr.test new file mode 100644 index 0000000..4bc2612 --- /dev/null +++ b/parser/testdata/corpus/sql/window/test_boundary_expr.test @@ -0,0 +1,119 @@ +# source: test/sql/window/test_boundary_expr.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +CREATE TABLE tenk1 ( unique1 int4, unique2 int4, two int4, four int4, ten int4, twenty int4, hundred int4, thousand int4, twothousand int4, fivethous int4, tenthous int4, odd int4, even int4, stringu1 string, stringu2 string, string4 string ) +-- +ok +== +insert into tenk1 values (4, 1621, 0, 0, 4, 4, 4, 4, 4, 4, 4, 8 ,9 ,'EAAAAA', 'JKCAAA', 'HHHHxx'), (2, 2716, 0, 2, 2, 2, 2, 2, 2, 2, 2, 4 ,5 ,'CAAAAA', 'MAEAAA', 'AAAAxx'), (1, 2838, 1, 1, 1, 1, 1, 1, 1, 1, 1, 2 ,3 ,'BAAAAA', 'EFEAAA', 'OOOOxx'), (6, 2855, 0, 2, 6, 6, 6, 6, 6, 6, 6, 12 ,13 ,'GAAAAA', 'VFEAAA', 'VVVVxx'), (9, 4463, 1, 1, 9, 9, 9, 9, 9, 9, 9, 18 ,19 ,'JAAAAA', 'RPGAAA', 'VVVVxx'),(8, 5435, 0, 0, 8, 8, 8, 8, 8, 8, 8, 16 ,17 ,'IAAAAA', 'BBIAAA', 'VVVVxx'), (5, 5557, 1, 1, 5, 5, 5, 5, 5, 5, 5, 10 ,11,'FAAAAA', 'TFIAAA', 'HHHHxx'), (3, 5679, 1, 3, 3, 3, 3, 3, 3, 3, 3, 6 ,7 ,'DAAAAA', 'LKIAAA', 'VVVVxx'), (7, 8518, 1,3, 7, 7, 7, 7, 7, 7, 7, 14 ,15 ,'HAAAAA', 'QPMAAA', 'OOOOxx'), (0, 9998, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 ,1 ,'AAAAAA','OUOAAA', 'OOOOxx') +-- +ok +== +SELECT sum(unique1) over (order by unique1 rows between 2 preceding and 2 following) su FROM tenk1 order by unique1 +-- +ok +== +SELECT sum(unique1) over (order by unique1 rows between 2 preceding and 1 preceding) su FROM tenk1 order by unique1 +-- +ok +== +SELECT sum(unique1) over (order by unique1 rows between 1 following and 3 following) su FROM tenk1 order by unique1 +-- +ok +== +SELECT sum(unique1) over (order by unique1 rows between unbounded preceding and 1 following) su FROM tenk1 order by unique1 +-- +ok +== +SELECT sum(unique1) over (order by unique1 rows between 5 following and 10 following) su FROM tenk1 order by unique1 +-- +ok +== +create table issue1472 (permno real, date date, ret real); +-- +ok +== +insert into issue1472 values + (10000.0, '1986-02-28'::date, -0.2571428716182709), + (10000.0, '1986-03-31'::date, 0.36538460850715637), + (10000.0, '1986-04-30'::date, -0.09859155118465424), + (10000.0, '1986-05-30'::date, -0.22265625), + (10000.0, '1986-06-30'::date, -0.005025125574320555) +; +-- +ok +== +select permno, + sum(log(ret+1)) over (PARTITION BY permno ORDER BY date rows between 12 preceding and 2 preceding), + ret +from issue1472 +ORDER BY permno, date; +-- +ok +== +create table issue1697 as + select mod(b, 100) as a, b from (select b from range(10000) tbl(b)) t +-- +ok +== +select avg(a) over ( + order by b asc + rows between mod(b * 1023, 11) preceding and 23 - mod(b * 1023, 11) following) +from issue1697 +-- +ok +== +WITH t(id, k) AS ( + VALUES + (1, 1), + (2, 1) +) +SELECT + id, + SUM(1) OVER ( + ORDER BY k + RANGE BETWEEN CURRENT ROW AND CURRENT ROW + ) AS current_row_frame, + SUM(1) OVER ( + ORDER BY k + RANGE BETWEEN 0 PRECEDING AND 0 PRECEDING + ) AS zero_preceding_frame, + SUM(1) OVER ( + ORDER BY k + RANGE BETWEEN 0 FOLLOWING AND 0 FOLLOWING + ) AS zero_following_frame +FROM t +ORDER BY id; +-- +ok +== +SELECT COUNT(*) OVER ( + ORDER BY id ROWS BETWEEN off PRECEDING AND CURRENT ROW +) +FROM (VALUES (1, NULL::INTEGER)) AS src(id, off); +-- +ok +== +SELECT COUNT(*) OVER ( + ORDER BY id ROWS BETWEEN off FOLLOWING AND UNBOUNDED FOLLOWING +) +FROM (VALUES (1, NULL::INTEGER)) AS src(id, off); +-- +ok +== +SELECT COUNT(*) OVER ( + ORDER BY id ROWS BETWEEN UNBOUNDED PRECEDING AND off PRECEDING +) +FROM (VALUES (1, NULL::INTEGER)) AS src(id, off); +-- +ok +== +SELECT COUNT(*) OVER ( + ORDER BY id ROWS BETWEEN CURRENT ROW AND off FOLLOWING +) +FROM (VALUES (1, NULL::INTEGER)) AS src(id, off); +-- +ok +== diff --git a/parser/testdata/corpus/sql/window/test_constant_orderby.test b/parser/testdata/corpus/sql/window/test_constant_orderby.test new file mode 100644 index 0000000..84dab5b --- /dev/null +++ b/parser/testdata/corpus/sql/window/test_constant_orderby.test @@ -0,0 +1,17 @@ +# source: test/sql/window/test_constant_orderby.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +SELECT + l_orderkey, + l_shipmode, + l_linenumber, + mode(l_linenumber ORDER BY l_linenumber DESC) over w AS l_mode, +FROM lineitem +WINDOW w AS (partition by l_shipmode) +ORDER BY ALL +LIMIT 10 +-- +ok +== diff --git a/parser/testdata/corpus/sql/window/test_cume_dist_orderby.test b/parser/testdata/corpus/sql/window/test_cume_dist_orderby.test new file mode 100644 index 0000000..3999a01 --- /dev/null +++ b/parser/testdata/corpus/sql/window/test_cume_dist_orderby.test @@ -0,0 +1,59 @@ +# source: test/sql/window/test_cume_dist_orderby.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +SELECT + i, + (i * 29) % 11 AS outside, + i // 2 AS inside, + cume_dist(ORDER BY inside DESC) OVER w AS cd, +FROM range(10) tbl(i) +WINDOW w AS ( + ORDER BY outside +) +ORDER BY inside DESC, i +-- +ok +== +SELECT + i, + i // 2 AS inside, + cume_dist(ORDER BY i // 2) OVER w AS cd, +FROM range(10) tbl(i) +WINDOW w AS ( + ORDER BY i // 2 + ROWS BETWEEN 3 PRECEDING AND 3 FOLLOWING +) +ORDER BY 1; +-- +ok +== +WITH t(id) AS ( + VALUES (1), (2), (3) +) +SELECT + id, + CUME_DIST(ORDER BY id) OVER ( + ORDER BY id + ROWS BETWEEN 2 FOLLOWING AND 2 FOLLOWING + ) AS actual, + 0.0 AS expected +FROM t +ORDER BY id; +-- +ok +== +SELECT + id, + k, + cume_dist(ORDER BY k) OVER w AS cd, +FROM (VALUES (1, 1), (2, 1), (3, 2)) tbl(id, k) +WINDOW w AS ( + ORDER BY k, id + ROWS BETWEEN UNBOUNDED PRECEDING AND UNBOUNDED FOLLOWING +) +ORDER BY id +-- +ok +== diff --git a/parser/testdata/corpus/sql/window/test_dense_rank.test b/parser/testdata/corpus/sql/window/test_dense_rank.test new file mode 100644 index 0000000..6f6e750 --- /dev/null +++ b/parser/testdata/corpus/sql/window/test_dense_rank.test @@ -0,0 +1,189 @@ +# source: test/sql/window/test_dense_rank.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +WITH t AS ( + SELECT i, DENSE_RANK() OVER (ORDER BY i % 50) AS d + FROM range(3000) tbl(i) +), w AS ( + SELECT d, COUNT(*) as c + FROM t + GROUP BY ALL +) +SELECT COUNT(*), MIN(d), MAX(d), MIN(c), MAX(c) +FROM w +-- +ok +== +WITH t AS ( + SELECT i, DENSE_RANK() OVER (PARTITION BY i // 3000 ORDER BY i % 50) AS d + FROM range(9000) tbl(i) +), w AS ( + SELECT d, COUNT(*) as c + FROM t + GROUP BY ALL +) +SELECT COUNT(*), MIN(d), MAX(d), MIN(c), MAX(c) +FROM w +-- +ok +== +CREATE TABLE issue9416(idx VARCHAR, source VARCHAR, project VARCHAR, specimen VARCHAR, sample_id VARCHAR); +-- +ok +== +INSERT INTO issue9416 VALUES + ('197bc9528efbc76a523d796b749a69f6','json','0bf0b46fb9c01829c55e','e4de2878',NULL), + ('0f62e5fa923495012f3863e7ea05f566','json','d98171d6fe06b3','440ce2bf','9fc93ee404d6bccb69'), + ('9b15a709814582ecbec00d8397852865','json','24ed1657','c3d1f46c','06c234e260a7484'), + ('8569d67b0ccbbf316b360be3bb4fe418','json','d98171d6fe06b3','14875a37','3416100f300c7bd'), + ('d2f02b24d59696079e3d649b403fbb22','json','82e092e750a','e7deeb7f','6d8dded6f044'), + ('60a2b8898440b2f4531268e27b7d3495','json','f657d34b6','46afa8e7','7bb186ce013b'), + ('5aa1982136f3991ad5ed537793d40a0f','json','d58e2b351518','a98b2b0c','ac594941b5d9'), + ('cc70cc91af828c833b5bf20785b91918','json','4953ff4b','8450467c','d1509d0abde0'), + ('7cf99d6372183aab6a9a22205e1b0e96','json','14b5b262c52400','e7deeb7f','6d8dded6f044'), + ('3cf6f7ec6609c6456f6587c441310ace','json','0c155a1ba5','e984dd5b','d374014b756d'), + ('e1223eb2cc51161d32495ff0ad8b34ae','json','f05964c5c4','4f3354c3','10eebe991cf9'), + ('7b8b64bac7c7dc692d1fe76f6eeff2bb','json','6bd9ce7f1d8','492f260c','314d3e061be7'), + ('7b8b64bac7c7dc692d1fe76f6eeff2bb','json','249f40c5d97','492f260c','314d3e061be7'), + ('cd29186ef73b658079d848fca1ebe839','json','6bd9ce7f1d8','492f260c','314d3e061be7'), + ('d67a74eb29392e06b97161d9f3121705','json','0bf0b46fb9c01829c55e','2d28e9ee','0deb6a6b189d309'), + ('9dcc686429408e3319161c39b008f705','json','24ed1657','8450467c','d1509d0abde0'), + ('11788bb5a0477c1bfb31a9f33af80c40','json','4ea4e97b39c4b','4f3354c3','10eebe991cf9'), + ('59bceab687b4004dbeed6291f07af37d','json','6d00cb7409','4f3354c3','10eebe991cf9'), + ('76b23210847e653b6060104da0e86d5b','json','24ed1657','22f4528f','7632cf8f4849404'), + ('2605143ff05ae1ce66b1cc70f80fe53d','json','249f40c5d97','b93c50ce','be70d8b88fff'), + ('1a1864b5f4ed27acfbbf6e5069348a5a','json','6bd9ce7f1d8','6c082f61','ee109745d498'), + ('92200c3306e18e53a41550c6306a3ee4','json','8271fea91bc236c','d6f24fd5',NULL), + ('dd39e08b282cf4a6429bcfefaa2af071','json','249f40c5d97','1396d8b6','3826343264acc9'), + ('3afcae2318313f112b62536fa160678d','json','24ed1657','5311f290','129c0a0fd3e82a8'), + ('3afcae2318313f112b62536fa160678d','json','24ed1657','08b8de7c543d','129c0a0fd3e82a8'), + ('3afcae2318313f112b62536fa160678d','json','24ed1657','ce001fa3a2a4','129c0a0fd3e82a8'), + ('79acd6669071e95a5b2fe5456216ab32','json','24ed1657','5311f290','129c0a0fd3e82a8'), + ('79acd6669071e95a5b2fe5456216ab32','json','24ed1657','08b8de7c543d','129c0a0fd3e82a8'), + ('79acd6669071e95a5b2fe5456216ab32','json','24ed1657','ce001fa3a2a4','129c0a0fd3e82a8'), + ('d0a7e9d3eda115120021a895a81db8be','json','24ed1657','5311f290','129c0a0fd3e82a8'), + ('d0a7e9d3eda115120021a895a81db8be','json','24ed1657','08b8de7c543d','129c0a0fd3e82a8'), + ('d0a7e9d3eda115120021a895a81db8be','json','24ed1657','ce001fa3a2a4','129c0a0fd3e82a8'), + ('a59a3a4ad8d2ab867c9b830974588645','json','24ed1657','5311f290','129c0a0fd3e82a8'), + ('a59a3a4ad8d2ab867c9b830974588645','json','24ed1657','08b8de7c543d','129c0a0fd3e82a8'), + ('a59a3a4ad8d2ab867c9b830974588645','json','24ed1657','ce001fa3a2a4','129c0a0fd3e82a8'), + ('6193ffd18b0da96e80e2a38baac9a7e4','json','14b5b262c52400','3c03d64c34','1b5cfdd6a5de'), + ('6193ffd18b0da96e80e2a38baac9a7e4','rprt','1a5cf3833',NULL,'1b5cfdd6a5de'), + ('ecf1739fed72151784dab88dbe2f2aa9','json','14b5b262c52400','3c03d64c34','1b5cfdd6a5de'), + ('ecf1739fed72151784dab88dbe2f2aa9','rprt','1a5cf3833',NULL,'1b5cfdd6a5de'), + ('204cd9b011e2cab64bcdf1b3d668a9ef','json','7d9a79908fcc','8274fbb94a','5a928f187ed19b2'), + ('c8360bd0e28ea5bbffd66e76886bbccb','json','d6b3921920','a63d8','0e06e1f9f6580fb'), + ('c8360bd0e28ea5bbffd66e76886bbccb','rprt','d6b3921920',NULL,'0e06e1f9f6580fb'), + ('c6eb00fb5a023557439a9b898c7cc3ea','json','d6b3921920','a63d8','f891b965f2561d9'), + ('c6eb00fb5a023557439a9b898c7cc3ea','rprt','d6b3921920',NULL,'f891b965f2561d9'), + ('f2dacff642ad3f805229d7e976810f1d','rprt','d6b3921920',NULL,'6817ec9d3b7b726'), + ('8def2cd0450b56c3e0c9bb6da67b842b','rprt','d6b3921920',NULL,'6817ec9d3b7b726'), + ('6db7ef8b4a9e41bb41971dced546131b','rprt','d6b3921920',NULL,'bc32d9059dde8ba'), + ('4524efca2bf1aa0565f03a9aaf9771d2','json','14b5b262c52400','cf3b1945e2','5c0157ef5367'), + ('6f63a84401944c32b9a329af08d6473c','json','8b736466c7adc6','d0acb13cd9','d734a9d755ef6276'), + ('8ef4bc6ac39585b2ec45218ad1d06464','rprt','67b7fd541ae7e','c117f7db3b','cf94993616ef'), + ('01899ea72c60bd5e614132c99fffd48e','json','14b5b262c52400','2a50feb98b','eead79cf6ef0'), + ('b1407bdda20fad91cb9072c08c5c23a8','json','3608008ba4c9','e4840a8e75','139e04ae890beb8'), + ('2091d4939af33d3911b057ed446367f1','rprt','6522e2c00f5b87d5b','f2b8d4d02d','23de2ff19778'), + ('81f36975a777a353b0861874e03d0f95','rprt','14b5b262c52400','e05f1a1ec2','acf577df3840'), + ('5b3961bf4255e83ee1e7e795e14c8119','rprt','b9cbf09f3366297','1109e52066','47afce7dacb5'), + ('0b53312f91b22db1bf7c18251a199d36','json','14b5b262c52400','c8561fe22f','6e30638eaaf6'), + ('e277322f26cd477bae52240c46678286','json','14b5b262c52400','d185c22b68','42a062d827c'), + ('71150d87b4e7852448a524e03817efc4','json','bb87c32c765d1','3e60145162','8e072527a7cf82d'), + ('1039fc7de3c12dad1e7d3bd9e73827de','json','d6b3921920','65c0a3e2a9','9ff56f55c850390'), + ('3c67c976516f8a5a1044ad9a8935cf02','rprt','bdc5a7fd6ca','dfc9fd824b','bfbef96674e73829'), + ('56ab3e25a40913b6e961cff217a83750','json','24ed1657','724e7df1','fc81c8a39465'), + ('5f726fff8b638d0ac1ba9dcb9a4037be','json','14b5b262c52400','b1bddeb160','1e2b4afd36f'), + ('4448f84ff7496b6d1a0d311838be238d','json','14b5b262c52400','50a45c4db0','83ef23a7f827'), + ('216414a29307f00aecfc9e5cba7ac821','json','c05bced980e6381','949ae57ce4','05f77bf546f'), + ('5327f9ec2dc334bde0222b52de4d65ef','json','67b7fd541ae7e','8aea85ada0','c0048c2b539e'), + ('d3c9b836ce61a53daf39d813c97a36b9','json','249f40c5d97','35d05d68','db4853c8a41'), + ('6d4affc7041c65d0f56551f4d4370a7d','rprt','d6b3921920',NULL,'84624aa9753a681'), + ('caab5b21770a321067fb2052c2eea792','rprt','14b5b262c52400','8b8da80085','d427763bd611'), + ('eecdf1e7e87c04c56328b0d37fb06349','json','14b5b262c52400','3bfabeb9d9','7c613b2d73cc'), + ('b533aa0c674433a09cee8555b35b7ca6','json','9c3b3335f959','f9d8c52aa2','d082926c94a8a60'), + ('6dfe749835d6a895a3a116580dc4217a','rprt','14b5b262c52400','6dd9b2d650','b3d88f29e3e5'), + ('6150133032c53a35ce28c6308931137d','rprt','b04a2a75f0c4a9','9f3026e2','a1bcb7232a50'), + ('47e77fd2d027114df5ac9daa17237934','json','b04a2a75f0c4a9','6e07291b','564347d748e0'), + ('0d66c06fd2a29247b4bc798591f15cbc','rprt','093a316f6c9c0856b','ebcca53e20','4c767b833785b25b072e'), + ('997371252646aed7ac3fa43da1f69ef2','rprt','d6b3921920','5be2b052','612fc8691ec7852'), + ('e963d96d34e35ba06cea05ff78e84e41','json','33debfe262d7','114a0c85','f6d1ea3976b0a03'), + ('f50959f1079cd24b7dcb6370d8e63344','rprt','1a5cf3833',NULL,'a1b77be48d05'), + ('4e44d4c96d3d26290d13e5f9bc14d8dd','rprt','67b7fd541ae7e','c117f7db3b','18d653ec3c0'), + ('797c887ce1edab55fefaa7a690065843','rprt','14b5b262c52400','22efccc05e','7a9348e1538f'), + ('ffbc9337bb6f6c7d43ab32a9398474da','rprt','b04a2a75f0c4a9','6e07291b','564347d748e0'), + ('3ac840afe9d088e5c490ed4cd48d2269','json','67b7fd541ae7e','ffaa35275c','c58867f82d10'), + ('72cedda51ecfb6678f4e3a3956066311','json','402423768220bca1f','9a28c664','eed0f9697609'), + ('92488464899a3b31ea1bc61a2ebc2013','json','14b5b262c52400','1a10cdadd7','ee4cacc7ce10'), + ('c85e95cfec9f42fff138d498101cd7ea','json','14b5b262c52400','f1b4cf931e','3b4f71a3ddde'), + ('399edac903f69ac760fa36a8b68cdfb0','rprt','67b7fd541ae7e','a539fb31c3','4c920da298bd'), + ('a223c0e6017570f5a1039003e767e692','json','67b7fd541ae7e','7bfb6b3721','5ae5c617d126'), + ('1503860c3c6391385807ab9b6cdd1934','json','67b7fd541ae7e','4936ad40b0','94fbcb7cd167'), + ('6f269d7f6cf850a9cd0d4d804eef24a0','rprt','14b5b262c52400','943c04e54b','cc79fc503d80'), + ('732a12aa44489aeef05b614a1e8dbd2d','rprt','14b5b262c52400','a2335b4159','45e7e30aa621'), + ('b876617f4b7bdb3abc694da31b09d838','rprt','14b5b262c52400','93a91bf863','b824ed7a5f67'), + ('fd63b4bf7ee546b2c0c55200ae968872','rprt','67b7fd541ae7e','62cd05887b','9c1940a4032a'), + ('50a00a903778fb65ef92a736bd9fe262','json','67b7fd541ae7e','7e81c8b2f3','00eb98252668113'), + ('053891bc9d52d48986302c5e13adf276','json','67b7fd541ae7e','a1762f3d79','e06b767a6ed2'), + ('f537b4d753bb441436ff8d73af423691','json','efdfcef7da0','98c6db64','4c9b34c566ae'), + ('8dc4f5e5bb2663f09218b369be5bf524','rprt','03b000865c98e','f31af55c63','a02983ae108ced0449cb4'), + ('d69d899aba162c4f14593f9c6a062bdd','rprt','67b7fd541ae7e','7bfb6b3721','c32aa62b7207'), + ('88b784ce065a5cf2360e7616c4b3f7f6','json','62769691cd4e','ebdf919e','37e16f2e5319832f'), + ('cdda71f56ad05dae20b1e22ee19b227b','rprt','67b7fd541ae7e','17d7c8f29a','21c1f8fadde3'), + ('5e1d22685085f0d85553eb2b7b4155a6','rprt','14b5b262c52400','737542af23','092dcc6fdef7'), + ('7f387dad4f9bef7c2301977590cec0f2','json','67b7fd541ae7e','09591aea45','ab584388528d'), + ('a83145a960baebcf1bff9c462f8489e5','json','14b5b262c52400','2ea6e3e6fb','4fe26b0e2203'), + ('4d7a36c58267592481297676d57c9e84','json','581d813a840d3d6391','54239e1a8e','232d99055474'), + ('31f0b71e67e64d42079098a53374e094','json','14b5b262c52400','a43ad72889','7d702f310fbe'), + ('6ddc75b9771136d9a6366aaa5d951f1a','rprt','14b5b262c52400','75263a6f0c','7309f2e8695a'), + ('4595e59a1225042680842f63736481d4','json','14b5b262c52400','44f5fdb8b1','9c2c14ec6924'), + ('66c1f24117ee34a1b3d587a22047fad1','rprt','14b5b262c52400','bfe39ca56f','b49aa5fad4d5'), + ('37027bc152a681b87d5ffb9a37c325a5','rprt','efdfcef7da0','9f1668a8','682ff39acb86'), + ('c3b46edd87eb14842b6444c001ae6456','json','3608008ba4c9','f650844d13','5326d2a94e28825'), + ('82beaa8e1c8c482d792f601b37a40b8a','rprt','14b5b262c52400','c86e0093c2','5ae33221b17'), + ('333aa3a45ab3f01ad95b2a312870aa1e','json','14b5b262c52400','57f7ec0030','8545146eeba5'), + ('16b64ffcb514bf69c6936eaf4e86889e','rprt','14b5b262c52400','2a50feb98b','64bb80701037'), + ('01d42ee5515c3b500018e723278e27c1','json','67b7fd541ae7e','958967a48a','97453818ba51'), + ('2a031d3176c7d4f19c532e5d2e7b411e','rprt','14b5b262c52400','164c3bb214','3389fe2776be'), + ('8d3b5d415e43df82b6b560effeb6ee80','json','67b7fd541ae7e','9205577d7c','bc96b93082c6'), + ('339690825234f32fd7da02fd567d5109','rprt','b04a2a75f0c4a9','9f3026e2','a1bcb7232a50'), + ('13c6d4555db02b653d8f2b5ce06bb143','json','402423768220bca1f','49d58dba','59b0906f7fcb'), + ('39a39a7e3c48c1b3b262e8653b1a3ec4','rprt','14b5b262c52400','7b34590a85','eec88226d871'), + ('fdd9d71a087b9048b8ac7dd29186cedf','rprt','315316c7af745a97','8a7c0917d4','743680a0303171bbd'), + ('f37e684c9ec0d0690a3c6feeaf6b1301','json','14b5b262c52400','0059c84703','8426f8984729'), + ('3787d0c9ead3866324d7586044747d65','rprt','b9cbf09f3366297','3822b4212e','611f4b0f498e') +; +-- +ok +== +WITH dups AS ( + SELECT ROW_NUMBER() OVER same_idx AS dup + , COUNT(*) OVER same_idx AS n_dup + , (DENSE_RANK() OVER asc_spcmn) + (DENSE_RANK() OVER desc_spcmn) - 1 AS n_spcmn + , * + FROM issue9416 + WINDOW same_idx AS ( + PARTITION BY idx + ORDER BY source, project, specimen + ROWS BETWEEN UNBOUNDED PRECEDING AND UNBOUNDED FOLLOWING + ) + , asc_spcmn AS ( + PARTITION BY idx + ORDER BY specimen ASC NULLS FIRST + ROWS BETWEEN UNBOUNDED PRECEDING AND UNBOUNDED FOLLOWING + ) + , desc_spcmn AS ( + PARTITION BY idx + ORDER BY specimen DESC NULLS LAST + ROWS BETWEEN UNBOUNDED PRECEDING AND UNBOUNDED FOLLOWING + ) +) +SELECT * +FROM dups +WHERE n_spcmn > 1 +ORDER BY idx, dup; +-- +ok +== diff --git a/parser/testdata/corpus/sql/window/test_duplicate_partition.test b/parser/testdata/corpus/sql/window/test_duplicate_partition.test new file mode 100644 index 0000000..899fadf --- /dev/null +++ b/parser/testdata/corpus/sql/window/test_duplicate_partition.test @@ -0,0 +1,45 @@ +# source: test/sql/window/test_duplicate_partition.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +CREATE TABLE src(a INTEGER, b INTEGER, v INTEGER); +-- +ok +== +INSERT INTO src VALUES (1, 1, 10), (1, 2, 20); +-- +ok +== +SELECT + SUM(v) OVER (PARTITION BY a, a) AS w_aa, + SUM(v) OVER (PARTITION BY a, b) AS w_ab +FROM src +ORDER BY b; +-- +ok +== +SELECT + SUM(v) OVER (PARTITION BY a, b) AS w_ab, + SUM(v) OVER (PARTITION BY a, a) AS w_aa +FROM src +ORDER BY b; +-- +ok +== +SELECT + SUM(v) OVER (PARTITION BY a, a) AS w_aa, + SUM(v) OVER (PARTITION BY a) AS w_a +FROM src +ORDER BY b; +-- +ok +== +SELECT + SUM(v) OVER (PARTITION BY a, a, b) AS w_aab, + SUM(v) OVER (PARTITION BY a, a, a) AS w_aaa +FROM src +ORDER BY b; +-- +ok +== diff --git a/parser/testdata/corpus/sql/window/test_empty_frames.test b/parser/testdata/corpus/sql/window/test_empty_frames.test new file mode 100644 index 0000000..358ff5c --- /dev/null +++ b/parser/testdata/corpus/sql/window/test_empty_frames.test @@ -0,0 +1,133 @@ +# source: test/sql/window/test_empty_frames.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +CREATE TABLE t1 (id INTEGER, ch CHAR(1)) ; +-- +ok +== +INSERT INTO t1 VALUES (1, 'A'); +-- +ok +== +INSERT INTO t1 VALUES (2, 'B'); +-- +ok +== +INSERT INTO t1 VALUES (NULL, 'B'); +-- +ok +== +SELECT id, {agg} OVER (PARTITION BY ch ORDER BY id ROWS BETWEEN 1 FOLLOWING AND 2 FOLLOWING) +FROM t1 +ORDER BY 1; +-- +error: Parser Error: syntax error at or near "}" +== +SELECT {agg} OVER (ROWS BETWEEN 1 FOLLOWING AND 1 PRECEDING) AS actual +FROM range(1); +-- +error: Parser Error: syntax error at or near "}" +== +SELECT id, count(*) OVER (PARTITION BY ch ORDER BY id ROWS BETWEEN 3 FOLLOWING AND 1 FOLLOWING) +FROM t1 +ORDER BY 1; +-- +ok +== +SELECT {agg} OVER (ROWS BETWEEN 1 FOLLOWING AND 1 PRECEDING EXCLUDE TIES) AS actual +FROM range(1); +-- +error: Parser Error: syntax error at or near "}" +== +SELECT id, lead(id ORDER BY id) OVER (ORDER BY ch ROWS BETWEEN 3 FOLLOWING AND 1 FOLLOWING) +FROM t1 +ORDER BY 1; +-- +ok +== +SELECT id, rank() OVER (ORDER BY id ROWS BETWEEN 3 FOLLOWING AND 1 FOLLOWING) +FROM t1 +ORDER BY 1; +-- +ok +== +SELECT id, {func}(ORDER BY id) OVER (ORDER BY ch ROWS BETWEEN 3 FOLLOWING AND 1 FOLLOWING) +FROM t1 +ORDER BY 1; +-- +error: Parser Error: syntax error at or near "}" +== +SELECT id, ntile(2 ORDER BY id) OVER (ORDER BY ch ROWS BETWEEN 3 FOLLOWING AND 1 FOLLOWING) +FROM t1 +ORDER BY 1; +-- +ok +== +SELECT id, rank(ORDER BY id) OVER (ORDER BY ch ROWS BETWEEN 3 FOLLOWING AND 1 FOLLOWING) +FROM t1 +ORDER BY 1; +-- +ok +== +SELECT id, {func}(ORDER BY id) OVER (ORDER BY ch ROWS BETWEEN 1 FOLLOWING AND CURRENT ROW) +FROM t1 +ORDER BY 1; +-- +error: Parser Error: syntax error at or near "}" +== +SELECT id, ntile(2 ORDER BY id) OVER (ORDER BY ch ROWS BETWEEN 1 FOLLOWING AND CURRENT ROW) +FROM t1 +ORDER BY 1; +-- +ok +== +SELECT id, rank(ORDER BY id) OVER (ORDER BY ch ROWS BETWEEN 1 FOLLOWING AND CURRENT ROW) +FROM t1 +ORDER BY 1; +-- +ok +== +SELECT id, {agg}(id) OVER (PARTITION BY ch ORDER BY id ROWS BETWEEN 1 FOLLOWING AND 2 FOLLOWING) +FROM t1 +ORDER BY 1; +-- +error: Parser Error: syntax error at or near "}" +== +SELECT id, {agg}(id, 0.5) OVER (PARTITION BY ch ORDER BY id ROWS BETWEEN 1 FOLLOWING AND 2 FOLLOWING) +FROM t1 +ORDER BY 1; +-- +error: Parser Error: syntax error at or near "}" +== +SELECT id, {agg}(id, ch) OVER (PARTITION BY ch ORDER BY id ROWS BETWEEN 1 FOLLOWING AND 2 FOLLOWING) +FROM t1 +ORDER BY 1; +-- +error: Parser Error: syntax error at or near "}" +== +SELECT id, {agg}(id > 0) OVER (PARTITION BY ch ORDER BY id ROWS BETWEEN 1 FOLLOWING AND 2 FOLLOWING) +FROM t1 +ORDER BY 1; +-- +error: Parser Error: syntax error at or near "}" +== +SELECT id, {agg}(id, id) OVER (PARTITION BY ch ORDER BY id ROWS BETWEEN 1 FOLLOWING AND 2 FOLLOWING) +FROM t1 +ORDER BY 1; +-- +error: Parser Error: syntax error at or near "}" +== +SELECT id, string_agg(id, ' ') OVER (PARTITION BY ch ORDER BY id ROWS BETWEEN 1 FOLLOWING AND 2 FOLLOWING) +FROM t1 +ORDER BY 1; +-- +ok +== +SELECT id, bitstring_agg(id, 1, 3) OVER (PARTITION BY ch ORDER BY id ROWS BETWEEN 1 FOLLOWING AND 2 FOLLOWING) +FROM t1 +ORDER BY 1; +-- +ok +== diff --git a/parser/testdata/corpus/sql/window/test_evil_window.test b/parser/testdata/corpus/sql/window/test_evil_window.test new file mode 100644 index 0000000..857a01f --- /dev/null +++ b/parser/testdata/corpus/sql/window/test_evil_window.test @@ -0,0 +1,41 @@ +# source: test/sql/window/test_evil_window.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +select * +from ( + select lag(i, -1) over () as negative, lead(i, 1) over () as positive + from generate_series(0, 10, 1) tbl(i) + ) w +where negative <> positive +-- +ok +== +SELECT depname, sum(sum(salary)) over (partition by depname order by salary) FROM empsalary group by depname, salary order by depname, salary +-- +ok +== +SELECT empno, sum(salary*2) OVER (PARTITION BY depname ORDER BY empno) FROM empsalary ORDER BY depname, empno +-- +ok +== +SELECT empno, 2*sum(salary) OVER (PARTITION BY depname ORDER BY empno) FROM empsalary ORDER BY depname, empno +-- +ok +== +SELECT depname, sum(salary)*100.0000/sum(sum(salary)) OVER (PARTITION BY depname ORDER BY salary) AS revenueratio FROM empsalary GROUP BY depname, salary ORDER BY depname, revenueratio +-- +ok +== +CREATE TABLE empty_unsorted(c0 VARCHAR); +-- +ok +== +SELECT * +FROM empty_unsorted +WHERE(NOT(false = ANY([]))) +ORDER BY(~((SUM(true) OVER() - SUM(true) OVER())::INT)) ASC; +-- +ok +== diff --git a/parser/testdata/corpus/sql/window/test_fill_orderby.test b/parser/testdata/corpus/sql/window/test_fill_orderby.test new file mode 100644 index 0000000..9b06a5f --- /dev/null +++ b/parser/testdata/corpus/sql/window/test_fill_orderby.test @@ -0,0 +1,257 @@ +# source: test/sql/window/test_fill_orderby.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +select fill(i order by 10-i, i * i) over (order by i) from range(3) tbl(i); +-- +ok +== +select fill(i::VARCHAR order by i) over (order by i) from range(3) tbl(i); +-- +ok +== +select fill(i order by i::VARCHAR) over (order by i) from range(3) tbl(i); +-- +ok +== +with source as ( + select + i, + i * 3 % 5 as permuted, + if(permuted = {nulled}, NULL, permuted) as missing + from range(5) tbl(i) +) +select + i, + permuted, + fill(missing order by permuted) over (order by i) as filled +from source +qualify filled <> permuted +-- +error: Parser Error: syntax error at or near "}" +== +SELECT fill(y ORDER BY x) OVER () +FROM ( + VALUES + (-1e308::DOUBLE, 1::DOUBLE), + (0::DOUBLE, NULL), + (1e308::DOUBLE, 3::DOUBLE) +) t(x, y) +ORDER BY x; +-- +ok +== +with source as ( + select + i, + i * 3 % 5 as permuted, + if(permuted > 0, NULL, permuted) as missing + from range(5) tbl(i) +) +select + i, + permuted, + fill(missing order by permuted) over (order by i) as filled +from source +qualify filled <> permuted +-- +ok +== +with source as ( + select + i, + i * 5 % 11 as permuted, + if(permuted < 6, NULL, permuted) as missing + from range(11) tbl(i) +) +select + i, + permuted, + fill(missing order by permuted) over (partition by permuted // 5 order by i) as filled +from source +qualify filled is distinct from permuted +order by i +-- +ok +== +with null_chunk as ( + select + 1 as p, + s, + NULL::DOUBLE as v, + from range(2050) tbl(s) + union all + select + 2 as p, + s, + s::DOUBLE as v, + from range(16) tbl(s) +) +select + p, + s, + fill(v order by -s) over(partition by p order by s) as f, +from null_chunk +-- +ok +== +with null_chunk as ( + select + 1 as p, + s, + NULL::DOUBLE as v, + from range(8) tbl(s) + union all + select + 2 as p, + s, + s::DOUBLE as v, + from range(8) tbl(s) +) +select + p, + s, + fill(v order by s) over(partition by p order by s) as f, +from null_chunk +order by all +-- +ok +== +with source as ( + select + i, + i * 5 % 11 as permuted, + if(permuted = 2, NULL, permuted) as missing, + if(permuted < 4, NULL, permuted) as unsorted, + from range(11) tbl(i) +) +select + i, + permuted, + fill(missing order by unsorted) over (order by i) as filled +from source +qualify filled is distinct from permuted +order by i +-- +ok +== +with source as ( + select + i, + (i + 1) * 3 % 5 as permuted, + if(permuted = 0, NULL, permuted) as missing + from ( + from range(5) tbl(i) + union all + select NULL::INTEGER as i + ) t(i) +) +select + i, + permuted, + fill(missing order by permuted asc nulls first) over (order by i) as filled +from source +qualify filled is distinct from permuted +-- +ok +== +with source as ( + select + i, + (i + 1) * 3 % 5 as permuted, + if(permuted = 4, NULL, permuted) as missing + from ( + from range(5) tbl(i) + union all + select NULL::INTEGER as i + ) t(i) +) +select + i, + permuted, + fill(missing order by permuted asc nulls last) over (order by i) as filled +from source +qualify filled is distinct from permuted +-- +ok +== +select + i, + permuted, + fill(missing order by permuted asc nulls last) over (order by i) as filled +from (values + (0, 1, NULL), + (1, NULL, 0) +) source(i, missing, permuted) +order by i +-- +ok +== +select + i, + permuted, + fill(missing order by permuted asc nulls first) over (order by i) as filled +from (values + (0, NULL, 2), + (1, 0, NULL), + (2, 1, 1), +) source(i, missing, permuted) +order by i +-- +ok +== +with source as ( + select + i, + (i + 1) * 3 % 5 as permuted, + if(permuted = {nullable}, NULL, permuted) as missing + from ( + select range::{ordertype} as i from range(5) + union all + select {unusable}::{ordertype} as i + ) t(i) +) +select + i, + fill(missing order by permuted) over (order by i) as filled +from source +qualify filled is distinct from permuted +order by i +-- +error: Parser Error: syntax error at or near "}" +== +with source as ( + ( + select + ('2025-01-01'::DATE + INTERVAL (i) DAY)::{ordertype} as t, + ('2025-01-01'::DATE + INTERVAL ((i + 1) * 3 % 5) DAY)::{ordertype} as permuted, + if(i = {nullable}, NULL, permuted) as missing + from range(5) tbl(i) + ) + union all + ( + select + {unusable}::{ordertype} as t, + t as permuted, + permuted as missing + ) +) +select + t, + fill(missing order by permuted) over (order by t) as filled +from source +qualify filled is distinct from permuted +order by t +-- +error: Parser Error: syntax error at or near "{" +== +SELECT x, y, fill(y ORDER BY x) OVER () AS filled +FROM (VALUES + (0::BIGINT, 9223372036854775807::BIGINT), + (1::BIGINT, NULL), + (2::BIGINT, -9223372036854775807::BIGINT)) t(x, y) +ORDER BY x; +-- +ok +== diff --git a/parser/testdata/corpus/sql/window/test_ignore_nulls.test b/parser/testdata/corpus/sql/window/test_ignore_nulls.test new file mode 100644 index 0000000..856f370 --- /dev/null +++ b/parser/testdata/corpus/sql/window/test_ignore_nulls.test @@ -0,0 +1,264 @@ +# source: test/sql/window/test_ignore_nulls.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +CREATE TABLE issue2549 AS SELECT * FROM (VALUES + (0, 1, 614), + (1, 1, null), + (2, 1, null), + (3, 1, 639), + (4, 1, 2027) +) tbl(id, user_id, order_id); +-- +ok +== +SELECT + id, + user_id, + order_id, + LAST_VALUE (order_id IGNORE NULLS) over ( + PARTITION BY user_id + ORDER BY id + ROWS BETWEEN UNBOUNDED PRECEDING AND 1 PRECEDING + ) AS last_order_id +FROM issue2549 +ORDER BY ALL +-- +ok +== +SELECT + id, + user_id, + order_id, + FIRST_VALUE (order_id IGNORE NULLS) over ( + PARTITION BY user_id + ORDER BY id + ROWS BETWEEN 1 PRECEDING AND UNBOUNDED FOLLOWING + ) AS last_order_id +FROM issue2549 +ORDER BY ALL +-- +ok +== +SELECT + id, + user_id, + order_id, + NTH_VALUE (order_id, 2 IGNORE NULLS) over ( + PARTITION BY user_id + ORDER BY id + ROWS BETWEEN UNBOUNDED PRECEDING AND 1 PRECEDING + ) AS last_order_id +FROM issue2549 +ORDER BY ALL +-- +ok +== +SELECT + id, + user_id, + order_id, + LEAD(order_id, 1, -1 IGNORE NULLS) over ( + PARTITION BY user_id + ORDER BY id + ) AS last_order_id +FROM issue2549 +ORDER BY ALL +-- +ok +== +SELECT + id, + user_id, + order_id, + LAG(order_id, 1, -1 IGNORE NULLS) over ( + PARTITION BY user_id + ORDER BY id + ) AS last_order_id +FROM issue2549 +ORDER BY ALL +-- +ok +== +SELECT + id, + user_id, + order_id, + LAG(order_id, 0, -1 IGNORE NULLS) over ( + PARTITION BY user_id + ORDER BY id + ) AS last_order_id +FROM issue2549 +ORDER BY ALL +-- +ok +== +SELECT + id, + user_id, + order_id, + LAST_VALUE (order_id RESPECT NULLS) over ( + PARTITION BY user_id + ORDER BY id + ROWS BETWEEN UNBOUNDED PRECEDING AND 1 PRECEDING + ) AS last_order_id +FROM issue2549 +ORDER BY ALL +-- +ok +== +SELECT + id, + user_id, + order_id, + FIRST_VALUE (order_id RESPECT NULLS) over ( + PARTITION BY user_id + ORDER BY id + ROWS BETWEEN UNBOUNDED PRECEDING AND 1 PRECEDING + ) AS last_order_id +FROM issue2549 +ORDER BY ALL +-- +ok +== +SELECT + id, + user_id, + order_id, + NTH_VALUE (order_id, 2 RESPECT NULLS) over ( + PARTITION BY user_id + ORDER BY id + ROWS BETWEEN UNBOUNDED PRECEDING AND 1 PRECEDING + ) AS last_order_id +FROM issue2549 +ORDER BY ALL +-- +ok +== +SELECT + id, + user_id, + order_id, + LEAD(order_id, 1, -1 RESPECT NULLS) over ( + PARTITION BY user_id + ORDER BY id + ) AS last_order_id +FROM issue2549 +ORDER BY ALL +-- +ok +== +SELECT + id, + user_id, + order_id, + LAG(order_id, 1, -1 RESPECT NULLS) over ( + PARTITION BY user_id + ORDER BY id + ) AS last_order_id +FROM issue2549 +ORDER BY ALL +-- +ok +== +SELECT + id, + user_id, + order_id, + LAG(order_id, 0, -1 RESPECT NULLS) over ( + PARTITION BY user_id + ORDER BY id + ) AS last_order_id +FROM issue2549 +ORDER BY ALL +-- +ok +== +CREATE TABLE IF NOT EXISTS issue6635(index INTEGER, data INTEGER); +-- +ok +== +insert into issue6635 values + (1,1), + (2,2), + (3,NULL), + (4,NULL), + (5,5), + (6,NULL), + (7,NULL) +; +-- +ok +== +SELECT *, + first(data IGNORE NULLS) OVER w, + last(data IGNORE NULLS) OVER w, + nth_value(data, 1 IGNORE NULLS) OVER w +FROM issue6635 +WINDOW w AS ( + ORDER BY index + ROWS BETWEEN 1 FOLLOWING + AND UNBOUNDED FOLLOWING +) +; +-- +ok +== +WITH gen AS ( + SELECT *, + ((id * 1327) % 9973) / 10000.0 AS rnd + FROM generate_series(1, 10000) tbl(id) +), +lvl AS ( + SELECT id, + rnd, + CASE + WHEN rnd <= 0.1 THEN 'shallow' + WHEN rnd >= 0.9 THEN 'high' + END AS water_level + FROM gen +) +SELECT *, + LAST_VALUE(water_level IGNORE NULLS) OVER ( + ORDER BY id + ) AS grade +FROM lvl +ORDER BY id +-- +ok +== +SELECT + v, + lead(v) OVER (ORDER BY id), + lead(v IGNORE NULLS) OVER (ORDER BY id) +FROM (VALUES + (1, 1), + (2, NULL), + (3, 2), + (4, NULL), + (5, 3), + (6, NULL) +) tbl(id, v); +-- +ok +== +SELECT ABS(x {modifier} NULLS) FROM range(10) tbl(x) +-- +error: Parser Error: syntax error at or near "{" +== +SELECT SUM(x {modifier} NULLS) +FROM range(10) tbl(x) +-- +error: Parser Error: syntax error at or near "{" +== +SELECT SUM(x {modifier} NULLS) OVER (PARTITION BY (x / 3) ORDER BY x % 3) +FROM range(10) tbl(x) +-- +error: Parser Error: syntax error at or near "{" +== +SELECT FILL(x {modifier} NULLS) OVER (PARTITION BY (x / 3) ORDER BY x % 3) +FROM range(10) tbl(x) +-- +error: Parser Error: syntax error at or near "{" +== diff --git a/parser/testdata/corpus/sql/window/test_invalid_window.test b/parser/testdata/corpus/sql/window/test_invalid_window.test new file mode 100644 index 0000000..8af492f --- /dev/null +++ b/parser/testdata/corpus/sql/window/test_invalid_window.test @@ -0,0 +1,84 @@ +# source: test/sql/window/test_invalid_window.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +SELECT depname, min(salary) OVER (PARTITION BY depname ORDER BY salary, empno) m1 FROM empsalary GROUP BY m1 ORDER BY depname, empno +-- +ok +== +select row_number() over (range between unbounded following and unbounded preceding); +-- +error: Parser Error: Frame start cannot be UNBOUNDED FOLLOWING +== +select row_number() over (range between unbounded preceding and unbounded preceding); +-- +error: Parser Error: Frame end cannot be UNBOUNDED PRECEDING +== +select LIST(salary ORDER BY enroll_date, salary) OVER (PARTITION BY depname) FROM empsalary +ORDER BY ALL DESC +-- +ok +== +SELECT sum(i) OVER (ORDER BY i GROUPS 1 PRECEDING) +FROM generate_series(1,10) AS _(i) +ORDER BY i +-- +ok +== +SELECT array_agg(i) OVER ({invalid} ROWS BETWEEN UNBOUNDED PRECEDING AND CURRENT ROW) +FROM generate_series(1,5) AS _(i) +WINDOW {invalid} AS (ORDER BY i); +-- +error: Parser Error: syntax error at or near "{" +== +SELECT + i, + {func}(i ORDER BY i // 2, i) OVER ( + ORDER BY i // 2 + ROWS BETWEEN 3 PRECEDING AND 3 FOLLOWING + EXCLUDE TIES + ) AS f, +FROM range(10) tbl(i) +ORDER BY i; +-- +error: Parser Error: syntax error at or near "}" +== +SELECT + i, + lead(i ORDER BY i // 2, i) OVER w AS f, +FROM range(10) tbl(i) +WINDOW w AS ( + ORDER BY i // 2 + ROWS BETWEEN 3 PRECEDING AND 3 FOLLOWING + EXCLUDE TIES + ) +ORDER BY i; +-- +ok +== +SELECT + i, + {func}(ORDER BY i // 2, i) OVER ( + ORDER BY i // 2 + ROWS BETWEEN 3 PRECEDING AND 3 FOLLOWING + EXCLUDE TIES + ) AS f, +FROM range(10) tbl(i) +ORDER BY i; +-- +error: Parser Error: syntax error at or near "}" +== +SELECT + i, + {func}(ORDER BY i // 2, i) OVER w AS f, +FROM range(10) tbl(i) +WINDOW w AS ( + ORDER BY i // 2 + ROWS BETWEEN 3 PRECEDING AND 3 FOLLOWING + EXCLUDE TIES +) +ORDER BY i; +-- +error: Parser Error: syntax error at or near "}" +== diff --git a/parser/testdata/corpus/sql/window/test_invalid_window.test.metadata.json b/parser/testdata/corpus/sql/window/test_invalid_window.test.metadata.json new file mode 100644 index 0000000..85e42c0 --- /dev/null +++ b/parser/testdata/corpus/sql/window/test_invalid_window.test.metadata.json @@ -0,0 +1,6 @@ +{ + "todo": { + "a944cdc99be3a290": "transformer-raised parser error: upstream rejects in the transformer, not the grammar; expected to clear as transformers land (milestones 3-5)", + "b01e96e0203c6ba1": "transformer-raised parser error: upstream rejects in the transformer, not the grammar; expected to clear as transformers land (milestones 3-5)" + } +} diff --git a/parser/testdata/corpus/sql/window/test_lead_lag.test b/parser/testdata/corpus/sql/window/test_lead_lag.test new file mode 100644 index 0000000..88b77ab --- /dev/null +++ b/parser/testdata/corpus/sql/window/test_lead_lag.test @@ -0,0 +1,119 @@ +# source: test/sql/window/test_lead_lag.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +select c1, lead(c1, 2) over (order by c0 rows between 2 preceding and 4 preceding) as b +from (values + (1, 2), + (2, 3), + (3, 4), + (4, 5) +) a(c0, c1); +-- +ok +== +select c1, lead("offset" := 2, col := c1) over (order by c0 rows between 2 preceding and 4 preceding) as b +from (values + (1, 2), + (2, 3), + (3, 4), + (4, 5) +) a(c0, c1); +-- +ok +== +select c1, lead("default" := 1337, col := c1) over (order by c0 rows between 2 preceding and 4 preceding) as b +from (values + (1, 2), + (2, 3), + (3, 4), + (4, 5) +) a(c0, c1); +-- +ok +== +create table win(id int, v int, t int, f float, s varchar); +-- +ok +== +insert into win values + (1, 1, 2, 0.54, 'h'), + (1, 1, 1, 0.21, 'e'), + (1, 2, 3, 0.001, 'l'), + (2, 10, 4, 0.04, 'l'), + (2, 11, -1, 10.45, 'o'), + (3, -1, 0, 13.32, ','), + (3, 5, -2, 9.87, 'wor'), + (3, null, 10, 6.56, 'ld'); +-- +ok +== +select id, v, t, lag(v, 2, NULL) over (partition by id order by t asc) +from win +order by id, t +-- +ok +== +CREATE TABLE issue14398 (date DATE, "group" INT, count INT, status STRING); +-- +ok +== +INSERT INTO issue14398 VALUES +('2024-01-01', 1, 1000, 'ordered'), +('2024-02-01', 1, 1000, 'dispatched'), +('2024-03-01', 1, 1000, 'dispatched'), +('2024-01-01', 2, 2000, 'ordered'), +('2024-02-01', 2, 2000, 'ordered'), +('2024-03-01', 2, 2000, 'ordered'), +('2024-01-01', 3, 3000, 'ordered'), +('2024-02-01', 3, 3000, 'ordered'), +('2024-03-01', 3, 3000, 'late'), +('2024-01-01', 4, 4000, 'ordered'), +('2024-02-01', 4, 4000, 'ordered'), +('2024-03-01', 4, 4000, 'ordered'), +('2024-01-01', 5, 5000, 'ordered'), +('2024-02-01', 5, 5000, 'late'), +('2024-03-01', 5, 5000, 'ordered'), +('2024-01-01', 6, 1000, 'dispatched'), +('2024-02-01', 6, 1000, 'dispatched'), +('2024-03-01', 6, 1000, 'dispatched'), +('2024-01-01', 7, 1000, 'late'), +('2024-02-01', 7, 1000, 'dispatched'), +('2024-03-01', 7, 1000, 'dispatched'); +-- +ok +== +SELECT + "t0"."date", + "t0"."group", + "t0"."count", + "t0"."status", + LEAD("t0"."date", 2) OVER (PARTITION BY "t0"."group" ORDER BY "t0"."date" ASC ROWS BETWEEN UNBOUNDED PRECEDING AND UNBOUNDED FOLLOWING) AS "end_date", + LEAD("t0"."status", 2) OVER (PARTITION BY "t0"."group" ORDER BY "t0"."date" ASC ROWS BETWEEN UNBOUNDED PRECEDING AND UNBOUNDED FOLLOWING) AS "end_status" +FROM "issue14398" AS "t0" +ORDER BY 2, 1 +-- +ok +== +CREATE TABLE issue17266(c1 INT, c2 SMALLINT, c3 BITSTRING); +-- +ok +== +INSERT INTO issue17266 VALUES +(0, null, null), +(1, 32767, '101'), +(2, -32767, '101'), +(3, 0, '000'), +(4, null, null); +-- +ok +== +SELECT c1, c3, c2, LAG(c3, c2, BITSTRING'010101010') OVER (PARTITION BY c1 ORDER BY c3) FROM issue17266 ORDER BY c1; +-- +ok +== +SELECT c1, c3, c2, LEAD(c3, c2, BITSTRING'010101010') OVER (PARTITION BY c1 ORDER BY c3) FROM issue17266 ORDER BY c1; +-- +ok +== diff --git a/parser/testdata/corpus/sql/window/test_leadlag_orderby.test b/parser/testdata/corpus/sql/window/test_leadlag_orderby.test new file mode 100644 index 0000000..620a2f3 --- /dev/null +++ b/parser/testdata/corpus/sql/window/test_leadlag_orderby.test @@ -0,0 +1,64 @@ +# source: test/sql/window/test_leadlag_orderby.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +SELECT + i, + (i * 29) % 11 AS outside, + i // 2 AS inside, + lead(i, 1, NULL ORDER BY inside DESC, i) OVER w, + lag(i, 1, NULL ORDER BY inside DESC, i) OVER w, +FROM range(10) tbl(i) +WINDOW w AS ( + ORDER BY outside +) +ORDER BY inside DESC, i +-- +ok +== +SELECT + i, + i // 2 AS inside, + lead(i, 1, NULL ORDER BY i // 2, i) OVER w AS next, + lag(i, 1, NULL ORDER BY i // 2, i) OVER w AS prev, +FROM range(10) tbl(i) +WINDOW w AS ( + ORDER BY i // 2 + ROWS BETWEEN 3 PRECEDING AND 3 FOLLOWING +) +ORDER BY i +-- +ok +== +INSERT INTO issue17266 VALUES +(0, null, null), +(1, 32767, '101'), +(2, -32767, '101'), +(3, 0, '000'), +(4, 1, '010'), +(5, 0, '110'), +(6, null, null); +-- +ok +== +SELECT + c1, + c3, + c2, + LAG(c3, c2 ORDER BY c1, BITSTRING'010101010') OVER (PARTITION BY c1 ORDER BY c3) +FROM issue17266 +ORDER BY c1; +-- +ok +== +SELECT + c1, + c3, + c2, + LEAD(c3, c2 ORDER BY c1, BITSTRING'010101010') OVER (PARTITION BY c1 ORDER BY c3) +FROM issue17266 +ORDER BY c1; +-- +ok +== diff --git a/parser/testdata/corpus/sql/window/test_list_window.test b/parser/testdata/corpus/sql/window/test_list_window.test new file mode 100644 index 0000000..17cc198 --- /dev/null +++ b/parser/testdata/corpus/sql/window/test_list_window.test @@ -0,0 +1,49 @@ +# source: test/sql/window/test_list_window.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +CREATE TABLE list_extract_test(i INTEGER, g INTEGER); +-- +ok +== +INSERT INTO list_extract_test VALUES (1, 1), (2, 1), (3, 2), (NULL, 3), (42, 3); +-- +ok +== +CREATE VIEW list_window AS +SELECT g, LIST(i) OVER (PARTITION BY g ORDER BY i ROWS BETWEEN UNBOUNDED PRECEDING AND UNBOUNDED FOLLOWING) as l +FROM list_extract_test; +-- +ok +== +SELECT * FROM list_window ORDER BY g +-- +ok +== +SELECT FIRST(LIST_EXTRACT(l, 1)) FROM list_window GROUP BY g ORDER BY g; +-- +ok +== +SELECT FIRST(LIST_EXTRACT(l, 2)) FROM list_window GROUP BY g ORDER BY g; +-- +ok +== +SELECT FIRST(LIST_EXTRACT(l, 3)) FROM list_window GROUP BY g ORDER BY g; +-- +ok +== +create table list_combine_test as + select range%3 j, + range::varchar AS s, + case when range%3=0 then '-' else '|' end sep + from range(1, 65) +-- +ok +== +select j, s, list(s) over (partition by j order by s) +from list_combine_test +order by j, s; +-- +ok +== diff --git a/parser/testdata/corpus/sql/window/test_mad_window.test b/parser/testdata/corpus/sql/window/test_mad_window.test new file mode 100644 index 0000000..c78c4f7 --- /dev/null +++ b/parser/testdata/corpus/sql/window/test_mad_window.test @@ -0,0 +1,63 @@ +# source: test/sql/window/test_mad_window.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +create table mads as select range r from range(20) union all values (NULL), (NULL), (NULL); +-- +ok +== +SELECT r % 2 as p, r, r/3.0, mad(r/3.0) over (partition by r % 2 order by r) +FROM mads ORDER BY 1, 2 +-- +ok +== +SELECT r, r/3.0, mad(r/3.0) over (order by r rows between 1 preceding and 1 following) +FROM mads ORDER BY 1, 2, 3 +-- +ok +== +SELECT r, r/3.0, mad(r/3.0) over (order by r rows between 1 preceding and 3 following) FROM mads ORDER BY 1, 2, 3 +-- +ok +== +SELECT r % 3 as p, r, n, mad(n) over (partition by r % 3 order by r) +FROM (SELECT r, CASE r % 2 WHEN 0 THEN r ELSE NULL END AS n FROM mads) nulls +ORDER BY 1, 2 +-- +ok +== +SELECT r, n, mad(n) over (order by r rows between 1 preceding and 1 following) +FROM (SELECT r, CASE r % 2 WHEN 0 THEN r ELSE NULL END AS n FROM mads) nulls +ORDER BY 1 +-- +ok +== +SELECT r, n, mad(n) over (order by r rows between 1 preceding and 3 following) +FROM (SELECT r, CASE r % 2 WHEN 0 THEN r ELSE NULL END AS n FROM mads) nulls +ORDER BY 1 +-- +ok +== +SELECT r, n, mad(n) over (order by r rows between unbounded preceding and unbounded following) +FROM (SELECT r, CASE r % 2 WHEN 0 THEN r ELSE NULL END AS n FROM mads) nulls +ORDER BY 1 +-- +ok +== +CREATE TABLE coverage AS SELECT * FROM (VALUES + (1), (2), (3), (1) + ) tbl(r) +-- +ok +== +SELECT r, mad(r) OVER (ORDER BY r ROWS BETWEEN 1 PRECEDING AND 1 FOLLOWING) +FROM coverage +ORDER BY 1 +-- +ok +== +PRAGMA debug_window_mode={windowmode} +-- +error: Parser Error: syntax error at or near "}" +== diff --git a/parser/testdata/corpus/sql/window/test_mode_window.test b/parser/testdata/corpus/sql/window/test_mode_window.test new file mode 100644 index 0000000..68c00ad --- /dev/null +++ b/parser/testdata/corpus/sql/window/test_mode_window.test @@ -0,0 +1,66 @@ +# source: test/sql/window/test_mode_window.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +create table modes as select range r from range(10) union all values (NULL), (NULL), (NULL); +-- +ok +== +SELECT r % 2, r, r//3, mode(r//3) over (partition by r % 2 order by r) FROM modes ORDER BY 1, 2 +-- +ok +== +SELECT r, r//3, mode(r//3) over (order by r rows between 1 preceding and 1 following) +FROM modes +ORDER BY ALL +-- +ok +== +SELECT r, r//3, mode(r//3) over (order by r rows between 1 preceding and 3 following) FROM modes ORDER BY 1, 2 +-- +ok +== +SELECT r, r // 3, n, mode(n) over (partition by r % 3 order by r) +FROM (SELECT r, CASE r % 2 WHEN 0 THEN r ELSE NULL END AS n FROM modes) nulls +ORDER BY 1 +-- +ok +== +SELECT r, n, mode(n) over (order by r rows between 1 preceding and 1 following) +FROM (SELECT r, CASE r % 2 WHEN 0 THEN r ELSE NULL END AS n FROM modes) nulls +ORDER BY ALL +-- +ok +== +SELECT r, n, mode(n) over (order by r rows between 1 preceding and 3 following) +FROM (SELECT r, CASE r % 2 WHEN 0 THEN r ELSE NULL END AS n FROM modes) nulls +ORDER BY 1 +-- +ok +== +SELECT r, n, mode(n) over (order by r rows between unbounded preceding and unbounded following) +FROM (SELECT r, CASE r % 2 WHEN 0 THEN r ELSE NULL END AS n FROM modes) nulls +ORDER BY 1 +-- +ok +== +WITH t(r) AS (VALUES (0), (1), (2), (3), (4), (5), (6), (7), (8), (9), (NULL), (NULL), (NULL)) +SELECT r, r//3, mode(r//3) over (order by r rows between 1 preceding and 1 following) +FROM t +ORDER BY ALL +-- +ok +== +WITH src(x) AS ( + VALUES (0), (2) +) +SELECT + MODE(DISTINCT x) OVER ( + ORDER BY x ASC + ROWS BETWEEN UNBOUNDED PRECEDING AND UNBOUNDED FOLLOWING + ) AS actual +FROM src; +-- +ok +== diff --git a/parser/testdata/corpus/sql/window/test_naive_aggregation.test b/parser/testdata/corpus/sql/window/test_naive_aggregation.test new file mode 100644 index 0000000..c76df7b --- /dev/null +++ b/parser/testdata/corpus/sql/window/test_naive_aggregation.test @@ -0,0 +1,142 @@ +# source: test/sql/window/test_naive_aggregation.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +PRAGMA debug_window_mode=separate +-- +ok +== +CREATE TABLE filtering AS + SELECT + x + ,round(x * 0.333,0) % 3 AS y + ,round(x * 0.333,0) % 3 AS z + FROM generate_series(0,10) tbl(x); +-- +ok +== +SELECT + x + ,y + ,z + ,avg(x) OVER (PARTITION BY y) AS plain_window + ,avg(x) FILTER (WHERE x = 1) OVER (PARTITION BY y) AS x_filtered_window + ,avg(x) FILTER (WHERE z = 0) OVER (PARTITION BY y) AS z_filtered_window +FROM filtering +ORDER BY y, x; +-- +ok +== +SELECT + x + ,y + ,z + ,count(*) OVER (PARTITION BY y) AS plain_window + ,count(*) FILTER (WHERE x = 1) OVER (PARTITION BY y) AS x_filtered_window + ,count(*) FILTER (WHERE z = 0) OVER (PARTITION BY y) AS z_filtered_window +FROM filtering +ORDER BY y, x; +-- +ok +== +SELECT + x + ,y + ,z + ,median(x) OVER (PARTITION BY y) AS plain_window + ,median(x) FILTER (WHERE x = 1) OVER (PARTITION BY y) AS x_filtered_window + ,median(x) FILTER (WHERE z = 0) OVER (PARTITION BY y) AS z_filtered_window +FROM filtering +ORDER BY y, x; +-- +ok +== +SELECT x, count(x) FILTER (WHERE x % 2 = 0) OVER (ORDER BY x ROWS BETWEEN 2 PRECEDING AND 2 FOLLOWING) +FROM generate_series(0,10) tbl(x); +-- +ok +== +CREATE TABLE figure1 AS + SELECT * + FROM VALUES + (1, 'a'), + (2, 'b'), + (3, 'b'), + (4, 'c'), + (5, 'c'), + (6, 'b'), + (7, 'c'), + (8, 'a') + v(i, s); +-- +ok +== +SELECT i + , s + , COUNT(DISTINCT s) OVER( ORDER BY i ROWS BETWEEN 2 PRECEDING AND 2 FOLLOWING) AS c +FROM figure1 +ORDER BY i +-- +ok +== +SELECT i + , s + , COUNT(DISTINCT s) OVER( ORDER BY i ROWS BETWEEN 2 PRECEDING AND 2 FOLLOWING EXCLUDE TIES) AS c +FROM figure1 +ORDER BY i +-- +ok +== +SELECT + i // 10 AS p, + i, + ANY_VALUE(i ORDER BY i DESC) OVER( + PARTITION BY i // 10 + ORDER BY i + ROWS BETWEEN 2 PRECEDING AND 2 FOLLOWING + ) AS c +FROM range(20) tbl(i) +ORDER BY ALL +-- +ok +== +SELECT + i // 10 AS p, + i, + LIST(i ORDER BY i DESC) OVER( + PARTITION BY i // 10 + ORDER BY i + ROWS BETWEEN 2 PRECEDING AND 2 FOLLOWING + ) AS c +FROM range(20) tbl(i) +ORDER BY ALL +-- +ok +== +SELECT + i // 10 AS p, + i, + LIST(DISTINCT i // 2 ORDER BY i DESC) OVER( + PARTITION BY i // 10 + ORDER BY i + ROWS BETWEEN 2 PRECEDING AND 2 FOLLOWING + ) AS c +FROM range(20) tbl(i) +ORDER BY ALL +-- +ok +== +SELECT + i // 10 AS p, + i, + LIST(DISTINCT i // 2 ORDER BY i DESC) FILTER (i > 1) OVER( + PARTITION BY i // 10 + ORDER BY i + ROWS BETWEEN 2 PRECEDING AND 2 FOLLOWING + ) AS c +FROM range(20) tbl(i) +ORDER BY ALL +-- +ok +== diff --git a/parser/testdata/corpus/sql/window/test_negative_range.test b/parser/testdata/corpus/sql/window/test_negative_range.test new file mode 100644 index 0000000..168574b --- /dev/null +++ b/parser/testdata/corpus/sql/window/test_negative_range.test @@ -0,0 +1,53 @@ +# source: test/sql/window/test_negative_range.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +CREATE OR REPLACE TABLE issue10855(i INTEGER, v FLOAT); +-- +ok +== +INSERT INTO issue10855 VALUES (0, 1), (1, 2), (2, 3),; +-- +ok +== +SELECT i, v, sum(v) OVER (ORDER BY i RANGE BETWEEN 1 PRECEDING AND -1 FOLLOWING) +FROM issue10855 +-- +ok +== +SELECT i, v, sum(v) OVER (ORDER BY i RANGE BETWEEN -1 FOLLOWING AND 1 FOLLOWING) +FROM issue10855 +-- +ok +== +SELECT i, v, sum(v) OVER (ORDER BY i RANGE BETWEEN -1 PRECEDING AND 1 FOLLOWING) +FROM issue10855 +-- +ok +== +SELECT i, v, sum(v) OVER (ORDER BY i RANGE BETWEEN 1 PRECEDING AND -1 PRECEDING) +FROM issue10855 +-- +ok +== +SELECT i, v, sum(v) OVER (ORDER BY i DESC RANGE BETWEEN 1 PRECEDING AND -1 FOLLOWING) +FROM issue10855 +-- +ok +== +SELECT i, v, sum(v) OVER (ORDER BY i DESC RANGE BETWEEN -1 FOLLOWING AND 1 FOLLOWING) +FROM issue10855 +-- +ok +== +SELECT i, v, sum(v) OVER (ORDER BY i DESC RANGE BETWEEN -1 PRECEDING AND 1 FOLLOWING) +FROM issue10855 +-- +ok +== +SELECT i, v, sum(v) OVER (ORDER BY i DESC RANGE BETWEEN 1 PRECEDING AND -1 PRECEDING) +FROM issue10855 +-- +ok +== diff --git a/parser/testdata/corpus/sql/window/test_no_default_window_spec.test b/parser/testdata/corpus/sql/window/test_no_default_window_spec.test new file mode 100644 index 0000000..acf9e5b --- /dev/null +++ b/parser/testdata/corpus/sql/window/test_no_default_window_spec.test @@ -0,0 +1,33 @@ +# source: test/sql/window/test_no_default_window_spec.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +create table tenk1d(ten int4, four int4) +-- +ok +== +insert into tenk1d values (0,0), (1,1), (3,3), (2,2), (4,2), (9,1), (4,0), (7,3), (0,2), (2,0), (5,1), (1,3), (3,1), (6,0), (8,0), (9,3), (8,2), (6,2), (7,1), (5,3) +-- +ok +== +SELECT four, ten, sum(ten) over (partition by four order by ten) st, last_value(ten) over (partition by four order by ten) lt FROM tenk1d ORDER BY four, ten +-- +ok +== +SELECT four, ten, sum(ten) over (partition by four order by ten range between unbounded preceding and current row) st, last_value(ten) over (partition by four order by ten range between unbounded preceding and current row) lt FROM tenk1d order by four, ten +-- +ok +== +SELECT four, ten, sum(ten) over (partition by four order by ten range between unbounded preceding and unbounded following) st, last_value(ten) over (partition by four order by ten range between unbounded preceding and unbounded following) lt FROM tenk1d order by four, ten +-- +ok +== +SELECT four, ten//4 as two, sum(ten//4) over (partition by four order by ten//4 range between unbounded preceding and current row) st, last_value(ten//4) over (partition by four order by ten//4 range between unbounded preceding and current row) lt FROM tenk1d order by four, ten//4 +-- +ok +== +SELECT four, ten//4 as two, sum(ten//4) OVER w st, last_value(ten//4) OVER w lt FROM tenk1d WINDOW w AS (partition by four order by ten//4 range between unbounded preceding and current row) order by four, ten//4 +-- +ok +== diff --git a/parser/testdata/corpus/sql/window/test_nthvalue.test b/parser/testdata/corpus/sql/window/test_nthvalue.test new file mode 100644 index 0000000..12fd292 --- /dev/null +++ b/parser/testdata/corpus/sql/window/test_nthvalue.test @@ -0,0 +1,117 @@ +# source: test/sql/window/test_nthvalue.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +CREATE TABLE empsalary (depname varchar, empno bigint, salary int, enroll_date date); +-- +ok +== +INSERT INTO empsalary VALUES ('develop', 10, 5200, '2007-08-01'), ('sales', 1, 5000, '2006-10-01'), ('personnel', 5, 3500, '2007-12-10'), ('sales', 4, 4800, '2007-08-08'), ('personnel', 2, 3900, '2006-12-23'), ('develop', 7, 4200, '2008-01-01'), ('develop', 9, 4500, '2008-01-01'), ('sales', 3, 4800, '2007-08-01'), ('develop', 8, 6000, '2006-10-01'), ('develop', 11, 5200, '2007-08-15'); +-- +ok +== +SELECT depname, empno, + nth_value(empno, 2) OVER ( + PARTITION BY depname ORDER BY empno ASC + ROWS BETWEEN CURRENT ROW AND UNBOUNDED FOLLOWING + ) fv +FROM empsalary +ORDER BY 1, 2 +-- +ok +== +SELECT depname, empno, + nth_value(empno, NULL) OVER ( + PARTITION BY depname ORDER BY empno ASC + ROWS BETWEEN CURRENT ROW AND UNBOUNDED FOLLOWING + ) fv +FROM empsalary +ORDER BY 1, 2 +-- +ok +== +SELECT depname, empno, + nth_value(NULL, 2) OVER ( + PARTITION BY depname ORDER BY empno ASC + ROWS BETWEEN CURRENT ROW AND UNBOUNDED FOLLOWING + ) fv +FROM empsalary +ORDER BY 1, 2 +-- +ok +== +SELECT depname, empno, + nth_value(empno, case empno % 3 when 1 then 2 else NULL end) OVER ( + PARTITION BY depname ORDER BY empno ASC + ROWS BETWEEN CURRENT ROW AND UNBOUNDED FOLLOWING + ) fv +FROM empsalary +ORDER BY 1, 2 +-- +ok +== +CREATE VIEW empno_nulls AS +SELECT depname, case empno % 2 when 1 then empno else NULL end as empno, salary, enroll_date +FROM empsalary +-- +ok +== +SELECT depname, empno, + nth_value(empno, 2) OVER ( + PARTITION BY depname ORDER BY empno ASC + ROWS BETWEEN CURRENT ROW AND UNBOUNDED FOLLOWING + ) fv +FROM empno_nulls +ORDER BY 1, 2, 3 +-- +ok +== +SELECT depname, empno, 1 + empno %3 as offset, + nth_value(empno, 1 + empno %3) OVER ( + PARTITION BY depname ORDER BY empno ASC + ROWS BETWEEN CURRENT ROW AND UNBOUNDED FOLLOWING + ) fv +FROM empsalary +ORDER BY 1, 2 +-- +ok +== +SELECT depname, empno, empno %3 as offset, + nth_value(empno, empno %3) OVER ( + PARTITION BY depname ORDER BY empno ASC + ROWS BETWEEN CURRENT ROW AND UNBOUNDED FOLLOWING + ) fv +FROM empsalary +ORDER BY 1, 2 +-- +ok +== +SELECT depname, empno, + nth_value(-1, 2) OVER ( + PARTITION BY depname ORDER BY empno ASC + ROWS BETWEEN CURRENT ROW AND UNBOUNDED FOLLOWING + ) fv +FROM empsalary +ORDER BY 1, 2 +-- +ok +== +SELECT depname, empno, + nth_value(empno) OVER ( + PARTITION BY depname ORDER BY empno ASC + ROWS BETWEEN CURRENT ROW AND UNBOUNDED FOLLOWING + ) fv +FROM empsalary +-- +ok +== +SELECT depname, empno, + nth_value(empno, 2, 3) OVER ( + PARTITION BY depname ORDER BY empno ASC + ROWS BETWEEN CURRENT ROW AND UNBOUNDED FOLLOWING + ) fv +FROM empsalary +-- +ok +== diff --git a/parser/testdata/corpus/sql/window/test_ntile.test b/parser/testdata/corpus/sql/window/test_ntile.test new file mode 100644 index 0000000..8a5e8b1 --- /dev/null +++ b/parser/testdata/corpus/sql/window/test_ntile.test @@ -0,0 +1,151 @@ +# source: test/sql/window/test_ntile.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +CREATE TABLE Scoreboard(TeamName VARCHAR, Player VARCHAR, Score INTEGER); +-- +ok +== +INSERT INTO Scoreboard VALUES ('Mongrels', 'Apu', 350); +-- +ok +== +INSERT INTO Scoreboard VALUES ('Mongrels', 'Ned', 666); +-- +ok +== +INSERT INTO Scoreboard VALUES ('Mongrels', 'Meg', 1030); +-- +ok +== +INSERT INTO Scoreboard VALUES ('Mongrels', 'Burns', 1270); +-- +ok +== +INSERT INTO Scoreboard VALUES ('Simpsons', 'Homer', 1); +-- +ok +== +INSERT INTO Scoreboard VALUES ('Simpsons', 'Lisa', 710); +-- +ok +== +INSERT INTO Scoreboard VALUES ('Simpsons', 'Marge', 990); +-- +ok +== +INSERT INTO Scoreboard VALUES ('Simpsons', 'Bart', 2010); +-- +ok +== +SELECT + TeamName, + Player, + Score, + NTILE(2) OVER (PARTITION BY TeamName ORDER BY Score ASC) AS NTILE +FROM ScoreBoard s +ORDER BY TeamName, Score; +-- +ok +== +SELECT + TeamName, + Player, + Score, + NTILE(2) OVER (ORDER BY Score ASC) AS NTILE +FROM ScoreBoard s +ORDER BY Score; +-- +ok +== +SELECT + TeamName, + Player, + Score, + NTILE(1000) OVER (PARTITION BY TeamName ORDER BY Score ASC) AS NTILE +FROM ScoreBoard s +ORDER BY TeamName, Score; +-- +ok +== +SELECT + TeamName, + Player, + Score, + NTILE(1) OVER (PARTITION BY TeamName ORDER BY Score ASC) AS NTILE +FROM ScoreBoard s +ORDER BY TeamName, Score; +-- +ok +== +SELECT + TeamName, + Player, + Score, + NTILE(NULL) OVER (PARTITION BY TeamName ORDER BY Score ASC) AS NTILE +FROM ScoreBoard s +ORDER BY TeamName, Score; +-- +ok +== +SELECT + TeamName, + Player, + Score, + NTILE() OVER (PARTITION BY TeamName ORDER BY Score ASC) AS NTILE +FROM ScoreBoard s +ORDER BY TeamName, Score; +-- +ok +== +SELECT + TeamName, + Player, + Score, + NTILE(1,2) OVER (PARTITION BY TeamName ORDER BY Score ASC) AS NTILE +FROM ScoreBoard s +ORDER BY TeamName, Score; +-- +ok +== +SELECT + TeamName, + Player, + Score, + NTILE(1,2,3) OVER (PARTITION BY TeamName ORDER BY Score ASC) AS NTILE +FROM ScoreBoard s +ORDER BY TeamName, Score; +-- +ok +== +SELECT + TeamName, + Player, + Score, + NTILE(1,2,3,4) OVER (PARTITION BY TeamName ORDER BY Score ASC) AS NTILE +FROM ScoreBoard s +ORDER BY TeamName, Score; +-- +ok +== +SELECT + TeamName, + Player, + Score, + NTILE(-1) OVER (PARTITION BY TeamName ORDER BY Score ASC) AS NTILE +FROM ScoreBoard s +ORDER BY TeamName, Score; +-- +ok +== +SELECT + TeamName, + Player, + Score, + NTILE(0) OVER (PARTITION BY TeamName ORDER BY Score ASC) AS NTILE +FROM ScoreBoard s +ORDER BY TeamName, Score; +-- +ok +== diff --git a/parser/testdata/corpus/sql/window/test_order_by_all.test b/parser/testdata/corpus/sql/window/test_order_by_all.test new file mode 100644 index 0000000..ac43896 --- /dev/null +++ b/parser/testdata/corpus/sql/window/test_order_by_all.test @@ -0,0 +1,25 @@ +# source: test/sql/window/test_order_by_all.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +SELECT i, j, ROW_NUMBER() OVER (ORDER BY ALL) AS rn +FROM ( + SELECT i ,j + FROM generate_series(1, 5) s(i) + CROSS JOIN generate_series(1, 2) t(j) +) t; +-- +error: Parser Error: Cannot ORDER BY ALL in a window expression +== +SELECT + rank() OVER (ORDER BY COLUMNS('^(.*)_score$') DESC) AS '\1_rank' +FROM ( + SELECT + range AS math_score, + 100-range as reading_score + from range(65, 100, 5) +); +-- +ok +== diff --git a/parser/testdata/corpus/sql/window/test_order_by_all.test.metadata.json b/parser/testdata/corpus/sql/window/test_order_by_all.test.metadata.json new file mode 100644 index 0000000..346522d --- /dev/null +++ b/parser/testdata/corpus/sql/window/test_order_by_all.test.metadata.json @@ -0,0 +1,5 @@ +{ + "todo": { + "4fb9fdcecdc6a6db": "transformer-raised parser error: upstream rejects in the transformer, not the grammar; expected to clear as transformers land (milestones 3-5)" + } +} diff --git a/parser/testdata/corpus/sql/window/test_quantile_window.test b/parser/testdata/corpus/sql/window/test_quantile_window.test new file mode 100644 index 0000000..cd559fc --- /dev/null +++ b/parser/testdata/corpus/sql/window/test_quantile_window.test @@ -0,0 +1,215 @@ +# source: test/sql/window/test_quantile_window.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +create table quantiles as select range r from range(10) union all values (NULL), (NULL), (NULL); +-- +ok +== +SELECT r % 2, r, median(r) over (partition by r % 2 order by r) FROM quantiles ORDER BY 1, 2 +-- +ok +== +SELECT r, median(r) over (order by r rows between 1 preceding and 1 following) FROM quantiles ORDER BY 1, 2 +-- +ok +== +SELECT r, median(r) over (order by r rows between 1 preceding and 3 following) FROM quantiles ORDER BY 1, 2 +-- +ok +== +SELECT r, quantile(r, 0.5) over (order by r rows between 1 preceding and 3 following) FROM quantiles ORDER BY 1, 2 +-- +ok +== +SELECT r % 2, r, median(r::VARCHAR) over (partition by r % 2 order by r) FROM quantiles ORDER BY 1, 2 +-- +ok +== +SELECT r, median(r::VARCHAR) over (order by r rows between 1 preceding and 1 following) FROM quantiles ORDER BY 1, 2 +-- +ok +== +SELECT r, quantile(r::VARCHAR, 0.5) over (order by r rows between 1 preceding and 3 following) FROM quantiles ORDER BY 1, 2 +-- +ok +== +SELECT r, median('prefix-' || r::VARCHAR || '-suffix') over (order by r rows between 1 preceding and 1 following) FROM quantiles ORDER BY 1, 2 +-- +ok +== +SELECT r % 3, r, n, median(n) over (partition by r % 3 order by r) +FROM (SELECT r, CASE r % 2 WHEN 0 THEN r ELSE NULL END AS n FROM quantiles) nulls +ORDER BY 1, 2 +-- +ok +== +SELECT r, n, median(n) over (order by r rows between 1 preceding and 1 following) +FROM (SELECT r, CASE r % 2 WHEN 0 THEN r ELSE NULL END AS n FROM quantiles) nulls +ORDER BY 1 +-- +ok +== +SELECT r, n, median(n) over (order by r rows between 1 preceding and 3 following) +FROM (SELECT r, CASE r % 2 WHEN 0 THEN r ELSE NULL END AS n FROM quantiles) nulls +ORDER BY 1 +-- +ok +== +SELECT r, n, median(n) over (order by r rows between unbounded preceding and unbounded following) +FROM (SELECT r, CASE r % 2 WHEN 0 THEN r ELSE NULL END AS n FROM quantiles) nulls +ORDER BY 1 +-- +ok +== +WITH t(i, p, f) AS (VALUES + (0, 1, 1), + (1, 1, 1), + (2, 1, 1), + (3, 3, 1), + (4, 1, 1), + (5, 3, 1) +) +SELECT i, MEDIAN(i) OVER (ORDER BY i ROWS BETWEEN p PRECEDING and f FOLLOWING) +FROM t +ORDER BY 1 +-- +ok +== +WITH t(r, i, p, f) AS (VALUES + (0, 0, 1, 1), + (1, 1, 1, 1), + (2, 2, 1, 1), + (3, 0, 1, 1), + (4, 1, 1, 1), + (5, 2, 1, 1) +) +SELECT r, MEDIAN(i) OVER (ORDER BY r ROWS BETWEEN p PRECEDING and f FOLLOWING) +FROM t +ORDER BY 1 +-- +ok +== +WITH t(r, i, p, f) AS (VALUES + (0, 0, 1, 2), + (1, 1, 1, 2), + (2, 2, 1, 2), + (3, 3, 1, 2), + (4, 4, 1, 2), + (5, 5, 1, 2) +) +SELECT r, QUANTILE_DISC(i, [0.25, 0.5, 0.75]) OVER (ORDER BY r ROWS BETWEEN p PRECEDING and f FOLLOWING) +FROM t +ORDER BY 1 +-- +ok +== +WITH t(r, i, p, f) AS (VALUES + (0, NULL, 1, 2), + (1, 1, 1, 2), + (2, 2, 1, 2), + (3, 3, 1, 2), + (4, 4, 1, 2), + (5, 5, 1, 2) +) +SELECT r, QUANTILE_DISC(i, [0.25, 0.5, 0.75]) OVER (ORDER BY r ROWS BETWEEN p PRECEDING and f FOLLOWING) +FROM t +ORDER BY 1 +-- +ok +== +WITH t(r, i, p, f) AS (VALUES + (0, NULL, 1, 2), + (1, NULL, 1, 2), + (2, NULL, 1, 2), + (3, NULL, 1, 2), + (4, NULL, 1, 2), + (5, NULL, 1, 2) +) +SELECT r, QUANTILE_DISC(i, [0.25, 0.5, 0.75]) OVER (ORDER BY r ROWS BETWEEN p PRECEDING and f FOLLOWING) +FROM t +ORDER BY 1 +-- +ok +== +WITH t(r, i, p, f) AS (VALUES + (0, 0, 1, 2), + (1, 1, 1, 2), + (2, 2, 1, 2), + (3, 3, 1, 2), + (4, 4, 1, 2), + (5, 5, 1, 2) +) +SELECT r, QUANTILE_CONT(i, [0.25, 0.5, 0.75]) OVER (ORDER BY r ROWS BETWEEN p PRECEDING and f FOLLOWING) +FROM t +ORDER BY 1 +-- +ok +== +WITH t(r, i, p, f) AS (VALUES + (0, 0, 1, 2), + (1, 1, 1, 2), + (2, 2, 1, 2), + (3, 0, 1, 2), + (4, 1, 1, 2), + (5, 2, 1, 2) +) +SELECT r, QUANTILE_CONT(i, [0.25, 0.5, 0.75]) OVER (ORDER BY r ROWS BETWEEN p PRECEDING and f FOLLOWING) +FROM t +ORDER BY 1 +-- +ok +== +SELECT r, quantile_disc(i, 0.5) OVER (ORDER BY r ROWS BETWEEN 1 PRECEDING AND 1 FOLLOWING) q +FROM (VALUES + (0, 0), + (1, 1), + (2, 2), + (3, 0), + (4, 1) + ) tbl(r, i) +ORDER BY 1, 2 +-- +ok +== +SELECT r, quantile_cont(i, 0.5) OVER (ORDER BY r ROWS BETWEEN 2 PRECEDING AND 1 FOLLOWING) q +FROM (VALUES + (0, 0), + (1, 1), + (2, 2), + (3, 3), + (4, 0), + (5, 1) + ) tbl(r, i) +ORDER BY 1, 2 +-- +ok +== +SELECT r, quantile_cont(i, 0.5) OVER (ORDER BY r ROWS BETWEEN 2 PRECEDING AND 1 FOLLOWING) q +FROM (VALUES + (0, NULL), + (1, 1), + (2, 2), + (3, 3), + (4, NULL), + (5, 1) + ) tbl(r, i) +ORDER BY 1, 2 +-- +ok +== +WITH t(r, i, p, f) AS (VALUES + (0, 0, 1, 1), + (1, 1, 1, 1), + (2, 2, 1, 1), + (3, 0, 1, 1), + (4, 1, 1, 1), + (5, 2, 1, 1) +) +SELECT r, QUANTILE_DISC(i, 0.5) OVER (ORDER BY r ROWS BETWEEN p PRECEDING and f FOLLOWING) +FROM t +ORDER BY 1 +-- +ok +== diff --git a/parser/testdata/corpus/sql/window/test_range_optimisation.test b/parser/testdata/corpus/sql/window/test_range_optimisation.test new file mode 100644 index 0000000..7b0950e --- /dev/null +++ b/parser/testdata/corpus/sql/window/test_range_optimisation.test @@ -0,0 +1,41 @@ +# source: test/sql/window/test_range_optimisation.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +CREATE TABLE rides ( + id INTEGER, + requested_date DATE, + city VARCHAR, + wait_time INTEGER +); +-- +ok +== +INSERT INTO rides VALUES + (0, '2023-01-05', 'San Francisco', 2925), + (1, '2023-01-03', 'San Francisco', 755), + (2, '2023-01-03', 'San Francisco', 2880), + (3, '2023-01-05', 'San Francisco', 1502), + (4, '2023-01-03', 'San Francisco', 2900), + (5, '2023-01-01', 'San Francisco', 1210), + (6, '2023-01-04', 'San Francisco', 200), + (7, '2023-01-02', 'San Francisco', 980), + (8, '2023-01-02', 'San Francisco', 430), + (9, '2023-01-05', 'San Francisco', 2999), + (10, '2023-01-01', 'San Francisco', 856), + (11, '2023-01-02', 'San Francisco', 490), + (12, '2023-01-02', 'San Francisco', 720), +-- +ok +== +SELECT "id", "requested_date", "city", "wait_time", min("wait_time") OVER win_3d +FROM rides +WINDOW win_3d AS ( + PARTITION BY "city" + ORDER BY requested_date ASC + RANGE BETWEEN INTERVAL 3 DAYS PRECEDING AND INTERVAL 1 DAYS PRECEDING) +ORDER BY "requested_date", "city", "id" +-- +ok +== diff --git a/parser/testdata/corpus/sql/window/test_rank.test b/parser/testdata/corpus/sql/window/test_rank.test new file mode 100644 index 0000000..084f460 --- /dev/null +++ b/parser/testdata/corpus/sql/window/test_rank.test @@ -0,0 +1,40 @@ +# source: test/sql/window/test_rank.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +WITH t AS ( + SELECT i, RANK() OVER (ORDER BY i % 50) AS d + FROM range(3000) tbl(i) +), w AS ( + SELECT d, COUNT(*) as c + FROM t + GROUP BY ALL +) +SELECT COUNT(*), MIN(d), MAX(d), MIN(c), MAX(c) +FROM w +-- +ok +== +WITH t AS ( + SELECT i, RANK() OVER (PARTITION BY i // 3000 ORDER BY i % 50) AS d + FROM range(9000) tbl(i) +), w AS ( + SELECT d, COUNT(*) as c + FROM t + GROUP BY ALL +) +SELECT COUNT(*), MIN(d), MAX(d), MIN(c), MAX(c) +FROM w +-- +ok +== +SELECT + *, + RANK() OVER (ORDER BY x NULLS FIRST) rank_nulls_first, + RANK() OVER (ORDER BY x NULLS LAST) rank_nulls_last, +FROM VALUES (1), (1), (1), (NULL) as issue8315(x) +ORDER BY x +-- +ok +== diff --git a/parser/testdata/corpus/sql/window/test_rank_orderby.test b/parser/testdata/corpus/sql/window/test_rank_orderby.test new file mode 100644 index 0000000..8a18121 --- /dev/null +++ b/parser/testdata/corpus/sql/window/test_rank_orderby.test @@ -0,0 +1,76 @@ +# source: test/sql/window/test_rank_orderby.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +SELECT + i, + (i * 29) % 11 AS outside, + rank(ORDER BY (i // 2) DESC) OVER w, + percent_rank(ORDER BY (i // 2) DESC) OVER w, +FROM range(10) tbl(i) +WINDOW w AS ( + ORDER BY (i * 29) % 11 +) +ORDER BY 2 +-- +ok +== +WITH ranked AS ( + SELECT + i, + i // 100 AS p, + i % 50 AS o, + 100 - 2 * (i % 50) - 1 AS expected, + rank(ORDER BY i % 50 DESC) OVER w AS actual, + FROM range(100_000) tbl(i) + WINDOW w AS ( + PARTITION BY i // 100 + ORDER BY i + ROWS BETWEEN UNBOUNDED PRECEDING AND UNBOUNDED FOLLOWING + ) +) +SELECT * +FROM ranked +WHERE expected <> actual +ORDER BY p, o DESC +LIMIT 20 +-- +ok +== +SELECT + i, + i // 2 AS outside, + rank(ORDER BY i // 2) OVER w, + percent_rank(ORDER BY i // 2) OVER w, +FROM range(10) tbl(i) +WINDOW w AS ( + ORDER BY i // 2 + ROWS BETWEEN 3 PRECEDING AND 3 FOLLOWING +) +ORDER BY 1 +-- +ok +== +SELECT + id, + k, + percent_rank(ORDER BY k) OVER (ORDER BY k, id) AS arg_percent_rank, +FROM (VALUES (1, 1), (2, 1)) tbl(id, k) +ORDER BY id +-- +ok +== +SELECT + id, + k, + rank(ORDER BY k) OVER w, + percent_rank(ORDER BY k) OVER w, +FROM (VALUES (1, 1), (2, 1), (3, 2)) tbl(id, k) +WINDOW w AS ( + ORDER BY k, id +) +ORDER BY id +-- +ok +== diff --git a/parser/testdata/corpus/sql/window/test_rownumber_orderby.test b/parser/testdata/corpus/sql/window/test_rownumber_orderby.test new file mode 100644 index 0000000..0d08bb7 --- /dev/null +++ b/parser/testdata/corpus/sql/window/test_rownumber_orderby.test @@ -0,0 +1,18 @@ +# source: test/sql/window/test_rownumber_orderby.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +SELECT + i, + (i * 29) % 11 AS outside, + row_number(ORDER BY (i // 2) DESC) OVER w, + ntile(4 ORDER BY (i // 2) DESC) OVER w, +FROM range(10) tbl(i) +WINDOW w AS ( + ORDER BY (i * 29) % 11 +) +ORDER BY 2 +-- +ok +== diff --git a/parser/testdata/corpus/sql/window/test_scalar_window.test b/parser/testdata/corpus/sql/window/test_scalar_window.test new file mode 100644 index 0000000..8c351ce --- /dev/null +++ b/parser/testdata/corpus/sql/window/test_scalar_window.test @@ -0,0 +1,33 @@ +# source: test/sql/window/test_scalar_window.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +SELECT row_number() OVER () +-- +ok +== +SELECT avg(42) OVER () +-- +ok +== +SELECT concat() OVER () +-- +ok +== +SELECT nonexistingfunction() OVER () +-- +ok +== +SELECT avg(row_number() over ()) over () +-- +ok +== +SELECT avg(42) over (partition by row_number() over ()) +-- +error: Parser Error: window functions are not allowed in window definitions +== +SELECT avg(42) over (order by row_number() over ()) +-- +error: Parser Error: window functions are not allowed in window definitions +== diff --git a/parser/testdata/corpus/sql/window/test_scalar_window.test.metadata.json b/parser/testdata/corpus/sql/window/test_scalar_window.test.metadata.json new file mode 100644 index 0000000..151055c --- /dev/null +++ b/parser/testdata/corpus/sql/window/test_scalar_window.test.metadata.json @@ -0,0 +1,6 @@ +{ + "todo": { + "2ad67376335b80c3": "transformer-raised parser error: upstream rejects in the transformer, not the grammar; expected to clear as transformers land (milestones 3-5)", + "76691012431cffdd": "transformer-raised parser error: upstream rejects in the transformer, not the grammar; expected to clear as transformers land (milestones 3-5)" + } +} diff --git a/parser/testdata/corpus/sql/window/test_split_partition_heap.test b/parser/testdata/corpus/sql/window/test_split_partition_heap.test new file mode 100644 index 0000000..1070c3a --- /dev/null +++ b/parser/testdata/corpus/sql/window/test_split_partition_heap.test @@ -0,0 +1,13 @@ +# source: test/sql/window/test_split_partition_heap.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +create table partsupp as select uuid()::varchar as c5 from range(8000); +-- +ok +== +SELECT (ntile(5002) OVER (ROWS BETWEEN CURRENT ROW AND CURRENT ROW) >= 0), c5 FROM partsupp; +-- +ok +== diff --git a/parser/testdata/corpus/sql/window/test_streaming_lead_lag.test b/parser/testdata/corpus/sql/window/test_streaming_lead_lag.test new file mode 100644 index 0000000..ee5b728 --- /dev/null +++ b/parser/testdata/corpus/sql/window/test_streaming_lead_lag.test @@ -0,0 +1,152 @@ +# source: test/sql/window/test_streaming_lead_lag.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +EXPLAIN +SELECT i, LAG(i, 1) OVER() AS i1 +FROM range(10) tbl(i); +-- +ok +== +SELECT i, LAG(i, 1) OVER() AS i1 +FROM range(10) tbl(i); +-- +ok +== +EXPLAIN +SELECT i, LAG(i, -1) OVER() AS i1 +FROM range(10) tbl(i); +-- +ok +== +SELECT i, LAG(i, -1) OVER() AS i1 +FROM range(10) tbl(i); +-- +ok +== +EXPLAIN +SELECT i, LEAD(i, -1) OVER() AS i1 +FROM range(10) tbl(i); +-- +ok +== +SELECT i, LEAD(i, -1) OVER() AS i1 +FROM range(10) tbl(i); +-- +ok +== +EXPLAIN +SELECT i, LEAD(i, 1) OVER() AS i1 +FROM range(10) tbl(i); +-- +ok +== +SELECT i, LEAD(i, 1) OVER() AS i1 +FROM range(10) tbl(i); +-- +ok +== +EXPLAIN +SELECT i, LAG(i, 1) OVER() AS i1 +FROM range(3000) tbl(i) +WHERE i % 2 = 0 +QUALIFY i1 <> i - 2 +-- +ok +== +SELECT i, LAG(i, 1) OVER() AS i1 +FROM range(3000) tbl(i) +WHERE i % 2 = 0 +QUALIFY i1 <> i - 2 +-- +ok +== +EXPLAIN +SELECT i, LAG(i, 1, 50) OVER() AS i1 +FROM range(10) tbl(i); +-- +ok +== +SELECT i, LAG(i, 1, 50) OVER() AS i1 +FROM range(10) tbl(i); +-- +ok +== +EXPLAIN +SELECT i, LEAD(i, 1, 50) OVER() AS i1 +FROM range(10) tbl(i); +-- +ok +== +SELECT i, LEAD(i, 1, 50) OVER() AS i1 +FROM range(10) tbl(i); +-- +ok +== +EXPLAIN +SELECT i, LEAD(i, 2) OVER() AS i1 +FROM range(3000) tbl(i) +WHERE i % 2048 = 0 +-- +ok +== +SELECT i, LEAD(i, 2) OVER() AS i1 +FROM range(3000) tbl(i) +WHERE i % 2048 = 0 +-- +ok +== +EXPLAIN +SELECT i, LEAD(i, 2) OVER() AS i1 +FROM range(5000) tbl(i) +WHERE i % 2048 = 0 +-- +ok +== +SELECT i, LEAD(i, 2) OVER() AS i1 +FROM range(5000) tbl(i) +WHERE i % 2048 = 0 +-- +ok +== +EXPLAIN +SELECT i, LAG(i, 3000) OVER() AS i1 +FROM range(5000) tbl(i); +-- +ok +== +EXPLAIN +SELECT i, LEAD(i, 3000) OVER() AS i1 +FROM range(5000) tbl(i); +-- +ok +== +SELECT i, LEAD(i, 1) OVER(), LEAD(i, 2) OVER() +FROM range(10) tbl(i) +-- +ok +== +select * from ( + select + id, + lead(id, 2047, -1) over() l + from range(6144) tbl(id) + where id != 1 + and id != 2 + and id != 2500 + and id != 2501 + and id != 2502 +) +where id >= 2040 and id <= 2050; +-- +ok +== +SELECT LAG ( v3 , 10 , 3 ) OVER( ) +FROM VALUES + ( 0 , 1::VARCHAR , 1 ), + ( 1 , NULL , 2 ) + AS v0(v1, v3, v2); +-- +ok +== diff --git a/parser/testdata/corpus/sql/window/test_streaming_nthvalue.test b/parser/testdata/corpus/sql/window/test_streaming_nthvalue.test new file mode 100644 index 0000000..a25457f --- /dev/null +++ b/parser/testdata/corpus/sql/window/test_streaming_nthvalue.test @@ -0,0 +1,47 @@ +# source: test/sql/window/test_streaming_nthvalue.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +explain select nth_value(i, 1) over () +from range(10) tbl(i) +-- +ok +== +explain select nth_value(i, 2) over (ROWS BETWEEN UNBOUNDED PRECEDING AND CURRENT ROW) +from range(5) tbl(i) +-- +ok +== +select nth_value(i, 2) over (ROWS BETWEEN UNBOUNDED PRECEDING AND CURRENT ROW) +from range(5) tbl(i) +-- +ok +== +explain select nth_value(i, -1) over (ROWS BETWEEN UNBOUNDED PRECEDING AND CURRENT ROW) +from range(5) tbl(i) +-- +ok +== +select nth_value(i, -1) over (ROWS BETWEEN UNBOUNDED PRECEDING AND CURRENT ROW) +from range(5) tbl(i) +-- +ok +== +SELECT s, + nth_value(s, 2 IGNORE NULLS) over(ROWS BETWEEN UNBOUNDED PRECEDING AND CURRENT ROW) +FROM (VALUES + (NULL), + ('A'), + (NULL), + ('B') + ) t(s) +-- +ok +== +select i, nth_value(i, 2049) over(ROWS BETWEEN UNBOUNDED PRECEDING AND CURRENT ROW) n +from range(2049) tbl(i) +QUALIFY n IS NOT NULL; +-- +ok +== diff --git a/parser/testdata/corpus/sql/window/test_streaming_window.test b/parser/testdata/corpus/sql/window/test_streaming_window.test new file mode 100644 index 0000000..540122e --- /dev/null +++ b/parser/testdata/corpus/sql/window/test_streaming_window.test @@ -0,0 +1,421 @@ +# source: test/sql/window/test_streaming_window.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +create table integers (i int, j int) +-- +ok +== +insert into integers values (2, 2), (2, 1), (1, 2), (1, NULL) +-- +ok +== +EXPLAIN +SELECT i, COUNT(*) OVER() FROM integers; +-- +ok +== +EXPLAIN +SELECT i, SUM(i) OVER() FROM integers; +-- +ok +== +EXPLAIN +SELECT j, COUNT(j) FILTER(WHERE i = 2) OVER(ROWS BETWEEN UNBOUNDED PRECEDING AND CURRENT ROW) FROM integers; +-- +ok +== +EXPLAIN +SELECT j, COUNT(*) FILTER(WHERE i = 2) OVER(ROWS BETWEEN UNBOUNDED PRECEDING AND CURRENT ROW) FROM integers; +-- +ok +== +EXPLAIN +SELECT j, SUM(j) FILTER(WHERE i = 2) OVER(ROWS BETWEEN UNBOUNDED PRECEDING AND CURRENT ROW) FROM integers; +-- +ok +== +explain select row_number() over (), i, j from integers +-- +ok +== +select row_number() over (), i, j from integers +-- +ok +== +explain select row_number() over (), i, j from integers where i>1 +-- +ok +== +select row_number() over (), i, j from integers where i>1 +-- +ok +== +explain select rank() over (), i, j from integers +-- +ok +== +select rank() over (), i, j from integers +-- +ok +== +explain select dense_rank() over (), i, j from integers +-- +ok +== +select dense_rank() over (), i, j from integers +-- +ok +== +explain select percent_rank() over (), i, j from integers +-- +ok +== +select percent_rank() over (), i, j from integers +-- +ok +== +EXPLAIN +SELECT i, COUNT(*) OVER(ROWS BETWEEN UNBOUNDED PRECEDING AND CURRENT ROW) FROM integers; +-- +ok +== +SELECT i, COUNT(*) OVER(ROWS BETWEEN UNBOUNDED PRECEDING AND CURRENT ROW) FROM integers; +-- +ok +== +EXPLAIN +SELECT i, COUNT(*) FILTER(WHERE i = 2) OVER(ROWS BETWEEN UNBOUNDED PRECEDING AND CURRENT ROW) FROM integers; +-- +ok +== +SELECT i, COUNT(*) FILTER(WHERE i = 2) OVER(ROWS BETWEEN UNBOUNDED PRECEDING AND CURRENT ROW) FROM integers; +-- +ok +== +EXPLAIN +SELECT j, COUNT(j) OVER(ROWS BETWEEN UNBOUNDED PRECEDING AND CURRENT ROW) FROM integers; +-- +ok +== +SELECT j, COUNT(j) OVER(ROWS BETWEEN UNBOUNDED PRECEDING AND CURRENT ROW) FROM integers; +-- +ok +== +EXPLAIN +SELECT i, SUM(i) OVER(ROWS BETWEEN UNBOUNDED PRECEDING AND CURRENT ROW) FROM integers; +-- +ok +== +SELECT i, SUM(i) OVER(ROWS BETWEEN UNBOUNDED PRECEDING AND CURRENT ROW) FROM integers; +-- +ok +== +EXPLAIN +SELECT SUM(s) FROM ( + SELECT SUM(i) OVER(ROWS BETWEEN UNBOUNDED PRECEDING AND CURRENT ROW) s + FROM range(5000) tbl(i) +); +-- +ok +== +SELECT SUM(s) FROM ( + SELECT SUM(i) OVER(ROWS BETWEEN UNBOUNDED PRECEDING AND CURRENT ROW) s + FROM range(5000) tbl(i) +); +-- +ok +== +explain select i, j, first_value(i) over (), first_value(j) over () from integers +-- +ok +== +EXPLAIN +SELECT first_value(i) OVER (ROWS BETWEEN UNBOUNDED PRECEDING AND CURRENT ROW) +FROM integers; +-- +ok +== +select i, j, first_value(i) over (), first_value(j) over () from integers +-- +ok +== +select row_number() over (), first_value(i) over (), first_value(j) over () from integers +-- +ok +== +EXPLAIN +SELECT first_value(i) OVER (ROWS BETWEEN CURRENT ROW AND CURRENT ROW) +FROM range(4) t(i); +-- +ok +== +SELECT i, + first_value(i) OVER (ROWS BETWEEN CURRENT ROW AND CURRENT ROW), + first_value(i) OVER (ROWS BETWEEN 1 PRECEDING AND CURRENT ROW), + first_value(i) OVER (ROWS BETWEEN 1 FOLLOWING AND 1 FOLLOWING), + first_value(i) OVER (ROWS BETWEEN CURRENT ROW AND UNBOUNDED FOLLOWING) +FROM range(4) t(i); +-- +ok +== +EXPLAIN +SELECT first_value(i) OVER (GROUPS BETWEEN UNBOUNDED PRECEDING AND CURRENT ROW) +FROM integers; +-- +ok +== +EXPLAIN +SELECT first_value(i) OVER (ROWS BETWEEN UNBOUNDED PRECEDING AND UNBOUNDED FOLLOWING) +FROM integers; +-- +ok +== +SELECT i, j, + first_value(i) OVER (GROUPS BETWEEN UNBOUNDED PRECEDING AND CURRENT ROW), + first_value(j) OVER (ROWS BETWEEN UNBOUNDED PRECEDING AND UNBOUNDED FOLLOWING) +FROM integers; +-- +ok +== +EXPLAIN +SELECT first_value(i) OVER (RANGE BETWEEN UNBOUNDED PRECEDING AND CURRENT ROW) +FROM integers; +-- +ok +== +EXPLAIN +SELECT first_value(i) OVER (RANGE BETWEEN UNBOUNDED PRECEDING AND UNBOUNDED FOLLOWING) +FROM integers; +-- +ok +== +SELECT i, + first_value(i) OVER (RANGE BETWEEN UNBOUNDED PRECEDING AND CURRENT ROW), + first_value(i) OVER (RANGE BETWEEN UNBOUNDED PRECEDING AND UNBOUNDED FOLLOWING) +FROM integers; +-- +ok +== +EXPLAIN +SELECT first_value(i) OVER (RANGE BETWEEN CURRENT ROW AND UNBOUNDED FOLLOWING) +FROM integers; +-- +ok +== +EXPLAIN +SELECT first_value(i) OVER (ORDER BY i RANGE BETWEEN UNBOUNDED PRECEDING AND CURRENT ROW) +FROM integers; +-- +ok +== +SELECT i, first_value(i) OVER (RANGE BETWEEN CURRENT ROW AND UNBOUNDED FOLLOWING) +FROM integers; +-- +ok +== +SELECT i, first_value(i) OVER (ORDER BY i RANGE BETWEEN UNBOUNDED PRECEDING AND CURRENT ROW) +FROM integers; +-- +ok +== +select row_number() over (), row_number() over () from integers +-- +ok +== +explain select first_value(i IGNORE NULLS) over () from integers +-- +ok +== +explain select first_value(i IGNORE NULLS) over (ROWS BETWEEN UNBOUNDED PRECEDING AND CURRENT ROW) +from integers +-- +ok +== +explain select last_value(i IGNORE NULLS) over () from integers +-- +ok +== +explain select last_value(i IGNORE NULLS) over (ROWS BETWEEN UNBOUNDED PRECEDING AND CURRENT ROW) +from integers +-- +ok +== +SELECT s, + first(s IGNORE NULLS) over(ROWS BETWEEN UNBOUNDED PRECEDING AND CURRENT ROW) +FROM (VALUES (NULL), ('A'), (NULL), ('B')) t(s) +-- +ok +== +SELECT s, + last(s IGNORE NULLS) over(ROWS BETWEEN UNBOUNDED PRECEDING AND CURRENT ROW) +FROM (VALUES (NULL), ('A'), (NULL), ('B')) t(s) +-- +ok +== +SELECT s, + last(s IGNORE NULLS) over(ROWS BETWEEN UNBOUNDED PRECEDING AND CURRENT ROW) +FROM (VALUES ('A'), (NULL), ('B'), (NULL)) t(s) +-- +ok +== +SELECT s, + first(s IGNORE NULLS) over(ROWS BETWEEN UNBOUNDED PRECEDING AND CURRENT ROW) +FROM (VALUES ('A'), (NULL), ('B'), (NULL)) t(s) +-- +ok +== +WITH alternate AS ( + SELECT + range r, + IF(range % 2, range, NULL) s + FROM range(3000) +) +SELECT + r, + s, + last(s IGNORE NULLS) over(ROWS BETWEEN UNBOUNDED PRECEDING AND CURRENT ROW) l +FROM alternate +QUALIFY l <> r - ((r + 1) % 2) +-- +ok +== +WITH alternate AS ( + SELECT + range r, + IF(range < 2100, NULL, range) s + FROM range(3000) +) +SELECT + r, + s, + first(s IGNORE NULLS) over(ROWS BETWEEN UNBOUNDED PRECEDING AND CURRENT ROW) f +FROM alternate +QUALIFY (f IS NOT NULL AND r < 2100) + OR (f IS NULL AND r >= 2100) +-- +ok +== +explain select first_value(i) over (), last_value(i) over () from integers +-- +ok +== +explain select last_value(i) over (), first_value(i) over () from integers +-- +ok +== +explain select first_value(i) over (), last_value(i) over (order by j) from integers +-- +ok +== +explain select last_value(i) over (order by j), first_value(i) over () from integers +-- +ok +== +CREATE TABLE v1(id bigint); +-- +ok +== +CREATE TABLE v2(id bigint); +-- +ok +== +INSERT INTO v1 VALUES (11), (12), (13); +-- +ok +== +INSERT INTO v2 VALUES (21), (22); +-- +ok +== +CREATE VIEW vertices_view AS + SELECT * FROM v1 + UNION ALL + SELECT * FROM v2; +-- +ok +== +SELECT id AS sparse_id, row_number() OVER () AS rnum +FROM vertices_view; +-- +ok +== +WITH RECURSIVE rte AS ( + SELECT 1 l, 1::BIGINT r + UNION ALL + SELECT l+1, row_number() OVER() + FROM rte + WHERE l < 3 +) +SELECT * FROM rte; +-- +ok +== +PREPARE sw1 AS + SELECT i, row_number() OVER() AS row_no + FROM range(10, 20) tbl(i) + QUALIFY row_no <= ?::BIGINT +; +-- +ok +== +EXECUTE sw1(10); +-- +ok +== +EXECUTE sw1(2); +-- +ok +== +from (values ({'key': 'A'}), ({'key': 'B'}), ({'key': 'C'})) +select + list(col0) over (rows between unbounded preceding and current row) as result +-- +ok +== +CREATE TABLE issue17621(i INT, j INT, k INT); +-- +ok +== +INSERT INTO issue17621 VALUES (1,1,1), + (1,4,1), + (1,2,1), + (1,4,1), + (1,4,1), + (1,1,2), + (1,4,2), + (1,2,2), + (1,4,2), + (1,1,3), + (1,4,3), + (1,2,3), + (1,4,3), + (1,1,4), + (1,4,4), + (1,2,4), + (1,4,4); +-- +ok +== +SELECT + k, + STDDEV_POP(i), + SUM(j), + STDDEV_SAMP(k) OVER (ORDER BY k NULLS FIRST ROWS UNBOUNDED PRECEDING) std_wf +FROM issue17621 +GROUP BY ROLLUP(k) +ORDER BY k NULLS FIRST +-- +ok +== +WITH start_and_inputs AS ( + SELECT 50 AS moves + UNION ALL + SELECT 50 AS moves +) +SELECT moves, sum(moves) OVER (ROWS BETWEEN UNBOUNDED PRECEDING AND CURRENT ROW) AS sum +FROM start_and_inputs; +-- +ok +== diff --git a/parser/testdata/corpus/sql/window/test_streaming_window_distinct.test b/parser/testdata/corpus/sql/window/test_streaming_window_distinct.test new file mode 100644 index 0000000..7836e2e --- /dev/null +++ b/parser/testdata/corpus/sql/window/test_streaming_window_distinct.test @@ -0,0 +1,44 @@ +# source: test/sql/window/test_streaming_window_distinct.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +explain +SELECT i, + SUM(DISTINCT i % 3) OVER (ROWS BETWEEN UNBOUNDED PRECEDING AND CURRENT ROW) +FROM range(10) tbl(i) +-- +ok +== +SELECT i, + SUM(DISTINCT i % 3) OVER (ROWS BETWEEN UNBOUNDED PRECEDING AND CURRENT ROW) +FROM range(10) tbl(i) +-- +ok +== +EXPLAIN +SELECT + LIST(DISTINCT col0) OVER (ROWS BETWEEN UNBOUNDED PRECEDING AND CURRENT ROW) AS result +FROM (VALUES ({'key': 'A'}), ({'key': 'B'}), ({'key': 'A'})) +-- +ok +== +SELECT + LIST(DISTINCT col0) OVER (ROWS BETWEEN UNBOUNDED PRECEDING AND CURRENT ROW) AS result +FROM (VALUES ({'key': 'A'}), ({'key': 'B'}), ({'key': 'A'})) +-- +ok +== +explain +SELECT i, + SUM(DISTINCT i % 5) FILTER (i % 3 = 0) OVER (ROWS BETWEEN UNBOUNDED PRECEDING AND CURRENT ROW) +FROM range(20) tbl(i) +-- +ok +== +SELECT i, + SUM(DISTINCT i % 5) FILTER (i % 3 = 0) OVER (ROWS BETWEEN UNBOUNDED PRECEDING AND CURRENT ROW) +FROM range(20) tbl(i) +-- +ok +== diff --git a/parser/testdata/corpus/sql/window/test_thread_count.test b/parser/testdata/corpus/sql/window/test_thread_count.test new file mode 100644 index 0000000..fbfc305 --- /dev/null +++ b/parser/testdata/corpus/sql/window/test_thread_count.test @@ -0,0 +1,18 @@ +# source: test/sql/window/test_thread_count.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +select row_number() over () +, count(distinct upper_ch1_ch2) over()::int as num_bigrams +, sum(count_ch1_ch2) over () as bigram_count_all +, count_ch1_ch2 / bigram_count_all as actual_bigram_frequency +, ch1.actual_frequency * ch2.actual_frequency as expected_bigram_frequency +from read_csv('{DATA_DIR}/csv/issue_13525/stat_bigrams.csv') as stat_bigrams +inner join read_csv('{DATA_DIR}/csv/issue_13525/stat_stat_chars.csv') as ch1 +on stat_bigrams.ascii_upper_ch1 = ch1.ascii_upper_ch +inner join read_csv('{DATA_DIR}/csv/issue_13525/stat_stat_chars.csv') as ch2 +on stat_bigrams.ascii_upper_ch2 = ch2.ascii_upper_ch; +-- +ok +== diff --git a/parser/testdata/corpus/sql/window/test_tpcc_results.test b/parser/testdata/corpus/sql/window/test_tpcc_results.test new file mode 100644 index 0000000..14d7734 --- /dev/null +++ b/parser/testdata/corpus/sql/window/test_tpcc_results.test @@ -0,0 +1,24 @@ +# source: test/sql/window/test_tpcc_results.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +select + submission_date, + dbsystem, + tps, + count(distinct dbsystem) over w AS competing, + rank(order by tps desc) over w AS new_rank, + first_value(tps order by tps desc) over w AS best_performance, + first_value(dbsystem order by tps desc) over w AS best_system, + lead(tps order by tps desc) over w AS second_performance, + lead(dbsystem order by tps desc, dbsystem) over w AS second_system, +from '{DATA_DIR}/csv/tpcc_results.csv' +window w as ( + order by submission_date + range between unbounded preceding and current row +) +ORDER BY ALL; +-- +ok +== diff --git a/parser/testdata/corpus/sql/window/test_tpcds_q49.test b/parser/testdata/corpus/sql/window/test_tpcds_q49.test new file mode 100644 index 0000000..30e7d81 --- /dev/null +++ b/parser/testdata/corpus/sql/window/test_tpcds_q49.test @@ -0,0 +1,17 @@ +# source: test/sql/window/test_tpcds_q49.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +create table wintest( item integer, return_ratio numeric, currency_ratio numeric) +-- +ok +== +insert into wintest values (7539 ,0.590000 , 0.590000), (3337 ,0.626506 , 0.626506), (15597 ,0.661972 , 0.661972), (2915 ,0.698630 , 0.698630), (11933 ,0.717172 , 0.717172), (483 ,0.800000 , 0.800000), (85 ,0.857143 , 0.857143), (97 ,0.903614 , 0.903614), (117 ,0.925000 , 0.925000), (5299 ,0.927083 , 0.927083), (10055 ,0.945652 , 0.945652), (4231 ,0.977778 , 0.977778), (5647 ,0.987805 , 0.987805), (8679 ,0.988764 , 0.988764), (10323 ,0.977778 , 1.111111), (3305 ,0.737500 , 1.293860) +-- +ok +== +SELECT item, rank() OVER (ORDER BY return_ratio) AS return_rank, rank() OVER (ORDER BY currency_ratio) AS currency_rank FROM wintest order by item +-- +ok +== diff --git a/parser/testdata/corpus/sql/window/test_value_exclude.test b/parser/testdata/corpus/sql/window/test_value_exclude.test new file mode 100644 index 0000000..f26a676 --- /dev/null +++ b/parser/testdata/corpus/sql/window/test_value_exclude.test @@ -0,0 +1,39 @@ +# source: test/sql/window/test_value_exclude.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +WITH src(id, v) AS ( + VALUES + (1, 10), + (2, 20) +) +SELECT + id, + {vfunc}(v ORDER BY v DESC) OVER ( + ORDER BY id + ROWS BETWEEN UNBOUNDED PRECEDING AND UNBOUNDED FOLLOWING + EXCLUDE CURRENT ROW + ) AS actual +FROM src +ORDER BY id; +-- +error: Parser Error: syntax error at or near "}" +== +WITH src(id, v) AS ( + VALUES + (1, 10), + (2, 20) +) +SELECT + id, + NTH_VALUE(v, 0 ORDER BY v DESC) OVER ( + ORDER BY id + ROWS BETWEEN UNBOUNDED PRECEDING AND UNBOUNDED FOLLOWING + EXCLUDE CURRENT ROW + ) AS actual +FROM src +ORDER BY id; +-- +ok +== diff --git a/parser/testdata/corpus/sql/window/test_value_orderby.test b/parser/testdata/corpus/sql/window/test_value_orderby.test new file mode 100644 index 0000000..849a78b --- /dev/null +++ b/parser/testdata/corpus/sql/window/test_value_orderby.test @@ -0,0 +1,91 @@ +# source: test/sql/window/test_value_orderby.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +SELECT + i, + (i * 29) % 11 AS outside, + first_value(i ORDER BY i DESC) OVER w, + last_value(i ORDER BY i DESC) OVER w, + nth_value(i, 2 ORDER BY i DESC) OVER w, +FROM range(10) tbl(i) +WINDOW w AS ( + ORDER BY (i * 29) % 11 + ROWS BETWEEN 3 PRECEDING AND 3 FOLLOWING +) +ORDER BY 2 +-- +ok +== +with IDS as ( + select * as idx from generate_series(1,4) +),DATA as ( + select *, (case when idx != 3 then idx * 1.0 else NULL end) as value from IDS +) +SELECT + last(value ORDER BY idx IGNORE NULLS) OVER (ORDER BY idx ROWS BETWEEN UNBOUNDED PRECEDING AND 0 FOLLOWING) +FROM DATA +-- +ok +== +CREATE TABLE all_nulls (order_col int,value_col float,partition_col int); +-- +ok +== +INSERT INTO all_nulls VALUES (2,NULL,10); +-- +ok +== +INSERT INTO all_nulls VALUES (1,NULL,10); +-- +ok +== +SELECT first_value(value_col ORDER BY order_col IGNORE NULLS) over (PARTITION BY partition_col) +FROM all_nulls; +-- +ok +== +SELECT last_value(value_col ORDER BY order_col IGNORE NULLS) over (PARTITION BY partition_col) +FROM all_nulls; +-- +ok +== +SELECT nth_value(value_col, 1 ORDER BY order_col IGNORE NULLS) over (PARTITION BY partition_col) +FROM all_nulls; +-- +ok +== +WITH t(a,b) AS ( + VALUES + (0, 'a'), (0, 'b'), + (1, 'c'), + (2, 'd'), (2, 'e'), (2, 'f') +), framed AS ( + SELECT a, b, + nth_value(b, 1) OVER w AS b1, + nth_value(b, 1 ORDER BY b) OVER w AS b1_ordered, + FROM t + WINDOW w AS (ORDER BY a RANGE BETWEEN CURRENT ROW AND CURRENT ROW) +) +FROM framed +where a = 1 +-- +ok +== +WITH t(a, q) AS ( + VALUES + (1, NULL), + (2, 0) +) +SELECT + a, + q, + FIRST_VALUE(q ORDER BY 1 IGNORE NULLS) OVER ( + PARTITION BY q, a + ) AS actual +FROM t +ORDER BY a; +-- +ok +== diff --git a/parser/testdata/corpus/sql/window/test_volatile_independence.test b/parser/testdata/corpus/sql/window/test_volatile_independence.test new file mode 100644 index 0000000..58f9cc5 --- /dev/null +++ b/parser/testdata/corpus/sql/window/test_volatile_independence.test @@ -0,0 +1,21 @@ +# source: test/sql/window/test_volatile_independence.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +SELECT + list(random()) OVER (ORDER BY id), + max(random()) OVER (ORDER BY id) +FROM range(3) t(id); +-- +ok +== +SELECT count(*) FROM ( + SELECT + any_value(uuid()::varchar) OVER (PARTITION BY g) AS id_a, + any_value(uuid()::varchar) OVER (PARTITION BY g) AS id_b + FROM (VALUES (1),(1),(2),(2)) t(g) +) WHERE id_a = id_b; +-- +ok +== diff --git a/parser/testdata/corpus/sql/window/test_wide_orderby.test b/parser/testdata/corpus/sql/window/test_wide_orderby.test new file mode 100644 index 0000000..1766a3a --- /dev/null +++ b/parser/testdata/corpus/sql/window/test_wide_orderby.test @@ -0,0 +1,27 @@ +# source: test/sql/window/test_wide_orderby.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +PRAGMA debug_force_external={forced} +-- +error: Parser Error: syntax error at or near "}" +== +SELECT last_value(i ORDER BY i DESC) OVER w AS crash +FROM range(5_000) tbl(i) +WINDOW w AS (ORDER BY i ASC) +-- +ok +== +SELECT rank(ORDER BY i DESC) OVER w AS crash +FROM range(5_000) tbl(i) +WINDOW w AS (ORDER BY i ASC) +-- +ok +== +SELECT cume_dist(ORDER BY i DESC) OVER w AS crash +FROM range(5_000) tbl(i) +WINDOW w AS (ORDER BY i ASC) +-- +ok +== diff --git a/parser/testdata/corpus/sql/window/test_window_aggregate_macro.test b/parser/testdata/corpus/sql/window/test_window_aggregate_macro.test new file mode 100644 index 0000000..c5cb3a1 --- /dev/null +++ b/parser/testdata/corpus/sql/window/test_window_aggregate_macro.test @@ -0,0 +1,27 @@ +# source: test/sql/window/test_window_aggregate_macro.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +CREATE MACRO tinyint_min(a) as cast(min(a) as tinyint); +-- +ok +== +CREATE MACRO max_plus_one(a) as 1 + max(a); +-- +ok +== +create or replace table test as ( + select unnest(range(1000)) as x +); +-- +ok +== +SELECT tinyint_min(x), max_plus_one(x) FROM test; +-- +ok +== +SELECT DISTINCT tinyint_min(x) OVER (), max_plus_one(x) OVER () FROM test; +-- +ok +== diff --git a/parser/testdata/corpus/sql/window/test_window_binding.test b/parser/testdata/corpus/sql/window/test_window_binding.test new file mode 100644 index 0000000..4cccded --- /dev/null +++ b/parser/testdata/corpus/sql/window/test_window_binding.test @@ -0,0 +1,29 @@ +# source: test/sql/window/test_window_binding.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +SELECT MIN(a) OVER (PARTITION BY i ORDER BY i) FROM integers +-- +ok +== +SELECT MIN(i) OVER (PARTITION BY a ORDER BY i) FROM integers +-- +ok +== +SELECT MIN(i) OVER (PARTITION BY i ORDER BY a) FROM integers +-- +ok +== +SELECT MIN(i) OVER (PARTITION BY i, a ORDER BY i) FROM integers +-- +ok +== +SELECT MIN(i) OVER (PARTITION BY i ORDER BY i, a) FROM integers +-- +ok +== +SELECT MIN(i) OVER (PARTITION BY i ORDER BY i) FROM integers +-- +ok +== diff --git a/parser/testdata/corpus/sql/window/test_window_binding_ctes.test b/parser/testdata/corpus/sql/window/test_window_binding_ctes.test new file mode 100644 index 0000000..8821fe7 --- /dev/null +++ b/parser/testdata/corpus/sql/window/test_window_binding_ctes.test @@ -0,0 +1,53 @@ +# source: test/sql/window/test_window_binding_ctes.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +select i, lag(i) over named_window from (values (1), (2), (3)) as t (i) window named_window as (order by i); +-- +ok +== +with subquery as (select i, lag(i) over named_window from (values (1), (2), (3)) as t (i) window named_window as (order by i)) select * from subquery; +-- +ok +== +select * from (select i, lag(i) over named_window from (values (1), (2), (3)) as t (i) window named_window as (order by i)) t1; +-- +ok +== +CREATE VIEW v1 AS select i, lag(i) over named_window from (values (1), (2), (3)) as t (i) window named_window as (order by i); +-- +ok +== +SELECT * FROM (SELECT i, lag(i) OVER named_window FROM ( VALUES (1), (2), (3)) AS t (i) window named_window AS ( ORDER BY i)) t1, (SELECT i, lag(i) OVER named_window FROM ( VALUES (1), (2), (3)) AS t (i) window named_window AS ( ORDER BY i)) t2 ORDER BY 1, 2, 3, 4; +-- +ok +== +WITH subquery AS (SELECT i, lag(i) OVER named_window FROM ( VALUES (1), (2), (3)) AS t (i)) SELECT * FROM subquery window named_window AS ( ORDER BY i); +-- +error: Parser Error: window "named_window" does not exist +== +select i, lag(i) over named_window from (values (1), (2), (3)) as t (i) window named_window as (order by i), named_window as (order by j); +-- +error: Parser Error: window "named_window" is already defined +== +CREATE TABLE a (id INT); +-- +ok +== +WITH + cte_a AS ( + SELECT * + FROM a + WINDOW my_window AS () + ), + cte_b AS ( + SELECT * + FROM a + WINDOW my_window AS () + ) +SELECT * +FROM cte_a CROSS JOIN cte_b; +-- +ok +== diff --git a/parser/testdata/corpus/sql/window/test_window_binding_ctes.test.metadata.json b/parser/testdata/corpus/sql/window/test_window_binding_ctes.test.metadata.json new file mode 100644 index 0000000..18824f2 --- /dev/null +++ b/parser/testdata/corpus/sql/window/test_window_binding_ctes.test.metadata.json @@ -0,0 +1,6 @@ +{ + "todo": { + "0e8d373f8ebea010": "transformer-raised parser error: upstream rejects in the transformer, not the grammar; expected to clear as transformers land (milestones 3-5)", + "d2db65c424b476be": "transformer-raised parser error: upstream rejects in the transformer, not the grammar; expected to clear as transformers land (milestones 3-5)" + } +} diff --git a/parser/testdata/corpus/sql/window/test_window_bool.test b/parser/testdata/corpus/sql/window/test_window_bool.test new file mode 100644 index 0000000..fbd56e1 --- /dev/null +++ b/parser/testdata/corpus/sql/window/test_window_bool.test @@ -0,0 +1,37 @@ +# source: test/sql/window/test_window_bool.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +create table a as select range%2==0 j, range::integer AS i from range(1, 5, 1) +-- +ok +== +select j, i, sum(i) over () from a order by 1,2 +-- +ok +== +select j, i, sum(i) over (partition by j) from a order by 1,2 +-- +ok +== +select j, i, sum(i) over (partition by j order by i) from a order by 1,2 +-- +ok +== +create table a as select range%2 j, range%3==0 AS i from range(1, 5, 1) +-- +ok +== +select j, i, bool_and(i) over (), bool_or(i) over () from a order by 1,2 +-- +ok +== +select j, i, bool_and(i) over (partition by j), bool_or(i) over (partition by j) from a order by 1,2 +-- +ok +== +select j, i, bool_and(not i) over (partition by j order by i), bool_and(i) over (partition by j order by i), bool_or(i) over (partition by j order by i) from a order by 1,2 +-- +ok +== diff --git a/parser/testdata/corpus/sql/window/test_window_clause.test b/parser/testdata/corpus/sql/window/test_window_clause.test new file mode 100644 index 0000000..10f6e6c --- /dev/null +++ b/parser/testdata/corpus/sql/window/test_window_clause.test @@ -0,0 +1,111 @@ +# source: test/sql/window/test_window_clause.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +create table integers as select range i from range(0,16); +-- +ok +== +select max(base), max(referenced), sum(refined), sum(unrefined) from ( + select + row_number() over w AS base, + row_number() over (w) as referenced, + sum(i % 4) over (w rows between 1 preceding and 1 following) AS refined, + sum(i % 4) over (rows between 1 preceding and 1 following) AS unrefined + from integers + WINDOW w AS (partition by i // 4 order by i % 4) +) q; +-- +ok +== +select + x, y, + count(*) over (partition by y order by x), + count(*) over (w order by x) +from (values (1, 1), (2, 1), (3, 2), (4, 2)) as t (x, y) +window w as (partition by y) +order by x +-- +ok +== +select + x, y, + count(*) over (partition by y order by x), + count(*) over (w order by x) +from (values (1, 1), (2, 1), (3, 2), (4, 2)) as t (x, y) +window w as (partition by y order by x desc) +order by x +-- +error: Parser Error: Cannot override ORDER BY clause of window "w" +== +select + x, y, + count(*) over (partition by y order by x), + count(*) over (w partition by y) +from (values (1, 1), (2, 1), (3, 2), (4, 2)) as t (x, y) +window w as (partition by x) +order by x +-- +error: Parser Error: Cannot override PARTITION BY clause of window "w" +== +select i, sum(i) over (w) as smoothed +from integers +window w AS (order by i rows between 1 preceding and 1 following) +order by i; +-- +error: Parser Error: cannot copy window "w" because it has a frame clause +== +SELECT sum(1) over cumulativeSum +FROM integers +WINDOW cumulativeSum AS (), + cumulativesum AS (order by i rows between 1 preceding and 1 following); +-- +error: Parser Error: window "cumulativesum" is already defined +== +SELECT sum(i) over cumulativeSum +FROM integers +WINDOW cumulativeSum AS (); +-- +ok +== +SELECT count(*) OVER w AS x +FROM (VALUES (1), (2)) AS t(a) +WINDOW base AS (ORDER BY a), w AS (base ROWS BETWEEN CURRENT ROW AND UNBOUNDED FOLLOWING) +ORDER BY a; +-- +ok +== +SELECT count(*) OVER w AS x +FROM (VALUES (1), (2)) AS t(a) +WINDOW base AS (ORDER BY a), w AS (base) +ORDER BY a; +-- +ok +== +SELECT count(*) OVER w AS x +FROM (VALUES (1), (2)) AS t(a) +WINDOW base AS (ORDER BY a), w AS (base RANGE BETWEEN CURRENT ROW AND UNBOUNDED FOLLOWING) +ORDER BY a; +-- +ok +== +SELECT count(*) OVER w AS x +FROM (VALUES (1), (2)) AS t(a) +WINDOW base AS (ORDER BY a), w AS (base GROUPS BETWEEN CURRENT ROW AND UNBOUNDED FOLLOWING) +ORDER BY a; +-- +ok +== +SELECT count(*) OVER w +FROM (VALUES (1), (2)) AS t(a) +WINDOW w AS (base), base AS (ORDER BY a); +-- +error: Parser Error: window "base" does not exist +== +SELECT count(*) OVER w +FROM (VALUES (1), (2)) AS t(a) +WINDOW w AS (w); +-- +error: Parser Error: window "w" does not exist +== diff --git a/parser/testdata/corpus/sql/window/test_window_clause.test.metadata.json b/parser/testdata/corpus/sql/window/test_window_clause.test.metadata.json new file mode 100644 index 0000000..d526261 --- /dev/null +++ b/parser/testdata/corpus/sql/window/test_window_clause.test.metadata.json @@ -0,0 +1,10 @@ +{ + "todo": { + "84dedaaf2db41fc2": "transformer-raised parser error: upstream rejects in the transformer, not the grammar; expected to clear as transformers land (milestones 3-5)", + "9c47af271ef9c2f9": "transformer-raised parser error: upstream rejects in the transformer, not the grammar; expected to clear as transformers land (milestones 3-5)", + "9e4603bc2eea26a4": "transformer-raised parser error: upstream rejects in the transformer, not the grammar; expected to clear as transformers land (milestones 3-5)", + "c4a0f47f624c993b": "transformer-raised parser error: upstream rejects in the transformer, not the grammar; expected to clear as transformers land (milestones 3-5)", + "ce8e3949514da730": "transformer-raised parser error: upstream rejects in the transformer, not the grammar; expected to clear as transformers land (milestones 3-5)", + "ea6eacac12b584cf": "transformer-raised parser error: upstream rejects in the transformer, not the grammar; expected to clear as transformers land (milestones 3-5)" + } +} diff --git a/parser/testdata/corpus/sql/window/test_window_constant_aggregate.test b/parser/testdata/corpus/sql/window/test_window_constant_aggregate.test new file mode 100644 index 0000000..4deb5c6 --- /dev/null +++ b/parser/testdata/corpus/sql/window/test_window_constant_aggregate.test @@ -0,0 +1,190 @@ +# source: test/sql/window/test_window_constant_aggregate.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +SELECT part, id, sum(val) OVER(PARTITION BY part ORDER BY id), lead(val) OVER(PARTITION BY part ORDER BY id) +FROM (SELECT range AS id, range % 5 AS part, range AS val FROM range(13)) t +ORDER BY ALL; +-- +ok +== +SELECT part, id, list_sort(list(val) OVER(PARTITION BY part)) +FROM (SELECT range AS id, range % 5 AS part, range AS val FROM range(13)) t +ORDER BY ALL; +-- +ok +== +SELECT part, min(const) AS lo, max(const) AS hi +FROM ( + SELECT part, sum(val) OVER(PARTITION BY part) as const + FROM ( + (SELECT 1 AS part, range AS val FROM range(73)) + UNION ALL + (SELECT 2 AS part, range AS val FROM range(75)) + UNION ALL + (SELECT 3 AS part, range AS val FROM range(77)) + UNION ALL + (SELECT 4 AS part, range AS val FROM range(79)) + UNION ALL + (SELECT 5 AS part, range AS val FROM range(81)) + UNION ALL + (SELECT 6 AS part, range AS val FROM range(83)) + ) u +) t +GROUP BY ALL +ORDER BY ALL +; +-- +ok +== +SELECT part, min(const) AS lo, max(const) AS hi +FROM ( + SELECT part, sum(val) OVER(PARTITION BY part) AS const + FROM ( + SELECT part, val + FROM ( + (SELECT range as part, random() AS val FROM range(10)) r + CROSS JOIN + range(3000) + ) p + ) t +) w +GROUP BY ALL +HAVING lo <> hi +ORDER BY ALL +; +-- +ok +== +CREATE TABLE issue7353 ( + Season VARCHAR, + Medal VARCHAR, + Sex VARCHAR, + Ct INT, + Depth INT +); +-- +ok +== +INSERT INTO issue7353 (Season, Medal, Sex, Ct, Depth) VALUES + (NULL, NULL, NULL, 271116, 0), + ('Summer', NULL, NULL, 222552, 1), + ('Winter', NULL, NULL, 48564, 1), + ('Summer', 'NA', NULL, 188464, 2), + ('Summer', 'Gold', NULL, 11459, 2), + ('Winter', 'NA', NULL, 42869, 2), + ('Summer', 'Bronze', NULL, 11409, 2), + ('Winter', 'Bronze', NULL, 1886, 2), + ('Winter', 'Gold', NULL, 1913, 2), + ('Winter', 'Silver', NULL, 1896, 2), + ('Summer', 'Silver', NULL, 11220, 2), + ('Summer', 'NA', 'M', 138463, 3), + ('Summer', 'Gold', 'M', 8319, 3), + ('Winter', 'NA', 'F', 13268, 3), + ('Winter', 'NA', 'M', 29601, 3), + ('Summer', 'NA', 'F', 50001, 3), + ('Summer', 'Bronze', 'M', 8235, 3), + ('Winter', 'Bronze', 'M', 1289, 3), + ('Winter', 'Gold', 'M', 1306, 3), + ('Winter', 'Silver', 'M', 1289, 3), + ('Summer', 'Gold', 'F', 3140, 3), + ('Summer', 'Silver', 'M', 8092, 3), + ('Summer', 'Bronze', 'F', 3174, 3), + ('Summer', 'Silver', 'F', 3128, 3), + ('Winter', 'Bronze', 'F', 597, 3), + ('Winter', 'Gold', 'F', 607, 3), + ('Winter', 'Silver', 'F', 607, 3); +-- +ok +== +PRAGMA default_null_order='NULLS LAST'; +-- +ok +== +SELECT *, max(Ct) FILTER (WHERE Depth=1) OVER (PARTITION BY Season) as value_depth1 +from issue7353 +order by all; +-- +ok +== +SELECT + i // 10 AS p, + i, + STRING_AGG(i, ',' ORDER BY i DESC) OVER(PARTITION BY p) AS c +FROM range(20) tbl(i) +ORDER BY ALL +-- +ok +== +with table_1 AS ( + SELECT + 'fb30cf47-6f6b-42ef-dec2-3f984479a2aa'::uuid AS id, + unnest(generate_series( + '2024-04-01'::date, + '2025-03-01'::date, + interval '1 month' + )) AS date + UNION ALL BY NAME + SELECT + '7d1cc557-2d45-6900-a1ed-b2c64f5d9200'::uuid AS id, + unnest(generate_series( + '2024-02-01'::date, + '2025-01-01'::date, + interval '1 month' + )) AS date +), table_2 AS ( + SELECT + 'fb30cf47-6f6b-42ef-dec2-3f984479a2aa'::uuid AS id, + unnest(generate_series( + '2024-04-01'::date, + '2025-03-01'::date, + interval '1 month' + )) AS date, + 1 AS value + UNION ALL BY NAME + SELECT + '7d1cc557-2d45-6900-a1ed-b2c64f5d9200'::uuid AS id, + unnest(generate_series( + '2022-12-01'::date, + '2023-12-01'::date, + interval '1 month' + )) AS date, + 1 AS value +), output AS ( + SELECT + table_1.id, + table_1.date, + sum(table_2.value) over ( + PARTITION BY table_1.id + ORDER BY table_1.date ASC + ROWS BETWEEN UNBOUNDED PRECEDING AND UNBOUNDED FOLLOWING + ) AS test_sum, + FROM table_1 + LEFT JOIN table_2 + ON table_1.id = table_2.id + AND table_1.date = table_2.date +) +SELECT * FROM output +ORDER BY id DESC, date DESC; +-- +ok +== +with repro2 AS ( + SELECT range // 59 AS id, random() AS value + FROM range(1475) +), X AS ( + SELECT + list(value) OVER ( + PARTITION BY id + ORDER BY value + ROWS BETWEEN UNBOUNDED PRECEDING AND UNBOUNDED FOLLOWING + ) AS values + FROM repro2 +) +select count(*) +from X +where values[1] != list_aggregate(values, 'min') +-- +ok +== diff --git a/parser/testdata/corpus/sql/window/test_window_constant_allocator.test b/parser/testdata/corpus/sql/window/test_window_constant_allocator.test new file mode 100644 index 0000000..f044b9b --- /dev/null +++ b/parser/testdata/corpus/sql/window/test_window_constant_allocator.test @@ -0,0 +1,26 @@ +# source: test/sql/window/test_window_constant_allocator.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +WITH cte AS ( + SELECT 1 AS ext + UNION ALL + SELECT 2 + UNION ALL + SELECT 3 + UNION ALL + SELECT 4 +) +SELECT + CASE + WHEN ext % 2 = 0 THEN 'even' + ELSE 'odd' + END AS pred, + TRUE AS eof, + CAST(NULL AS BOOLEAN) AS converter, + STRING_AGG(cte.ext, 'abc') OVER () AS str_agg +FROM cte; +-- +ok +== diff --git a/parser/testdata/corpus/sql/window/test_window_cse.test b/parser/testdata/corpus/sql/window/test_window_cse.test new file mode 100644 index 0000000..1f7944c --- /dev/null +++ b/parser/testdata/corpus/sql/window/test_window_cse.test @@ -0,0 +1,53 @@ +# source: test/sql/window/test_window_cse.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +CREATE TABLE eventlog AS + SELECT ts, + CHR((RANDOM() * 3 + 65)::INTEGER) AS activity_name, + (RANDOM() * 100)::INTEGER AS case_id + FROM generate_series('2023-01-01'::TIMESTAMP, '2023-02-01'::TIMESTAMP, INTERVAL 1 HOUR) tbl(ts); +-- +ok +== +CREATE VIEW cse AS +WITH t AS (SELECT + string_agg(activity_name, ',' order by ts asc, activity_name) as trace, + 1 as cnt +from + eventlog +group by case_id +) +SELECT + trace, + sum(cnt) as cnt_trace, + sum(cnt_trace) over () as cnt_total, + sum(cnt) / sum(cnt_trace) over () as rel, + sum(cnt_trace) over ( + order by cnt_trace desc + ROWS between UNBOUNDED PRECEDING and CURRENT ROW) + / sum(cnt_trace) over () + as rel +from t +group by trace +order by cnt_trace desc +-- +ok +== +EXPLAIN FROM cse; +-- +ok +== +CREATE VIEW noncse AS +SELECT + quantile(x, 0.3) over() as q3, + quantile(x, 0.7) over() as q7 +FROM generate_series(1, 10) as tbl(x); +-- +ok +== +EXPLAIN FROM noncse; +-- +ok +== diff --git a/parser/testdata/corpus/sql/window/test_window_dbplyr.test b/parser/testdata/corpus/sql/window/test_window_dbplyr.test new file mode 100644 index 0000000..2e5da3e --- /dev/null +++ b/parser/testdata/corpus/sql/window/test_window_dbplyr.test @@ -0,0 +1,25 @@ +# source: test/sql/window/test_window_dbplyr.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +CREATE TABLE dbplyr_052 (x INTEGER, g DOUBLE, w int) +-- +ok +== +INSERT INTO dbplyr_052 VALUES (1,1, 42),(2,1, 42),(3,1, 42),(2,2, 42),(3,2, 42),(4,2, 42) +-- +ok +== +SELECT x, g FROM (SELECT x, g, SUM(x) OVER (PARTITION BY g ORDER BY x ROWS UNBOUNDED PRECEDING) AS zzz67 FROM (SELECT x, g FROM dbplyr_052 ORDER BY x) dbplyr_053) dbplyr_054 WHERE (zzz67 > 3.0) +-- +ok +== +SELECT x, g FROM (SELECT x, g, SUM(x) OVER (PARTITION BY g ORDER BY x ROWS UNBOUNDED PRECEDING) AS zzz67 FROM (SELECT x, g FROM dbplyr_052 ORDER BY w) dbplyr_053) dbplyr_054 WHERE (zzz67 > 3.0) +-- +ok +== +SELECT x, g FROM (SELECT x, g, SUM(x) OVER (PARTITION BY g ORDER BY x ROWS UNBOUNDED PRECEDING) AS zzz67 FROM (SELECT * FROM dbplyr_052 ORDER BY x) dbplyr_053) dbplyr_054 WHERE (zzz67 > 3.0) +-- +ok +== diff --git a/parser/testdata/corpus/sql/window/test_window_distinct.test b/parser/testdata/corpus/sql/window/test_window_distinct.test new file mode 100644 index 0000000..f6900ad --- /dev/null +++ b/parser/testdata/corpus/sql/window/test_window_distinct.test @@ -0,0 +1,171 @@ +# source: test/sql/window/test_window_distinct.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +SELECT COUNT(DISTINCT 42) OVER () +-- +ok +== +WITH src(c) AS ( + SELECT range % 2 + FROM range(33) +) +SELECT LIST(DISTINCT c ORDER BY c) OVER ( + ORDER BY c + ROWS BETWEEN UNBOUNDED PRECEDING AND UNBOUNDED FOLLOWING +) AS window_list +FROM src +LIMIT 1 +-- +ok +== +WITH t AS ( + SELECT col0 AS a, col1 AS b + FROM (VALUES + (1,2), + (1,1), + (1,2), + (2,1), + (2,1), + (2,2), + (2,3), + (2,4) + ) v) +SELECT *, COUNT(b) OVER(PARTITION BY a), COUNT(DISTINCT b) OVER(PARTITION BY a) +FROM t +ORDER BY 1, 2 +-- +ok +== +WITH uncascaded AS ( + SELECT i, i % 29 AS v + FROM range(1000) tbl(i) +) +SELECT i + , v + , COUNT(DISTINCT v) OVER (ORDER BY i ROWS BETWEEN 25 PRECEDING AND 25 FOLLOWING) AS w +FROM uncascaded +ORDER BY i +-- +ok +== +WITH cascaded AS ( + SELECT i, i % 29 AS v + FROM range(10000) tbl(i) +) +SELECT i + , v + , COUNT(DISTINCT v) OVER (ORDER BY i ROWS BETWEEN 25 PRECEDING AND 25 FOLLOWING) AS w +FROM cascaded +ORDER BY i +-- +ok +== +SELECT i + , s + , i // 2 AS o + , COUNT(DISTINCT s) OVER( + ORDER BY i // 2 + ROWS BETWEEN 2 PRECEDING AND 2 FOLLOWING + EXCLUDE TIES + ) AS c +FROM figure1 +ORDER BY i +-- +ok +== +INSERT INTO figure1 VALUES + (9, NULL), + (NULL, 'b'), + (NULL, NULL), +; +-- +ok +== +SELECT i + , s + , COUNT(DISTINCT s) OVER( ORDER BY i, s NULLS LAST ROWS BETWEEN 2 PRECEDING AND 2 FOLLOWING) AS c +FROM figure1 +ORDER BY i, s NULLS LAST +-- +ok +== +CREATE TABLE nested AS + SELECT + i, + s, + {"m": i % 2, "s": s} AS n, + [(i % 2)::VARCHAR, s] AS l, + i * i AS r + FROM figure1 +-- +ok +== +SELECT i + , n + , COUNT(DISTINCT n) OVER( ORDER BY i, s NULLS LAST ROWS BETWEEN 2 PRECEDING AND 2 FOLLOWING) AS c +FROM nested +ORDER BY i, s NULLS LAST +-- +ok +== +SELECT i + , l + , COUNT(DISTINCT l) OVER( ORDER BY i, s NULLS LAST ROWS BETWEEN 2 PRECEDING AND 2 FOLLOWING) AS c +FROM nested +ORDER BY i, s NULLS LAST +-- +ok +== +SELECT r + , s + , COUNT(DISTINCT s) OVER( ORDER BY r RANGE BETWEEN 10 PRECEDING AND 10 FOLLOWING) AS c +FROM nested +ORDER BY i, s NULLS LAST +-- +ok +== +SELECT i + , s + , STRING_AGG(DISTINCT s, ', ') OVER( ORDER BY i, s NULLS LAST ROWS BETWEEN 2 PRECEDING AND 2 FOLLOWING) AS c +FROM nested +ORDER BY i, s NULLS LAST +-- +ok +== +SELECT i + , s + , MEDIAN(DISTINCT s) OVER( ORDER BY i, s NULLS LAST ROWS BETWEEN 2 PRECEDING AND 2 FOLLOWING) AS c +FROM nested +ORDER BY i, s NULLS LAST +-- +ok +== +SELECT i + , s + , COUNT(DISTINCT s) + FILTER (WHERE i % 3 = 0) + OVER( ORDER BY i, s NULLS LAST ROWS BETWEEN 2 PRECEDING AND 2 FOLLOWING) + AS c +FROM nested +ORDER BY i, s NULLS LAST +-- +ok +== +SELECT i + , s + , COUNT(DISTINCT s) FILTER (WHERE i % 3 = 1) OVER( ORDER BY i ROWS BETWEEN 2 PRECEDING AND 2 FOLLOWING) AS c +FROM nested +ORDER BY i +-- +ok +== +SELECT i + , s + , COUNT(DISTINCT s) FILTER (WHERE i % 3 = 2) OVER( ORDER BY i ROWS BETWEEN 2 PRECEDING AND 2 FOLLOWING) AS c +FROM nested +ORDER BY i +-- +ok +== diff --git a/parser/testdata/corpus/sql/window/test_window_filter.test b/parser/testdata/corpus/sql/window/test_window_filter.test new file mode 100644 index 0000000..3d06da7 --- /dev/null +++ b/parser/testdata/corpus/sql/window/test_window_filter.test @@ -0,0 +1,86 @@ +# source: test/sql/window/test_window_filter.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +CREATE TABLE testing AS + SELECT + x + ,round(x * 0.333,0) % 3 AS y + ,round(x * 0.333,0) % 3 AS z + FROM generate_series(0,10) tbl(x); +-- +ok +== +SELECT + x + ,y + ,z + ,avg(x) OVER (PARTITION BY y) AS plain_window + ,avg(x) FILTER (WHERE x = 1) OVER (PARTITION BY y) AS x_filtered_window + ,avg(x) FILTER (WHERE z = 0) OVER (PARTITION BY y) AS z_filtered_window +FROM testing +ORDER BY y, x; +-- +ok +== +SELECT + x + ,y + ,z + ,count(*) OVER (PARTITION BY y) AS plain_window + ,count(*) FILTER (WHERE x = 1) OVER (PARTITION BY y) AS x_filtered_window + ,count(*) FILTER (WHERE z = 0) OVER (PARTITION BY y) AS z_filtered_window +FROM testing +ORDER BY y, x; +-- +ok +== +SELECT + x + ,y + ,z + ,median(x) OVER (PARTITION BY y) AS plain_window + ,median(x) FILTER (WHERE x = 1) OVER (PARTITION BY y) AS x_filtered_window + ,median(x) FILTER (WHERE z = 0) OVER (PARTITION BY y) AS z_filtered_window +FROM testing +ORDER BY y, x; +-- +ok +== +SELECT + x + ,y + ,z + , {nullary}() OVER (PARTITION BY y) AS plain_window + , {nullary}() FILTER (WHERE x = 1) OVER (PARTITION BY y) AS x_filtered_window + , {nullary}() FILTER (WHERE z = 0) OVER (PARTITION BY y) AS z_filtered_window +FROM testing +ORDER BY y, x; +-- +error: Parser Error: syntax error at or near "}" +== +SELECT + x + ,y + ,z + , {unary}(x) OVER (PARTITION BY y) AS plain_window + , {unary}(x) FILTER (WHERE x = 1) OVER (PARTITION BY y) AS x_filtered_window + , {unary}(x) FILTER (WHERE z = 0) OVER (PARTITION BY y) AS z_filtered_window +FROM testing +ORDER BY y, x; +-- +error: Parser Error: syntax error at or near "}" +== +SELECT + x + ,y + ,z + , {binary}(x, 1) OVER (PARTITION BY y) AS plain_window + , {binary}(x, 1) FILTER (WHERE x = 1) OVER (PARTITION BY y) AS x_filtered_window + , {binary}(x, 1) FILTER (WHERE z = 0) OVER (PARTITION BY y) AS z_filtered_window +FROM testing +ORDER BY y, x; +-- +error: Parser Error: syntax error at or near "binary" +== diff --git a/parser/testdata/corpus/sql/window/test_window_finalize_race.test b/parser/testdata/corpus/sql/window/test_window_finalize_race.test new file mode 100644 index 0000000..20346f2 --- /dev/null +++ b/parser/testdata/corpus/sql/window/test_window_finalize_race.test @@ -0,0 +1,43 @@ +# source: test/sql/window/test_window_finalize_race.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +PRAGMA threads=2 +-- +ok +== +WITH t AS (SELECT 0 AS x), +u AS ( + SELECT * FROM t WHERE x >= 5000 + UNION ALL + SELECT * FROM t +) +SELECT x, count() OVER () FROM u ORDER BY x DESC; +-- +ok +== +WITH final_cols AS ( + SELECT i AS x + FROM range(1) t(i) +), +final_people AS ( + SELECT * + FROM final_cols + WHERE x >= 5000 + UNION ALL + SELECT * + FROM final_cols + WHERE NOT EXISTS ( + SELECT 1 + FROM final_cols + WHERE x >= 5000 + ) +) +SELECT x, count() OVER () AS full_count +FROM final_people +ORDER BY x DESC +LIMIT 5; +-- +ok +== diff --git a/parser/testdata/corpus/sql/window/test_window_fusion.test b/parser/testdata/corpus/sql/window/test_window_fusion.test new file mode 100644 index 0000000..2db9693 --- /dev/null +++ b/parser/testdata/corpus/sql/window/test_window_fusion.test @@ -0,0 +1,179 @@ +# source: test/sql/window/test_window_fusion.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +create table lineitem ( + l_extendedprice decimal(15,2), + l_partkey integer, + l_orderkey integer +); +-- +ok +== +insert into lineitem (values + (29733.00, 1, 2883), + (1802.00, 1, 5121), + (4505.00, 1, 6179), + (29733.00, 1, 6273), + (30634.00, 1, 8645), + (41446.00, 1, 12005), + (36040.00, 1, 16135), + (29733.00, 1, 16198), + (26129.00, 1, 20199), + (24327.00, 1, 22117), + (19822.00, 1, 24866), + (24327.00, 1, 26756), + (9010.00, 1, 27558), + (45050.00, 1, 29859), + (2703.00, 1, 34692), + (11713.00, 1, 36611), + (18020.00, 1, 38051), + (21624.00, 1, 42465), + (36040.00, 1, 42758), + (39644.00, 1, 47620), + (28832.00, 1, 50498), + (12614.00, 1, 51970), + (2703.00, 1, 53189), + (22525.00, 1, 53825), + (21624.00, 1, 54592), + (36941.00, 1, 59202), + (18942.00, 2, 548), + (17138.00, 2, 807), + (24354.00, 2, 2117), + (9020.00, 2, 2528), + (28864.00, 2, 4102), + (42394.00, 2, 4452), + (11726.00, 2, 7458), + (39688.00, 2, 27969), + (37884.00, 2, 28900), + (9922.00, 2, 30278), + (12628.00, 2, 30597), + (7216.00, 2, 33058), + (41492.00, 2, 37026), + (40590.00, 2, 37123), + (36982.00, 2, 39809), + (36080.00, 2, 41415), + (18942.00, 2, 42147), + (24354.00, 2, 42533), + (41492.00, 2, 43650), + (45100.00, 2, 44103), + (17138.00, 2, 46913), + (31570.00, 2, 50499), + (37884.00, 2, 54086), + (26158.00, 2, 54436), + (4510.00, 2, 54436), + (3608.00, 2, 54630), + (41492.00, 2, 55136), +); +-- +ok +== +select + l_extendedprice, + l_partkey, + l_orderkey, + sum(l_extendedprice) over(), +from lineitem +order by l_partkey, l_orderkey, l_extendedprice +-- +ok +== +select + l_extendedprice, + l_partkey, + l_orderkey, + sum(l_extendedprice) over(order by l_partkey), +from lineitem +order by l_partkey, l_orderkey, l_extendedprice +-- +ok +== +select + l_extendedprice, + l_partkey, + l_orderkey, + sum(l_extendedprice) over(order by l_partkey, l_orderkey), +from lineitem +order by l_partkey, l_orderkey, l_extendedprice desc +-- +ok +== +select + l_extendedprice, + l_partkey, + l_orderkey, + sum(l_extendedprice) over(order by l_partkey, l_orderkey desc), +from lineitem +order by l_partkey, l_orderkey, l_extendedprice desc +-- +ok +== +select + l_extendedprice, + l_partkey, + l_orderkey, + sum(l_extendedprice) over(), + sum(l_extendedprice) over(order by l_partkey), + sum(l_extendedprice) over(order by l_partkey, l_orderkey), + sum(l_extendedprice) over(order by l_partkey, l_orderkey desc), +from lineitem +order by l_partkey, l_orderkey, l_extendedprice desc +-- +ok +== +select + l_extendedprice, + l_partkey, + l_orderkey, + sum(l_extendedprice) over(partition by l_partkey), +from lineitem +order by l_partkey, l_orderkey, l_extendedprice desc +-- +ok +== +select + l_extendedprice, + l_partkey, + l_orderkey, + sum(l_extendedprice) over(partition by l_partkey order by l_orderkey), +from lineitem +order by l_partkey, l_orderkey, l_extendedprice desc +-- +ok +== +select + l_extendedprice, + l_partkey, + l_orderkey, + sum(l_extendedprice) over(partition by l_partkey order by l_orderkey desc), +from lineitem +order by l_partkey, l_orderkey, l_extendedprice desc +-- +ok +== +select + l_extendedprice, + l_partkey, + l_orderkey, + sum(l_extendedprice) over(partition by l_partkey), + sum(l_extendedprice) over(partition by l_partkey order by l_orderkey), + sum(l_extendedprice) over(partition by l_partkey order by l_orderkey desc), +from lineitem +order by l_partkey, l_orderkey, l_extendedprice desc +-- +ok +== +select + l_extendedprice, + l_partkey, + l_orderkey, + sum(l_extendedprice) over(), + sum(l_extendedprice) over(order by l_partkey), + sum(l_extendedprice) over(order by l_partkey, l_orderkey), + sum(l_extendedprice) over(partition by l_partkey order by l_orderkey desc), +from lineitem +order by l_partkey, l_orderkey, l_extendedprice desc +-- +ok +== diff --git a/parser/testdata/corpus/sql/window/test_window_interval.test b/parser/testdata/corpus/sql/window/test_window_interval.test new file mode 100644 index 0000000..5aa944a --- /dev/null +++ b/parser/testdata/corpus/sql/window/test_window_interval.test @@ -0,0 +1,15 @@ +# source: test/sql/window/test_window_interval.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +create table a as select case when range%2==0 then interval '1 year' else interval '2 years' end j, range::integer AS i from range(1, 5, 1) +-- +ok +== +with src(id, k, x) as (values (1, interval '26' day, 10), (2, interval '30' day, 1)) +select id, k, sum(x) over (order by k range between interval '4' day preceding and current row) +from src order by id +-- +ok +== diff --git a/parser/testdata/corpus/sql/window/test_window_order_collate.test b/parser/testdata/corpus/sql/window/test_window_order_collate.test new file mode 100644 index 0000000..6953d01 --- /dev/null +++ b/parser/testdata/corpus/sql/window/test_window_order_collate.test @@ -0,0 +1,67 @@ +# source: test/sql/window/test_window_order_collate.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +select + *, + array_agg(col) over(partition by id order by col collate nocase) as lead_col_nocase +from ( + select + unnest(array[1, 1, 1, 1]) as id, + unnest(array['A', 'a', 'b', 'B']) as col +) +-- +ok +== +CREATE TABLE db_city (name VARCHAR, city VARCHAR COLLATE NOCASE); +-- +ok +== +INSERT INTO db_city VALUES + ('DuckDB', 'Amsterdam'), + ('MonetDB','amsterdam'), + ('VectorWise', 'Amstërdam'); + +-- +ok +== +SELECT name, city, row_number() OVER (PARTITION BY city) AS row_id +FROM db_city; +-- +ok +== +SELECT name, city, row_number() OVER (PARTITION BY city COLLATE NOCASE) AS row_id +FROM db_city; +-- +ok +== +CREATE TABLE t86 +( + c0 VARCHAR COLLATE NOCASE NOT NULL +); +-- +ok +== +CREATE TABLE t0 +( + c0 BOOLEAN UNIQUE NOT NULL, + PRIMARY KEY (c0) +); +-- +ok +== +INSERT INTO t0(c0) VALUES (true); +-- +ok +== +INSERT INTO t86(c0) VALUES (''), ('cOB4'); +-- +ok +== +(SELECT t86.c0, t0.c0 FROM t0, t86) EXCEPT ALL ( + SELECT i,i FROM range(0, 4) r(i) +); +-- +ok +== diff --git a/parser/testdata/corpus/sql/window/test_window_rows.test b/parser/testdata/corpus/sql/window/test_window_rows.test new file mode 100644 index 0000000..022f266 --- /dev/null +++ b/parser/testdata/corpus/sql/window/test_window_rows.test @@ -0,0 +1,344 @@ +# source: test/sql/window/test_window_rows.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +CREATE TABLE t3(a TEXT, b TEXT, c INTEGER); +-- +ok +== +INSERT INTO t3 VALUES + ('HH', 'bb', 355), ('CC', 'aa', 158), ('BB', 'aa', 399), + ('FF', 'bb', 938), ('HH', 'aa', 480), ('FF', 'bb', 870), + ('JJ', 'aa', 768), ('JJ', 'aa', 899), ('GG', 'bb', 929), + ('II', 'bb', 421), ('GG', 'bb', 844), ('FF', 'bb', 574), + ('CC', 'bb', 822), ('GG', 'bb', 938), ('BB', 'aa', 660), + ('HH', 'aa', 979), ('BB', 'bb', 792), ('DD', 'aa', 845), + ('JJ', 'bb', 354), ('FF', 'bb', 295), ('JJ', 'aa', 234), + ('BB', 'bb', 840), ('AA', 'aa', 934), ('EE', 'aa', 113), + ('AA', 'bb', 309), ('BB', 'aa', 412), ('AA', 'aa', 911), + ('AA', 'bb', 572), ('II', 'aa', 398), ('II', 'bb', 250), + ('II', 'aa', 652), ('BB', 'bb', 633), ('AA', 'aa', 239), + ('FF', 'aa', 670), ('BB', 'bb', 705), ('HH', 'bb', 963), + ('CC', 'bb', 346), ('II', 'bb', 671), ('BB', 'aa', 247), + ('AA', 'aa', 223), ('GG', 'aa', 480), ('HH', 'aa', 790), + ('FF', 'aa', 208), ('BB', 'bb', 711), ('EE', 'aa', 777), + ('DD', 'bb', 716), ('CC', 'aa', 759), ('CC', 'aa', 430), + ('CC', 'aa', 607), ('DD', 'bb', 794), ('GG', 'aa', 148), + ('GG', 'aa', 634), ('JJ', 'bb', 257), ('DD', 'bb', 959), + ('FF', 'bb', 726), ('BB', 'aa', 762), ('JJ', 'bb', 336), + ('GG', 'aa', 335), ('HH', 'bb', 330), ('GG', 'bb', 160), + ('JJ', 'bb', 839), ('FF', 'aa', 618), ('BB', 'aa', 393), + ('EE', 'bb', 629), ('FF', 'aa', 667), ('AA', 'bb', 870), + ('FF', 'bb', 102), ('JJ', 'aa', 113), ('DD', 'aa', 224), + ('AA', 'bb', 627), ('HH', 'bb', 730), ('II', 'bb', 443), + ('HH', 'bb', 133), ('EE', 'bb', 252), ('II', 'bb', 805), + ('BB', 'bb', 786), ('EE', 'bb', 768), ('HH', 'bb', 683), + ('DD', 'bb', 238), ('DD', 'aa', 256); +-- +ok +== +SELECT row_number() OVER win +FROM t3 + WINDOW win AS ( + ORDER BY c, b, a + ROWS BETWEEN UNBOUNDED PRECEDING AND UNBOUNDED FOLLOWING EXCLUDE NO OTHERS + ) +-- +ok +== +SELECT nth_value(c, 14) OVER win +FROM t3 + WINDOW win AS ( + ORDER BY c, b, a + ROWS BETWEEN UNBOUNDED PRECEDING AND UNBOUNDED FOLLOWING EXCLUDE NO OTHERS + ) +-- +ok +== +SELECT min(c) OVER win, max(c) OVER win, sum(c) OVER win FROM t3 + WINDOW win AS ( + ORDER BY c, b, a + ROWS BETWEEN UNBOUNDED PRECEDING AND CURRENT ROW EXCLUDE NO OTHERS + ) ORDER BY a, b, c; +-- +ok +== +SELECT row_number() OVER win +FROM t3 + WINDOW win AS ( + ORDER BY c, b, a + ROWS BETWEEN UNBOUNDED PRECEDING AND UNBOUNDED FOLLOWING EXCLUDE CURRENT ROW + ) +-- +ok +== +SELECT nth_value(c, 14) OVER win +FROM t3 + WINDOW win AS ( + ORDER BY c, b, a + ROWS BETWEEN UNBOUNDED PRECEDING AND UNBOUNDED FOLLOWING EXCLUDE CURRENT ROW + ) +-- +ok +== +SELECT min(c) OVER win, max(c) OVER win, sum(c) OVER win FROM t3 + WINDOW win AS ( + ORDER BY c, b, a + ROWS BETWEEN UNBOUNDED PRECEDING AND CURRENT ROW EXCLUDE CURRENT ROW + ) ORDER BY a, b, c; +-- +ok +== +SELECT row_number() OVER win +FROM t3 + WINDOW win AS ( + ORDER BY c, b, a + ROWS BETWEEN UNBOUNDED PRECEDING AND UNBOUNDED FOLLOWING EXCLUDE GROUP + ) +-- +ok +== +SELECT nth_value(c, 14) OVER win +FROM t3 + WINDOW win AS ( + ORDER BY c, b, a + ROWS BETWEEN UNBOUNDED PRECEDING AND UNBOUNDED FOLLOWING EXCLUDE GROUP + ) +-- +ok +== +SELECT min(c) OVER win, max(c) OVER win, sum(c) OVER win FROM t3 + WINDOW win AS ( + ORDER BY c, b, a + ROWS BETWEEN UNBOUNDED PRECEDING AND CURRENT ROW EXCLUDE GROUP + ) ORDER BY a, b, c; +-- +ok +== +SELECT row_number() OVER win +FROM t3 + WINDOW win AS ( + ORDER BY c, b, a + ROWS BETWEEN UNBOUNDED PRECEDING AND UNBOUNDED FOLLOWING EXCLUDE TIES + ) +-- +ok +== +SELECT nth_value(c, 14) OVER win +FROM t3 + WINDOW win AS ( + ORDER BY c, b, a + ROWS BETWEEN UNBOUNDED PRECEDING AND UNBOUNDED FOLLOWING EXCLUDE TIES + ) +-- +ok +== +SELECT min(c) OVER win, max(c) OVER win, sum(c) OVER win FROM t3 + WINDOW win AS ( + ORDER BY c, b, a + ROWS BETWEEN UNBOUNDED PRECEDING AND CURRENT ROW EXCLUDE TIES + ) ORDER BY a, b, c; +-- +ok +== +CREATE TABLE t1(a INTEGER, b INTEGER); +-- +ok +== +INSERT INTO t1 VALUES + (NULL, 1), (NULL, 2), (NULL, 3), (10, 4), (10, 5); +-- +ok +== +SELECT sum(b) OVER ( + ORDER BY a NULLS FIRST ROWS BETWEEN 1 PRECEDING AND 1 FOLLOWING + ) FROM t1 ORDER BY 1 NULLS FIRST; +-- +ok +== +SELECT sum(b) OVER ( + ORDER BY a NULLS LAST ROWS BETWEEN 1 PRECEDING AND 1 FOLLOWING + ) FROM t1 ORDER BY 1 NULLS LAST; +-- +ok +== +SELECT sum(b) OVER ( + ORDER BY a DESC NULLS LAST ROWS BETWEEN 1 PRECEDING AND 1 FOLLOWING + ) FROM t1 ORDER BY 1 NULLS FIRST; +-- +ok +== +SELECT sum(b) OVER ( + ORDER BY a DESC NULLS LAST ROWS BETWEEN 1 PRECEDING AND 1 FOLLOWING + ) FROM t1 ORDER BY 1 NULLS LAST; +-- +ok +== +INSERT INTO t3 VALUES + (NULL, 'bb', 355), (NULL, 'cc', 158), (NULL, 'aa', 399), + ('JJ', NULL, 839), ('FF', NULL, 618), ('BB', NULL, 393), + (NULL, 'bb', 629), (NULL, NULL, 667), (NULL, NULL, 870); +-- +ok +== +SELECT max(c) OVER win, + min(c) OVER win, + count(a) OVER win +FROM t3 + WINDOW win AS ( ORDER BY c NULLS FIRST, b NULLS FIRST, a NULLS FIRST + ROWS BETWEEN 6 PRECEDING AND UNBOUNDED FOLLOWING EXCLUDE NO OTHERS ) + ORDER BY 1 NULLS FIRST, 2 NULLS FIRST, 3 NULLS FIRST +-- +ok +== +SELECT sum(c) FILTER (WHERE (c%2)!=0) OVER win, + rank() OVER win, + dense_rank() OVER win +FROM t3 + WINDOW win AS ( ORDER BY c NULLS FIRST, b NULLS FIRST, a NULLS FIRST + ROWS BETWEEN 6 PRECEDING AND UNBOUNDED FOLLOWING EXCLUDE NO OTHERS ) + ORDER BY 1 NULLS FIRST, 2 NULLS FIRST, 3 NULLS FIRST +-- +ok +== +SELECT max(c) OVER win, + min(c) OVER win, + count(a) OVER win +FROM t3 + WINDOW win AS ( ORDER BY c NULLS LAST, b NULLS LAST, a NULLS LAST + ROWS BETWEEN 6 PRECEDING AND UNBOUNDED FOLLOWING EXCLUDE NO OTHERS ) + ORDER BY 1 NULLS FIRST, 2 NULLS FIRST, 3 NULLS FIRST +-- +ok +== +SELECT sum(c) FILTER (WHERE (c%2)!=0) OVER win, + rank() OVER win, + dense_rank() OVER win +FROM t3 + WINDOW win AS ( ORDER BY c NULLS LAST, b NULLS LAST, a NULLS LAST + ROWS BETWEEN 6 PRECEDING AND UNBOUNDED FOLLOWING EXCLUDE NO OTHERS ) + ORDER BY 1 NULLS FIRST, 2 NULLS FIRST, 3 NULLS FIRST +-- +ok +== +SELECT max(c) OVER win, + min(c) OVER win, + count(a) OVER win +FROM t3 + WINDOW win AS ( ORDER BY c NULLS FIRST, b NULLS FIRST, a NULLS FIRST + ROWS BETWEEN 6 PRECEDING AND UNBOUNDED FOLLOWING EXCLUDE CURRENT ROW ) + ORDER BY 1 NULLS FIRST, 2 NULLS FIRST, 3 NULLS FIRST +-- +ok +== +SELECT sum(c) FILTER (WHERE (c%2)!=0) OVER win, + rank() OVER win, + dense_rank() OVER win +FROM t3 + WINDOW win AS ( ORDER BY c NULLS FIRST, b NULLS FIRST, a NULLS FIRST + ROWS BETWEEN 6 PRECEDING AND UNBOUNDED FOLLOWING EXCLUDE CURRENT ROW ) + ORDER BY 1 NULLS FIRST, 2 NULLS FIRST, 3 NULLS FIRST +-- +ok +== +SELECT max(c) OVER win, + min(c) OVER win, + count(a) OVER win +FROM t3 + WINDOW win AS ( ORDER BY c NULLS LAST, b NULLS LAST, a NULLS LAST + ROWS BETWEEN 6 PRECEDING AND UNBOUNDED FOLLOWING EXCLUDE CURRENT ROW ) + ORDER BY 1 NULLS FIRST, 2 NULLS FIRST, 3 NULLS FIRST +-- +ok +== +SELECT sum(c) FILTER (WHERE (c%2)!=0) OVER win, + rank() OVER win, + dense_rank() OVER win +FROM t3 + WINDOW win AS ( ORDER BY c NULLS LAST, b NULLS LAST, a NULLS LAST + ROWS BETWEEN 6 PRECEDING AND UNBOUNDED FOLLOWING EXCLUDE CURRENT ROW ) + ORDER BY 1 NULLS FIRST, 2 NULLS FIRST, 3 NULLS FIRST +-- +ok +== +SELECT max(c) OVER win, + min(c) OVER win, + count(a) OVER win +FROM t3 + WINDOW win AS ( ORDER BY c NULLS FIRST, b NULLS FIRST, a NULLS FIRST + ROWS BETWEEN 6 PRECEDING AND UNBOUNDED FOLLOWING EXCLUDE GROUP ) + ORDER BY 1 NULLS FIRST, 2 NULLS FIRST, 3 NULLS FIRST +-- +ok +== +SELECT sum(c) FILTER (WHERE (c%2)!=0) OVER win, + rank() OVER win, + dense_rank() OVER win +FROM t3 + WINDOW win AS ( ORDER BY c NULLS FIRST, b NULLS FIRST, a NULLS FIRST + ROWS BETWEEN 6 PRECEDING AND UNBOUNDED FOLLOWING EXCLUDE GROUP ) + ORDER BY 1 NULLS FIRST, 2 NULLS FIRST, 3 NULLS FIRST +-- +ok +== +SELECT max(c) OVER win, + min(c) OVER win, + count(a) OVER win +FROM t3 + WINDOW win AS ( ORDER BY c NULLS LAST, b NULLS LAST, a NULLS LAST + ROWS BETWEEN 6 PRECEDING AND UNBOUNDED FOLLOWING EXCLUDE GROUP ) + ORDER BY 1 NULLS FIRST, 2 NULLS FIRST, 3 NULLS FIRST +-- +ok +== +SELECT sum(c) FILTER (WHERE (c%2)!=0) OVER win, + rank() OVER win, + dense_rank() OVER win +FROM t3 + WINDOW win AS ( ORDER BY c NULLS LAST, b NULLS LAST, a NULLS LAST + ROWS BETWEEN 6 PRECEDING AND UNBOUNDED FOLLOWING EXCLUDE GROUP ) + ORDER BY 1 NULLS FIRST, 2 NULLS FIRST, 3 NULLS FIRST +-- +ok +== +SELECT max(c) OVER win, + min(c) OVER win, + count(a) OVER win +FROM t3 + WINDOW win AS ( ORDER BY c NULLS FIRST, b NULLS FIRST, a NULLS FIRST + ROWS BETWEEN 6 PRECEDING AND UNBOUNDED FOLLOWING EXCLUDE TIES ) + ORDER BY 1 NULLS FIRST, 2 NULLS FIRST, 3 NULLS FIRST +-- +ok +== +SELECT sum(c) FILTER (WHERE (c%2)!=0) OVER win, + rank() OVER win, + dense_rank() OVER win +FROM t3 + WINDOW win AS ( ORDER BY c NULLS FIRST, b NULLS FIRST, a NULLS FIRST + ROWS BETWEEN 6 PRECEDING AND UNBOUNDED FOLLOWING EXCLUDE TIES ) + ORDER BY 1 NULLS FIRST, 2 NULLS FIRST, 3 NULLS FIRST +-- +ok +== +SELECT max(c) OVER win, + min(c) OVER win, + count(a) OVER win +FROM t3 + WINDOW win AS ( ORDER BY c NULLS LAST, b NULLS LAST, a NULLS LAST + ROWS BETWEEN 6 PRECEDING AND UNBOUNDED FOLLOWING EXCLUDE TIES ) + ORDER BY 1 NULLS FIRST, 2 NULLS FIRST, 3 NULLS FIRST +-- +ok +== +SELECT sum(c) FILTER (WHERE (c%2)!=0) OVER win, + rank() OVER win, + dense_rank() OVER win +FROM t3 + WINDOW win AS ( ORDER BY c NULLS LAST, b NULLS LAST, a NULLS LAST + ROWS BETWEEN 6 PRECEDING AND UNBOUNDED FOLLOWING EXCLUDE TIES ) + ORDER BY 1 NULLS FIRST, 2 NULLS FIRST, 3 NULLS FIRST +-- +ok +== diff --git a/parser/testdata/corpus/sql/window/test_window_string_agg.test b/parser/testdata/corpus/sql/window/test_window_string_agg.test new file mode 100644 index 0000000..508c40b --- /dev/null +++ b/parser/testdata/corpus/sql/window/test_window_string_agg.test @@ -0,0 +1,21 @@ +# source: test/sql/window/test_window_string_agg.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +create table a as select range%3 j, range::varchar AS s, case when range%3=0 then '-' else '|' end sep from range(1, 7, 1) +-- +ok +== +select j, s, string_agg(s) over (partition by j order by s) from a order by j, s; +-- +ok +== +select j, s, string_agg(s, '|') over (partition by j order by s) from a order by j, s; +-- +ok +== +select j, s, string_agg(s, sep) over (partition by j order by s) from a order by j, s; +-- +ok +== diff --git a/parser/testdata/corpus/sql/window/test_window_tpcds.test b/parser/testdata/corpus/sql/window/test_window_tpcds.test new file mode 100644 index 0000000..4cf8cc3 --- /dev/null +++ b/parser/testdata/corpus/sql/window/test_window_tpcds.test @@ -0,0 +1,53 @@ +# source: test/sql/window/test_window_tpcds.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +CREATE TABLE item(i_category VARCHAR, i_brand VARCHAR, i_price INTEGER) +-- +ok +== +INSERT INTO item VALUES ('toys', 'fisher-price', 100) +-- +ok +== +SELECT i_category, i_brand, avg(sum(i_price)) OVER (PARTITION BY i_category), rank() OVER (PARTITION BY i_category ORDER BY i_category, i_brand) rn FROM item GROUP BY i_category, i_brand; +-- +ok +== +CREATE TABLE item(i_category VARCHAR, i_brand VARCHAR, i_item_sk INTEGER); +-- +ok +== +CREATE TABLE store(s_store_name VARCHAR, s_company_name VARCHAR, s_store_sk INTEGER); +-- +ok +== +CREATE TABLE date_dim(d_year INTEGER, d_moy INTEGER, d_date_sk INTEGER); +-- +ok +== +CREATE TABLE store_sales(ss_sales_price DECIMAL, ss_item_sk INTEGER, ss_sold_date_sk INTEGER, ss_store_sk INTEGER); +-- +ok +== +INSERT INTO item VALUES ('Music', 'exportischolar', 1); +-- +ok +== +INSERT INTO store VALUES ('ought', 'Unknown', 1); +-- +ok +== +INSERT INTO date_dim VALUES (1999, 1, 1); +-- +ok +== +INSERT INTO store_sales VALUES (2.8, 1, 1, 1); +-- +ok +== +SELECT i_category, i_brand, s_store_name, s_company_name, d_year, d_moy, sum(ss_sales_price) sum_sales, avg(sum(ss_sales_price)) OVER (PARTITION BY i_category, i_brand, s_store_name, s_company_name, d_year) avg_monthly_sales, rank() OVER (PARTITION BY i_category, i_brand, s_store_name, s_company_name ORDER BY d_year, d_moy) rn FROM item, store_sales, date_dim, store WHERE ss_item_sk = i_item_sk AND ss_sold_date_sk = d_date_sk AND ss_store_sk = s_store_sk AND (d_year = 1999 OR (d_year = 1999-1 AND d_moy =12) OR (d_year = 1999+1 AND d_moy =1)) GROUP BY i_category, i_brand, s_store_name, s_company_name, d_year, d_moy; +-- +ok +== diff --git a/parser/testdata/corpus/sql/window/test_window_types.test b/parser/testdata/corpus/sql/window/test_window_types.test new file mode 100644 index 0000000..cc41f85 --- /dev/null +++ b/parser/testdata/corpus/sql/window/test_window_types.test @@ -0,0 +1,9 @@ +# source: test/sql/window/test_window_types.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +create table a as select range%3::{type} j, range::{type} AS i from range(1, 7, 1) +-- +error: Parser Error: syntax error at or near "{" +== diff --git a/parser/testdata/corpus/sql/window/test_window_unnest_error.test b/parser/testdata/corpus/sql/window/test_window_unnest_error.test new file mode 100644 index 0000000..e0b29f9 --- /dev/null +++ b/parser/testdata/corpus/sql/window/test_window_unnest_error.test @@ -0,0 +1,41 @@ +# source: test/sql/window/test_window_unnest_error.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +CREATE TABLE tbl AS SELECT 42 AS i; +-- +ok +== +SELECT SUM(i) OVER (ROWS BETWEEN UNNEST([1]) PRECEDING AND 1 FOLLOWING) FROM tbl; +-- +ok +== +SELECT SUM(i) OVER (ROWS BETWEEN 1 PRECEDING AND UNNEST([1]) FOLLOWING) FROM tbl; +-- +ok +== +SELECT lead(c0, UNNEST([1])) OVER (ROWS BETWEEN 2 PRECEDING AND 4 PRECEDING) +FROM (VALUES (1, 2)) a(c0); +-- +ok +== +SELECT x, count(x) FILTER (WHERE x % 2 = UNNEST([2])) OVER (ORDER BY x ROWS BETWEEN 2 PRECEDING AND 2 FOLLOWING) +FROM generate_series(0, 10) tbl(x); +-- +ok +== +SELECT lead(c0, 0, UNNEST([1])) OVER (ROWS BETWEEN 2 PRECEDING AND 4 PRECEDING) +FROM (VALUES (1, 2)) a(c0); +-- +ok +== +SELECT SUM(i) OVER (ROWS BETWEEN (SELECT UNNEST([1])) PRECEDING AND 1 FOLLOWING) FROM tbl; +-- +ok +== +SELECT lead(c0, (SELECT UNNEST([0])), (SELECT UNNEST([1]))) OVER (ROWS BETWEEN 2 PRECEDING AND 4 PRECEDING) +FROM (VALUES (1, 2)) a(c0); +-- +ok +== diff --git a/parser/testdata/corpus/sql/window/test_window_wisconsin.test b/parser/testdata/corpus/sql/window/test_window_wisconsin.test new file mode 100644 index 0000000..498e852 --- /dev/null +++ b/parser/testdata/corpus/sql/window/test_window_wisconsin.test @@ -0,0 +1,89 @@ +# source: test/sql/window/test_window_wisconsin.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +SELECT COUNT(*) OVER () FROM tenk1 +-- +ok +== +SELECT sum(four) OVER (PARTITION BY ten ORDER BY unique2) AS sum_1, ten, four FROM tenk1 WHERE unique2 < 10 order by ten, unique2 +-- +ok +== +SELECT row_number() OVER (ORDER BY unique2) rn FROM tenk1 WHERE unique2 < 10 ORDER BY rn +-- +ok +== +SELECT rank() OVER (PARTITION BY four ORDER BY ten) AS rank_1, ten, four FROM tenk1 WHERE unique2 < 10 ORDER BY four, ten +-- +ok +== +SELECT dense_rank() OVER (PARTITION BY four ORDER BY ten) FROM tenk1 WHERE unique2 < 10 ORDER BY four, ten +-- +ok +== +SELECT first_value(ten) OVER (PARTITION BY four ORDER BY ten) FROM tenk1 WHERE unique2 < 10 order by four, ten +-- +ok +== +SELECT cast(percent_rank() OVER (PARTITION BY four ORDER BY ten)*10 as INTEGER) FROM tenk1 ORDER BY four, ten +-- +ok +== +SELECT cast(cume_dist() OVER (PARTITION BY four ORDER BY ten)*10 as integer) FROM tenk1 WHERE unique2 < 10 order by four, ten +-- +ok +== +SELECT ntile(2) OVER (ORDER BY ten, four) nn FROM tenk1 ORDER BY ten, four, nn +-- +ok +== +SELECT ntile(3) OVER (ORDER BY ten, four) nn FROM tenk1 ORDER BY ten, four, nn +-- +ok +== +SELECT ntile(4) OVER (ORDER BY ten, four) nn FROM tenk1 ORDER BY ten, four, nn +-- +ok +== +SELECT ntile(5) OVER (ORDER BY ten, four) nn FROM tenk1 ORDER BY ten, four, nn +-- +ok +== +SELECT lag(ten) OVER (PARTITION BY four ORDER BY ten) lt FROM tenk1 order by four, ten, lt +-- +ok +== +SELECT lead(ten) OVER (PARTITION BY four ORDER BY ten) lt FROM tenk1 order by four, ten, lt +-- +ok +== +SELECT lag(ten, four) OVER (PARTITION BY four ORDER BY ten) lt FROM tenk1 order by four, ten, lt +-- +ok +== +SELECT lag(ten, four, 0) OVER (PARTITION BY four ORDER BY ten) lt FROM tenk1 order by four, ten, lt +-- +ok +== +SELECT lag(ten, four, 0, 0) OVER (PARTITION BY four ORDER BY ten) lt FROM tenk1 order by four, ten, lt +-- +ok +== +SELECT lead(ten * 2, 1) OVER (PARTITION BY four ORDER BY ten) lt FROM tenk1 order by four, ten, lt +-- +ok +== +SELECT lead(ten * 2, 1, -1) OVER (PARTITION BY four ORDER BY ten) lt FROM tenk1 order by four, ten, lt +-- +ok +== +SELECT COUNT(*) OVER w c, SUM(four) OVER w s, cast(AVG(ten) OVER w * 10 as integer) a, RANK() over w r, DENSE_RANK() over w dr, ROW_NUMBER() OVER w rn FROM tenk1 WINDOW w AS () ORDER BY rn +-- +ok +== +SELECT COUNT(*) OVER w c, SUM(four) OVER w s, cast(AVG(ten) OVER w * 10 as integer) a, RANK() over w r, DENSE_RANK() over w dr, ROW_NUMBER() OVER w rn FROM tenk1 WINDOW w AS (rows between 1 preceding and 1 following) ORDER BY rn +-- +ok +== diff --git a/parser/testdata/corpus/sql/window/window_mtcars.test b/parser/testdata/corpus/sql/window/window_mtcars.test new file mode 100644 index 0000000..e0872d7 --- /dev/null +++ b/parser/testdata/corpus/sql/window/window_mtcars.test @@ -0,0 +1,145 @@ +# source: test/sql/window/window_mtcars.test +# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 +# oracle: v2.0.0-alpha38195 +# generated by cmd/regenerate - do not edit + +CREATE TABLE mtcars (mpg DECIMAL, cyl INTEGER, disp DECIMAL, hp INTEGER, drat DECIMAL, wt DECIMAL, qsec DECIMAL, vs INTEGER, am INTEGER, gear INTEGER, carb INTEGER); +-- +ok +== +INSERT INTO mtcars VALUES ('21.0', '6', '160.0', '110', '3.90', '2.620', '16.46', '0', '1', '4', '4'); +-- +ok +== +INSERT INTO mtcars VALUES ('21.0', '6', '160.0', '110', '3.90', '2.875', '17.02', '0', '1', '4', '4'); +-- +ok +== +INSERT INTO mtcars VALUES ('22.8', '4', '108.0', '93', '3.85', '2.320', '18.61', '1', '1', '4', '1'); +-- +ok +== +INSERT INTO mtcars VALUES ('21.4', '6', '258.0', '110', '3.08', '3.215', '19.44', '1', '0', '3', '1'); +-- +ok +== +INSERT INTO mtcars VALUES ('18.7', '8', '360.0', '175', '3.15', '3.440', '17.02', '0', '0', '3', '2'); +-- +ok +== +INSERT INTO mtcars VALUES ('18.1', '6', '225.0', '105', '2.76', '3.460', '20.22', '1', '0', '3', '1'); +-- +ok +== +INSERT INTO mtcars VALUES ('14.3', '8', '360.0', '245', '3.21', '3.570', '15.84', '0', '0', '3', '4'); +-- +ok +== +INSERT INTO mtcars VALUES ('24.4', '4', '146.7', '62', '3.69', '3.190', '20.00', '1', '0', '4', '2'); +-- +ok +== +INSERT INTO mtcars VALUES ('22.8', '4', '140.8', '95', '3.92', '3.150', '22.90', '1', '0', '4', '2'); +-- +ok +== +INSERT INTO mtcars VALUES ('19.2', '6', '167.6', '123', '3.92', '3.440', '18.30', '1', '0', '4', '4'); +-- +ok +== +INSERT INTO mtcars VALUES ('17.8', '6', '167.6', '123', '3.92', '3.440', '18.90', '1', '0', '4', '4'); +-- +ok +== +INSERT INTO mtcars VALUES ('16.4', '8', '275.8', '180', '3.07', '4.070', '17.40', '0', '0', '3', '3'); +-- +ok +== +INSERT INTO mtcars VALUES ('17.3', '8', '275.8', '180', '3.07', '3.730', '17.60', '0', '0', '3', '3'); +-- +ok +== +INSERT INTO mtcars VALUES ('15.2', '8', '275.8', '180', '3.07', '3.780', '18.00', '0', '0', '3', '3'); +-- +ok +== +INSERT INTO mtcars VALUES ('10.4', '8', '472.0', '205', '2.93', '5.250', '17.98', '0', '0', '3', '4'); +-- +ok +== +INSERT INTO mtcars VALUES ('10.4', '8', '460.0', '215', '3.00', '5.424', '17.82', '0', '0', '3', '4'); +-- +ok +== +INSERT INTO mtcars VALUES ('14.7', '8', '440.0', '230', '3.23', '5.345', '17.42', '0', '0', '3', '4'); +-- +ok +== +INSERT INTO mtcars VALUES ('32.4', '4', '78.7', '66', '4.08', '2.200', '19.47', '1', '1', '4', '1'); +-- +ok +== +INSERT INTO mtcars VALUES ('30.4', '4', '75.7', '52', '4.93', '1.615', '18.52', '1', '1', '4', '2'); +-- +ok +== +INSERT INTO mtcars VALUES ('33.9', '4', '71.1', '65', '4.22', '1.835', '19.90', '1', '1', '4', '1'); +-- +ok +== +INSERT INTO mtcars VALUES ('21.5', '4', '120.1', '97', '3.70', '2.465', '20.01', '1', '0', '3', '1'); +-- +ok +== +INSERT INTO mtcars VALUES ('15.5', '8', '318.0', '150', '2.76', '3.520', '16.87', '0', '0', '3', '2'); +-- +ok +== +INSERT INTO mtcars VALUES ('15.2', '8', '304.0', '150', '3.15', '3.435', '17.30', '0', '0', '3', '2'); +-- +ok +== +INSERT INTO mtcars VALUES ('13.3', '8', '350.0', '245', '3.73', '3.840', '15.41', '0', '0', '3', '4'); +-- +ok +== +INSERT INTO mtcars VALUES ('19.2', '8', '400.0', '175', '3.08', '3.845', '17.05', '0', '0', '3', '2'); +-- +ok +== +INSERT INTO mtcars VALUES ('27.3', '4', '79.0', '66', '4.08', '1.935', '18.90', '1', '1', '4', '1'); +-- +ok +== +INSERT INTO mtcars VALUES ('26.0', '4', '120.3', '91', '4.43', '2.140', '16.70', '0', '1', '5', '2'); +-- +ok +== +INSERT INTO mtcars VALUES ('30.4', '4', '95.1', '113', '3.77', '1.513', '16.90', '1', '1', '5', '2'); +-- +ok +== +INSERT INTO mtcars VALUES ('15.8', '8', '351.0', '264', '4.22', '3.170', '14.50', '0', '1', '5', '4'); +-- +ok +== +INSERT INTO mtcars VALUES ('19.7', '6', '145.0', '175', '3.62', '2.770', '15.50', '0', '1', '5', '6'); +-- +ok +== +INSERT INTO mtcars VALUES ('15.0', '8', '301.0', '335', '3.54', '3.570', '14.60', '0', '1', '5', '8'); +-- +ok +== +INSERT INTO mtcars VALUES ('21.4', '4', '121.0', '109', '4.11', '2.780', '18.60', '1', '1', '4', '2'); +-- +ok +== +SELECT + mpg, + SUM(mpg) OVER (ROWS BETWEEN 1 PRECEDING AND CURRENT ROW) AS mpg_roll +FROM + mtcars +-- +ok +== diff --git a/token/keywords_test.go b/token/keywords_test.go index 0fe3f59..7a18c69 100644 --- a/token/keywords_test.go +++ b/token/keywords_test.go @@ -12,7 +12,7 @@ import ( func TestKeywordListCounts(t *testing.T) { counts := map[string]int{ "reserved_keyword.list": 75, - "unreserved_keyword.list": 339, + "unreserved_keyword.list": 338, "column_name_keyword.list": 55, "func_name_keyword.list": 30, "type_name_keyword.list": 32, @@ -28,8 +28,8 @@ func TestKeywordListCounts(t *testing.T) { } total += len(words) } - if total != 531 { - t.Errorf("total keyword entries = %d, want 531", total) + if total != 530 { + t.Errorf("total keyword entries = %d, want 530", total) } } @@ -39,7 +39,7 @@ func TestCategoryCounts(t *testing.T) { want int }{ {KeywordReserved, 75}, - {KeywordUnreserved, 339}, + {KeywordUnreserved, 338}, {KeywordColumnName, 55}, {KeywordFuncName, 30}, {KeywordTypeName, 32}, From c04229e5ccbb76729c2b08afd5d591f26201a8c7 Mon Sep 17 00:00:00 2001 From: Claude Date: Fri, 21 Aug 2026 14:24:47 +0000 Subject: [PATCH 3/3] Address adversarial review findings Regeneration pipeline correctness: - cmd/regenerate now removes corpus files (and their sidecars) that a full run did not produce, so tests deleted or renamed upstream stop gating darkwing against an older pin's verdicts; orphaned sidecars are cleaned up the same way. Partial runs (-only/-limit) skip both the cleanup and the corpus-wide README rewrite instead of clobbering state for files they did not regenerate. - Oracle timeouts and crashes are no longer recorded as must-accept: the CLI produced no verdict (it may have died inside its own parser), so those statements are dropped as unverified and counted in the README. The 12 timeout statements are gone from the corpus; one file whose only case was unverified is deleted by the new stale cleanup. - The bind-time nested-parse imprecision (query('...') raising Parser Error for its inner string) is now documented on duckdbsrc.classify and in the corpus README: triage stays manual because such a disagreement is indistinguishable from a genuine engine bug. Format and code hygiene: - testfile.CanStore also rejects empty statements, statements whose first line is empty (Read drops blank lines between cases), and statements whose first line starts with '#' (header absorption), with tests - future corpus sources hit the skippedUnstorable path instead of silent round-trip corruption. - The TopLevelStatement peel loop now lives in one place, matcher.Engine.MatchAll (returning partial results alongside errors); the harness classify/dumpCase, cmd/debug-parse, and the matcher tests all use it. - duckdbsrc uses errors.As instead of the hand-rolled isExit helper; the dead token import and its keep-alive are gone from parser_test. The gate stays green over the regenerated corpus (43,807 must-accept, 1,407 must-reject); go test -race ./... is clean. Co-Authored-By: Claude Claude-Session: https://claude.ai/code/session_01CTQBC9AzfdFPFsZtwn1mHY --- cmd/debug-parse/main.go | 19 ++-- cmd/regenerate/main.go | 90 ++++++++++++++++++- internal/duckdbsrc/duckdbsrc.go | 36 ++++---- internal/matcher/engine.go | 23 +++++ internal/matcher/matcher_test.go | 16 +--- internal/testfile/testfile.go | 19 +++- internal/testfile/testfile_test.go | 13 +++ parser/parser_test.go | 30 ++----- parser/testdata/README.md | 10 ++- .../catalog/table/create_table_as_abort.test | 13 --- .../sql/settings/max_execution_time.test | 43 --------- .../sql/settings/operator_memory_limit.test | 12 --- 12 files changed, 179 insertions(+), 145 deletions(-) delete mode 100644 parser/testdata/corpus/sql/catalog/table/create_table_as_abort.test diff --git a/cmd/debug-parse/main.go b/cmd/debug-parse/main.go index a4fa4ec..8388d61 100644 --- a/cmd/debug-parse/main.go +++ b/cmd/debug-parse/main.go @@ -47,21 +47,12 @@ func run(sql string, tokensOnly bool) error { if err != nil { return err } - // peel one TopLevelStatement at a time, exactly like upstream's - // Parser::ParseQuery loop - pos := 0 + results, err := engine.MatchAll(tokens) + if err != nil { + return err + } statement := 0 - for pos < len(tokens) { - result, newPos, err := engine.MatchTopLevel(tokens, pos) - if err != nil { - return err - } - if newPos == pos { - // no progress; should be unreachable with a well-formed - // TopLevelStatement rule - return fmt.Errorf("matcher made no progress at token %d", pos) - } - pos = newPos + for _, result := range results { // TopLevelStatement <- Statement? (';'+ / EndOfInput): a // separator-only match yields no statement, as upstream's // TransformTopLevelStatement returns nullptr for it diff --git a/cmd/regenerate/main.go b/cmd/regenerate/main.go index 868fd2a..d7f7dd8 100644 --- a/cmd/regenerate/main.go +++ b/cmd/regenerate/main.go @@ -126,7 +126,9 @@ func run(srcDir, binary, outDir string, workers int, timeout time.Duration, only } corpusDir := filepath.Join(outDir, "corpus") - accepted, rejected := 0, 0 + accepted, rejected, unverified := 0, 0, 0 + written := make(map[string]bool) + filesWritten := 0 for _, pf := range perFile { out := testfile.File{ Header: []string{ @@ -138,6 +140,13 @@ func run(srcDir, binary, outDir string, workers int, timeout time.Duration, only } for _, sql := range pf.stmts { v := verdicts[sql] + if v.TimedOut || v.Crashed { + // no verdict was actually observed: the CLI died or was + // cut off, possibly inside its own parser, so recording + // either accept or reject would be a guess + unverified++ + continue + } c := testfile.Case{SQL: sql, Reject: v.Reject, Error: v.Error} if v.Reject { rejected++ @@ -146,6 +155,9 @@ func run(srcDir, binary, outDir string, workers int, timeout time.Duration, only } out.Cases = append(out.Cases, c) } + if len(out.Cases) == 0 { + continue + } dest := filepath.Join(corpusDir, filepath.FromSlash(pf.rel)) if err := os.MkdirAll(filepath.Dir(dest), 0o755); err != nil { return err @@ -153,8 +165,23 @@ func run(srcDir, binary, outDir string, workers int, timeout time.Duration, only if err := testfile.Write(dest, &out); err != nil { return err } + written[dest] = true + filesWritten++ + } + log.Printf("corpus written: %d files, %d must-accept, %d must-reject, %d unverified dropped", + filesWritten, accepted, rejected, unverified) + + if only != "" || limit > 0 { + // a partial run regenerates a subset: removing "stale" files or + // rewriting the corpus-wide README would clobber state belonging + // to the files that were not regenerated + log.Printf("partial run (-only/-limit): skipping stale-file cleanup and README update") + return nil + } + + if err := removeStale(corpusDir, written); err != nil { + return err } - log.Printf("corpus written: %d files, %d must-accept, %d must-reject", len(perFile), accepted, rejected) readme := fmt.Sprintf(`# darkwing conformance corpus @@ -165,21 +192,76 @@ hand; rerun the tool instead (see PLAN.md, § Conformance oracle and corpus). - Pinned commit: %s - Oracle: DuckDB CLI %s (nightly build of the pinned commit) - Files: %d, cases: %d (%d must-accept, %d must-reject) +- Statements without an observed verdict (oracle timeout/crash): %d, dropped Classification: the oracle runs each statement against :memory: with extension autoloading disabled. An error starting with "Parser Error" means must-reject (first error line recorded); success or any post-parse -error (Binder, Catalog, ...) means must-accept. +error (Binder, Catalog, ...) means must-accept. Statements for which the +CLI produced no verdict (timeout or crash - possibly inside its own +parser) are excluded rather than guessed. Bind-time nested parses (e.g. +query('...') parsing its string argument) still surface as Parser Errors +and are recorded must-reject; the grammar never sees the inner SQL, so +those cases carry skip entries in the sidecars. Sidecar files (*.metadata.json) carry todo/skip lists keyed by case content hash; they are maintained by hand and survive regeneration. -`, duckdbsrc.PinnedCommit, duckdbsrc.PinnedVersion, len(perFile), accepted+rejected, accepted, rejected) +`, duckdbsrc.PinnedCommit, duckdbsrc.PinnedVersion, filesWritten, accepted+rejected, accepted, rejected, unverified) if err := os.MkdirAll(outDir, 0o755); err != nil { return err } return os.WriteFile(filepath.Join(outDir, "README.md"), []byte(readme), 0o644) } +// removeStale deletes corpus files that this (full) run did not produce - +// leftovers from tests deleted or renamed upstream, whose expectations +// would otherwise keep gating darkwing against an older pin - along with +// their sidecars, and any sidecar orphaned by a vanished corpus file. +func removeStale(corpusDir string, written map[string]bool) error { + var stale, orphans []string + err := filepath.WalkDir(corpusDir, func(path string, d fs.DirEntry, err error) error { + if err != nil || d.IsDir() { + return err + } + switch { + case strings.HasSuffix(path, ".test"): + if !written[path] { + stale = append(stale, path) + } + case strings.HasSuffix(path, ".metadata.json"): + corpus := strings.TrimSuffix(path, ".metadata.json") + if !written[corpus] { + orphans = append(orphans, path) + } + } + return nil + }) + if os.IsNotExist(err) { + return nil + } + if err != nil { + return err + } + for _, path := range stale { + if err := os.Remove(path); err != nil { + return err + } + meta := testfile.MetadataPath(path) + if err := os.Remove(meta); err != nil && !os.IsNotExist(err) { + return err + } + } + for _, path := range orphans { + if err := os.Remove(path); err != nil && !os.IsNotExist(err) { + return err + } + } + if len(stale) > 0 || len(orphans) > 0 { + log.Printf("removed %d stale corpus files and %d orphaned sidecars", len(stale), len(orphans)) + } + return nil +} + func collectFiles(srcDir, only string) ([]string, error) { var files []string for _, root := range []string{ diff --git a/internal/duckdbsrc/duckdbsrc.go b/internal/duckdbsrc/duckdbsrc.go index bd6c1e1..fd7daad 100644 --- a/internal/duckdbsrc/duckdbsrc.go +++ b/internal/duckdbsrc/duckdbsrc.go @@ -7,6 +7,7 @@ package duckdbsrc import ( "bytes" "context" + "errors" "fmt" "os" "os/exec" @@ -66,14 +67,17 @@ func Verify(path string) error { // Verdict is the oracle's classification of one statement. type Verdict struct { // Reject is true when the CLI raised a Parser Error. Success and any - // post-parse error (Binder, Catalog, ...) are must-accept, as are - // timeouts and crashes (execution ran, so parsing succeeded). + // post-parse error (Binder, Catalog, ...) are must-accept. Reject bool // Error is the first "Parser Error" line for rejected statements. Error string - // TimedOut records that execution was cut short (still must-accept). + // TimedOut records that the CLI was cut off before printing a + // verdict. No verdict was observed - the hang could even be inside + // the CLI's parser - so callers must treat the statement as + // unverified, not as must-accept. TimedOut bool - // Crashed records a CLI crash after parsing (still must-accept). + // Crashed records that the CLI died before printing a verdict; like + // TimedOut, the statement is unverified. Crashed bool } @@ -124,10 +128,11 @@ func (o *Oracle) Run(sql string) (Verdict, error) { } if err != nil { var exitErr *exec.ExitError - if isExit(err, &exitErr) { + if errors.As(err, &exitErr) { if exitErr.ExitCode() == -1 || exitErr.ExitCode() > 1 { - // killed by a signal or an abnormal exit: the CLI got past - // parsing and died executing (fuzzer statements do this) + // killed by a signal or an abnormal exit with no verdict + // printed; possibly inside the CLI's own parser, so the + // caller must not guess accept or reject from this return Verdict{Crashed: true}, nil } // plain error exit with a non-parser error on stderr: @@ -139,16 +144,17 @@ func (o *Oracle) Run(sql string) (Verdict, error) { return Verdict{}, nil } -func isExit(err error, target **exec.ExitError) bool { - if e, ok := err.(*exec.ExitError); ok { - *target = e - return true - } - return false -} - // classify scans CLI stderr for the first error line. Only "Parser Error" // means reject; everything else is post-parse. +// +// One known imprecision is inherent to this interface: a bind-time nested +// parse (query('...'), query_table, json_serialize_sql parsing its string +// argument) also raises "Parser Error" even though the outer statement +// parsed fine, so such statements are recorded must-reject. The grammar +// never sees the inner SQL, so those corpus cases are excluded via skip +// entries in the metadata sidecars - triage stays manual because a +// syntax-error-shaped disagreement is otherwise indistinguishable from a +// genuine engine bug. func classify(stderr string) (Verdict, bool) { for _, line := range strings.Split(stderr, "\n") { line = strings.TrimSpace(line) diff --git a/internal/matcher/engine.go b/internal/matcher/engine.go index 0116709..58e7d4b 100644 --- a/internal/matcher/engine.go +++ b/internal/matcher/engine.go @@ -109,6 +109,29 @@ func (e *Engine) MatchTopLevel(tokens []token.Token, pos int) (ParseResult, int, return runMatch(e.topLevel, tokens, pos) } +// MatchAll peels TopLevelStatement matches until the token stream is +// consumed - upstream's Parser::ParseQuery loop. On error it returns the +// results matched so far alongside the error, so callers can report +// partial progress. +func (e *Engine) MatchAll(tokens []token.Token) ([]ParseResult, error) { + var results []ParseResult + pos := 0 + for pos < len(tokens) { + r, newPos, err := e.MatchTopLevel(tokens, pos) + if err != nil { + return results, err + } + if newPos == pos { + // unreachable with a well-formed TopLevelStatement rule, which + // always consumes at least a terminator or the EOI sentinel + return results, &MatchError{Msg: fmt.Sprintf("matcher made no progress at token %d", pos)} + } + results = append(results, r) + pos = newPos + } + return results, nil +} + func runMatch(root matcher, tokens []token.Token, pos int) (result ParseResult, newPos int, err error) { s := &state{ tokens: tokens, diff --git a/internal/matcher/matcher_test.go b/internal/matcher/matcher_test.go index 1261d83..5bb74ec 100644 --- a/internal/matcher/matcher_test.go +++ b/internal/matcher/matcher_test.go @@ -94,21 +94,7 @@ func mustTokens(t *testing.T, sql string) []token.Token { // matchAll drives the statement-at-a-time loop over the whole input. func matchAll(t *testing.T, engine *Engine, sql string) ([]ParseResult, error) { t.Helper() - tokens := mustTokens(t, sql) - var results []ParseResult - pos := 0 - for pos < len(tokens) { - r, newPos, err := engine.MatchTopLevel(tokens, pos) - if err != nil { - return nil, err - } - if newPos == pos { - t.Fatalf("no progress at token %d of %q", pos, sql) - } - results = append(results, r) - pos = newPos - } - return results, nil + return engine.MatchAll(mustTokens(t, sql)) } func TestAcceptStatements(t *testing.T) { diff --git a/internal/testfile/testfile.go b/internal/testfile/testfile.go index 9c08f0f..f4caf8f 100644 --- a/internal/testfile/testfile.go +++ b/internal/testfile/testfile.go @@ -58,11 +58,22 @@ type File struct { Cases []Case } -// CanStore reports whether a statement can be represented in the corpus -// format: the format delimits with whole lines "==" and "--", so a -// statement containing either as an exact line cannot be stored. +// CanStore reports whether a statement round-trips through the corpus +// format. Unstorable shapes: the format delimits with whole lines "==" and +// "--", so a statement containing either as an exact line cannot be +// stored; a statement whose first line is empty (Read drops blank lines +// between cases) or starts with '#' (a leading first case would be +// absorbed into the file header) cannot be stored either, nor can an +// empty statement. func CanStore(sql string) bool { - for _, line := range strings.Split(sql, "\n") { + if sql == "" { + return false + } + lines := strings.Split(sql, "\n") + if lines[0] == "" || strings.HasPrefix(lines[0], "#") { + return false + } + for _, line := range lines { if line == caseSeparator || line == partSeparator { return false } diff --git a/internal/testfile/testfile_test.go b/internal/testfile/testfile_test.go index 64c2e1f..fc83c78 100644 --- a/internal/testfile/testfile_test.go +++ b/internal/testfile/testfile_test.go @@ -49,6 +49,19 @@ func TestCanStore(t *testing.T) { if !CanStore("SELECT 1 -- comment\nFROM t") { t.Error("-- with trailing text is storable") } + // shapes Read cannot reproduce byte-for-byte + if CanStore("") { + t.Error("an empty statement must not be storable") + } + if CanStore("\nSELECT 1") { + t.Error("a leading empty line must not be storable (Read drops it)") + } + if CanStore("# leading comment\nSELECT 1") { + t.Error("a leading '#' line must not be storable (header absorption)") + } + if !CanStore("SELECT 1\n # indented hash is fine") { + t.Error("'#' beyond the first line/column is storable") + } } func TestMetadataRoundTrip(t *testing.T) { diff --git a/parser/parser_test.go b/parser/parser_test.go index 95f22bf..1973fc7 100644 --- a/parser/parser_test.go +++ b/parser/parser_test.go @@ -19,7 +19,6 @@ import ( "github.com/sqlc-dev/darkwing/internal/matcher" "github.com/sqlc-dev/darkwing/internal/testfile" "github.com/sqlc-dev/darkwing/lexer" - "github.com/sqlc-dev/darkwing/token" ) var ( @@ -40,17 +39,8 @@ func classify(engine *matcher.Engine, sql string) verdict { if err != nil { return verdict{reject: true, detail: err.Error()} } - pos := 0 - for pos < len(tokens) { - result, newPos, err := engine.MatchTopLevel(tokens, pos) - if err != nil { - return verdict{reject: true, detail: err.Error()} - } - if newPos == pos { - return verdict{reject: true, detail: fmt.Sprintf("matcher made no progress at token %d", pos)} - } - _ = result - pos = newPos + if _, err := engine.MatchAll(tokens); err != nil { + return verdict{reject: true, detail: err.Error()} } return verdict{} } @@ -159,15 +149,12 @@ func dumpCase(t *testing.T, engine *matcher.Engine, c *testfile.Case, got verdic for _, tk := range tokens { fmt.Fprintf(&sb, " %-16s %4d..%-4d %q\n", tk.Kind, tk.Span.Start, tk.Span.End, tk.Text) } - pos := 0 - for pos < len(tokens) { - result, newPos, err := engine.MatchTopLevel(tokens, pos) - if err != nil || newPos == pos { - fmt.Fprintf(&sb, "match error at token %d: %v\n", pos, err) - break - } + results, err := engine.MatchAll(tokens) + for _, result := range results { sb.WriteString(matcher.Dump(result)) - pos = newPos + } + if err != nil { + fmt.Fprintf(&sb, "match error: %v\n", err) } } t.Log(sb.String()) @@ -233,6 +220,3 @@ func TestCorpusRoundTrip(t *testing.T) { } } } - -// keep the token package linked in for -check-parse dumps -var _ = token.EndOfInput diff --git a/parser/testdata/README.md b/parser/testdata/README.md index ff0c960..a7613c0 100644 --- a/parser/testdata/README.md +++ b/parser/testdata/README.md @@ -6,12 +6,18 @@ hand; rerun the tool instead (see PLAN.md, § Conformance oracle and corpus). - Source: DuckDB test/sql/**/*.test and test/fuzzer/**/*.test - Pinned commit: 8cbdaba6acb50db7780d22a65dd131584d472262 - Oracle: DuckDB CLI v2.0.0-alpha38195 (nightly build of the pinned commit) -- Files: 4071, cases: 45226 (43819 must-accept, 1407 must-reject) +- Files: 4070, cases: 45214 (43807 must-accept, 1407 must-reject) +- Statements without an observed verdict (oracle timeout/crash): 12, dropped Classification: the oracle runs each statement against :memory: with extension autoloading disabled. An error starting with "Parser Error" means must-reject (first error line recorded); success or any post-parse -error (Binder, Catalog, ...) means must-accept. +error (Binder, Catalog, ...) means must-accept. Statements for which the +CLI produced no verdict (timeout or crash - possibly inside its own +parser) are excluded rather than guessed. Bind-time nested parses (e.g. +query('...') parsing its string argument) still surface as Parser Errors +and are recorded must-reject; the grammar never sees the inner SQL, so +those cases carry skip entries in the sidecars. Sidecar files (*.metadata.json) carry todo/skip lists keyed by case content hash; they are maintained by hand and survive regeneration. diff --git a/parser/testdata/corpus/sql/catalog/table/create_table_as_abort.test b/parser/testdata/corpus/sql/catalog/table/create_table_as_abort.test deleted file mode 100644 index 482a1e7..0000000 --- a/parser/testdata/corpus/sql/catalog/table/create_table_as_abort.test +++ /dev/null @@ -1,13 +0,0 @@ -# source: test/sql/catalog/table/create_table_as_abort.test -# pin: 8cbdaba6acb50db7780d22a65dd131584d472262 -# oracle: v2.0.0-alpha38195 -# generated by cmd/regenerate - do not edit - -CREATE TABLE IF NOT EXISTS integers AS SELECT i1.i FROM range(10000000000000000) i1(i); --- -ok -== -CREATE TABLE integers AS SELECT i1.i FROM range(10000000000000000) i1(i); --- -ok -== diff --git a/parser/testdata/corpus/sql/settings/max_execution_time.test b/parser/testdata/corpus/sql/settings/max_execution_time.test index 166c185..9705149 100644 --- a/parser/testdata/corpus/sql/settings/max_execution_time.test +++ b/parser/testdata/corpus/sql/settings/max_execution_time.test @@ -19,53 +19,10 @@ SET max_execution_time=50 -- ok == -SELECT COUNT(*) FROM range(100000000) t1, range(1000) t2 --- -ok -== SELECT 1 -- ok == -WITH RECURSIVE cte AS ( - SELECT 1 as n - UNION ALL - SELECT n+1 FROM cte WHERE n < 10000000 -) -SELECT COUNT(*) FROM cte --- -ok -== -SELECT i % 10000000 as g, COUNT(*) FROM range(100000000) t(i) GROUP BY 1 --- -ok -== -SELECT * FROM range(50000000) ORDER BY random() --- -ok -== -SELECT i, SUM(i) OVER (PARTITION BY i % 1000000 ORDER BY i) FROM range(10000000) t(i) --- -ok -== -SELECT - CASE WHEN i % 2 = 0 THEN - CASE WHEN i % 3 = 0 THEN - CASE WHEN i % 5 = 0 THEN 'FizzBuzz' - ELSE 'Fizz' END - ELSE CASE WHEN i % 5 = 0 THEN 'Buzz' - ELSE i::VARCHAR END END - ELSE i::VARCHAR END as result, - COUNT(*) -FROM range(100000000) t(i) -GROUP BY 1 --- -ok -== -SELECT DISTINCT i FROM range(50000000) t(i) --- -ok -== SELECT COUNT(*) FROM range(1000) -- ok diff --git a/parser/testdata/corpus/sql/settings/operator_memory_limit.test b/parser/testdata/corpus/sql/settings/operator_memory_limit.test index e0c42aa..dcc6019 100644 --- a/parser/testdata/corpus/sql/settings/operator_memory_limit.test +++ b/parser/testdata/corpus/sql/settings/operator_memory_limit.test @@ -39,22 +39,10 @@ SET operator_memory_limit='1MB' -- ok == -SELECT * FROM range(10000000) ORDER BY random(); --- -ok -== SELECT i % 1000000 as g, COUNT(*) FROM range(10000000) t(i) GROUP BY 1; -- ok == -SELECT DISTINCT i FROM range(10000000) t(i); --- -ok -== -SELECT i, SUM(i) OVER (PARTITION BY i % 100000 ORDER BY i) FROM range(5000000) t(i); --- -ok -== CREATE TABLE t1 AS SELECT * FROM range(1000000) -- ok